eliminar - ¿Cómo puedo crear una matriz bidimensional en JavaScript?

eliminar un elemento de un array javascript

Question

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

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

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

Answer 1

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

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

2 y 4 siendo primera y segunda dimensiones respectivamente.

Estamos haciendo uso de Array.from , que puede tomar un Array.from 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);

El mismo truco puede usarse 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 debemos tener los primeros valores de dimensión inicializados para ejecutar .map . Recuerde que Array no asignará las posiciones hasta que lo ordene a través de .fill o asignación de valor directo.

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

Seguir

¿Por qué no funciona esto?

 Array(2).fill(Array(4));

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 que un arr[0][0] = ''foo'' 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]);

Answer 2

Utilizar comprensión de matrices

En JavaScript 1.7 y versiones posteriores, puede usar la comprensión de matrices 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 matriz nxm que desee y rellenarla 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 here .

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

Answer 3

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é funciona esto: el new Array(n) constructor new Array(n) crea un objeto con un prototipo de Array.prototype y luego asigna la length del objeto, lo que da como resultado una matriz despoblada. Debido a su falta de miembros reales, no podemos ejecutar la función Array.prototype.map en él.

Sin embargo, cuando proporciona más de un argumento al constructor, como cuando hace Array(1, 2, 3, 4) , el constructor usará el objeto arguments para crear una instancia y rellenar un objeto Array correctamente.

Por esta razón, podemos usar Array.apply(null, Array(x)) , porque la función de apply difundirá 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 real, todo lo que tenemos que hacer es llamar al map y crear la segunda capa ( y ).

Answer 4

Debajo de uno, crea una matriz de 5x5 y rellénalos con null

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

console.log(md);

Answer 5

Dos líneas

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

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

Answer 6

Encontré que este código funciona para mí:

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];
        }
    }
}

Answer 7

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 deletreaba bineeshkumar

Answer 8

Función recursiva para crear una matriz multidimensional:

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

    arr = new Array(dims[0]);

    for (var i=0; i<dims[0]; i++) {
        arr[i] = new Array(dims[1]);
        arr[i] = makeArray(dims.slice(1), arr[i]);
    }

    return arr;
}

Construye un 4x3x4x2 4D-Array:

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

Answer 9

He encontrado a continuación es la forma más sencilla:

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

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

Answer 10

Hice una modificación de la respuesta de Matthew Crumley para crear una función de matriz multidimensional. Agregué las dimensiones de la matriz que se pasarán como variable de matriz y habrá otra variable: value , que se usará para establecer los valores de los elementos de las últimas matrices en la matriz 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]]

Answer 11

Javascript no admite matrices bidimensionales, en lugar de eso, almacenamos una matriz dentro de otra matriz y obtenemos los datos de esa matriz según la posición de la matriz a la que desea acceder. Recuerde que la numeración de matrices 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

Answer 12

Javascript solo tiene matrices unidimensionales, pero puede crear matrices de matrices, como otros lo han señalado.

La siguiente función se puede usar para construir una matriz bidimensional 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 usarla.

Entonces puedes simplemente llamar:

var arr = Create2DArray(100);

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

Answer 13

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

Answer 14

La forma más fácil:

var myArray = [[]];

Answer 15

La razón por la que algunos dicen que no es posible es porque una matriz bidimensional es realmente 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 tenga 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 conflictivos.

Answer 16

La respuesta más sana 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 rellenar directamente con las filas ya que el relleno utiliza 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);

Answer 17

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

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

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

Answer 18

Mi enfoque es muy similar al de @Bineesh pero con un enfoque más general.

Puede declarar la doble matriz 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á la salida esperada

[ 9, 8 ] 9 123

Answer 19

No estoy seguro de que alguien haya respondido esto, pero encontré que esto me funcionó bastante bien.

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

p.ej:

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

Para una matriz bidimensional, por ejemplo.

Answer 20

Para crear una matriz 2D en javaScript, podemos crear una matriz primero 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 utiliza este método como se muestra a continuación.

var array = Create2DArray(10,20);

Answer 21

Para los amantes de un trazador de líneas 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() Fill Array().fill()

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

Answer 22

Pocas personas muestran el uso del empuje:
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

Answer 23

Podría asignar una matriz de filas, donde cada fila es una matriz de la misma longitud. O podría asignar una matriz unidimensional con filas * elementos de columnas y definir métodos para asignar coordenadas de fila / columna a índices de elementos.

Cualquiera que sea la implementación que elija, si lo envuelve en un objeto, puede definir los métodos de acceso en un prototipo para que la API sea fácil de usar.

Answer 24

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

Answer 25

Simplemente hace que cada elemento dentro de la matriz sea una matriz.

var x = new Array(10);

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

console.log(x);

Answer 26

Tuve que hacer una función de matriz flexible para agregarle "registros" cuando lo necesitaba y poder actualizarlos y hacer los cálculos necesarios antes de enviarlos 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 :)

Answer 27

Un ejemplo simplificado:

var blocks = [];

blocks[0] = [];

blocks[0][0] = 7;

Answer 28

Un trazador de líneas para crear una matriz de 2 dimensiones am * n rellena con 0.

new Array(m).fill(new Array(n).fill(0));

Answer 29

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

Answer 30

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 = ''<ol>'';
  for ( var i = 0; i < songs.length; i += 1) {
    listHTML += ''<li>'' + songs[i][0] + '' by '' + songs[i][1] + ''</li>'';
  }
  listHTML += ''</ol>'';
  print(listHTML);
}

printSongs(playList);