尝试在Number的原型中添加迭代器。

Number.prototype[Symbol.iterator] = function *(){
  let i = 0;
  while(i < this) yield i++;
  return;
}

现在数字是可迭代的，只需将一个数字传递给Array.from

Array.from(10);//[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

或者任何其他需要迭代的地方，比如。。。循环。

for(const number of 10) console.log(number);//logs 0 through 9 sequentially

这有点复杂，但也很酷。

您可以使用Es6中的阵列填充和映射；就像一些人在回答这个问题时建议的那样。以下是一些示例：

Example-One: Array(10).fill(0).map((e,i)=>i+1)

Result-One: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

Example-Two: Array(100/10).fill(0).map((e,i)=>(i*10)+10)

Result-Two:[10, 20, 30, 40, 50, 60, 70, 80, 90, 100]

我更喜欢这样，因为我觉得这很简单。

使用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）

为了好玩，我想借鉴伊恩·亨利的答案。

当然，var array=new array（N）；将为您提供大小为N的数组，但键和值将相同。。。。然后，要将数组缩短为M大小，请使用array.length=M…但对于一些添加的功能，请尝试：

function range()
{
    // This function takes optional arguments:
    // start, end, increment
    //    start may be larger or smaller than end
    // Example:  range(null, null, 2);

    var array = []; // Create empty array

      // Get arguments or set default values:
    var start = (arguments[0] ? arguments[0] : 0);
    var end   = (arguments[1] ? arguments[1] : 9);
      // If start == end return array of size 1
    if (start == end) { array.push(start); return array; }
    var inc   = (arguments[2] ? Math.abs(arguments[2]) : 1);

    inc *= (start > end ? -1 : 1); // Figure out which direction to increment.

      // Loop ending condition depends on relative sizes of start and end
    for (var i = start; (start < end ? i <= end : i >= end) ; i += inc)
        array.push(i);

    return array;
}

var foo = range(1, -100, 8.5)

for(var i=0;i<foo.length;i++){
  document.write(foo[i] + ' is item: ' + (i+1) + ' of ' + foo.length + '<br/>'); 
}​

上述输出：

1是第1项，共12项-7.5为第2项，共12项-16是第3项，共12项-24.5为第4项，共12项-33是第5项，共12项-41.5是第6项，共12项-50是第7项，共12项-58.5为第8项，共12项-67是第9项，共12项-75.5为第10项，共12项-84是第11项，共12项-92.5是第12项，共12项

jsFiddle示例

此函数使用自动生成的参数数组。

该函数创建一个数组，该数组中的值以大小增量开始，以大小增量结束，其中

range(start, end, increment);

每个值都有一个默认值，增量的符号无关紧要，因为增量的方向取决于开始和结束的相对大小。

嗯，简单但重要的问题。Functional JS在Array对象下肯定缺少一个通用的展开方法，因为我们可能需要创建一个数字项数组，不仅是简单的[1，2，3，…，111]，而且是一个函数产生的序列，可能是x＝＞x*2而不是x＝＞x

目前，要执行这项工作，我们必须依赖Array.prototype.map（）方法。然而，为了使用Array.prototype.map（），我们需要提前知道数组的大小。还是。。如果我们不知道大小，那么我们可以使用Array.prototype.reduce（），但Array.protocol.reduce）用于缩小（折叠）而不是展开正确。。？

显然，我们需要函数JS中的Array.unfold（）工具。这是我们可以简单地自己实现的；

Array.unfold = function(p,f,t,s){
  var res = [],
   runner = v =>  p(v,res.length-1,res) ? [] : (res.push(f(v)),runner(t(v)), res);
  return runner(s);
};

数组展开（p，f，t，v）采用4个参数。

p这是一个定义停止位置的函数。与许多数组函子一样，p函数接受3个参数。值、索引和当前生成的数组。它应返回布尔值。当它返回true时，递归迭代停止。f这是一个返回下一项函数值的函数。t这是一个函数，用于返回下一个参数，以便在下一个回合中提供给f。s是种子值，用于通过f计算索引0的舒适座椅。

因此，如果我们打算创建一个数组，其中包含一个像1，4，9，16，25…n^2这样的序列，我们可以简单地这样做。

Array.unfold=函数（p，f，t，s）{var res=[]，转轮=v=>p（v，res.length-1，res）？[]：（res.push（f（v）），runner（t（v），res）；回流流道；};var myArr=数组展开（（_，i）=>i>=9，x=>Math.pow（x，2），x=>x+1，1）；console.log（myArr）；

Fast

这个解决方案可能是最快的——它是由lodash_.range函数启发而来的（但我的更简单、更快）

设N=10，i=0，a=阵列（N）；而（i<N）a[i++]=i；控制台日志（a）；

与当前（2020.12.11）相比，基于while/for的现有答案的性能优势

内存在开始时由a=数组（N）分配一次使用了增加索引i++——看起来比减少索引i快30%左右——（可能是因为CPU缓存在正向上更快）

在此答案中，使用了20多种其他解决方案进行了速度测试