J'ai lu en ligne et certains endroits disent que ce n'est pas possible, certains le disent, puis donnent un exemple et d'autres réfutent l'exemple, etc.

1. Comment déclarer un tableau bidimensionnel en JavaScript? (en supposant que c'est possible)

2. Comment pourrais-je accéder à ses membres? ( myArray[0][1]ou myArray[0,1]?)

Vous transformez simplement chaque élément du tableau en tableau.

var x = new Array(10);

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

console.log(x);

Semblable à la réponse d'Activa, voici une fonction pour créer un tableau à n dimensions:

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 n'a que des tableaux unidimensionnels, mais vous pouvez créer des tableaux de tableaux, comme d'autres l'ont souligné.

La fonction suivante peut être utilisée pour construire un tableau 2D de dimensions fixes:

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

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

  return arr;
}

Le nombre de colonnes n'est pas vraiment important, car il n'est pas nécessaire de spécifier la taille d'un tableau avant de l'utiliser.

Ensuite, vous pouvez simplement appeler:

var arr = Create2DArray(100);

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

La façon la plus simple:

var myArray = [[]];

Comment créer un tableau bidimensionnel vide (une ligne)

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

2 et 4 étant respectivement de première et deuxième dimensions.

Nous utilisons Array.from, qui peut prendre un paramètre de type tableau et un mappage facultatif pour chacun des éléments.

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

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

La même astuce peut être utilisée pour créer un tableau JavaScript contenant 1 ... N

Alternativement (mais plus inefficace 12% avec n = 10,000)

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

La baisse des performances vient du fait que nous devons avoir les premières valeurs de dimension initialisées pour s'exécuter .map. N'oubliez Arraypas que les positions ne seront pas attribuées tant que vous ne les aurez pas commandées par le biais d' .fillune attribution de valeur directe ou directe.

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

Suivre

Voici une méthode qui semble correcte, mais qui a des problèmes .

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

Bien qu'il retourne le tableau bidimensionnel apparemment souhaité ( [ [ <4 empty items> ], [ <4 empty items> ] ]), il y a un crochet: les tableaux de première dimension ont été copiés par référence. Cela signifie qu'un arr[0][0] = 'foo'changerait en fait deux lignes au lieu d'une.

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

Certains disent que ce n'est pas possible parce qu'un tableau à deux dimensions n'est en réalité qu'un tableau de tableaux. Les autres commentaires ici fournissent des méthodes parfaitement valides pour créer des tableaux bidimensionnels en JavaScript, mais le point de vue le plus pur serait que vous ayez un tableau d'objets unidimensionnel, chacun de ces objets serait un tableau unidimensionnel composé de deux éléments.

C'est donc la cause des points de vue contradictoires.

Peu de gens montrent l'utilisation de push:
Pour apporter quelque chose de nouveau, je vais vous montrer comment initialiser la matrice avec une valeur, par exemple: 0 ou une chaîne vide "".
Rappelant que si vous avez un tableau de 10 éléments, en javascript le dernier index sera 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;
}

exemples d'utilisation:

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

Deux doublures:

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

Il générera un tableau a de la longueur 10, rempli de tableaux. (Push ajoute un élément à un tableau et renvoie la nouvelle longueur)

La réponse la plus saine semble être

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

Notez que nous ne pouvons pas remplir directement avec les lignes car fill utilise un constructeur de copie peu profond, donc toutes les lignes partageraient la même mémoire ... voici un exemple qui montre comment chaque ligne serait partagée (tirée d'autres réponses):

// 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 façon la plus simple:

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'

Voici ce que j'ai réalisé:

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

Cela m'a épelé bineeshkumar

Les tableaux bidimensionnels sont créés de la même manière que les tableaux unidimensionnels. Et vous y accédez comme array[0][1].

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

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

Je ne sais pas si quelqu'un a répondu à cela, mais j'ai trouvé que cela fonctionnait assez bien pour moi -

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

par exemple:

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

Pour un tableau à 2 dimensions, par exemple.

Pour créer un tableau 2D en javaScript, nous pouvons d'abord créer un tableau puis ajouter des tableaux en tant qu'éléments. Cette méthode retournera un tableau 2D avec le nombre donné de lignes et de colonnes.

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

pour créer un tableau, utilisez cette méthode comme ci-dessous.

var array = Create2DArray(10,20);

Pour créer un tableau "2D" non clairsemé (x, y) avec tous les indices adressables et les valeurs définies sur null:

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

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

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

Des variations et des corrections à ce sujet ont été mentionnées dans les commentaires et à divers points en réponse à cette question, mais pas comme une réponse réelle, donc je l'ajoute ici.

Il convient de noter que (semblable à la plupart des autres réponses), cela a une complexité temporelle O (x * y), donc il ne convient probablement pas aux très grands tableaux.

Utiliser les compréhensions de tableau

Dans JavaScript 1.7 et supérieur, vous pouvez utiliser des compréhensions de tableaux pour créer des tableaux à deux dimensions. Vous pouvez également filtrer et / ou manipuler les entrées tout en remplissant le tableau et ne pas avoir à utiliser de boucles.

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

Vous pouvez créer le n x mtableau de votre choix et le remplir avec une valeur par défaut en appelant

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

Plus d'exemples et de documentation peuvent être trouvés ici .

Veuillez noter que ce n'est pas encore une fonctionnalité standard .

Pour les amateurs de paquebot Array.from ()

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

Un autre (extrait du commentaire de dmitry_romanov) utilise Array (). Fill ()

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

Utilisation de l' opérateur de propagation ES6 + ("inspiré" par la réponse InspiredJW :))

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

Mon approche est très similaire à la réponse @Bineesh mais avec une approche plus générale.

Vous pouvez déclarer le double tableau comme suit:

var myDoubleArray = [[]];

Et le stockage et l'accès au contenu de la manière suivante:

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

Cela imprimera la sortie attendue

[ 9, 8 ] 9 123

Performance

Aujourd'hui 2020.02.05 j'effectue des tests sur MacOs HighSierra 10.13.6 sur Chrome v79.0, Safari v13.0.4 et Firefox v72.0, pour les solutions choisies.

Conclusions pour le tableau 2D non initialisé

• solution ésotérique {}/arr[[i,j]] (N) est la plus rapide pour les grands et les petits tableaux et elle semble être un bon choix pour les grands tableaux clairsemés
• solutions basées sur for-[]/while (A, G) sont rapides et constituent un bon choix pour les petites baies.
• solutions for-[] (B, C) sont rapides et sont un bon choix pour les grands tableaux
• solutions basées sur Array..map/from/fill (I, J, K, L, M) sont assez lentes pour les petits tableaux et assez rapides pour les grands tableaux
• étonnamment for-Array(n)(B, C) est beaucoup plus lent en safari que for-[](A)
• étonnamment for-[](A) pour les grands tableaux est lent sur tous les navigateurs
• solutions K est lent pour les petits tableaux pour tous les navigateurs
• les solutions A, E, G sont lentes pour les grands tableaux pour tous les navigateurs
• la solution M est la plus lente pour tous les tableaux sur tous les navigateurs

Conclusions pour le tableau 2D initialisé

• les solutions basées sur for/while(A, B, C, D, E, G) sont les plus rapides / assez rapides pour les petits tableaux sur tous les navigateurs
• les solutions basées sur for(A, B, C, E) sont les plus rapides / assez rapides pour les grands tableaux sur tous les navigateurs
• les solutions basées sur Array..map/from/fill(I, J, K, L, M) sont moyennes rapides ou lentes pour les petits tableaux sur tous les navigateurs
• les solutions F, G, H, I, J, K, L pour les grands tableaux sont moyennes ou rapides sur chrome et safari mais les plus lentes sur firefox.
• la solution ésotérique {}/arr[[i,j]](N) est la plus lente pour les petits et les grands tableaux sur tous les navigateurs

Détails

Tester les solutions qui ne remplissent pas (initialiser) le tableau de sortie

Nous testons la vitesse des solutions pour

• petits tableaux (12 éléments) - vous pouvez effectuer des tests sur votre machine ICI
• grands tableaux (1 million d'éléments) tableaux - vous pouvez effectuer des tests sur votre machine ICI

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 des solutions qui remplissent (initialisent) le tableau de sortie

Nous testons la vitesse des solutions pour

• petits tableaux (12 éléments) - vous pouvez effectuer des tests sur votre machine ICI
• grands tableaux (1 million d'éléments) tableaux - vous pouvez effectuer des tests sur votre machine ICI

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

J'ai trouvé ci-dessous le moyen le plus simple:

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

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

Javascript ne prend pas en charge les tableaux bidimensionnels, à la place, nous stockons un tableau dans un autre tableau et récupérons les données de ce tableau en fonction de la position de ce tableau à laquelle vous souhaitez accéder. N'oubliez pas que la numérotation des tableaux commence à ZÉRO .

Exemple de code:

/* 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 + peuvent le faire de manière encore plus simple

Création d'un tableau 3 x 2 rempli de true

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

J'ai dû créer une fonction de tableau flexible pour y ajouter des «enregistrements» selon mes besoins et pour pouvoir les mettre à jour et effectuer les calculs nécessaires avant de l'envoyer à une base de données pour un traitement ultérieur. Voici le code, j'espère que ça aide :).

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

N'hésitez pas à optimiser et / ou signaler tout bug :)

Voici un moyen rapide que j'ai trouvé pour créer un tableau à deux dimensions.

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

Vous pouvez également facilement transformer cette fonction en fonction ES5.

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

Pourquoi cela fonctionne: le new Array(n)constructeur crée un objet avec un prototype de Array.prototypepuis attribue celui-ci length, résultant en un tableau non peuplé. En raison de son manque de membres réels, nous ne pouvons pas exécuter la Array.prototype.mapfonction dessus.

Toutefois, lorsque vous fournissez plusieurs arguments au constructeur, comme lorsque vous le faites Array(1, 2, 3, 4), le constructeur utilisera l' argumentsobjet pour instancier et remplir Arraycorrectement un objet.

Pour cette raison, nous pouvons utiliser Array.apply(null, Array(x)), car la applyfonction répartira les arguments dans le constructeur. Par souci de clarté, faire Array.apply(null, Array(3))équivaut à faire Array(null, null, null).

Maintenant que nous avons créé un véritable tableau peuplé, tout ce que nous devons faire est d'appeler mapet de créer la deuxième couche ( y).

En dessous, crée une matrice 5x5 et remplissez-les de null

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

console.log(md);

Les tailles de ligne et de colonne d'un tableau connues uniquement au moment de l' exécution, puis la méthode suivante peut être utilisée pour créer un tableau 2D dynamique .

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

Il existe une autre solution, qui ne vous oblige pas à prédéfinir la taille du tableau 2D, et qui est très concise.

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

Cela fonctionne parce que, [1,2]est transformé en chaîne, qui est utilisé comme clé de chaîne pour l' tableobjet.

Pour créer un tableau 4x6, faites simplement ceci

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