Promise : méthode statique withResolvers()

Syntaxe

Promise.withResolvers()

Paramètres

Aucun.

Valeur de retour

Un objet simple contenant les propriétés suivantes :

promise

Un objet Promise.

resolve

Une fonction qui résout la promesse. Pour sa sémantique, voir la référence du constructeur Promise().

reject

Une fonction qui rompt la promesse. Pour sa sémantique, voir la référence du constructeur Promise().

Description

Promise.withResolvers() est exactement équivalent au code suivant :

let resoudre, rompre;
const promesse = new Promise((res, rej) => {
  resoudre = res;
  rompre = rej;
});

Sauf qu'il est plus concis et ne nécessite pas l'utilisation de let.

La principale différence lors de l'utilisation de Promise.withResolvers() est que les fonctions de résolution et de rejet vivent désormais dans la même portée que la promesse elle-même, au lieu d'être créées et utilisées une seule fois dans l'exécuteur. Cela peut permettre certains cas d'utilisation plus avancés, comme lorsqu'on les réutilise pour des évènements récurrents, en particulier avec les flux et les files d'attente. Cela entraîne également généralement moins d'imbrication que d'envelopper beaucoup de logique dans l'exécuteur.

Promise.withResolvers() est générique et prend en charge l'héritage, ce qui signifie qu'il peut être appelé sur des sous-classes de Promise, et le résultat contient une promesse du type de la sous-classe. Pour ce faire, le constructeur de la sous-classe doit implémenter la même signature que le constructeur Promise() — acceptant une seule fonction executor qui peut être appelée avec les fonctions de rappel resolve et reject en tant que paramètres.

Exemples

Transformer un flux en un itérable asynchrone

Le cas d'utilisation de Promise.withResolvers() est lorsque vous avez une promesse qui doit être résolue ou rejetée par un écouteur d'évènements qui ne peut pas être enveloppé à l'intérieur de l'exécuteur de promesse. L'exemple suivant transforme un flux lisible ^(angl.) de Node.js en un itérable asynchrone. Chaque promise ici représente un seul lot de données disponible, et chaque fois que le lot actuel est lu, une nouvelle promesse est créée pour le lot suivant. Remarquez comment les écouteurs d'évènements ne sont attachés qu'une seule fois, mais appellent en réalité une version différente des fonctions resolve et reject à chaque fois.

async function* lisibleAvecIterableAsync(flux) {
  let { promise, resolve, reject } = Promise.withResolvers();
  flux.on("error", (erreur) => reject(erreur));
  flux.on("end", () => resolve());
  flux.on("readable", () => resolve());

  while (flux.readable) {
    await promise;
    let portion;
    while ((portion = flux.read())) {
      yield portion;
    }
    ({ promise, resolve, reject } = Promise.withResolvers());
  }
}

Appeler withResolvers() sur un constructeur qui n'est pas une promesse

Promise.withResolvers() est une méthode générique. Elle peut être appelée sur n'importe quel constructeur qui implémente la même signature que le constructeur Promise(). Par exemple, vous pouvez l'appeler sur un constructeur qui transmet console.log comme fonctions resolve et reject à executeur :

class PasUnePromesse {
  constructor(executeur) {
    // Les fonctions « resolve » et « reject » ne se comportent pas du
    // tout comme celles d'une promesse native, mais
    // Promise.withResolvers() les retourne telles quelles.
    executeur(
      (valeur) => console.log("Résolue", valeur),
      (raison) => console.log("Rompue", raison),
    );
  }
}

const { promise, resolve, reject } = Promise.withResolvers.call(PasUnePromesse);
resolve("bonjour");
// Journaux : Résolue bonjour

Spécifications

Compatibilité des navigateurs

Voir aussi

• La prothèse d'émulation de Promise.withResolvers dans core-js ^(angl.)
• La prothèse d'émulation es-shims de Promise.withResolvers ^(angl.)
• Le guide d'utilisation des promesses
• L'objet natif Promise
• Le constructeur Promise()