为什么要初始化长度？理论上没有必要这样做。它甚至会导致混乱的行为，因为所有使用该长度来确定数组是否为空的测试都会报告该数组不为空。一些测试表明，如果随后填充数组，则设置大数组的初始长度可能会更有效，但每个浏览器的性能增益（如果有的话）似乎有所不同。jsLint不喜欢new Array（），因为构造函数不明确。新阵列（4）；创建长度为4的空数组。但是新阵列（'4'）；创建包含值“4”的数组。

关于你的评论：在JS中，你不需要初始化数组的长度。它是动态增长的。您可以将长度存储在某个变量中，例如。

var data = [];
var length = 5; // user defined length

for(var i = 0; i < length; i++) {
    data.push(createSomeObject());
}

您不应该使用新阵列的原因如下：

var Array = function () {};

var x = new Array(4);

alert(x.length);  // undefined...

其他一些代码可能会干扰Array变量。我知道任何人都会写这样的代码有点牵强，但是。。。

此外，正如Felix King所说，界面有点不一致，可能会导致一些非常难以追踪的bug。

如果您想要一个长度=x的数组，并填充未定义的（就像新的array（x）那样），您可以这样做：

var x = 4;
var myArray = [];
myArray[x - 1] = undefined;

alert(myArray.length); // 4

数组构造函数有一个不明确的语法，JSLint毕竟会伤害你的感情。

此外，如果示例代码损坏，第二个var语句将引发SyntaxError。您正在设置数组测试的属性长度，因此不需要另一个变量。

就您的选择而言，array.length是唯一“干净”的选项。问题是，为什么首先需要设置大小？尝试重构代码以消除这种依赖。

这将把长度属性初始化为4:

var x = [,,,,];

（这可能是更好的评论，但太长了）

所以，读了这篇文章后，我很好奇预分配是否真的更快，因为理论上应该更快http://www.html5rocks.com/en/tutorials/speed/v8/.

所以我仍然不确定，所以我把它放在了测试中。事实证明，它似乎更慢。

var time = Date.now();
var temp = [];
for(var i=0;i<100000;i++){
    temp[i]=i;
}
console.log(Date.now()-time);


var time = Date.now();
var temp2 = new Array(100000);
for(var i=0;i<100000;i++){
    temp2[i] = i;
}
console.log(Date.now()-time); 

经过几次偶然运行后，此代码产生以下结果：

$ node main.js 
9
16
$ node main.js 
8
14
$ node main.js 
7
20
$ node main.js 
9
14
$ node main.js 
9
19

我很惊讶，没有一个功能性的解决方案可以让你设置一行的长度。以下内容基于UndercoreJS：

var test = _.map(_.range(4), function () { return undefined; });
console.log(test.length);

由于上面提到的原因，除非我想将数组初始化为特定值，否则我会避免这样做。有趣的是，还有其他实现范围的库，包括Lo-dash和Lazy，它们可能具有不同的性能特征。

var arr=[];
arr[5]=0;
alert("length="+arr.length); // gives 6

Array（5）为您提供了一个长度为5但没有值的数组，因此您无法对其进行迭代。Array.apply（null，Array（5））.map（function（）｛｝）为您提供了一个长度为5且未定义为值的数组，现在可以对其进行迭代。Array.apply（null，Array（5））.map（函数（x，i）{return i；}）为您提供一个长度为5、值为0,1,2,3,4的数组。Array（5）.forEach（警报）不执行任何操作，Array.apply（null，Array（5个））.forEach（警报）为您提供5个警报ES6为我们提供了Array.from，所以现在您也可以使用Array.from（Array（5））.forEach（alert）如果您想用某个值进行初始化，那么最好知道。。。来自（'abcde'）的数组，来自（'x'。重复（5））的数组从（{length:5}，（v，i）=>i）//得到[0，1，2，3，4]

这是另一个解决方案

var arr = Array.apply( null, { length: 4 } );
arr;  // [undefined, undefined, undefined, undefined] (in Chrome)
arr.length; // 4

apply（）的第一个参数是this对象绑定，这里我们不关心它，所以我们将其设置为null。

Array.apply（..）正在调用Array（..）函数，并将｛length:3｝对象值作为其参数展开。

请人们不要放弃你的旧习惯。分配内存一次，然后处理该数组中的条目（与以前一样），与在数组增长时多次分配内存（这是系统在使用其他建议方法时不可避免的做法），两者在速度上存在很大差异。

当然，这些都不重要，除非你想用更大的阵列做些酷的事情。然后它就开始了。

鉴于目前JS中似乎仍然没有设置数组初始容量的选项，我使用以下方法。。。

var newArrayWithSize = function(size) {
  this.standard = this.standard||[];
  for (var add = size-this.standard.length; add>0; add--) {
   this.standard.push(undefined);// or whatever
  }
  return this.standard.slice(0,size);
}

需要权衡：

该方法在第一次调用函数时花费的时间与其他方法一样长，但在以后的调用中花费的时间很少（除非要求更大的数组）。标准阵列永久保留的空间与您所要求的最大阵列一样多。

但如果它与你正在做的事情相吻合，就会有回报。非正式计时看跌期权

for (var n=10000;n>0;n--) {var b = newArrayWithSize(10000);b[0]=0;}

以相当快的速度（假设n＝1000000，大约需要5秒），以及

for (var n=10000;n>0;n--) {
  var b = [];for (var add=10000;add>0;add--) {
    b.push(undefined);
  }
}

在一分钟以上（在同一个铬控制台上，10000台的速度大约为90秒，或者大约慢2000倍）。这不仅仅是分配，还有10000次推送、for循环等。。

使用ES2015.fill（），您现在可以简单地执行以下操作：

// `n` is the size you want to initialize your array
// `0` is what the array will be filled with (can be any other value)
Array(n).fill(0)

这比Array.apply（0，new Array（n））.map（i=>value）要简洁得多

可以在.fill（）中删除0并在没有参数的情况下运行，这将用undefined填充数组。（但是，这将在Typescript中失败）

可以使用array.length=youValue设置数组长度

所以应该是

var myArray = [];
myArray.length = yourValue;

最短：

设arr=[…数组（10）]；控制台日志（arr）；

ES6引入了Array.from，它允许您从任何“类数组”或可迭代对象创建Array：

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

在这种情况下，{length:10}表示“类数组”对象的最小定义：一个只定义了长度属性的空对象。

Array.from允许第二个参数映射到结果数组上。

[...Array(6)].map(x => 0);
// [0, 0, 0, 0, 0, 0]

OR

Array(6).fill(0);
// [0, 0, 0, 0, 0, 0]

注意：不能循环空插槽，即Array（4）。forEach（（）=>…）

---

OR

（字体安全）

Array(6).fill(null).map((_, i) => i);
// [0, 1, 2, 3, 4, 5]

---

OR

使用函数的经典方法（适用于任何浏览器）

function NewArray(size) {
    var x = [];
    for (var i = 0; i < size; ++i) {
        x[i] = i;
    }
    return x;
}

var a = NewArray(10);
// [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

---

创建嵌套阵列

当使用填充直观地创建二维阵列时，应该创建新的实例。但实际发生的情况是，相同的数组将作为引用存储。

var a = Array(3).fill([6]);
// [  [6], [6], [6]  ]

a[0].push(9);
// [  [6, 9], [6, 9], [6, 9]  ]

解决方案

var a = [...Array(3)].map(x => []);

a[0].push(4, 2);
// [  [4, 2], [], []  ]

因此，3x2阵列将如下所示：

[...Array(3)].map(x => Array(2).fill(0));
// [  [0, 0], [0, 0], [0, 0]  ]

---

N维阵列

function NArray(...dimensions) {
    var index = 0;
    function NArrayRec(dims) {
        var first = dims[0], next = dims.slice().splice(1); 
        if(dims.length > 1) 
            return Array(dims[0]).fill(null).map((x, i) => NArrayRec(next ));
        return Array(dims[0]).fill(null).map((x, i) => (index++));
    }
    return NArrayRec(dimensions);
}

var arr = NArray(3, 2, 4);
// [   [  [ 0,  1,  2,  3 ] , [  4,  5,  6,  7]  ],
//     [  [ 8,  9,  10, 11] , [ 12, 13, 14, 15]  ],
//     [  [ 16, 17, 18, 19] , [ 20, 21, 22, 23]  ]   ]

---

初始化棋盘

var Chessboard = [...Array(8)].map((x, j) => {
    return Array(8).fill(null).map((y, i) => {
        return `${String.fromCharCode(65 + i)}${8 - j}`;
    });
});

// [ [A8, B8, C8, D8, E8, F8, G8, H8],
//   [A7, B7, C7, D7, E7, F7, G7, H7],
//   [A6, B6, C6, D6, E6, F6, G6, H6],
//   [A5, B5, C5, D5, E5, F5, G5, H5],
//   [A4, B4, C4, D4, E4, F4, G4, H4],
//   [A3, B3, C3, D3, E3, F3, G3, H3],
//   [A2, B2, C2, D2, E2, F2, G2, H2],
//   [A1, B1, C1, D1, E1, F1, G1, H1] ]

---

数学填充值

处理数学时，简便的小方法过载

function NewArray( size , method, linear )
{
    method = method || ( i => i ); 
    linear = linear || false;
    var x = [];
    for( var i = 0; i < size; ++i )
        x[ i ] = method( linear ? i / (size-1) : i );
    return x;
}

NewArray( 4 ); 
// [ 0, 1, 2, 3 ]

NewArray( 4, Math.sin ); 
// [ 0, 0.841, 0.909, 0.141 ]

NewArray( 4, Math.sin, true );
// [ 0, 0.327, 0.618, 0.841 ]

var pow2 = ( x ) => x * x;

NewArray( 4, pow2 ); 
// [ 0, 1, 4, 9 ]

NewArray( 4, pow2, true ); 
// [ 0, 0.111, 0.444, 1 ]

假设数组的长度是恒定的。在Javascript中，我们这样做：

const intialArray=新数组（指定值）；

在大多数答案中，建议填充数组，因为否则“无法对其进行迭代”，但这不是真的。您可以迭代空数组，但不能使用forEach。While循环、for of循环和for i循环工作正常。

const count = Array(5);

不起作用。

console.log('---for each loop:---');
count.forEach((empty, index) => {
    console.log(`counting ${index}`);
});

这些工作：

console.log('---for of loop:---');
for (let [index, empty] of count.entries()) {
  console.log(`counting for of loop ${index}`);
}

console.log('---for i loop:---');
for (let i = 0, il = count.length; i < il; ++i) {
  console.log(`counting for i loop ${i}`);
}

console.log('---while loop:---');
let index = 0;
while (index < count.length) { 
  console.log(`counting while loop ${index}`); 
  index++; 
}

用上面的例子检查这个小提琴。

另外，angulars*ngFor在空数组中也很好：

<li *ngFor="let empty of count; let i = index" [ngClass]="
  <span>Counting with *ngFor {{i}}</span>
</li>

除了其他人的答案之外，另一个聪明的方法是使用Float32Array创建一个数组并对其进行迭代。

为此，从Float32Array创建一个具有所需长度的实例，如下所示：

new Float32Array(5)

此代码返回一个数组，您可以使用array.from（）将其转换为数组：

Array.from(new Float32Array(5)) // [0, 0, 0, 0, 0]

您还可以使用fill（）更改项的值：

Array.from(new Float32Array(5).fill(2)) // [2, 2, 2, 2, 2]

当然，您可以对其进行迭代：

Array.from(new Float32Array(5)).map(item => /* ... */ )

最简单的形式是使用

Array.from({ length: 3 });

// gives you
[undefined, undefined, undefined]

与Array（3）不同，它将为您提供一个无法迭代的数组。from（｛length｝）为您提供了一个可以轻松迭代的数组。

Array.from({ length: 3 }).map((e, idx) => `hi ${idx}`);
// ['hi 1', 'hi 2', 'hi 3']