Saltar al contenido
Iteradores y generadores

Iterator helpers

Lección 3 de 411 min4 ejercicios

Con arrays, encadenar filter y map es natural. Con iteradores y generadores, hasta 2025 no había nada parecido: había que convertirlos en arrays primero, y con una secuencia infinita eso era imposible. Los iterator helpers traen esos métodos a cualquier iterador, y con una ventaja: son perezosos.

Los métodos (ES2025)

Todos los iteradores del lenguaje, incluidos los generadores, tienen ahora estos métodos:

function* naturales() {
  let n = 1;
  while (true) yield n++;
}

const cuadradosPares = naturales()
  .filter((n) => n % 2 === 0)  // solo pares
  .map((n) => n * n)           // al cuadrado
  .drop(1)                     // saltea el primero
  .take(3)                     // se queda con tres
  .toArray();                  // a array

console.log(cuadradosPares);
Devuelven otro iterador (perezosos) Consumen el iterador
map, filter, flatMap toArray, reduce, forEach
take(n), drop(n) some, every, find

Perezosos

Un método perezoso no hace nada hasta que alguien pide valores, y entonces procesa solo los necesarios, de a uno, a lo largo de toda la cadena:

const registro = [];
const resultado = Iterator.from([1, 2, 3, 4, 5])
  .map((n) => {
    registro.push(n);
    return n * 10;
  })
  .take(2)
  .toArray();

console.log(resultado);
console.log(registro);  // solo se procesaron dos

Con un array, map habría transformado los cinco elementos antes de que alguien recortara. Con listas enormes, archivos o secuencias infinitas, la diferencia es enorme.

Iterator.from

Los arrays, Map y Set son iterables, pero no tienen take ni drop. Iterator.from convierte cualquier iterable en un iterador con todos los helpers:

const tareas = new Set(["leer", "escribir", "practicar", "repasar"]);

const siguientes = Iterator.from(tareas).drop(1).take(2).toArray();
console.log(siguientes);

const mapa = new Map([["ana", 31], ["luis", 27], ["eva", 35]]);
console.log(mapa.entries().filter(([, edad]) => edad > 30).map(([n]) => n).toArray());

Los iteradores de entries(), keys() y values() ya tienen los helpers sin necesidad de Iterator.from.

Unir iteradores (ES2026)

Iterator.concat recorre varios iterables, uno detrás de otro, sin crear arrays intermedios:

const manana = ["café", "tostadas"];
const tarde = new Set(["té"]);

console.log(Iterator.concat(manana, tarde).toArray());

Lo que llega en ES2027

Ya terminados en TC39 y llegando a los navegadores:

// Recorrer varios iteradores a la vez, emparejando sus valores
const nombres = ["Ana", "Luis"];
const edades = [31, 27];
console.log(Iterator.zip([nombres, edades]).toArray());

// includes y join, como en los arrays
console.log(Iterator.from(["a", "b", "c"]).includes("b"));
console.log(Iterator.from(["a", "b", "c"]).join("-"));

Y el chunking, para partir un iterador en bloques de un tamaño fijo, o en ventanas que se deslizan:

const lecturas = Iterator.from([1, 2, 3, 4, 5]);
console.log(lecturas.chunks(2).toArray());   // [ [1, 2], [3, 4], [5] ]

const temperaturas = Iterator.from([20, 22, 21, 25]);
console.log(temperaturas.windows(2).toArray()); // [ [20, 22], [22, 21], [21, 25] ]

Resumen

  • ES2025: map, filter, flatMap, take, drop, reduce, toArray, forEach, some, every y find en todos los iteradores.
  • Son perezosos: procesan solo los valores que se piden, así que funcionan con secuencias infinitas.
  • Devuelven iteradores: termina con toArray() si necesitas un array.
  • Iterator.from da los helpers a cualquier iterable.
  • ES2026: Iterator.concat. ES2027: Iterator.zip, includes, join, chunks y windows.

¡A practicar!

Tu progreso se guarda en este navegador.

Autoevaluación: Métodos para iteradores

Elige una respuesta en cada pregunta.

  1. ¿Qué son los iterator helpers (ES2025)?

  2. ¿Qué significa que sean perezosos?

  3. iterador.map(fn), ¿qué devuelve?

  4. ¿Para qué sirve Iterator.from(x)?

Ordena la salida: Solo lo necesario

Un generador infinito que avisa cada vez que produce un número. Ordena lo que aparecería en la consola.

function* naturales() {  let n = 1;  while (true) {    console.log("genera", n);    yield n++;  }} const resultado = naturales().filter((n) => n % 2 === 0).take(1).toArray();console.log(resultado);console.log(Iterator.from([1, 2, 3]).map((x) => x * 2).toArray().join("-"));

Consola, de arriba abajo

  1. 2-4-6
  2. genera 2
  3. genera 1
  4. [ 2 ]

Detective: Tratar un iterador como array

Se esperaba poder leer el primer nombre. Encuentra la línea donde está el malentendido y elige el arreglo.

Consola

edades.js:5
console.log(nombres[0].length);
                       ^

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

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

Laboratorio: Los primeros pares

Escribe primerosPares con iterator helpers, para que funcione incluso con una secuencia infinita.

programa.jsse ejecuta mientras escribes

$ node programa.js

(escribe tu código: se ejecuta solo)

Lo que debe cumplir

  • Imprime [ 2, 4, 6 ] y [ 8, 10 ] (pendiente)
  • Si hay menos pares de los pedidos, devuelve los que haya (pendiente)
  • Usa Iterator.from y take (pendiente)

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