Ich habe online gelesen und einige Orte sagen, dass es nicht möglich ist, einige sagen, dass es möglich ist und geben dann ein Beispiel und andere widerlegen das Beispiel usw.

1. Wie deklariere ich ein zweidimensionales Array in JavaScript? (vorausgesetzt es ist möglich)

2. Wie würde ich auf seine Mitglieder zugreifen? ( myArray[0][1]oder myArray[0,1]?)

Sie machen einfach jedes Element innerhalb des Arrays zu einem Array.

var x = new Array(10);

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

console.log(x);

Ähnlich wie bei Activas Antwort gibt es hier eine Funktion zum Erstellen eines n-dimensionalen Arrays:

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 hat nur eindimensionale Arrays, aber Sie können Arrays von Arrays erstellen, wie andere betonten.

Die folgende Funktion kann verwendet werden, um ein 2D-Array mit festen Abmessungen zu erstellen:

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

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

  return arr;
}

Die Anzahl der Spalten ist nicht wirklich wichtig, da die Größe eines Arrays vor der Verwendung nicht angegeben werden muss.

Dann können Sie einfach anrufen:

var arr = Create2DArray(100);

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

Der einfachste Weg:

var myArray = [[]];

So erstellen Sie ein leeres zweidimensionales Array (einzeilig)

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

2 und 4 sind die erste bzw. zweite Dimension.

Wir verwenden Array.from, die einen Array-ähnlichen Parameter und eine optionale Zuordnung für jedes der Elemente verwenden können.

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

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

Der gleiche Trick kann verwendet werden, um ein JavaScript-Array mit 1 ... N zu erstellen

Alternativ (aber ineffizienter 12% mit n = 10,000)

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

Der Leistungsabfall ist darauf zurückzuführen, dass die ersten Dimensionswerte für die Ausführung initialisiert werden müssen .map. Denken ArraySie daran, dass die Positionen erst zugewiesen werden, wenn Sie sie durch .filloder direkt zuweisen .

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

Nachverfolgen

Hier ist eine Methode, die korrekt erscheint, aber Probleme aufweist .

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

Während es das scheinbar gewünschte zweidimensionale Array ( [ [ <4 empty items> ], [ <4 empty items> ] ]) zurückgibt , gibt es einen Haken: Arrays der ersten Dimension wurden als Referenz kopiert. Das bedeutet, dass a arr[0][0] = 'foo'tatsächlich zwei Zeilen anstelle von einer ändern würde.

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

Einige sagen, dass dies nicht möglich ist, weil ein zweidimensionales Array eigentlich nur ein Array von Arrays ist. Die anderen Kommentare hier bieten vollkommen gültige Methoden zum Erstellen zweidimensionaler Arrays in JavaScript. Der reinste Gesichtspunkt wäre jedoch, dass Sie ein eindimensionales Array von Objekten haben. Jedes dieser Objekte wäre ein eindimensionales Array, das aus zwei Elementen besteht.

Das ist also die Ursache für die widersprüchlichen Sichtweisen.

Nur wenige Leute zeigen die Verwendung von Push:
Um etwas Neues zu bringen, zeige ich Ihnen, wie Sie die Matrix mit einem Wert initialisieren, zum Beispiel: 0 oder einer leeren Zeichenfolge "".
Wenn Sie ein Array mit 10 Elementen haben, ist der letzte Index in 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;
}

Anwendungsbeispiele:

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

Zweiliner:

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

Es wird ein Array a der Länge 10 generiert, das mit Arrays gefüllt ist. (Push fügt einem Array ein Element hinzu und gibt die neue Länge zurück.)

Die vernünftigste Antwort scheint zu sein

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

Beachten Sie, dass wir nicht direkt mit den Zeilen füllen können, da die Füllung einen flachen Kopierkonstruktor verwendet. Daher würden alle Zeilen denselben Speicher verwenden. Hier ist ein Beispiel, das zeigt, wie jede Zeile gemeinsam genutzt wird (aus anderen Antworten entnommen):

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

Der einfachste Weg:

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'

Das habe ich erreicht:

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

Das buchstabierte mich bineeshkumar

Zweidimensionale Arrays werden genauso erstellt wie eindimensionale Arrays. Und Sie greifen gerne darauf zu array[0][1].

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

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

Ich bin mir nicht sicher, ob jemand darauf geantwortet hat, aber ich fand, dass dies für mich ziemlich gut funktioniert hat -

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

z.B:

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

Zum Beispiel für ein zweidimensionales Array.

Um ein 2D-Array in JavaScript zu erstellen, können wir zuerst ein Array erstellen und dann Arrays als Elemente hinzufügen. Diese Methode gibt ein 2D-Array mit der angegebenen Anzahl von Zeilen und Spalten zurück.

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

Verwenden Sie diese Methode wie folgt, um ein Array zu erstellen.

var array = Create2DArray(10,20);

So erstellen Sie ein nicht spärliches "2D" -Array (x, y) mit allen adressierbaren Indizes und auf null gesetzten Werten:

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

Variationen und Korrekturen hierzu wurden in Kommentaren und an verschiedenen Stellen als Antwort auf diese Frage erwähnt, jedoch nicht als tatsächliche Antwort, daher füge ich sie hier hinzu.

Es sollte beachtet werden, dass dies (ähnlich wie die meisten anderen Antworten) eine O (x * y) -Zeitkomplexität aufweist, so dass es wahrscheinlich nicht für sehr große Arrays geeignet ist.

Verwenden Sie Array-Verständnisse

In JavaScript 1.7 und höher können Sie Array-Verständnis verwenden , um zweidimensionale Arrays zu erstellen. Sie können die Einträge auch filtern und / oder bearbeiten, während Sie das Array füllen, und müssen keine Schleifen verwenden.

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

Sie können jedes n x mgewünschte Array erstellen und durch Aufrufen mit einem Standardwert füllen

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

Weitere Beispiele und Dokumentationen finden Sie hier .

Bitte beachten Sie, dass dies noch keine Standardfunktion ist .

Für Einzeiler Liebhaber Array.from ()

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

Ein anderer (aus dem Kommentar von dmitry_romanov) verwendet Array (). Fill ()

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

Verwenden des ES6 + Spread- Operators ("inspiriert" von der InspiredJW- Antwort :))

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

Mein Ansatz ist der Antwort von @Bineesh sehr ähnlich, jedoch mit einem allgemeineren Ansatz.

Sie können das Double-Array wie folgt deklarieren:

var myDoubleArray = [[]];

Und das Speichern und Zugreifen auf die Inhalte auf folgende Weise:

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

Dadurch wird die erwartete Ausgabe gedruckt

[ 9, 8 ] 9 123

Ich fand unten ist der einfachste Weg:

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

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

Performance

Heute 2020.02.05 führe ich Tests auf MacOs HighSierra 10.13.6 unter Chrome v79.0, Safari v13.0.4 und Firefox v72.0 für ausgewählte Lösungen durch.

Schlussfolgerungen für nicht initialisiertes 2d-Array

• esoterische Lösung {}/arr[[i,j]] (N) ist für große und kleine Arrays am schnellsten und scheint für große, spärliche Arrays eine gute Wahl zu sein
• Lösungen, die auf for-[]/while(A, G) basieren , sind schnell und eine gute Wahl für kleine Arrays.
• Lösungen for-[](B, C) sind schnell und eine gute Wahl für große Arrays
• Lösungen, die auf Array..map/from/fill(I, J, K, L, M) basieren, sind für kleine Arrays ziemlich langsam und für große Arrays ziemlich schnell
• überraschenderweise ist for-Array(n)(B, C) auf Safari viel langsamer als for-[](A)
• Überraschenderweise ist for-[](A) für große Arrays in allen Browsern langsam
• Lösungen K ist langsam für kleine Arrays für alle Browser
• Die Lösungen A, E, G sind für große Arrays für alle Browser langsam
• Lösung M ist für alle Arrays in allen Browsern am langsamsten

Schlussfolgerungen für das initialisierte 2d-Array

• Lösungen basierend auf for/while (A, B, C, D, E, G) basieren, sind für kleine Arrays in allen Browsern am schnellsten / ziemlich schnell
• Lösungen, die auf for(A, B, C, E) basieren, sind für große Arrays in allen Browsern am schnellsten / ziemlich schnell
• Lösungen, die auf Array..map/from/fill(I, J, K, L, M) basieren, sind für kleine Arrays in allen Browsern mittelschnell oder langsam
• Die Lösungen F, G, H, I, J, K, L für große Arrays sind auf Chrom und Safari mittel oder schnell, auf Firefox jedoch am langsamsten.
• Die esoterische Lösung {}/arr[[i,j]](N) ist für kleine und große Arrays in allen Browsern am langsamsten

Einzelheiten

Testen Sie auf Lösungen, die das Ausgabearray nicht füllen (initialisieren)

Wir testen die Geschwindigkeit von Lösungen für

• kleine Arrays (12 Elemente) - Sie können HIER Tests auf Ihrem Computer durchführen
• Große Arrays (1 Million Elemente) Arrays - Sie können HIER Tests auf Ihrem Computer durchführen

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

Testen Sie auf Lösungen, die das Ausgabearray füllen (initialisieren)

Wir testen die Geschwindigkeit von Lösungen für

• kleine Arrays (12 Elemente) - Sie können HIER Tests auf Ihrem Computer durchführen
• Große Arrays (1 Million Elemente) Arrays - Sie können HIER Tests auf Ihrem Computer durchführen

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 unterstützt keine zweidimensionalen Arrays. Stattdessen speichern wir ein Array in einem anderen Array und rufen die Daten von diesem Array ab, je nachdem, auf welche Position des Arrays Sie zugreifen möchten. Denken Sie daran , Array Numerierung beginnt bei Null .

Codebeispiel:

/* 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 + können dies noch einfacher tun

Erstellen eines 3 x 2-Arrays, das mit true gefüllt ist

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

Ich musste eine flexible Array-Funktion erstellen, um "Datensätze" nach Bedarf hinzuzufügen und sie aktualisieren und alle erforderlichen Berechnungen durchführen zu können, bevor ich sie zur weiteren Verarbeitung an eine Datenbank schickte. Hier ist der Code, hoffe es hilft :).

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

Fühlen Sie sich frei zu optimieren und / oder auf Fehler hinzuweisen :)

Hier ist eine schnelle Möglichkeit, ein zweidimensionales Array zu erstellen.

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

Sie können diese Funktion auch problemlos in eine ES5-Funktion umwandeln.

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

Warum dies funktioniert: Der new Array(n)Konstruktor erstellt ein Objekt mit einem Prototyp von Array.prototypeund weist dann das Objekt zu length, was zu einem nicht ausgefüllten Array führt. Aufgrund des Mangels an tatsächlichen Mitgliedern können wir die Array.prototype.mapFunktion nicht darauf ausführen .

Wenn Sie dem Konstruktor jedoch mehr als ein Argument bereitstellen, z. B. wenn Sie dies tun Array(1, 2, 3, 4), verwendet der Konstruktor das argumentsObjekt, um ein ArrayObjekt korrekt zu instanziieren und zu füllen .

Aus diesem Grund können wir verwenden Array.apply(null, Array(x)), da die applyFunktion die Argumente im Konstruktor verteilt. Zur Verdeutlichung ist das Tun Array.apply(null, Array(3))gleichbedeutend mit dem Tun Array(null, null, null).

Nachdem wir ein tatsächlich bestücktes Array erstellt haben, müssen wir nur noch mapdie zweite Ebene ( y) aufrufen und erstellen .

Erstellen Sie unter einer eine 5x5-Matrix und füllen Sie sie mit null

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

console.log(md);

Zeilen- und Spaltengrößen eines Arrays, die nur zur Laufzeit bekannt sind, und die folgende Methode können zum Erstellen eines dynamischen 2D-Arrays verwendet werden .

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

Es gibt eine andere Lösung, die Sie nicht zwingt, die Größe des 2D-Arrays vorab zu definieren, und die sehr präzise ist.

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

Dies funktioniert, weil [1,2]es in eine Zeichenfolge umgewandelt wird, die als Zeichenfolgenschlüssel für das tableObjekt verwendet wird.

Führen Sie dies einfach aus, um ein 4x6-Array zu erstellen

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