循环代码最短

a=i=[];for(;i<100;)a[i++]=0;

edit:
for(a=i=[];i<100;)a[i++]=0;
or
for(a=[],i=100;i--;)a[i]=0;

安全var版本

var a=[],i=0;for(;i<100;)a[i++]=0;

edit:
for(var i=100,a=[];i--;)a[i]=0;

我只使用：

var arr = [10];
for (var i=0; i<=arr.length;arr[i] = i, i++);

这个concat版本在我的Chrome测试中要快得多（2013-03-21）。10000000个元素约200ms，而直接初始化为675。

function filledArray(len, value) {
    if (len <= 0) return [];
    var result = [value];
    while (result.length < len/2) {
        result = result.concat(result);
    }
    return result.concat(result.slice(0, len-result.length));
}

另外：如果你想用字符串填充数组，这是一种简洁的方法（虽然没有concat那么快）：

function filledArrayString(len, value) {
    return new Array(len+1).join(value).split('');
}

其他人似乎缺少的是预先设置数组的长度，这样解释器就不会不断改变数组的大小。

我的简单一行代码是Array.protocol.slice.apply（newUint8Array（长度））

但是，如果我要创建一个函数来快速执行，而不需要一些复杂的变通方法，我可能会编写一个这样的函数：

var filledArray = function(value, l) {
    var i = 0, a = []; a.length = l;
    while(i<l) a[i++] = value;
    return a;
    }

ES6引入了Array.prototype.fill。它可以这样使用：

new Array(len).fill(0);

不确定它是否很快，但我喜欢它，因为它很短，很自我描述。

它仍然不在IE中（检查兼容性），但有一个polyfill可用。

值得指出的是，Array.prototype.fill是作为ECMAScript 6（Harmony）提案的一部分添加的。在考虑线程中提到的其他选项之前，我宁愿使用下面写的polyfill。

if (!Array.prototype.fill) {
  Array.prototype.fill = function(value) {

    // Steps 1-2.
    if (this == null) {
      throw new TypeError('this is null or not defined');
    }

    var O = Object(this);

    // Steps 3-5.
    var len = O.length >>> 0;

    // Steps 6-7.
    var start = arguments[1];
    var relativeStart = start >> 0;

    // Step 8.
    var k = relativeStart < 0 ?
      Math.max(len + relativeStart, 0) :
      Math.min(relativeStart, len);

    // Steps 9-10.
    var end = arguments[2];
    var relativeEnd = end === undefined ?
      len : end >> 0;

    // Step 11.
    var final = relativeEnd < 0 ?
      Math.max(len + relativeEnd, 0) :
      Math.min(relativeEnd, len);

    // Step 12.
    while (k < final) {
      O[k] = value;
      k++;
    }

    // Step 13.
    return O;
  };
}