Base di conoscenzaCentro esami
ITItaliano
Scegli la lingua13

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

Fonti