我一直在网上阅读，有些地方说这是不可能的，有些地方说是不可能，然后举一个例子，其他人则反驳该例子，等等。

1. 如何在JavaScript中声明二维数组？（假设有可能）

2. 我将如何访问其成员？（myArray[0][1]或myArray[0,1]？）

您只需将数组中的每个项目都设为一个数组。

var x = new Array(10);

for (var i = 0; i < x.length; i++) {
  x[i] = new Array(3);
}

console.log(x);

与activa的答案类似，这是一个创建n维数组的函数：

function createArray(length) {
    var arr = new Array(length || 0),
        i = length;

    if (arguments.length > 1) {
        var args = Array.prototype.slice.call(arguments, 1);
        while(i--) arr[length-1 - i] = createArray.apply(this, args);
    }

    return arr;
}

createArray();     // [] or new Array()

createArray(2);    // new Array(2)

createArray(3, 2); // [new Array(2),
                   //  new Array(2),
                   //  new Array(2)]

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;
// ...

最简单的方法：

var myArray = [[]];

如何创建一个空的二维数组（单行）

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数组。

或者（但使用时效率低下 12％n = 10,000）

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

性能下降的事实是，我们必须初始化第一个维度值才能运行.map。请记住，Array在您通过直通.fill或直接值分配进行订购之前， 不会分配头寸。

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

跟进

这是一种看似正确但有问题的方法。

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

尽管它确实返回了显然需要的二维数组（[ [ <4 empty items> ], [ <4 empty items> ] ]），但有一个问题：第一维数组已通过引用复制。这意味着a arr[0][0] = 'foo'实际上将更改两行而不是一行。

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

有人说不可能的原因是因为二维数组实际上只是数组的数组。这里的其他注释提供了在JavaScript中创建二维数组的完全有效的方法，但最纯粹的观点是您拥有一个一维对象数组，每个对象都是一个由两个元素组成的一维数组。

因此，这就是观点冲突的原因。

很少有人展示出push的用法：
要带来新的东西，我将向您展示如何使用一些值来初始化矩阵，例如：0或空字符串“”。
提醒您，如果您有10个元素的数组，那么在javascript中，最后一个索引将为9！

function matrix( rows, cols, defaultValue){

  var arr = [];

  // Creates all lines:
  for(var i=0; i < rows; i++){

      // Creates an empty line
      arr.push([]);

      // Adds cols to the empty line:
      arr[i].push( new Array(cols));

      for(var j=0; j < cols; j++){
        // Initializes:
        arr[i][j] = defaultValue;
      }
  }

return arr;
}

用法示例：

x = matrix( 2 , 3,''); // 2 lines, 3 cols filled with empty string
y = matrix( 10, 5, 0);// 10 lines, 5 cols filled with 0

两线：

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

它将生成一个长度为10的数组，并用数组填充。（将元素添加到数组中并返回新的长度）

最明智的答案似乎是

var nrows = ~~(Math.random() * 10);
var ncols = ~~(Math.random() * 10);
console.log(`rows:${nrows}`);
console.log(`cols:${ncols}`);
var matrix = new Array(nrows).fill(0).map(row => new Array(ncols).fill(0));
console.log(matrix);

注意，由于fill使用浅拷贝构造函数，因此我们不能直接填充行，因此所有行将共享相同的内存...以下示例演示如何共享每一行（取自其他答案）：

// 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);

最简单的方法：

var arr  = [];

var arr1 = ['00','01'];
var arr2 = ['10','11'];
var arr3 = ['20','21'];

arr.push(arr1);
arr.push(arr2);
arr.push(arr3);

alert(arr[0][1]); // '01'
alert(arr[1][1]); // '11'
alert(arr[2][0]); // '20'

这是我实现的目标：

var appVar = [[]];
appVar[0][4] = "bineesh";
appVar[0][5] = "kumar";
console.log(appVar[0][4] + appVar[0][5]);
console.log(appVar);

这叫我bineeshkumar

二维数组的创建方式与一维数组相同。您可以像这样访问它们array[0][1]。

var arr = [1, 2, [3, 4], 5];

alert (arr[2][1]); //alerts "4"

我不确定是否有人回答过这个问题，但是我发现这对我很有效-

var array = [[,],[,]]

例如：

var a = [[1,2],[3,4]]

例如，对于二维数组。

要在javaScript中创建2D数组，我们可以先创建一个Array，然后添加Arrays作为其元素。此方法将返回具有给定行数和列数的2D数组。

function Create2DArray(rows,columns) {
   var x = new Array(rows);
   for (var i = 0; i < rows; i++) {
       x[i] = new Array(columns);
   }
   return x;
}

要创建数组，请使用以下方法。

var array = Create2DArray(10,20);

要创建一个所有索引都可寻址且值设置为null的非稀疏“ 2D”数组（x，y）：

let 2Darray = new Array(x).fill(null).map(item =>(new Array(y).fill(null))) 

奖励“ 3D”数组（x，y，z）

let 3Darray = new Array(x).fill(null).map(item=>(new Array(y).fill(null)).map(item=>Array(z).fill(null)))

在评论中以及针对此问题的不同地方都提到了对此的各种更改和更正，但并未作为实际答案，因此在此添加。

应该注意的是（类似于大多数其他答案），这具有O（x * y）的时间复杂度，因此它可能不适合非常大的数组。

使用数组推导

在JavaScript 1.7和更高版本中，您可以使用数组推导来创建二维数组。您也可以在填充数组时过滤和/或操作条目，而不必使用循环。

var rows = [1, 2, 3];
var cols = ["a", "b", "c", "d"];

var grid = [ for (r of rows) [ for (c of cols) r+c ] ];

/* 
         grid = [
            ["1a","1b","1c","1d"],
            ["2a","2b","2c","2d"],
            ["3a","3b","3c","3d"]
         ]
*/

您可以创建所需的任何n x m数组，并通过调用以下方法将其填充为默认值

var default = 0;  // your 2d array will be filled with this value
var n_dim = 2;
var m_dim = 7; 

var arr = [ for (n of Array(n_dim)) [ for (m of Array(m_dim) default ]] 
/* 
         arr = [
            [0, 0, 0, 0, 0, 0, 0],
            [0, 0, 0, 0, 0, 0, 0],
         ]
*/

在此处可以找到更多示例和文档。

请注意，这不是标准功能。

对于一个班轮爱好者来说Array.from（）

// 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"))

我的方法与@Bineesh答案非常相似，但具有更通用的方法。

您可以声明double数组，如下所示：

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

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

var array1 = [[]];   
array1[0][100] = 5; 

alert(array1[0][100]);
alert(array1.length);
alert(array1[0].length);

性能

今天，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）的解决方案速度很快，是小型阵列的理想选择。
• 解决方案for-[]（B，C）快速，它们是大型阵列的不错选择
• 基于Array..map/from/fill（I，J，K，L，M）的解决方案对于小型阵列来说非常慢，而对于大型阵列来说非常快
• 令人惊讶的是for-Array(n)（B，C）在野生动物园中比for-[]（A）慢得多
• 令人惊讶的for-[]是，大数组在所有浏览器中的速度（A）都很慢
• 解决方案对于所有浏览器来说，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元） -您可以在计算机上执行测试HERE
• 大阵列（1万台）阵列-你可以在你的计算机上执行测试HERE

function A(r) {
  var arr = [];
  for (var i = 0; i < r; i++) arr[i] = [];
  return arr;
}

function B(r, c) {
  var arr = new Array(r);
  for (var i = 0; i < arr.length; i++) arr[i] = new Array(c);
  return arr;
}

function C(r, c) {
  var arr = Array(r);
  for (var i = 0; i < arr.length; i++) arr[i] = Array(c);
  return arr;
}

function D(r, c) {
  // strange, but works
  var arr = [];
  for (var i = 0; i < r; i++) {
    arr.push([]);
    arr[i].push(Array(c));
  }
  return arr;
}

function E(r, c) {
  let array = [[]];
  for (var x = 0; x < c; x++) {
    array[x] = [];
    for (var y = 0; y < r; y++) array[x][y] = [0];
  }
  return array;
}

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

    arr = Array(dims[0]);

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

    return arr;
  }
  return makeArray([r, c]);
}

function G(r) {
  var a = [];
  while (a.push([]) < r);
  return a;
}

function H(r,c) {
  function createArray(length) {
    var arr = new Array(length || 0),
        i = length;

    if (arguments.length > 1) {
        var args = Array.prototype.slice.call(arguments, 1);
        while(i--) arr[length-1 - i] = createArray.apply(this, args);
    }

    return arr;
  }
  return createArray(r,c);
}

function I(r, c) {
  return [...Array(r)].map(x => Array(c));
}

function J(r, c) {
  return Array(r).fill(0).map(() => Array(c));
}

function K(r, c) {
  return Array.from(Array(r), () => Array(c));
}

function L(r, c) {
  return Array.from({length: r}).map(e => Array(c));
}

function M(r, c) {
  return Array.from({length: r}, () => Array.from({length: c}, () => {}));
}

function N(r, c) {
  return {}
}



// -----------------------------------------------
// SHOW
// -----------------------------------------------

log = (t, f) => {
  let A = f(3, 4); // create array with 3 rows and 4 columns
  A[1][2] = 6 // 2-nd row 3nd column set to 6
  console.log(`${t}[1][2]: ${A[1][2]}, full: ${JSON.stringify(A).replace(/null/g,'x')}`);
}

log2 = (t, f) => {
  let A = f(3, 4); // create array with 3 rows and 4 columns
  A[[1,2]] = 6 // 2-nd row 3nd column set to 6
  console.log(`${t}[1][2]: ${A[[1,2]]}, full: ${JSON.stringify(A).replace(/null/g,'x')}`);
}

log('A', A);
log('B', B);
log('C', C);
log('D', D);
log('E', E);
log('F', F);
log('G', G);
log('H', H);
log('I', I);
log('J', J);
log('K', K);
log('L', L);
log('M', M);
log2('N', N);

This is presentation of solutions - not benchmark

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

我们测试解决方案的速度

• 小数组（12元） -您可以在计算机上执行测试HERE
• 大阵列（1万台）阵列-你可以在你的计算机上执行测试HERE

function A(r, c, def) {
  var arr = [];
  for (var i = 0; i < r; i++) arr[i] = Array(c).fill(def);
  return arr;
}

function B(r, c, def) {
  var arr = new Array(r);
  for (var i = 0; i < arr.length; i++) arr[i] = new Array(c).fill(def);
  return arr;
}

function C(r, c, def) {
  var arr = Array(r);
  for (var i = 0; i < arr.length; i++) arr[i] = Array(c).fill(def);
  return arr;
}

function D(r, c, def) {
  // strange, but works
  var arr = [];
  for (var i = 0; i < r; i++) {
    arr.push([]);
    arr[i].push(Array(c));
  }
  for (var i = 0; i < r; i++) for (var j = 0; j < c; j++) arr[i][j]=def
  return arr;
}

function E(r, c, def) {
  let array = [[]];
  for (var x = 0; x < c; x++) {
    array[x] = [];
    for (var y = 0; y < r; y++) array[x][y] = def;
  }
  return array;
}

function F(r, c, def) {
  var makeArray = function(dims, arr) {
    if (dims[1] === undefined) {
      return Array(dims[0]).fill(def);
    }

    arr = Array(dims[0]);

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

    return arr;
  }
  return makeArray([r, c]);
}

function G(r, c, def) {
  var a = [];
  while (a.push(Array(c).fill(def)) < r);
  return a;
}

function H(r,c, def) {
  function createArray(length) {
    var arr = new Array(length || 0),
        i = length;

    if (arguments.length > 1) {
        var args = Array.prototype.slice.call(arguments, 1);
        while(i--) arr[length-1 - i] = createArray.apply(this, args).fill(def);
    }

    return arr;
  }
  return createArray(r,c);
}

function I(r, c, def) {
  return [...Array(r)].map(x => Array(c).fill(def));
}

function J(r, c, def) {
  return Array(r).fill(0).map(() => Array(c).fill(def));
}

function K(r, c, def) {
  return Array.from(Array(r), () => Array(c).fill(def));
}

function L(r, c, def) {
  return Array.from({length: r}).map(e => Array(c).fill(def));
}

function M(r, c, def) {
  return Array.from({length: r}, () => Array.from({length: c}, () => def));
}

function N(r, c, def) {
  let arr={};
  for (var i = 0; i < r; i++) for (var j = 0; j < c; j++) arr[[i,j]]=def;
  return arr;
}



// -----------------------------------------------
// SHOW
// -----------------------------------------------

log = (t, f) => {
  let A = f(1000,1000,7); // create array with 1000 rows and 1000 columns, 
                          // each array cell initilised by 7
  A[800][900] = 5         // 800nd row and 901nd column set to 5
  console.log(`${t}[1][2]: ${A[1][2]}, ${t}[800][901]: ${A[800][900]}`);
}

log2 = (t, f) => {
  let A = f(1000,1000,7); // create array with 1000 rows and 1000 columns, 
                          // each array cell initilised by 7
  A[[800,900]] = 5            // 800nd row 900nd column set to 5
  console.log(`${t}[1][2]: ${A[[1,2]]}, ${t}[800][900]: ${A[[800,900]]}`);
}

log('A', A);
log('B', B);
log('C', C);
log('D', D);
log('E', E);
log('F', F);
log('G', G);
log('H', H);
log('I', I);
log('J', J);
log('K', K);
log('L', L);
log('M', M);
log2('N', N);

This is presentation of solutions - not benchmark

Javascript不支持二维数组，相反，我们将一个数组存储在另一个数组中，然后根据要访问该数组的位置从该数组中获取数据。请记住，数组计算从ZERO开始。

代码示例：

/* Two dimensional array that's 5 x 5 

       C0 C1 C2 C3 C4 
    R0[1][1][1][1][1] 
    R1[1][1][1][1][1] 
    R2[1][1][1][1][1] 
    R3[1][1][1][1][1] 
    R4[1][1][1][1][1] 
*/

var row0 = [1,1,1,1,1],
    row1 = [1,1,1,1,1],
    row2 = [1,1,1,1,1],
    row3 = [1,1,1,1,1],
    row4 = [1,1,1,1,1];

var table = [row0,row1,row2,row3,row4];
console.log(table[0][0]); // Get the first item in the array

ES6 +，ES2015 +可以用更简单的方式做到这一点

创建3 x 2填充为true的数组

[...Array(3)].map(item => Array(2).fill(true))

我必须制作一个灵活的数组函数，以便根据需要向其中添加“记录”，并能够对其进行更新并进行所需的任何计算，然后再将其发送到数据库进行进一步处理。这是代码，希望对您有所帮助：)。

function Add2List(clmn1, clmn2, clmn3) {
    aColumns.push(clmn1,clmn2,clmn3); // Creates array with "record"
    aLine.splice(aPos, 0,aColumns);  // Inserts new "record" at position aPos in main array
    aColumns = [];    // Resets temporary array
    aPos++ // Increments position not to overlap previous "records"
}

随时优化和/或指出任何错误:)

我发现这是制作二维数组的一种快速方法。

function createArray(x, y) {
    return Array.apply(null, Array(x)).map(e => Array(y));
}

您也可以轻松地将此功能转换为ES5功能。

function createArray(x, y) {
    return Array.apply(null, Array(x)).map(function(e) {
        return Array(y);
    });
}

为何起作用：new Array(n)构造函数创建一个原型Array.prototype为的对象，然后分配该对象的length，从而导致未填充的数组。由于缺少实际成员，因此我们无法在其Array.prototype.map上运行该功能。

但是，当您向构造函数提供多个参数时（例如，当您提供时）Array(1, 2, 3, 4)，构造函数将使用该对象正确地arguments实例化并填充一个Array对象。

因此，我们可以使用Array.apply(null, Array(x))，因为该apply函数会将参数传播到构造函数中。为了澄清起见，做Array.apply(null, Array(3))等同于做Array(null, null, null)。

现在我们已经创建了一个实际的填充数组，我们所需要做的就是调用map并创建第二层（y）。

在下方，创建一个5x5矩阵并填充 null

var md = [];
for(var i=0; i<5; i++) {
    md.push(new Array(5).fill(null));
}

console.log(md);

只有在运行时才知道数组的行和列大小，然后可以使用以下方法创建动态2d数组。

var num = '123456';
var row = 3; // Known at run time
var col = 2; // Known at run time
var i = 0;

var array2D = [[]];
for(var r = 0; r < row; ++r)
{
    array2D[r] = [];
    for(var c = 0; c < col; ++c)
    {
        array2D[r][c] = num[i++];
    }
}
console.log(array2D); 
// [[ '1', '2' ], 
//  [ '3', '4' ], 
//  [ '5', '6' ]]

console.log(array2D[2][1]); // 6

还有另一种解决方案，它不强迫您预先定义2d数组的大小，这非常简洁。

var table = {}
table[[1,2]] = 3 // Notice the double [[ and ]]
console.log(table[[1,2]]) // -> 3

之所以起作用，[1,2]是因为将其转换为字符串，该字符串用作table对象的字符串键。

要创建4x6阵列，只需执行此操作

const x = [...Array(6)].map(elem => new Array(4))