如何在JavaScript中创建二维数组？-Java 学习之路

969

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

如何在JavaScript中声明二维数组？（假设有可能）
我如何访问其成员？（ myArray[0][1] 或 myArray[0,1] ？）

30 回答

Javascript不支持二维数组，而是将数组存储在另一个数组中，并根据您要访问的数组的位置从该数组中获取数据 . 记住数组计算从 ZERO 开始 .

Code Example:

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

回复于 2018-12-13T12:04:02+00:00

384
这是我发现制作二维数组的快速方法 .
```
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 ） .
回复于 2018-12-13T12:04:02+00:00
72
如何创建空的二维数组（单行）
```
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);
```
同样的技巧可用于Create a JavaScript array containing 1...N

或者（但效率更低12％，n = 10,000）
```
Array(2).fill(null).map(() => Array(4))
```
性能下降是因为我们必须将第一个维度值初始化为运行 .map . 请记住，在您通过 .fill 或直接赋值进行订购之前， Array 不会分配位置 .
```
var arr = Array(2).fill(null).map(() => Array(4));
arr[0][0] = 'foo';
console.info(arr);
```
跟进

为什么这不起作用？
```
Array(2).fill(Array(4));
```
虽然它确实返回了显然需要的二维数组（ [ [ <4 empty items> ], [ <4 empty items> ] ] ），但有一个问题：第一维数组已经通过引用复制了 . 这意味着 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]);
```
回复于 2018-12-13T12:04:02+00:00

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

var x = new Array(10);

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

console.log(x);

回复于 2018-12-13T12:04:02+00:00

167
二维数组的创建方式与单维数组相同 . 你可以像_454760那样访问它们 .
```
var arr = [1, 2, [3, 4], 5];

alert (arr[2][1]); //alerts "4"
```
回复于 2018-12-13T12:04:02+00:00

最简单的方法：

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'

回复于 2018-12-13T12:04:02+00:00

26
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;
// ...
```
回复于 2018-12-13T12:04:02+00:00

我的方法与@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

回复于 2018-12-13T12:04:02+00:00

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

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

console.log(md);

回复于 2018-12-13T12:04:02+00:00

41
一个衬垫用于创建填充0的m * n 2维阵列 .
```
new Array(m).fill(new Array(n).fill(0));
```
回复于 2018-12-13T12:04:02+00:00

使用数组理解

在JavaScript 1.7及更高版本中，您可以使用 array comprehensions 创建二维数组 . 您还可以在填充数组时过滤和/或操作条目，而不必使用循环 .

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

可以找到更多示例和文档here .

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

回复于 2018-12-13T12:04:02+00:00

我已经修改了Matthew Crumley 's answer for creating a multidimensional array function. I' ve添加了要作为数组变量传递的数组的维度，还有另一个变量 value ，它将用于设置多维数组中最后一个数组的元素值 .

/*
*   Function to create an n-dimensional array
*
*   @param array dimensions
*   @param any type value
*
*   @return array array
 */
function createArray(dimensions, value) {
    // Create new array
    var array = new Array(dimensions[0] || 0);
    var i = dimensions[0];

    // If dimensions array's length is bigger than 1
    // we start creating arrays in the array elements with recursions
    // to achieve multidimensional array
    if (dimensions.length > 1) {
        // Remove the first value from the array
        var args = Array.prototype.slice.call(dimensions, 1);
        // For each index in the created array create a new array with recursion
        while(i--) {
            array[dimensions[0]-1 - i] = createArray(args, value);
        }
    // If there is only one element left in the dimensions array
    // assign value to each of the new array's elements if value is set as param
    } else {
        if (typeof value !== 'undefined') {
            while(i--) {
                array[dimensions[0]-1 - i] = value;
            }
        }
    }

    return array;
}

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

createArray([2], 'empty');    // ['empty', 'empty']

createArray([3, 2], 0);       // [[0, 0],
                              //  [0, 0],
                              //  [0, 0]]

回复于 2018-12-13T12:04:02+00:00

4

您可以分配一个行数组，其中每一行都是一个长度相同的数组 . 或者，您可以使用行*列元素分配一维数组，并定义将行/列坐标映射到元素索引的方法 .

无论您选择哪种实现，如果将其包装在对象中，您都可以在原型中定义访问器方法，以使API易于使用 .

回复于 2018-12-13T12:04:02+00:00
2
要在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);
```
回复于 2018-12-13T12:04:02+00:00
63
一个简化的例子：
```
var blocks = [];

blocks[0] = [];

blocks[0][0] = 7;
```
回复于 2018-12-13T12:04:02+00:00

很少有人表示使用推送：
为了带来新的东西，我将向您展示如何使用一些值初始化矩阵，例如：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

回复于 2018-12-13T12:04:02+00:00

我必须制作一个灵活的数组函数，以便根据需要为其添加“记录”，并能够更新它们，并在将其发送到数据库进行进一步处理之前进行所需的任何计算 . 这是代码，希望它有帮助:) .

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"
}

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

回复于 2018-12-13T12:04:02+00:00

10
最简单的方法：
```
var myArray = [[]];
```
回复于 2018-12-13T12:04:02+00:00

最苛刻的答案似乎是

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

注意我们不能 directly 填充行，因为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);

回复于 2018-12-13T12:04:02+00:00

8
要创建一个非稀疏的“2D”数组（x，y），其中所有索引都是可寻址的，并且值设置为null：
```
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）时间复杂度，因此它可能不适合非常大的阵列 .
回复于 2018-12-13T12:04:02+00:00

与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)]

回复于 2018-12-13T12:04:02+00:00

19

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

所以，这是观点冲突的原因 .

回复于 2018-12-13T12:04:02+00:00

var playList = [
  ['I Did It My Way', 'Frank Sinatra'],
  ['Respect', 'Aretha Franklin'],
  ['Imagine', 'John Lennon'],
  ['Born to Run', 'Bruce Springsteen'],
  ['Louie Louie', 'The Kingsmen'],
  ['Maybellene', 'Chuck Berry']
];

function print(message) {
  document.write(message);
}

function printSongs( songs ) {
  var listHTML = '<ol>';
  for ( var i = 0; i < songs.length; i += 1) {
    listHTML += '<li>' + songs[i][0] + ' by ' + songs[i][1] + '</li>';
  }
  listHTML += '</ol>';
  print(listHTML);
}

printSongs(playList);

回复于 2018-12-13T12:04:02+00:00

这就是我所取得的成就：

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

这拼写了我bineeshkumar

回复于 2018-12-13T12:04:02+00:00

var items = [
  [1, 2],
  [3, 4],
  [5, 6]
];
console.log(items[0][0]); // 1
console.log(items);

回复于 2018-12-13T12:04:02+00:00

1112

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

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

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

回复于 2018-12-13T12:04:02+00:00

我发现这段代码对我有用：

var map = [
    []
];

mapWidth = 50;
mapHeight = 50;
fillEmptyMap(map, mapWidth, mapHeight);

...

function fillEmptyMap(array, width, height) {
    for (var x = 0; x < width; x++) {
        array[x] = [];
        for (var y = 0; y < height; y++) {

            array[x][y] = [0];
        }
    }
}

回复于 2018-12-13T12:04:02+00:00

2
双内胆：
```
var a = []; 
while(a.push([]) < 10);
```
它将生成一个长度为10的数组a，其中包含数组 . （Push将一个元素添加到数组并返回新的长度）
回复于 2018-12-13T12:04:02+00:00

对于一位班轮爱好者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"));

回复于 2018-12-13T12:04:02+00:00

2
我不确定是否有人回答过此问题，但我发现这对我很有帮助 -
```
var array = [[,],[,]]
```
例如：
```
var a = [[1,2],[3,4]]
```
例如，对于二维阵列 .
回复于 2018-12-13T12:04:02+00:00

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

30 回答

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

或者（但效率更低12％，n = 10,000）

跟进

使用数组理解

相关问题