范围（开始、结束、步骤）：使用ES6迭代器

你只要求上限和下限。在这里，我们也创建了一个带步骤的。

您可以轻松创建range（）生成器函数，该函数可以用作迭代器。这意味着您不必预先生成整个阵列。

function * range ( start, end, step = 1 ) {
  let state = start;
  while ( state < end ) {
    yield state;
    state += step;
  }
  return;
};

现在，您可能需要创建一个从迭代器预生成数组并返回列表的东西。这对于接受数组的函数很有用。为此，我们可以使用Array.from（）

const generate_array = (start,end,step) =>
  Array.from( range(start,end,step) );

现在您可以轻松生成静态数组，

const array1 = generate_array(1,10,2);
const array1 = generate_array(1,7);

但是，当需要迭代器（或允许您使用迭代器）时，您也可以轻松创建迭代器。

for ( const i of range(1, Number.MAX_SAFE_INTEGER, 7) ) {
  console.log(i)
}

特别注意事项

如果你使用Ramda，他们和Lodash一样有自己的R.range

Array.from(Array((m - n + 1)), (v, i) => n + i); // m > n and both of them are integers.

在边界内生成整数数组的递归解决方案。

function intSequence(start, end, n = start, arr = []) {
  return (n === end) ? arr.concat(n)
    : intSequence(start, end, start < end ? n + 1 : n - 1, arr.concat(n));
}

$> intSequence(1, 1)
<- Array [ 1 ]

$> intSequence(1, 3)
<- Array(3) [ 1, 2, 3 ]

$> intSequence(3, -3)
<- Array(7) [ 3, 2, 1, 0, -1, -2, -3 ]

/**
 * @param {!number|[!number,!number]} sizeOrRange Can be the `size` of the range (1st signature) or a
 *   `[from, to]`-shape array (2nd signature) that represents a pair of the *starting point (inclusive)* and the
 *   *ending point (exclusive)* of the range (*mathematically, a left-closed/right-open interval: `[from, to)`*).
 * @param {!number} [fromOrStep] 1st signature: `[from=0]`. 2nd signature: `[step=1]`
 * @param {!number} [stepOrNothing] 1st signature: `[step=1]`. 2nd signature: NOT-BEING-USED
 * @example
 * range(5) ==> [0, 1, 2, 3, 4] // size: 5
 * range(4, 5)    ==> [5, 6, 7, 8]  // size: 4, starting from: 5
 * range(4, 5, 2) ==> [5, 7, 9, 11] // size: 4, starting from: 5, step: 2
 * range([2, 5]) ==> [2, 3, 4] // [2, 5) // from: 2 (inclusive), to: 5 (exclusive)
 * range([1, 6], 2) ==> [1, 3, 5] // from: 1, to: 6, step: 2
 * range([1, 7], 2) ==> [1, 3, 5] // from: 1, to: 7 (exclusive), step: 2
 * @see {@link https://stackoverflow.com/a/72388871/5318303}
 */
export function range (sizeOrRange, fromOrStep, stepOrNothing) {
  let from, to, step, size
  if (sizeOrRange instanceof Array) { // 2nd signature: `range([from, to], step)`
    [from, to] = sizeOrRange
    step = fromOrStep ?? 1
    size = Math.ceil((to - from) / step)
  } else { // 1st signature: `range(size, from, step)`
    size = sizeOrRange
    from = fromOrStep ?? 0
    step = stepOrNothing ?? 1
  }
  return Array.from({length: size}, (_, i) => from + i * step)
}

示例：

控制台日志(范围（5），//[0，1，2，3，4]//size:5范围（[2，5]），//[2，3，4]//[2、5）//从：2（含）到：5（不含）范围（4，2），//[2，3，4，5]//大小：4，从：2开始范围（[1，6]，2），//[1，3，5]//从：1到：6，步骤：2范围（[1，7]，2），//[1，3，5]//从：1到：7（不含），步骤：2)<脚本>函数范围（sizeOrRange、fromOrStep、stepOrNothing）{让从、到、步长、大小if（sizeOrRange instanceof Array）｛//第二个签名：`range（[from，to]，step）`[from，to]=sizeOrRange步骤=来自或步骤？？1.size=数学ceil（（to-from）/步长）}else｛//第一个签名：`range（大小，从，步）`size=sizeOrRangefrom=来自或步骤？？0step=stepOrNothing？？1.}return Array.from（｛length:size｝，（_，i）=>from+i*step）}</script>

我的代码高尔夫同事想出了这个（ES6），包容的：

(s,f)=>[...Array(f-s+1)].map((e,i)=>i+s)

非包容性：

(s,f)=>[...Array(f-s)].map((e,i)=>i+s)

Javascript提供了一个从给定值创建和填充数组的函数，接收容器数组和映射函数作为参数：

让arr=数组来源（SOURCE_Array，MAP_FUNCTION）；

由于MAP_FUNCTION提供了迭代的值和索引，因此可以创建一个空数组（SOURCE_array）并使用索引填充它，如下所示（supposing 10是您所需的长度）：

let arr=Array.from（数组（10），（n，索引）=>索引）；

输出：[0, 1, 2, 3, 4, 5, 6, 7, 8, 9].