我的方法与@Bineesh的答案非常相似，但采用了更普遍的方法。

你可以这样声明双数组:

var myDoubleArray = [[]];

并以以下方式存储和访问内容:

var testArray1 = [9,8]
var testArray2 = [3,5,7,9,10]
var testArray3 = {"test":123}
var index = 0;

myDoubleArray[index++] = testArray1;
myDoubleArray[index++] = testArray2;
myDoubleArray[index++] = testArray3;

console.log(myDoubleArray[0],myDoubleArray[1][3], myDoubleArray[2]['test'],) 

这将打印预期的输出

[ 9, 8 ] 9 123

为Java Script创建n维矩阵数组，填充初始默认值为0。

function arr (arg, def = 0){
      if (arg.length > 2){
        return Array(arg[0]).fill().map(()=>arr(arg.slice(1)));
      } else {
        return Array(arg[0]).fill().map(()=>Array(arg[1]).fill(def));
      }
    }

// Simple Usage of 4 dimensions
var s = arr([3,8,4,6])

// Use null default value with 2 dimensions
var k = arr([5,6] , null)

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

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}`);

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

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

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

最明智的答案似乎是

var nrows = ~~(随机数学)* 10); var ncols = ~~(随机数学)* 10); 游戏机。log (rows:美元(nrows)); 游戏机。log(离职:美元(ncols)); var矩阵=新阵列(nrows)。地图(row =>新阵列(ncols).fill(0)); 游戏机。log(《黑客帝国》);

请注意，我们不能直接填充行，因为填充使用浅复制构造函数，因此所有行将共享相同的内存…下面是演示如何共享每一行的示例(取自其他答案):

// DON'T do this: each row in arr, is shared
var arr = Array(2).fill(Array(4));
arr[0][0] = 'foo'; // also modifies arr[1][0]
console.info(arr);

如何创建空二维数组(一行)

Array.from(Array(2), () => new Array(4))

2和4分别是一维和二维。

我们使用了Array.from，它可以接受一个类似数组的参数和每个元素的可选映射。

Array.from（arrayLike[， mapFn[， thisArg]]）

var arr = Array.from(Array(2)， () => new Array(4)); Arr [0][0] = 'foo'; console.info (arr);

同样的技巧可以用于创建包含1…N的JavaScript数组

或者(但当n = 10,000时效率更低，为12%)

Array(2).fill(null).map(() => Array(4))

性能下降的原因是我们必须初始化第一个维度的值才能运行.map。记住，数组不会分配位置，直到你通过.fill或直接赋值对它进行排序。

var arr =阵列(2).fill (null) . map(() = >阵列(4)); Arr [0][0] = 'foo'; console.info (arr);

跟进

这里有一个方法看起来是正确的，但有问题。

 Array(2).fill(Array(4)); // BAD! Rows are copied by reference

虽然它确实返回了显然需要的二维数组([[<4空项>]，[<4空项>]])，但有一个问题:一维数组是通过引用复制的。这意味着arr[0][0] = 'foo'实际上会改变两行而不是一行。

var arr =数组(2).fill(数组(4)); Arr [0][0] = 'foo'; console.info (arr); console.info (arr [0] [0], arr [1] [0]);