Iterator: recorrer sin conocer el interior

  • Lección 24 de 32
  • 11 min
  • Intermedio
  • 13 pasos

Si tu loop sabe que los usuarios vienen en páginas, cada cambio interno te obliga a editarlo. Vas a esconder ese interior detrás de un iterador, hacer que tu clase funcione con `for…of` y ver dónde ya usas esta idea.

Valores entregados
—
Peticiones a la API
—
Tu códigoititPagedMapfetchPages()rlUsersArrayListPagedIteratorprotocoloIteratorAPIAPIInformefor anidadopáginas por dentroTu loop conoce las páginasconst users = new Paged([["ana", "leo"], ["sol"]]);▸for (const page of users.pages)for (const u of page)show(u);a editara editar tambiénahora: users.byIdCambia el interior de Paged−for (const page of users.pages)−for (const u of page)+for (const u of users.byId.values())show(u);next(){ value, done }El protocolo Iteratorinterface Iterator<T> {▸next(): IteratorResult<T>;}// { value: "ana", done: false }// { value: undefined, done: true }next()sabe por dónde vanext(), paso a pasoconst it = users[Symbol.iterator]();▸it.next(); // {value:"ana",done:false}it.next(); // {value:"leo",done:false}it.next(); // {value:"sol",done:false}▸it.next(); // {value:undefined,done:true}sin páginasyield* pagePaged se vuelve iterableclass Paged<T> implements Iterable<T> {constructor(private pages: T[][]) {}+*[Symbol.iterator]() {+for (const page of this.pages)+yield* page;+}}▸for (const u of users) show(u);trae [Symbol.iterator]el mismo for…ofIterables que ya traesfor (const c of "sol") {} // s, o, lfor (const [k, v] of map) {} // paresconst copy = [...new Set([1, 2])];▸for (const x of {}) {}▸// TypeError: {} is not iterable1 de 3 páginaspide al avanzarPáginas que se piden al avanzarasync function* fetchPages(total) {for (let p = 1; p <= total; p++)yield await getPage(p);}for await (const page of fetchPages(3)) {show(page);▸break; // solo se pidió la página 1}una línea por vueltabreak cierra rlreadline: una línea por vueltaconst rl = readline.createInterface({input: fs.createReadStream(file),crlfDelay: Infinity,});▸for await (const line of rl) {show(line);}__next__()__iter__()El mismo protocolo en Pythonclass Users:def __init__(self, items):self.items = itemsdef __iter__(self):yield from self.itemsit = iter(Users(["ana"]))next(it) # "ana"▸next(it) # StopIteration[...it] da []ya lo recorrióUn iterador ya gastadoconst it = users[Symbol.iterator]();[...it]; // ["ana", "leo", "sol"]▸[...it]; // [][...users]; // los 3 otra vezla lista cambióConcurrentModificationExceptionJava: modificar mientras recorresfor (String u : list) {if (u.equals("leo"))▸list.add("eva");}▸// ConcurrentModificationExceptionno lo escribasun array bastaCuándo no y lo que cuestaun array o built-in ya bastano escribas el tuyonecesitas items[5] o el totalun iterador no los davalores calculados al pedirlosmás difícil de depurarfor await sobre una APIesconde la esperanext() o donefor…ofIterator en una tablaproblemael loop conoce el interiorsoluciónnext() da { value, done }en JS[Symbol.iterator] + generadorperezosopide solo lo que el loop pidecuidadoun uso; no modificar al recorrer
  • petición
  • respuesta
  • petición lenta
  • petición fallida

Paso 1 de 13

Problema

Tu loop conoce las páginas

Tu app guarda los usuarios en una clase Paged que los agrupa en páginas: [["ana", "leo"], ["sol"]]. Para mostrarlos, tu código recorre users.pages y, dentro, cada página: dos loops anidados.

Funciona, pero tu loop sabe cómo está guardada la colección por dentro. Ese detalle no le importa: solo quería los usuarios, uno detrás de otro.

Qué cambió

  • dos loops sobre users.pages

Paso 2 de 13

Problema

Cambia el interior, cambian todos los loops

Ahora el equipo decide guardar los usuarios en un Map por id, users.byId. users.pages deja de existir y tu loop se rompe.

No solo el tuyo: el informe y cada sitio que recorría usuarios tiene que editarse. Un cambio interno de Paged se volvió un cambio en todos los que la usan.

Qué cambió

  • pages → byId
  • cada loop, editado

Paso 3 de 13

Concepto

Un objeto que te da el siguiente

La idea de Iterator: en vez de entrar a la colección, le pides un objeto que la recorre por ti. Gamma, Helm, Johnson y Vlissides lo incluyen entre los patrones de comportamiento de su libro de 1994: acceder a los elementos en orden sin exponer cómo están guardados.

En JavaScript ese objeto cumple un protocolo con un método, next(), que devuelve { value, done }: el siguiente valor, o done: true cuando ya no quedan.

Qué cambió

  • el iterador it
  • el protocolo Iterator

Paso 4 de 13

Técnica

next(), paso a paso

Pides el iterador con users[Symbol.iterator]() y llamas a next(). La primera vez devuelve { value: "ana", done: false }; luego "leo" y "sol". La cuarta llamada devuelve { value: undefined, done: true }.

El iterador recuerda por dónde va: sabe que después de "leo" termina la página 1 y salta a la 2. Quien llama ve 3 valores y un final, sin páginas.

Qué cambió

  • it.next() × 4

Paso 5 de 13

Solución

for…of hace las llamadas por ti

No tienes que llamar a next() a mano. Si Paged tiene un método [Symbol.iterator](), es iterable: for…of pide el iterador, llama a next() en cada vuelta y se detiene con done: true.

La forma más corta de escribirlo es un generador, function* con yield: cada yield entrega un valor y pausa la función hasta el siguiente next(), y yield* page entrega uno por uno los de cada página. Tu loop queda en for (const u of users).

Qué cambió

  • *[Symbol.iterator]()
  • los loops anidados

Paso 6 de 13

Concepto

Ya lo usas: Array, String, Map y Set

Array, String, Map y Set ya traen su [Symbol.iterator](): por eso for…of recorre los caracteres de un texto o los pares [clave, valor] de un Map. El spread ([...x]) y la desestructuración de arrays usan el mismo protocolo.

Un objeto plano {} no lo trae, y en Node for (const x of {}) lanza TypeError: {} is not iterable. Conocer el protocolo explica ese error: a ese objeto le falta [Symbol.iterator].

Qué cambió

  • Paged → Map

Paso 7 de 13

Técnica

Perezoso: páginas de una API

Un iterador no necesita tener todo en memoria: trae o calcula cada valor cuando el loop lo pide. Con async function* cada vuelta puede esperar una petición, y for await espera cada página antes de seguir.

En el ejemplo, fetchPages(3) podría traer 3 páginas, pero el loop sale con break después de la primera: la API recibe 1 petición de 3. Por eso un generador puede ser infinito: los helpers de Iterator, como take(5), también piden solo lo que necesitan.

Qué cambió

  • async function* fetchPages
  • API

Paso 8 de 13

Técnica

Dónde te lo cruzas: leer un archivo en Node

El módulo readline de Node.js lee un archivo línea por línea con el mismo protocolo: creas la interfaz sobre un stream y la recorres con for await (const line of rl). No recibes un array con todas las líneas: recibes una por vuelta.

Si sales del loop con break, la documentación indica que la interfaz se cierra. Es el mismo for await del paso anterior: el origen cambió de una API a un archivo y tu loop no se enteró.

Qué cambió

  • API
  • fetchPages → rl

Paso 9 de 13

Concepto

En Python: __iter__ y __next__

Python tiene el mismo protocolo con otros nombres: el iterable define __iter__(), que devuelve el iterador, y el iterador define __next__(), que devuelve el siguiente valor o lanza StopIteration cuando ya no quedan.

Como en JavaScript, un generador (yield) implementa el protocolo por ti. Y una regla de la documentación: un iterador que ya lanzó StopIteration debe seguir lanzándolo en cada llamada siguiente.

Qué cambió

  • [Symbol.iterator] → __iter__
  • next() → __next__

Paso 10 de 13

Compromiso

Un iterador se usa una vez

Un iterable se puede recorrer muchas veces: cada for…of pide un iterador nuevo. Un iterador, no: cuando llegó a done: true, se queda ahí.

Si guardas it, lo recorres y después se lo pasas al informe, [...it] da [], sin ningún error. Pasa el iterable (users) y no el iterador, o crea uno nuevo para cada recorrido.

Qué cambió

  • el informe usa el mismo it

Paso 11 de 13

Problema

No cambies la lista mientras la recorres

En Java, si agregas un elemento a un ArrayList mientras lo recorres con un for, el siguiente paso del iterador lanza ConcurrentModificationException. Sus iteradores son fail-fast: fallan en cuanto notan un cambio estructural que no hicieron ellos.

La documentación aclara que es best-effort: no garantiza detectarlo siempre, así que no programes contando con la excepción. Si necesitas quitar elementos mientras recorres, hazlo con el propio iterador (it.remove()) o arma una lista nueva.

Qué cambió

  • Paged → ArrayList
  • list.add() dentro del for

Paso 12 de 13

Compromiso

Cuándo no escribir el tuyo

Si tus datos ya son un array, un Map o cualquier built-in, no escribas un iterador: ya lo traen. Y si necesitas acceso por posición (items[5]) o saber el total antes de empezar, un iterador no te da ninguna de las dos cosas.

Lo que pagas cuando sí lo usas: se consume una vez, los valores calculados al pedirlos cuestan más de inspeccionar al depurar, y un for await esconde la espera de cada petición dentro de un loop que parece normal.

Paso 13 de 13

Resumen

Pedir el siguiente, sin mirar adentro

Cuando un loop sabe cómo está guardada una colección, cada cambio interno rompe a quienes la recorren. Un iterador da el siguiente valor con next(), o done: true, y el loop no ve nada más.

En JavaScript basta un [Symbol.iterator]() escrito como generador para que tu tipo funcione con for…of, y con async function* traes datos por partes. Un iterador se usa una vez, y la colección no se modifica mientras la recorres.

Aprenderás

  • Ver por qué recorrer el interior de una colección ata tu loop a cómo se guarda.
  • Usar el protocolo: `next()` devuelve `{ value, done }`.
  • Hacer que tu tipo funcione con `for…of` escribiendo un generador.
  • Traer datos por partes con `async function*` y `for await`.
  • Evitar recorrer dos veces el mismo iterador y modificar una colección mientras la recorres.