CKTIS / JavaScript
Protocollo degli iteratori: next(), return(), value e done
Controlla `done`, non `value`, per rilevare la fine dell’iterazione. Scopri come leggere il valore finale e quando `for...of` chiama il metodo facoltativo `return()`.
Versione: ECMAScript 2024 and the current web platform; runtime support varies
Sintassi
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 iteratore sincrono è un oggetto con un metodo next() che restituisce un oggetto risultato (IteratorResult). Un oggetto iterabile ha un metodo [Symbol.iterator]() che restituisce un iteratore. La sola presenza di next() non rende un oggetto iterabile; un oggetto generatore svolge entrambi i ruoli. for...of ottiene l’iteratore e chiama next() senza argomenti. Il significato di un eventuale argomento dipende dall’implementazione dell’iteratore.
Con done: false, value è un elemento, anche se vale undefined. done: true indica che l’iterazione è terminata; value può allora contenere un valore finale che for...of non passa al corpo del ciclo. Se done manca, equivale a false; for...of converte la proprietà in un booleano per verificarla. Una volta esaurito l’iteratore, le chiamate successive a next() dovrebbero continuare a indicare done: true, ma il linguaggio non lo impone.
Il metodo facoltativo return(value) segnala che il chiamante smette di iterare e dà all’iteratore la possibilità di liberare le risorse. Di solito il risultato contiene done: true e l’argomento passato come value. Un generatore può però restituire done: false se esegue un yield in finally. In caso di uscita anticipata con break o per un’eccezione nel corpo del ciclo, for...of chiama return() senza argomenti, se presente, e ignora done e value del risultato. Non lo chiama se l’iteratore si esaurisce normalmente o se è next() a lanciare un’eccezione.
Le chiamate manuali a next() non chiudono automaticamente l’iteratore: se ti fermi prima della fine, chiama tu return() se è invocabile. for...of lancia un TypeError se next() o la chiamata a return() durante la chiusura restituisce qualcosa che non è un oggetto. Se la chiusura è stata avviata da un’eccezione nel corpo del ciclo, prevale l’eccezione originale.
Esempi
{
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"));
}Risultato
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
Tre generatori distinti mostrano l’esaurimento normale con il valore finale `end`, la chiusura automatica con `break` e la chiamata esplicita a `return("stopped")`. Ogni generatore avviato stampa `cleanup` nel proprio blocco `finally`.
Lezioni correlate
- JavaScript · Lezione 8 · Avanzato · Versione: 4