Perché i generatori comuni consentono di scrivere…

I generatori comuni in JavaScript consentono di scrivere codice asincrono grazie alla loro capacità di sospendere e riprendere l'esecuzione, nonché di trasmettere valori in entrambe le direzioni (tramite yield e next()).

Ecco come funziona nel contesto dell'asincronia:

Sospensione dell'esecuzione (yield): Quando si raggiunge l'istruzione yield, il generatore si sospende e restituisce un valore. Nel codice asincrono, questo valore può essere una promessa o un'altra "azione" da eseguire in modo asincrono.
Attesa del risultato asincrono: Il codice esterno (ad esempio, un "runner" o un wrapper per il generatore) riceve il valore passato tramite yield. Se si tratta di una promessa, attende la sua risoluzione o rifiuto.
Ripresa dell'esecuzione (next()): Dopo che l'operazione asincrona (risoluzione della promessa) è completata, il risultato asincrono (il valore della promessa) viene passato di nuovo al generatore tramite il metodo next(). Il generatore riprende l'esecuzione da dove era stato sospeso.
Trasmissione del risultato: Il valore passato a next() diventa il risultato dell'espressione yield all'interno del generatore. In questo modo, il generatore può "ottenere" il risultato dell'operazione asincrona e continuare a lavorarci sopra, come se il codice fosse sincrono.

Questo pattern crea un'illusione di esecuzione sincrona per le operazioni asincrone, rendendo il codice più leggibile e gestibile rispetto all'uso tradizionale di callback o catene .then() complesse.

Un esempio di ciò sono i wrapper come co (anche se ora sono più comuni async/await, che sono fondamentalmente zucchero sintattico sui generatori e promesse):

// Esempio di utilizzo di un generatore per l'asincronia
function* myAsyncGenerator() {
  try {
    const result1 = yield Promise.resolve(1); // Sospensione, restituisce una promessa
    console.log('Primo risultato:', result1); // Riprende con il valore

    const result2 = yield new Promise(resolve => setTimeout(() => resolve(2), 500)); // Un'altra operazione asincrona
    console.log('Secondo risultato:', result2);

    return 'Fatto'; // Fine del generatore
  } catch (error) {
    console.error('Errore:', error);
  }
}

// "Runner" semplice per il generatore (semplificato)
function run(generatorFunc) {
  const generator = generatorFunc();

  function handleNext(newValue) {
    const result = generator.next(newValue);

    if (!result.done) {
      if (result.value instanceof Promise) {
        result.value.then(handleNext).catch(handleError);
      } else {
        handleNext(result.value);
      }
    } else {
      console.log('Generatore completato con risultato:', result.value);
    }
  }

  function handleError(error) {
      generator.throw(error);
  }

  handleNext(); // Avvia il generatore
}

// Eseguiamo il nostro generatore asincrono
run(myAsyncGenerator);

In questo esempio, yield Promise.resolve(1) sospende il generatore. Il "runner" (o co) aspetta che la promessa si risolva e poi riprende il generatore passando il valore 1 tramite next(1). Questo valore 1 diventa il risultato di yield Promise.resolve(1) all’interno del generatore, permettendo di processarlo nella riga successiva (console.log). Questo meccanismo permette di simulare un flusso di esecuzione sincrono per operazioni asincrone.

Perché i generatori comuni consentono di scrivere codice asincrono?