Kurs JavaScript i React · Moduł 5: useEffect i własne hooki
Zaawansowane efekty - race conditions i debouncing
W tej lekcji6
W poprzednim module nauczyłeś się podstaw optymalizacji useEffect: właściwego dobierania zależności, używania flag isCurrent do zapobiegania wyścigom i prostego debouncingu. Czas na zaawansowane techniki - jak prawdziwy oficer inżynieryjny na statku kosmicznym, musisz znać nie tylko podstawowe procedury, ale także protokoły awaryjne na wypadek najbardziej złożonych sytuacji.
AbortController - anulowanie requestów
Prosta flaga isCurrent ma wadę: request kontynuuje działanie w tle, zużywając zasoby sieciowe. Gdy użytkownik szybko przełącza się między stronami, w tle mogą działać dziesiątki bezużytecznych requestów. To jak wysyłanie sygnałów radiowych do stacji, z których już odleciałeś - marnujesz energię nadajnika.
AbortController to wbudowany mechanizm przeglądarki, który pozwala faktycznie anulować request HTTP, a nie tylko ignorować jego wynik.
function PlanetDetails({ planetId }) {
const [planet, setPlanet] = useState(null);
const [loading, setLoading] = useState(true);
const [error, setError] = useState(null);
useEffect(() => {
// Tworzymy kontroler do anulowania requestu
const abortController = new AbortController();
setLoading(true);
setError(null);
fetch(`/api/planets/${planetId}`, {
signal: abortController.signal // Przekazujemy sygnał do fetch
})
.then(res => res.json())
.then(data => {
setPlanet(data);
setLoading(false);
})
.catch(err => {
// AbortError oznacza, że request został celowo anulowany
if (err.name !== 'AbortError') {
setError(err.message);
setLoading(false);
}
// Jeśli AbortError - nie robimy nic, bo komponent już nie istnieje
});
// Cleanup: anuluj request gdy planetId się zmieni lub komponent się odmontuje
return () => abortController.abort();
}, [planetId]);
if (loading) return <p>Ładowanie danych planety...</p>;
if (error) return <p>Błąd: {error}</p>;
return <h2>{planet?.name}</h2>;
}Kluczowa różnica: z flagą isCurrent request leci dalej w tle i zużywa transfer. Z AbortController przeglądarka naprawdę przerywa połączenie sieciowe. Przy dużych plikach lub wolnym połączeniu to ogromna oszczędność.
Race conditions - głębsza analiza
Race condition (wyścig) w kontekście React to sytuacja, gdzie wynik asynchronicznej operacji trafia do komponentu w niewłaściwym momencie. Wyobraź sobie: astronauta klika na planetę Mars, potem szybko na Jowisza. Request o Marsa leci 2 sekundy, o Jowisza 0.5 sekundy. Jowisz wraca pierwszy - poprawnie wyświetlamy Jowisza. Ale po 2 sekundach wraca Mars i nadpisuje dane Jowisza!
// PROBLEM: Race condition bez zabezpieczenia
function StarMap({ starId }) {
const [star, setStar] = useState(null);
useEffect(() => {
// Każda zmiana starId uruchamia nowy fetch
// Ale poprzedni fetch nadal działa w tle!
fetchStarData(starId).then(data => {
setStar(data); // Może nadpisać nowsze dane!
});
}, [starId]);
return <div>{star?.name}</div>;
}
// ROZWIĄZANIE: AbortController eliminuje wyścig
function StarMap({ starId }) {
const [star, setStar] = useState(null);
useEffect(() => {
const controller = new AbortController();
fetchStarData(starId, { signal: controller.signal })
.then(data => setStar(data))
.catch(err => {
if (err.name !== 'AbortError') console.error(err);
});
return () => controller.abort(); // Anuluj poprzedni request
}, [starId]);
return <div>{star?.name}</div>;
}Stale closures - pułapka nieaktualnych wartości
Stale closure (nieaktualne domknięcie) to subtelny bug, który pojawia się, gdy callback wewnątrz useEffect "widzi" starą wersję zmiennej stanu. To jak czytanie wczorajszego raportu sensorów, myśląc że to dane bieżące.
// PROBLEM: Stale closure
function AsteroidCounter() {
const [count, setCount] = useState(0);
useEffect(() => {
const timer = setInterval(() => {
// Ta funkcja "widzi" count z momentu utworzenia timera = zawsze 0!
setCount(count + 1); // Zawsze ustawia na 1, bo count = 0
}, 1000);
return () => clearInterval(timer);
}, []); // Pusta tablica = efekt uruchomiony raz, count zamknięty na 0
return <p>Asteroidy: {count}</p>;
}
// ROZWIĄZANIE 1: Użyj functional updater
function AsteroidCounter() {
const [count, setCount] = useState(0);
useEffect(() => {
const timer = setInterval(() => {
// Functional updater zawsze otrzymuje aktualną wartość!
setCount(prevCount => prevCount + 1);
}, 1000);
return () => clearInterval(timer);
}, []);
return <p>Asteroidy: {count}</p>;
}
// ROZWIĄZANIE 2: Użyj useRef dla wartości, które muszą być aktualne
function TrajectoryCalculator() {
const [velocity, setVelocity] = useState(100);
const velocityRef = useRef(velocity);
// Synchronizuj ref z najnowszą wartością
useEffect(() => {
velocityRef.current = velocity;
}, [velocity]);
useEffect(() => {
const timer = setInterval(() => {
// ref.current zawsze ma najnowszą wartość
console.log('Aktualna prędkość:', velocityRef.current);
}, 1000);
return () => clearInterval(timer);
}, []);
return <input value={velocity} onChange={e => setVelocity(Number(e.target.value))} />;
}Reguła: Jeśli callback w setInterval lub setTimeout potrzebuje aktualnej wartości stanu, użyj functional updater (setState(prev => ...)) lub useRef.
Zaawansowane wzorce cleanup
Cleanup function w useEffect to nie tylko clearInterval. W prawdziwych aplikacjach musisz czyścić wiele rodzajów zasobów jednocześnie.
function LiveDashboard({ stationId }) {
const [data, setData] = useState(null);
useEffect(() => {
const controller = new AbortController();
let eventSource = null;
let reconnectTimer = null;
// 1. Fetch danych początkowych
fetch(`/api/station/${stationId}`, { signal: controller.signal })
.then(res => res.json())
.then(setData)
.catch(err => {
if (err.name !== 'AbortError') console.error(err);
});
// 2. Server-Sent Events dla aktualizacji na żywo
function connectSSE() {
eventSource = new EventSource(`/api/station/${stationId}/live`);
eventSource.onmessage = (event) => {
setData(JSON.parse(event.data));
};
eventSource.onerror = () => {
eventSource.close();
// Ponowne połączenie po 5 sekundach
reconnectTimer = setTimeout(connectSSE, 5000);
};
}
connectSSE();
// 3. Cleanup: zamknij WSZYSTKIE zasoby
return () => {
controller.abort(); // Anuluj fetch
if (eventSource) eventSource.close(); // Zamknij SSE
if (reconnectTimer) clearTimeout(reconnectTimer); // Anuluj reconnect
};
}, [stationId]);
return <div>{data?.status}</div>;
}Debounce z cleanup - prawidłowy wzorzec
W poprzednim module poznałeś prosty debouncing. Teraz zobaczmy wzorzec, który poprawnie obsługuje cleanup i unika wycieków pamięci:
function useDebounce(value, delay) {
const [debouncedValue, setDebouncedValue] = useState(value);
useEffect(() => {
// Ustaw timer na aktualizację zdebouncowanej wartości
const timer = setTimeout(() => {
setDebouncedValue(value);
}, delay);
// Cleanup: anuluj timer jeśli value zmieni się przed upływem delay
return () => clearTimeout(timer);
}, [value, delay]);
return debouncedValue;
}
// Użycie w komponencie wyszukiwarki
function GalaxySearch() {
const [query, setQuery] = useState('');
const debouncedQuery = useDebounce(query, 400);
const [results, setResults] = useState([]);
// Ten efekt uruchamia się dopiero po 400ms od ostatniego znaku
useEffect(() => {
if (!debouncedQuery) {
setResults([]);
return;
}
const controller = new AbortController();
fetch(`/api/search?q=${debouncedQuery}`, { signal: controller.signal })
.then(res => res.json())
.then(setResults)
.catch(err => {
if (err.name !== 'AbortError') console.error(err);
});
return () => controller.abort();
}, [debouncedQuery]);
return (
<div>
<input value={query} onChange={e => setQuery(e.target.value)} placeholder="Szukaj w galaktyce..." />
<ul>
{results.map(r => <li key={r.id}>{r.name}</li>)}
</ul>
</div>
);
}Zauważ, jak łączymy trzy wzorce: custom hook (useDebounce), AbortController i cleanup. To typowy wzorzec w profesjonalnych aplikacjach React.
Podsumowanie
Zaawansowane techniki zarządzania efektami:
- AbortController - anuluj requesty zamiast ignorować odpowiedzi. Oszczędza transfer i zasoby.
- Race conditions - używaj AbortController lub flag cancel, aby zapobiec nadpisaniu nowszych danych starszymi.
- Stale closures - używaj functional updater (
setState(prev => ...)) lubuseRefw callbackach timerów. - Złożony cleanup - zamykaj wszystkie zasoby: fetch, SSE, timery, event listenery.
- Debounce + AbortController - łącz oba wzorce dla optymalnego wyszukiwania.
Kod do tej lekcji: App.jsx
import React, { useState, useEffect, useRef, useCallback } from 'react';
// === Custom Hook: useDebounce ===
function useDebounce(value, delay) {
const [debouncedValue, setDebouncedValue] = useState(value);
useEffect(() => {
const timer = setTimeout(() => setDebouncedValue(value), delay);
return () => clearTimeout(timer);
}, [value, delay]);
return debouncedValue;
}
// === Demo 1: AbortController ===
function AbortControllerDemo() {
const [planetId, setPlanetId] = useState(1);
const [planet, setPlanet] = useState(null);
const [loading, setLoading] = useState(false);
const [log, setLog] = useState([]);
const addLog = useCallback((msg) => {
setLog(prev => [...prev.slice(-6), `[${new Date().toLocaleTimeString()}] ${msg}`]);
}, []);
useEffect(() => {
const controller = new AbortController();
setLoading(true);
addLog(`Fetch planety #${planetId} - START`);
// Symulacja fetch z AbortController
const timer = setTimeout(() => {
if (!controller.signal.aborted) {
const planets = ['Merkury','Wenus','Ziemia','Mars','Jowisz','Saturn','Uran','Neptun'];
setPlanet({ id: planetId, name: planets[(planetId - 1) % planets.length] });
setLoading(false);
addLog(`Fetch planety #${planetId} - OK`);
}
}, 800 + Math.random() * 1200);
return () => {
controller.abort();
clearTimeout(timer);
addLog(`Fetch planety #${planetId} - ANULOWANY`);
};
}, [planetId, addLog]);
return (
<div className="demo-card">
<h2>AbortController</h2>
<p className="info">Klikaj szybko - zobacz anulowanie!</p>
<div className="controls-row">
{[1,2,3,4,5].map(id => (
<button key={id}
className={planetId === id ? 'active' : ''}
onClick={() => setPlanetId(id)}>
#{id}
</button>
))}
</div>
<div className="result">
{loading ? 'Ładowanie...' : planet ? `Planeta: ${planet.name}` : 'Wybierz planetę'}
</div>
<div className="log">
{log.map((l, i) => (
<div key={i} className={l.includes('ANULOWANY') ? 'log-abort' : l.includes('OK') ? 'log-ok' : 'log-start'}>
{l}
</div>
))}
</div>
</div>
);
}
// === Demo 2: Stale Closure ===
function StaleClosureDemo() {
const [count, setCount] = useState(0);
const [badCount, setBadCount] = useState(0);
const [running, setRunning] = useState(false);
// BUG: stale closure - count zamknięty na 0
useEffect(() => {
if (!running) return;
const timer = setInterval(() => {
setBadCount(badCount + 1); // Zawsze widzi badCount=0!
}, 500);
return () => clearInterval(timer);
}, [running]); // badCount nie w zależnościach = stale closure
// FIX: functional updater
useEffect(() => {
if (!running) return;
const timer = setInterval(() => {
setCount(prev => prev + 1); // Zawsze aktualna wartość!
}, 500);
return () => clearInterval(timer);
}, [running]);
const reset = () => {
setRunning(false);
setCount(0);
setBadCount(0);
};
return (
<div className="demo-card">
<h2>Stale Closure</h2>
<div className="comparison">
<div className="bad">
<h3>BUG: count + 1</h3>
<div className="big-number">{badCount}</div>
<p>Zamrożony na 1!</p>
</div>
<div className="good">
<h3>FIX: prev => prev + 1</h3>
<div className="big-number">{count}</div>
<p>Rośnie poprawnie!</p>
</div>
</div>
<div className="controls-row">
<button onClick={() => setRunning(true)} disabled={running}>Start</button>
<button onClick={reset}>Reset</button>
</div>
</div>
);
}
// === Demo 3: Debounce + AbortController ===
function DebouncedSearchDemo() {
const [query, setQuery] = useState('');
const debouncedQuery = useDebounce(query, 400);
const [results, setResults] = useState([]);
const [searchCount, setSearchCount] = useState(0);
const [keystrokeCount, setKeystrokeCount] = useState(0);
useEffect(() => {
if (!debouncedQuery) {
setResults([]);
return;
}
const controller = new AbortController();
setSearchCount(c => c + 1);
// Symulacja wyszukiwania
const stars = [
'Syriusz', 'Betelgeza', 'Rigel', 'Vega', 'Altair',
'Deneb', 'Polaris', 'Antares', 'Aldebaran', 'Spica',
'Procjon', 'Akhernar', 'Kapella', 'Arktur', 'Kanopus'
];
const timer = setTimeout(() => {
if (!controller.signal.aborted) {
const filtered = stars.filter(s =>
s.toLowerCase().includes(debouncedQuery.toLowerCase())
);
setResults(filtered);
}
}, 200);
return () => {
controller.abort();
clearTimeout(timer);
};
}, [debouncedQuery]);
const handleInput = (e) => {
setQuery(e.target.value);
setKeystrokeCount(c => c + 1);
};
return (
<div className="demo-card">
<h2>Debounce + Abort</h2>
<input
className="search-input"
placeholder="Szukaj gwiazdy (np. Syr, Bet, Rig)..."
value={query}
onChange={handleInput}
/>
<div className="stats-row">
<span>Klawisze: {keystrokeCount}</span>
<span>Requesty: {searchCount}</span>
<span>Zaoszczędzone: {Math.max(0, keystrokeCount - searchCount)}</span>
</div>
{results.length > 0 && (
<div className="results">
{results.map(r => <div key={r} className="result-item">{r}</div>)}
</div>
)}
{debouncedQuery && results.length === 0 && (
<p className="no-results">Brak wyników dla "{debouncedQuery}"</p>
)}
</div>
);
}
function App() {
return (
<div className="app">
<h1>Zaawansowane Efekty</h1>
<div className="demos">
<AbortControllerDemo />
<StaleClosureDemo />
<DebouncedSearchDemo />
</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. Który z poniższych zasobów wymaga cleanup function w useEffect?
2. Jak zapobiec race conditions przy pobieraniu danych w useEffect (np. szybkie przełączanie między stronami)?
To 2 z 7 pytań do tej lekcji. Pozostałe rozwiążesz w grze.
Zadania praktyczne w grze
- Klikanie w kolejności
Uporządkuj setup event listenera:
- Układanie w pionie
Ułóż kolejność wykonywania hooków podczas renderowania:
- Klikanie w kolejności
Ułóż cleanup function dla timera w useEffect:
- Układanie w pionie
Uporządkuj kroki zapobiegania wyciekom pamięci w useEffect - od identyfikacji do rozwiązania:
- Klikanie w kolejności
Uporządkuj custom hook:
- Klikanie w kolejności
Ułóż wzorzec wywołania async w useEffect:
- Układanie w pionie
Ułóż kroki obsługi fetch z AbortController w useEffect:
- Układanie w pionie
Uporządkuj cykl życia efektu z cleanup przy zmianie zależności:
- Układanie w poziomie
Ułóż elementy deklaracji custom hooka od lewej do prawej:
- Układanie w pionie
Uporządkuj cykl życia efektu w useEffect:
Zadania po tej lekcji
- Kliknij w kolejnościEvent listener setup
- Ułóż w kolejnościuseLayoutEffect
- PytanieStrategie czyszczenia efektów
- PytanieRace conditions w useEffect
- Kliknij w kolejnościCzyszczenie timera w useEffect
- PytanieOptymalizacje wydajności
- Ułóż w kolejnościWycieki pamięci a useEffect
- Kliknij w kolejnościWzorzec własnego hooka
- Kliknij w kolejnościAsync funkcje w useEffect
- PytanieuseRef w integracji z bibliotekami
- Ułóż w kolejnościAbortController w useEffect
- PytanieTestowanie cleanup w useEffect
- Ułóż w kolejnościCleanup function w useEffect
- PytanieTworzenie custom hooków
- Ułóż w kolejnościDeklaracja custom hooka
- Ułóż w kolejnościCykl życia useEffect
- PytanieWzorce kompozycji efektów