Γιατί οι συνηθισμένοι γεννήτορες επιτρέπουν τη…

Οι συνηθισμένοι γεννήτριες στη JavaScript επιτρέπουν τη συγγραφή ασύγχρονου κώδικα χάρη στην ικανότητά τους να παύουν και να συνεχίζουν την εκτέλεση, καθώς και να μεταφέρουν τιμές και προς τις δύο κατευθύνσεις (μέσω yield και next()).

Ακολουθεί πώς λειτουργεί αυτό στο πλαίσιο της ασynchronίας:

Παύση εκτέλεσης (yield): Όταν φτάνει στη δήλωση yield, ο γεννήτριας παύει και επιστρέφει μια τιμή. Στον ασύγχρονο κώδικα, αυτή η τιμή μπορεί να είναι ένα υπόσχεση (promise) ή άλλη "ενέργεια" που πρέπει να εκτελεστεί ασύγχρονα.
Αναμονή ασύγχρονου αποτελέσματος: Ο εξωτερικός κώδικας (π.χ. "τρέχων" ή περιτύλιγμα για τον γεννήτρια) λαμβάνει την τιμή που περνάει μέσω yield. Αν αυτή είναι υπόσχεση, περιμένει την επίλυση ή την απόρριψή της.
Επανεκκίνηση εκτέλεσης (next()): Μετά την ολοκλήρωση της ασύγχρονης λειτουργίας (την επίλυση της υπόσχεσης), το ασύγχρονο αποτέλεσμα (η τιμή της υπόσχεσης) περνάει πίσω στη γεννήτρια μέσω της μεθόδου next(). Η γεννήτρια συνεχίζει την εκτέλεση από το σημείο όπου είχε παύσει.
Μεταφορά αποτελέσματος: Η τιμή που περνάει στο next() γίνεται το αποτέλεσμα της έκφρασης yield μέσα στη γεννήτρια. Έτσι, η γεννήτρια μπορεί "να λάβει" το αποτέλεσμα μιας ασύγχρονης λειτουργίας και να συνεχίσει με αυτό, σαν να ήταν συγχρονικός κώδικας.

Αυτό το μοτίβο δημιουργεί την ψευδαίσθηση συγχρονικής εκτέλεσης για ασύγχρονες λειτουργίες, καθιστώντας τον κώδικα πιο ευανάγνωστο και διαχειρίσιμο σε σύγκριση με την παραδοσιακή χρήση callback ή πολύπλοκων αλυσίδων .then().

Παραδείγματα τέτοιων περιτύλιξης είναι τύπου co (αν και τώρα πιο διαδεδομένα είναι τα async/await, που ουσιαστικά αποτελούν συντακτική ζάχαρη πάνω στους γεννήτριες και τις υποσχέσεις):

// Παράδειγμα χρήσης γεννήτριας για ασύγχρονη λειτουργία
function* myAsyncGenerator() {
  try {
    const result1 = yield Promise.resolve(1); // Παύση, επιστροφή υπόσχεσης
    console.log('Λάβαμε το πρώτο αποτέλεσμα:', result1); // Επανεκκίνηση με μεταβιβασμό αποτελέσματος

    const result2 = yield new Promise(resolve => setTimeout(() => resolve(2), 500)); // Άλλη μια ασύγχρονη λειτουργία
    console.log('Λάβαμε το δεύτερο αποτέλεσμα:', result2);

    return 'Έτοιμο'; // Ολοκλήρωση γεννήτριας
  } catch (error) {
    console.error('Παρουσιάστηκε σφάλμα:', error);
  }
}

// Απλός "τρέχων" για τη γεννήτρια (απλοποιημένο)
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('Η γεννήτρια ολοκληρώθηκε με αποτέλεσμα:', result.value);
    }
  }

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

  handleNext(); // Εκκίνηση της γεννήτριας
}

// Ξεκινάμε τη γεννήτρια μας
run(myAsyncGenerator);

Σε αυτό το παράδειγμα, το yield Promise.resolve(1) παύει τη γεννήτρια. Ο "τρέχων" (ή co) περιμένει μέχρι η υπόσχεση να επιλυθεί και στη συνέχεια επανεκκινεί τη γεννήτρια, περνώντας την τιμή 1 μέσω next(1). Αυτή η τιμή 1 γίνεται το αποτέλεσμα του yield Promise.resolve(1) μέσα στη γεννήτρια, επιτρέποντας την επεξεργασία της στην επόμενη γραμμή (console.log). Αυτός ο μηχανισμός επιτρέπει την ψευδαίσθηση συγχρονικού ρεύματος εκτέλεσης για ασύγχρονες λειτουργίες.

Γιατί οι συνηθισμένοι γεννήτορες επιτρέπουν τη συγγραφή ασύγχρονου κώδικα;