两行:

var a = []; 
while(a.push([]) < 10);

它将生成一个长度为10的数组a，其中充满数组。 (Push将一个元素添加到数组中并返回新的长度)

实际上呢?是的。你可以创建一个数组的数组，作为一个2D数组，因为每个项目本身就是一个数组: Let items = [ (1、2), (3、4), (5、6) ]; console.log(项目[0][0]);/ / 1 console.log(项目[0][1]);/ / 2 console.log(项目[1][0]);/ / 3 console.log(项目[1][1]);/ / 4 console.log(项目);

但从技术上讲，这只是一个数组的数组，而不是一个“真正的”2D数组，正如I. J. Kennedy指出的那样。

需要注意的是，您可以将数组嵌套到另一个数组中，从而创建“多维”数组。

我不喜欢使用.fill()的ES6解决方案。有些可能可以工作，但为了避免引用复制问题而添加的额外箍使它们不直观。

我建议的ES6方法是对外部数组和内部数组充分利用展开运算符。在我看来，这更容易解释。

[...Array(3)].map(() => [...Array(4)])

如果你需要设置一个初始值，那么你可以在内部数组创建时使用.map()链接:

[...Array(3)].map(() => [...Array(4)].map(() => 0))

最后，一个类型安全的TypeScript util函数:

export const createMultiDimensionalArray = <T>(
  n: number,
  m: number,
  initialVal?: T,
): T[][] => {
  const matrix = [...Array(n)].map(() => [...Array(m)]);
  return initialVal === undefined
    ? matrix
    : matrix.map(r => r.map(() => initialVal));
};

使用它的例子:

const a = createMultiDimensionalArray(1, 2);
a[1][2] = 3;     // Works

const b = createMultiDimensionalArray(2, 3, false);
b[1][2] = true;  // Works
b[1][2] = 3;     // Error: Type '3' is not assignable to type 'boolean'.

你也可以创建一个函数来创建一个2D数组，就像这样:

var myTable = [];

function createArray(myLength) {
    myTable = new Array(myLength);
    var cols, rows;
    for (cols = 0; cols < myLength; cols++) {
        myTable[cols] = new Array(myLength);
    }
}

您可以使用以下命令调用它，这将为您提供一个10x10的2D数组。

createArray(10);

您还可以使用此方法创建3D数组。

性能

今天2020.02.05，我在Chrome v79.0, Safari v13.0.4和Firefox v72.0上对MacOs HighSierra 10.13.6进行测试，以选择解决方案。

非初始化二维数组的结论

深奥的解{}/arr[[i,j]] (N)对于大小数组都是最快的，看起来对于大型稀疏数组也是不错的选择 基于for-[]/while (A,G)的求解速度较快，是小型数组的良好选择。 -[] (B,C)的解是快速的，对于大数组是很好的选择 基于Array..map/from/fill (I,J,K,L,M)对于小数组来说非常慢，而对于大数组来说非常快 for- array (n) (B,C)在safari上比for-[] (A)慢得多 令人惊讶的是，for-[] (A) for大数组在所有浏览器上都很慢 解决方案K对于所有浏览器的小数组都很慢 解决方案A,E,G对于所有浏览器的大数组都很慢 对于所有浏览器上的所有数组，解决方案M是最慢的

初始化二维数组的结论

基于for/while (A,B,C,D,E,G)的解决方案对于所有浏览器上的小数组来说都是最快的/相当快的 基于for (A,B,C,E)的解决方案对于大数组在所有浏览器上都是最快的/相当快的 基于Array..map/from/fill (I,J,K,L,M)在所有浏览器上都是中、快或慢的小数组 针对大数组的F,G,H,I,J,K,L解决方案在chrome和safari上中等或快速，但在firefox上最慢。 深奥的解决方案{}/arr[[i,j]] (N)对于所有浏览器上的大小数组都是最慢的

细节

测试没有填充(初始化)输出数组的解决方案

我们测试解的速度

小数组(12个元素)-你可以在你的机器上执行测试 大数组(100万个元素)数组-你可以在你的机器上执行测试

函数A(r) { Var arr = []; For (var I = 0;I < r;I ++) arr[I] = []; 返回arr; ｝ 函数B(r, c) { var arr = new Array(r); For (var I = 0;I < arrr .length;i++) arr[i] = new Array(c); 返回arr; ｝ 函数C(r, C) { var arr =数组(r); For (var I = 0;I < arrr .length;i++) arr[i] =数组(c); 返回arr; ｝ 函数D(r, c) { //奇怪，但有效 Var arr = []; For (var I = 0;I < r;我+ +){ arr.push ([]); 加勒比海盗[我].push(数组(c)); ｝ 返回arr; ｝ 函数E(r, c) { Let array = [[]]; For (var x = 0;X < c;x + +) { 数组[x] = []; For (var y = 0;Y < r;数组[x][Y] = [0]; ｝ 返回数组; ｝ 函数F(r, c) { var makeArray = function(调暗，arr) { If (dims[1] === undefined) { 返回数组(dim [0]); ｝ arr = Array(dimms [0]); For (var I = 0;I < dim [0];我+ +){ arr[i] = Array(dimms [1]); arr[i] = makeArray(dms .slice(1)， arr[i]); ｝ 返回arr; ｝ 返回makeArray([r, c]); ｝ 函数G(r) { Var a = []; While (a.push([]) < r); 返回一个; ｝ 函数H(r,c) { 函数createArray(length) { var arr =新的数组(长度|| 0)， I =长度; 如果参数。长度> 1){ var args = Array.prototype.slice。调用(参数,1); while(i——)arr[length-1 - i] = createArray。应用(这个,args); ｝ 返回arr; ｝ 返回createArray (r、c); ｝ 函数I(r, c) { 返回数组(r)[…]。map(x =>数组(c)); ｝ 函数J(r, c) { 返回Array(r).fill(0).map(() => Array(c)); ｝ 函数K(r, c) { return Array.from(Array(r)， () => Array(c)); ｝ 函数L(r, c) { 返回Array.from({length: r})。map(e => Array(c)); ｝ 函数M(r, c) { 返回Array.from({长度:r}, () = > Array.from({长度:c }, () => {})); ｝ 函数N(r, c) { 返回{} ｝ // ----------------------------------------------- / /显示 // ----------------------------------------------- Log = (t, f) => { 令A = f(3,4);//创建3行4列的数组 A[1][2] = 6 //第2行第3列设置为6 console.log(“$ {t}[1][2]: ${一个[1][2]},完整:$ {JSON.stringify (A) .replace(/空/ g,“x”)}”); ｝ Log2 = (t, f) => { 令A = f(3,4);//创建3行4列的数组 A[[1,2]] = 6 //第2行第3列设为6 console.log(“$ {t}[1][2]: ${一个[[1,2]]},完整:$ {JSON.stringify (A) .replace(/空/ g,“x”)}”); ｝ 日志(' A '); 日志(B, B); 日志(C, C); 日志(' D ' D); 日志(E, E); 日志(F, F); 日志(G, G); 日志(H, H); 日志(“我”,我); 日志(“J”,J); 日志(K, K); 日志(L, L); 日志(“M”,M); log2 (N, N); 这是解决方案的展示，而不是基准测试

测试填充(初始化)输出数组的解决方案

我们测试解的速度

小数组(12个元素)-你可以在你的机器上执行测试 大数组(100万个元素)数组-你可以在你的机器上执行测试

函数A(r, c, def) { Var arr = []; For (var I = 0;I < r;i++) arr[i] =数组(c).fill(def); 返回arr; ｝ 函数B(r, c, def) { var arr = new Array(r); For (var I = 0;I < arrr .length;i++) arr[i] = new Array(c).fill(def); 返回arr; ｝ 函数C(r, C, def) { var arr =数组(r); For (var I = 0;I < arrr .length;i++) arr[i] =数组(c).fill(def); 返回arr; ｝ 函数D(r, c, def) { //奇怪，但有效 Var arr = []; For (var I = 0;I < r;我+ +){ arr.push ([]); 加勒比海盗[我].push(数组(c)); ｝ For (var I = 0;I < r;i++) for (var j = 0;J < c;j + +) arr[我][j] = def 返回arr; ｝ 函数E(r, c, def) { Let array = [[]]; For (var x = 0;X < c;x + +) { 数组[x] = []; For (var y = 0;Y < r;数组[x][Y] = def; ｝ 返回数组; ｝ 函数F(r, c, def) { var makeArray = function(调暗，arr) { If (dims[1] === undefined) { 返回数组(退去[0]).fill (def); ｝ arr = Array(dimms [0]); For (var I = 0;I < dim [0];我+ +){ arr[i] = Array(dimms [1]); arr[i] = makeArray(dms .slice(1)， arr[i]); ｝ 返回arr; ｝ 返回makeArray([r, c]); ｝ 函数G(r, c, def) { Var a = []; while (a.push(Array(c).fill(def)) < r); 返回一个; ｝ 函数H(r,c, def) { 函数createArray(length) { var arr =新的数组(长度|| 0)， I =长度; 如果参数。长度> 1){ var args = Array.prototype.slice。调用(参数,1); while(i——)arr[length-1 - i] = createArray。应用(这个,args) .fill (def); ｝ 返回arr; ｝ 返回createArray (r、c); ｝ 函数I(r, c, def) { 返回数组(r)[…]。map(x =>数组(c).fill(def)); ｝ 函数J(r, c, def) { 返回数组(r) .fill (0) . map(() = >数组(c) .fill (def)); ｝ 函数K(r, c, def) { 返回Array.from(Array(r)， () => Array(c).fill(def)); ｝ 函数L(r, c, def) { 返回Array.from({length: r})。map(e => Array(c).fill(def)); ｝ 函数M(r, c, def) { 返回Array.from({长度:r}, () = > Array.from({长度:c}, () = > def)); ｝ 函数N(r, c, def) { 让arr = {}; For (var I = 0;I < r;i++) for (var j = 0;J < c;j + +) arr [[i, j]] = def; 返回arr; ｝ // ----------------------------------------------- / /显示 // ----------------------------------------------- Log = (t, f) => { 令A = f(1000,1000,7);//创建一个1000行1000列的数组 //每个数组单元格初始化为7 A[800][900] = 5 //第800行和第901列设为5 console.log(“$ {t}[1][2]: ${一个[1][2]},{t}美元[800][901]:${一个[800][900]}”); ｝ Log2 = (t, f) => { 令A = f(1000,1000,7);//创建一个1000行1000列的数组 //每个数组单元格初始化为7 A[[800,900]] = 5 //第800行第900列设置为5 console.log(“$ {t}[1][2]: ${一个[[1,2]]},{t}美元[800][900]:${一个[[800900]]}'); ｝ 日志(' A '); 日志(B, B); 日志(C, C); 日志(' D ' D); 日志(E, E); 日志(F, F); 日志(G, G); 日志(H, H); 日志(“我”,我); 日志(“J”,J); 日志(K, K); 日志(L, L); 日志(“M”,M); log2 (N, N); 这是解决方案的展示，而不是基准测试

我发现这段代码适合我:

var map = [
    []
];

mapWidth = 50;
mapHeight = 50;
fillEmptyMap(map, mapWidth, mapHeight);

...

function fillEmptyMap(array, width, height) {
    for (var x = 0; x < width; x++) {
        array[x] = [];
        for (var y = 0; y < height; y++) {

            array[x][y] = [0];
        }
    }
}