Menos bucles, más intención
Casi todos los bucles sobre arrays hacen una de pocas cosas: transformar cada elemento, quedarse con algunos, buscar uno o calcular un total. JavaScript trae un método para cada tarea. Reciben una función que se ejecuta con cada elemento y dejan claro qué quieres hacer, no cómo recorrer.
Todos los ejemplos usan este array:
const productos = [
{ nombre: "Teclado", precio: 80, stock: 5 },
{ nombre: "Mouse", precio: 25, stock: 0 },
{ nombre: "Monitor", precio: 300, stock: 2 },
];
Cada elemento es un objeto con propiedades; se lee con producto.nombre. Los objetos tienen su propia lección a continuación, pero esto basta por ahora.
forEach: hacer algo con cada uno
forEach ejecuta la función con cada elemento. No devuelve nada; sirve para efectos como mostrar:
productos.forEach((p) => console.log(p.nombre));
// Teclado
// Mouse
// Monitor
La función también recibe el índice como segundo argumento: (p, i) => ....
map: transformar
map devuelve un array nuevo con el resultado de aplicar la función a cada elemento. El original no cambia, y el nuevo tiene el mismo largo:
const nombres = productos.map((p) => p.nombre);
console.log(nombres.join(", ")); // Teclado, Mouse, Monitor
const conDescuento = [10, 20, 30].map((n) => n * 0.9);
console.log(conDescuento.join(" ")); // 9 18 27
filter: quedarse con algunos
filter devuelve un array nuevo con los elementos para los que la función devuelve true:
const disponibles = productos.filter((p) => p.stock > 0);
console.log(disponibles.length); // 2
const pares = [1, 2, 3, 4, 5, 6].filter((n) => n % 2 === 0);
console.log(pares.join(",")); // 2,4,6
find: buscar uno
find devuelve el primer elemento que cumple la condición, o undefined si ninguno la cumple. Hay un pariente, findIndex, que devuelve su posición (o -1):
const monitor = productos.find((p) => p.nombre === "Monitor");
console.log(monitor.precio); // 300
const caro = productos.find((p) => p.precio > 1000);
console.log(caro); // undefined
some y every: preguntas de sí o no
somedevuelvetruesi al menos uno cumple.everydevuelvetruesi todos cumplen.
console.log(productos.some((p) => p.stock === 0)); // true
console.log(productos.every((p) => p.precio > 10)); // true
reduce: combinar en un valor
reduce recorre el array llevando un acumulador. En cada paso, la función recibe el acumulador y el elemento actual, y devuelve el nuevo acumulador. El segundo argumento de reduce es el valor inicial:
const total = [10, 20, 30].reduce((acumulado, n) => acumulado + n, 0);
console.log(total); // 60
Paso a paso:
| Paso | acumulado |
n |
Devuelve |
|---|---|---|---|
| 1 | 0 (inicial) |
10 |
10 |
| 2 | 10 |
20 |
30 |
| 3 | 30 |
30 |
60 |
Con objetos:
const valorInventario = productos.reduce((suma, p) => suma + p.precio * p.stock, 0);
console.log(valorInventario); // 1000
Encadenar métodos
Como map y filter devuelven arrays, puedes encadenarlos. Se lee de arriba hacia abajo, como una receta:
const nombresDisponibles = productos
.filter((p) => p.stock > 0)
.map((p) => p.nombre.toUpperCase());
console.log(nombresDisponibles.join(", ")); // TECLADO, MONITOR
Resumen
| Método | Devuelve | Úsalo para |
|---|---|---|
forEach |
undefined |
Hacer algo con cada elemento |
map |
Array del mismo largo | Transformar |
filter |
Array igual o más corto | Seleccionar |
find |
Un elemento o undefined |
Buscar el primero |
some / every |
Booleano | Preguntar |
reduce |
Un valor | Totales, combinaciones |
Ninguno de estos métodos modifica el array original. Esa es una gran ventaja: puedes usarlos sin miedo a romper datos que otra parte del programa necesita.