Kurs JavaScript i React · Moduł 11: Pobieranie danych i API
Zaawansowana obsługa błędów
W tej lekcji4
W kosmosie rzeczy często nie idą zgodnie z planem: komunikacja może być przerwana, serwery mogą być przeciążone, dane mogą być uszkodzone. Do tej pory każdy błąd kończył się jednym komunikatem w stylu "Coś poszło nie tak". Użytkownik nie wie wtedy, czy ma się zalogować, poczekać, czy sprawdzić Wi-Fi. Dobra obsługa błędów to różnica między udaną misją a katastrofą. W tej lekcji zbudujemy cztery warstwy ochrony: czytelne komunikaty, Error Boundary, powiadomienia toast i ponawianie z rosnącym opóźnieniem.
Try/Catch/Finally - pełen wzorzec
Pierwsza warstwa zamienia kody statusu HTTP na zdania zrozumiałe dla człowieka. Instrukcja switch dobiera komunikat do kodu, a catch odróżnia błędy serwera od błędów sieci. Gdy w ogóle nie ma połączenia, fetch() odrzuca Promise z błędem typu TypeError:
async function fetchWithFullErrorHandling(url) {
try {
// Próba pobrania danych
const response = await fetch(url);
if (!response.ok) {
// Różne komunikaty dla różnych kodów błędów
switch (response.status) {
case 400:
throw new Error('Nieprawidłowe zapytanie');
case 401:
throw new Error('Brak autoryzacji - zaloguj się');
case 403:
throw new Error('Brak dostępu do tego zasobu');
case 404:
throw new Error('Zasób nie został znaleziony');
case 429:
throw new Error('Zbyt wiele zapytań - spróbuj później');
case 500:
throw new Error('Błąd serwera - spróbuj później');
default:
throw new Error(`Nieznany błąd: ${response.status}`);
}
}
return await response.json();
} catch (err) {
// Obsługa błędów sieci (brak internetu, timeout)
if (err instanceof TypeError) {
throw new Error(
'Błąd sieci - sprawdź połączenie z internetem'
);
}
throw err; // Re-throw inne błędy
}
}Nasze własne błędy z switch to zwykłe Error, a nie TypeError, więc catch przepuszcza je dalej bez zmian (throw err). Funkcja nadal zwraca dane albo rzuca błąd, zmieniła się tylko jakość komunikatu.
Komponent ErrorBoundary
Druga warstwa chroni przed błędem, który wysadziłby cały interfejs. Gdy komponent rzuci wyjątek podczas renderowania, React odmontowuje całe drzewo i użytkownik widzi białą stronę. Error Boundary to komponent, który łapie błędy renderowania w swoich dzieciach i pokazuje zapasowy widok. Nawet w React 19 da się go napisać tylko jako komponent klasowy, bo potrzebuje metod cyklu życia static getDerivedStateFromError (ustawia stan błędu) i componentDidCatch (np. loguje błąd):
import React from 'react';
class ErrorBoundary extends React.Component {
constructor(props) {
super(props);
this.state = { hasError: false, error: null };
}
static getDerivedStateFromError(error) {
return { hasError: true, error };
}
componentDidCatch(error, errorInfo) {
console.error('ErrorBoundary złapał błąd:', error);
console.error('Stack:', errorInfo.componentStack);
}
render() {
if (this.state.hasError) {
return (
<div className="error-boundary">
<h2>Coś poszło nie tak</h2>
<p>{this.state.error?.message}</p>
<button onClick={() => this.setState({
hasError: false, error: null
})}>
Spróbuj ponownie
</button>
</div>
);
}
return this.props.children;
}
}
// Użycie:
function App() {
return (
<ErrorBoundary>
<SpaceDashboard />
</ErrorBoundary>
);
}Gdy SpaceDashboard wybuchnie, reszta aplikacji przetrwa, a przycisk czyści stan i próbuje wyrenderować dzieci jeszcze raz. Bardzo ważne ograniczenie z dokumentacji React: Error Boundary nie łapie błędów w obsłudze zdarzeń ani w kodzie asynchronicznym, czyli np. odrzuconego fetch() w useEffect. Takie błędy obsługujesz przez try/catch i stan error. W praktyce polecam gotową paczkę react-error-boundary, żeby nie pisać tej klasy samodzielnie.
Powiadomienia Toast
Trzecia warstwa to komunikaty, które nie zasłaniają treści. Toast to krótki dymek w rogu ekranu, znikający po kilku sekundach. Żeby dowolny komponent mógł go wywołać, udostępniamy funkcję addToast przez Context:
import React, { useState, createContext, useContext } from 'react';
const ToastContext = createContext();
function ToastProvider({ children }) {
const [toasts, setToasts] = useState([]);
const addToast = (message, type = 'error') => {
const id = Date.now();
setToasts(prev => [...prev, { id, message, type }]);
// Auto-usuwanie po 5 sekundach
setTimeout(() => {
setToasts(prev => prev.filter(t => t.id !== id));
}, 5000);
};
return (
<ToastContext.Provider value={{ addToast }}>
{children}
<div className="toast-container">
{toasts.map(toast => (
<div key={toast.id} className={`toast toast-${toast.type}`}>
{toast.message}
</div>
))}
</div>
</ToastContext.Provider>
);
}
function useToast() {
return useContext(ToastContext);
}Provider trzyma listę toastów w stanie, a setTimeout usuwa każdy po 5 sekundach. Hook useToast to tylko skrót do useContext. Teraz dowolny komponent wewnątrz providera może zgłosić sukces albo błąd:
// Użycie w komponencie:
function DataComponent() {
const { addToast } = useToast();
const fetchData = async () => {
try {
const response = await fetch('/api/data');
if (!response.ok) throw new Error('Błąd serwera');
const data = await response.json();
addToast('Dane pobrane pomyślnie!', 'success');
} catch (err) {
addToast(err.message, 'error');
}
};
return <button onClick={fetchData}>Pobierz dane</button>;
}Komponent nie renderuje żadnego komunikatu sam, tylko zgłasza go wyżej. Drobiazg: Date.now() jako id może się powtórzyć przy dwóch toastach w tej samej milisekundzie, więc w produkcji użyj crypto.randomUUID() albo licznika.
Retry z exponential backoff
Czwarta warstwa naprawia błędy chwilowe. Gdy serwer jest przeciążony (429) albo ma awarię (5xx), natychmiastowe ponowienie tylko go dobija. Exponential backoff to czekanie coraz dłużej: 1 s, 2 s, 4 s. Opóźnienie liczymy jako Math.pow(2, attempt) * 1000:
async function fetchWithRetry(url, maxRetries = 3) {
for (let attempt = 0; attempt <= maxRetries; attempt++) {
try {
const response = await fetch(url);
if (response.status === 429 || response.status >= 500) {
// Serwer przeciążony lub błąd serwera
if (attempt < maxRetries) {
// Exponential backoff: 1s, 2s, 4s
const delay = Math.pow(2, attempt) * 1000;
console.log(
`Próba ${attempt + 1} nie powiodła się. \
Ponowna próba za ${delay}ms...`
);
await new Promise(resolve =>
setTimeout(resolve, delay)
);
continue;
}
}
if (!response.ok) {
throw new Error(`HTTP Error: ${response.status}`);
}
return await response.json();
} catch (err) {
if (attempt === maxRetries) {
throw new Error(
`Nie udało się po ${maxRetries + 1} próbach: ${err.message}`
);
}
const delay = Math.pow(2, attempt) * 1000;
await new Promise(resolve => setTimeout(resolve, delay));
}
}
}Przy maxRetries = 3 funkcja próbuje łącznie cztery razy, a po ostatniej porażce rzuca błąd z liczbą prób. Zwróć uwagę, że catch ponawia każdy błąd, także 404, którego ponawianie nic nie da. W prawdziwym projekcie ponawiaj tylko błędy sieci, 429 i 5xx, a TanStack Query z poprzedniej lekcji zrobi to za Ciebie (domyślnie trzy ponowienia z backoffem).
Pamiętaj: dobry komunikat o błędzie mówi załodze, co się stało i co może zrobić dalej, więc nigdy nie zostawiaj jej w ciemności.
Kod do tej lekcji: App.jsx
import React, { useState, createContext, useContext } from 'react';
// Toast Context
const ToastContext = createContext();
function ToastProvider({ children }) {
const [toasts, setToasts] = useState([]);
const addToast = (message, type = 'error') => {
const id = Date.now();
setToasts(prev => [...prev, { id, message, type }]);
setTimeout(() => {
setToasts(prev => prev.filter(t => t.id !== id));
}, 4000);
};
const removeToast = (id) => {
setToasts(prev => prev.filter(t => t.id !== id));
};
return (
<ToastContext.Provider value={{ addToast }}>
{children}
<div className="toast-container">
{toasts.map(toast => (
<div key={toast.id} className={"toast toast-" + toast.type}>
<span>{toast.message}</span>
<button className="toast-close" onClick={() => removeToast(toast.id)}>x</button>
</div>
))}
</div>
</ToastContext.Provider>
);
}
function useToast() {
return useContext(ToastContext);
}
// Symulacja roznych odpowiedzi serwera
function simulateResponse(scenario) {
return new Promise((resolve, reject) => {
setTimeout(() => {
switch (scenario) {
case 'success':
resolve({ ok: true, status: 200, json: () => Promise.resolve({ data: 'Dane pobrane!' }) });
break;
case '404':
resolve({ ok: false, status: 404, statusText: 'Not Found' });
break;
case '500':
resolve({ ok: false, status: 500, statusText: 'Internal Server Error' });
break;
case 'network':
reject(new TypeError('Failed to fetch'));
break;
default:
resolve({ ok: true, status: 200 });
}
}, 1000);
});
}
function ErrorDemo() {
const { addToast } = useToast();
const [loading, setLoading] = useState(false);
const testScenario = async (scenario) => {
setLoading(true);
try {
const response = await simulateResponse(scenario);
if (!response.ok) {
switch (response.status) {
case 400: throw new Error('Nieprawidlowe zapytanie');
case 401: throw new Error('Brak autoryzacji');
case 404: throw new Error('Zasob nie znaleziony');
case 429: throw new Error('Zbyt wiele zapytan');
case 500: throw new Error('Blad serwera');
default: throw new Error(`Blad HTTP: ${response.status}`);
}
}
const data = await response.json();
addToast(data.data, 'success');
} catch (err) {
if (err instanceof TypeError) {
addToast('Blad sieci - sprawdz polaczenie', 'error');
} else {
addToast(err.message, 'error');
}
} finally {
setLoading(false);
}
};
return (
<div className="demo">
<h1>Obsluga Bledow - Demo</h1>
<p>Kliknij przycisk, aby zasymulowac rozne odpowiedzi serwera:</p>
<div className="button-grid">
<button className="btn success" onClick={() => testScenario('success')} disabled={loading}>
200 OK (Sukces)
</button>
<button className="btn warning" onClick={() => testScenario('404')} disabled={loading}>
404 Not Found
</button>
<button className="btn danger" onClick={() => testScenario('500')} disabled={loading}>
500 Server Error
</button>
<button className="btn danger" onClick={() => testScenario('network')} disabled={loading}>
Network Error
</button>
</div>
{loading && <p className="status">Wysylanie zapytania...</p>}
</div>
);
}
function App() {
return (
<ToastProvider>
<ErrorDemo />
</ToastProvider>
);
}
export default App;Hasła z dokumentacji w tej lekcji
Widzisz błąd w tej lekcji?
Sprawdź się
Odpowiedz na pytania z tej lekcji. Wybierz odpowiedź, a od razu zobaczysz, czy jest poprawna.
1. Czym jest Error Boundary w React i kiedy się uruchamia?
Zadania praktyczne w grze
- Układanie w pionie
Ułóż rosnące opóźnienia w strategii exponential backoff (od najkrótszego do najdłuższego):
- Edytor kodu
System Toast
- Klikanie w kolejności
Kliknij elementy w kolejności bloku try/catch/finally:
- Klikanie w kolejności
Ułóż składnię obsługi błędów z async/await:
- Układanie w poziomie
Ułóż składnię warunku sprawdzającego kod statusu HTTP odpowiedzi: