Constructeur

Il n'existe pas d'entité JavaScript correspondant au constructeur AsyncGenerator. Les instances d'AsyncGenerator doivent être retournées par des fonctions génératrices asynchrones :

async function* createAsyncGenerator() {
  yield Promise.resolve(1);
  yield await Promise.resolve(2);
  yield 3;
}
const asyncGen = createAsyncGenerator();
asyncGen.next().then((res) => console.log(res.value)); // 1
asyncGen.next().then((res) => console.log(res.value)); // 2
asyncGen.next().then((res) => console.log(res.value)); // 3

Il existe uniquement un objet caché qui est l'objet prototype partagé par tous les objets créés par les fonctions génératrices asynchrones. Cet objet est souvent présenté sous la forme AsyncGenerator.prototype pour lui donner l'apparence d'une classe, mais il devrait plutôt s'appeler AsyncGeneratorFunction.prototype.prototype, car AsyncGeneratorFunction est une véritable entité JavaScript. Pour comprendre la chaîne de prototypes des instances d'AsyncGenerator, voir AsyncGeneratorFunction.prototype.prototype.

Propriétés d'instance

Ces propriétés sont définies sur AsyncGenerator.prototype et partagées par toutes les instances d'AsyncGenerator.

AsyncGenerator.prototype.constructor

La fonction constructeur qui a créé l'objet instance. Pour les instances d'AsyncGenerator, la valeur initiale est AsyncGeneratorFunction.prototype.

Note : Les objets AsyncGenerator ne conservent pas de référence vers la fonction génératrice asynchrone qui les a créés.

AsyncGenerator.prototype[Symbol.toStringTag]

La valeur initiale de la propriété [Symbol.toStringTag] est la chaîne de caractères "AsyncGenerator". Cette propriété est utilisée par Object.prototype.toString().

Méthodes d'instance

Hérite aussi des méthodes d'instance de sa super‑classe AsyncIterator.

AsyncGenerator.prototype.next()

Retourne une promesse (Promise) qui sera résolue avec la valeur fournie par l'expression yield.

AsyncGenerator.prototype.return()

Agit comme si une instruction return était insérée dans le corps du générateur à la position suspendue actuelle, ce qui termine le générateur et lui permet d'effectuer des opérations de nettoyage lorsqu'il est combiné avec un bloc try...finally.

AsyncGenerator.prototype.throw()

Agit comme si une instruction throw était insérée dans le corps du générateur à la position suspendue actuelle, ce qui informe le générateur d'une condition d'erreur et lui permet de gérer l'erreur, ou d'effectuer un nettoyage et de se fermer.

Exemples

Itération d'un générateur asynchrone

L'exemple suivant itère sur un générateur asynchrone, affichant les valeurs 1-6 dans la console à des intervalles de temps décroissants. Remarquez qu'à chaque fois qu'une Promise est yieldée, elle est automatiquement résolue dans la boucle for await...of.

// Une tâche asynchrone. Imaginez qu'elle fasse quelque chose de plus utile
// en pratique.
function valeurRetardee(time, value) {
  return new Promise((resolve /*, reject */) => {
    setTimeout(() => resolve(value), time);
  });
}

async function* generer() {
  yield valeurRetardee(2000, 1);
  yield valeurRetardee(1000, 2);
  yield valeurRetardee(500, 3);
  yield valeurRetardee(250, 4);
  yield valeurRetardee(125, 5);
  yield valeurRetardee(50, 6);
  console.log("Terminé !");
}

async function principal() {
  for await (const value of generer()) {
    console.log("valeur", value);
  }
}

principal().catch((e) => console.error(e));

Spécifications

Compatibilité des navigateurs

Voir aussi

• L'instruction function*
• L'instruction async function*
• L'expression function*
• Fonction génératrice
• Fonction génératrice asynchrone
• Guide des itérateurs et des générateurs