Pur și simplu a face fiecare element din matrice o matrice.

var x = new Array(10);

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

console.log(x);

Similare pentru a activa's a răspunde, aici's o funcție pentru a crea un n-dimensional matrice:

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 are doar 1-dimensional matrice, dar vă puteți construi tablouri de tablouri, ca și ceilalți subliniat.

Următoarele funcții pot fi folosite pentru a construi un 2-d matrice de dimensiuni fixe:

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

  for (var i=0;i

Cel mai simplu mod:

var myArray = [[]];

Cum de a crea un gol tablou bidimensional (o linie)

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

2 și 4, fiind prima și a doua dimensiuni, respectiv.

Folosim Array.from, care poate lua o mulțime-ca param și un opțional de cartografiere pentru fiecare dintre elemente.

Matrice.din(arrayLike[, mapFn[, thisArg]])

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

Același truc poate fi folosit pentru a a Crea o matrice JavaScript care conțin 1...N

Alternativ (dar mai ineficiente 12% cu n = 10.000 de)

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

Performanța scădere vine cu faptul că trebuie să avem mai întâi valorile parametrilor inițializat la fug .map. Amintiți-vă că "Matrice" nu va aloca pozițiile până la tine pentru a printr .umple sau direct atribuirea valorii.

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

Follow-up

Aici's o metodă care pare a fi corectă, dar are probleme.

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

În timp ce acesta se întoarce aparent dorit tablou bidimensional ([ [ <4 gol elemente> ], [ <4 gol elemente> ] ]), există o captură: prima dimensiune tablouri au fost copiate de referință. Asta înseamnă că o arr[0][0] = 'foo' ar schimba de fapt două rânduri în loc de una.

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

Motivul pentru care unii spun că e't posibil, pentru că este un tablou bidimensional este de fapt doar o serie de tablouri. Alte comentarii pe aici ofere perfect valabil metode de a crea două-dimensional matrice în JavaScript, dar cea mai pura punct de vedere ar fi că ai o singură dimensiune matrice de obiecte, fiecare dintre aceste obiecte ar fi un dimensional matrice formată din două elemente.

Deci, ca's cauza contradictorii puncte de vedere.

Puțini oameni arăta utilizarea de push: Pentru a aduce ceva nou, eu vă va arăta cum pentru a inițializa matrice cu o anumită valoare, de exemplu: 0 sau un șir gol "". Amintind că, dacă ai un 10 de elemente de matrice, în javascript ultimul indice va fi de 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;
}

exemple de utilizare:

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

Două-liner:

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

Acesta va genera o matrice de lungime 10, pline cu tablouri. (Împinge adaugă un element într-un tablou și returnează noua lungime)

Cel mai bun răspuns pare a fi

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

Rețineți putem't direct umple cu rânduri de umplere folosește superficial constructor de copiere, prin urmare, toate rândurile vor partaja same memorie...aici este un exemplu care demonstrează cum fiecare rând ar fi partajată (luate de la alte răspunsuri):

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

Aceasta este ceea ce am realizat :

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

Acest scrie-mi bineeshkumar

Cel mai simplu mod:

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'

Două-dimensional matrice sunt create în același mod unic dimensional matrice sunt. Și le puteți accesa ca matrice[0][1].

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

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

Am'm nu sunt sigur dacă cineva a răspuns la acest lucru, dar am gasit aceasta a lucrat pentru mine destul de bine

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

de exemplu:

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

Pentru o a 2-dimensional matrice, de exemplu.

Pentru a crea o matrice 2D în javaScript putem crea o Serie întâi și apoi se adaugă Tablouri ca's elemente. Aceasta metoda va returna o matrice 2D cu anumit număr de rânduri și coloane.

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

pentru a crea o Matrice a folosi această metodă ca mai jos.

var array = Create2DArray(10,20);

Pentru a crea un non-rare "2D" matrice (x,y) cu toți indicii adresabile și valorile setat la null:

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

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

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

Modificări și corecții pe aceasta au fost menționate în comentarii și la diferite puncte în răspuns la această întrebare, dar nu ca un răspuns real deci, eu sunt adăugarea de aici.

Ar trebui remarcat faptul că (similar cu cele mai multe alte răspunsuri) are O(x*y) complexitatea timp așa că, probabil, nu este potrivit pentru foarte tablouri de mari dimensiuni.

Utilizarea Largă Comprehensions

În JavaScript 1.7 și mai mare, puteți utiliza matrice comprehensions pentru a crea tablouri bidimensionale. Puteți filtra, de asemenea, și/sau de a manipula înregistrările în timp ce de umplere matrice și don't trebuie să utilizați bucle.

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

Puteți crea orice n x m matrice vrei și umple-l cu o valoare implicită de asteptare

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

Mai multe exemple și documentație pot fi găsite aici.

Vă rugăm să rețineți că acest lucru nu este o caracteristică standard încă.

Abordarea mea este foarte similar cu @Bineesh răspuns, dar cu o abordare mai generală.

Puteți declara dublu matrice, după cum urmează:

var myDoubleArray = [[]];

Și stocarea și accesarea conținutului în felul următor:

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

Acest lucru se va imprima rezultatul așteptat

[ 9, 8 ] 9 123

Pentru o linie iubitorii Matrice.din()

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

Un altul (de la comentarii de dmitry_romanov) utilizarea Array().fill()

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

Javascript nu are suport pentru două-dimensional matrice, în loc să stocăm o matrice într-o altă matrice și de a prelua datele din matrice în funcție de ceea ce poziție din matrice care doriți să o accesați. Amintiți-vă matrice numerotarea incepe de la ZERO.

Exemplu De Cod:

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