Base de conocimientosCentro de exámenes
ESEspañol
Elegir idioma13

CKTIS / JavaScript

Protocolo de iteradores: next(), return(), value y done

Comprueba `done`, no `value`, para detectar el fin de la iteración. Aprende a leer el valor final y cuándo `for...of` llama al método opcional `return()`.

Versión: ECMAScript 2024 and the current web platform; runtime support varies

Sintaxis

const iterator = iterable[Symbol.iterator]();
const result = iterator.next();
// result.done: completion flag; result.value: element or completion value
// When stopping early during manual iteration, call the optional method if callable:
if (typeof iterator.return === "function") {
  iterator.return();
}

Un iterador síncrono es un objeto con un método next() que devuelve un objeto de resultado (IteratorResult). Un iterable tiene un método [Symbol.iterator]() que devuelve un iterador. Tener next() no basta para ser iterable; un objeto generador cumple ambas funciones. for...of obtiene el iterador y llama a next() sin argumentos. El significado de un posible argumento depende de la implementación del iterador.

Con done: false, value es un elemento, aunque sea undefined. done: true indica que la iteración ha terminado; value puede contener entonces un valor final que for...of no entrega al cuerpo del bucle. Si falta done, se trata como false; for...of convierte la propiedad en un booleano para comprobarla. Una vez agotado el iterador, las llamadas posteriores a next() deberían seguir indicando done: true, pero el lenguaje no lo exige.

El método opcional return(value) indica que quien llama va a dejar de iterar y permite al iterador liberar recursos. Normalmente devuelve done: true y el argumento recibido como value; un generador puede devolver done: false si ejecuta un yield en finally. Si se sale antes de tiempo mediante break o una excepción en el cuerpo del bucle, for...of llama a return() sin argumentos si existe e ignora done y value del resultado. No lo llama al agotarse el iterador normalmente ni si el propio next() lanza una excepción.

Llamar manualmente a next() no cierra el iterador de forma automática. Si te detienes antes de tiempo, llama a return() si es invocable. for...of lanza un TypeError si next() o la llamada de cierre a return() devuelve algo que no es un objeto. Si el cierre se inició por una excepción en el cuerpo del bucle, tiene prioridad la excepción original.

Ejemplos

{
  function* sequence() {
    try {
      yield undefined;
      return "end";
    } finally {
      console.log("cleanup");
    }
  }

  function show(label, { done, value }) {
    console.log(`${label}: done=${done}, value=${value}`);
  }

  const full = sequence();
  show("next", full.next());
  show("next", full.next());
  show("next", full.next());

  for (const value of sequence()) {
    console.log(`loop: ${value}`);
    break;
  }

  const manual = sequence();
  manual.next();
  show("return", manual.return("stopped"));
}

Resultado

next: done=false, value=undefined
cleanup
next: done=true, value=end
next: done=true, value=undefined
loop: undefined
cleanup
cleanup
return: done=true, value=stopped

Tres generadores independientes muestran el agotamiento normal con el valor final `end`, el cierre automático al ejecutar `break` y la llamada explícita a `return("stopped")`. Cada generador iniciado imprime `cleanup` en su bloque `finally`.

Lecciones relacionadas

  • JavaScript · Lección 8 · Avanzado · Versión: 4

Fuentes