如何在JavaScript中创建二维数组？

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

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

我如何访问其成员？（

myArray[0][1]

或

myArray[0,1]

？）

var项目=[
[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.
控制台日志（项目）创建二维数组的方法与创建一维数组的方法相同。您可以像
数组[0][1]
一样访问它们

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

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

您只需将数组中的每个项设置为一个数组


var x=新数组（10）；
对于（变量i=0；i控制台日志（x）Javascript只有一维数组，但正如其他人指出的，您可以构建数组数组

以下函数可用于构造固定尺寸的二维数组：

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

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

  return arr;
}

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

所以，这就是观点冲突的原因
 与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)]

我不确定是否有人回答了这个问题，但我发现这对我来说非常有效-

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

例如：

例如，对于二维数组
 我必须制作一个灵活的数组函数，根据需要向其中添加“记录”，并能够在将其发送到数据库进行进一步处理之前更新它们并执行所需的任何计算。以下是代码，希望对您有所帮助：）

请随意优化和/或指出任何错误：）
最简单的方法：

var myArray = [[]];

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'

很少有人使用推送：

要带来一些新内容，我将向您展示如何使用一些值初始化矩阵，例如：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;
}

最简单的方法：

var myArray = [[]];

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 array1=[[]]；
阵列1[0][100]=5；
警报（阵列1[0][100]）；
警报（阵列1.长度）；
警报（数组1[0]。长度）两个衬里：

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

var a=[]；
而（a.push（[]）<10）；

它将生成一个长度为10的数组a，并填充数组。
（Push向数组中添加一个元素并返回新的长度）
要在javaScript中创建2D数组，我们可以先创建一个数组，然后添加数组作为其元素。此方法将返回具有给定行数和列数的二维数组

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

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

代码示例：

/* 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

最明智的答案似乎是


var nrows=~~（Math.random（）*10）；
var ncols=~~（Math.random（）*10）；
log（`rows:${nrows}`）；
log（`cols:${ncols}`）；
var矩阵=新数组（nrows）.fill（0）.map（行=>新数组（ncols）.fill（0））；
控制台日志（矩阵）我发现了一种快速制作二维数组的方法

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

工作原理：
新数组（n）
构造函数创建一个原型为
数组的对象。原型
，然后分配对象的
长度
，从而生成一个未填充的数组。由于缺少实际成员，我们无法在其上运行
Array.prototype.map
函数

但是，当您向构造函数提供多个参数时，例如当您执行
数组（1、2、3、4）
时，构造函数将使用
参数
对象来正确实例化和填充
数组
对象

出于这个原因，我们可以使用
Array.apply（null，Array（x））
，因为
apply
函数将参数分散到构造函数中。为了澄清，执行
Array.apply（null，Array（3））
相当于执行
Array（null，null，null）

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


var-appVar=[[]]；
appVar[0][4]=“bineesh”；
appVar[0][5]=“kumar”；
log（appVar[0][4]+appVar[0][5]）；
console.log（appVar）使用数组理解
在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"]
         ]
*/

您可以创建所需的任何
nxm
数组，并通过调用

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],
         ]
*/

可以找到更多的示例和文档

请注意，这还不是一个标准功能。
我的方法与@Bineesh answer非常相似，但采用了更通用的方法

可以按如下方式声明双数组：

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

一个用于创建填充有0的m*n二维数组的线条

new Array(m).fill(new Array(n).fill(0));

为一艘邮轮爱好者

另一个（来自dmitry_romanov的评论）使用

使用ES6+运算符（“受InspiredJW启发”））


var播放列表=[
[“我是按我的方式做的”，“Frank Sinatra”]，
[“尊敬”，“阿瑞莎·富兰克林”]，
[“想象”，“约翰·列侬”]，
[“生来就是要跑的”，“Br”
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

new Array(m).fill(new Array(n).fill(0));

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

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

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

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

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

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

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

Array(m).fill(v).map(() => Array(n).fill(v))