Jak ošetřit chybu (odmítnutí) promise při použití…

Při použití await s promise mohou být chyby (reject) zpracovány několika způsoby:

Struktura try...catch: Nejčastější a doporučený způsob. Elegantně zachytí chybu, která je vyhozena při řešení (resolve) nebo odmítnutí (reject) promise.

async function fetchData() {
  try {
    const response = await fetch('https://api.example.com/data');
    if (!response.ok) {
      throw new Error(`HTTP error! status: ${response.status}`);
    }
    const data = await response.json();
    console.log(data);
  } catch (error) {
    console.error('Chyba při získávání dat:', error);
    // Další zpracování chyby nebo upozornění uživatele
  }
}

fetchData();

Metoda .catch() po await: Méně preferovaná, ale možná. Chyba bude zpracována v callbacku .catch(), pokud je promise odmítnuto.

async function fetchData() {
  const response = await fetch('https://api.example.com/data')
    .catch(error => {
      console.error('Chyba při provádění fetch:', error);
      // Zpracování chyby fetch
      throw error; // Přenesení chyby pro další zpracování, pokud je třeba
    });

  if (response && !response.ok) {
       console.error(`HTTP error! status: ${response.status}`);
       // Zpracování HTTP chyby
  }

  if (response && response.ok) {
      const data = await response.json()
          .catch(error => {
              console.error('Chyba při parsování JSON:', error);
              // Zpracování chyby parsování JSON
          });
      if (data) {
          console.log(data);
      }
  }
}

fetchData();

Tento přístup může být složitý při zpracování mnoha potenciálních bodů selhání.

Zpracování s návratovou hodnotou chyby: Některé knihovny nebo vlastní funkce mohou vracet n-tici [data, error] místo odmítnutí promise.

async function safelyFetchData() {
   const [data, error] = await safePromise(fetch('https://api.example.com/data'));
   if (error) {
      console.error('Obecná chyba při získávání dat:', error);
      return null; // nebo jiná hodnota indikující selhání
   }
   // Předpokládáme, že safePromise také řeší response.ok
   console.log(data);
   return data;
}

// Příklad implementace safePromise (zjednodušený)
async function safePromise(promise) {
    try {
        const result = await promise;
         // Zde může být kontrola result.ok pro fetch
         if (result && result.ok !== undefined && !result.ok) {
             throw new Error(`HTTP error! status: ${result.status}`);
         }
        // Pro fetch, možná bude třeba počkat i 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" nebo "go-style error handling") je vhodný, když je potřeba zpracovávat chyby lokálně bez přerušení běhu funkce.

Nejčistší a nejčtenější způsob je použití try...catch kolem bloku kódu obsahujícího await.

Jak ošetřit chybu (odmítnutí) promise při použití await?