როგორ შეიძლება მართოთ დაპირების შეცდომა (უარყოფა) `await`-ის გამოყენებისას?

await-თან промის გამოყენებისას, შეცდომები (reject) შეიძლება დამუშავდეს რამდენიმე გზით:

1. try...catch კონსტრუქცია: ყველაზე გავრცელებული და რეკომენდებული მეთოდი. საშუალებას აძლევს ელეგანტურად იჭეროს შეცდომა, რომელიც გამოიწვია პრომის განსახილველმა (resolve) ან უარყოფამ (reject).

   async function fetchData() {
     try {
       const response = await fetch('https://api.example.com/data');
       if (!response.ok) {
         throw new Error(`HTTP შეცდომა! სტატუსი: ${response.status}`);
       }
       const data = await response.json();
       console.log(data);
     } catch (error) {
       console.error('შეცდომა მონაცემების მიღებისას:', error);
       // დამატებითი შეცდომის დამუშავება ან მომხმარებლის შეტყობინება
     }
   }
   
   fetchData();
   

2. .catch() მეთოდი await-ის შემდეგ: ნაკლებად სასურველი, მაგრამ შესაძლო ვარიანტი. შეცდომა დამუშავდება .catch()-ის კოლბეკში, თუ პრომისი უარყოფილია.

   async function fetchData() {
     const response = await fetch('https://api.example.com/data')
       .catch(error => {
         console.error('შეცდომა fetch-ის შესრულებისას:', error);
         // fetch-ის შეცდომის დამუშავება
         throw error; // გადაგზავნა შეცდომის დამატებითი დამუშავებისთვის, თუ საჭიროა
       });
   
     if (response && !response.ok) {
          console.error(`HTTP შეცდომა! სტატუსი: ${response.status}`);
          // HTTP შეცდომის დამუშავება
     }
   
     if (response && response.ok) {
         const data = await response.json()
             .catch(error => {
                 console.error('შეცდომა JSON-ის ანალიზისას:', error);
                 // JSON-ის ანალიზის შეცდომის დამუშავება
             });
         if (data) {
             console.log(data);
         }
     }
   }
   
   fetchData();
   

   ეს მიდგომა შეიძლება გახდეს მოუხერხებელი მრავალ შესაძლო შეცდომის წერტილში დამუშავებისას.

3. შეცდომის დაბრუნების მეთოდი: ზოგი ბიბლიოთეკა ან საკუთარი ფუნქციები შეიძლება აბრუნებდეს ტოლკს [მონაცემები, შეცდომა] ნაცვლად პრომის უარყოფის.

   async function safelyFetchData() {
      const [data, error] = await safePromise(fetch('https://api.example.com/data'));
      if (error) {
         console.error('საერთო შეცდომა მონაცემების მიღებისას:', error);
         return null; // ან სხვა მნიშვნელობა, რომელიც მიუთითებს შეცდომაზე
      }
      // ვარაუდი, რომ safePromise ასევე მართავს response.ok-ს
      console.log(data);
      return data;
   }
   
   // მაგალითი safePromise-ის რეალიზაციის (სადავო)
   async function safePromise(promise) {
       try {
           const result = await promise;
            // აქ შეიძლება იყოს check result.ok fetch-ისთვის
            if (result && result.ok !== undefined && !result.ok) {
                throw new Error(`HTTP შეცდომა! სტატუსი: ${result.status}`);
            }
           // fetch-ისთვის, შესაძლოა, საჭიროა await result.json()
           if (result && typeof result.json === 'function') {
               const jsonData = await result.json();
               return [jsonData, null];
           }
           return [result, null];
       } catch (error) {
           return [null, error];
       }
   }
   
   safelyFetchData();
   

   ეს ნიმუში (სხვადასხვა სახელით "error-first callback" ან "go-style error handling") მოსახერხებელია, როდესაც საჭიროა შეცდომების ადგილობრივი დამუშავება, ფუნქციის გაჩერების გარეშე.

ყველაზე სუფთა და კითხულადი მეთოდი არის try...catch-ის გამოყენება await-ის შემცველ კოდის ბლოკის გარშემო.