Arquetipo
Patrones de comportamientoUso: Muy altaComplejidad: Baja

Iterator

Iterador · Cursor

Permite recorrer los elementos de una colección uno a uno sin exponer cómo está organizada por dentro.

“Quiero recorrer una colección sin exponer cómo está guardada.”

workEl caso real

Tu sistema sincroniza todos los clientes de un CRM externo. La API del CRM devuelve los clientes de 100 en 100 y, para pedir la página siguiente, hay que enviar el cursor que llegó en la respuesta anterior. Varios procesos necesitan recorrer todos los clientes: la sincronización, una exportación y un informe mensual.

warningEl problema sin el patrón

Cada proceso repite el mismo bucle de paginación: pedir una página, leer el cursor y detectar el final. Si el CRM cambia su forma de paginar, hay que corregir todos los bucles.

check_circleCómo lo resuelve el patrón

Un iterador encapsula el recorrido: quien lo usa solo pide "el siguiente cliente" hasta que no quedan más. Cómo se piden las páginas y se maneja el cursor queda oculto. En TypeScript se implementa de forma natural con un generador asíncrono.

schemaDiagrama de clases

Diagrama interactivo: puedes acercar, mover el lienzo y pasar el cursor sobre cada clase para ver su detalle.

codeEl código, antes y después

cancelSin el patrónANTES
let cursor: string | undefined;
do {
  const pagina = await crm.listarClientes({ limite: 100, cursor });
  for (const cliente of pagina.datos) await sincronizar(cliente);
  cursor = pagina.siguienteCursor; // el mismo bucle, copiado en cada proceso
} while (cursor);
check_circleCon el patrónDESPUÉS
class ClientesCrm implements AsyncIterable<Cliente> {
  constructor(private crm: ApiCrm) {}

  async *[Symbol.asyncIterator]() {
    let cursor: string | undefined;
    do {
      const pagina = await this.crm.listarClientes({ limite: 100, cursor });
      yield* pagina.datos;
      cursor = pagina.siguienteCursor;
    } while (cursor);
  }
}

// Cualquier proceso recorre los clientes sin saber nada de páginas ni cursores
for await (const cliente of new ClientesCrm(crm)) {
  await sincronizar(cliente);
}

Ejemplos en TypeScript, simplificados para mostrar la idea: los tipos auxiliares (Pedido, Cliente…) se omiten.

lightbulb

Matiz importante

La mayoría de lenguajes modernos traen el patrón integrado: Symbol.iterator y generadores en JavaScript y TypeScript, IEnumerable y yield return en C#, Iterator en Java y generadores en Python. Rara vez hace falta escribir hasNext() y next() a mano.

thumb_upCuándo usarlo

  • ✓La colección tiene una estructura interna compleja (páginas, árbol, grafo) que no quieres exponer.
  • ✓Necesitas varias formas de recorrer la misma colección, o un recorrido perezoso que carga a medida que avanza.
  • ✓Necesitas varios recorridos a la vez sobre la misma colección, o pausar uno y retomarlo más tarde: cada iterador guarda su propia posición.

do_not_disturb_onCuándo no usarlo

  • ✕Es una lista o un array simple: los bucles del lenguaje ya usan iteradores.
  • ✕Necesitas acceso aleatorio por posición más que un recorrido secuencial.
  • ✕En colecciones muy especializadas, un iterador genérico puede ser más lento que acceder directamente a sus elementos.

memoryPrincipios en juego

  • •Responsabilidad única: el recorrido se separa de la colección y de quien la usa.
  • •Ocultamiento de información: el cliente no conoce la estructura interna (páginas, árbol, grafo).

hubPatrones relacionados

  • •Composite: los iteradores permiten recorrer un árbol sin conocer su estructura.
  • •Factory Method: una colección puede devolver el iterador adecuado mediante un método fábrica.
  • •Memento: se puede guardar la posición de un recorrido para continuarlo después.

quizPon a prueba lo que leíste

Dos preguntas al azar sobre este patrón. Cada vez que las cambias salen otras.

Más ejercicios →

code_blocksIterator en tu lenguaje

El mismo caso, implementado completo y de forma idiomática. Se puede copiar y ejecutar.

LO IDIOMÁTICO EN TYPESCRIPT: Un generador asíncrono (async *) implementa AsyncIterable y el cliente lo recorre con for await: no hace falta escribir next() a mano. Además el recorrido es perezoso: si el cliente sale del bucle antes, no se piden más páginas.

iterator.ts · 45 líneas
interface Cliente { id: number; nombre: string }
interface Pagina { datos: Cliente[]; siguienteCursor?: string }

// API simulada que devuelve los clientes de dos en dos
class ApiCrm {
  readonly #clientes: Cliente[] = ['Ana', 'Luis', 'Marta', 'Jorge', 'Elena'].map((nombre, i) => ({ id: i + 1, nombre }));
  peticiones = 0;

  async listarClientes({ limite, cursor }: { limite: number; cursor?: string }): Promise<Pagina> {
    this.peticiones++;
    const desde = cursor ? Number(cursor) : 0;
    const hasta = desde + limite;
    return {
      datos: this.#clientes.slice(desde, hasta),
      siguienteCursor: hasta < this.#clientes.length ? String(hasta) : undefined,
    };
  }
}

export class ClientesCrm implements AsyncIterable<Cliente> {
  constructor(private readonly crm: ApiCrm, private readonly limite = 2) {}

  async *[Symbol.asyncIterator](): AsyncGenerator<Cliente> {
    let cursor: string | undefined;
    do {
      const pagina = await this.crm.listarClientes({ limite: this.limite, cursor });
      yield* pagina.datos;
      cursor = pagina.siguienteCursor;
    } while (cursor);
  }
}

// ── Uso ──
const crm = new ApiCrm();
for await (const cliente of new ClientesCrm(crm)) {
  console.log(cliente.nombre);
}
console.log(`Peticiones a la API: ${crm.peticiones}`); // 3

// Perezoso: si se corta antes, no se piden más páginas
const otroCrm = new ApiCrm();
for await (const cliente of new ClientesCrm(otroCrm)) {
  if (cliente.id === 2) break;
}
console.log(`Peticiones a la API: ${otroCrm.peticiones}`); // 1
Ver los 23 patrones en TypeScript →