რომელი 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 მდგომარეობაში მითითებული მნიშვნელობით:

  // განკუთვნილი დაპირების შექმნა
  const resolvedPromise = Promise.resolve("ეს უკვე შესრულებული დაპირებაა");
  

• Promise.reject(): ქმნის დაპირებას, რომელიც დაუყოვნებლივ გადადის 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 ან rejected მდგომარეობაში, როდესაც ყველა დაპირება დასრულდება. მნიშვნელობა იქნება ობიექტების მასივი, რომლებიც აღწერენ თითოეული დაპირების შედეგს:

  // 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, რომელიც შეიცავს ყველა უარყოფილი დაპირების მიზეზებს. მომსახურება Node.js 12-დან:

  // 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`-ის, თუ ყველა დაპირება უარყოფილია
    });