在v8中填充数组的最快方法是：

[...Array(5)].map((_,i) => i);

结果将为：[0，1，2，3，4]

在ES6中：

Array.from({length: 1000}, (_, i) => i).slice(1);

或者更好（没有额外的变量_，也没有额外的切片调用）：

Array.from({length:1000}, Number.call, i => i + 1)

或者，如果您的列表少于256个结果，您可以使用Uint8Array来获得稍快的结果（或者，您可以根据列表的长度使用其他Uint列表，例如Uint16的最大值为65535，或Uint32的最大值4294967295等。不过，正式地说，这些类型的数组只是在ES6中添加的）。例如：

Uint8Array.from({length:10}, Number.call, i => i + 1)

ES5:

Array.apply(0, {length: 1000}).map(function(){return arguments[1]+1});

或者，在ES5中，对于map函数（类似于上面ES6中Array.from函数的第二个参数），可以使用Number.call

Array.apply(0,{length:1000}).map(Number.call,Number).slice(1)

或者，如果你在这里也反对.sslice，你可以执行上面的ES5等效操作（来自ES6），比如：

Array.apply(0,{length:1000}).map(Number.call, Function("i","return i+1"))

您可以这样做：

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）中不起作用。

在ES6中，使用Array from（）和key（）方法。

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

使用排列运算符的较短版本。

[...Array(10).keys()]
//=> [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

从1开始，将map函数传递给Array from（），对象具有长度属性：

Array.from({length: 10}, (_, i) => i + 1)
//=> [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

试试这个

[…Array.from（｛length:30｝）.keys（）]

简单量程发生器：

    const min = 2000;
    const max = 2022;
    const range = Array.from({ length: max - min + 1 }, (v, k) => k + min); 
    console.log('range', range);