递归函数创建多维数组:

var makeArray = function (dims, arr) {          
    if (dims[1] === undefined) {
        return new Array(dims[0]);
    }

    arr = new Array(dims[0]);

    for (var i=0; i<dims[0]; i++) {
        arr[i] = new Array(dims[1]);
        arr[i] = makeArray(dims.slice(1), arr[i]);
    }

    return arr;
}

构建一个2x3x4x2的4D-Array:

var array = makeArray([2, 3, 4, 2]);    

我发现下面是最简单的方法:

Var array1 = [[]]; Array1 [0][100] = 5; alert (array1 [0] [100]); 警报(array1.length); alert (array1 [0] . length);

实际上呢?是的。你可以创建一个数组的数组，作为一个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指出的那样。

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

性能

今天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); 这是解决方案的展示，而不是基准测试

如果数组的大小未知会发生什么?或者数组应该动态创建和填充?另一种解决方案，为我工作是使用类与静态2d数组变量，在数组中不存在索引的情况下将启动它:

function _a(x,y,val){
    // return depending on parameters
    switch(arguments.length){
        case 0: return _a.a;
        case 1: return _a.a[x];
        case 2: return _a.a[x][y];
    }

    // declare array if wasn't declared yet
    if(typeof _a.a[x] == 'undefined')
        _a.a[x] = [];

    _a.a[x][y] = val;
}
// declare static empty variable
_a.a = [];

语法将是:

_a(1,1,2); // populates [1][1] with value 2
_a(1,1);   // 2 or alternative syntax _a.a[1][1]
_a(1);     // [undefined × 1, 2]
_a.a;      // [undefined × 1, Array[2]]
_a.a.length

我不喜欢使用.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'.