Jak obsłużyć błąd (odrzucenie) obietnicy podczas…

Podczas korzystania z await z obietnicą, błędy (odrzucenia) mogą być obsługiwane na kilka sposobów:

Konstrukcja try...catch: Najczęstszy i zalecany sposób. Pozwala elegancko przechwycić błąd wyrzucony podczas rozwiązywania (resolve) lub odrzucenia (reject) obietnicy.

async function fetchData() {
  try {
    const response = await fetch('https://api.example.com/data');
    if (!response.ok) {
      throw new Error(`Błąd HTTP! status: ${response.status}`);
    }
    const data = await response.json();
    console.log(data);
  } catch (error) {
    console.error('Błąd podczas pobierania danych:', error);
    // Dodatkowe obsługi błędu lub powiadomienie użytkownika
  }
}

fetchData();

Metoda .catch() po await: Mniej preferowana, ale możliwa. Błąd będzie obsłużony w callbacku .catch(), jeśli obietnica zostanie odrzucona.

async function fetchData() {
  const response = await fetch('https://api.example.com/data')
    .catch(error => {
      console.error('Błąd podczas fetch:', error);
      // Obsługa błędu fetch
      throw error; // Ponowne wyrzucenie błędu do dalszej obsługi
    });

  if (response && !response.ok) {
       console.error(`Błąd HTTP! status: ${response.status}`);
       // Obsługa błędu HTTP
  }

  if (response && response.ok) {
      const data = await response.json()
          .catch(error => {
              console.error('Błąd podczas parsowania JSON:', error);
              // Obsługa błędu parsowania JSON
          });
      if (data) {
          console.log(data);
      }
  }
}

fetchData();

To podejście może stać się nieczytelne przy obsłudze wielu potencjalnych punktów awarii.

Obsługa z wartością zwracanego błędu: Niektóre biblioteki lub własne funkcje mogą zwracać krotkę [dane, błąd] zamiast odrzucania obietnicy.

async function safelyFetchData() {
   const [data, error] = await safePromise(fetch('https://api.example.com/data'));
   if (error) {
      console.error('Ogólny błąd podczas pobierania danych:', error);
      return null; // lub inną wartość wskazującą na błąd
   }
   // Zakłada się, że safePromise obsługuje również błędy response.ok
   console.log(data);
   return data;
}

// Przykład implementacji safePromise (uproszczony)
async function safePromise(promise) {
    try {
        const result = await promise;
         // Tu może być sprawdzenie result.ok dla fetch
         if (result && result.ok !== undefined && !result.ok) {
             throw new Error(`Błąd HTTP! status: ${result.status}`);
         }
        // Dla fetch, być może trzeba będzie 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();

Ten wzorzec (często nazywany "error-first callback" lub "go-style error handling") jest przydatny, gdy chcesz obsługiwać błędy lokalnie bez przerywania działania funkcji.

Najczystszy i najbardziej czytelny sposób to użycie try...catch wokół bloku kodu zawierającego await.

Jak obsłużyć błąd (odrzucenie) obietnicy podczas korzystania z await?