Tôi đã đọc trực tuyến và một số nơi nói rằng điều đó là không thể, một số người nói điều đó và sau đó đưa ra một ví dụ và những người khác bác bỏ ví dụ, v.v.

1. Làm cách nào để khai báo mảng 2 chiều trong JavaScript? (giả sử là có thể)

2. Làm thế nào tôi có thể truy cập các thành viên của nó? ( myArray[0][1]hoặc myArray[0,1]?)

Bạn chỉ cần làm cho mỗi mục trong mảng là một mảng.

var x = new Array(10);

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

console.log(x);

Tương tự như câu trả lời của activa, đây là một hàm để tạo một mảng n chiều:

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 chỉ có mảng 1 chiều, nhưng bạn có thể xây dựng mảng mảng, như những người khác đã chỉ ra.

Hàm sau có thể được sử dụng để xây dựng một mảng 2 chiều có kích thước cố định:

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

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

  return arr;
}

Số lượng cột không thực sự quan trọng, vì không bắt buộc phải chỉ định kích thước của một mảng trước khi sử dụng nó.

Sau đó, bạn có thể chỉ cần gọi:

var arr = Create2DArray(100);

arr[50][2] = 5;
arr[70][5] = 7454;
// ...

Cách dễ nhất:

var myArray = [[]];

Cách tạo một mảng hai chiều trống (một dòng)

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

2 và 4 lần lượt là kích thước thứ nhất và thứ hai.

Chúng tôi đang sử dụng Array.from, có thể lấy tham số giống như mảng và ánh xạ tùy chọn cho từng thành phần.

Array.from (mảngLike [, mapFn [, thisArg]])

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

Thủ thuật tương tự có thể được sử dụng để Tạo một mảng JavaScript chứa 1 ... N

Cách khác (nhưng không hiệu quả hơn 12% với n = 10,000)

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

Việc giảm hiệu suất đi kèm với thực tế là chúng ta phải có các giá trị thứ nguyên đầu tiên được khởi tạo để chạy .map. Hãy nhớ rằng Arraysẽ không phân bổ các vị trí cho đến khi bạn đặt nó qua .fillhoặc gán giá trị trực tiếp.

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

Theo sát

Đây là một phương pháp có vẻ đúng, nhưng có vấn đề .

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

Mặc dù nó trả về mảng hai chiều rõ ràng mong muốn ( [ [ <4 empty items> ], [ <4 empty items> ] ]), nhưng có một nhược điểm: mảng thứ nguyên đầu tiên đã được sao chép bằng tham chiếu. Điều đó có nghĩa là arr[0][0] = 'foo'thực sự sẽ thay đổi hai hàng thay vì một.

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

Lý do một số người nói rằng điều đó là không thể bởi vì một mảng hai chiều thực sự chỉ là một mảng của các mảng. Các ý kiến ​​khác ở đây cung cấp các phương pháp hoàn toàn hợp lệ để tạo các mảng hai chiều trong JavaScript, nhưng quan điểm thuần túy nhất là bạn có một mảng các đối tượng, mỗi đối tượng sẽ là một mảng một chiều gồm hai phần tử.

Vì vậy, đó là nguyên nhân của các quan điểm mâu thuẫn.

Rất ít người chỉ ra cách sử dụng đẩy:
Để mang đến một cái gì đó mới, tôi sẽ chỉ cho bạn cách khởi tạo ma trận với một số giá trị, ví dụ: 0 hoặc một chuỗi rỗng "".
Nhắc nhở rằng nếu bạn có mảng 10 phần tử, trong javascript, chỉ mục cuối cùng sẽ là 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;
}

ví dụ sử dụng:

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

Hai lớp lót:

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

Nó sẽ tạo ra một mảng a có độ dài 10, chứa đầy các mảng. (Đẩy thêm một phần tử vào một mảng và trả về độ dài mới)

Câu trả lời rõ ràng nhất là

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

Lưu ý rằng chúng ta không thể điền trực tiếp vào các hàng vì điền sử dụng hàm tạo sao chép nông, do đó tất cả các hàng sẽ chia sẻ cùng một bộ nhớ ... đây là ví dụ minh họa cách mỗi hàng sẽ được chia sẻ (lấy từ các câu trả lời khác):

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

Cách dễ nhất:

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'

Đây là những gì tôi đạt được:

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

Điều này đánh vần tôi bineeshkumar

Mảng hai chiều được tạo ra giống như cách mảng đơn chiều. Và bạn truy cập chúng như thế nào array[0][1].

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

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

Tôi không chắc có ai trả lời được không nhưng tôi thấy điều này hiệu quả với tôi khá nhiều -

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

ví dụ:

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

Ví dụ, đối với mảng 2 chiều.

Để tạo một mảng 2D trong javaScript, trước tiên chúng ta có thể tạo một mảng và sau đó thêm Mảng như các phần tử của nó. Phương thức này sẽ trả về một mảng 2D với số lượng hàng và cột đã cho.

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

để tạo một Array sử dụng phương thức này như dưới đây.

var array = Create2DArray(10,20);

Để tạo một mảng "2D" không thưa thớt (x, y) với tất cả các chỉ mục có thể định địa chỉ và các giá trị được đặt thành null:

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

Phần thưởng "3D" (x, y, z)

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

Biến thể và sửa chữa về điều này đã được đề cập trong các ý kiến ​​và tại các điểm khác nhau để trả lời cho câu hỏi này nhưng không phải là một câu trả lời thực tế vì vậy tôi đang thêm nó ở đây.

Cần lưu ý rằng (tương tự như hầu hết các câu trả lời khác) điều này có độ phức tạp thời gian O (x * y) nên có lẽ nó không phù hợp với các mảng rất lớn.

Sử dụng mảng hiểu

Trong JavaScript 1.7 trở lên, bạn có thể sử dụng khả năng hiểu mảng để tạo mảng hai chiều. Bạn cũng có thể lọc và / hoặc thao tác các mục trong khi điền vào mảng và không phải sử dụng các vòng lặp.

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

Bạn có thể tạo bất kỳ n x mmảng nào bạn muốn và điền nó với một giá trị mặc định bằng cách gọi

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

Nhiều ví dụ và tài liệu có thể được tìm thấy ở đây .

Xin lưu ý rằng đây chưa phải là một tính năng tiêu chuẩn .

Đối với một người yêu thích lót Array.from ()

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

Một số khác (từ nhận xét của dmitry_romanov) sử dụng Array (). Fill ()

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

Sử dụng toán tử trải rộng ES6 + ("lấy cảm hứng" từ câu trả lời của InspiredJW :))

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

Cách tiếp cận của tôi rất giống với câu trả lời @Bineesh nhưng với cách tiếp cận tổng quát hơn.

Bạn có thể khai báo mảng kép như sau:

var myDoubleArray = [[]];

Và việc lưu trữ và truy cập nội dung theo cách sau:

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'],) 

Điều này sẽ in đầu ra dự kiến

[ 9, 8 ] 9 123

Tôi tìm thấy dưới đây là cách đơn giản nhất:

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

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

Hiệu suất

Hôm nay 2020.02.05 Tôi thực hiện các thử nghiệm trên MacOs HighSierra 10.13.6 trên Chrome v79.0, Safari v13.0.4 và Firefox v72.0, cho các giải pháp được chọn.

Kết luận cho mảng 2d không khởi tạo

• giải pháp bí truyền {}/arr[[i,j]](N) là nhanh nhất cho các mảng lớn và nhỏ và có vẻ như nó là lựa chọn tốt cho các mảng lớn thưa thớt
• các giải pháp dựa trên for-[]/while(A, G) là nhanh chóng và chúng là lựa chọn tốt cho các mảng nhỏ.
• các giải pháp for-[](B, C) là nhanh chóng và chúng là lựa chọn tốt cho các mảng lớn
• các giải pháp dựa trên Array..map/from/fill(I, J, K, L, M) khá chậm đối với các mảng nhỏ và khá nhanh đối với các mảng lớn
• Thật đáng ngạc nhiên for-Array(n)(B, C) trên safari chậm hơn nhiều so với for-[](A)
• Thật ngạc nhiên for-[](A) cho mảng lớn chậm trên tất cả các trình duyệt
• giải pháp K chậm đối với mảng nhỏ cho tất cả các trình duyệt
• các giải pháp A, E, G chậm cho các mảng lớn cho tất cả các trình duyệt
• giải pháp M chậm nhất cho tất cả các mảng trên tất cả các trình duyệt

Kết luận cho mảng 2d khởi tạo

• các giải pháp dựa trên for/while(A, B, C, D, E, G) là nhanh nhất / khá nhanh đối với các mảng nhỏ trên tất cả các trình duyệt
• các giải pháp dựa trên for(A, B, C, E) là nhanh nhất / khá nhanh cho các mảng lớn trên tất cả các trình duyệt
• các giải pháp dựa trên Array..map/from/fill(I, J, K, L, M) là trung bình nhanh hoặc chậm đối với các mảng nhỏ trên tất cả các trình duyệt
• các giải pháp F, G, H, I, J, K, L cho các mảng lớn là trung bình hoặc nhanh trên chrome và safari nhưng chậm nhất trên firefox.
• giải pháp bí truyền {}/arr[[i,j]](N) là chậm nhất đối với các mảng nhỏ và lớn trên tất cả các trình duyệt

Chi tiết

Kiểm tra các giải pháp không lấp đầy (khởi tạo) mảng đầu ra

Chúng tôi kiểm tra tốc độ của các giải pháp cho

• mảng nhỏ (12 yếu tố) - bạn có thể thực hiện kiểm tra trên máy của mình TẠI ĐÂY
• mảng lớn (1 triệu phần tử) mảng - bạn có thể thực hiện kiểm tra trên máy của mình TẠI ĐÂY

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

Kiểm tra các giải pháp điền vào mảng đầu ra (khởi tạo)

Chúng tôi kiểm tra tốc độ của các giải pháp cho

• mảng nhỏ (12 yếu tố) - bạn có thể thực hiện kiểm tra trên máy của mình TẠI ĐÂY
• mảng lớn (1 triệu phần tử) mảng - bạn có thể thực hiện kiểm tra trên máy của mình TẠI ĐÂY

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 không hỗ trợ mảng hai chiều, thay vào đó chúng tôi lưu trữ một mảng bên trong mảng khác và tìm nạp dữ liệu từ mảng đó tùy thuộc vào vị trí của mảng đó bạn muốn truy cập. Ghi nhớ số mảng bắt đầu từ ZERO .

Mã ví dụ:

/* 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 + có thể làm điều này theo cách đơn giản hơn

Tạo 3 x 2 Mảng chứa đầy sự thật

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

Tôi đã phải tạo một hàm mảng linh hoạt để thêm "bản ghi" vào nó khi tôi cần và để có thể cập nhật chúng và làm bất kỳ phép tính nào tôi cần trước khi tôi gửi nó đến cơ sở dữ liệu để xử lý thêm. Đây là mã, hy vọng nó sẽ giúp :).

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

Vui lòng tối ưu hóa và / hoặc chỉ ra bất kỳ lỗi nào :)

Đây là một cách nhanh chóng mà tôi đã tìm thấy để tạo một mảng hai chiều.

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

Bạn cũng có thể dễ dàng biến chức năng này thành chức năng ES5.

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

Tại sao điều này hoạt động: hàm new Array(n)tạo tạo một đối tượng với nguyên mẫu Array.prototypevà sau đó gán cho đối tượng length, dẫn đến một mảng không được điền. Do thiếu thành viên thực tế, chúng tôi không thể chạy Array.prototype.mapchức năng trên nó.

Tuy nhiên, khi bạn cung cấp nhiều hơn một đối số cho hàm tạo, chẳng hạn như khi bạn thực hiện Array(1, 2, 3, 4), hàm tạo sẽ sử dụng argumentsđối tượng để khởi tạo và điền Arraychính xác một đối tượng.

Vì lý do này, chúng ta có thể sử dụng Array.apply(null, Array(x)), bởi vì applyhàm sẽ truyền bá các đối số vào hàm tạo. Để làm rõ, làm Array.apply(null, Array(3))là tương đương với làm Array(null, null, null).

Bây giờ chúng ta đã tạo một mảng dân cư thực tế, tất cả những gì chúng ta cần làm là gọi mapvà tạo lớp thứ hai ( y).

Bên dưới một, tạo một ma trận 5x5 và điền chúng với null

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

console.log(md);

Kích thước hàng và cột của một mảng chỉ được biết đến tại thời điểm chạy, sau đó phương thức sau có thể được sử dụng để tạo mảng 2d động .

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

Có một giải pháp khác, đó là không bắt buộc bạn phải xác định trước kích thước của mảng 2d và điều đó rất súc tích.

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

Điều này hoạt động bởi vì, [1,2]được chuyển đổi thành một chuỗi, được sử dụng làm khóa chuỗi cho tableđối tượng.

Để tạo một mảng 4x6, chỉ cần làm điều này

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