Kurs JavaScript i React · Moduł 16: Obsługa błędów i Suspense

Zaawansowane wzorce Error Handling

6 min czytania ·
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:

WzorzecKiedy używać
Error BoundaryBłędy renderowania komponentów
try/catchEvent handlery i kod synchroniczny
useErrorBoundaryBłędy asynchroniczne w Error Boundary
RetryNiestabilne połączenia sieciowe
Fallback contentOpcjonalne dane
Global handlerNieprzewidziane 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. 1. Która metoda Error Boundary jest najlepsza do logowania błędów do zewnętrznego serwisu?

  2. 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:

  1. PytanieError monitoring w produkcji
  2. Ułóż w kolejnościStrategie recovery od najprostszej do najbardziej złożonej
  3. Zadanie z kodemPraktyka: Error Boundary z limitem retry
  4. Ułóż w kolejnościGlobal error handling - window listeners
  5. PytanieFallback do prostszej wersji
  6. Ułóż w kolejnościKolejność dodawania odporności do aplikacji
  7. Zadanie z kodemPraktyka: Taby z lazy loading
  8. PytanieZastosowanie React.lazy()
  9. Ułóż w kolejnościProgressive Loading - priorytet ładowania
  10. Ułóż w kolejnościresetKeys w react-error-boundary
  11. Zadanie z kodemPraktyka: Mini Resilient Dashboard
  12. Ułóż w kolejnościKompletna architektura odporności

Przydatne artykuły