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