Welke soorten Promise ken je?

Belangrijkste soorten promises in Node.js:

Basic Promise: Een container voor toekomstige waarden of fouten. Heeft drie toestanden: pending (in afwachting), fulfilled (succesvol voltooid), rejected (afgewezen met fout). Wordt gemaakt met de constructor new Promise().

// Aanmaken van een basis promise
const myPromise = new Promise((resolve, reject) => {
  // Asynchrone operatie
  setTimeout(() => {
    const success = true;
    if (success) {
      resolve("Operatie succesvol voltooid");
    } else {
      reject("Er is een fout opgetreden");
    }
  }, 1000);
});

Promise.resolve(): Maakt een promise die onmiddellijk in de fulfilled-staat overgaat met een opgegeven waarde.

// Aanmaken van een resolved promise
const resolvedPromise = Promise.resolve("Dit is al een voltooide promise");

Promise.reject(): Maakt een promise die onmiddellijk in de rejected-staat overgaat met een foutreden.

// Aanmaken van een rejected promise
const rejectedPromise = Promise.reject(new Error("Dit is een afgewezen promise"));

Promise.all(): Neemt een array van promises en geeft een nieuwe promise terug. Deze nieuwe promise gaat in de fulfilled-staat wanneer alle promises in de array succesvol zijn voltooid. De waarde is een array van resultaten in dezelfde volgorde als de input promises. Als één van de promises wordt afgewezen, wordt Promise.all() onmiddellijk afgewezen met de reden van de eerste afgewezen promise.
```
// Gebruik van 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 zal [1, 2, 3] zijn
  })
  .catch((error) => {
    // Foutafhandeling
  });
```
Promise.allSettled(): Neemt een array van promises en geeft een nieuwe promise terug. Deze nieuwe promise gaat in de fulfilled-staat wanneer alle promises of succesvol zijn voltooid (fulfilled) of afgewezen (rejected). De waarde is een array van objecten die het resultaat van elke promise beschrijven (toestand en waarde/reden). In tegenstelling tot Promise.all(), wordt niet onmiddellijk afgewezen.
```
// Gebruik van Promise.allSettled()
const promiseA = Promise.resolve("succes");
const promiseB = Promise.reject("fout");
Promise.allSettled([promiseA, promiseB])
  .then((results) => {
    // results is een array van objecten:
    // [{status: 'fulfilled', value: 'succes'}, {status: 'rejected', reason: 'fout'}]
  });
```

Promise.race(): Neemt een array van promises en geeft een nieuwe promise terug. Deze nieuwe promise gaat in de fulfilled- of rejected-staat met de resultaat/reden van de eerste promise uit de array die succesvol is voltooid of is afgewezen.

// Gebruik van Promise.race()
const promiseFast = new Promise((resolve, reject) => setTimeout(() => resolve("Ik ben snel!"), 50));
const promiseSlow = new Promise((resolve, reject) => setTimeout(() => resolve("Ik ben traag..."), 500));
Promise.race([promiseFast, promiseSlow])
  .then((value) => {
    // value zal "Ik ben snel!" zijn
  });

Promise.any(): Neemt een array van promises en geeft een nieuwe promise terug. Deze gaat in de fulfilled-staat met de waarde van de eerste promise die succesvol is voltooid. Als alle promises worden afgewezen, geeft Promise.any() een fout AggregateError met de redenen van alle afgewezen promises. Beschikbaar vanaf Node.js 12.

// Gebruik van Promise.any()
const promiseFail1 = Promise.reject("Fout 1");
const promiseSuccess = Promise.resolve("Succes!");
const promiseFail2 = Promise.reject("Fout 2");
Promise.any([promiseFail1, promiseSuccess, promiseFail2])
  .then((value) => {
    // value zal "Succes!" zijn
  })
  .catch((error) => {
    // Foutafhandeling van AggregateError als alle promises worden afgewezen
  });