我在寻找一个功能性的解决方案，最终得到了：

function numbers(min, max) {
  return Array(max-min+2).join().split(',').map(function(e, i) { return min+i; });
}

console.log(numbers(1, 9));

注意：join（）.split（'，'）将稀疏数组转换为连续数组。

这个问题有很多复杂的答案，但只有一句简单的话：

[...Array(255).keys()].map(x => x + 1)

此外，虽然上面的内容写起来很短（很整洁），但我认为下面的内容要快一点（最大长度：

127，国际8，

255，Uint8，

32767，国际16，

65535、Uint16、，

2147483647，国际32，

4294967295，Uint32。

（基于最大整数值），这里还有关于类型化数组的更多信息）：

(new Uint8Array(255)).map(($,i) => i + 1);

虽然这个解决方案也不太理想，因为它创建了两个数组，并使用了额外的变量声明“$”（不确定使用这个方法有什么方法可以解决这个问题）。我认为以下解决方案是实现这一目标的最快方法：

for(var i = 0, arr = new Uint8Array(255); i < arr.length; i++) arr[i] = i + 1;

在该语句之后的任何时候，您都可以在当前范围中简单地使用变量“arr”；

如果你想用它做一个简单的函数（带有一些基本的验证）：

功能范围（最小、最大）{min=min&&min.constructor==数字？最小值：0；!（max&&max.constructor==Number&&max>min）&&//布尔语句也可以用于void返回类型，如单行if语句。（（最大值=最小值）&（最小值=0））//如果指定了一个“max”参数，那么首先检查它是否是一个数字，以及它是否大于min：如果是，保持不变；如果没有，那么就把它当作一开始没有“max”，“max”变为“min”（默认情况下，min变为0）对于（var i=0，arr=new(最大值<128？Int8阵列：最大值<256？Uint8阵列：最大值<32768？Int16阵列：最大值<65536？Uint16阵列：最大值<2147483648？Int32阵列：最大值<4294967296？Uint32阵列：大堆)（最大值-最小值）；i<arr.length；i++）arr[i]=i+min；返回arr；}//如果需要，可以使用数组方法轻松循环range（1,11）.forEach（x=>console.log（x））；//或者如果你习惯了蟒蛇。。。在“你可以用”for。。。的“如果您需要单个值：对于（i范围（20202025））console.log（i）；//或者如果你真的想用“for…”。。在“”中，您可以，但随后您只能访问密钥：对于（范围内的k（25,30））console.log（k）；控制台日志(范围（1128）.构造器名称，范围（200）.构造器名称，范围（400900）.结构名称，范围（33333）.结构名称，范围（823100000）.结构名称，range（10,4）//当“min”参数大于“max”时，它只会认为没有“max”，新的max变为“min”，“min”变为0，就好像“max”从未被写入);

因此，通过上述功能，上述超慢的“简单一行”变成了超快，甚至更短：

range(1,14000);

让我们分享我的：p

Math.pow(2, 10).toString(2).split('').slice(1).map((_,j) => ++j)

所有这些都太复杂了。只要做到：

function count(num) {
  var arr = [];
  var i = 0;

  while (num--) {
    arr.push(i++);
  }

  return arr;
}

console.log(count(9))
//=> [ 0, 1, 2, 3, 4, 5, 6, 7, 8 ]

或者从a到b的范围

function range(a, b) {
  var arr = [];

  while (a < b + 1) {
    arr.push(a++);
  }

  return arr;
}

console.log(range(4, 9))
//=> [ 4, 5, 6, 7, 8, 9 ]

使用ES6的多种方式

使用扩展运算符（…）和键方法

[ ...Array(N).keys() ].map( i => i+1);

填充/贴图

Array(N).fill().map((_, i) => i+1);

排列自

Array.from(Array(N), (_, i) => i+1)

Array.from和｛length:N｝hack

Array.from({ length: N }, (_, i) => i+1)

关于广义形式的注记

通过将i+1更改为所需的表达式（例如i*2、-i、1+i*2和i%2等），上述所有形式都可以生成初始化为几乎任何所需值的数组。如果表达式可以用函数f表示，那么第一种形式就变得简单

[ ...Array(N).keys() ].map(f)

示例：

Array.from({length: 5}, (v, k) => k+1); 
// [1,2,3,4,5]

由于数组在每个位置都是用undefined初始化的，因此v的值将是undefineed

展示所有表格的示例

让演示=（N）=>{控制台日志([…数组（N）.keys（）].map（（i）=>i+1），数组（N）.fill（）.map（（_，i）=>i+1），数组.from（数组（N），（_，i）=>i+1），Array.from（{length:N}，（_，i）=>i+1）)}演示（5）

具有自定义初始化函数f的更通用示例，即。

[ ...Array(N).keys() ].map((i) => f(i))

甚至更简单

[ ...Array(N).keys() ].map(f)

让demo=（N，f）=>{控制台日志([…数组（N）.keys（）].map（f），数组（N）.fill（）.map（（_，i）=>f（i）），数组.from（数组（N），（_，i）=>f（i）），数组.从（｛长度：N｝，（_，i）=>f（i））)}演示（5，i=>2*i+1）

如果您使用的是lodash，则可以使用_.范围：

_.range（[开始=0]，结束，[步骤=1]）创建数字数组（积极和/或消极）从开始到结束，但不是包括，结束。如果指定了负启动，则使用步骤-1没有终点或台阶。如果未指定结束，则设置为开始然后将start设置为0。

示例：

_.range(4);
// ➜ [0, 1, 2, 3]

_.range(-4);
// ➜ [0, -1, -2, -3]

_.range(1, 5);
// ➜ [1, 2, 3, 4]

_.range(0, 20, 5);
// ➜ [0, 5, 10, 15]

_.range(0, -4, -1);
// ➜ [0, -1, -2, -3]

_.range(1, 4, 0);
// ➜ [1, 1, 1]

_.range(0);
// ➜ []