Kurs JavaScript i React · Moduł 11: Pobieranie danych i API

Projekt Główny: Kosmiczny Katalog Gwiazd

6 min czytania ·
W tej lekcji3

Znasz już osobno wszystkie systemy statku: nadajnik (fetch), panel stanów, ochronę przed wyścigami, paginację. Ale w prawdziwej misji działają one jednocześnie i to na styku systemów pojawiają się błędy. Czas połączyć wszystko, czego się nauczyłeś! W tym projekcie zbudujesz kompletną aplikację "Kosmiczny Katalog Gwiazd" (Star Catalog), która pobiera dane z API, obsługuje stany ładowania i błędów, umożliwia wyszukiwanie i wspiera paginację.

Wymagania projektu

Twoja aplikacja powinna zawierać:

  1. Pobieranie danych z API - użyj fetch() z async/await
  2. Stan ładowania - wyświetl spinner lub skeleton podczas ładowania
  3. Obsługa błędów - pokaż komunikat błędu z opcją ponownej próby
  4. Stan pustych danych - obsłuż sytuację, gdy nie ma wyników
  5. Wyszukiwanie - filtruj wyniki po nazwie z debouncingiem
  6. Paginacja - nawigacja między stronami wyników
  7. Custom hook useFetch - wyodrębnij logikę pobierania danych

Nowym pojęciem jest tylko debouncing: zamiast wysyłać zapytanie przy każdym naciśnięciu klawisza, czekamy, aż użytkownik przestanie pisać na pół sekundy. Wpisanie słowa "Luke" to wtedy jedno zapytanie, a nie cztery.

Architektura aplikacji

Zanim napiszesz kod, rozrysuj moduły statku. Każdy komponent ma jedno zadanie, a cała logika sieciowa siedzi w jednym hooku:

// Struktura komponentów:
// App
// ├── SearchBar (input wyszukiwania)
// ├── useFetch (custom hook)
// ├── LoadingSpinner / ErrorMessage / EmptyState
// ├── StarList (lista wyników)
// │   └── StarCard (pojedynczy wynik)
// └── Pagination (nawigacja stron)

W naszej implementacji SearchBar i StarList są dla zwięzłości wpisane bezpośrednio w App jako <input> i siatka kart. Gdy aplikacja urośnie, wydzielisz je bez zmiany logiki.

Implementacja

Budujemy od dołu, zaczynając od silnika. Hook useFetch to znany z lekcji o race conditions bezpieczny fetch, z jednym dodatkiem: licznikiem reloadKey. Jest on w zależnościach efektu, więc jego zwiększenie przez refetch wysyła zapytanie ponownie pod ten sam adres:

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

// Custom Hook - useFetch
function useFetch(url) {
  const [data, setData] = useState(null);
  const [loading, setLoading] = useState(true);
  const [error, setError] = useState(null);
  const [reloadKey, setReloadKey] = useState(0);

  useEffect(() => {
    if (!url) return;
    const controller = new AbortController();

    async function fetchData() {
      try {
        setLoading(true);
        setError(null);
        const response = await fetch(url, {
          signal: controller.signal
        });
        if (!response.ok) {
          throw new Error(`HTTP ${response.status}`);
        }
        const result = await response.json();
        setData(result);
      } catch (err) {
        if (err.name !== 'AbortError') {
          setError(err.message);
        }
      } finally {
        if (!controller.signal.aborted) {
          setLoading(false);
        }
      }
    }

    fetchData();
    return () => controller.abort();
  }, [url, reloadKey]);

  // Zmiana reloadKey uruchamia efekt ponownie
  const refetch = () => setReloadKey(k => k + 1);

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

Gdy zmieni się url (nowa strona lub nowe wyszukiwanie), cleanup anuluje poprzednie zapytanie, więc wyścig nie nadpisze wyników. Samo ustawienie tej samej wartości stanu, np. setPage(p => p), niczego by nie ponowiło, bo React pomija render, gdy stan się nie zmienia. Dlatego potrzebny jest osobny licznik.

Następnie trzy panele stanów z lekcji o ładowaniu i błędach. EmptyState dostaje zapytanie, żeby powiedzieć, czego nie znaleziono:

// Komponenty pomocnicze
function LoadingSpinner() {
  return (
    <div style={{ textAlign: 'center', padding: '40px' }}>
      <div className="spinner"></div>
      <p>Skanowanie galaktyki...</p>
    </div>
  );
}

function ErrorMessage({ message, onRetry }) {
  return (
    <div className="error-panel">
      <h3>Utracono łączność!</h3>
      <p>{message}</p>
      <button onClick={onRetry}>Ponów skanowanie</button>
    </div>
  );
}

function EmptyState({ query }) {
  return (
    <div className="empty-panel">
      <p>Brak wyników {query ? `dla "${query}"` : ''}</p>
      <p>Spróbuj innego zapytania</p>
    </div>
  );
}

Żaden z tych komponentów nie wie nic o sieci, dostają tylko propsy. Karta gwiazdy i paginacja są równie proste. Pagination nie trzyma własnego stanu, tylko zgłasza zmianę strony przez onPageChange:

function StarCard({ star }) {
  return (
    <div className="star-card">
      <h3>{star.name}</h3>
      <p>Wzrost: {star.height} cm</p>
      <p>Waga: {star.mass} kg</p>
      <p>Kolor wlosow: {star.hair_color}</p>
      <p>Rok urodzenia: {star.birth_year}</p>
    </div>
  );
}

function Pagination({ page, totalPages, onPageChange }) {
  return (
    <div className="pagination">
      <button
        onClick={() => onPageChange(page - 1)}
        disabled={page === 1}
      >
        Poprzednia
      </button>
      <span>Strona {page} z {totalPages}</span>
      <button
        onClick={() => onPageChange(page + 1)}
        disabled={page >= totalPages}
      >
        Następna
      </button>
    </div>
  );
}

Warunek page >= totalPages jest bezpieczniejszy niż ===, bo zadziała nawet wtedy, gdy nowe wyszukiwanie zmniejszy liczbę stron.

Na koniec mostek dowodzenia, czyli App. Debouncing to efekt z setTimeout: każde naciśnięcie klawisza sprząta poprzedni timer, więc debouncedQuery zmienia się dopiero po 500 ms ciszy. Tekst wyszukiwania przepuszczamy przez encodeURIComponent, żeby spacje i znaki specjalne nie zepsuły adresu:

// Główna aplikacja
function App() {
  const [searchQuery, setSearchQuery] = useState('');
  const [debouncedQuery, setDebouncedQuery] = useState('');
  const [page, setPage] = useState(1);

  // Debounce wyszukiwania
  useEffect(() => {
    const timer = setTimeout(() => {
      setDebouncedQuery(searchQuery);
      setPage(1); // Reset strony przy nowym wyszukiwaniu
    }, 500);
    return () => clearTimeout(timer);
  }, [searchQuery]);

  // Buduj URL z parametrami
  const url = debouncedQuery
    ? `https://swapi.dev/api/people/?search=${encodeURIComponent(debouncedQuery)}&page=${page}`
    : `https://swapi.dev/api/people/?page=${page}`;

  const { data, loading, error, refetch } = useFetch(url);
  const totalPages = data ? Math.ceil(data.count / 10) : 1;

  return (
    <div className="app">
      <h1>Kosmiczny Katalog Gwiazd</h1>

      <input
        type="text"
        value={searchQuery}
        onChange={e => setSearchQuery(e.target.value)}
        placeholder="Szukaj w galaktyce..."
        className="search-input"
      />

      {loading && <LoadingSpinner />}

      {error && (
        <ErrorMessage
          message={error}
          onRetry={refetch}
        />
      )}

      {!loading && !error && data && (
        <>
          {data.results.length === 0 ? (
            <EmptyState query={debouncedQuery} />
          ) : (
            <>
              <p>Znaleziono: {data.count} wyników</p>
              <div className="star-grid">
                {data.results.map(star => (
                  <StarCard key={star.name} star={star} />
                ))}
              </div>
              <Pagination
                page={page}
                totalPages={totalPages}
                onPageChange={setPage}
              />
            </>
          )}
        </>
      )}
    </div>
  );
}

export default App;

Adres URL jest wyliczany przy każdym renderze ze stanu, a nie przechowywany osobno, więc zawsze pasuje do page i debouncedQuery. Przycisk "Ponów skanowanie" woła teraz refetch i naprawdę wysyła zapytanie jeszcze raz. Nowe wyszukiwanie resetuje stronę do 1, bo strona 3 dla "Luke" zwykle nie istnieje.

Ten projekt łączy wszystkie techniki z tego modułu: fetch API, stany loading/error/empty, useEffect, custom hook useFetch, AbortController, debouncing i paginację. Spróbuj zbudować go samodzielnie, a następnie porównaj z powyższym rozwiązaniem. Moja rada: zacznij od samego hooka i jednej listy, a wyszukiwanie dołóż na końcu. Jako rozszerzenie możesz podmienić useFetch na useQuery z TanStack Query i zobaczyć, ile kodu znika.

Pamiętaj: dobra aplikacja to statek, w którym każdy moduł robi jedno, a hook useFetch jest jego wspólnym systemem łączności.

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

// Custom Hook - useFetch
function useFetch(url) {
  const [data, setData] = useState(null);
  const [loading, setLoading] = useState(true);
  const [error, setError] = useState(null);

  useEffect(() => {
    if (!url) {
      setLoading(false);
      return;
    }

    const controller = new AbortController();

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

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

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

        const result = await response.json();
        setData(result);
      } catch (err) {
        if (err.name !== 'AbortError') {
          setError(err.message);
        }
      } finally {
        setLoading(false);
      }
    }

    fetchData();
    return () => controller.abort();
  }, [url]);

  return { data, loading, error };
}

// Komponenty pomocnicze
function LoadingSpinner() {
  return (
    <div className="state-box">
      <div className="spinner"></div>
      <p>Skanowanie galaktyki...</p>
    </div>
  );
}

function ErrorMessage({ message, onRetry }) {
  return (
    <div className="state-box error-box">
      <h3>Utracono lacznosc!</h3>
      <p>{message}</p>
      <button className="retry-btn" onClick={onRetry}>Ponow skanowanie</button>
    </div>
  );
}

function EmptyState({ query }) {
  return (
    <div className="state-box empty-box">
      <h3>Sektor pusty</h3>
      <p>Nie znaleziono wynikow {query ? `dla "${query}"` : ''}</p>
    </div>
  );
}

function StarCard({ star }) {
  return (
    <div className="star-card">
      <h3>{star.name}</h3>
      <div className="star-stats">
        <div className="stat">
          <span className="stat-label">Wzrost</span>
          <span className="stat-value">{star.height} cm</span>
        </div>
        <div className="stat">
          <span className="stat-label">Waga</span>
          <span className="stat-value">{star.mass} kg</span>
        </div>
        <div className="stat">
          <span className="stat-label">Ur.</span>
          <span className="stat-value">{star.birth_year}</span>
        </div>
        <div className="stat">
          <span className="stat-label">Wlosy</span>
          <span className="stat-value">{star.hair_color}</span>
        </div>
      </div>
    </div>
  );
}

function Pagination({ page, totalPages, onPageChange }) {
  return (
    <div className="pagination">
      <button
        onClick={() => onPageChange(page - 1)}
        disabled={page <= 1}
      >
        Poprzednia
      </button>
      <span className="page-info">Strona {page} z {totalPages}</span>
      <button
        onClick={() => onPageChange(page + 1)}
        disabled={page >= totalPages}
      >
        Nastepna
      </button>
    </div>
  );
}

// Glowna aplikacja
function App() {
  const [searchQuery, setSearchQuery] = useState('');
  const [debouncedQuery, setDebouncedQuery] = useState('');
  const [page, setPage] = useState(1);

  // Debounce
  useEffect(() => {
    const timer = setTimeout(() => {
      setDebouncedQuery(searchQuery);
      setPage(1);
    }, 500);
    return () => clearTimeout(timer);
  }, [searchQuery]);

  // URL z parametrami
  const url = debouncedQuery
    ? `https://swapi.dev/api/people/?search=${debouncedQuery}&page=${page}`
    : `https://swapi.dev/api/people/?page=${page}`;

  const { data, loading, error } = useFetch(url);
  const totalPages = data ? Math.ceil(data.count / 10) : 1;

  return (
    <div className="app">
      <h1>Kosmiczny Katalog Gwiazd</h1>

      <div className="search-bar">
        <input
          type="text"
          value={searchQuery}
          onChange={e => setSearchQuery(e.target.value)}
          placeholder="Szukaj w galaktyce..."
          className="search-input"
        />
      </div>

      {loading && <LoadingSpinner />}

      {error && (
        <ErrorMessage
          message={error}
          onRetry={() => { setPage(1); setDebouncedQuery(debouncedQuery + ' '); }}
        />
      )}

      {!loading && !error && data && (
        <>
          {data.results.length === 0 ? (
            <EmptyState query={debouncedQuery} />
          ) : (
            <>
              <p className="results-count">Znaleziono: {data.count} wynikow</p>
              <div className="star-grid">
                {data.results.map(star => (
                  <StarCard key={star.name} star={star} />
                ))}
              </div>
              {totalPages > 1 && (
                <Pagination
                  page={page}
                  totalPages={totalPages}
                  onPageChange={setPage}
                />
              )}
            </>
          )}
        </>
      )}
    </div>
  );
}

export default App;

Hasła z dokumentacji w tej lekcji

Widzisz błąd w tej lekcji?

  1. Projekt do wysłaniaProjekt do mentora: Kosmiczny Katalog Gwiazd
  2. WideoPodsumowanie modułu

Przydatne artykuły