Jakie rodzaje Promise znasz?

Główne typy obietnic w Node.js:

Podstawowa obietnica: Reprezentuje kontener dla przyszłych wartości lub błędów. Ma trzy stany: pending (oczekujące), fulfilled (zrealizowane), rejected (odrzucone). Tworzy się ją za pomocą konstruktora new Promise().

// Tworzenie podstawowej obietnicy
const myPromise = new Promise((resolve, reject) => {
  // Operacja asynchroniczna
  setTimeout(() => {
    const success = true;
    if (success) {
      resolve("Operacja pomyślnie zakończona");
    } else {
      reject("Wystąpił błąd");
    }
  }, 1000);
});

Promise.resolve(): Tworzy obietnicę, która natychmiast przechodzi do stanu fulfilled z podaną wartością.

// Tworzenie rozwiązanej obietnicy
const resolvedPromise = Promise.resolve("To już jest rozwiązana obietnica");

Promise.reject(): Tworzy obietnicę, która natychmiast przechodzi do stanu rejected z podaną przyczyną błędu.

// Tworzenie odrzuconej obietnicy
const rejectedPromise = Promise.reject(new Error("To jest odrzucona obietnica"));

Promise.all(): Przyjmuje tablicę obietnic i zwraca nową obietnicę. Przechodzi do stanu fulfilled, gdy wszystkie obietnice w tablicy zostaną pomyślnie zakończone. Wartość będzie tablicą wyników w tym samym porządku co wejściowe obietnice. Jeśli któraś z obietnic zostanie odrzucona, Promise.all() zostanie odrzucona natychmiast z przyczyną pierwszej odrzuconej obietnicy.
```
// Użycie 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 będzie [1, 2, 3]
  })
  .catch((error) => {
    // Obsługa błędów
  });
```
Promise.allSettled(): Przyjmuje tablicę obietnic i zwraca nową obietnicę. Przechodzi do stanu fulfilled, gdy wszystkie obietnice w tablicy zostaną zakończone, czy to pomyślnie (fulfilled), czy odrzucone (rejected). Wartość będzie tablicą obiektów opisujących wynik każdej obietnicy (stan i wartość/przyczynę). W przeciwieństwie do Promise.all(), nie odrzuca się natychmiast.
```
// Użycie Promise.allSettled()
const promiseA = Promise.resolve("sukces");
const promiseB = Promise.reject("błąd");
Promise.allSettled([promiseA, promiseB])
  .then((results) => {
    // results będzie tablicą obiektów:
    // [{status: 'fulfilled', value: 'sukces'}, {status: 'rejected', reason: 'błąd'}]
  });
```

Promise.race(): Przyjmuje tablicę obietnic i zwraca nową obietnicę. Przechodzi do stanu fulfilled lub rejected z wynikiem/przyczyną pierwszej obietnicy z tablicy, która się zakończyła, czy to pomyślnie, czy odrzucona.

// Użycie Promise.race()
const promiseFast = new Promise((resolve, reject) => setTimeout(() => resolve("Jestem szybki!"), 50));
const promiseSlow = new Promise((resolve, reject) => setTimeout(() => resolve("Jestem wolny..."), 500));
Promise.race([promiseFast, promiseSlow])
  .then((value) => {
    // value będzie "Jestem szybki!"
  });

Promise.any(): Przyjmuje tablicę obietnic i zwraca nową obietnicę. Przechodzi do stanu fulfilled z wartością pierwszej obietnicy, która zakończyła się pomyślnie. Jeśli wszystkie obietnice zostaną odrzucone, Promise.any() zwraca błąd AggregateError, zawierający przyczyny wszystkich odrzuconych obietnic. Dostępne od Node.js 12.

// Użycie Promise.any()
const promiseFail1 = Promise.reject("Błąd 1");
const promiseSuccess = Promise.resolve("Sukces!");
const promiseFail2 = Promise.reject("Błąd 2");
Promise.any([promiseFail1, promiseSuccess, promiseFail2])
  .then((value) => {
    // wartość będzie "Sukces!"
  })
  .catch((error) => {
    // Obsługa błędu `AggregateError`, jeśli wszystkie obietnice zostaną odrzucone
  });