const promise1 = new Promise((resolve, reject) => {  resolve("Success!");});promise1.then((value) => {  console.log(value);  // Expected output: "Success!"});

then(siTenue)then(siTenue, siRejetée)

const p1 = new Promise((resoudre, rejeter) => {  resoudre("Réussite !");  // ou  // rejeter(new Error("Erreur !"));});p1.then(  (value) => {    console.log(value); // Réussite !  },  (reason) => {    console.error(reason); // Erreur !  },);

Promise.resolve(1).then(2).then(console.log); // 1Promise.reject(1).then(2, 2).then(console.log, console.log); // 1

Promise.resolve("toto")  // 1. On reçoit "toto", on y concatène "truc" et on résout  // avec la valeur obtenue pour le prochain then  .then(    (chaine) =>      new Promise((resoudre, rejeter) => {        setTimeout(() => {          chaine += "truc";          resoudre(chaine);        }, 1);      }),  )  // 2. On reçoit "tototruc", on enregistre une fonction de rappel  // pour manipuler cette chaîne et l'afficher dans la console  // mais on renverra avant la chaîne non modifiée au prochain then  .then((chaine) => {    setTimeout(() => {      chaine += "machin";      console.log(chaine); // tototrucmachin    }, 1);    return chaine;  })  // 3. On affiche des messages sur l'exécution du code dans cette section  // avant le traitement de la chaîne dans le bloc then() précédent.  .then((chaine) => {    console.log(      "Dernier then(). Oups, on n'a pas pris la peine d'instancier et de renvoyer une promesse dans l'appel then() précédent. L'ordre de la séquence pourrait être surprenant.",    );    // On notera qu'ici `chaine` n'a pas le suffixe 'machin'. En effet, nous avons    // simuler l'attente asynchrone avec une fonction setTimeout()    console.log(chaine); // tototruc  });// Affichera ceci dans la console, dans cet ordre :// Dernier then(). Oups, on n'a pas pris la peine d'instancier et de renvoyer une promesse dans l'appel then() précédent. L'ordre de la séquence pourrait être surprenant.// tototruc// tototrucmachin

const p2 = new Promise((resoudre, rejeter) => {  resoudre(1);});p2.then((valeur) => {  console.log(valeur); // 1  return valeur + 1;}).then((valeur) => {  console.log(valeur, "- une valeur synchrone fonctionne"); // 2 - une valeur synchrone fonctionne});p2.then((valeur) => {  console.log(valeur); // 1});

Promise.resolve()  .then(() => {    // On lève une exception pour que .then()    // renvoie une promesse rompue    throw new Error("Oh non !");  })  .then(    () => {      console.log("Pas appelée.");    },    (erreur) => {      console.error(`Fonction siRejetée() appelée : ${erreur.message}`);    },  );

Promise.resolve()  .then(() => {    // On lève une exception pour que .then()    // renvoie une promesse rompue    throw new Error("Oh non !");  })  .catch((erreur) => {    console.error(`Fonction siRejetée() appelée : ${erreur.message}`);  })  .then(() => {    console.log(      "Je suis toujours appelée, même si la promesse du then() précédent échoue.",    );  });

Promise.reject()  .then(    () => 99,    () => 42,  ) // siRejetée renvoie 42 qui est empaqueté dans une promesse tenue  .then((solution) => console.log(`Résolue avec ${solution}`)); // Résolue avec 42

function resoudrePlusTard(resoudre, rejeter) {  setTimeout(() => {    resoudre(10);  }, 1000);}function rejeterPlusTard(resoudre, rejeter) {  setTimeout(() => {    rejeter(new Error("Erreur"));  }, 1000);}const p1 = Promise.resolve("toto");const p2 = p1.then(() => {  // On renvoie une promesse qui sera résolue avec la valeur 10 après 1 seconde  return new Promise(resoudrePlusTard);});p2.then(  (v) => {    console.log("résolue", v); // "résolue", 10  },  (e) => {    // N'est pas appelée    console.error("rejetée", e);  },);const p3 = p1.then(() => {  // On renvoie une promesse qui sera rejetée avec 'Erreur' après 1 seconde  return new Promise(rejeterPlusTard);});p3.then(  (v) => {    // N'est pas appelée    console.log("résolue", v);  },  (e) => {    console.error("rejetée", e); // "rejetée", 'Erreur'  },);

function obtenirDonnees() {  // L'API fetch() renvoie une promesse. Cette fonction  // renvoie également une promesse sauf qu'on effectue  // un traitement plus avancé sur la valeur de résolution  // de la promesse renvoyée.  return fetch("current-data.json").then((response) => {    if (response.headers.get("content-type") !== "application/json") {      throw new TypeError();    }    const j = response.json();    // faire quelque chose avec j    // La valeur de réussite fournie lorsqu'on    // appelle obtenirDonnees().then()    return j;  });}

// Prenons une promesse résolue comme 'promResolue', l'appel à// 'promResolue.then(…)' renvoie immédiatement une nouvelle promesse,// mais la fonction de rappel '(value) => {…}' sera appelée de// façon asynchrone, comme on peut le voir dans la console.// La nouvelle promesse est affectée à 'promSuivante', cette// dernière est résolue avec la valeur renvoyée par le gestionnaire.const promResolue = Promise.resolve(33);console.log(promResolue);const promSuivante = promResolue.then((valeur) => {  console.log(    `Ceci est appelé après la fin de la pile principale. ` +      `La valeur reçue est : ${valeur}, la valeur renvoyée est : ${valeur + 1}`,  );  return valeur + 1;});console.log(promSuivante);// En utilisant setTimeout(), on peut retarder l'exécution d'une fonction// jusqu'au moment où la pile des appels est videsetTimeout(() => {  console.log(promSuivante);});// Le code qui précède, affichera ce qui suit dans cet ordre :// Promise {[[PromiseStatus]]: "resolved", [[PromiseResult]]: 33}// Promise {[[PromiseStatus]]: "pending", [[PromiseResult]]: undefined}// "Ceci est appelé après la fin de la pile principale. La valeur reçue est : 33, la valeur renvoyée est : 34"// Promise {[[PromiseStatus]]: "resolved", [[PromiseResult]]: 34}

Help improve MDN

Cette page a été modifiée le⁨17 févr. 2025⁩ par lescontributeurs du MDN.