Las matrices son una de las estructuras de datos más fundamentales en JavaScript. Con una matriz, puede almacenar múltiples valores en una sola variable. JavaScript proporciona numerosos métodos integrados para manipular matrices, lo que las hace increíblemente versátiles. En esta publicación, exploraremos todos los métodos de matriz integrados y cómo usarlos de manera efectiva en sus proyectos de JavaScript.

Métodos básicos

para cada()

El método forEach() le permite iterar sobre una matriz y ejecutar una función proporcionada una vez para cada elemento de la matriz. Es una forma sencilla de recorrer una matriz.

const array = [1, 2, 3, 4, 5];

array.forEach((element) => {
  console.log(element);
});

mapa()

El método map() crea una nueva matriz llena con los resultados de llamar a una función proporcionada en cada elemento de la matriz. Normalmente se utiliza para transformar datos.

const array = [1, 2, 3, 4, 5];

const doubled = array.map((element) => element * 2);

console.log(doubled); // [2, 4, 6, 8, 10]

filtrar()

El método filter() crea una nueva matriz con todos los elementos que pasan la prueba implementada por la función proporcionada. Es útil cuando necesitas filtrar ciertos elementos de una matriz según una condición.

const array = [1, 2, 3, 4, 5];

const evenNumbers = array.filter((element) => element % 2 === 0);

console.log(evenNumbers); // [2, 4]

reducir()

El método reduce() ejecuta una función reductora en cada elemento de la matriz, lo que da como resultado un único valor de salida. A menudo se usa para sumar valores, acumular totales o fusionar matrices en un solo valor.

const array = [1, 2, 3, 4, 5];

const sum = array.reduce((accumulator, currentValue) => accumulator   currentValue, 0);

console.log(sum); // 15

encontrar()

El método find() devuelve el valor del primer elemento de la matriz que satisface la función de prueba proporcionada. Se detiene después de encontrar la primera coincidencia.

const array = [1, 2, 3, 4, 5];

const found = array.find((element) => element > 3);

console.log(found); // 4

encontrar índice()

El método findIndex() devuelve el índice del primer elemento de la matriz que satisface la función de prueba proporcionada. Si ningún elemento satisface la función de prueba, devuelve -1.

const array = [1, 2, 3, 4, 5];

const index = array.findIndex((element) => element > 3);

console.log(index); // 3

clasificar()

El método sort() ordena los elementos de una matriz en su lugar y devuelve la matriz ordenada. Se usa comúnmente para ordenar cadenas y números, pero puede requerir una función de comparación para ordenar los números correctamente.

const array = [5, 3, 8, 1, 2];

const sortedArray = array.sort((a, b) => a - b);

console.log(sortedArray); // [1, 2, 3, 5, 8]

contrarrestar()

El método reverse() invierte los elementos de una matriz en su lugar. El primer elemento de la matriz se convierte en el último y el último se convierte en el primero.

const array = [1, 2, 3, 4, 5];

const reversedArray = array.reverse();

console.log(reversedArray); // [5, 4, 3, 2, 1]

concat()

El método concat() se utiliza para fusionar dos o más matrices. Devuelve una nueva matriz, sin modificar las matrices originales.

const array1 = [1, 2, 3];
const array2 = [4, 5, 6];

const concatenatedArray = array1.concat(array2);

console.log(concatenatedArray); // [1, 2, 3, 4, 5, 6]

rebanada()

El método slice() devuelve una copia superficial de una parte de una matriz en un nuevo objeto de matriz seleccionado de principio a fin (final no incluido).

const array = [1, 2, 3, 4, 5];

const slicedArray = array.slice(1, 4);

console.log(slicedArray); // [2, 3, 4]

empalme()

El método splice() cambia el contenido de una matriz eliminando, reemplazando o agregando elementos.

const array = [1, 2, 3, 4, 5];

array.splice(2, 1, 6, 7);

console.log(array); // [1, 2, 6, 7, 4, 5]

empujar()

El método push() agrega uno o más elementos al final de una matriz y devuelve la nueva longitud de la matriz.

const array = [1, 2, 3];

array.push(4, 5);

console.log(array); // [1, 2, 3, 4, 5]

estallido()

El método pop() elimina el último elemento de una matriz y devuelve ese elemento.

const array = [1, 2, 3, 4, 5];

const lastElement = array.pop();

console.log(lastElement); // 5
console.log(array); // [1, 2, 3, 4]

cambio()

El método shift() elimina el primer elemento de una matriz y devuelve ese elemento.

const array = [1, 2, 3, 4, 5];

const firstElement = array.shift();

console.log(firstElement); // 1
console.log(array); // [2, 3, 4, 5]

desactivar()

El método unshift() agrega uno o más elementos al comienzo de una matriz y devuelve la nueva longitud de la matriz.

const array = [2, 3, 4, 5];

array.unshift(1);

console.log(array); // [1, 2, 3, 4, 5]

unirse()

El método join() crea y devuelve una nueva cadena concatenando todos los elementos de una matriz, separados por comas o una cadena separadora especificada.

const array = [1, 2, 3, 4, 5];

const joinedString = array.join('-');

console.log(joinedString); // "1-2-3-4-5"

Métodos adicionales

cada()

El método each() prueba si todos los elementos de la matriz pasan la función de prueba proporcionada.

const array = [2, 4, 6, 8];

const allEven = array.every((element) => element % 2 === 0);

console.log(allEven); // true

alguno()

El método some() prueba si al menos un elemento de la matriz pasa la función de prueba proporcionada.

const array = [1, 2, 3, 4, 5];

const hasEven = array.some((element) => element % 2 === 0);

console.log(hasEven); // true

departamento()

El método flat() crea una nueva matriz con todos los elementos de la submatriz concatenados en ella de forma recursiva hasta la profundidad especificada.

const array = [1, [2, [3, [4]]]];

const flattenedArray = array.flat(2);

console.log(flattenedArray); // [1, 2, 3, [4]]

mapa plano()

El método flatMap() primero asigna cada elemento usando una función de mapeo y luego aplana el resultado en una nueva matriz. Es una combinación de map() y flat().

const array = [1, 2, 3, 4];

const flattened = array.flatMap((num) => [num, num * 2]);

console.log(flattened); // [1, 2, 2, 4, 3, 6, 4, 8]

llenar()

El método fill() llena todos los elementos de una matriz con un valor estático desde un índice inicial hasta un índice final.

const array = [1, 2, 3, 4, 5];

array.fill(0, 2, 4);

console.log(array); // [1, 2, 0, 0, 5]

copiar dentro()

El método copyWithin() copia superficialmente parte de una matriz a otra ubicación en la misma matriz sin modificar su longitud.

const array = [1, 2, 3, 4, 5];

array.copyWithin(0, 3, 5);

console.log(array); // [4, 5, 3, 4, 5]

incluye()

El método incluye() comprueba si una matriz contiene un valor determinado.

const array = [1, 2, 3, 4, 5];

const hasThree =

 array.includes(3);

console.log(hasThree); // true

a cadena()

El método toString() convierte una matriz en una cadena, separada por comas.

const array = [1, 2, 3, 4, 5];

const arrayString = array.toString();

console.log(arrayString); // "1,2,3,4,5"

índice de()

El método indexOf() devuelve el primer índice en el que se puede encontrar un elemento determinado en la matriz, o -1 si no está presente.

const array = [1, 2, 3, 4, 5];

const index = array.indexOf(3);

console.log(index); // 2

último índice de()

El método lastIndexOf() devuelve el último índice en el que se puede encontrar un elemento determinado en la matriz, o -1 si no está presente.

const array = [1, 2, 3, 4, 3, 5];

const lastIndex = array.lastIndexOf(3);

console.log(lastIndex); // 4

de()

El método Array.from() crea una nueva instancia de matriz a partir de un objeto iterable o similar a una matriz.

const array = Array.from('hello');

console.log(array); // ['h', 'e', 'l', 'l', 'o']

esmatriz()

El método Array.isArray() comprueba si el valor pasado es una matriz.

const array = [1, 2, 3, 4, 5];
const notArray = { a: 1, b: 2 };

console.log(Array.isArray(array)); // true
console.log(Array.isArray(notArray)); // false

de()

El método Array.of() crea una nueva instancia de matriz con un número variable de elementos.

const array1 = Array.of(1, 2, 3);
const array2 = Array.of('a', 'b', 'c');

console.log(array1); // [1, 2, 3]
console.log(array2); // ['a', 'b', 'c']

Conclusión

Las matrices de JavaScript vienen con una amplia gama de métodos integrados que permiten una poderosa manipulación de datos. Comprender estos métodos le hará más eficiente a la hora de escribir código limpio y conciso. Tómate un tiempo para experimentar con estos métodos y ver cómo pueden mejorar tu código.
Publicado originalmente: Guía de métodos de matriz de JavaScript