Jak radzisz sobie w sytuacji, gdy obietnica kończy się błędem (odrzut)?

Obsługuję za pomocą metod .catch() lub .finally().

.catch() służy do obsługi odrzuconych obietnic. Jeśli obietnica zostanie pomyślnie rozwiązana, blok .catch() jest ignorowany.

// Obsługa błędów za pomocą `.catch()`
fetch('/api/data')
  .then(response => {
    if (!response.ok) {
      throw new Error('Request failed'); // Symulacja błędu
    }
    return response.json();
  })
  .then(data => {
    console.log('Odebrane dane:', data);
  })
  .catch(error => {
    console.error('Błąd:', error); // Obsługa błędu tutaj
  });

.finally() jest wykonywane niezależnie od tego, czy obietnica zakończyła się sukcesem (fulfill), czy błędem (reject). Jest przydatne do czyszczenia zasobów lub ukrywania wskaźników ładowania.

// Użycie `.finally()` do wykonania kodu po zakończeniu obietnicy
fetch('/api/data')
  .then(response => {
    if (!response.ok) {
      throw new Error('Request failed');
    }
    return response.json();
  })
  .then(data => {
    console.log('Odebrane dane:', data);
  })
  .catch(error => {
    console.error('Błąd:', error);
  })
  .finally(() => {
    console.log('Zakończono żądanie.'); // Ten kod zawsze się wykona
  });

Mogę także użyć konstrukcji try...catch wewnątrz funkcji async, aby obsłużyć błędy operacji asynchronicznych, w tym obietnic:

// Obsługa błędów w async/await za pomocą try...catch
async function fetchData() {
  try {
    const response = await fetch('/api/data');
    if (!response.ok) {
      throw new Error('Request failed');
    }
    const data = await response.json();
    console.log('Odebrane dane:', data);
  } catch (error) {
    console.error('Błąd:', error); // Obsługa błędu tutaj
  } finally {
    console.log('Zakończono operację fetch.'); // Zawsze się wykona
  }
}

fetchData();

Wybór metody zależy od kontekstu i wymagań logiki obsługi. .catch() jest główną konstrukcją do reagowania na błędy, a .finally() do działań wykonywanych niezależnie od wyniku. try...catch w funkcjach async zapewnia bardziej znany, synchroniczny styl obsługi błędów.