Saltar al contenido
Colecciones y datos

Métodos de array

Lección 2 de 713 min4 ejercicios

Casi todo lo que harías con un bucle sobre un array (transformar, filtrar, buscar, sumar, ordenar) ya tiene un método que lo hace en una línea, y que dice con su nombre lo que hace. Conocerlos es la diferencia entre leer código y descifrarlo.

Qué mirar en el pizarrón

Cada método de la cadena recibe un array y entrega su resultado al siguiente. Fíjate en que aparecen arrays nuevos en cada paso y en que precios nunca cambia.

En el pizarrón

const precios = [12, 5, 30]; const total = precios  .filter((p) => p >= 10)  .map((p) => p * 2)  .reduce((acum, p) => acum + p, 0); console.log(total);console.log(precios);

Variables

  1. precios→ array #1
  2. array #1[ 12, 5, 30 ]
Consola(vacía)

Tres precios. Vas a ver una cadena de tres métodos: cada uno recibe un array, aplica una función a cada elemento y entrega su resultado al siguiente.

Con el foco aquí también puedes avanzar y retroceder con las flechas del teclado.

Ver todos los pasos en texto
  1. Paso 1: Tres precios. Vas a ver una cadena de tres métodos: cada uno recibe un array, aplica una función a cada elemento y entrega su resultado al siguiente. Variables: precios → array #1, array #1 [ 12, 5, 30 ].
  2. Paso 2: filter llama a la función con cada precio y se queda con los que dan true. El 5 no pasa. Devuelve un array nuevo (#2), más corto. Variables: precios → array #1, array #1 [ 12, 5, 30 ], filter 12 ✓ · 5 ✗ · 30 ✓, array #2 [ 12, 30 ].
  3. Paso 3: map recibe el array #2 y transforma cada elemento. Devuelve otro array nuevo (#3), del mismo largo que el que recibió. Variables: precios → array #1, array #1 [ 12, 5, 30 ], map 12 → 24 · 30 → 60, array #3 [ 24, 60 ].
  4. Paso 4: reduce arranca con el acumulador en 0, el valor inicial. Con el primer elemento, la función devuelve 0 + 24, y eso pasa a ser el nuevo acumulador. Variables: precios → array #1, array #1 [ 12, 5, 30 ], reduce acum: 0 → 0 + 24 = 24, array #3 [ 24, 60 ].
  5. Paso 5: Con el segundo: 24 + 60 = 84. Ya no quedan elementos: reduce devuelve el acumulador final. No devuelve un array, sino un solo valor. Variables: precios → array #1, array #1 [ 12, 5, 30 ], reduce acum: 24 → 24 + 60 = 84, array #3 [ 24, 60 ].
  6. Paso 6: Los arrays intermedios ya no hacen falta y el recolector los libera. Y lo más importante: precios no cambió. filter, map y reduce nunca modifican el array original. Variables: precios → array #1, array #1 [ 12, 5, 30 ], total 84.

Transformar, filtrar, combinar

Los tres de la cadena del pizarrón, que ya usaste en Estilo funcional:

const alumnos = [
  { nombre: "Ana", nota: 9 },
  { nombre: "Luis", nota: 5 },
  { nombre: "Eva", nota: 7 },
];

const nombres = alumnos.map((a) => a.nombre);           // transforma cada uno
const aprobados = alumnos.filter((a) => a.nota >= 6);   // se queda con algunos
const promedio = alumnos.reduce((s, a) => s + a.nota, 0) / alumnos.length;

console.log(nombres);
console.log(aprobados.length, promedio);

Los callbacks reciben tres argumentos: el elemento, su índice y el array entero. Casi siempre basta con el primero.

Buscar con una condición

const pedidos = [
  { id: 1, estado: "enviado" },
  { id: 2, estado: "pendiente" },
  { id: 3, estado: "pendiente" },
];

console.log(pedidos.find((p) => p.estado === "pendiente"));      // el primero
console.log(pedidos.findIndex((p) => p.estado === "pendiente")); // su índice
console.log(pedidos.findLast((p) => p.estado === "pendiente"));  // el último (ES2023)
console.log(pedidos.some((p) => p.estado === "enviado"));        // ¿alguno?
console.log(pedidos.every((p) => p.id > 0));                     // ¿todos?

find y findLast devuelven undefined si nadie cumple; findIndex y findLastIndex, -1.

Aplanar

const capitulos = [["intro", "historia"], ["sintaxis"], []];
console.log(capitulos.flat());

const frases = ["hola mundo", "adiós amigos"];
console.log(frases.flatMap((f) => f.split(" ")));  // map + flat en un paso

Ordenar

sort ordena el propio array (lo modifica) y, sin argumentos, compara como texto. Casi siempre necesitas un comparador: una función que recibe dos elementos y devuelve un número negativo si el primero va antes, positivo si va después, o 0 si da igual.

const nums = [10, 1, 5, 100];
console.log([...nums].sort());                  // como texto: 1, 10, 100, 5
console.log([...nums].sort((a, b) => a - b));   // números, de menor a mayor
console.log([...nums].sort((a, b) => b - a));   // de mayor a menor

const nombres = ["Óscar", "ana", "Eva"];
console.log([...nombres].sort((a, b) => a.localeCompare(b, "es")));

Para textos con acentos y mayúsculas, usa localeCompare, que sigue las reglas del idioma.

Cortar y unir

const letras = ["a", "b", "c", "d", "e"];

console.log(letras.slice(1, 3));   // copia de una parte: [ 'b', 'c' ]
console.log(letras.slice(-2));     // los dos últimos
console.log(letras.join("-"));     // a texto
console.log(letras.concat(["f"])); // array nuevo, unido

Cuáles modifican el original

Modifican el array Devuelven algo nuevo
push, pop, shift, unshift map, filter, slice, concat
sort, reverse, splice, fill flat, flatMap, toSorted, toReversed
find, some, every, reduce, join (otro tipo de valor)

Resumen

  • map transforma, filter selecciona, reduce combina en un valor.
  • find/findLast buscan un elemento; some/every responden sí o no.
  • flat y flatMap aplanan arrays anidados.
  • sort modifica y compara como texto: pásale un comparador.
  • slice copia; splice modifica.
  • forEach solo recorre: siempre devuelve undefined.

¡A practicar!

Tu progreso se guarda en este navegador.

Autoevaluación: El método justo

Elige una respuesta en cada pregunta.

  1. Quieres el primer usuario mayor de edad. ¿Qué método usas?

  2. ¿Qué devuelve forEach?

  3. ¿Qué da [10, 1, 5].sort()?

  4. ¿Para qué sirve some?

Ordena la salida: Ordenar, buscar y aplanar

Dos formas de ordenar, dos de buscar y una de aplanar. Ordena lo que aparecería en la consola.

const nums = [10, 1, 5, 100]; console.log([...nums].sort().join(","));console.log([...nums].sort((a, b) => a - b).join(","));console.log(nums.find((n) => n > 4), nums.findLast((n) => n > 4));console.log(nums.some((n) => n > 50), nums.every((n) => n > 0));console.log([[1, 2], [3]].flat().length);

Consola, de arriba abajo

  1. true true
  2. 1,5,10,100
  3. 3
  4. 1,10,100,5
  5. 10 100

Detective: Esperar un array de forEach

Se esperaba un array con los dobles. Encuentra la línea y elige el método correcto.

Consola

dobles.js:5
console.log(dobles.length);
                   ^

TypeError: Cannot read properties of undefined (reading 'length')

Paso 1: toca la línea de código que causa el error.

Laboratorio: Los baratos, en mayúsculas

Escribe nombresBaratos encadenando filter y map.

programa.jsse ejecuta mientras escribes

$ node programa.js

(escribe tu código: se ejecuta solo)

Lo que debe cumplir

  • Imprime [ 'TÉ', 'MATE' ] (pendiente)
  • Respeta el máximo: con 10 devuelve los tres (pendiente)
  • Usa filter y map, sin for ni while (pendiente)

    domina-js · JavaScript en español, gratis y paso a paso.