Métodos modernos de Array

Los arrays son la estructura de datos más utilizada en JavaScript para almacenar colecciones. Además de los métodos clásicos como push o pop, el lenguaje incluye un conjunto de métodos declarativos que permiten recorrer, filtrar y transformar listas de forma mucho más clara que con bucles for tradicionales.

En esta lección revisamos los métodos más utilizados en el día a día de un desarrollador web: map, filter, find, some, every, includes, flat y flatMap. Todos ellos comparten una característica: reciben una función como argumento (llamada función callback) que se ejecuta para cada elemento del array.

Un método declarativo describe "qué queremos obtener" en lugar de "cómo recorrer la lista paso a paso". Esta forma de escribir código resulta más breve y fácil de leer.

Transformar y filtrar listas

Los dos métodos más frecuentes en cualquier aplicación son map y filter. Ambos devuelven un nuevo array sin modificar el original, lo que favorece un estilo de programación seguro y predecible.

Método map

El método map aplica una función a cada elemento del array y devuelve un nuevo array con los resultados. Es la herramienta adecuada cuando necesitas transformar cada elemento en otro valor.

const precios = [10, 25, 40];
const preciosConIva = precios.map(precio => precio * 1.21);

console.log(preciosConIva); // [12.1, 30.25, 48.4]
console.log(precios); // [10, 25, 40] (el original no cambia)

También funciona con arrays de objetos, extrayendo una propiedad concreta o generando nuevos objetos:

const usuarios = [
    { nombre: "Ana", edad: 30 },
    { nombre: "Luis", edad: 25 },
    { nombre: "Marta", edad: 42 }
];

const nombres = usuarios.map(usuario => usuario.nombre);
console.log(nombres); // ["Ana", "Luis", "Marta"]

Método filter

El método filter crea un array nuevo con los elementos que cumplen una condición. La función callback debe devolver true para conservar el elemento o false para descartarlo.

const numeros = [1, 2, 3, 4, 5, 6, 7, 8];
const pares = numeros.filter(numero => numero % 2 === 0);

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

Combinado con map, permite escribir pipelines de datos muy expresivos:

const productos = [
    { nombre: "Portátil", precio: 1200, stock: 3 },
    { nombre: "Ratón", precio: 25, stock: 0 },
    { nombre: "Teclado", precio: 60, stock: 5 }
];

const disponibles = productos
    .filter(producto => producto.stock > 0)
    .map(producto => producto.nombre);

console.log(disponibles); // ["Portátil", "Teclado"]

Búsqueda y comprobación

A menudo no queremos transformar toda la colección, sino localizar un elemento concreto o comprobar si la lista cumple alguna condición. Para eso existen find, some, every e includes.

Método find

El método find devuelve el primer elemento que cumple una condición. Si ningún elemento la cumple, devuelve undefined.

const libros = [
    { titulo: "Dune", autor: "Herbert" },
    { titulo: "Foundation", autor: "Asimov" },
    { titulo: "Hyperion", autor: "Simmons" }
];

const libroAsimov = libros.find(libro => libro.autor === "Asimov");
console.log(libroAsimov); // { titulo: "Foundation", autor: "Asimov" }

A diferencia de filter, no devuelve un array: devuelve un único elemento. Es ideal cuando sabes que como máximo existe un resultado.

Métodos some y every

Estos dos métodos devuelven un valor booleano:

• 1. some: devuelve true si al menos un elemento cumple la condición.
• 2. every: devuelve true si todos los elementos cumplen la condición.

const edades = [18, 25, 32, 14];

const hayMenores = edades.some(edad => edad < 18);
console.log(hayMenores); // true

const todosMayores = edades.every(edad => edad >= 18);
console.log(todosMayores); // false

Son muy útiles para validaciones, por ejemplo comprobar si un carrito tiene algún producto sin stock o si todos los usuarios están verificados.

Método includes

El método includes comprueba si un array contiene un valor concreto y devuelve true o false. Funciona con tipos primitivos (números, cadenas, booleanos).

const lenguajes = ["javascript", "python", "java", "go"];

console.log(lenguajes.includes("python")); // true
console.log(lenguajes.includes("rust")); // false

Es más claro que usar indexOf seguido de una comparación con -1, que era la forma antigua de hacerlo.

Aplanar arrays con flat y flatMap

Cuando trabajamos con listas de listas (arrays anidados), el método flat aplana la estructura uniendo los sub-arrays en uno solo. Acepta un parámetro opcional para indicar cuántos niveles aplanar.

const anidado = [[1, 2], [3, 4], [5, 6]];
const plano = anidado.flat();
console.log(plano); // [1, 2, 3, 4, 5, 6]

const muyAnidado = [1, [2, [3, [4]]]];
console.log(muyAnidado.flat(2)); // [1, 2, 3, [4]]
console.log(muyAnidado.flat(Infinity)); // [1, 2, 3, 4]

El método flatMap combina un map seguido de un flat de un solo nivel. Es habitual cuando la función de transformación devuelve un array por cada elemento:

const frases = ["hola mundo", "aprender javascript"];
const palabras = frases.flatMap(frase => frase.split(" "));
console.log(palabras); // ["hola", "mundo", "aprender", "javascript"]

Ejemplo integrador

Veamos un ejemplo realista: una lista de pedidos de un comercio donde queremos conocer el total facturado de los pedidos pagados.

const pedidos = [
    { id: 1, cliente: "Ana", total: 45, pagado: true },
    { id: 2, cliente: "Luis", total: 120, pagado: false },
    { id: 3, cliente: "Marta", total: 80, pagado: true },
    { id: 4, cliente: "Carlos", total: 200, pagado: true }
];

const totales = pedidos
    .filter(pedido => pedido.pagado)
    .map(pedido => pedido.total);

console.log(totales); // [45, 80, 200]

El código se lee casi como una frase en español: "de los pedidos, quédate con los pagados y extrae el total". Esta claridad es la gran ventaja de los métodos modernos de Array frente al bucle for tradicional.

const clientesConPedidoGrande = pedidos.some(pedido => pedido.total > 150);
console.log(clientesConPedidoGrande); // true

const cliente = pedidos.find(pedido => pedido.cliente === "Marta");
console.log(cliente); // { id: 3, cliente: "Marta", total: 80, pagado: true }

Como regla práctica: usa map cuando quieras transformar cada elemento, filter cuando quieras conservar solo algunos, find cuando busques uno concreto, some o every para validaciones booleanas e includes para comprobar pertenencia.

Estos métodos sustituyen en la mayoría de casos a los bucles for clásicos y son la forma recomendada de trabajar con arrays en JavaScript moderno.