Quels types de Promise connais-tu?

Principaux types de promesses en Node.js:

Promise de base: C'est un conteneur pour des valeurs futures ou des erreurs. Elle a trois états : pending (en attente), fulfilled (réalisée), rejected (rejetée). Créée avec le constructeur new Promise().

// Création d'une promesse de base
const myPromise = new Promise((resolve, reject) => {
  // Opération asynchrone
  setTimeout(() => {
    const success = true;
    if (success) {
      resolve("Opération réussie");
    } else {
      reject("Une erreur est survenue");
    }
  }, 1000);
});

Promise.resolve() : Crée une promesse qui passe immédiatement à l'état fulfilled avec une valeur donnée.

// Création d'une promesse résolue
const resolvedPromise = Promise.resolve("Ceci est déjà une promesse résolue");

Promise.reject() : Crée une promesse qui passe immédiatement à l'état rejected avec une raison d'erreur donnée.

// Création d'une promesse rejetée
const rejectedPromise = Promise.reject(new Error("Ceci est une promesse rejetée"));

Promise.all() : Prend un tableau de promesses et retourne une nouvelle promesse. Elle passe à l'état fulfilled lorsque toutes les promesses du tableau sont réussies. La valeur sera un tableau de résultats dans le même ordre que les promesses d'entrée. Si l'une des promesses est rejetée, Promise.all() est rejetée immédiatement avec la raison de la première promesse rejetée.

// Utilisation de Promise.all()
const promise1 = Promise.resolve(1);
const promise2 = Promise.resolve(2);
const promise3 = new Promise((resolve, reject) => setTimeout(() => resolve(3), 100));
Promise.all([promise1, promise2, promise3])
  .then((values) => {
    // values sera [1, 2, 3]
  })
  .catch((error) => {
    // Gestion des erreurs
  });

Promise.allSettled() : Prend un tableau de promesses et retourne une nouvelle promesse. Elle passe à l'état fulfilled lorsque toutes les promesses du tableau sont terminées, avec succès (fulfilled) ou rejet (rejected). La valeur sera un tableau d'objets décrivant le résultat de chaque promesse (état et valeur/raison). Contrairement à Promise.all(), elle ne se rejette pas immédiatement.
```
// Utilisation de Promise.allSettled()
const promiseA = Promise.resolve("succès");
const promiseB = Promise.reject("erreur");
Promise.allSettled([promiseA, promiseB])
  .then((results) => {
    // results sera un tableau d'objets:
    // [{status: 'fulfilled', value: 'succès'}, {status: 'rejected', reason: 'erreur'}]
  });
```

Promise.race() : Prend un tableau de promesses et retourne une nouvelle promesse. La nouvelle promesse passe à l'état fulfilled ou rejected avec le résultat/raison de la première promesse du tableau qui se termine, avec succès ou rejet.

// Utilisation de Promise.race()
const promiseFast = new Promise((resolve, reject) => setTimeout(() => resolve("Je suis rapide!"), 50));
const promiseSlow = new Promise((resolve, reject) => setTimeout(() => resolve("Je suis lent..."), 500));
Promise.race([promiseFast, promiseSlow])
  .then((value) => {
    // value sera "Je suis rapide!"
  });

Promise.any() : Prend un tableau de promesses et retourne une nouvelle promesse. La promesse passe à l'état fulfilled avec la valeur de la première promesse qui se termine avec succès. Si toutes les promesses sont rejetées, Promise.any() renvoie une erreur AggregateError contenant les raisons de toutes les promesses rejetées. Disponible à partir de Node.js 12.

// Utilisation de Promise.any()
const promiseFail1 = Promise.reject("Erreur 1");
const promiseSuccess = Promise.resolve("Succès!");
const promiseFail2 = Promise.reject("Erreur 2");
Promise.any([promiseFail1, promiseSuccess, promiseFail2])
  .then((value) => {
    // value sera "Succès!"
  })
  .catch((error) => {
    // Gestion de l'AggregateError si toutes les promesses sont rejetées
  });