CKTIS / JavaScript
Les fonctions resolve et reject de l’exécuteur de Promise
Le constructeur `Promise` fournit deux fonctions à son exécuteur. Le premier appel à l’une d’elles fixe l’issue de la promesse sans nécessairement la terminer sur-le-champ.
Version : ECMAScript 2024 and the current web platform; runtime support varies
Syntaxe
new Promise((resolve, reject) => { /* Call resolve(value) or reject(reason). */ });new Promise(executor) attend une fonction et l’appelle de manière synchrone, avec resolve en premier et reject en second. Ces noms de paramètres sont conventionnels ; chaque paire est liée à une seule promesse nouvellement créée. Les deux fonctions renvoient undefined et peuvent être conservées pour un appel ultérieur, par exemple dans une fonction de rappel. Les méthodes statiques Promise.resolve() et Promise.reject(), elles, renvoient des promesses.
resolve(value) accomplit immédiatement la promesse si la valeur passée est primitive. Passer la promesse à son propre resolve la rejette avec une TypeError. Pour tout autre objet, JavaScript lit la propriété then de manière synchrone. Si la valeur lue n’est pas appelable, la promesse est immédiatement accomplie avec l’objet lui-même, même s’il s’agit d’une autre promesse. Si la valeur lue est appelable, l’objet est un thenable : JavaScript appelle then plus tard. La promesse suit l’issue du thenable et peut rester en attente. Une exception lors de la lecture de then, ou lors de son appel avant que l’une des fonctions de rappel qui lui sont fournies ait été appelée, entraîne aussi un rejet.
reject(reason) rejette immédiatement la promesse avec le motif donné, sans en suivre l’issue même si ce motif est une promesse. Toute valeur est admise, mais un objet Error est généralement plus utile. Sans argument, la valeur est undefined. Seul le premier appel à l’une des deux fonctions compte, même si la promesse est encore en attente. Son issue est fixée (resolved), mais elle n’est terminée (settled) qu’une fois accomplie ou rejetée. Les gestionnaires enregistrés avec then() et catch() s’exécutent de manière asynchrone.
Le constructeur ignore la valeur renvoyée par l’exécuteur. Une exception qui sort de l’exécuteur de manière synchrone ne rejette la promesse que si aucune des deux fonctions n’a été appelée. Si aucune ne l’est jamais et que l’exécuteur ne lève pas d’exception, la promesse reste en attente. Évitez un exécuteur async : le constructeur ignore la promesse qu’il renvoie, donc le rejet de celle-ci ne rejette pas la promesse extérieure.
Exemples
{
let finish;
const inner = new Promise((resolve) => {
finish = resolve;
});
const outer = new Promise((resolve, reject) => {
console.log("executor");
resolve(inner);
reject(new Error("ignored"));
});
console.log("after constructor");
outer.then((value) => {
console.log(`fulfilled: ${value}`);
return new Promise((resolve, reject) => {
reject(new Error("failed"));
});
}).catch((reason) => {
console.log(`rejected: ${reason.message}`);
});
finish(42);
}Résultat
executor after constructor fulfilled: 42 rejected: failed
`executor` apparaît avant `after constructor`, car l’exécuteur s’exécute de manière synchrone. `resolve(inner)` fixe l’issue de `outer` alors que `inner` est en attente ; `reject(new Error("ignored"))` n’a donc aucun effet. `finish(42)` accomplit `inner` ; le gestionnaire affiche `fulfilled: 42`, puis `catch()` traite le rejet d’une autre promesse avec le message `failed`.
Leçons associées
- JavaScript · Leçon 14 · Intermédiaire · Version : 3
- JavaScript · Leçon 15 · Intermédiaire · Version : 3