პრომისების ჯაჭვებში გამონაკლისები JavaScript-ში

დაე, რაღაც მიზეზების გამო, ჩვენი პრომისი დასრულდეს შეცდომით:

javascriptlet promise = new Promise(function(resolve, reject) {
  setTimeout(function() {
    reject('error');
  }, 3000);
});

ამ შემთხვევაში კოდის შესრულება მაშინვე გადავა იმ then-ზე, რომელშიც არის შეცდომის დამმუშავებელი ფუნქცია, ან პირველ catch-ზე, იმის მიხედვით, რაც ჯერ შეგვხვდება.

აი პირველი სიტუაციის მაგალითი:

javascriptpromise.then(
  function(result) {
    return result + '1';
  }
).then(
  function(result) {
    return result + '2';
  },
  function(error) {
    // შესრულება მაშინვე გადავა აქ
  }
).then(
  function(result) {
    console.log(result);
  }
);

აი მეორე სიტუაციის მაგალითი:

javascriptpromise.then(
  function(result) {
    return result + '1';
  }
).then(
  function(result) {
    return result + '2';
  }
).catch(
  function(error) {
    // შესრულება მაშინვე გადავა აქ
  }
).then(
  function(result) {
    console.log(result);
  }
);

დამმუშავებელ ფუნქციას ორი ვარიანტი აქვს: თუ მან გაუმკლავდა გამონაკლისურ სიტუაციას, მაშინ შეუძლია დააბრუნოს შედეგი return-ის მეშვეობით და შესრულება გაგრძელდება შემდგომ ჯაჭვში. თუ კი მას ვერ გაუმკლავდა შეცდომას, მაშინ შეუძლია ან არაფერი დააბრუნოს, ან გამოისროლოს გამონაკლისი throw-ის მეშვეობით. ამ შემთხვევაში შესრულება გადავა შემდეგ შეცდომის დამმუშავებელზე (then-ში ან catch-ში - რაც ჯერ შეგვხვდება).

როგორც წესი, ყველა შეცდომა ჯაჭვიდან იჭერება ერთ ადგილას: ჯაჭვის ბოლოში მოთავსებულია catch:

javascriptpromise.then(
  function(result) {
    return result + '1';
  }
).then(
  function(result) {
    return result + '2';
  }
).catch(
  function(error) {
    // მივალთ აქ შეცდომის შემთხვევაში
  }
);

ამ შემთხვევაში გამონაკლისს შეუძლია წარმოიშვას თვითონ პრომისში, ან იყოს გამოშვებული throw-ის მეშვეობით ჯაჭვის ნებისმიერ რგოლში:

javascriptpromise.then(
  function(result) {
    return result + '1';
  }
).then(
  function(result) {
    if (ყველაფერიკარგადაა) {
      return result + '2';
    } else {
      throw new Error('შეცდომა'); // გადავდივართ უახლოეს დამმუშავებელთან
    }
  }
)
.then(
  function(result) {
    return result + '3';
  }
).catch(
  function(error) {
    // უახლოესი დამმუშავებელი
  }
);

გაითვალისწინეთ, რომ catch საჭიროა ზუსტად შეცდომის დიაგნოსტიკისთვის: არის ის მოსაგვარებელი თუ არა. თუ შეცდომა მოსაგვარებელია, მაშინ catch უნდა გადასცეს მისი გადაწყვეტა თავის შემდგომ then-ს. ხოლო თუ არ არის მოსაგვარებელი (ან ეს კონკრეტული catch უბრალოდ არ იცის მისი გადაწყვეტა), მაშინ ჩვენ უნდა ან არაფერი დავაბრუნოთ ან გამოვისროლოთ გამონაკლისი:

javascriptpromise.then(
  function(result) {
    return result + '1';
  }
).then(
  function(result) {
    return result + '2';
  }
).catch(
  function(error) {
    if (შეცდომამოსაგვარებელი�ა) {
      return 'მონაცემები'; // ვგზავნით შემდეგ then-ზე
    } else {
      // არაფერს არ ვაბრუნებთ ან ვისროლეთ გამონაკლისი
    }
  }
).then(
  function(result) {
    // აქ ვაგვარებთ შეცდომას
  }
);