Ի՞նչ տեսակի Promise-ներ գիտես։

Node.js-ում հիմնական տեսակի խոստումները:

• Հիմնական խոստում: Ներկայացնում է ապագա արժեքների կամ սխալների համար կոնտեյներ: Ունի երեք վիճակներ՝ pending (սպասում է), fulfilled (հաջողությամբ կատարված), rejected (անհաջողված սխալի պատճառով): Ստեղծվում է new Promise() կոնստրուկտորով:

  // Հիմնական խոստում ստեղծելը
  const myPromise = new Promise((resolve, reject) => {
    // Ասինխրոն գործողություն
    setTimeout(() => {
      const success = true;
      if (success) {
        resolve("Գործողությունը հաջողությամբ ավարտվեց");
      } else {
        reject("Սխալ է տեղի ունեցել");
      }
    }, 1000);
  });
  

• Promise.resolve(): Ստեղծում է խոստում, որը անմիջապես անցնում է fulfilled վիճակին նշված արժեքով:

  // Resolved խոստում ստեղծելը
  const resolvedPromise = Promise.resolve("Սա արդեն կատարված խոստում է");
  

• Promise.reject(): Ստեղծում է խոստում, որը անմիջապես անցնում է rejected վիճակին նշված սխալի պատճառով:

  // Rejected խոստում ստեղծելը
  const rejectedPromise = Promise.reject(new Error("Սա մերժված խոստում է"));
  

• Promise.all(): Ստանում է խոստումների զանգված և վերադարձնում նոր խոստում: Այս նոր խոստումը անցնում է fulfilled վիճակին, երբ բոլորը հաջողությամբ ավարտվեն: Արժեքը կլինի արդյունքների զանգված՝ նույն կարգով, ինչ մուտքային խոստումները: Եթե միայն մեկը մերժվի, Promise.all() մերժվում է առաջին մերժված խոստումով:

  // 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 կլինի [1, 2, 3]
    })
    .catch((error) => {
      // սխալների մշակումը
    });
  

• Promise.allSettled(): Ստանում է խոստումների զանգված և վերադարձնում նոր խոստում: Այս նոր խոստումը անցնում է fulfilled վիճակին, երբ բոլորը կամ հաջողությամբ ավարտվեն, կամ մերժվեն: Արժեքը կլինի օբյեկտների զանգված, որոնք նկարագրում են յուրաքանչյուր խոստման արդյունքը:

  // Promise.allSettled() օգտագործում
  const promiseA = Promise.resolve("հաջողություն");
  const promiseB = Promise.reject("սխալ");
  Promise.allSettled([promiseA, promiseB])
    .then((results) => {
      // results կլինի օբյեկտների զանգված՝
      // [{status: 'fulfilled', value: 'հաջողություն'}, {status: 'rejected', reason: 'սխալ'}]
    });
  

• Promise.race(): Ստանում է խոստումների զանգված և վերադարձնում նոր խոստում: Այս նոր խոստումը անցնում է fulfilled կամ rejected վիճակին, երբ առաջին խոստումը, որը կամ հաջողությամբ ավարտվեց, կամ մերժվեց:

  // Promise.race() օգտագործում
  const promiseFast = new Promise((resolve, reject) => setTimeout(() => resolve("Ես արագ եմ!"), 50));
  const promiseSlow = new Promise((resolve, reject) => setTimeout(() => resolve("Ես դանդաղ եմ..."), 500));
  Promise.race([promiseFast, promiseSlow])
    .then((value) => {
      // value կլինի "Ես արագ եմ!"
    });
  

• Promise.any(): Ստանում է խոստումների զանգված և վերադարձնում նոր խոստում: Այս նոր խոստումը անցնում է fulfilled վիճակին, երբ առաջին հաջող ավարտվող խոստումը հայտնաբերվում է: Եթե բոլոր խոստումները մերժվեն, Promise.any() վերադարձնում է սխալ AggregateError, որը պարունակում է բոլոր մերժված խոստումների պատճառները:

  // Promise.any() օգտագործում
  const promiseFail1 = Promise.reject("Սխալ 1");
  const promiseSuccess = Promise.resolve("Հաջողություն!");
  const promiseFail2 = Promise.reject("Սխալ 2");
  Promise.any([promiseFail1, promiseSuccess, promiseFail2])
    .then((value) => {
      // value կլինի "Հաջողություն!"
    })
    .catch((error) => {
      // Օպերատիվ `AggregateError`, եթե բոլոր խոստումները մերժվեն
    });