Ho letto online e alcuni posti dicono che non è possibile, alcuni lo dicono e poi danno un esempio e altri confutano l'esempio, ecc.

1. Come posso dichiarare un array bidimensionale in JavaScript? (supponendo che sia possibile)

2. Come accederei ai suoi membri? ( myArray[0][1]o myArray[0,1]?)

È sufficiente trasformare ciascun elemento all'interno dell'array in un array.

var x = new Array(10);

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

console.log(x);

Simile alla risposta di Activa, ecco una funzione per creare un array n-dimensionale:

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 ha solo array monodimensionali, ma è possibile creare array di array, come altri hanno sottolineato.

La seguente funzione può essere utilizzata per costruire un array 2-d di dimensioni fisse:

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

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

  return arr;
}

Il numero di colonne non è molto importante, poiché non è necessario specificare la dimensione di un array prima di usarlo.

Quindi puoi semplicemente chiamare:

var arr = Create2DArray(100);

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

La via più facile:

var myArray = [[]];

Come creare un array bidimensionale vuoto (una riga)

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

2 e 4 sono rispettivamente prima e seconda dimensione.

Ci stiamo avvalendo di Array.from, che può richiedere un parametro simile a un array e una mappatura opzionale per ciascuno degli elementi.

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

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

Lo stesso trucco può essere utilizzato per creare un array JavaScript contenente 1 ... N

In alternativa (ma più inefficiente del 12% con n = 10,000)

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

La riduzione delle prestazioni deriva dal fatto che è necessario inizializzare i primi valori di dimensione per l'esecuzione .map. Ricorda che Arraynon assegnerai le posizioni fino a quando non le ordinerai tramite .filll'assegnazione diretta o diretta del valore.

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

Azione supplementare

Ecco un metodo che appare corretto, ma presenta problemi .

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

Mentre restituisce l'array bidimensionale ( [ [ <4 empty items> ], [ <4 empty items> ] ]) apparentemente desiderato , c'è un problema: gli array della prima dimensione sono stati copiati per riferimento. Ciò significa che a arr[0][0] = 'foo'cambierebbe effettivamente due righe anziché una.

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

Il motivo per cui alcuni dicono che non è possibile è perché un array bidimensionale è in realtà solo un array di array. Gli altri commenti qui forniscono metodi perfettamente validi per la creazione di matrici bidimensionali in JavaScript, ma il punto di vista più puro sarebbe che si dispone di una matrice unidimensionale di oggetti, ciascuno di questi oggetti sarebbe una matrice unidimensionale composta da due elementi.

Quindi, questa è la causa dei punti di vista contrastanti.

Poche persone mostrano l'uso di push:
per portare qualcosa di nuovo, ti mostrerò come inizializzare la matrice con un certo valore, ad esempio: 0 o una stringa vuota "".
Ricordando che se hai un array di 10 elementi, in javascript l'ultimo indice sarà 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;
}

esempi di utilizzo:

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

Due-liner:

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

Genererà un array a della lunghezza 10, pieno di array. (Push aggiunge un elemento a un array e restituisce la nuova lunghezza)

La risposta più sana sembra essere

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

Nota che non possiamo riempire direttamente con le righe poiché fill usa un costruttore di copia superficiale, quindi tutte le righe condividono la stessa memoria ... ecco un esempio che dimostra come ogni riga sarebbe condivisa (presa da altre risposte):

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

La via più facile:

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'

Questo è quello che ho raggiunto:

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

Questo mi ha scritto bineeshkumar

Le matrici bidimensionali sono create allo stesso modo delle matrici monodimensionali. E tu accedi a loro come array[0][1].

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

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

Non sono sicuro che qualcuno abbia risposto a questo, ma ho scoperto che ha funzionato abbastanza bene per me -

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

per esempio:

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

Per un array bidimensionale, ad esempio.

Per creare un array 2D in javaScript, possiamo prima creare un array e quindi aggiungere array come elementi. Questo metodo restituirà un array 2D con il numero specificato di righe e colonne.

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

per creare un array utilizzare questo metodo come di seguito.

var array = Create2DArray(10,20);

Per creare una matrice "2D" non sparsa (x, y) con tutti gli indici indirizzabili e i valori impostati su null:

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

matrice "3D" di bonus (x, y, z)

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

Variazioni e correzioni al riguardo sono state menzionate nei commenti e in vari punti in risposta a questa domanda, ma non come una risposta effettiva, quindi la aggiungo qui.

Va notato che (simile alla maggior parte delle altre risposte) questo ha una complessità temporale di O (x * y), quindi probabilmente non è adatto per array molto grandi.

Usa comprensioni array

In JavaScript 1.7 e versioni successive è possibile utilizzare la comprensione degli array per creare array bidimensionali. È inoltre possibile filtrare e / o manipolare le voci durante il riempimento dell'array e non è necessario utilizzare i 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"]
         ]
*/

È possibile creare qualsiasi n x marray desiderato e riempirlo con un valore predefinito chiamando

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

Altri esempi e documentazione sono disponibili qui .

Questa non è ancora una funzionalità standard .

Per gli amanti del liner Array.from ()

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

Un altro (dal commento di dmitry_romanov) usa Array (). Fill ()

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

Utilizzo dell'operatore spread ES6 + ("ispirato" dalla risposta InspiredJW :))

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

Il mio approccio è molto simile alla risposta di @Bineesh ma con un approccio più generale.

È possibile dichiarare il doppio array come segue:

var myDoubleArray = [[]];

E la memorizzazione e l'accesso ai contenuti nel modo seguente:

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

Questo stamperà l'output previsto

[ 9, 8 ] 9 123

Prestazione

Oggi 2020.02.05 eseguo test su MacO HighSierra 10.13.6 su Chrome v79.0, Safari v13.0.4 e Firefox v72.0, per le soluzioni scelte.

Conclusioni per array 2d non inizializzati

• soluzione esoterica {}/arr[[i,j]] (N) è la più veloce per array grandi e piccoli e sembra sia una buona scelta per array sparsi
• soluzioni basate su for-[]/while (A, G) sono veloci e sono una buona scelta per array di piccole dimensioni.
• soluzioni for-[] (B, C) sono veloci e sono una buona scelta per array di grandi dimensioni
• soluzioni basate su Array..map/from/fill (I, J, K, L, M) sono piuttosto lente per array di piccole dimensioni e abbastanza veloci per array di grandi dimensioni
• sorprendentemente for-Array(n)(B, C) è molto più lento nel safari rispetto a for-[](A)
• sorprendentemente for-[](A) per array di grandi dimensioni è lento su tutti i browser
• le soluzioni K sono lente per array di piccole dimensioni per tutti i browser
• le soluzioni A, E, G sono lente per array di grandi dimensioni per tutti i browser
• la soluzione M è la più lenta per tutti gli array su tutti i browser

Conclusioni per array 2d inizializzato

• le soluzioni basate su for/while(A, B, C, D, E, G) sono più veloci / abbastanza veloci per array di piccole dimensioni su tutti i browser
• le soluzioni basate su for(A, B, C, E) sono più veloci / abbastanza veloci per array di grandi dimensioni su tutti i browser
• soluzioni basate su Array..map/from/fill (I, J, K, L, M) sono mediamente veloci o lente per piccoli array su tutti i browser
• le soluzioni F, G, H, I, J, K, L per array di grandi dimensioni sono medie o veloci su Chrome e Safari ma più lente su Firefox.
• la soluzione esoterica {}/arr[[i,j]](N) è la più lenta per array piccoli e grandi su tutti i browser

Dettagli

Test per soluzioni che non riempiono (inizializzano) array di output

Testiamo la velocità delle soluzioni per

• matrici di piccole dimensioni (12 elementi): puoi eseguire i test sulla tua macchina QUI
• array di grandi dimensioni (1 milione di elementi) array: puoi eseguire test QUI sulla tua macchina

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

Test per soluzioni che riempiono (inizializzano) array di output

Testiamo la velocità delle soluzioni per

• matrici di piccole dimensioni (12 elementi): puoi eseguire i test sulla tua macchina QUI
• array di grandi dimensioni (1 milione di elementi) array: puoi eseguire test QUI sulla tua macchina

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

Ho trovato di seguito il modo più semplice:

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

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

Javascript non supporta array bidimensionali, invece memorizziamo un array all'interno di un altro array e recuperiamo i dati da quell'array in base alla posizione dell'array a cui desideri accedere. Ricorda che la numerazione degli array inizia da ZERO .

Esempio di codice:

/* 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 + possono farlo in modo ancora più semplice

Creazione di array 3 x 2 riempiti con true

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

Ho dovuto creare una funzione di array flessibile per aggiungere "record" ad esso di cui avevo bisogno e per poterli aggiornare e fare tutti i calcoli necessari prima di inviarlo a un database per ulteriori elaborazioni. Ecco il codice, spero che sia d'aiuto :).

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

Sentiti libero di ottimizzare e / o segnalare eventuali bug :)

Ecco un modo rapido che ho trovato per creare un array bidimensionale.

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

Puoi facilmente trasformare questa funzione anche in una funzione ES5.

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

Perché funziona: il new Array(n)costruttore crea un oggetto con un prototipo di Array.prototypee quindi assegna l'oggetto length, risultando in un array non popolato. A causa della sua mancanza di membri effettivi, non è possibile eseguire la Array.prototype.mapfunzione su di esso.

Tuttavia, quando si fornisce più di un argomento al costruttore, come quando lo si fa Array(1, 2, 3, 4), il costruttore utilizzerà l' argumentsoggetto per creare un'istanza e popolare un oggettoArray correttamente oggetto.

Per questo motivo, possiamo usare Array.apply(null, Array(x)), perché la applyfunzione diffonderà gli argomenti nel costruttore. Per chiarimenti, fare Array.apply(null, Array(3))equivale a fare Array(null, null, null).

Ora che abbiamo creato un array popolato reale, tutto ciò che dobbiamo fare è chiamare mape creare il secondo livello ( y).

Sotto uno, crea una matrice 5x5 e riempili null

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

console.log(md);

Le dimensioni di riga e colonna di un array noto solo in fase di esecuzione, quindi il seguente metodo potrebbe essere utilizzato per la creazione di un array 2D dinamico .

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'è un'altra soluzione, che non ti obbliga a pre-definire la dimensione dell'array 2d, e questo è molto conciso.

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

Questo funziona perché, [1,2]viene trasformato in una stringa, che viene utilizzata come chiave di stringa per l' tableoggetto.

Per creare un array 4x6, è sufficiente farlo

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