He estado leyendo en línea y algunos lugares dicen que no es posible, algunos lo dicen y luego dan un ejemplo y otros refutan el ejemplo, etc.

1. ¿Cómo declaro una matriz bidimensional en JavaScript? (suponiendo que sea posible)

2. ¿Cómo accedería a sus miembros? ( myArray[0][1]o myArray[0,1]?)

Simplemente convierte cada elemento dentro de la matriz en una matriz.

var x = new Array(10);

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

console.log(x);

Similar a la respuesta de activa, aquí hay una función para crear una matriz n-dimensional:

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 solo tiene matrices unidimensionales, pero puede construir matrices de matrices, como otros señalaron.

La siguiente función se puede utilizar para construir una matriz 2-d de dimensiones fijas:

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

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

  return arr;
}

El número de columnas no es realmente importante, porque no es necesario especificar el tamaño de una matriz antes de usarlo.

Entonces puedes simplemente llamar:

var arr = Create2DArray(100);

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

La forma más fácil:

var myArray = [[]];

Cómo crear una matriz bidimensional vacía (una línea)

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

2 y 4 son primera y segunda dimensiones respectivamente.

Estamos haciendo uso de Array.from, que puede tomar un parámetro similar a una matriz y una asignación opcional para cada uno de los elementos.

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

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

Se puede usar el mismo truco para crear una matriz de JavaScript que contenga 1 ... N

Alternativamente (pero más ineficiente 12% con n = 10,000)

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

La disminución del rendimiento viene con el hecho de que tenemos que tener los primeros valores de dimensión inicializados para ejecutarse .map. Recuerde que Arrayno asignará las posiciones hasta que lo ordene a través de .filluna asignación de valor directa o directa.

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

Seguimiento

Aquí hay un método que parece correcto, pero tiene problemas .

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

Si bien devuelve la matriz bidimensional aparentemente deseada ( [ [ <4 empty items> ], [ <4 empty items> ] ]), hay una captura: las matrices de primera dimensión se han copiado por referencia. Eso significa arr[0][0] = 'foo'que a realmente cambiaría dos filas en lugar de una.

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

La razón por la que algunos dicen que no es posible es porque una matriz bidimensional es realmente solo una matriz de matrices. Los otros comentarios aquí proporcionan métodos perfectamente válidos para crear matrices bidimensionales en JavaScript, pero el punto de vista más puro sería que tiene una matriz unidimensional de objetos, cada uno de esos objetos sería una matriz unidimensional que consta de dos elementos.

Entonces, esa es la causa de los puntos de vista en conflicto.

Pocas personas muestran el uso de push:
para traer algo nuevo, le mostraré cómo inicializar la matriz con algún valor, por ejemplo: 0 o una cadena vacía "".
Recordando que si tiene una matriz de 10 elementos, ¡en JavaScript el último índice será 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;
}

ejemplos de uso:

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

Dos líneas:

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

Generará una matriz a de la longitud 10, llena de matrices. (Push agrega un elemento a una matriz y devuelve la nueva longitud)

La respuesta más sensata parece ser

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

Tenga en cuenta que no podemos llenar directamente con las filas ya que el relleno usa un constructor de copia superficial, por lo tanto, todas las filas compartirían la misma memoria ... aquí hay un ejemplo que demuestra cómo se compartiría cada fila (tomada de otras respuestas):

// 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 forma más fácil:

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'

Esto es lo que logré:

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

Esto me deletreó bineeshkumar

Las matrices bidimensionales se crean de la misma manera que las matrices unidimensionales. Y accedes a ellos como array[0][1].

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

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

No estoy seguro de si alguien ha respondido esto, pero descubrí que esto me funcionó bastante bien.

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

p.ej:

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

Para una matriz bidimensional, por ejemplo.

Para crear una matriz 2D en javaScript, primero podemos crear una matriz y luego agregar matrices como elementos. Este método devolverá una matriz 2D con el número dado de filas y columnas.

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

Para crear una matriz, utilice este método como se muestra a continuación.

var array = Create2DArray(10,20);

Para crear una matriz "2D" no dispersa (x, y) con todos los índices direccionables y valores establecidos en nulo:

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

Matriz "3D" de bonificación (x, y, z)

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

Se han mencionado variaciones y correcciones sobre esto en los comentarios y en varios puntos en respuesta a esta pregunta, pero no como una respuesta real, así que lo estoy agregando aquí.

Cabe señalar que (similar a la mayoría de las otras respuestas) tiene una complejidad de tiempo O (x * y), por lo que probablemente no sea adecuado para matrices muy grandes.

Usar comprensiones de matriz

En JavaScript 1.7 y superior, puede utilizar las comprensiones de matriz para crear matrices bidimensionales. También puede filtrar y / o manipular las entradas mientras llena la matriz y no tiene que usar bucles.

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

Puede crear cualquier n x mmatriz que desee y llenarla con un valor predeterminado llamando

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

Más ejemplos y documentación se pueden encontrar aquí .

Tenga en cuenta que esta no es una característica estándar todavía .

Para los amantes de una línea Array.from ()

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

Otro (del comentario de dmitry_romanov) usa Array (). Fill ()

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

Uso del operador de propagación ES6 + ("inspirado" por la respuesta de InspiredJW :))

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

Mi enfoque es muy similar a la respuesta @Bineesh pero con un enfoque más general.

Puede declarar la matriz doble de la siguiente manera:

var myDoubleArray = [[]];

Y el almacenamiento y acceso a los contenidos de la siguiente manera:

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

Esto imprimirá el resultado esperado

[ 9, 8 ] 9 123

Actuación

Hoy 2020.02.05 realizo pruebas en MacOs HighSierra 10.13.6 en Chrome v79.0, Safari v13.0.4 y Firefox v72.0, para las soluciones elegidas.

Conclusiones para la matriz 2d no inicializada

• La solución esotérica {}/arr[[i,j]](N) es la más rápida para matrices grandes y pequeñas y parece que es una buena opción para matrices dispersas grandes
• Las soluciones basadas en for-[]/while(A, G) son rápidas y son una buena opción para arreglos pequeños.
• Las soluciones for-[](B, C) son rápidas y son una buena opción para grandes matrices
• soluciones basadas en Array..map/from/fill (I, J, K, L, M) son bastante lentas para matrices pequeñas y bastante rápidas para matrices grandes
• Sorprendentemente for-Array(n)(B, C) es mucho más lento en safari que for-[](A)
• Sorprendentemente for-[](A) para gran variedad es lento en todos los navegadores
• soluciones K es lento para matrices pequeñas para todos los navegadores
• Las soluciones A, E, G son lentas para grandes matrices para todos los navegadores
• la solución M es la más lenta para todas las matrices en todos los navegadores

Conclusiones para la matriz 2d inicializada

• Las soluciones basadas en for/while(A, B, C, D, E, G) son más rápidas / bastante rápidas para arreglos pequeños en todos los navegadores
• Las soluciones basadas en for(A, B, C, E) son más rápidas / bastante rápidas para grandes matrices en todos los navegadores
• Las soluciones basadas en Array..map/from/fill(I, J, K, L, M) son medio rápidas o lentas para arreglos pequeños en todos los navegadores
• Las soluciones F, G, H, I, J, K, L para matrices grandes son medianas o rápidas en Chrome y Safari pero son más lentas en Firefox.
• La solución esotérica {}/arr[[i,j]](N) es más lenta para arreglos pequeños y grandes en todos los navegadores

Detalles

Pruebe las soluciones que no llenan (inicializan) la matriz de salida

Probamos la velocidad de las soluciones para

• matrices pequeñas (12 elementos): puede realizar pruebas en su máquina AQUÍ
• matrices grandes (1 millón de elementos): puede realizar pruebas en su máquina AQUÍ

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

Pruebe las soluciones que llenan (inicializan) la matriz de salida

Probamos la velocidad de las soluciones para

• matrices pequeñas (12 elementos): puede realizar pruebas en su máquina AQUÍ
• matrices grandes (1 millón de elementos): puede realizar pruebas en su máquina AQUÍ

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

Encontré a continuación es la forma más simple:

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

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

Javascript no admite matrices bidimensionales, en su lugar almacenamos una matriz dentro de otra matriz y recuperamos los datos de esa matriz dependiendo de la posición de la matriz a la que desea acceder. Recuerde que la numeración de la matriz comienza en CERO .

Ejemplo de código:

/* 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 + puede hacer esto de una manera aún más simple

Creando una matriz de 3 x 2 llena de verdadero

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

Tuve que hacer una función de matriz flexible para agregarle "registros" cuando lo necesitaba y para poder actualizarlos y hacer los cálculos necesarios antes de enviarlo a una base de datos para su posterior procesamiento. Aquí está el código, espero que ayude :).

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

Siéntase libre de optimizar y / o señalar cualquier error :)

Aquí hay una forma rápida que he encontrado para hacer una matriz bidimensional.

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

También puede convertir fácilmente esta función en una función ES5.

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

Por qué esto funciona: el new Array(n)constructor crea un objeto con un prototipo Array.prototypey luego asigna el objeto length, lo que resulta en una matriz despoblada. Debido a su falta de miembros reales, no podemos ejecutar la Array.prototype.mapfunción en él.

Sin embargo, cuando proporciona más de un argumento al constructor, como cuando lo hace Array(1, 2, 3, 4), el constructor usará el argumentsobjeto para crear instancias y llenar unArray objeto correctamente.

Por esta razón, podemos usar Array.apply(null, Array(x)), porque la applyfunción extenderá los argumentos en el constructor. Para aclarar, hacer Array.apply(null, Array(3))es equivalente a hacer Array(null, null, null).

Ahora que hemos creado una matriz poblada real, todo lo que tenemos que hacer es llamar mapy crear la segunda capa ( y).

Debajo de uno, crea una matriz de 5x5 y las llena con null

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

console.log(md);

Los tamaños de fila y columna de una matriz conocida solo en el tiempo de ejecución, entonces el siguiente método podría usarse para crear una matriz dinámica en 2d .

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

Hay otra solución, que no te obliga a predefinir el tamaño de la matriz 2d, y es muy conciso.

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

Esto funciona porque, [1,2]se transforma en una cadena, que se utiliza como una clave de cadena para el tableobjeto.

Para crear una matriz 4x6, simplemente haga esto

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