Contenido del curso
Arrays a profundidad
Los arrays en JavaScript son un tipo de estructura de datos que permite almacenar múltiples valores en una sola variable. A diferencia de las variables simples como los números o las cadenas de texto, los arrays pueden tener múltiples valores y elementos.
En esta clase, vamos a explorar algunas de las características avanzadas de los arrays en JavaScript, incluyendo la creación de arrays utilizando la clase constructora Array, copiar arrays, arrays bidimensionales y arrays de múltiples dimensiones.
Creación de Arrays utilizando la Clase Constructora Array
En JavaScript, los arrays se pueden crear de una forma diferente a la tradicional utilizando la clase constructora Array. La clase constructora Array proporciona una forma fácil y flexible de crear arrays con diferentes elementos y longitudes.
let myArray = new Array();
También puedes especificar los elementos que deseas incluir en el array al crearlo, como se muestra a continuación:
let myArray = new Array(1, 2, 3, 4);
Array.from()
La función Array.from() permite crear un nuevo array a partir de un objeto similar a un array o iterable. La sintaxis para utilizar Array.from() es la siguiente:
let myArray = Array.from('hello'); console.log(myArray); // ["h", "e", "l", "l", "o"]
Array(n).fill()
La función fill() permite llenar un array con un valor específico. La sintaxis para utilizar fill() es la siguiente:
let myArray = new Array(5).fill(0); console.log(myArray); // [0, 0, 0, 0, 0]
Array.isArray()
La función Array.isArray() permite determinar si un objeto es un array o no. La sintaxis para utilizar Array.isArray() es la siguiente:
let myArray = [1, 2, 3, 4]; console.log(Array.isArray(myArray)); // true
Copiando Arrays
En JavaScript, es común tener la necesidad de hacer una copia de un array existente, ya sea para manipular los datos sin afectar el array original o para trabajar con múltiples versiones del mismo array. Hay varias maneras de hacer esto en JavaScript, incluyendo la creación de una nueva instancia de un array, el uso de métodos incorporados y el uso del spread operator.
Crear una nueva instancia del array:
Una forma de hacer una copia de un array es crear una nueva instancia del mismo array. Esto se logra usando el constructor Array:
const originalArray = [1, 2, 3, 4]; const copiedArray = new Array(...originalArray); console.log(originalArray === copiedArray); // Output: false
En este ejemplo, se utiliza el operador spread para expandir los elementos del array original en una nueva instancia del constructor Array.
Uso de métodos incorporados:
Otro enfoque para hacer una copia de un array es utilizar los métodos incorporados de JavaScript. Por ejemplo, puedes utilizar el método slice para hacer una copia de un array:
const originalArray = [1, 2, 3, 4]; const copiedArray = originalArray.slice(); console.log(originalArray === copiedArray); // Output: false
Otro método incorporado es el método concat:
const originalArray = [1, 2, 3, 4]; const copiedArray = originalArray.concat(); console.log(originalArray === copiedArray); // Output: false
spread operator:
El spread operator es una forma conveniente de hacer una copia de un array. El spread operator se utiliza para expandir los elementos de un array en una lista:
const originalArray = [1, 2, 3, 4]; const copiedArray = [...originalArray]; console.log(originalArray === copiedArray); // Output: false
En este ejemplo, se utiliza el spread operator para expandir los elementos del array original en una nueva instancia de un array.
Es importante tener en cuenta que, aunque estos métodos parecen hacer una copia de un array, solo hacen una copia superficial, lo que significa que los elementos dentro del array original y la copia comparten los mismos valores. Si necesitas hacer una copia profunda de un array, es necesario utilizar una biblioteca de terceros o escribir tu propia función para hacer una copia profunda.
Arrays Bidimensionales
Los arrays bidimensionales son un tipo de estructura de datos en la que cada elemento es un array y cada uno de esos arrays contiene más elementos. En otras palabras, son arrays de arrays. Estos pueden ser útiles para representar datos en un formato más organizado, como una tabla o una matriz.
Para crear un array bidimensional, puedes inicializar un array vacío y luego agregar arrays a sus elementos. Aquí hay un ejemplo:
const matrix = []; matrix[0] = [1, 2, 3]; matrix[1] = [4, 5, 6]; matrix[2] = [7, 8, 9]; console.log(matrix); // Output: [ // [1, 2, 3], // [4, 5, 6], // [7, 8, 9] // ]
También puedes crear un array bidimensional utilizando la clase constructora Array:
const matrix = new Array(3); for (let i = 0; i < matrix.length; i++) { matrix[i] = new Array(3); } matrix[0][0] = 1; matrix[0][1] = 2; matrix[0][2] = 3; matrix[1][0] = 4; matrix[1][1] = 5; matrix[1][2] = 6; matrix[2][0] = 7; matrix[2][1] = 8; matrix[2][2] = 9; console.log(matrix); // Output: [ // [1, 2, 3], // [4, 5, 6], // [7, 8, 9] // ]
Para acceder a un elemento específico en un array bidimensional, debes proporcionar dos índices. Por ejemplo, si deseas acceder al elemento 5 en el ejemplo anterior, puedes hacerlo de la siguiente manera:
console.log(matrix[1][1]); // Output: 5
Además de crear y acceder a los elementos de un array bidimensional, también puedes copiar un array bidimensional utilizando el spread operator:
const originalMatrix = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]; const copiedMatrix = [...originalMatrix]; console.log(originalMatrix === copiedMatrix); // Output: false
En este ejemplo, el spread operator se utiliza para crear una copia profunda del array original, lo que significa que los elementos dentro del array también se copian.
Además de los arrays bidimensionales, también puedes crear arrays de más dimensiones. Por ejemplo, puedes crear un array tridimensional:
const cube = []; for (let i = 0; i < 3; i++) { cube[i] = []; for (let j = 0; j < 3; j++) { cube[i][j] = []; for (let k = 0; k < 3; k++) { cube[i][j][k] = i + j + k; } } } console.log(cube); // Output: //[ // [[0, 1, 2], [1, 2, 3], [2, 3, 4]], // [[1, 2, 3], [2, 3, 4], [3, 4, 5]], // [[2, 3, 4], [3, 4, 5], [4, 5, 6]] //]
Como puedes ver, los arrays de más dimensiones siguen la misma lógica de los arrays bidimensionales, pero con más niveles de índices para acceder a los elementos.
Puedes profundizar en estos temas viendo el Curso de Manipulación de Arrays en JavaScript
Ameth Ordoñez Erazo
student
Juan Pablo Cortés
student
Javier Alvarez Tarazona
student
Alfonso Neil Jiménez Casallas
student
Luis Castro
student
Rubén Ernesto Aragón Gil
studentEn Javascript, hasta hace poco, no existía una forma oficial y fácil de hacer copias profundas de objetos y arreglos. Ahora existe una nueva API que crea copias profundas llamado structuredClone, el cual tiene un gran soporte con los navegadores actuales:
const obj = { a: { b: true } } const deepCopy = structuredClone(obj)
Históricamente se han usado bibliotecas o el hack de JSON.stringify() para ello, pero ya no es necesario.
¿Qué te parece esta novedad de Javascript?
Añado link de la documentación al aporte de Ameth: https://developer.mozilla.org/en-US/docs/Web/API/structuredClone
Array de cuatro dimensiones:
const array4D = []; for (let i = 0; i < 3; i++) { array4D[i] = []; for (let j = 0; j < 3; j++) { array4D[i][j] = []; for (let k = 0; k < 3; k++) { array4D[i][j][k] = []; for (let l = 0; l < 3; l++) { array4D[i][j][k][l] = i + j + k + l; } } } } console.log(array4D);
este algoritmo tiene complejidad temporal 0(n^4)
Características avanzadas de arrays:
. Clase constructora Array: Además de la forma literal de crear arrays, también podemos utilizar la clase constructora Array para crearlos. Por ejemplo:
const array1 = new Array(3); console.log(array1); // [undefined, undefined, undefined]
Copiar arrays: Podemos copiar arrays de varias maneras, por ejemplo:
const array1 = [1, 2, 3]; const array2 = array1.slice(); // Copiar con slice const array3 = [...array1]; // Copiar con spread operator const array4 = Array.from(array1); // Copiar con Array.from
Arrays bidimensionales: En JavaScript, también podemos crear arrays bidimensionales para almacenar datos de dos dimensiones. Por ejemplo:
const array2D = [ [1, 2], [3, 4], ]; console.log(array2D[0][1]); // 2
Arrays de múltiples dimensiones: Podemos crear arrays de más de dos dimensiones en JavaScript utilizando técnicas como arrays de arrays. Por ejemplo:
const array3D = [ [[1, 2], [3, 4]], [[5, 6], [7, 8]], ]; console.log(array3D[0][0][1]); // 2
Quiero transcribir esta lógica, espero tener algo de razón, en caso de no, me pueden ayudar, no me enojo:
const cube = []; for (let i = 0; i < 3; i++) { cube[i] = []; for (let j = 0; j < 3; j++) { cube[i][j] = []; for (let k = 0; k < 3; k++) { cube[i][j][k] = i + j + k; } } }
cube será un array, el primer for se encarga de tener 3 array en lista;
[ [ ], [ ], [ ] ]
El segundo for crea otros 3 array dentro del array padre. Creo que quedaría así:
[[ ], [ ], [ ]], [[ ], [ ], [ ]], [[ ], [ ], [ ]]
El tercer for inserta una serie de números, en los 3 respectivos arrays y sub arrays:
[[0, 1, 2], [1, 2, 3], [2, 3, 4]], [[1, 2, 3], [2, 3, 4], [3, 4, 5]], [[2, 3, 4], [3, 4, 5], [4, 5, 6]]
