Kurs JavaScript i React · Moduł 16: Obsługa błędów i Suspense
Zaawansowane wzorce Error Handling
W tej lekcji5
Twoje granice błędów łapią awarie i pokazują fallback, ale zastanów się: skąd dowiesz się, że o trzeciej w nocy tysiąc osób zobaczyło komunikat "Coś poszło nie tak"? Użytkownik nie wyśle Ci konsoli, a Ty nie siedzisz przy każdej przeglądarce. W tej lekcji poznamy zaawansowane techniki obsługi błędów, które możesz zastosować w złożonych aplikacjach React. Te wzorce są jak zaawansowane systemy bezpieczeństwa na stacji kosmicznej - wielowarstwowe, inteligentne i elastyczne.
Error Monitoring i Logging
W produkcji musisz wiedzieć o błędach natychmiast. Zintegruj Error Boundary z systemem monitoringu. Poniższa klasa robi trzy rzeczy: generuje identyfikator awarii, wysyła raport do serwisu (funkcja logErrorToService to Twój klient, na przykład Sentry) i pokazuje użytkownikowi kod, który może podać wsparciu:
class MonitoredErrorBoundary extends React.Component {
constructor(props) {
super(props);
this.state = { hasError: false, error: null, errorId: null };
}
static getDerivedStateFromError(error) {
return { hasError: true, error };
}
componentDidCatch(error, errorInfo) {
// Generuj unikalny ID błędu
const errorId = Date.now().toString(36);
this.setState({ errorId });
// Wyślij do serwisu monitoringu
logErrorToService({
errorId,
message: error.message,
stack: error.stack,
componentStack: errorInfo.componentStack,
timestamp: new Date().toISOString(),
url: window.location.href,
userAgent: navigator.userAgent
});
}
render() {
if (this.state.hasError) {
return (
<div className="error-report">
<h3>Wystąpił błąd</h3>
<p>Kod błędu: {this.state.errorId}</p>
<p>Nasz zespół został powiadomiony.</p>
<button onClick={() => this.setState({ hasError: false })}>
Spróbuj ponownie
</button>
</div>
);
}
return this.props.children;
}
}Raport wysyłamy w componentDidCatch, a nie w getDerivedStateFromError, bo ta druga działa w fazie renderowania i musi być czysta. Date.now().toString(36) to tylko prosty identyfikator oparty na czasie, a dwie awarie w tej samej milisekundzie dostałyby ten sam kod. W produkcji użyj crypto.randomUUID() albo identyfikatora zwróconego przez serwis monitoringu.
Context-aware Error Handling
Różne części aplikacji mogą wymagać różnej obsługi błędów. Awaria systemu podtrzymywania życia to alarm, awaria widżetu pogody to wpis w dzienniku. Kontekst React (createContext i useContext) pozwala przekazać tę politykę całemu poddrzewu bez przekazywania propsów:
import { createContext, useContext } from 'react';
const ErrorContext = createContext({
onError: (error) => console.error(error),
severity: 'normal'
});
function useErrorHandler() {
const { onError, severity } = useContext(ErrorContext);
return (error) => {
if (severity === 'critical') {
// Dla krytycznych sekcji - wyślij alert
sendAlert(error);
}
onError(error);
};
}
// Użycie
function CriticalSection({ children }) {
return (
<ErrorContext.Provider value={{
onError: (err) => sendToMonitoring(err),
severity: 'critical'
}}>
<ErrorBoundary>
{children}
</ErrorBoundary>
</ErrorContext.Provider>
);
}Każdy komponent wewnątrz CriticalSection wywoła useErrorHandler() i dostanie funkcję, która sama wie, czy podnieść alarm. W React 19 możesz też pisać krócej <ErrorContext value={...}>, zapis z .Provider nadal działa.
Error Recovery Strategies
Samo pokazanie błędu to dopiero początek. Poniżej dwie strategie odzyskiwania.
Strategy 1: Automatyczne odświeżanie komponentu
Ta strategia korzysta z ErrorBoundary z biblioteki react-error-boundary i ze sztuczki z propem key. Gdy key się zmienia, React niszczy stary komponent i tworzy nowy, z czystym stanem:
function AutoRecoveryBoundary({ children, maxRetries = 3 }) {
const [retryCount, setRetryCount] = useState(0);
const [key, setKey] = useState(0);
const handleReset = () => {
if (retryCount < maxRetries) {
setRetryCount(prev => prev + 1);
setKey(prev => prev + 1); // Wymusza remount
}
};
return (
<ErrorBoundary
key={key}
FallbackComponent={({ error }) => (
<div>
<p>Błąd: {error.message}</p>
{retryCount < maxRetries ? (
<button onClick={handleReset}>
Spróbuj ponownie ({maxRetries - retryCount} prób pozostało)
</button>
) : (
<p>Nie udało się naprawić błędu. Skontaktuj się z supportem.</p>
)}
</div>
)}
>
{children}
</ErrorBoundary>
);
}Licznik retryCount żyje poza granicą, więc remount go nie zeruje, i dlatego limit prób działa. Wszystko wewnątrz granicy zaczyna od zera.
Strategy 2: Fallback do prostszej wersji
Zamiast komunikatu możesz pokazać uboższą, ale działającą wersję tej samej informacji. Interaktywny wykres zależy od ciężkiej biblioteki, zwykła tabela nie:
function ChartWithFallback({ data }) {
return (
<ErrorBoundary
FallbackComponent={() => (
// Zamiast interaktywnego wykresu, pokaż prostą tabelę
<table>
<thead><tr><th>Nazwa</th><th>Wartość</th></tr></thead>
<tbody>
{data.map(item => (
<tr key={item.id}>
<td>{item.name}</td>
<td>{item.value}</td>
</tr>
))}
</tbody>
</table>
)}
>
<InteractiveChart data={data} />
</ErrorBoundary>
);
}Dane są te same, zmienia się tylko sposób ich pokazania. Załoga dalej widzi odczyty, choć bez animacji.
Global Error Handling
Przechwytuj nieobsłużone błędy na poziomie globalnym. Zdarzenie error na window łapie wyjątki, których nikt nie złapał, na przykład z handlerów i timerów, a unhandledrejection łapie odrzucone obietnice bez .catch():
// W głównym komponencie aplikacji (np. App)
useEffect(() => {
const handleUnhandledError = (event) => {
console.error('Unhandled error:', event.error);
// Wyślij do monitoringu
};
const handleUnhandledRejection = (event) => {
console.error('Unhandled promise rejection:', event.reason);
// Wyślij do monitoringu
};
window.addEventListener('error', handleUnhandledError);
window.addEventListener('unhandledrejection', handleUnhandledRejection);
return () => {
window.removeEventListener('error', handleUnhandledError);
window.removeEventListener('unhandledrejection', handleUnhandledRejection);
};
}, []);Funkcja sprzątająca zdejmuje oba nasłuchiwacze przy odmontowaniu, więc nie dublują się. Pamiętaj, że według react.dev w trybie deweloperskim błędy złapane przez componentDidCatch też docierają do window, a w produkcji już nie, więc w dev zobaczysz niektóre błędy dwa razy.
React 19 dodał do tego drugą warstwę: opcje onCaughtError i onUncaughtError funkcji createRoot. Pierwsza dostaje błędy złapane przez dowolną granicę, druga te, których nie złapała żadna:
import { createRoot } from 'react-dom/client';
const root = createRoot(document.getElementById('root'), {
onCaughtError: (error, errorInfo) => {
// Błąd złapany przez Error Boundary
reportToMonitoring('caught', error, errorInfo.componentStack);
},
onUncaughtError: (error, errorInfo) => {
// Błąd, którego nie złapała żadna granica
reportToMonitoring('uncaught', error, errorInfo.componentStack);
}
});
root.render(<App />);Oba callbacki dostają componentStack, więc masz jedno centralne miejsce na raportowanie wszystkich błędów renderowania. Domyślnie React po prostu loguje je do konsoli.
Podsumowanie wzorców
Zbierzmy wszystkie warstwy osłon w jednej tabeli:
| Wzorzec | Kiedy używać |
|---|---|
| Error Boundary | Błędy renderowania komponentów |
| try/catch | Event handlery i kod synchroniczny |
| useErrorBoundary | Błędy asynchroniczne w Error Boundary |
| Retry | Niestabilne połączenia sieciowe |
| Fallback content | Opcjonalne dane |
| Global handler | Nieprzewidziane błędy |
Moja rada: w nowym projekcie React 19 zacznij od onCaughtError i onUncaughtError w createRoot, bo to najtańszy sposób, żeby żaden błąd renderowania nie przeszedł niezauważony. W projekcie głównym tej lokacji połączysz wszystkie te wzorce w jeden odporny pulpit misji.
Pamiętaj: dobra stacja nie tylko przetrwa awarię, ale też od razu zgłasza ją do centrum kontroli misji.
Kod do tej lekcji: App.jsx
import React, { useState, useEffect, createContext, useContext } from 'react';
import './styles.css';
// Error Logging Context
const ErrorLogContext = createContext({ logs: [], addLog: () => {} });
function useErrorLog() {
return useContext(ErrorLogContext);
}
// Monitored Error Boundary
class MonitoredBoundary extends React.Component {
constructor(props) {
super(props);
this.state = { hasError: false, error: null, retries: 0 };
}
static getDerivedStateFromError(error) {
return { hasError: true, error };
}
componentDidCatch(error, info) {
const log = {
id: Date.now(),
section: this.props.section || 'unknown',
message: error.message,
time: new Date().toLocaleTimeString(),
};
if (this.props.onLogError) {
this.props.onLogError(log);
}
}
handleRetry = () => {
if (this.state.retries < (this.props.maxRetries || 3)) {
this.setState(s => ({
hasError: false,
error: null,
retries: s.retries + 1,
}));
}
};
render() {
if (this.state.hasError) {
const remaining = (this.props.maxRetries || 3) - this.state.retries;
return (
<div className="monitored-error">
<h4>{this.props.section} - Awaria</h4>
<p>{this.state.error.message}</p>
{remaining > 0 ? (
<button onClick={this.handleRetry} className="retry-btn">
Ponow ({remaining} prob)
</button>
) : (
<p className="no-retry">Brak prob - zglos blad</p>
)}
</div>
);
}
return this.props.children;
}
}
function UnstableWidget({ name, fail = 0.5 }) {
if (Math.random() < fail) {
throw new Error(name + ': system failure');
}
return (
<div className="widget-ok">
<span className="dot" /> {name}: Online
</div>
);
}
// Error Log Panel
function ErrorLogPanel({ logs }) {
if (logs.length === 0) return (
<div className="log-panel">
<h3>Dziennik bledow</h3>
<p className="empty">Brak zarejestrowanych bledow</p>
</div>
);
return (
<div className="log-panel">
<h3>Dziennik bledow ({logs.length})</h3>
{logs.map(log => (
<div key={log.id} className="log-entry">
<span className="log-time">{log.time}</span>
<span className="log-section">[{log.section}]</span>
<span className="log-msg">{log.message}</span>
</div>
))}
</div>
);
}
export default function App() {
const [key, setKey] = useState(0);
const [logs, setLogs] = useState([]);
const addLog = (log) => {
setLogs(prev => [log, ...prev].slice(0, 10));
};
return (
<div className="app">
<h1>Error Monitoring</h1>
<button onClick={() => setKey(k => k + 1)} className="reset-btn">
Restart systemow
</button>
<div className="grid" key={key}>
<MonitoredBoundary section="Silniki" maxRetries={3} onLogError={addLog}>
<UnstableWidget name="Silniki" fail={0.5} />
</MonitoredBoundary>
<MonitoredBoundary section="Nawigacja" maxRetries={3} onLogError={addLog}>
<UnstableWidget name="Nawigacja" fail={0.5} />
</MonitoredBoundary>
<MonitoredBoundary section="Lacznosc" maxRetries={3} onLogError={addLog}>
<UnstableWidget name="Lacznosc" fail={0.5} />
</MonitoredBoundary>
<MonitoredBoundary section="Sensory" maxRetries={3} onLogError={addLog}>
<UnstableWidget name="Sensory" fail={0.5} />
</MonitoredBoundary>
</div>
<ErrorLogPanel logs={logs} />
</div>
);
}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. Która metoda Error Boundary jest najlepsza do logowania błędów do zewnętrznego serwisu?
2. Na czym polega strategia 'fallback do prostszej wersji komponentu'?
To 2 z 3 pytań do tej lekcji. Pozostałe rozwiążesz w grze.
Zadania praktyczne w grze
- Układanie w pionie
Uporządkuj strategie naprawy błędów od najprostszej do najbardziej złożonej:
- Edytor kodu
Zaimplementuj RetryErrorBoundary z maxRetries
- Układanie w poziomie
Ułóż składnię dodania globalnego handlera błędów:
- Układanie w pionie
Uporządkuj kroki budowania resilient aplikacji:
- Edytor kodu
Zaimplementuj taby z lazy loading
- Układanie w pionie
Uporządkuj elementy strony według priorytetu ładowania (od najwyższego):
- Układanie w poziomie
Ułóż składnię ErrorBoundary z resetKeys:
- Edytor kodu
Zbuduj mini resilient dashboard
- Układanie w pionie
Uporządkuj warstwy odporności od zewnętrznej do wewnętrznej:
Zadania po tej lekcji
- PytanieError monitoring w produkcji
- Ułóż w kolejnościStrategie recovery od najprostszej do najbardziej złożonej
- Zadanie z kodemPraktyka: Error Boundary z limitem retry
- Ułóż w kolejnościGlobal error handling - window listeners
- PytanieFallback do prostszej wersji
- Ułóż w kolejnościKolejność dodawania odporności do aplikacji
- Zadanie z kodemPraktyka: Taby z lazy loading
- PytanieZastosowanie React.lazy()
- Ułóż w kolejnościProgressive Loading - priorytet ładowania
- Ułóż w kolejnościresetKeys w react-error-boundary
- Zadanie z kodemPraktyka: Mini Resilient Dashboard
- Ułóż w kolejnościKompletna architektura odporności