您可以这样做：

var N = 10; 
Array.apply(null, {length: N}).map(Number.call, Number)

结果：[0，1，2，3，4，5，6，7，8，9]

或具有随机值：

Array.apply(null, {length: N}).map(Function.call, Math.random)

结果：[0.782694901619107，0.9572225909214467，0.8586748542729765，0.8653848143294454, 0.008339877473190427, 0.9911756622605026, 0.8133423360995948, 0.8377588465809822, 0.5577575915958732, 0.16363654541783035]

解释

首先，注意Number.call（undefined，N）等同于Number（N），它只返回N。我们稍后将使用这个事实。

Array.apply（null，[undefined，undefineed，undefinded]）等同于Array（undefine，undefine，undefide），它生成一个三元素数组，并为每个元素分配undefine。

如何将其推广到N个元素？考虑一下Array（）的工作原理，大致如下：

function Array() {
    if ( arguments.length == 1 &&
         'number' === typeof arguments[0] &&
         arguments[0] >= 0 && arguments &&
         arguments[0] < 1 << 32 ) {
        return [ … ];  // array of length arguments[0], generated by native code
    }
    var a = [];
    for (var i = 0; i < arguments.length; i++) {
        a.push(arguments[i]);
    }
    return a;
}

自ECMAScript 5以来，Function.pr原型.apply（thisArg，argsArray）也接受鸭子类型的类似数组的对象作为其第二个参数。如果我们调用Array.apply（null，｛length:N｝），那么它将执行

function Array() {
    var a = [];
    for (var i = 0; i < /* arguments.length = */ N; i++) {
        a.push(/* arguments[i] = */ undefined);
    }
    return a;
}

现在我们有一个N元素数组，每个元素都设置为undefined。当我们对其调用.map（callback，thisArg）时，每个元素都将被设置为callback.call（thisArg，element，index，array）的结果。因此，[未定义，未定义，…，未定义].map（Number.call，Number）会将每个元素映射到（Number.call）.call（Number，undefined，index，array），这与Number.ccall（undefineed，index，array）相同，正如我们之前所观察到的，它的计算结果为index。这就完成了元素与其索引相同的数组。

为什么要解决Array.apply（null，{length:N}）而不是Array（N）的问题？毕竟，这两个表达式都会产生一个未定义元素的N元素数组。不同之处在于，在前一个表达式中，每个元素都被显式设置为undefined，而在后一个表达式，每个元素从未被设置。根据.map（）的文档：

回调仅对已赋值数组的索引调用；对于已删除或从未赋值的索引，不会调用它。

因此，Array（N）不足；数组（N）.map（Number.call，Number）将导致长度为N的未初始化数组。

兼容性

由于该技术依赖于ECMAScript 5中指定的Function.protype.apply（）的行为，因此它在之前的ECMAScript5浏览器（如Chrome 14和Internet Explorer 9）中不起作用。

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

当然，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);

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

感谢@NikoRuotsalainen的回答。我在我的实用程序中写道：

const range = ({from = 0, to, step = 1, length = Math.ceil((to - from) / step)}) => 
  Array.from({length}, (_, i) => from + i * step)

示例：常量范围=（｛from=0，to，step=1，length=Math.ceil（（to-from）/step）｝）=>Array.from（｛length｝，（_，i）=>from+i*step）控制台日志(范围（｛长度：5｝），//[0，1，2，3，4]范围（｛到：5｝），//[0，1，2，3，4]范围（｛从：2，到：5｝），//[2，3，4]（包括“从”，不包括“到”）范围（｛从：2，长度：4｝），//[2，3，4，5]范围（｛从：1到：5，步骤：2｝），//[1，3]范围（｛从：1到：6，步骤：2｝），//[1，3，5])

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

[...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);

ES5版本，效率很低，但可能是最短的一个，它是一个表达式，而不是一个变量填充有例如for循环的语句：

(Array(N)+'').split(',').map(function(d,i){return i})

空数组和数组中只有数字的解决方案

const arrayOne=新数组（10）；console.log（arrayOne）；const arrayTwo=[…数组（10）.keys（）]；console.log（arrayTwo）；var arrayThree=Array.from（Array（10）.keys（））；console.log（arrayThree）；const arrayStartWithOne=Array.from（Array（10）.keys（），item=>item+1）；console.log（arrayStartWithOne）