Kurs JavaScript i React · Moduł 5: useEffect i własne hooki
Obsługa API i pobieranie danych
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:
- Używamy
useStatedo przechowywania danych, stanu ładowania i błędów - Używamy
useEffectz pustą tablicą zależności, aby pobrać dane tylko raz po zamontowaniu komponentu - Wykorzystujemy
async/awaitdo obsługi asynchronicznego pobierania danych - 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:
- Pobieramy dane na podstawie
missionId, które może się zmieniać - Używamy flagi
isMounteddo zapobiegania aktualizacji stanu po odmontowaniu komponentu - Dodajemy funkcję czyszczącą, która ustawia
isMounted = falseprzy 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:
- Używamy
AbortControllerdo tworzenia sygnału, który może przerwać żądanie Fetch - Przekazujemy sygnał do opcji żądania Fetch
- W funkcji czyszczącej wywołujemy
abortController.abort(), aby anulować trwające żądanie - 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:
- Używamy
Promise.all()do równoległego wykonywania wielu żądań - Gromadzimy wszystkie dane w jednym stanie
missionData - 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:
- Używamy własnego hooka
useDataFetchingz obsługą ponownych prób, pamięcią podręczną i funkcją ręcznego odświeżania - Implementujemy wykładniczy backoff przy ponawianiu prób (każda kolejna próba czeka dłużej)
- Wykorzystujemy parametry, aby dostosować zachowanie hooka do różnych przypadków użycia
- 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:
- Organizacja kodu - wydzielenie logiki API od komponentów
- Własne hooki - tworzenie abstrakcji dla powtarzających się operacji pobierania danych
- Obsługa wszystkich stanów - ładowanie, sukces, błąd, offline
- Czyszczenie zasobów - anulowanie żądań, zapobieganie aktualizacji stanu po odmontowaniu
- Strategie retry - automatyczne ponawianie nieudanych żądań
- 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. Jaka jest główna różnica między useEffect(() => {}, []) a componentDidMount?
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
Zadania po tej lekcji
- Zadanie z kodemPraktyka: Data fetching
- PytanieuseEffect a cykl życia
- PytanieuseEffect bez tablicy zależności
- Ułóż w kolejnościSkładnia useEffect z tablicą zależności
- Zadanie z kodemPraktyka: WebSocket connection
- PytanieWarunkowe wykonanie efektów
- Ułóż w kolejnościFazy cyklu życia komponentu
- Zadanie z kodemPraktyka: Event listeners