Kurs JavaScript i React · Moduł 5: useEffect i własne hooki
Optymalizacja wydajności z useEffect
W tej lekcji7
W kosmicznej podróży przez React, wydajność jest krytycznie ważna - podobnie jak zarządzanie zasobami na statku kosmicznym. Nieoptymalne wykorzystanie efektów ubocznych może prowadzić do nadmiernej liczby renderowań, marnotrawstwa zasobów i wolnej reakcji aplikacji. W tym module nauczymy się, jak optymalizować działanie useEffect, aby nasze aplikacje działały płynnie i efektywnie.
Problemy wydajnościowe z useEffect
Hook useEffect jest potężnym narzędziem, ale niewłaściwie używany może powodować różne problemy:
- Zbyt częste wykonywanie efektów - gdy zależności zmieniają się często lub są nieprawidłowo zdefiniowane
- Kosztowne operacje - gdy wewnątrz efektu wykonujemy złożone obliczenia lub manipulacje DOM
- Kaskadowe aktualizacje - gdy jeden efekt powoduje zmiany stanu, które wyzwalają kolejne efekty
- Niepotrzebne renderowania - gdy efekty aktualizują stan, mimo że dane się faktycznie nie zmieniły
Optymalizacja tablicy zależności
Tablica zależności w useEffect jest kluczem do optymalizacji - określa kiedy efekt powinien być ponownie wykonany.
Błąd 1: Zbyt wiele zależności
// Problematyczny kod
function AstronautTracker({ team }) {
const [position, setPosition] = useState({ x: 0, y: 0 });
const [status, setStatus] = useState('online');
// Ten efekt będzie uruchamiany zbyt często
useEffect(() => {
console.log(`Śledzenie astronauty: ${team.leader}`);
fetchAstronautPosition(team.leader).then(newPosition => {
setPosition(newPosition);
});
}, [team, position, status]); // Zbędne zależności: position i status
return <div>Pozycja lidera: {position.x}, {position.y}</div>;
}Rozwiązanie: Używaj tylko niezbędnych zależności
// Poprawiony kod
function AstronautTracker({ team }) {
const [position, setPosition] = useState({ x: 0, y: 0 });
const [status, setStatus] = useState('online');
// Efekt używa tylko potrzebnych zależności
useEffect(() => {
console.log(`Śledzenie astronauty: ${team.leader}`);
fetchAstronautPosition(team.leader).then(newPosition => {
setPosition(newPosition);
});
}, [team.leader]); // Tylko potrzebna zależność
return <div>Pozycja lidera: {position.x}, {position.y}</div>;
}Technika: Memoryzacja obiektów i funkcji
Obiekty i funkcje tworzone podczas renderowania są zawsze "nowe" z perspektywy porównywania zależności. Możemy to zoptymalizować za pomocą hooków useMemo i useCallback:
function SpaceshipDashboard() {
// Bez optymalizacji - obiekt config jest tworzony na nowo przy każdym renderze
const config = { speed: 10, fuel: 100 };
// Z optymalizacją - obiekt config jest zapamiętany i reużyty
const memoizedConfig = useMemo(() => ({ speed: 10, fuel: 100 }), []);
// Bez optymalizacji - funkcja handleData jest tworzona na nowo przy każdym renderze
const handleData = (data) => console.log(data);
// Z optymalizacją - funkcja handleData jest zapamiętana i reużyta
const memoizedHandleData = useCallback((data) => console.log(data), []);
useEffect(() => {
// Ten efekt będzie uruchamiany tylko raz
const subscription = spaceApi.subscribe(memoizedConfig, memoizedHandleData);
return () => subscription.unsubscribe();
}, [memoizedConfig, memoizedHandleData]); // Zależności są stabilne
return <div>Statek kosmiczny</div>;
}Techniki optymalizacji kosztownych operacji
1. Debouncing i throttling
Gdy efekt reaguje na szybko zmieniające się wartości (np. input użytkownika), warto użyć debouncing lub throttling:
function SearchAsteroids({ query }) {
const [results, setResults] = useState([]);
const [debouncedQuery, setDebouncedQuery] = useState(query);
// Debouncing zapytania - aktualizuje się nie częściej niż co 500ms
useEffect(() => {
const timeoutId = setTimeout(() => {
setDebouncedQuery(query);
}, 500);
return () => clearTimeout(timeoutId);
}, [query]);
// Efekt wyszukiwania wykonuje się tylko gdy debouncedQuery się zmieni
useEffect(() => {
if (debouncedQuery) {
searchAsteroids(debouncedQuery).then(setResults);
}
}, [debouncedQuery]);
return (
<div>
<h2>Wyniki wyszukiwania</h2>
<ul>
{results.map(asteroid => (
<li key={asteroid.id}>{asteroid.name}</li>
))}
</ul>
</div>
);
}2. Unikanie niepotrzebnych aktualizacji stanu
function SpaceStation({ stationId }) {
const [data, setData] = useState(null);
useEffect(() => {
let isMounted = true;
fetchStationData(stationId).then(newData => {
// Aktualizuj tylko jeśli komponent jest wciąż zamontowany
if (isMounted) {
// Aktualizuj tylko jeśli dane faktycznie się zmieniły
if (JSON.stringify(data) !== JSON.stringify(newData)) {
setData(newData);
}
}
});
return () => {
isMounted = false;
};
}, [stationId]);
return data ? <StationDisplay data={data} /> : <Loading />;
}Optymalizacja efektów z danymi asynchronicznymi
Problem: Wyścigi (race conditions)
Gdy efekt wykonuje asynchroniczne operacje, może dojść do "wyścigów" - sytuacji, gdzie nowszy request zakończy się przed starszym:
// Problematyczny kod - podatny na wyścigi
function AsteroidDetails({ asteroidId }) {
const [details, setDetails] = useState(null);
useEffect(() => {
fetchAsteroidDetails(asteroidId).then(response => {
setDetails(response); // Możliwy wyścig, jeśli asteroidId zmieni się szybko
});
}, [asteroidId]);
return <div>{details?.name}</div>;
}Rozwiązanie: Anulowanie przestarzałych requestów
// Poprawiony kod - zabezpieczony przed wyścigami
function AsteroidDetails({ asteroidId }) {
const [details, setDetails] = useState(null);
useEffect(() => {
let isCurrent = true;
fetchAsteroidDetails(asteroidId).then(response => {
// Aktualizuj stan tylko jeśli to wciąż aktualny request
if (isCurrent) {
setDetails(response);
}
});
return () => {
isCurrent = false; // Oznacz, że ten efekt nie jest już aktualny
};
}, [asteroidId]);
return <div>{details?.name}</div>;
}Technika zaawansowana: AbortController
Dla API, które wspierają AbortController (np. fetch), możemy faktycznie anulować trwające requesty:
function PlanetScanner({ sector }) {
const [planets, setPlanets] = useState([]);
const [loading, setLoading] = useState(false);
useEffect(() => {
setLoading(true);
// Tworzenie kontrolera anulowania
const controller = new AbortController();
const signal = controller.signal;
fetch(`https://api.space/planets?sector=${sector}`, { signal })
.then(response => response.json())
.then(data => {
setPlanets(data);
setLoading(false);
})
.catch(error => {
if (error.name !== 'AbortError') {
console.error('Błąd:', error);
setLoading(false);
}
});
// Funkcja czyszcząca anuluje request, jeśli efekt zostanie przerwany
return () => {
controller.abort();
};
}, [sector]);
return (
<div>
{loading ? <Loading /> : (
<PlanetsList planets={planets} />
)}
</div>
);
}Separacja logiki do własnych hooków
Jednym z najlepszych sposobów optymalizacji jest tworzenie własnych hooków, które enkapsulują złożoną logikę i mogą być reużyte między komponentami:
// Własny hook do pobierania i zarządzania danymi
function usePlanetData(planetId) {
const [data, setData] = useState(null);
const [loading, setLoading] = useState(true);
const [error, setError] = useState(null);
useEffect(() => {
let isMounted = true;
setLoading(true);
fetchPlanetData(planetId)
.then(result => {
if (isMounted) {
setData(result);
setLoading(false);
}
})
.catch(err => {
if (isMounted) {
setError(err);
setLoading(false);
}
});
return () => {
isMounted = false;
};
}, [planetId]);
return { data, loading, error };
}
// Korzystanie z własnego hooka
function PlanetProfile({ planetId }) {
const { data, loading, error } = usePlanetData(planetId);
if (loading) return <LoadingIndicator />;
if (error) return <ErrorMessage error={error} />;
return (
<div>
<h1>{data.name}</h1>
<p>Średnica: {data.diameter} km</p>
<p>Klimat: {data.climate}</p>
</div>
);
}Używanie mechanizmu layoutEffect
W rzadkich przypadkach, gdy potrzebujesz wykonać pomiary DOM lub synchronizować się z układem strony przed renderowaniem, możesz użyć useLayoutEffect zamiast useEffect:
function CockpitInterface() {
const [dimensions, setDimensions] = useState({ width: 0, height: 0 });
const cockpitRef = useRef(null);
// useLayoutEffect uruchamia się synchronicznie po wszystkich mutacjach DOM,
// ale przed renderowaniem na ekranie
useLayoutEffect(() => {
if (cockpitRef.current) {
const { width, height } = cockpitRef.current.getBoundingClientRect();
setDimensions({ width, height });
}
}, []);
return (
<div ref={cockpitRef} className="cockpit">
<ControlPanel width={dimensions.width} height={dimensions.height} />
</div>
);
}Uwaga:
useLayoutEffectblokuje renderowanie wizualne, więc powinien być używany oszczędnie i tylko gdy absolutnie konieczne.
Podsumowanie: Najlepsze praktyki optymalizacji useEffect
- Minimalizuj zależności - używaj tylko niezbędnych wartości w tablicy zależności
- Separuj efekty - zamiast jednego złożonego efektu, używaj kilku prostszych
- Memoryzuj zależności - używaj useMemo i useCallback dla obiektów i funkcji
- Używaj debouncing/throttling - dla szybko zmieniających się wartości
- Anuluj przestarzałe operacje asynchroniczne - unikaj wyścigów i wycieków pamięci
- Twórz własne hooki - enkapsuluj złożoną logikę w reużywalnych hookach
- Analizuj wzorce renderowania - używaj React DevTools do wykrywania nadmiarowych renderowań
- Unikaj nieskończonych pętli - zawsze upewnij się, że efekty nie powodują nieskończonych cykli aktualizacji
Stosując te techniki optymalizacji, twoja aplikacja React będzie działać efektywnie nawet przy złożonych operacjach i dużych zbiorach danych - podobnie jak dobrze zoptymalizowany statek kosmiczny może pokonywać ogromne odległości z minimalnym zużyciem zasobów.
Kod do tej lekcji: App.jsx
import React, { useState, useEffect, useRef, useCallback } from 'react';
// Demonstracja tablicy zależności
function DependencyArrayDemo() {
const [count, setCount] = useState(0);
const [name, setName] = useState('');
const [logs, setLogs] = useState([]);
const addLog = (msg) => {
setLogs(prev => [...prev.slice(-4), `[${new Date().toLocaleTimeString()}] ${msg}`]);
};
// Effect bez zależności - uruchamia się przy każdym renderze
const effectRuns = useRef(0);
useEffect(() => {
// Bez setState: zmiana stanu tutaj wywołałaby kolejny render i nieskończoną pętlę
effectRuns.current += 1;
console.log(`Effect BEZ tablicy zależności (${effectRuns.current})`);
});
// Effect z pustą tablicą - tylko przy montowaniu
useEffect(() => {
addLog('Effect z [] - tylko przy mount');
}, []);
// Effect z zależnością od count
useEffect(() => {
addLog(`Effect z [count] - count = ${count}`);
}, [count]);
// Effect z zależnością od name
useEffect(() => {
if (name) addLog(`Effect z [name] - name = "${name}"`);
}, [name]);
return (
<div className="demo-card">
<h2>Tablica zależności</h2>
<div className="inputs">
<button onClick={() => setCount(c => c + 1)}>
Count: {count}
</button>
<input
value={name}
onChange={(e) => setName(e.target.value)}
placeholder="Wpisz imię..."
/>
</div>
<div className="logs">
{logs.map((log, i) => <div key={i}>{log}</div>)}
</div>
</div>
);
}
// Optymalizacja fetch requestów
function OptimizedFetchDemo() {
const [searchTerm, setSearchTerm] = useState('');
const [results, setResults] = useState([]);
const [loading, setLoading] = useState(false);
const [fetchCount, setFetchCount] = useState(0);
const abortControllerRef = useRef(null);
// Debounced search z cleanup
useEffect(() => {
// Anuluj poprzednie żądanie
if (abortControllerRef.current) {
abortControllerRef.current.abort();
}
if (!searchTerm.trim()) {
setResults([]);
return;
}
// Debounce - czekaj 500ms przed wyszukaniem
const timeoutId = setTimeout(() => {
abortControllerRef.current = new AbortController();
setLoading(true);
setFetchCount(c => c + 1);
// Symulacja API call
setTimeout(() => {
const mockResults = [
`Planeta: ${searchTerm}-Prime`,
`Gwiazda: ${searchTerm}-Alpha`,
`Mgławica: ${searchTerm}-Nebula`,
];
setResults(mockResults);
setLoading(false);
}, 500);
}, 500);
// Cleanup - anuluj timeout i żądanie
return () => {
clearTimeout(timeoutId);
if (abortControllerRef.current) {
abortControllerRef.current.abort();
}
};
}, [searchTerm]);
return (
<div className="demo-card">
<h2>Optymalizacja Fetch</h2>
<div className="fetch-counter">
Wykonanych zapytań: <span>{fetchCount}</span>
</div>
<input
value={searchTerm}
onChange={(e) => setSearchTerm(e.target.value)}
placeholder="Szukaj obiektów kosmicznych..."
/>
<div className="results">
{loading ? (
<div className="loading">Wyszukiwanie...</div>
) : results.length > 0 ? (
results.map((result, i) => (
<div key={i} className="result">{result}</div>
))
) : searchTerm ? (
<div className="empty">Wpisz, aby wyszukać</div>
) : null}
</div>
<p className="hint">Debounce 500ms + AbortController</p>
</div>
);
}
// Unikanie nieskończonych pętli
function InfiniteLoopPreventionDemo() {
const [data, setData] = useState({ count: 0 });
const renderCount = useRef(0);
const [safeMode, setSafeMode] = useState(true);
// Zliczanie renderów
renderCount.current += 1;
// NIEBEZPIECZNE - spowodowałoby nieskończoną pętlę
// useEffect(() => {
// setData({ count: data.count }); // Nowy obiekt = nowa referencja = re-render
// }, [data]);
// BEZPIECZNE - używamy callbacka
const incrementSafe = useCallback(() => {
setData(prev => ({ count: prev.count + 1 }));
}, []);
return (
<div className="demo-card">
<h2>Unikanie pętli</h2>
<div className="stats">
<div className="stat">
<span className="label">Count:</span>
<span className="value">{data.count}</span>
</div>
<div className="stat">
<span className="label">Rendery:</span>
<span className="value">{renderCount.current}</span>
</div>
</div>
<button onClick={incrementSafe}>
Bezpieczny increment (useCallback)
</button>
<p className="hint">
Używaj funkcji aktualizującej zamiast bezpośredniej referencji
</p>
</div>
);
}
// Optymalizacja z useRef zamiast state
function UseRefOptimizationDemo() {
const [, forceRender] = useState(0);
const clickCountRef = useRef(0);
const renderCountRef = useRef(0);
renderCountRef.current++;
const handleClick = () => {
clickCountRef.current++;
// Nie powoduje re-renderu!
};
return (
<div className="demo-card">
<h2>useRef vs useState</h2>
<div className="comparison">
<div className="box">
<h3>useRef (bez re-renderu)</h3>
<p>Kliknięcia: {clickCountRef.current}</p>
<button onClick={handleClick}>Kliknij (useRef)</button>
</div>
<div className="box">
<h3>Rendery komponentu</h3>
<p>Liczba: {renderCountRef.current}</p>
<button onClick={() => forceRender(n => n + 1)}>
Wymuś render
</button>
</div>
</div>
<p className="hint">
useRef nie powoduje re-renderu przy zmianie wartości
</p>
</div>
);
}
function App() {
return (
<div className="app">
<h1>Optymalizacja useEffect</h1>
<div className="demos">
<DependencyArrayDemo />
<OptimizedFetchDemo />
<InfiniteLoopPreventionDemo />
<UseRefOptimizationDemo />
</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. Co powinna zwracać funkcja cleanup w useEffect?
2. Dlaczego umieszczenie obiektu bezpośrednio w tablicy zależności useEffect może powodować nieskończoną pętlę?
To 2 z 5 pytań do tej lekcji. Pozostałe rozwiążesz w grze.
Zadania praktyczne w grze
- Układanie w pionie
Ułóż kolejność kroków renderowania React z useEffect:
- Edytor kodu
Hook zarządzania klatkami animacji
- Edytor kodu
Implementacja wyszukiwania z debounce
- Edytor kodu
Stwórz komponent TemperatureMonitor używający useEffect do symulowania odczytów temperatury co 2 sekundy.
- Układanie w pionie
Ułóż ewolucję optymalizacji event handling:
- Edytor kodu
Stwórz komponent CommunicationChannel z useEffect, który ustanawia połączenie i czyści przy unmount.
- Klikanie w kolejności
Ułóż cykl życia useEffect:
- Edytor kodu
Stwórz EarthCommunication używający useEffect do fetch danych z API i obsługi loading/error states.
- Układanie w pionie
Ułóż ścieżkę opanowania useEffect:
- Edytor kodu
Stwórz ColonySettings z useEffect do synchronizacji state z localStorage (theme, language, etc.).
- Edytor kodu
Stwórz ShipDashboard z useState dla paliwa/temperatury/silnika, useEffect z interwałem co 2s, oraz przyciskami do sterowania systemami
Zadania po tej lekcji
- Ułóż w kolejnościMoment uruchomienia useEffect
- PytanieWartość zwracana z cleanup w useEffect
- Zadanie z kodemPraktyka: requestAnimationFrame
- PytanieObiekt w tablicy zależności
- Zadanie z kodemPraktyka: Debouncing
- PytanieCleanup function w useEffect
- Zadanie z kodemPraktyka: Efekty uboczne
- Ułóż w kolejnościSortowanie pionowe: Optymalizacja obsługi zdarzeń
- Zadanie z kodemPraktyka: Cleanup w useEffect
- Kliknij w kolejnościSortowanie: Cykl życia useEffect
- PytanieHook useEffect dependencies
- Zadanie z kodemPraktyka: Pobieranie danych
- Ułóż w kolejnościSortowanie pionowe: useEffect mastery path
- Zadanie z kodemPraktyka: localStorage w React
- PytanieTestowanie stanu i zdarzeń
- Zadanie z kodemPraktyka: Ship Dashboard