Nivel inicial20 min de lectura · Publicado el

Métodos de arrays en JavaScript: map, filter, reduce, some

Métodos de arrays en JavaScript: find recorre [5, 12, 8, 130, 44] y devuelve 12, el primero mayor que 10; alrededor, otros métodos. find: el primero que cumplerubentejera.com 512813044find(x => x > 10)→ 12sortreducesomeeveryfindIndexsplicetoSorted
find prueba cada elemento en orden y se para en el primero que cumple: 12, aunque 130 y 44 también son mayores que 10. Cada método resuelve una pregunta sobre la lista sin escribir el bucle a mano.

Los métodos de arrays en JavaScript son funciones que ya trae cada array para hacer una operación concreta sobre la lista: transformarla, filtrarla, buscar en ella, ordenarla o resumirla en un valor. Te ahorran escribir el bucle a mano y, sobre todo, dejan claro qué quieres hacer.

Un array es una lista ordenada de valores, y cada valor ocupa una posición, su índice, que empieza en 0. La referencia completa de todos los métodos está en la página Array de MDN, la documentación de Mozilla. Aquí tienes los más habituales, explicados con ejemplos que puedes copiar.

Todos los ejemplos se han ejecutado con Node 24.21.0. Las salidas son las que imprime console.log en Node; en el navegador se ven igual, salvo el formato.

Chuleta: los métodos de arrays de un vistazo

Método Para qué sirve Devuelve ¿Cambia el array?
map(fn) Transformar cada elemento Un array nuevo del mismo tamaño No
filter(fn) Quedarse con los que cumplen Un array nuevo, quizá más corto No
forEach(fn) Hacer algo con cada elemento undefined No (salvo que tu función lo cambie)
reduce(fn, inicial) Combinar todos en un valor Un único valor No
find(fn) El primero que cumple El elemento o undefined No
findIndex(fn) La posición del primero que cumple El índice o -1 No
some(fn) ¿Alguno cumple? true / false No
every(fn) ¿Todos cumplen? true / false No
includes(valor) ¿Está este valor? true / false No
indexOf(valor) ¿En qué posición está este valor? El índice o -1 No
sort(fn) Ordenar El mismo array, ordenado Sí
toSorted(fn) Ordenar sin tocar el original Un array nuevo No
push() / pop() Añadir / quitar al final La nueva longitud / el elemento quitado Sí
unshift() / shift() Añadir / quitar al principio La nueva longitud / el elemento quitado Sí
splice() Quitar o meter en medio Los elementos quitados Sí
slice(inicio, fin) Sacar un trozo Un array nuevo No
join(separador) Unir en un texto Un string No

fn es la función que le pasas al método. Casi siempre recibe el elemento, y además su índice y el array completo por si los necesitas: (elemento, indice, array).

map(): transformar cada elemento

map() aplica tu función a cada elemento y devuelve un array nuevo con los resultados. El original no cambia, y el nuevo tiene siempre el mismo número de elementos.

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

console.log(conIva);
console.log(precios);

const usuarios = [
  { nombre: "Ana", edad: 34 },
  { nombre: "Luis", edad: 17 },
  { nombre: "Marta", edad: 25 },
];
console.log(usuarios.map((usuario) => usuario.nombre));
[ 12.1, 30.25, 4.84 ]
[ 10, 25, 4 ]
[ 'Ana', 'Luis', 'Marta' ]

El segundo caso es de los más frecuentes: sacar un solo campo de una lista de objetos. Si los objetos te resultan nuevos, tienes qué es un objeto en JavaScript.

filter(): quedarse con algunos

filter() prueba cada elemento con tu función y devuelve un array nuevo solo con los que dan true. Si ninguno cumple, devuelve un array vacío, nunca undefined.

const usuarios = [
  { nombre: "Ana", edad: 34 },
  { nombre: "Luis", edad: 17 },
  { nombre: "Marta", edad: 25 },
];
const mayoresDeEdad = usuarios.filter((usuario) => usuario.edad >= 18);

console.log(mayoresDeEdad);
console.log(usuarios.filter((usuario) => usuario.edad > 99));
[ { nombre: 'Ana', edad: 34 }, { nombre: 'Marta', edad: 25 } ]
[]

Los objetos de mayoresDeEdad no son copias: son los mismos objetos de usuarios. Si cambias mayoresDeEdad[0].edad, también cambia en la lista original. MDN lo llama copia superficial, y se explica en paso por valor y por referencia en JavaScript.

forEach(): recorrer el array

forEach() ejecuta tu función una vez por elemento y no devuelve nada (undefined). Sirve para hacer algo con cada uno: mostrarlo, guardarlo, enviarlo.

const tareas = ["comprar pan", "llamar al taller", "enviar factura"];

tareas.forEach((tarea, indice) => {
  console.log(`${indice + 1}. ${tarea}`);
});

const resultado = tareas.forEach((tarea) => tarea.toUpperCase());
console.log(resultado);
1. comprar pan
2. llamar al taller
3. enviar factura
undefined

La diferencia con map() está en la última línea: si quieres un array con los resultados, usa map(). Si solo quieres recorrer, forEach().

Dos límites que conviene conocer, según MDN:

  • No se puede parar. No hay break dentro de forEach(); la única forma de cortarlo es lanzar una excepción. Si necesitas parar, usa for...of, find() o some().
  • No espera a las promesas. Si tu función es async, forEach() no espera a que termine. Para recorrer con await, usa for...of.
const temperaturas = [18, 21, 35, 19, 40];

for (const temperatura of temperaturas) {
  if (temperatura > 30) {
    console.log(`Alerta: ${temperatura} grados`);
    break;
  }
}
Alerta: 35 grados

reduce(): de muchos valores a uno

reduce() recorre el array y va acumulando un resultado. Recibe una función (acumulado, elemento) y un valor inicial. Lo que devuelve tu función en cada paso pasa a ser el acumulado del siguiente.

const carrito = [
  { producto: "pan", precio: 1.2 },
  { producto: "leche", precio: 0.95 },
  { producto: "café", precio: 4.5 },
];
const total = carrito.reduce((acumulado, linea) => acumulado + linea.precio, 0);
console.log(total);
6.65

Paso a paso:

Paso acumulado linea.precio Devuelve
1 0 (el inicial) 1.2 1.2
2 1.2 0.95 2.15
3 2.15 4.5 6.65

El resultado no tiene por qué ser un número. Este ejemplo cuenta cuántas veces aparece cada valor y devuelve un objeto:

const votos = ["sí", "no", "sí", "sí", "abstención"];
const recuento = votos.reduce((cuenta, voto) => {
  cuenta[voto] = (cuenta[voto] ?? 0) + 1;
  return cuenta;
}, {});
console.log(recuento);
{ 'sí': 3, no: 1, 'abstención': 1 }

find() y findIndex(): buscar el primero que cumple

find() recorre el array en orden y se para en el primer elemento que cumple. Lo devuelve a él; si no hay ninguno, undefined. findIndex() hace lo mismo pero devuelve su posición, o -1.

const numeros = [5, 12, 8, 130, 44];

console.log(numeros.find((n) => n > 10));
console.log(numeros.find((n) => n > 1000));
console.log(numeros.findIndex((n) => n > 10));
console.log(numeros.findIndex((n) => n > 1000));
console.log(numeros.findLast((n) => n > 10));
console.log(numeros.findLastIndex((n) => n > 10));
console.log(numeros.filter((n) => n > 10));
12
undefined
1
-1
44
4
[ 12, 130, 44 ]

Es lo que muestra la portada: find() da 12 aunque 130 y 44 también sean mayores que 10, porque se para en el primero. Si los quieres todos, la última línea: filter(). Para buscar desde el final están findLast() y findLastIndex().

some() y every(): ¿alguno cumple?, ¿todos cumplen?

some() (el método Array.prototype.some()) devuelve true si al menos un elemento cumple la condición. every() devuelve true si la cumplen todos. Los dos se detienen en cuanto conocen la respuesta: some() en el primero que cumple y every() en el primero que no.

const notas = [7, 4, 9, 6];

console.log(notas.some((nota) => nota < 5));
console.log(notas.every((nota) => nota >= 5));
console.log([].some((nota) => nota < 5));
console.log([].every((nota) => nota >= 5));
true
false
false
true

Las dos últimas líneas sorprenden: con un array vacío, some() da false (no hay ninguno que cumpla) y every() da true (no hay ninguno que no cumpla). Si validas un formulario con every(), comprueba antes que la lista no esté vacía.

some() es también la forma de preguntar «¿está?» cuando buscas un objeto por uno de sus campos, como verás en el apartado siguiente.

includes() e indexOf(): ¿está este valor?

Cuando no buscas por una condición sino un valor concreto, no hace falta función:

const frutas = ["manzana", "pera", "uva", "pera"];

console.log(frutas.includes("pera"));
console.log(frutas.indexOf("pera"));
console.log(frutas.lastIndexOf("pera"));
console.log(frutas.indexOf("kiwi"));

console.log([NaN].includes(NaN));
console.log([NaN].indexOf(NaN));
true
1
3
-1
true
-1
  • includes() responde sí o no. Es la opción más legible si solo quieres saber si está.
  • indexOf() da la primera posición, y lastIndexOf(), la última. Devuelven -1 si no lo encuentran.
  • Con NaN se comportan distinto: includes() lo encuentra y indexOf() no. MDN explica que includes() compara como === salvo en que considera NaN igual a sí mismo. Si === te suena raro, mira la diferencia entre == y ===.

Con objetos, los dos comparan la referencia, no el contenido:

const ana = { nombre: "Ana" };
const personas = [ana];

console.log(personas.includes({ nombre: "Ana" }));
console.log(personas.includes(ana));
console.log(personas.some((p) => p.nombre === "Ana"));
false
true
true

{ nombre: "Ana" } crea un objeto nuevo, distinto del que hay en la lista aunque se escriba igual. Para buscar por contenido, some() o find() con una condición.

sort(): el método para ordenar un array en JavaScript

Sin función, sort() convierte cada elemento a texto y lo ordena por el código Unicode de sus caracteres. Por eso 10 va antes que 2: se compara "1" con "2".

const puntos = [1, 10, 2, 21];
console.log(puntos.sort());

const numeros = [40, 1, 5, 200];
numeros.sort((a, b) => a - b);
console.log(numeros);
[ 1, 10, 2, 21 ]
[ 1, 5, 40, 200 ]

La función de comparación recibe dos elementos. Si devuelve un número negativo, a va antes; si es positivo, b va antes; si es 0, se quedan como están. a - b ordena de menor a mayor y b - a, de mayor a menor.

Con textos en español pasa algo parecido: el orden Unicode pone las mayúsculas antes que las minúsculas y las letras con tilde al final. localeCompare compara según las reglas del idioma que le indiques, aquí "es":

const nombres = ["Óscar", "ana", "Zoe", "Ángela", "luis"];
console.log(nombres.toSorted());
console.log(nombres.toSorted((a, b) => a.localeCompare(b, "es")));
[ 'Zoe', 'ana', 'luis', 'Ángela', 'Óscar' ]
[ 'ana', 'Ángela', 'luis', 'Óscar', 'Zoe' ]

Para ordenar objetos, compara el campo que te interese: usuarios.toSorted((a, b) => a.edad - b.edad).

push(), pop(), shift() y unshift(): añadir y quitar por los extremos

const cola = ["Ana", "Luis"];

console.log(cola.push("Marta"));
console.log(cola);
console.log(cola.pop());
console.log(cola.unshift("Pepe"));
console.log(cola);
console.log(cola.shift());
console.log(cola);
3
[ 'Ana', 'Luis', 'Marta' ]
Marta
3
[ 'Pepe', 'Ana', 'Luis' ]
Pepe
[ 'Ana', 'Luis' ]
Método Dónde Qué hace Devuelve
push() Final Añade uno o varios La nueva longitud
pop() Final Quita el último El elemento quitado
unshift() Principio Añade uno o varios La nueva longitud
shift() Principio Quita el primero El elemento quitado

Los cuatro cambian el array. Un error frecuente es escribir const lista = otra.push(x) esperando un array: lo que se guarda es un número.

splice() y slice(): quitar, meter o sacar un trozo

Se escriben casi igual y hacen cosas distintas:

  • slice(inicio, fin) copia un trozo, desde inicio hasta fin sin incluirlo. No toca el original.
  • splice(inicio, cuantos, ...nuevos) cambia el original: quita cuantos elementos desde inicio, mete los nuevos en su lugar y devuelve los que ha quitado.
const letras = ["a", "b", "c", "d", "e"];

console.log(letras.slice(1, 3));
console.log(letras);

console.log(letras.splice(1, 2));
console.log(letras);

letras.splice(1, 0, "x", "y");
console.log(letras);

console.log(letras.slice(-2));
[ 'b', 'c' ]
[ 'a', 'b', 'c', 'd', 'e' ]
[ 'b', 'c' ]
[ 'a', 'd', 'e' ]
[ 'a', 'x', 'y', 'd', 'e' ]
[ 'd', 'e' ]

Con 0 como segundo argumento, splice() no quita nada y solo inserta. Un índice negativo cuenta desde el final: slice(-2) son los dos últimos.

Qué métodos cambian el array y cuáles no

Que un método mute el array significa que cambia el original, y cualquier otra variable que apunte a él verá el cambio.

Cambian el array original Su alternativa que no lo cambia
sort() toSorted()
reverse() toReversed()
splice() toSpliced()
arr[i] = valor with(i, valor)
push(a, b) concat([a, b])
pop() slice(0, -1)
shift() slice(1)
unshift(a, b) toSpliced(0, 0, a, b)
fill(), copyWithin() No tienen una equivalente directa: copia antes con [...arr]

La tabla sigue la de MDN («Copying methods and mutating methods»), salvo la fila de arr[i] = valor, que añadimos nosotros porque with() existe justo para ese caso.

map(), filter(), slice(), concat(), flat() y flatMap() siempre devuelven un array nuevo. forEach(), find(), some(), every(), includes(), indexOf(), reduce() y join() no devuelven un array y tampoco cambian el original.

toSorted(), toReversed(), toSpliced() y with()

Son las versiones «de copia» de sort(), reverse(), splice() y la asignación por índice: hacen lo mismo sin tocar el original. MDN indica que funcionan en todos los navegadores principales desde julio de 2023, y Node 24 los incluye; si tu código tiene que funcionar en entornos más antiguos, mira la tabla de compatibilidad de cada uno en MDN.

const original = ["c", "a", "b"];

const ordenado = original.toSorted();
const invertido = original.toReversed();
const sinElSegundo = original.toSpliced(1, 1);
const cambiado = original.with(0, "z");

console.log(ordenado);
console.log(invertido);
console.log(sinElSegundo);
console.log(cambiado);
console.log(original);
[ 'a', 'b', 'c' ]
[ 'b', 'a', 'c' ]
[ 'c', 'b' ]
[ 'z', 'a', 'b' ]
[ 'c', 'a', 'b' ]

La última línea es la que importa: original sigue igual.

Antes de usar un método, pregúntate si cambia tu array o te da uno nuevo.

Una precaución: estas copias, como las de map() o slice(), son superficiales. Si el array guarda objetos, el nuevo guarda los mismos objetos, no copias de ellos. Las formas de copiar un array, y cuándo hace falta una copia profunda, están en cómo copiar un array en JavaScript.

Otros métodos útiles: join, concat, at, flat, Array.isArray y Array.from

const palabras = ["hola", "mundo"];
console.log(palabras.join(" "));
console.log(palabras.concat(["y", "adiós"]));
console.log(palabras.at(-1));

console.log([1, [2, [3, [4]]]].flat());
console.log([1, [2, [3, [4]]]].flat(Infinity));

const frases = ["buenos días", "hasta luego"];
console.log(frases.flatMap((frase) => frase.split(" ")));

console.log(Array.isArray([1, 2]));
console.log(Array.isArray("hola"));
console.log(typeof [1, 2]);

console.log(Array.from("hola"));
console.log(Array.from({ length: 3 }, (_, i) => i * 2));
console.log(Array.of(7));
console.log(Array(7).length);
hola mundo
[ 'hola', 'mundo', 'y', 'adiós' ]
mundo
[ 1, 2, [ 3, [ 4 ] ] ]
[ 1, 2, 3, 4 ]
[ 'buenos', 'días', 'hasta', 'luego' ]
true
false
object
[ 'h', 'o', 'l', 'a' ]
[ 0, 2, 4 ]
[ 7 ]
7
  • join() une los elementos en un texto con el separador que elijas.
  • concat() devuelve un array nuevo con los dos juntos.
  • at() lee una posición y acepta negativos: at(-1) es el último, sin escribir arr[arr.length - 1].
  • flat() aplana un nivel de arrays anidados; con Infinity, todos. flatMap() es un map() seguido de un flat() de un nivel.
  • Array.isArray() es la forma fiable de saber si algo es un array, porque typeof devuelve "object".
  • Array.from() crea un array a partir de algo que se puede recorrer, como un texto, o de un objeto con length. Array.of(7) crea [7], mientras que Array(7) crea un array de 7 posiciones vacías. Esos huecos tienen sus propias reglas, que se cuentan en el comportamiento de los arrays con huecos.

Encadenar métodos: filter, map y reduce juntos

Como filter() y map() devuelven arrays, puedes encadenarlos. Cada paso se lee como una frase:

const pedidos = [
  { cliente: "Ana", importe: 120, pagado: true },
  { cliente: "Luis", importe: 80, pagado: false },
  { cliente: "Marta", importe: 45, pagado: true },
  { cliente: "Pepe", importe: 300, pagado: true },
];

const totalCobrado = pedidos
  .filter((pedido) => pedido.pagado)
  .map((pedido) => pedido.importe)
  .reduce((suma, importe) => suma + importe, 0);

console.log(totalCobrado);
465

«De los pedidos, los pagados; de ellos, el importe; y súmalos». Con un bucle for se puede hacer lo mismo, pero hay que leer el cuerpo entero para saber qué hace. Esa legibilidad es la razón de fondo para preferir estos métodos, en la línea de lo que se cuenta en funciones en código limpio.

Cada método recorre el array una vez, así que una cadena de tres lo recorre tres veces. Para listas normales no se nota; si trabajas con cientos de miles de elementos y el rendimiento importa, mídelo antes de decidir.

Ejercicios de métodos de arrays en JavaScript

Los métodos de arrays se aprenden como se coge fondo en el gimnasio: repitiendo. Aquí tienes un circuito de siete ejercicios sobre los mismos datos. Intenta cada uno sin mirar la solución y comprueba tu resultado con la salida.

const sesiones = [
  { nombre: "Ana", actividad: "remo", minutos: 30, hecha: true },
  { nombre: "Luis", actividad: "bici", minutos: 45, hecha: false },
  { nombre: "Marta", actividad: "remo", minutos: 20, hecha: true },
  { nombre: "Pepe", actividad: "carrera", minutos: 60, hecha: true },
  { nombre: "Lola", actividad: "bici", minutos: 15, hecha: false },
];
  1. Los nombres de las sesiones de más de 25 minutos.
  2. Los minutos, de la sesión más corta a la más larga, sin cambiar sesiones.
  3. El total de minutos de las sesiones hechas.
  4. Si hay alguna sesión sin hacer y si todas duran al menos 15 minutos.
  5. Quién tiene la primera sesión de bici y en qué posición está.
  6. Cuántas sesiones hay de cada actividad.
  7. La lista sin la sesión de Luis, sin tocar la original.
Soluciones
// 1. filter y map
const largas = sesiones
  .filter((sesion) => sesion.minutos > 25)
  .map((sesion) => sesion.nombre);
console.log(largas);

// 2. toSorted y map
const minutosOrdenados = sesiones
  .toSorted((a, b) => a.minutos - b.minutos)
  .map((sesion) => sesion.minutos);
console.log(minutosOrdenados);

// 3. filter y reduce
const minutosHechos = sesiones
  .filter((sesion) => sesion.hecha)
  .reduce((total, sesion) => total + sesion.minutos, 0);
console.log(minutosHechos);

// 4. some y every
const hayAlgunaSinHacer = sesiones.some((sesion) => !sesion.hecha);
const todasDuran15 = sesiones.every((sesion) => sesion.minutos >= 15);
console.log(hayAlgunaSinHacer, todasDuran15);

// 5. find y findIndex con la misma condición
const esDeBici = (sesion) => sesion.actividad === "bici";
console.log(sesiones.find(esDeBici).nombre, sesiones.findIndex(esDeBici));

// 6. reduce para contar
const porActividad = sesiones.reduce((cuenta, sesion) => {
  cuenta[sesion.actividad] = (cuenta[sesion.actividad] ?? 0) + 1;
  return cuenta;
}, {});
console.log(porActividad);

// 7. filter, que ya devuelve un array nuevo
const sinLuis = sesiones.filter((sesion) => sesion.nombre !== "Luis");
console.log(sinLuis.length, sesiones.length);
[ 'Ana', 'Luis', 'Pepe' ]
[ 15, 20, 30, 45, 60 ]
110
true true
Luis 1
{ remo: 2, bici: 2, carrera: 1 }
4 5

El ejercicio 6 es el más difícil: reduce() no tiene por qué acabar en un número; aquí acaba en un objeto que cuenta, como el recuento de votos del apartado de reduce(). En el 2, toSorted() deja sesiones como estaba: con sort(), los ejercicios siguientes partirían del array ya ordenado. Y en el 7, filter() ya devuelve un array nuevo. Con splice() y findIndex() también se puede, pero si no hubiera ninguna sesión de Luis, findIndex() daría -1 y se borraría la última sin avisar.

La idea del circuito viene de los dos días de Array Cardio de JavaScript30, el curso gratuito de Wes Bos, en inglés. Allí hay más ejercicios del mismo estilo, con su solución en su repositorio. Si quieres seguir practicando con tests, prueba las katas de ES6 o los ejercicios con corrección automática de Codewars.

Errores típicos con los métodos de arrays

const numeros = [1, 2, 3];

const dobles = numeros.map((n) => { n * 2; });
console.log(dobles);

const doblesBien = numeros.map((n) => n * 2);
console.log(doblesBien);

console.log(["1", "2", "3"].map(parseInt));
console.log(["1", "2", "3"].map(Number));

const a = [3, 1, 2];
const b = a.sort();
console.log(a === b);
[ undefined, undefined, undefined ]
[ 2, 4, 6 ]
[ 1, NaN, NaN ]
[ 1, 2, 3 ]
true
  1. Llaves sin return en una función flecha. Con llaves, (n) => { n * 2; } no devuelve nada, y map() llena el array de undefined. O quitas las llaves, o escribes return.
  2. map(parseInt). map() pasa tres argumentos: el elemento, el índice y el array. parseInt toma el índice como base numérica, y parseInt("2", 1) da NaN. Usa map(Number) o map((s) => parseInt(s, 10)). En qué se diferencian los dos está en parseInt o Number.
  3. Creer que sort() devuelve una copia. a === b da true: son el mismo array. Usa toSorted().
  4. Ordenar números sin función de comparación, como se vio en sort().
  5. reduce() sin valor inicial sobre un array que puede estar vacío.
  6. Usar filter() para buscar uno solo. filter(...)[0] funciona, pero recorre todo el array y dice peor lo que buscas. find() se para en el primero.
  7. forEach() con async, que no espera, como se explica en su apartado.

Fuentes

  • MDN Web Docs, consultado el 9 de noviembre de 2026:
  • JavaScript30 de Wes Bos: web del curso y repositorio, con los ejercicios «04 - Array Cardio Day 1» y «07 - Array Cardio Day 2», consultados el 13 de noviembre de 2026. Los datos y los ejercicios del circuito son nuevos.
  • Todos los ejemplos se han ejecutado con Node 24.21.0. Los dos primeros ejemplos de sort() ([1, 10, 2, 21] y [40, 1, 5, 200]) proceden de MDN, como en la versión original de este artículo (2018); el resto son nuevos.