Como posso criar um array bidimensional em JavaScript?

Eu tenho lido online e alguns lugares dizem que não é possível, alguns dizem que é e então 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] ?)

 var items = [ [1, 2], [3, 4], [5, 6] ]; console.log(items[0][0]); // 1 console.log(items); 

Você simplesmente faz com que cada item dentro da matriz seja um array.

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

Semelhante à resposta dativa, aqui está uma function 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 só tem arrays unidimensionais, mas você pode construir arrays de arrays, como outros apontaram.

A seguinte function pode ser usada para construir um array bidimensional de dimensões fixas:

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

O número de colunas não é realmente importante, porque não é necessário especificar o tamanho de um array antes de usá-lo.

Então você pode apenas ligar:

 var arr = Create2DArray(100); arr[50][2] = 5; arr[70][5] = 7454; // ... 

A maneira mais fácil:

 var myArray = [[]]; 

A razão pela qual alguns dizem que não é possível é porque uma matriz bidimensional é realmente apenas uma matriz de matrizes. Os outros comentários aqui fornecem methods perfeitamente válidos de criação de matrizes bidimensionais em JavaScript, mas o ponto de vista mais puro seria que você tem uma matriz unidimensional de objects, cada um desses objects seria uma matriz unidimensional composta de 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, exemplo: 0 ou uma string vazia “”.
Lembrando que se você tem 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-liner:

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

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

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

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

Os arrays bidimensionais são criados da mesma forma que os arrays unidimensionais são. E você os acessa como array[0][1] .

 var arr = [1, 2, [3, 4], 5]; alert (arr[2][1]); //alerts "4" 

Como criar uma matriz bidimensional vazia (uma linha)

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

2 e 4 sendo as primeiras e segundas dimensões, respectivamente.

Estamos usando o Array.from , que pode ter um parâmetro de 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); 

Eu não tenho certeza se alguém respondeu isso, mas eu achei que isso funcionou muito bem para mim –

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

por exemplo:

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

Para um array bidimensional, por exemplo.

Para criar um array 2D em javaScript, podemos criar um Array primeiro e depois adicionar Arrays como elementos. Este método retornará um array 2D com o número 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 um Array use este método como abaixo.

 var array = Create2DArray(10,20); 

Use Compreensão de Array

No JavaScript 1.7 e superior, você pode usar as compreensões de matriz para criar matrizes bidimensionais. Você também pode filtrar e / ou manipular as inputs 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 array nxm que desejar e preenchê-lo 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 .

Por favor, note que este não é um recurso padrão ainda .

Para amantes de um forro 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")); 

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

Você pode declarar a matriz dupla da seguinte maneira:

 var myDoubleArray = [[]]; 

E o armazenamento e acessando o 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'],) 

Isto irá imprimir a saída esperada

 [ 9, 8 ] 9 123 

Eu encontrei abaixo é a maneira mais simples:

 var array1 = [[]]; array1[0][100] = 5; alert(array1[0][100]); alert(array1.length); alert(array1[0].length); 

Eu tive que fazer uma function de matriz flexível para adicionar “registros” a ela como eu precisava e para poder atualizá-los e fazer quaisquer cálculos necessários antes de enviá-los para um database 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 🙂

O Javascript não suporta arrays bidimensionais, em vez disso, armazenamos um array dentro de outro array e buscamos os dados desse array, dependendo da posição do array que você deseja acessar. Lembre-se de que a numeração de array 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 

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

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

Você pode facilmente transformar essa function em uma function 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 new Array(n) cria um object com um protótipo de Array.prototype e, em seguida, atribui o length do object, resultando em uma matriz não preenchida. Devido à falta de membros reais, não podemos executar a function Array.prototype.map nele.

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

Por este motivo, podemos usar Array.apply(null, Array(x)) , porque a function apply irá espalhar os argumentos no construtor. Para esclarecimentos, fazer Array.apply(null, Array(3)) é equivalente a fazer Array(null, null, null) .

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

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

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

Você pode alocar uma matriz de linhas, onde cada linha é uma matriz do mesmo tamanho. Ou você pode alocar uma matriz unidimensional com elementos rows * columns e definir methods para mapear coordenadas de linha / coluna para índices de elementos.

Seja qual for a implementação escolhida, se você envolvê-la em um object, poderá definir os methods de access em um protótipo para tornar a API fácil de usar.

Eu achei que esse código funciona para mim:

 var map = [ [] ]; mapWidth = 50; mapHeight = 50; fillEmptyMap(map, mapWidth, mapHeight); 

 function fillEmptyMap(array, width, height) { for (var x = 0; x < width; x++) { array[x] = []; for (var y = 0; y < height; y++) { array[x][y] = [0]; } } } 

Um exemplo simplificado:

 var blocks = []; blocks[0] = []; blocks[0][0] = 7; 
 var playList = [ ['I Did It My Way', 'Frank Sinatra'], ['Respect', 'Aretha Franklin'], ['Imagine', 'John Lennon'], ['Born to Run', 'Bruce Springsteen'], ['Louie Louie', 'The Kingsmen'], ['Maybellene', 'Chuck Berry'] ]; function print(message) { document.write(message); } function printSongs( songs ) { var listHTML = '
    '; for ( var i = 0; i < songs.length; i += 1) { listHTML += '
  1. ' + songs[i][0] + ' by ' + songs[i][1] + ''; } listHTML += '
'; print(listHTML); } printSongs(playList);

Eu fiz uma modificação da resposta de Matthew Crumley para criar uma function de array multidimensional. Eu adicionei as dimensões da matriz a ser passada como variável de matriz e haverá outro value variável, que será usado para definir os valores dos elementos das últimas matrizes no array multidimensional.

 /* * Function to create an n-dimensional array * * @param array dimensions * @param any type value * * @return array array */ function createArray(dimensions, value) { // Create new array var array = new Array(dimensions[0] || 0); var i = dimensions[0]; // If dimensions array's length is bigger than 1 // we start creating arrays in the array elements with recursions // to achieve multidimensional array if (dimensions.length > 1) { // Remove the first value from the array var args = Array.prototype.slice.call(dimensions, 1); // For each index in the created array create a new array with recursion while(i--) { array[dimensions[0]-1 - i] = createArray(args, value); } // If there is only one element left in the dimensions array // assign value to each of the new array's elements if value is set as param } else { if (typeof value !== 'undefined') { while(i--) { array[dimensions[0]-1 - i] = value; } } } return array; } createArray([]); // [] or new Array() createArray([2], 'empty'); // ['empty', 'empty'] createArray([3, 2], 0); // [[0, 0], // [0, 0], // [0, 0]] 

Função recursiva para criar uma multidimensional array:

 var makeArray = function (dims, arr) { if (dims[1] === undefined) { return new Array(dims[0]); } arr = new Array(dims[0]); for (var i=0; i 

Construa um 4D-Array 2x3x4x2:

 var array = makeArray([2, 3, 4, 2]); 

Você também pode criar uma function para criar um array 2D como este:

 var myTable = []; function createArray(myLength) { myTable = new Array(myLength); var cols, rows; for (cols = 0; cols < myLength; cols++) { myTable[cols] = new Array(myLength); } } 

Você pode chamá-lo usando o seguinte, que lhe dará uma matriz 2D 10x10.

 createArray(10); 

Você também pode criar um array 3D usando esse método.