Kurs JavaScript i React · Moduł 5: useEffect i własne hooki

Obsługa API i pobieranie danych

15 min czytania ·
W tej lekcji6

Komunikacja z zewnętrznymi API jest jednym z najczęstszych przypadków użycia efektów ubocznych w aplikacjach React. W tym module nauczymy się, jak efektywnie pobierać, przetwarzać i zarządzać danymi z zewnętrznych źródeł.

Podstawy pobierania danych z API

W aplikacjach webowych, dane często pochodzą z zewnętrznych API, które dostarczają informacje w formacie JSON, XML lub innych. W naszej kosmicznej podróży, możemy wyobrazić sobie centrum kontroli misji pobierające dane z różnych satelitów, statków kosmicznych i stacji badawczych.

Prosty przykład pobierania danych z useEffect

import React, { useState, useEffect } from 'react';

function AstronautsList() {
  const [astronauts, setAstronauts] = useState([]);
  const [loading, setLoading] = useState(true);
  const [error, setError] = useState(null);

  useEffect(() => {
    // Funkcja asynchroniczna do pobierania danych
    async function fetchAstronauts() {
      try {
        setLoading(true);
        // Pobieranie danych
        const response = await fetch('https://api.spaceagency.com/astronauts');

        // Sprawdzenie czy odpowiedź jest OK
        if (!response.ok) {
          throw new Error(`HTTP Error: ${response.status}`);
        }

        // Parsowanie odpowiedzi JSON
        const data = await response.json();

        // Aktualizacja stanu
        setAstronauts(data);
        setError(null);
      } catch (err) {
        // Obsługa błędów
        setError(`Nie udało się pobrać danych: ${err.message}`);
        setAstronauts([]);
      } finally {
        // Oznaczenie zakończenia ładowania
        setLoading(false);
      }
    }

    // Wywołanie funkcji
    fetchAstronauts();
  }, []); // Pusta tablica zależności - wykonaj tylko raz

  // Renderowanie na podstawie stanu
  if (loading) return <div>Ładowanie danych...</div>;
  if (error) return <div>Błąd: {error}</div>;

  return (
    <div>
      <h2>Aktywni astronauci</h2>
      <ul>
        {astronauts.map(astronaut => (
          <li key={astronaut.id}>
            {astronaut.name} - {astronaut.role}
          </li>
        ))}
      </ul>
    </div>
  );
}

W powyższym przykładzie:

  1. Używamy useState do przechowywania danych, stanu ładowania i błędów
  2. Używamy useEffect z pustą tablicą zależności, aby pobrać dane tylko raz po zamontowaniu komponentu
  3. Wykorzystujemy async/await do obsługi asynchronicznego pobierania danych
  4. Obsługujemy różne stany (ładowanie, błąd, sukces) w interfejsie użytkownika

Zaawansowane techniki pobierania danych

1. Pobieranie danych z parametrami

Często musimy pobierać dane na podstawie parametrów, które mogą się zmieniać:

function MissionDetails({ missionId }) {
  const [mission, setMission] = useState(null);
  const [loading, setLoading] = useState(true);
  const [error, setError] = useState(null);

  useEffect(() => {
    let isMounted = true; // Flaga do zapobiegania aktualizacji stanu po odmontowaniu

    async function fetchMission() {
      try {
        setLoading(true);

        const response = await fetch(
          `https://api.spaceagency.com/missions/${missionId}`
        );

        if (!response.ok) {
          throw new Error(`HTTP Error: ${response.status}`);
        }

        const data = await response.json();

        // Aktualizuj stan tylko jeśli komponent jest nadal zamontowany
        if (isMounted) {
          setMission(data);
          setError(null);
        }
      } catch (err) {
        if (isMounted) {
          setError(`Nie udało się pobrać danych misji: ${err.message}`);
          setMission(null);
        }
      } finally {
        if (isMounted) {
          setLoading(false);
        }
      }
    }

    fetchMission();

    // Funkcja czyszcząca
    return () => {
      isMounted = false; // Oznacz, że komponent został odmontowany
    };
  }, [missionId]); // Pobierz dane ponownie, gdy zmieni się missionId

  // Renderowanie
  if (loading) return <div>Ładowanie danych misji...</div>;
  if (error) return <div>Błąd: {error}</div>;
  if (!mission) return <div>Nie znaleziono misji</div>;

  return (
    <div className="mission-details">
      <h2>{mission.name}</h2>
      <p>Status: {mission.status}</p>
      <p>Data startu: {new Date(mission.launchDate).toLocaleDateString()}</p>
      <p>Dowódca: {mission.commander}</p>
      {/* Więcej szczegółów misji */}
    </div>
  );
}

W tym przykładzie:

  1. Pobieramy dane na podstawie missionId, które może się zmieniać
  2. Używamy flagi isMounted do zapobiegania aktualizacji stanu po odmontowaniu komponentu
  3. Dodajemy funkcję czyszczącą, która ustawia isMounted = false przy odmontowaniu

2. Anulowanie żądań fetch

API Fetch nie ma wbudowanego mechanizmu anulowania, ale możemy użyć AbortController, aby przerwać żądanie:

function SpaceWeather({ location }) {
  const [weatherData, setWeatherData] = useState(null);
  const [loading, setLoading] = useState(true);
  const [error, setError] = useState(null);

  useEffect(() => {
    // Utwórz AbortController do anulowania żądania
    const abortController = new AbortController();
    const signal = abortController.signal;

    async function fetchWeatherData() {
      try {
        setLoading(true);

        const response = await fetch(
          `https://api.spaceagency.com/weather/${location}`,
          { signal } // Przypisanie sygnału do żądania
        );

        if (!response.ok) {
          throw new Error(`HTTP Error: ${response.status}`);
        }

        const data = await response.json();
        setWeatherData(data);
        setError(null);
      } catch (err) {
        // Ignoruj błędy związane z anulowaniem
        if (err.name === 'AbortError') {
          console.log('Żądanie pogody zostało anulowane');
        } else {
          setError(`Nie udało się pobrać danych pogodowych: ${err.message}`);
          setWeatherData(null);
        }
      } finally {
        setLoading(false);
      }
    }

    fetchWeatherData();

    // Funkcja czyszcząca anuluje żądanie, jeśli komponent
    // zostanie odmontowany przed zakończeniem pobierania
    return () => {
      abortController.abort();
    };
  }, [location]);

  // Renderowanie
  if (loading) return <div>Ładowanie danych pogodowych...</div>;
  if (error) return <div>Błąd: {error}</div>;
  if (!weatherData) return <div>Brak danych pogodowych</div>;

  return (
    <div className="space-weather">
      <h2>Pogoda kosmiczna: {location}</h2>
      <p>Promieniowanie: {weatherData.radiation} mSv</p>
      <p>Aktywność słoneczna: {weatherData.solarActivity}</p>
      <p>Temperatura: {weatherData.temperature}°C</p>
    </div>
  );
}

W tym przykładzie:

  1. Używamy AbortController do tworzenia sygnału, który może przerwać żądanie Fetch
  2. Przekazujemy sygnał do opcji żądania Fetch
  3. W funkcji czyszczącej wywołujemy abortController.abort(), aby anulować trwające żądanie
  4. Obsługujemy specjalnie błąd AbortError, który jest rzucany, gdy żądanie zostało anulowane

3. Obsługa wielu równoczesnych zapytań

Czasami potrzebujemy pobrać dane z kilku źródeł jednocześnie:

function MissionDashboard({ missionId }) {
  const [missionData, setMissionData] = useState({
    details: null,
    crew: [],
    telemetry: null
  });
  const [loading, setLoading] = useState(true);
  const [error, setError] = useState(null);

  useEffect(() => {
    let isMounted = true;

    async function fetchMissionData() {
      try {
        setLoading(true);

        // Pobieranie danych równolegle za pomocą Promise.all
        const [detailsResponse, crewResponse, telemetryResponse] = await Promise.all([
          fetch(`https://api.spaceagency.com/missions/${missionId}`),
          fetch(`https://api.spaceagency.com/missions/${missionId}/crew`),
          fetch(`https://api.spaceagency.com/missions/${missionId}/telemetry`)
        ]);

        // Sprawdzenie odpowiedzi
        if (!detailsResponse.ok || !crewResponse.ok || !telemetryResponse.ok) {
          throw new Error('Jedno lub więcej żądań zakończyło się błędem');
        }

        // Parsowanie danych równolegle
        const [details, crew, telemetry] = await Promise.all([
          detailsResponse.json(),
          crewResponse.json(),
          telemetryResponse.json()
        ]);

        if (isMounted) {
          setMissionData({ details, crew, telemetry });
          setError(null);
        }
      } catch (err) {
        if (isMounted) {
          setError(`Nie udało się pobrać danych misji: ${err.message}`);
        }
      } finally {
        if (isMounted) {
          setLoading(false);
        }
      }
    }

    fetchMissionData();

    return () => {
      isMounted = false;
    };
  }, [missionId]);

  // Renderowanie
  if (loading) return <div>Ładowanie danych misji...</div>;
  if (error) return <div>Błąd: {error}</div>;

  const { details, crew, telemetry } = missionData;

  return (
    <div className="mission-dashboard">
      <h1>{details.name} - Panel kontrolny</h1>

      <section className="mission-details">
        <h2>Szczegóły misji</h2>
        <p>Status: {details.status}</p>
        <p>Cel: {details.objective}</p>
      </section>

      <section className="crew-info">
        <h2>Załoga</h2>
        <ul>
          {crew.map(member => (
            <li key={member.id}>
              {member.name} - {member.role}
            </li>
          ))}
        </ul>
      </section>

      <section className="telemetry-data">
        <h2>Telemetria</h2>
        <p>Tlen: {telemetry.oxygen}%</p>
        <p>Paliwo: {telemetry.fuel}%</p>
        <p>Prędkość: {telemetry.velocity} km/h</p>
      </section>
    </div>
  );
}

W tym przykładzie:

  1. Używamy Promise.all() do równoległego wykonywania wielu żądań
  2. Gromadzimy wszystkie dane w jednym stanie missionData
  3. Obsługujemy wszystkie dane w jednym komponencie

Dobre praktyki i wzorce

1. Wyodrębnianie logiki pobierania danych

Aby poprawić czytelność i utrzymanie kodu, warto wyodrębnić logikę pobierania danych poza komponent:

// api.js - Serwisy API
const API_BASE_URL = 'https://api.spaceagency.com';

export async function fetchAstronauts() {
  const response = await fetch(`${API_BASE_URL}/astronauts`);
  if (!response.ok) {
    throw new Error(`HTTP Error: ${response.status}`);
  }
  return response.json();
}

export async function fetchMission(missionId) {
  const response = await fetch(`${API_BASE_URL}/missions/${missionId}`);
  if (!response.ok) {
    throw new Error(`HTTP Error: ${response.status}`);
  }
  return response.json();
}

// Komponent z wyodrębnioną logiką API
function AstronautsList() {
  const [astronauts, setAstronauts] = useState([]);
  const [loading, setLoading] = useState(true);
  const [error, setError] = useState(null);

  useEffect(() => {
    let isMounted = true;

    async function getAstronauts() {
      try {
        setLoading(true);
        const data = await fetchAstronauts();

        if (isMounted) {
          setAstronauts(data);
          setError(null);
        }
      } catch (err) {
        if (isMounted) {
          setError(`Nie udało się pobrać danych: ${err.message}`);
          setAstronauts([]);
        }
      } finally {
        if (isMounted) {
          setLoading(false);
        }
      }
    }

    getAstronauts();

    return () => {
      isMounted = false;
    };
  }, []);

  // Renderowanie
  //
}

2. Tworzenie własnych hooków do pobierania danych

Dla powtarzalnych operacji pobierania danych, najlepszym rozwiązaniem jest stworzenie własnego hooka:

// useFetch.js - Własny hook do pobierania danych
function useFetch(url, options = {}) {
  const [data, setData] = useState(null);
  const [loading, setLoading] = useState(true);
  const [error, setError] = useState(null);

  useEffect(() => {
    let isMounted = true;
    const abortController = new AbortController();
    const signal = abortController.signal;

    async function fetchData() {
      try {
        setLoading(true);

        const response = await fetch(url, {
          ...options,
          signal,
        });

        if (!response.ok) {
          throw new Error(`HTTP Error: ${response.status}`);
        }

        const result = await response.json();

        if (isMounted) {
          setData(result);
          setError(null);
        }
      } catch (err) {
        if (err.name !== 'AbortError' && isMounted) {
          setError(`Nie udało się pobrać danych: ${err.message}`);
          setData(null);
        }
      } finally {
        if (isMounted) {
          setLoading(false);
        }
      }
    }

    fetchData();

    return () => {
      isMounted = false;
      abortController.abort();
    };
  }, [url, JSON.stringify(options)]);

  return { data, loading, error };
}

// Użycie własnego hooka
function PlanetInfo({ planetId }) {
  const { data: planet, loading, error } = useFetch(
    `https://api.spaceagency.com/planets/${planetId}`
  );

  if (loading) return <div>Ładowanie...</div>;
  if (error) return <div>Błąd: {error}</div>;
  if (!planet) return <div>Nie znaleziono planety</div>;

  return (
    <div className="planet-card">
      <h2>{planet.name}</h2>
      <p>Typ: {planet.type}</p>
      <p>Średnica: {planet.diameter} km</p>
      <p>Odległość od Słońca: {planet.distanceFromSun} mln km</p>
    </div>
  );
}

3. Bardziej zaawansowany hook do pobierania danych z pamięcią podręczną i mechanizmem ponownych prób

// useDataFetching.js
function useDataFetching(fetchFn, dependencies = [], options = {}) {
  const {
    initialData = null,
    cacheKey = null,
    maxRetries = 3,
    retryDelay = 1000,
  } = options;

  const [data, setData] = useState(initialData);
  const [loading, setLoading] = useState(true);
  const [error, setError] = useState(null);

  // Użycie useRef do śledzenia prób
  const retriesRef = useRef(0);

  // Sprawdzenie cache przy pierwszym renderowaniu
  useEffect(() => {
    if (cacheKey) {
      const cachedData = localStorage.getItem(cacheKey);
      if (cachedData) {
        try {
          setData(JSON.parse(cachedData));
          setLoading(false);
        } catch (e) {
          console.error('Błąd parsowania danych z cache:', e);
        }
      }
    }
  }, [cacheKey]);

  // Główna logika pobierania danych
  useEffect(() => {
    let isMounted = true;
    const abortController = new AbortController();

    async function fetchData() {
      try {
        setLoading(true);

        const result = await fetchFn(abortController.signal);

        if (isMounted) {
          setData(result);
          setError(null);

          // Zapisanie do cache, jeśli dostępne
          if (cacheKey) {
            localStorage.setItem(cacheKey, JSON.stringify(result));
          }

          // Zresetuj licznik prób
          retriesRef.current = 0;
        }
      } catch (err) {
        if (!isMounted) return;

        if (err.name === 'AbortError') {
          console.log('Żądanie anulowane');
          return;
        }

        // Logika ponownych prób
        if (retriesRef.current < maxRetries) {
          console.log(`Próba ${retriesRef.current + 1} z ${maxRetries} nie powiodła się. Ponowienie za ${retryDelay}ms`);

          setTimeout(() => {
            if (isMounted) {
              retriesRef.current += 1;
              fetchData(); // Ponowna próba
            }
          }, retryDelay * Math.pow(2, retriesRef.current)); // Wykładniczy backoff

          return;
        }

        // Po wyczerpaniu wszystkich prób
        setError(`Nie udało się pobrać danych: ${err.message}`);
        setData(initialData);
      } finally {
        if (isMounted) {
          setLoading(false);
        }
      }
    }

    fetchData();

    return () => {
      isMounted = false;
      abortController.abort();
    };
  }, [...dependencies]);

  // Funkcja do ręcznego odświeżania danych
  const refetch = useCallback(async () => {
    setLoading(true);
    retriesRef.current = 0;

    try {
      const abortController = new AbortController();
      const result = await fetchFn(abortController.signal);
      setData(result);
      setError(null);

      if (cacheKey) {
        localStorage.setItem(cacheKey, JSON.stringify(result));
      }
    } catch (err) {
      setError(`Nie udało się odświeżyć danych: ${err.message}`);
    } finally {
      setLoading(false);
    }
  }, [fetchFn, cacheKey]);

  return { data, loading, error, refetch };
}

// Przykład użycia
function MarsMissions() {
  // Funkcja do pobrania danych
  const fetchMissions = useCallback(async (signal) => {
    const response = await fetch('https://api.spaceagency.com/mars/missions', { signal });
    if (!response.ok) throw new Error(`HTTP Error: ${response.status}`);
    return response.json();
  }, []);

  // Użycie zaawansowanego hooka
  const {
    data: missions,
    loading,
    error,
    refetch
  } = useDataFetching(fetchMissions, [], {
    initialData: [],
    cacheKey: 'mars-missions-cache',
    maxRetries: 2
  });

  return (
    <div className="mars-missions">
      <div className="header">
        <h2>Misje na Marsa</h2>
        <button onClick={refetch} disabled={loading}>
          {loading ? 'Odświeżanie...' : 'Odśwież'}
        </button>
      </div>

      {loading && missions.length === 0 && <div>Ładowanie misji...</div>}
      {error && <div className="error">Błąd: {error}</div>}

      <ul className="missions-list">
        {missions.map(mission => (
          <li key={mission.id} className={`mission-item ${mission.status}`}>
            <h3>{mission.name}</h3>
            <p>Start: {new Date(mission.launchDate).toLocaleDateString()}</p>
            <p>Status: {mission.status}</p>
          </li>
        ))}
      </ul>

      {missions.length === 0 && !loading && !error && (
        <p>Nie znaleziono żadnych misji.</p>
      )}
    </div>
  );
}

W tym zaawansowanym przykładzie:

  1. Używamy własnego hooka useDataFetching z obsługą ponownych prób, pamięcią podręczną i funkcją ręcznego odświeżania
  2. Implementujemy wykładniczy backoff przy ponawianiu prób (każda kolejna próba czeka dłużej)
  3. Wykorzystujemy parametry, aby dostosować zachowanie hooka do różnych przypadków użycia
  4. Obsługujemy zarówno początkowe ładowanie, jak i ręczne odświeżanie danych

Obsługa błędów przy pobieraniu danych

Poza podstawową obsługą błędów w komponentach, warto zaimplementować bardziej zaawansowane techniki:

1. Komponent granicy błędów (Error Boundary)

Granice błędów pozwalają na elegancką obsługę nieoczekiwanych błędów:

// ErrorBoundary.js
class ErrorBoundary extends React.Component {
  constructor(props) {
    super(props);
    this.state = { hasError: false, error: null, errorInfo: null };
  }

  static getDerivedStateFromError(error) {
    // Aktualizacja stanu, aby następny render pokazał UI awaryjne
    return { hasError: true };
  }

  componentDidCatch(error, errorInfo) {
    // Możesz też zalogować błąd do serwisu monitoringu
    console.error('Przechwycono błąd:', error, errorInfo);
    this.setState({ error, errorInfo });

    // Wysyłanie błędu do serwisu raportowania
    // logErrorToService(error, errorInfo);
  }

  render() {
    if (this.state.hasError) {
      // Możesz wyrenderować dowolny UI awaryjny
      return (
        <div className="error-boundary">
          <h2>Coś poszło nie tak!</h2>
          <p>Wystąpił błąd podczas renderowania komponentu.</p>
          <details>
            <summary>Szczegóły błędu</summary>
            <p>{this.state.error && this.state.error.toString()}</p>
            <p>Komponenty: {this.state.errorInfo && this.state.errorInfo.componentStack}</p>
          </details>
          <button onClick={() => this.setState({ hasError: false })}>
            Spróbuj ponownie
          </button>
        </div>
      );
    }

    return this.props.children;
  }
}

// Użycie error boundary dla komponentu
function App() {
  return (
    <div className="app">
      <header>Centrum kontroli misji</header>

      <ErrorBoundary>
        <MissionDashboard missionId="mars-2030" />
      </ErrorBoundary>

      <ErrorBoundary>
        <AstronautsList />
      </ErrorBoundary>

      <footer>Space Agency © 2023</footer>
    </div>
  );
}

2. Strategie ponownych prób

Gdy API jest niestabilne, warto implementować strategie automatycznych ponownych prób:

async function fetchWithRetry(url, options = {}, maxRetries = 3, delay = 1000) {
  let retries = 0;

  while (retries < maxRetries) {
    try {
      const response = await fetch(url, options);

      if (!response.ok) {
        throw new Error(`HTTP Error: ${response.status}`);
      }

      return await response.json();
    } catch (err) {
      retries++;

      if (retries >= maxRetries) {
        throw err; // Wszystkie próby nieudane, przekaż błąd dalej
      }

      console.log(`Próba ${retries} z ${maxRetries} nieudana. Ponowienie za ${delay}ms`);

      // Odczekaj przed kolejną próbą (wykładniczy backoff)
      await new Promise(resolve => setTimeout(resolve, delay * Math.pow(2, retries - 1)));
    }
  }
}

3. Obsługa problemów z połączeniem

Warto również obsługiwać problemy z połączeniem internetowym:

// Hook do monitorowania stanu połączenia
function useOnlineStatus() {
  const [isOnline, setIsOnline] = useState(navigator.onLine);

  useEffect(() => {
    function handleOnline() {
      setIsOnline(true);
    }

    function handleOffline() {
      setIsOnline(false);
    }

    window.addEventListener('online', handleOnline);
    window.addEventListener('offline', handleOffline);

    return () => {
      window.removeEventListener('online', handleOnline);
      window.removeEventListener('offline', handleOffline);
    };
  }, []);

  return isOnline;
}

// Użycie w komponencie
function DataFetchingComponent() {
  const isOnline = useOnlineStatus();
  const { data, loading, error, refetch } = useFetch('https://api.example.com/data');

  if (!isOnline) {
    return (
      <div className="offline-message">
        <h3>Brak połączenia z internetem</h3>
        <p>Sprawdź połączenie i spróbuj ponownie.</p>
      </div>
    );
  }

  if (loading) return <div>Ładowanie...</div>;
  if (error) return <div>Błąd: {error}</div>;

  return (
    <div>
      <h2>Dane</h2>
      {/* Renderowanie danych */}
    </div>
  );
}

Symulacja API podczas developmentu

Podczas opracowywania aplikacji, rzeczywiste API może być niedostępne lub niegotowe. W takim przypadku warto zasymulować API:

1. Prosta symulacja z opóźnieniem

// mockApi.js
const DELAY = 1000; // Symulacja opóźnienia sieci

export function mockFetch(data, shouldFail = false, failureRate = 0) {
  return new Promise((resolve, reject) => {
    setTimeout(() => {
      // Symulacja losowego błędu
      if (shouldFail || Math.random() < failureRate) {
        reject(new Error('Symulowany błąd API'));
        return;
      }

      resolve(data);
    }, DELAY);
  });
}

// Przykładowe dane
const MOCK_ASTRONAUTS = [
  { id: 1, name: 'Jan Kowalski', role: 'Dowódca' },
  { id: 2, name: 'Anna Nowak', role: 'Pilot' },
  { id: 3, name: 'Piotr Wiśniewski', role: 'Inżynier pokładowy' }
];

export function getAstronauts() {
  return mockFetch(MOCK_ASTRONAUTS, false, 0.2);
}

2. Bardziej rozbudowana symulacja z MSW (Mock Service Worker)

MSW to biblioteka, która pozwala symulować żądania API na poziomie przeglądarki:

// mockServiceWorker.js
import { setupWorker, rest } from 'msw';

// Dane do symulacji
const astronauts = [
  { id: 1, name: 'Jan Kowalski', role: 'Dowódca' },
  { id: 2, name: 'Anna Nowak', role: 'Pilot' },
  { id: 3, name: 'Piotr Wiśniewski', role: 'Inżynier pokładowy' }
];

const missions = [
  {
    id: 'mars-2030',
    name: 'Mars 2030',
    status: 'Planowana',
    launchDate: '2030-05-15',
    commander: 'Jan Kowalski'
  },
  {
    id: 'iss-2023',
    name: 'ISS Expedition 70',
    status: 'W trakcie',
    launchDate: '2023-09-01',
    commander: 'Anna Nowak'
  }
];

// Definiowanie handlerów
export const handlers = [
  // Pobieranie wszystkich astronautów
  rest.get('https://api.spaceagency.com/astronauts', (req, res, ctx) => {
    return res(
      ctx.delay(1000),
      ctx.status(200),
      ctx.json(astronauts)
    );
  }),

  // Pobieranie astronauty po ID
  rest.get('https://api.spaceagency.com/astronauts/:id', (req, res, ctx) => {
    const { id } = req.params;
    const astronaut = astronauts.find(a => a.id === parseInt(id));

    if (!astronaut) {
      return res(
        ctx.delay(500),
        ctx.status(404),
        ctx.json({ error: 'Astronauta nie znaleziony' })
      );
    }

    return res(
      ctx.delay(500),
      ctx.status(200),
      ctx.json(astronaut)
    );
  }),

  // Pobieranie misji
  rest.get('https://api.spaceagency.com/missions', (req, res, ctx) => {
    return res(
      ctx.delay(800),
      ctx.status(200),
      ctx.json(missions)
    );
  }),

  // Pobieranie misji po ID
  rest.get('https://api.spaceagency.com/missions/:id', (req, res, ctx) => {
    const { id } = req.params;
    const mission = missions.find(m => m.id === id);

    if (!mission) {
      return res(
        ctx.delay(500),
        ctx.status(404),
        ctx.json({ error: 'Misja nie znaleziona' })
      );
    }

    return res(
      ctx.delay(700),
      ctx.status(200),
      ctx.json(mission)
    );
  })
];

// Inicjalizacja service workera
export const worker = setupWorker(...handlers);

Następnie w pliku wejściowym aplikacji (np. index.js):

// index.js
import React from 'react';
import { createRoot } from 'react-dom/client';
import App from './App';

// Warunkowo inicjalizuj mock API tylko w środowisku deweloperskim
if (process.env.NODE_ENV === 'development') {
  const { worker } = require('./mockServiceWorker');
  worker.start();
}

const root = createRoot(document.getElementById('root'));
root.render(<App />);

Podsumowanie

Pobieranie danych z API jest fundamentalną częścią większości aplikacji React. Klucz do sukcesu to:

  1. Organizacja kodu - wydzielenie logiki API od komponentów
  2. Własne hooki - tworzenie abstrakcji dla powtarzających się operacji pobierania danych
  3. Obsługa wszystkich stanów - ładowanie, sukces, błąd, offline
  4. Czyszczenie zasobów - anulowanie żądań, zapobieganie aktualizacji stanu po odmontowaniu
  5. Strategie retry - automatyczne ponawianie nieudanych żądań
  6. Testowanie - symulacja API podczas developmentu i testów

Pamiętaj, że dobra obsługa pobierania danych znacząco wpływa na odczucia użytkownika. Nawet jeśli API jest wolne, odpowiednio zaprojektowany interfejs z informacjami o stanie ładowania, animacjami i obsługą błędów może sprawić, że aplikacja będzie wydawać się szybsza i bardziej niezawodna.

Kod do tej lekcji: App.jsx
import React, { useState, useEffect } from 'react';

// Custom hook do pobierania danych
function useFetch(url, options = {}) {
  const [data, setData] = useState(null);
  const [loading, setLoading] = useState(true);
  const [error, setError] = useState(null);

  useEffect(() => {
    const controller = new AbortController();

    const fetchData = async () => {
      setLoading(true);
      setError(null);

      try {
        // Symulacja opóźnienia sieciowego
        await new Promise(resolve => setTimeout(resolve, 1500));

        // Symulacja danych z API
        const mockData = getMockData(url);
        setData(mockData);
      } catch (err) {
        if (err.name !== 'AbortError') {
          setError(err.message);
        }
      } finally {
        setLoading(false);
      }
    };

    fetchData();

    // Cleanup - anulowanie żądania
    return () => controller.abort();
  }, [url]);

  return { data, loading, error };
}

// Symulacja odpowiedzi API
function getMockData(url) {
  const endpoints = {
    '/api/planets': [
      { id: 1, name: 'Mars', distance: '225M km', status: 'Kolonizacja' },
      { id: 2, name: 'Jowisz', distance: '628M km', status: 'Eksploracja' },
      { id: 3, name: 'Saturn', distance: '1.2B km', status: 'Obserwacja' },
      { id: 4, name: 'Uran', distance: '2.7B km', status: 'Planowanie' },
    ],
    '/api/missions': [
      { id: 1, name: 'Apollo 25', crew: 6, status: 'W toku' },
      { id: 2, name: 'Artemis 12', crew: 4, status: 'Przygotowanie' },
      { id: 3, name: 'Europa Clipper', crew: 0, status: 'Automatyczna' },
    ],
    '/api/astronauts': [
      { id: 1, name: 'Anna Kowalska', role: 'Kapitan', missions: 5 },
      { id: 2, name: 'Jan Nowak', role: 'Inżynier', missions: 3 },
      { id: 3, name: 'Maria Wiśniewska', role: 'Naukowiec', missions: 7 },
    ],
  };
  return endpoints[url] || [];
}

// Komponent wyświetlający planety
function PlanetsList() {
  const { data, loading, error } = useFetch('/api/planets');

  if (loading) return <div className="loading">Ładowanie planet...</div>;
  if (error) return <div className="error">Błąd: {error}</div>;

  return (
    <div className="data-card">
      <h2>Planety</h2>
      <ul>
        {data?.map(planet => (
          <li key={planet.id}>
            <strong>{planet.name}</strong>
            <span className="detail">Dystans: {planet.distance}</span>
            <span className="status">{planet.status}</span>
          </li>
        ))}
      </ul>
    </div>
  );
}

// Komponent wyświetlający misje
function MissionsList() {
  const { data, loading, error } = useFetch('/api/missions');

  if (loading) return <div className="loading">Ładowanie misji...</div>;
  if (error) return <div className="error">Błąd: {error}</div>;

  return (
    <div className="data-card">
      <h2>Misje</h2>
      <ul>
        {data?.map(mission => (
          <li key={mission.id}>
            <strong>{mission.name}</strong>
            <span className="detail">Załoga: {mission.crew}</span>
            <span className="status">{mission.status}</span>
          </li>
        ))}
      </ul>
    </div>
  );
}

// Komponent wyświetlający astronautów
function AstronautsList() {
  const { data, loading, error } = useFetch('/api/astronauts');

  if (loading) return <div className="loading">Ładowanie astronautów...</div>;
  if (error) return <div className="error">Błąd: {error}</div>;

  return (
    <div className="data-card">
      <h2>Astronauci</h2>
      <ul>
        {data?.map(astronaut => (
          <li key={astronaut.id}>
            <strong>{astronaut.name}</strong>
            <span className="detail">Rola: {astronaut.role}</span>
            <span className="status">Misje: {astronaut.missions}</span>
          </li>
        ))}
      </ul>
    </div>
  );
}

function App() {
  const [refreshKey, setRefreshKey] = useState(0);

  return (
    <div className="app" key={refreshKey}>
      <h1>Centrum Danych Kosmicznych</h1>
      <button className="refresh-btn" onClick={() => setRefreshKey(k => k + 1)}>
        Odśwież wszystkie dane
      </button>
      <div className="data-grid">
        <PlanetsList />
        <MissionsList />
        <AstronautsList />
      </div>
    </div>
  );
}

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. 1. Jaka jest główna różnica między useEffect(() => {}, []) a componentDidMount?

  2. 2. Co się stanie, gdy NIE przekażemy tablicy zależności do useEffect (brak drugiego argumentu)?

To 2 z 3 pytań do tej lekcji. Pozostałe rozwiążesz w grze.

Zadania praktyczne w grze

  • Edytor kodu

    Stany: [data, setData], [loading, setLoading], [error, setError]. useEffect: setLoading(true), fetch('/api/satellite'), setData(result), setLoading(false). Try/catch dla błędów. Wyświetl: loading ? 'Ładowanie...' : data!

  • Układanie w poziomie

    Ułóż poprawną składnię useEffect z tablicą zależności:

  • Edytor kodu

    System komunikacji WebSocket

  • Układanie w pionie

    Uporządkuj fazy życia komponentu React:

  • Edytor kodu

    System globalnych skrótów klawiszowych

  1. Zadanie z kodemPraktyka: Data fetching
  2. PytanieuseEffect a cykl życia
  3. PytanieuseEffect bez tablicy zależności
  4. Ułóż w kolejnościSkładnia useEffect z tablicą zależności
  5. Zadanie z kodemPraktyka: WebSocket connection
  6. PytanieWarunkowe wykonanie efektów
  7. Ułóż w kolejnościFazy cyklu życia komponentu
  8. Zadanie z kodemPraktyka: Event listeners

Przydatne artykuły