1288

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

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

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

4

54 回答 54

1355 

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

于 2009-06-08T18:27:28.803 回答
487

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

var x = new Array(10);

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

console.log(x);

于 2009-06-08T18:28:58.537 回答
218

与 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)]
于 2009-06-08T20:49:18.583 回答
154

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

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> ] ])，但有一个问题：第一维数组已通过引用复制。这意味着 aarr[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-03-09T19:53:11.280 回答
92

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;
// ...
于 2009-06-08T18:32:00.467 回答
83

最简单的方法：

var myArray = [[]];
于 2013-01-22T18:47:57.463 回答
46

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

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

于 2009-06-08T18:33:44.817 回答
37

很少有人展示 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
于 2013-08-08T02:22:30.170 回答
29

两线：

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

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

于 2014-05-26T10:00:12.427 回答
28

最明智的答案似乎是

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

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

// 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);
于 2016-02-15T04:19:33.903 回答
23

最简单的方法：

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'
于 2013-12-27T08:59:10.193 回答
18

这就是我所取得的成就：

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

这拼写了我bineeshkumar

于 2016-05-18T15:16:10.930 回答
17

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

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

alert (arr[2][1]); //alerts "4"
于 2009-06-08T18:27:57.447 回答
17

表现

今天 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) 在 safari 上比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) 最慢

在此处输入图像描述

细节

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

我们测试解决方案的速度

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

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

我们测试解决方案的速度

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

在此处输入图像描述

于 2020-01-17T17:22:34.883 回答
15

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

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

例如：

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

例如，对于二维数组。

于 2012-07-01T03:28:50.897 回答
15

要创建一个所有索引可寻址且值设置为 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) 时间复杂度，因此它可能不适合非常大的数组。

于 2018-09-08T18:31:27.923 回答
15

要创建 4x6 数组，只需执行此操作

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

从空数组开始通常是一个好习惯，而不是填充 w 随机值。（您通常将数组声明为const x = []1D，因此最好在 2D 中开始 w 为空。）

于 2020-03-01T21:56:43.490 回答
13

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

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);
于 2014-06-25T11:38:43.043 回答
13

对于一个班轮爱好者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"))
于 2017-07-01T20:00:35.687 回答
11

使用数组理解

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

更多示例和文档可以在这里找到。

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

于 2016-08-11T17:33:39.750 回答
11 
Array(m).fill(v).map(() => Array(n).fill(v))

m x n您可以创建一个具有初始值的二维数组m，n可以是任何数字，v可以是任何值string, number, undefined。

一种方法可以是var a = [m][n]

于 2020-07-29T18:49:51.590 回答
9

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

    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

于 2019-09-27T16:19:17.967 回答
8

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

var array1 = [[]];   
array1[0][100] = 5; 
    
alert(array1[0][100]);
alert(array1.length);
alert(array1[0].length);

于 2014-04-15T09:14:47.127 回答
8

我的方法与@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
于 2016-12-04T04:36:48.977 回答
6

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

代码示例：

/* 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
于 2015-07-30T23:53:01.623 回答
6 

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

于 2017-10-03T15:22:59.697 回答
6

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

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

[...Array(3)].map(item => Array(2).fill(true))
于 2019-12-09T22:04:17.653 回答
5

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

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

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

于 2012-10-12T10:59:19.343 回答
5

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

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函数会将参数传播到构造函数中。为了澄清，doingArray.apply(null, Array(3))等同于doing Array(null, null, null)。

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

于 2016-03-25T05:56:18.570 回答
5

下面一个，创建一个 5x5 矩阵并用null

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

console.log(md);

于 2016-10-23T05:33:08.737 回答
5

一个创建填充为 0 的 am*n 二维数组的衬垫。

new Array(m).fill(new Array(n).fill(0));
于 2017-01-03T01:07:45.877 回答
5

还有另一种解决方案，它不会强制您预先定义二维数组的大小，而且非常简洁。

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

这是有效的，因为[1,2]它被转换为字符串，用作对象的字符串键table。

于 2018-01-22T01:58:03.150 回答
5

以下示例定义了一个名为活动的二维数组：

    let activities = [
        ['Work', 9],
        ['Eat', 1],
        ['Commute', 2],
        ['Play Game', 1],
        ['Sleep', 7]
    ];

在活动数组中，第一个维度表示活动，第二个维度显示每个活动每天花费的小时数。

要在控制台中显示活动数组，请使用 console.table() 方法，如下所示：

console.table(activities);

下面说明了输出：

┌─────────┬─────────────┬───┐
│ (index) │      0      │ 1 │
├─────────┼─────────────┼───┤
│    0    │   'Work'    │ 9 │
│    1    │    'Eat'    │ 1 │
│    2    │  'Commute'  │ 2 │
│    3    │ 'Play Game' │ 1 │
│    4    │   'Sleep'   │ 7 │
└─────────┴─────────────┴───┘

请注意，该(index)列用于说明内部数组的索引。

要访问多维数组的元素，首先使用方括号访问返回内部数组的外部数组的元素；然后使用另一个方括号访问内部数组的元素。

以下示例返回上述活动数组中第一个内部数组的第二个元素：

console.log(activities[0][1]); // 9

向 JavaScript 多维数组添加元素

您可以使用 Array 方法，例如push()和splice()来操作多维数组的元素。

例如，要在多维数组的末尾添加一个新元素，可以使用push()如下方法：

activities.push(['Study',2]);

┌─────────┬─────────────┬───┐
│ (index) │      0      │ 1 │
├─────────┼─────────────┼───┤
│    0    │   'Work'    │ 9 │
│    1    │    'Eat'    │ 1 │
│    2    │  'Commute'  │ 2 │
│    3    │ 'Play Game' │ 1 │
│    4    │   'Sleep'   │ 7 │
│    5    │   'Study'   │ 2 │
└─────────┴─────────────┴───┘

要在数组中间插入元素，请使用splice()方法。下面在活动数组的第二个位置插入一个元素：

activities.splice(1, 0, ['Programming', 2]);

┌─────────┬───────────────┬───┐
│ (index) │       0       │ 1 │
├─────────┼───────────────┼───┤
│    0    │    'Work'     │ 9 │
│    1    │ 'Programming' │ 2 │
│    2    │     'Eat'     │ 1 │
│    3    │   'Commute'   │ 2 │
│    4    │  'Play Game'  │ 1 │
│    5    │    'Sleep'    │ 7 │
│    6    │    'Study'    │ 2 │
└─────────┴───────────────┴───┘

此示例计算花费在每个活动上的小时数百分比，并将百分比附加到内部数组。

activities.forEach(activity => {
    let percentage = ((activity[1] / 24) * 100).toFixed();
    activity[2] = percentage + '%';
});

┌─────────┬───────────────┬───┬───────┐
│ (index) │       0       │ 1 │   2   │
├─────────┼───────────────┼───┼───────┤
│    0    │    'Work'     │ 9 │ '38%' │
│    1    │ 'Programming' │ 2 │ '8%'  │
│    2    │     'Eat'     │ 1 │ '4%'  │
│    3    │   'Commute'   │ 2 │ '8%'  │
│    4    │  'Play Game'  │ 1 │ '4%'  │
│    5    │    'Sleep'    │ 7 │ '29%' │
│    6    │    'Study'    │ 2 │ '8%'  │
└─────────┴───────────────┴───┴───────┘

从 JavaScript 多维数组中删除元素

要从数组中删除元素，请使用pop()orsplice()方法。

例如，以下语句删除活动数组的最后一个元素：

activities.pop();

┌─────────┬───────────────┬───┬───────┐
│ (index) │       0       │ 1 │   2   │
├─────────┼───────────────┼───┼───────┤
│    0    │    'Work'     │ 9 │ '38%' │
│    1    │ 'Programming' │ 2 │ '8%'  │
│    2    │     'Eat'     │ 1 │ '4%'  │
│    3    │   'Commute'   │ 2 │ '8%'  │
│    4    │  'Play Game'  │ 1 │ '4%'  │
│    5    │    'Sleep'    │ 7 │ '29%' │
└─────────┴───────────────┴───┴───────┘

pop()同样，您可以使用该方法从多维数组的内部数组中删除元素。以下示例从活动数组的内部数组中删除百分比元素。

activities.forEach((activity) => {
    activity.pop(2);
});

┌─────────┬───────────────┬───┐
│ (index) │       0       │ 1 │
├─────────┼───────────────┼───┤
│    0    │    'Work'     │ 9 │
│    1    │ 'Programming' │ 2 │
│    2    │     'Eat'     │ 1 │
│    3    │   'Commute'   │ 2 │
│    4    │  'Play Game'  │ 1 │
│    5    │    'Sleep'    │ 7 │
└─────────┴───────────────┴───┘

遍历 JavaScript 多维数组的元素

要迭代多维数组，请使用嵌套for循环，如下例所示。

// loop the outer array

for (let i = 0; i < activities.length; i++) {
    // get the size of the inner array
    var innerArrayLength = activities[i].length;
    // loop the inner array
    for (let j = 0; j < innerArrayLength; j++) {
        console.log('[' + i + ',' + j + '] = ' + activities[i][j]);
    }
}

第一个循环遍历外部数组的元素，嵌套循环遍历内部数组的元素。

下面显示了控制台中脚本的输出：

[0,0] = Work
[0,1] = 9
[1,0] = Eat
[1,1] = 1
[2,0] = Commute
[2,1] = 2
[3,0] = Play Game
[3,1] = 1
[4,0] = Sleep
[4,1] = 7
[5,0] = Study
[5,1] = 2

或者您可以使用该forEach()方法两次：

activities.forEach((activity) => {
    activity.forEach((data) => {
        console.log(data);
    });
});

Work
9
Eat
1
Commute
2
Play Game
1
Sleep
7
Study
2
于 2021-04-07T04:01:37.797 回答
3

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

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

于 2009-06-08T18:32:38.797 回答
3

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

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];
        }
    }
}
于 2014-06-14T15:46:56.410 回答
3

一个简化的例子：

var blocks = [];

blocks[0] = [];

blocks[0][0] = 7;
于 2015-09-21T05:17:32.287 回答
3

我不喜欢使用.fill(). 有些可能有效，但避免引用复制问题的额外箍使它们不直观。

我建议的 ES6 方法是充分利用扩展运算符来处理外部和内部数组。关于 IMO 的推理更容易。

[...Array(3)].map(() => [...Array(4)])

如果需要设置初始值，则.map()在内部数组创建上链接 a：

[...Array(3)].map(() => [...Array(4)].map(() => 0))

最后，一个类型安全的 TypeScript util 函数：

export const createMultiDimensionalArray = <T>(
  n: number,
  m: number,
  initialVal?: T,
): T[][] => {
  const matrix = [...Array(n)].map(() => [...Array(m)]);
  return initialVal === undefined
    ? matrix
    : matrix.map(r => r.map(() => initialVal));
};

使用它的例子：

const a = createMultiDimensionalArray(1, 2);
a[1][2] = 3;     // Works

const b = createMultiDimensionalArray(2, 3, false);
b[1][2] = true;  // Works
b[1][2] = 3;     // Error: Type '3' is not assignable to type 'boolean'.
于 2020-01-25T01:23:06.453 回答
2

我对Matthew Crumley的创建多维数组函数的答案进行了修改。我已经添加了要作为数组变量传递的数组的维度，并且会有另一个变量 - 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]]
于 2015-02-20T09:31:00.680 回答
2 
const arr = new Array(5).fill(new Array(5).fill(0));
console.log(arr);
于 2021-06-24T07:41:18.167 回答
1

创建多维数组的递归函数：

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

    arr = new Array(dims[0]);

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

    return arr;
}

构建一个 2x3x4x2 4D 阵列：

var array = makeArray([2, 3, 4, 2]);
于 2015-04-19T15:13:38.363 回答
1

您还可以创建一个函数来创建一个二维数组，如下所示：

var myTable = [];

function createArray(myLength) {
    myTable = new Array(myLength);
    var cols, rows;
    for (cols = 0; cols < myLength; cols++) {
        myTable[cols] = new Array(myLength);
    }
}

您可以使用以下命令调用它，这将为您提供 10x10 2D 数组。

createArray(10);

您也可以使用此方法创建 3D 阵列。

于 2015-09-24T12:07:44.150 回答
1

nodejs + lodash版本：

var _ = require("lodash");
var result = _.chunk(['a', 'b', 'c', 'd', 'e', 'f'], 2);
console.log(result);
console.log(result[2][0]);

输出：

[ [ 'a', 'b' ], [ 'c', 'd' ], [ 'e', 'f' ] ]
e
于 2015-12-26T20:38:20.160 回答
1 
Array.from({length: rows}).map(e => new Array(columns));
于 2019-06-08T20:04:20.187 回答
1 
 var items = [
      ["January 01", 42.5],
      ["February 01",  44.3],
      ["March 01",  28.7],
      ["April 01",  44.3],
      ["May 01",  22.9],
      ["June 01",  54.4],
      ["July 01",  69.3],
      ["August 01",  19.1],
      ["September 01",  82.5],
      ["October 01",  53.2],
      ["November 01",  75.9],
      ["December 01",  58.7]

    ];
  alert(items[1][0]); // February 01
  alert(items[5][1]); // 54.4
于 2019-07-20T11:29:49.440 回答
1

使用全局对象 Array 并用数组填充项目：

let arr = new Array(5).fill([]);

或者如果已知长度的二维数组：

let arr = new Array(5).fill(new Array(2));
于 2021-07-27T08:48:34.587 回答
0

如果你在谷歌图表的二维数组之后，最好的方法是

var finalData = [];
[["key",value], ["2013-8-5", 13.5], ["2013-7-29",19.7]...]

指的是 不是有效的二维数组谷歌图表

于 2013-11-21T01:33:43.350 回答
0 
var _field = (function()
{
    var array = [];
    for(var y = 0; y != 3; y++) { array[y] = new Array(5); }
    return array;
})();

// var item = _field[2][4];
于 2014-04-03T20:54:58.890 回答
0

如果数组的大小未知，会发生什么？还是应该动态创建和填充数组？对我有用的替代解决方案是使用带有静态二维数组变量的类，如果数组中不存在索引，它将启动它：

function _a(x,y,val){
    // return depending on parameters
    switch(arguments.length){
        case 0: return _a.a;
        case 1: return _a.a[x];
        case 2: return _a.a[x][y];
    }

    // declare array if wasn't declared yet
    if(typeof _a.a[x] == 'undefined')
        _a.a[x] = [];

    _a.a[x][y] = val;
}
// declare static empty variable
_a.a = [];

语法将是：

_a(1,1,2); // populates [1][1] with value 2
_a(1,1);   // 2 or alternative syntax _a.a[1][1]
_a(1);     // [undefined × 1, 2]
_a.a;      // [undefined × 1, Array[2]]
_a.a.length
于 2014-04-08T20:43:42.343 回答
0

这里有一个很棒的存储库。

  • 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)
于 2015-11-09T23:40:06.707 回答
0

一些评论中提到了这一点，但使用 Array.fill() 将有助于构造一个二维数组：

function create2dArr(x,y) {
    var arr = [];
    for(var i = 0; i < y; i++) {
        arr.push(Array(x).fill(0));
    }
    return arr; 
}

这将在返回的数组中产生一个长度为 x, y 次的数组。

于 2017-05-19T16:27:32.333 回答
0

这是我对多维数组的实现。

在这种方法中，我正在创建一个单维数组

我已经multi为Array对象添加了一个原型函数，它可以用来创建任何维度的数组。

我还index为Array对象添加了一个原型函数，可用于从多维索引中获取线性数组中的索引。

创建数组

//Equivalent to arr[I][J][K]..[] in C
var arr = new Array().multi(I,J,K,..);

在任何索引处访问数组值

//Equivalent in C arr[i][j][k];
var vaue = arr[arr.index(i,j,k)];

片段

/*
   Storing array as single dimension 
   and access using Array.index(i,j,k,...)
*/


Array.prototype.multi = function(){
 this.multi_size = arguments;
 this.multi_len = 1
 for(key in arguments) this.multi_len *=  arguments[key];
 for(var i=0;i<this.multi_len;i++) this.push(0);
 return this;
}

Array.prototype.index = function(){
   var _size = this.multi_len;
   var temp = 1;
   var index = 0;
   for(key in arguments) {
      temp*=this.multi_size[key];
      index+=(arguments[key]*(_size/temp))
   }
   return index;
}

// Now you can use the multi dimension array
// A 3x3 2D Matrix

var arr2d = new Array().multi(3,3); // A 2D Array
arr2d[arr2d.index(1,1,1)]  = 5;
console.log(arr2d[arr2d.index(1,1,1)]);

// A 3x3x3 3D Matrix

var arr3d = new Array().multi(3,3,3); // a 3D Array
arr3d[arr3d.index(1,1,1)]  = 5;
console.log(arr3d[arr3d.index(1,1,1)]);

// A 4x3x3 4D Matrix
var arr4d = new Array().multi(4,3,3,3); // a 4D Array
arr4d[arr4d.index(4,0,0,1)]  = 5;
console.log(arr4d[arr4d.index(4,0,0,1)]);

于 2017-08-06T12:37:43.693 回答
0

如果您想要的只是一个 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 并且在您遍历它时无法正确运行，因此请小心处理。

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

于 2017-12-23T10:29:09.567 回答
0

为 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)
于 2019-09-16T17:46:43.683 回答
-1

我的解决方案不会是最好的，但只是提供我的解决方案来创建用户定义的多维数组。

这个函数接受行和列，

function createArray(row,column) {
let arr = [];

for(var i=0; i<row; i++){
    arr[i] = [Math.floor(Math.random() * (10))];

    for(var j=0;j<column;j++){
        arr[i][j]= [Math.floor(Math.random() * (20))];
    }
}

return arr;
}

var arrVal = createArray(4, 5);

console.log(arrVal);
于 2021-08-17T05:50:10.187 回答