Eu tenho lido online e alguns lugares dizem que não é possível, alguns dizem que é e depois dão um exemplo e outros refutam o exemplo, etc.

1. Como declaro uma matriz bidimensional em JavaScript? (supondo que seja possível)

2. Como eu acessaria seus membros? ( myArray[0][1]ou myArray[0,1]?)

Você simplesmente transforma cada item da matriz em uma matriz.

var x = new Array(10);

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

console.log(x);

Semelhante à resposta da ativa, aqui está uma função para criar uma 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)]

O Javascript possui apenas matrizes unidimensionais, mas você pode criar matrizes, como outros apontaram.

A seguinte função pode ser usada para construir uma matriz bidimensional de dimensões fixas:

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

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

  return arr;
}

O número de colunas não é realmente importante, porque não é necessário especificar o tamanho de uma matriz antes de usá-la.

Depois, basta ligar para:

var arr = Create2DArray(100);

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

O jeito mais fácil:

var myArray = [[]];

Como criar uma matriz bidimensional vazia (uma linha)

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

2 e 4 sendo primeira e segunda dimensões, respectivamente.

Estamos usando Array.from, o que pode levar um parâmetro do tipo matriz e um mapeamento opcional para cada um dos elementos.

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

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

O mesmo truque pode ser usado para criar uma matriz JavaScript contendo 1 ... N

Alternativamente (mas 12% mais ineficiente com n = 10,000)

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

A diminuição do desempenho vem com o fato de que precisamos ter os primeiros valores de dimensão inicializados para execução .map. Lembre-se de que Arraynão alocará as posições até que você as solicite através da .fillatribuição direta ou de valor.

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

Acompanhamento

Aqui está um método que parece correto, mas tem problemas .

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

Embora retorne a matriz bidimensional aparentemente desejada ( [ [ <4 empty items> ], [ <4 empty items> ] ]), existe um problema: as matrizes da primeira dimensão foram copiadas por referência. Isso significa que um arr[0][0] = 'foo'realmente mudaria duas linhas em vez de uma.

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

A razão pela qual alguns dizem que isso não é possível é porque uma matriz bidimensional é realmente apenas uma matriz de matrizes. Os outros comentários aqui fornecem métodos perfeitamente válidos para a criação de matrizes bidimensionais em JavaScript, mas o ponto de vista mais puro seria o fato de você ter uma matriz unidimensional de objetos, cada um desses objetos seria uma matriz unidimensional composta por dois elementos.

Então, essa é a causa dos pontos de vista conflitantes.

Poucas pessoas mostram o uso de push:
Para trazer algo novo, mostrarei como inicializar a matriz com algum valor, por exemplo: 0 ou uma string vazia "".
Lembrando que se você tiver uma matriz de 10 elementos, em javascript o ú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;
}

exemplos 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

Dois revestimentos:

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

Ele irá gerar uma matriz de comprimento 10, preenchida com matrizes. (O push adiciona um elemento a uma matriz e retorna o novo comprimento)

A resposta mais 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);

Observe que não podemos preencher diretamente com as linhas, pois o preenchimento usa o construtor de cópia superficial, portanto, todas as linhas compartilhariam a mesma memória ... aqui está um exemplo que demonstra como cada linha seria compartilhada (extraída de outras respostas):

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

O jeito mais 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'

Isto é o que eu consegui:

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

Isso me soletrou bineeshkumar

Matrizes bidimensionais são criadas da mesma maneira que matrizes unidimensionais. E você acessa-os como array[0][1].

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

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

Não sei se alguém respondeu isso, mas achei que funcionou muito bem para mim -

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

por exemplo:

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

Para uma matriz bidimensional, por exemplo.

Para criar uma matriz 2D em javaScript, primeiro podemos criar uma matriz e, em seguida, adicionar matrizes como elementos. Este método retornará uma matriz 2D com o número especificado de linhas e colunas.

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

Para criar uma matriz, use este método como abaixo.

var array = Create2DArray(10,20);

Para criar uma matriz "2D" não esparsa (x, y) com todos os índices endereçáveis ​​e valores definidos como nulos:

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

Matriz "3D" de bônus (x, y, z)

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

Variações e correções sobre isso foram mencionadas nos comentários e em vários pontos em resposta a esta pergunta, mas não como uma resposta real, por isso estou adicionando aqui.

Deve-se notar que (semelhante à maioria das outras respostas) isso tem complexidade de tempo O (x * y), portanto, provavelmente não é adequado para matrizes muito grandes.

Usar compreensões de matriz

No JavaScript 1.7 e superior, você pode usar a compreensão de matrizes para criar matrizes bidimensionais. Você também pode filtrar e / ou manipular as entradas enquanto preenche a matriz e não precisa usar loops.

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

Você pode criar qualquer n x mmatriz que desejar e preenchê-la com um valor padrão chamando

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

Mais exemplos e documentação podem ser encontrados aqui .

Observe que esse ainda não é um recurso padrão .

Para os amantes de uma linha Array.from ()

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

Outro (do comentário de dmitry_romanov) usa Array (). Fill ()

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

Usando o operador de spread ES6 + ("inspirado" pela resposta InspiredJW :))

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

Minha abordagem é muito semelhante à resposta do @Bineesh, mas com uma abordagem mais geral.

Você pode declarar a matriz dupla da seguinte maneira:

var myDoubleArray = [[]];

E o armazenamento e acesso ao conteúdo da seguinte maneira:

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

Isso imprimirá a saída esperada

[ 9, 8 ] 9 123

atuação

Hoje em 2020.02.05, realizo testes no MacOs HighSierra 10.13.6 no Chrome v79.0, Safari v13.0.4 e Firefox v72.0, para soluções escolhidas.

Conclusões para uma matriz 2D não inicializada

• solução esotérica {}/arr[[i,j]] (N) é mais rápida para matrizes grandes e pequenas e parece ser uma boa escolha para matrizes esparsas grandes
• soluções baseadas em for-[]/while (A, G) são rápidas e são uma boa opção para pequenas matrizes.
• soluções for-[] (B, C) são rápidas e são uma boa opção para grandes matrizes
• soluções baseadas em Array..map/from/fill (I, J, K, L, M) são bastante lentas para pequenas matrizes e bastante rápidas para grandes matrizes
• surpreendentemente for-Array(n)(B, C) é muito mais lento no safari que for-[](A)
• surpreendentemente for-[](A) para grande variedade é lento em todos os navegadores
• soluções K é lenta para pequenas matrizes para todos os navegadores
• As soluções A, E, G são lentas para grandes matrizes para todos os navegadores
• solução M é a mais lenta para todas as matrizes em todos os navegadores

Conclusões para a matriz 2D inicializada

• as soluções baseadas em for/while(A, B, C, D, E, G) são mais rápidas / rápidas para pequenas matrizes em todos os navegadores
• as soluções baseadas em for(A, B, C, E) são mais rápidas / rápidas para grandes matrizes em todos os navegadores
• As soluções baseadas em Array..map/from/fill(I, J, K, L, M) são médias ou rápidas ou lentas para pequenas matrizes em todos os navegadores
• As soluções F, G, H, I, J, K, L para grandes matrizes são médias ou rápidas no chrome e safari, mas mais lentas no firefox.
• solução esotérica {}/arr[[i,j]](N) é mais lenta para matrizes pequenas e grandes em todos os navegadores

Detalhes

Teste de soluções que não preenchem (inicializam) a matriz de saída

Testamos a velocidade das soluções para

• matrizes pequenas (12 elementos) - você pode executar testes em sua máquina AQUI
• matrizes grandes (1 milhão de elementos) matrizes - você pode realizar testes em sua máquina AQUI

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

Teste de soluções que preenchem (inicializam) a matriz de saída

Testamos a velocidade das soluções para

• matrizes pequenas (12 elementos) - você pode executar testes em sua máquina AQUI
• matrizes grandes (1 milhão de elementos) matrizes - você pode realizar testes em sua máquina AQUI

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

Eu encontrei abaixo é a maneira mais simples:

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

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

O Javascript não suporta matrizes bidimensionais; em vez disso, armazenamos uma matriz dentro de outra matriz e buscamos os dados dessa matriz, dependendo da posição da matriz que você deseja acessar. Lembre-se de que a numeração da matriz começa em ZERO .

Exemplo 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 + pode fazer isso de maneira ainda mais simples

Criando matriz 3 x 2 preenchida com true

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

Eu tive que criar uma função de matriz flexível para adicionar "registros" a ele conforme necessário e poder atualizá-los e fazer os cálculos necessários antes de enviá-lo para um banco de dados para processamento adicional. Aqui está o código, espero que ajude :).

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

Sinta-se livre para otimizar e / ou apontar quaisquer erros :)

Aqui está uma maneira rápida que encontrei de fazer uma matriz bidimensional.

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

Você pode facilmente transformar essa função em uma função ES5 também.

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

Por que isso funciona: o new Array(n)construtor cria um objeto com um protótipo Array.prototypee depois atribui o objeto length, resultando em uma matriz não preenchida. Devido à falta de membros reais, não podemos executar oArray.prototype.map função nele.

No entanto, quando você fornece mais de um argumento ao construtor, como quando o faz Array(1, 2, 3, 4), o construtor usará o argumentsobjeto para instanciar e preencher umaArray objeto corretamente.

Por esse motivo, podemos usar Array.apply(null, Array(x)), porque a applyfunção espalhará os argumentos no construtor. Para esclarecimento, fazer Array.apply(null, Array(3))é equivalente a fazer Array(null, null, null).

Agora que criamos uma matriz preenchida real, tudo o que precisamos fazer é chamar mape criar a segunda camada ( y).

Abaixo de um, cria uma matriz 5x5 e preenche-os com null

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

console.log(md);

Os tamanhos de linha e coluna de uma matriz conhecida apenas no tempo de execução e o método a seguir pode ser usado para criar uma matriz 2D dinâmica .

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

Existe outra solução, que não o força a pré-definir o tamanho da matriz 2d, e isso é muito conciso.

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

Isso funciona porque, [1,2]é transformado em uma string, usada como uma chave de string para o tableobjeto.

Para criar uma matriz 4x6, basta fazer isso

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