这里有一个很棒的仓库。

API: masfufa.js 示例:masfufa.html

两个示例将足以理解这个库:

示例1:

   /*     | 1 , 2 , 3 |
    * MX= | 4 , 5 , 6 |     Dimensions= 3 x 3
    *     | 7 , 8 , 9 |
    */ 


  jsdk.getAPI('my');
  var A=[1, 2, 3, 4, 5, 6, 7, 8, 9];
  var MX=myAPI.getInstance('masfufa',{data:A,dim:'3x3'});

然后:

MX.get[0][0]  // -> 1 (first)
MX.get[2][2] //  ->9 (last)

示例2:

   /*      | 1 , 9 , 3 , 4 |
    * MXB= | 4 , 5 , 6 , 2 |     Dimensions= 2 x 4
    *   
    */ 

  var B=[1 , 9 , 3 , 4 , 4 , 5 , 6 , 2];
  var MXB=myAPI.getInstance('masfufa',{data:B,dim:'2x4'});

然后:

MXB.get[0][0]  // -> 1 (first)
MXB.get[1][3] //  -> 2 (last)
MXB.get[1][2] //  -> 6 (before last)

Javascript只有一维数组，但正如其他人指出的那样，你可以构建数组的数组。

下面的函数可以用来构造一个固定维度的二维数组:

function Create2DArray(rows) {
  var arr = [];

  for (var i=0;i<rows;i++) {
     arr[i] = [];
  }

  return arr;
}

列的数量其实并不重要，因为在使用数组之前不需要指定数组的大小。

然后你可以调用:

var arr = Create2DArray(100);

arr[50][2] = 5;
arr[70][5] = 7454;
// ...

下面，创建一个5x5矩阵，并将其填充为null

Var md = []; (var = 0;我< 5;我+ +){ md.push(新数组(5).fill (null)); ｝ console.log (md);

这将构造任何维度的数组。

function makeArrayChildren(parent, firstDimension, ...dimensions) {
  for (let i = 0; i < parent.length; i++) {
    parent[i] = new Array(firstDimension);
    if (dimensions.length != 0) {
      makeArrayChildren(parent[i], ...dimensions);
    }
  }
}
function makeArray(firstDimension, ...dimensions) {
  if (firstDimension == undefined) {
    throw Exception("Too few dimensions");
  }
  let topArray = new Array(firstDimension);
  if (dimensions.length != 0) makeArrayChildren(topArray, ...dimensions);
  return topArray;
}

这里还有另外两个我想做的函数，我可以用它作为一个完整性检查:一个用于在多维数组中所有最低级别项上执行的每个函数，一个填充方法。

Array.prototype.dimensionalFill = function (value) {
  for (let i = 0; i < this.length; i++) {
    const elem = this[i];
    if (elem instanceof Array) {
      elem.dimensionalFill(value);
    } else {
      this[i] = value;
    }
  }
};
/*Unlike forEach, this also loops over undefined values. */
Array.prototype.dimensionalForEach = function (callableFunc, thisArg) {
  if (thisArg != undefined) {
    return this.dimensionalForEach(callableFunc.bind(thisArg));
  }
  for (let i = 0; i < this.length; i++) {
    const elem = this[i];
    if (elem instanceof Array) {
      elem.dimensionalForEach(callableFunc);
    } else {
      callableFunc(elem, i, this);
    }
  }
};

这里有一个漂亮的小检查，它使用了所有的特性。所以至少，它不可能完全错误。

let arr = makeArray(10, 10, 5, 4);
arr.dimensionalFill(2);
let sum = 0;
arr.dimensionalForEach((elem) => {
  sum += elem;
});
console.log(`sum: ${sum} === ${10 * 10 * 5 * 4 * 2}`);

值得一提的是，在这一点上，创建一个全新的结构将是一个更好的实践，但这很有趣。

如果你想要的是一个4x4矩阵，看看DOMMatrix，它很容易使用，我可以说，

let m = new DOMMatrix(); 
// m.m11, m.m12, m.m13, m.m14, ..., m.m41, m.m42, m.m43, m.m44

最初由于不同的原因，它在node.js上不可用，并且仅限于4x4。

你也可以考虑使用一个自动激活对象，而不是JS的数组，看看我的答案，但这里也带来了更多的说服力:

var tree = () => new Proxy({}, { get: (target, name) => name in target ? target[name] : target[name] = tree() });

var t = tree();
t[0][2][3] = 4;
console.log(t[0][2][3]);

它使用新的JS和行为不正确时，你迭代它，所以要小心它。

如果你需要一个灵活的多维数组生成器，也可以看看这个。

对于一行程序爱好者来说

// creates 8x8 array filed with "0"    
const arr2d = Array.from({ length: 8 }, () => Array.from({ length: 8 }, () => "0"))

另一个(来自dmitry_romanov的评论)使用Array().fill()

// creates 8x8 array filed with "0"    
const arr2d = Array(8).fill(0).map(() => Array(8).fill("0"))

使用ES6+扩展操作符(“受InspiredJW启发”:))

// same as above just a little shorter
const arr2d = [...Array(8)].map(() => Array(8).fill("0"))