使用lodash或下划线

_.range(0, length - 1, 0);

或者，如果您已有一个数组，并且需要一个相同长度的数组

array.map(_.constant(0));

我知道我在某个地方有这个原型：）

Array.prototype.init = function(x,n)
{
    if(typeof(n)=='undefined') { n = this.length; }
    while (n--) { this[n] = x; }
    return this;
}

var a = (new Array(5)).init(0);

var b = [].init(0,4);

编辑：测试

作为对Joshua和其他方法的回应，我运行了自己的基准测试，我看到了与报告完全不同的结果。

以下是我测试的内容：

//my original method
Array.prototype.init = function(x,n)
{
    if(typeof(n)=='undefined') { n = this.length; }
    while (n--) { this[n] = x; }
    return this;
}

//now using push which I had previously thought to be slower than direct assignment
Array.prototype.init2 = function(x,n)
{
    if(typeof(n)=='undefined') { n = this.length; }
    while (n--) { this.push(x); }
    return this;
}

//joshua's method
function newFilledArray(len, val) {
    var a = [];
    while(len--){
        a.push(val);
    }
    return a;
}

//test m1 and m2 with short arrays many times 10K * 10

var a = new Date();
for(var i=0; i<10000; i++)
{
    var t1 = [].init(0,10);
}
var A = new Date();

var b = new Date();
for(var i=0; i<10000; i++)
{
    var t2 = [].init2(0,10);
}
var B = new Date();

//test m1 and m2 with long array created once 100K

var c = new Date();
var t3 = [].init(0,100000);
var C = new Date();

var d = new Date();
var t4 = [].init2(0,100000);
var D = new Date();

//test m3 with short array many times 10K * 10

var e = new Date();
for(var i=0; i<10000; i++)
{
    var t5 = newFilledArray(10,0);
}
var E = new Date();

//test m3 with long array created once 100K

var f = new Date();
var t6 = newFilledArray(100000, 0)
var F = new Date();

结果：

IE7 deltas:
dA=156
dB=359
dC=125
dD=375
dE=468
dF=412

FF3.5 deltas:
dA=6
dB=13
dC=63
dD=8
dE=12
dF=8

因此，据我估计，总体而言，推送速度确实较慢，但在FF中使用较长的阵列时表现更好，但在IE中表现更差，这只是总体上很糟糕（quel surprise）。

最快的方法是使用forEach=）

（我们保持IE＜9的向后兼容性）

var fillArray = Array.prototype.forEach
    ? function(arr, n) {
         arr.forEach(function(_, index) { arr[index] = n; });
         return arr;
      }
    : function(arr, n) {
         var len = arr.length;
         arr.length = 0;
         while(len--) arr.push(n);
         return arr;
      };

// test
fillArray([1,2,3], 'X'); // => ['X', 'X', 'X']

如果您需要在代码执行期间创建许多不同长度的零填充数组，我发现实现这一点的最快方法是使用本主题中提到的方法之一创建一次零数组，其长度永远不会超过，然后根据需要分割该数组。

例如（使用上面所选答案中的函数初始化数组），创建长度为maxLength的零填充数组，作为需要零数组的代码可见的变量：

var zero = newFilledArray(maxLength, 0);

现在，每当您需要长度为requiredLength<maxLength:

zero.slice(0, requiredLength);

在执行代码期间，我创建了数千次零填充数组，这大大加快了这个过程。

这里最快的是

(arr = []).length = len; arr.fill(0);

我通常使用Uint8Array（速度惊人）。例如，创建1M个元素的零填充矢量：

  var zeroFilled = [].slice.apply(new Uint8Array(1000000))

我是一个Linux用户，一直为我工作，但有一次，一个朋友使用Mac时有一些非零元素。我以为他的机器出故障了，但我们找到了最安全的方法来修复它：

  var zeroFilled = [].slice.apply(new Uint8Array(new Array(1000000)) 

已编辑

铬25.0.1364.160

弗雷德里克·戈特利布-6.43萨姆·巴纳姆-4.83伊莱-3.68约书亚2.91马修·克鲁姆利-2.67硼-2.55艾伦·赖斯-2.11康纳斯-0.68推压器温度-0.67zertosh-错误

Firefox 20.0

艾伦·赖斯-1.85约书亚-1.82马修·克鲁姆利-1.79硼-137弗雷德里克·戈特利布-0.67萨姆·巴纳姆-0.63伊莱-0.59kagax-0.13推压器温度-0.13zertosh-错误

错过了最重要的测试（至少对我来说）：Node.js测试。我怀疑它接近Chrome基准。