Saya telah membaca online dan beberapa tempat mengatakan itu tidak mungkin, beberapa mengatakan itu dan kemudian memberikan contoh dan yang lain menyangkal contohnya, dll.

1. Bagaimana cara mendeklarasikan array 2 dimensi dalam JavaScript? (dengan asumsi itu mungkin)

2. Bagaimana saya mengakses anggotanya? ( myArray[0][1]atau myArray[0,1]?)

Anda cukup membuat setiap item dalam array menjadi array.

var x = new Array(10);

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

console.log(x);

Mirip dengan jawaban activa, berikut adalah fungsi untuk membuat array n-dimensi:

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 hanya memiliki array 1 dimensi, tetapi Anda dapat membangun array array, seperti yang ditunjukkan orang lain.

Fungsi berikut dapat digunakan untuk membangun array 2-dimensi tetap:

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

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

  return arr;
}

Jumlah kolom tidak terlalu penting, karena tidak diperlukan untuk menentukan ukuran array sebelum menggunakannya.

Maka Anda bisa langsung menelepon:

var arr = Create2DArray(100);

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

Cara termudah:

var myArray = [[]];

Cara membuat array dua dimensi kosong (satu baris)

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

2 dan 4 masing-masing menjadi dimensi pertama dan kedua.

Kami memanfaatkan Array.from, yang dapat mengambil param seperti array dan pemetaan opsional untuk masing-masing elemen.

Array.from (arrayLike [, mapFn [, thisArg]])

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

Trik yang sama dapat digunakan untuk Membuat array JavaScript yang berisi 1 ... N

Atau (tetapi lebih tidak efisien 12% dengan n = 10,000)

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

Penurunan kinerja datang dengan fakta bahwa kita harus memiliki nilai dimensi pertama yang diinisialisasi untuk dijalankan .map. Ingatlah bahwa Arraytidak akan mengalokasikan posisi sampai Anda memesannya melalui .fillatau menentukan nilai langsung.

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

Mengikuti

Berikut adalah metode yang tampak benar, tetapi memiliki masalah .

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

Sementara itu mengembalikan array dua dimensi yang tampaknya diinginkan ( [ [ <4 empty items> ], [ <4 empty items> ] ]), ada tangkapan: array dimensi pertama telah disalin oleh referensi. Itu berarti arr[0][0] = 'foo'benar-benar akan mengubah dua baris, bukan satu.

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

Alasan beberapa orang mengatakan bahwa itu tidak mungkin adalah karena array dua dimensi sebenarnya hanya sebuah array array. Komentar lain di sini memberikan metode yang benar-benar valid untuk membuat array dua dimensi dalam JavaScript, tetapi sudut pandang paling murni adalah bahwa Anda memiliki array objek satu dimensi, masing-masing objek tersebut akan menjadi array satu dimensi yang terdiri dari dua elemen.

Jadi, itulah penyebab titik pandang yang saling bertentangan.

Beberapa orang menunjukkan penggunaan push:
Untuk membawa sesuatu yang baru, saya akan menunjukkan kepada Anda bagaimana menginisialisasi matriks dengan beberapa nilai, contoh: 0 atau string kosong "".
Mengingatkan bahwa jika Anda memiliki array 10 elemen, dalam javascript indeks terakhir akan menjadi 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;
}

contoh penggunaan:

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

Dua lapisan:

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

Ini akan menghasilkan array a dengan panjang 10, diisi dengan array. (Push menambahkan elemen ke array dan mengembalikan panjang baru)

Sepertinya jawaban paling jernih

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

Catatan kita tidak bisa langsung mengisi dengan baris karena isi menggunakan konstruktor copy dangkal, oleh karena itu semua baris akan berbagi memori yang sama ... di sini adalah contoh yang menunjukkan bagaimana setiap baris akan dibagi (diambil dari jawaban lain):

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

Cara termudah:

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'

Inilah yang saya raih:

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

Ini mengeja saya bineeshkumar

Array dua dimensi dibuat dengan cara yang sama dengan array satu dimensi. Dan Anda mengaksesnya seperti array[0][1].

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

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

Saya tidak yakin apakah ada yang menjawab ini tetapi saya menemukan ini bekerja dengan baik -

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

misalnya:

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

Untuk array 2 dimensi, misalnya.

Untuk membuat array 2D dalam javaScript kita bisa membuat Array terlebih dahulu dan kemudian menambahkan Array sebagai elemen-elemennya. Metode ini akan mengembalikan array 2D dengan jumlah baris dan kolom yang diberikan.

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

untuk membuat Array, gunakan metode ini seperti di bawah ini.

var array = Create2DArray(10,20);

Untuk membuat array "2D" non-sparse (x, y) dengan semua indeks dialamatkan dan nilai disetel ke nol:

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

bonus "3D" Array (x, y, z)

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

Variasi dan koreksi tentang hal ini telah disebutkan dalam komentar dan di berbagai titik dalam menanggapi pertanyaan ini tetapi bukan sebagai jawaban yang sebenarnya, jadi saya menambahkannya di sini.

Perlu dicatat bahwa (mirip dengan sebagian besar jawaban lainnya) ini memiliki kompleksitas waktu O (x * y) sehingga mungkin tidak cocok untuk array yang sangat besar.

Gunakan Array Comprehensions

Dalam JavaScript 1.7 dan lebih tinggi Anda dapat menggunakan pemahaman array untuk membuat array dua dimensi. Anda juga dapat memfilter dan / atau memanipulasi entri sambil mengisi array dan tidak harus menggunakan loop.

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

Anda dapat membuat berbagai n x marray yang Anda inginkan dan mengisinya dengan nilai default dengan memanggil

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

Lebih banyak contoh dan dokumentasi dapat ditemukan di sini .

Harap dicatat bahwa ini belum merupakan fitur standar .

Untuk pecinta satu liner, Array.from ()

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

Satu lagi (dari komentar oleh dmitry_romanov) menggunakan Array (). Fill ()

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

Menggunakan operator spread ES6 + ("terinspirasi" oleh jawaban InspiredJW :))

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

Pendekatan saya sangat mirip dengan jawaban @Bineesh tetapi dengan pendekatan yang lebih umum.

Anda dapat mendeklarasikan array ganda sebagai berikut:

var myDoubleArray = [[]];

Dan menyimpan dan mengakses konten dengan cara berikut:

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

Ini akan mencetak output yang diharapkan

[ 9, 8 ] 9 123

Performa

Hari ini 2020.02.05 saya melakukan tes pada MacOs HighSierra 10.13.6 di Chrome v79.0, Safari v13.0.4 dan Firefox v72.0, untuk solusi yang dipilih.

Kesimpulan untuk array 2d yang tidak diinisialisasi

• solusi esoteris {}/arr[[i,j]] (N) tercepat untuk array besar dan kecil dan sepertinya itu pilihan yang baik untuk array jarang besar
• solusi berdasarkan for-[]/while (A, G) cepat dan mereka pilihan yang baik untuk array kecil.
• solusi for-[] (B, C) cepat dan mereka pilihan yang baik untuk array besar
• solusi berdasarkan Array..map/from/fill (I, J, K, L, M) cukup lambat untuk array kecil, dan cukup cepat untuk array besar
• surprinsingly for-Array(n)(B, C) jauh lebih lambat pada safari daripada for-[](A)
• surprinsingly for-[](A) untuk array besar lambat di semua browser
• solusi K lambat untuk array kecil untuk semua browser
• solusi A, E, G lambat untuk array besar untuk semua browser
• solusi M paling lambat untuk semua array di semua browser

Kesimpulan untuk array 2d yang diinisialisasi

• solusi berdasarkan for/while(A, B, C, D, E, G) tercepat / cukup cepat untuk array kecil di semua browser
• solusi berdasarkan for(A, B, C, E) tercepat / cukup cepat untuk array besar di semua browser
• solusi berdasarkan Array..map/from/fill (I, J, K, L, M) sedang cepat atau lambat untuk array kecil di semua browser
• solusi F, G, H, I, J, K, L untuk array besar sedang atau cepat pada chrome dan safari tetapi paling lambat pada firefox.
• solusi esoterik {}/arr[[i,j]](N) paling lambat untuk array kecil dan besar di semua browser

Detail

Tes untuk solusi yang tidak mengisi array (inisialisasi)

Kami menguji kecepatan solusi untuk

• array kecil (12 elemen) - Anda dapat melakukan tes pada mesin Anda DI SINI
• array besar (1 juta elemen) array - Anda dapat melakukan tes pada mesin Anda DI SINI

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

Tes untuk solusi yang mengisi (menginisialisasi) output array

Kami menguji kecepatan solusi untuk

• array kecil (12 elemen) - Anda dapat melakukan tes pada mesin Anda DI SINI
• array besar (1 juta elemen) array - Anda dapat melakukan tes pada mesin Anda DI SINI

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

Saya temukan di bawah ini adalah cara paling sederhana:

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

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

Javascript tidak mendukung array dua dimensi, sebaliknya kami menyimpan array di dalam array lain dan mengambil data dari array itu tergantung pada posisi array yang ingin Anda akses. Ingat penomoran array dimulai dari NOL .

Contoh Kode:

/* 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 + dapat melakukan ini dengan cara yang lebih sederhana

Membuat 3 x 2 Array diisi dengan true

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

Saya harus membuat fungsi array yang fleksibel untuk menambahkan "catatan" ke dalamnya seperti yang saya butuhkan dan dapat memperbaruinya dan melakukan perhitungan apa pun yang diperlukan sebelum saya mengirimnya ke database untuk diproses lebih lanjut. Ini kodenya, semoga membantu :).

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

Jangan ragu untuk mengoptimalkan dan / atau menunjukkan bug :)

Inilah cara cepat yang saya temukan untuk membuat array dua dimensi.

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

Anda dapat dengan mudah mengubah fungsi ini menjadi fungsi ES5 juga.

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

Mengapa ini bekerja: new Array(n)konstruktor membuat objek dengan prototipe Array.prototypedan kemudian menetapkan objek length, menghasilkan array yang tidak berpenghuni. Karena kurangnya anggota yang sebenarnya, kami tidak dapat menjalankan Array.prototype.mapfungsinya.

Namun, ketika Anda memberikan lebih dari satu argumen kepada konstruktor, seperti ketika Anda melakukannya Array(1, 2, 3, 4), konstruktor akan menggunakan argumentsobjek untuk membuat instance dan mengisiArray objek dengan benar.

Untuk alasan ini, kita dapat menggunakan Array.apply(null, Array(x)), karena applyfungsi akan menyebarkan argumen ke konstruktor. Untuk klarifikasi, melakukan Array.apply(null, Array(3))sama dengan melakukan Array(null, null, null).

Sekarang kita telah membuat array berpopulasi aktual, yang perlu kita lakukan hanyalah memanggil mapdan membuat layer kedua ( y).

Di bawah ini, buat matriks 5x5 dan isi dengan null

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

console.log(md);

Ukuran baris dan kolom dari suatu array yang hanya diketahui pada saat run maka metode berikut dapat digunakan untuk membuat array 2d dinamis .

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

Ada solusi lain, yang tidak memaksa Anda untuk menentukan sebelumnya ukuran array 2d, dan itu sangat ringkas.

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

Ini berfungsi karena, [1,2]ditransformasikan menjadi string, yang digunakan sebagai kunci string untuk tableobjek.

Untuk membuat array 4x6, cukup lakukan ini

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