Ako môžete spracovať chybu (reject) sľubu pri použití…

Keď používate await s sľubom, chyby (reject) môžu byť spracované rôznymi spôsobmi:

Konštrukcia try...catch: Najbežnejší a odporúčaný spôsob. Elegantne zachytí chybu, ktorá je vyhodená pri riešení (resolve) alebo odmietnutí (reject) sľubu.

async function fetchData() {
  try {
    const response = await fetch('https://api.example.com/data');
    if (!response.ok) {
      throw new Error(`HTTP chyba! stav: ${response.status}`);
    }
    const data = await response.json();
    console.log(data);
  } catch (error) {
    console.error('Chyba pri získavaní dát:', error);
    // Ďalšie spracovanie chyby alebo upozornenie používateľa
  }
}

fetchData();

Metóda .catch() po await: Menej preferovaná, ale možná. Chyba bude spracovaná v callbacku .catch(), ak je sľub odmietnutý.

async function fetchData() {
  const response = await fetch('https://api.example.com/data')
    .catch(error => {
      console.error('Chyba pri vykonávaní fetch:', error);
      // Spracovanie chyby fetch
      throw error; // Prenos chyby na ďalšie spracovanie, ak je potrebné
    });

  if (response && !response.ok) {
       console.error(`HTTP chyba! stav: ${response.status}`);
       // Spracovanie HTTP chyby
  }

  if (response && response.ok) {
      const data = await response.json()
          .catch(error => {
              console.error('Chyba pri parsovaní JSON:', error);
              // Spracovanie chyby parsovania JSON
          });
      if (data) {
          console.log(data);
      }
  }
}

fetchData();

Tento prístup môže byť zložitý pri spracovaní viacerých potenciálnych bodov zlyhania.

Spracovanie s návratovou hodnotou chyby: Niektoré knižnice alebo vlastné funkcie môžu vracať dvojicu [dáta, chyba] namiesto odmietnutia sľubu.

async function safelyFetchData() {
   const [data, error] = await safePromise(fetch('https://api.example.com/data'));
   if (error) {
      console.error('Všeobecná chyba pri získavaní dát:', error);
      return null; // Alebo iná hodnota indikujúca neúspech
   }
   // Predpokladáme, že safePromise tiež spracováva response.ok
   console.log(data);
   return data;
}

// Príklad implementácie safePromise (zjednodušené)
async function safePromise(promise) {
    try {
        const result = await promise;
         // Tu môže byť kontrola result.ok pre fetch
         if (result && result.ok !== undefined && !result.ok) {
             throw new Error(`HTTP chyba! stav: ${result.status}`);
         }
        // Pre fetch, možno bude treba počkať aj na 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();

Tento vzor (často nazývaný "error-first callback" alebo "go-style error handling") je vhodný, keď je potrebné spracovávať chyby lokálne bez prerušenia behu funkcie.

Najčistejším a najčitateľnejším spôsobom je použitie try...catch okolo bloku kódu obsahujúceho await.

Ako môžete spracovať chybu (reject) sľubu pri použití await?