Milyen Promise típusokat ismersz?

Node.js-ben a fő ígért típusok:

• Alap ígéret: Egy konténer a jövőbeli értékek vagy hibák számára. Három állapota van: pending (várakozás), fulfilled (sikeresen teljesítve), rejected (elutasítva hibával). A new Promise() konstruktorral hozható létre.

  // Alap ígéret létrehozása
  const myPromise = new Promise((resolve, reject) => {
    // Aszinkron művelet
    setTimeout(() => {
      const success = true;
      if (success) {
        resolve("Művelet sikeresen befejeződött");
      } else {
        reject("Hiba történt");
      }
    }, 1000);
  });
  

• Promise.resolve(): Egy ígéretet hoz létre, amely azonnal fulfilled állapotba kerül egy adott értékkel.

  // Megoldott ígéret létrehozása
  const resolvedPromise = Promise.resolve("Ez már teljesített ígéret");
  

• Promise.reject(): Egy ígéretet hoz létre, amely azonnal rejected állapotba kerül egy hibával.

  // Elutasított ígéret létrehozása
  const rejectedPromise = Promise.reject(new Error("Ez egy elutasított ígéret"));
  

• Promise.all(): Egy ígéretek tömbjét fogadja, és egy új ígéretet ad vissza. Ez az új ígéret akkor kerül fulfilled állapotba, amikor minden ígéret sikeresen befejeződik. Az érték egy eredményekből álló tömb lesz ugyanabban a sorrendben, mint a bemeneti ígéretek. Ha bármi ígéret elutasításra kerül, a Promise.all() azonnal elutasításra kerül az első elutasított ígéret okával.

  // A Promise.all() használata
  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 [1, 2, 3] lesz
    })
    .catch((error) => {
      // Hibakezelés
    });
  

• Promise.allSettled(): Egy ígéretek tömbjét fogadja, és egy új ígéretet ad vissza. Ez az új ígéret akkor kerül fulfilled állapotba, amikor minden ígéret sikeresen befejeződik vagy elutasításra kerül. Az eredmény egy objektumokat tartalmazó tömb lesz, amelyek leírják az egyes ígéretek eredményét (állapot és érték/ok). A Promise.all()-tól eltérően, nem utasítódik el azonnal.

  // Promise.allSettled() használata
  const promiseA = Promise.resolve("siker");
  const promiseB = Promise.reject("hiba");
  Promise.allSettled([promiseA, promiseB])
    .then((results) => {
      // results egy objektumokat tartalmazó tömb lesz:
      // [{status: 'fulfilled', value: 'siker'}, {status: 'rejected', reason: 'hiba'}]
    });
  

• Promise.race(): Egy ígéretek tömbjét fogadja, és egy új ígéretet ad vissza. Ez az új ígéret akkor kerül fulfilled vagy rejected állapotba, a első ígéret eredményével vagy okával, amely sikeresen befejeződik vagy elutasításra kerül.

  // Promise.race() használata
  const promiseFast = new Promise((resolve, reject) => setTimeout(() => resolve("Gyors vagyok!"), 50));
  const promiseSlow = new Promise((resolve, reject) => setTimeout(() => resolve("Lassú vagyok..."), 500));
  Promise.race([promiseFast, promiseSlow])
    .then((value) => {
      // value "Gyors vagyok!" lesz
    });
  

• Promise.any(): Egy ígéretek tömbjét fogadja, és egy új ígéretet ad vissza. Ez az új ígéret akkor kerül fulfilled állapotba, amikor az első sikeresen befejeződő ígéret eredményével. Ha minden ígéret elutasításra kerül, a Promise.any() egy AggregateError hibát ad vissza, amely tartalmazza az összes elutasított ígéret okát. A Node.js 12-től elérhető.

  // Promise.any() használata
  const promiseFail1 = Promise.reject("Hiba 1");
  const promiseSuccess = Promise.resolve("Siker!");
  const promiseFail2 = Promise.reject("Hiba 2");
  Promise.any([promiseFail1, promiseSuccess, promiseFail2])
    .then((value) => {
      // value "Siker!" lesz
    })
    .catch((error) => {
      // Az összes elutasított ígéret okát tartalmazó AggregateError kezelése
    });