Kurs JavaScript i React · Moduł 5: useEffect i własne hooki
Czyszczenie efektów
W tej lekcji10
Poprawne czyszczenie efektów ubocznych jest kluczowym aspektem tworzenia niezawodnych aplikacji w React. Podobnie jak astronauci muszą czyścić swoje systemy podtrzymywania życia, aby uniknąć awarii, tak samo my musimy dbać o czyszczenie naszych efektów, aby uniknąć wycieków pamięci, niepotrzebnych obliczeń i innych problemów.
Dlaczego czyszczenie efektów jest ważne?
Gdy komponent jest odmontowywany (usuwany z DOM) lub gdy zmieniają się zależności efektu, mogą wystąpić różne problemy, jeśli nie zadbamy o właściwe czyszczenie:
- Wycieki pamięci - nieużywane zasoby, które nie są zwalniane
- Aktualizacja stanu odmontowanych komponentów - prowadzi do ostrzeżeń i błędów
- Niepotrzebne obliczenia - zużywanie zasobów na operacje, które nie są już potrzebne
- Kolidujące aktualizacje - gdy stare i nowe efekty działają jednocześnie
- Subskrypcje "duchów" - stare subskrypcje nadal reagujące na zdarzenia
Podstawowa składnia funkcji czyszczącej
W useEffect, funkcja czyszcząca jest zwracana z funkcji efektu:
useEffect(() => {
// Kod efektu - uruchamiany po renderowaniu
console.log('Efekt uruchomiony');
// Funkcja czyszcząca - uruchamiana przed następnym efektem lub przy odmontowaniu
return () => {
console.log('Efekt wyczyszczony');
};
}, [dependency]); // Tablica zależnościKiedy funkcja czyszcząca jest wywoływana?
Funkcja czyszcząca jest uruchamiana w dwóch sytuacjach:
- Przed ponownym uruchomieniem efektu - gdy zmieniają się zależności
- Przed odmontowaniem komponentu - gdy komponent jest usuwany z DOM
function SpaceModule({ moduleId }) {
useEffect(() => {
console.log(`Moduł ${moduleId} został zainicjalizowany`);
// Ta funkcja zostanie wywołana:
// 1. Przed następną inicjalizacją, gdy moduleId się zmieni
// 2. Gdy komponent SpaceModule zostanie odmontowany
return () => {
console.log(`Moduł ${moduleId} został wyłączony`);
};
}, [moduleId]);
return <div className="space-module">Moduł kosmiczny: {moduleId}</div>;
}Typowe przypadki wymagające czyszczenia
1. Interwały i timeouty
Niezwolnione interwały i timeouty mogą nadal działać w tle, zużywając zasoby i potencjalnie aktualizując stan nieistniejących już komponentów:
function Countdown({ seconds, onComplete }) {
const [timeLeft, setTimeLeft] = useState(seconds);
useEffect(() => {
// Nie rozpoczynaj odliczania, jeśli już zakończone
if (timeLeft <= 0) {
onComplete();
return;
}
console.log(`Rozpoczynam odliczanie od ${timeLeft}`);
// Ustawienie interwału
const intervalId = setInterval(() => {
setTimeLeft(prevTime => {
if (prevTime <= 1) {
onComplete();
return 0;
}
return prevTime - 1;
});
}, 1000);
// Funkcja czyszcząca zatrzymuje interwał
return () => {
console.log(`Zatrzymuję odliczanie na ${timeLeft}`);
clearInterval(intervalId);
};
}, [timeLeft, onComplete]);
return <div className="countdown">{timeLeft}</div>;
}2. Subskrypcje do zewnętrznych źródeł danych
Subskrypcje, które nie są anulowane, mogą nadal otrzymywać dane i powodować aktualizacje stanu:
function TelemetryMonitor({ shipId }) {
const [data, setData] = useState(null);
useEffect(() => {
let isMounted = true;
console.log(`Rozpoczynam monitorowanie statku ${shipId}`);
// Utworzenie subskrypcji do telemetrii
const subscription = telemetryService.subscribe(shipId, telemetryData => {
// Aktualizuj stan tylko jeśli komponent jest nadal zamontowany
if (isMounted) {
setData(telemetryData);
}
});
// Funkcja czyszcząca anuluje subskrypcję
return () => {
console.log(`Kończę monitorowanie statku ${shipId}`);
isMounted = false;
subscription.unsubscribe();
};
}, [shipId]);
if (!data) return <div>Oczekiwanie na dane telemetryczne...</div>;
return (
<div className="telemetry">
<h3>Telemetria statku: {shipId}</h3>
<p>Poziom tlenu: {data.oxygen}%</p>
<p>Temperatura: {data.temperature}°C</p>
<p>Prędkość: {data.velocity} km/h</p>
</div>
);
}3. Nasłuchiwanie zdarzeń DOM
Nasłuchiwacze zdarzeń, które nie są usuwane, mogą prowadzić do wycieków pamięci:
function KeyboardShortcuts({ onEscape }) {
useEffect(() => {
console.log('Instaluję nasłuchiwacz klawiatury');
// Funkcja obsługująca naciśnięcie klawisza
const handleKeyDown = (event) => {
if (event.key === 'Escape') {
onEscape();
}
};
// Dodanie nasłuchiwacza do dokumentu
document.addEventListener('keydown', handleKeyDown);
// Funkcja czyszcząca usuwa nasłuchiwacz
return () => {
console.log('Usuwam nasłuchiwacz klawiatury');
document.removeEventListener('keydown', handleKeyDown);
};
}, [onEscape]);
return null; // Ten komponent nie renderuje niczego widocznego
}4. WebSockets i połączenia czasu rzeczywistego
Połączenia, które pozostają otwarte, mogą zużywać zasoby i powodować wycieki:
function MissionControlSocket({ missionId, onMessage }) {
const [status, setStatus] = useState('disconnected');
useEffect(() => {
let socket = null;
// Funkcja inicjalizująca połączenie
const connect = () => {
console.log(`Łączenie z misją ${missionId}`);
setStatus('connecting');
// Utworzenie WebSocketa
socket = new WebSocket(`wss://mission-control.space/mission/${missionId}`);
socket.onopen = () => {
console.log(`Połączono z misją ${missionId}`);
setStatus('connected');
};
socket.onmessage = (event) => {
const data = JSON.parse(event.data);
onMessage(data);
};
socket.onerror = (error) => {
console.error(`Błąd połączenia WebSocket: ${error.message}`);
setStatus('error');
};
socket.onclose = () => {
console.log(`Rozłączono z misją ${missionId}`);
setStatus('disconnected');
};
};
// Inicjalizacja połączenia
connect();
// Funkcja czyszcząca zamyka połączenie
return () => {
console.log(`Zamykanie połączenia z misją ${missionId}`);
if (socket) {
socket.close();
}
};
}, [missionId, onMessage]);
return (
<div className="socket-status">
Status połączenia: {status}
</div>
);
}5. Anulowanie żądań fetch
Anulowanie trwających żądań fetch zapobiega aktualizacjom stanu po odmontowaniu:
function PlanetInfo({ planetId }) {
const [planet, setPlanet] = useState(null);
const [loading, setLoading] = useState(true);
const [error, setError] = useState(null);
useEffect(() => {
// Utworzenie kontrolera do anulowania żądania
const abortController = new AbortController();
const signal = abortController.signal;
async function fetchPlanetData() {
try {
setLoading(true);
console.log(`Pobieranie danych planety ${planetId}`);
const response = await fetch(`https://api.space.com/planets/${planetId}`, {
signal // przekazanie sygnału do fetch
});
if (!response.ok) {
throw new Error(`HTTP Error: ${response.status}`);
}
const data = await response.json();
setPlanet(data);
setError(null);
} catch (err) {
// Ignoruj błędy anulowania
if (err.name !== 'AbortError') {
console.error(`Błąd pobierania danych: ${err.message}`);
setError(`Nie udało się pobrać danych planety: ${err.message}`);
}
} finally {
setLoading(false);
}
}
fetchPlanetData();
// Funkcja czyszcząca anuluje trwające żądania
return () => {
console.log(`Anulowanie żądania dla planety ${planetId}`);
abortController.abort();
};
}, [planetId]);
if (loading) return <div>Ładowanie danych planety...</div>;
if (error) return <div>Błąd: {error}</div>;
if (!planet) return <div>Brak danych 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>
);
}Zaawansowane wzorce czyszczenia efektów
1. Flaga isMounted
Chociaż użycie AbortController jest preferowanym sposobem anulowania żądań fetch, w przypadkach, gdy nie możemy łatwo anulować operacji asynchronicznej, możemy użyć flagi isMounted:
function AsteroidTracker({ asteroidId }) {
const [data, setData] = useState(null);
useEffect(() => {
let isMounted = true; // Flaga informująca, czy komponent jest zamontowany
async function fetchAsteroidData() {
const response = await fetch(`https://api.nasa.gov/neo/rest/v1/neo/${asteroidId}`);
const asteroidData = await response.json();
// Aktualizuj stan tylko jeśli komponent jest nadal zamontowany
if (isMounted) {
setData(asteroidData);
}
}
fetchAsteroidData();
// Funkcja czyszcząca zmienia flagę
return () => {
isMounted = false;
};
}, [asteroidId]);
// Renderowanie...
}2. Synchronizacja z zewnętrznymi składowymi stanu
Gdy synchronizujemy stan React z zewnętrznym składowym stanu, ważne jest, aby przywrócić poprzedni stan podczas czyszczenia:
function ThemeSwitcher({ theme }) {
useEffect(() => {
// Zapisanie aktualnego motywu
const previousTheme = document.body.dataset.theme;
// Ustawienie nowego motywu
document.body.dataset.theme = theme;
console.log(`Zmieniam motyw na: ${theme}`);
// Przywrócenie poprzedniego motywu podczas czyszczenia
return () => {
console.log(`Przywracam poprzedni motyw: ${previousTheme || 'default'}`);
document.body.dataset.theme = previousTheme || 'default';
};
}, [theme]);
return (
<div className="theme-info">
Aktualny motyw: {theme}
</div>
);
}3. Obsługa zasobów współdzielonych
Gdy wiele komponentów współdzieli zasoby, należy użyć systemu zliczania referencji:
// Singleton do zarządzania współdzielonymi zasobami
class SharedResourceManager {
constructor() {
this.resources = new Map();
this.refCounts = new Map();
}
// Pozyskanie zasobu (zwiększenie licznika referencji)
acquire(resourceId, creator) {
if (!this.resources.has(resourceId)) {
// Tworzenie zasobu, jeśli nie istnieje
this.resources.set(resourceId, creator());
this.refCounts.set(resourceId, 0);
}
// Zwiększenie licznika referencji
this.refCounts.set(resourceId, this.refCounts.get(resourceId) + 1);
return this.resources.get(resourceId);
}
// Zwolnienie zasobu (zmniejszenie licznika referencji)
release(resourceId) {
if (!this.resources.has(resourceId)) return;
// Zmniejszenie licznika referencji
const newCount = this.refCounts.get(resourceId) - 1;
this.refCounts.set(resourceId, newCount);
// Usunięcie zasobu, gdy nie ma już referencji
if (newCount <= 0) {
const resource = this.resources.get(resourceId);
if (resource.dispose && typeof resource.dispose === 'function') {
resource.dispose();
}
this.resources.delete(resourceId);
this.refCounts.delete(resourceId);
}
}
}
// Singleton do użycia w całej aplikacji
export const sharedResources = new SharedResourceManager();
// Hook do użycia współdzielonego zasobu
function useSharedResource(resourceId, createResource) {
useEffect(() => {
// Pozyskanie zasobu
const resource = sharedResources.acquire(resourceId, createResource);
console.log(`Zasób ${resourceId} pozyskany, liczba użytkowników: ${sharedResources.refCounts.get(resourceId)}`);
// Zwolnienie zasobu przy czyszczeniu
return () => {
sharedResources.release(resourceId);
console.log(`Zasób ${resourceId} zwolniony`);
};
}, [resourceId]);
return sharedResources.resources.get(resourceId);
}
// Przykład użycia
function SpaceshipScanner() {
// Ten zasób będzie współdzielony między wszystkimi instancjami komponentu
const scanner = useSharedResource('advanced-scanner', () => {
console.log('Inicjalizacja skanera (kosztowna operacja)');
return {
scan: (target) => console.log(`Skanowanie ${target}...`),
dispose: () => console.log('Wyłączanie skanera')
};
});
return (
<button onClick={() => scanner.scan('Mars')}>
Skanuj Mars
</button>
);
}Typowe problemy i rozwiązania
1. Przepełnienie stosu wywołań przy czyszczeniu timera
Problem: Niepoprawne zatrzymanie timera może prowadzić do przepełnienia stosu:
// ŹLE: Funkcja czyszcząca nie zatrzymuje timeoutu prawidłowo
useEffect(() => {
function tick() {
setCount(count + 1);
setTimeout(tick, 1000);
}
tick();
return () => {
// Problem: nie mamy odniesienia do aktualnego timeout ID
};
}, [count]); // Zależność powoduje ponowne uruchomienie efektuRozwiązanie: Przechowuj aktualny identyfikator timeout:
// DOBRZE: Zapisujemy ID timeoutu, aby móc go anulować
useEffect(() => {
let timeoutId = null;
function tick() {
setCount(prevCount => prevCount + 1);
timeoutId = setTimeout(tick, 1000);
}
timeoutId = setTimeout(tick, 1000);
return () => {
clearTimeout(timeoutId);
};
}, []); // Brak zależności - uruchamiamy tylko raz2. Problemy z kolejnością czyszczenia
Problem: Czasami kolejność czyszczenia ma znaczenie, szczególnie gdy mamy kilka zagnieżdżonych efektów:
// Problematyczna kolejność czyszczenia
useEffect(() => {
// Efekt zewnętrzny
const resource = initializeResource();
useEffect(() => {
// Efekt wewnętrzny korzystający z zasobu
resource.use();
return () => {
// To czyszczenie może być wywołane po zwolnieniu zasobu
resource.stopUsing();
};
}, [someCondition]);
return () => {
// Ten zasób może być już używany przez wewnętrzny efekt
resource.dispose();
};
}, []);Rozwiązanie: Używaj oddzielnych, niezależnych efektów:
// Lepsze podejście
useEffect(() => {
// Efekt inicjalizujący zasób
const resource = initializeResource();
return () => {
// Czyszczenie zasobu
resource.dispose();
};
}, []);
useEffect(() => {
// Efekt korzystający z zasobu (używaj useRef lub kontekstu)
if (resourceRef.current) {
resourceRef.current.use();
return () => {
if (resourceRef.current) {
resourceRef.current.stopUsing();
}
};
}
}, [someCondition]);3. Niespójność stanu podczas czyszczenia
Problem: Podczas czyszczenia możemy uzyskać dostęp do nieaktualnego stanu:
function SpaceshipControl({ shipId }) {
const [power, setPower] = useState(100);
useEffect(() => {
// Inicjalizacja kontroli statku
const ship = spaceshipAPI.connect(shipId);
ship.setPower(power);
return () => {
// Problem: power może być nieaktualne podczas czyszczenia
console.log(`Odłączanie od statku przy mocy: ${power}`);
ship.disconnect();
};
}, [shipId]); // Brak zależności od power
return (
<div>
<p>Moc silników: {power}%</p>
<button onClick={() => setPower(power - 10)}>Zmniejsz moc</button>
</div>
);
}Rozwiązanie: Używaj referencji do przechowywania aktualnych wartości stanu:
function SpaceshipControl({ shipId }) {
const [power, setPower] = useState(100);
const powerRef = useRef(power);
// Aktualizacja referencji przy każdej zmianie stanu
useEffect(() => {
powerRef.current = power;
}, [power]);
useEffect(() => {
// Inicjalizacja kontroli statku
const ship = spaceshipAPI.connect(shipId);
ship.setPower(power);
return () => {
// Używamy aktualnej wartości z referencji
console.log(`Odłączanie od statku przy mocy: ${powerRef.current}%`);
ship.disconnect();
};
}, [shipId, power]);
return (
<div>
<p>Moc silników: {power}%</p>
<button onClick={() => setPower(power - 10)}>Zmniejsz moc</button>
</div>
);
}Testowanie czyszczenia efektów
Aby upewnić się, że efekty są poprawnie czyszczone, warto pisać testy sprawdzające to zachowanie:
// Przykład testu dla komponentu z czyszczeniem efektu
import { render, act, screen } from '@testing-library/react';
import { useState } from 'react';
// Prosty komponent z timerem do testowania
function TimerComponent() {
const [count, setCount] = useState(0);
useEffect(() => {
const interval = setInterval(() => {
setCount(c => c + 1);
}, 100);
return () => clearInterval(interval);
}, []);
return <div data-testid="count">{count}</div>;
}
// Test czyszczenia efektu
test('effect cleanup stops the interval', async () => {
jest.useFakeTimers();
const { unmount } = render(<TimerComponent />);
// Pozwól na kilka tyknięć timera
act(() => {
jest.advanceTimersByTime(250);
});
const countBefore = Number(screen.getByTestId('count').textContent);
// Odmontuj komponent (powinno to wyczyścić efekt i zatrzymać timer)
unmount();
// Przesuń zegar do przodu jeszcze raz
act(() => {
jest.advanceTimersByTime(250);
});
// Ponieważ komponent jest odmontowany i timer zatrzymany,
// możemy tylko sprawdzić, czy licznik nie wzrósł za bardzo przed odmontowaniem
expect(countBefore).toBeGreaterThanOrEqual(2);
expect(countBefore).toBeLessThanOrEqual(3);
jest.useRealTimers();
});Najlepsze praktyki czyszczenia efektów
Zawsze czyść efekty, które tworzą subskrypcje - timery, nasłuchiwacze zdarzeń, połączenia WebSocket, itp.
Używaj AbortController do anulowania żądań fetch - jest to standardowy mechanizm do anulowania operacji asynchronicznych.
Utrzymuj flagę montowania - dla operacji asynchronicznych, których nie można anulować, używaj flagi
isMountedi sprawdzaj ją przed aktualizacją stanu.Przechowuj referencje do zasobów - zmienne lokalne w efekcie przestają istnieć po jego wyczyszczeniu, więc używaj
useRefdo przechowywania odniesień do zasobów.Unikaj zbyt skomplikowanych efektów - efekt, który robi zbyt wiele rzeczy, będzie trudniejszy do poprawnego wyczyszczenia. Rozważ podzielenie go na mniejsze, bardziej skoncentrowane efekty.
Unikaj asynchronicznych funkcji czyszczących - funkcje czyszczące powinny być synchroniczne, aby React mógł zagwarantować ich wykonanie we właściwej kolejności.
Testuj czyszczenie efektów - szczególnie ważne jest testowanie odmontowywania komponentów, które tworzą zewnętrzne subskrypcje.
Czyszczenie efektów a wydajność
Odpowiednie czyszczenie efektów nie tylko zapobiega wyciekom pamięci, ale może również znacząco wpłynąć na wydajność aplikacji:
Mniejsze zużycie pamięci - przez zwalnianie nieużywanych zasobów
Mniej niepotrzebnych obliczeń - przez anulowanie operacji, które nie są już potrzebne
Redukcja liczby ponownych renderowań - przez unikanie niepotrzebnych aktualizacji stanu
Szybsze przeładowania strony - przez zapewnienie, że wszystkie zasoby są prawidłowo zwalniane
Podsumowanie
Czyszczenie efektów jest często pomijanym, ale kluczowym aspektem pracy z React. Podobnie jak astronauci muszą dbać o swoje systemy podtrzymywania życia, tak programiści muszą dbać o czystość swoich efektów ubocznych.
Dobrze napisane funkcje czyszczące:
- Zapobiegają wyciekom pamięci
- Unikają aktualizacji stanu odmontowanych komponentów
- Zwalniają zasoby systemowe
- Zapewniają spójność aplikacji
Pamiętaj, że każdy efekt, który tworzy połączenie, subskrypcję lub rezerwuje zasoby, powinien je również zwolnić podczas czyszczenia.
Kod do tej lekcji: App.jsx
import React, { useState, useEffect } from 'react';
// Demonstracja cleanup przy timerach
function TimerWithCleanup() {
const [count, setCount] = useState(0);
const [isRunning, setIsRunning] = useState(false);
useEffect(() => {
if (!isRunning) return;
console.log('⏰ Timer started');
const interval = setInterval(() => {
setCount(c => c + 1);
}, 1000);
// CLEANUP - bardzo ważne!
return () => {
console.log('Timer stopped (cleanup)');
clearInterval(interval);
};
}, [isRunning]);
return (
<div className="demo-card">
<h2>⏱Timer z Cleanup</h2>
<div className="counter">{count}s</div>
<div className="controls">
<button onClick={() => setIsRunning(true)} disabled={isRunning}>
▶Start
</button>
<button onClick={() => setIsRunning(false)} disabled={!isRunning}>
⏹Stop
</button>
<button onClick={() => { setCount(0); setIsRunning(false); }}>
Reset
</button>
</div>
<p className="hint">Otwórz konsolę, aby zobaczyć logi cleanup</p>
</div>
);
}
// Demonstracja cleanup przy event listenerach
function MouseTrackerWithCleanup() {
const [position, setPosition] = useState({ x: 0, y: 0 });
const [tracking, setTracking] = useState(false);
useEffect(() => {
if (!tracking) return;
const handleMouseMove = (e) => {
setPosition({ x: e.clientX, y: e.clientY });
};
console.log('Mouse tracking enabled');
window.addEventListener('mousemove', handleMouseMove);
// CLEANUP - usunięcie event listenera
return () => {
console.log('Mouse tracking disabled (cleanup)');
window.removeEventListener('mousemove', handleMouseMove);
};
}, [tracking]);
return (
<div className="demo-card">
<h2>Śledzenie Myszy</h2>
<div className="position">
X: {position.x} | Y: {position.y}
</div>
<button onClick={() => setTracking(!tracking)}>
{tracking ? 'Wyłącz śledzenie' : 'Włącz śledzenie'}
</button>
<p className="hint">
{tracking ? 'Poruszaj myszą!' : 'Kliknij, aby włączyć'}
</p>
</div>
);
}
// Demonstracja cleanup przy subskrypcjach
function SubscriptionWithCleanup() {
const [messages, setMessages] = useState([]);
const [subscribed, setSubscribed] = useState(false);
useEffect(() => {
if (!subscribed) return;
console.log('Subscribed to space channel');
// Symulacja subskrypcji (np. WebSocket)
const interval = setInterval(() => {
const newMessage = {
id: Date.now(),
text: `Transmisja #${Math.floor(Math.random() * 1000)}`,
time: new Date().toLocaleTimeString()
};
setMessages(prev => [...prev.slice(-4), newMessage]);
}, 2000);
// CLEANUP - anulowanie subskrypcji
return () => {
console.log('Unsubscribed from space channel (cleanup)');
clearInterval(interval);
};
}, [subscribed]);
return (
<div className="demo-card">
<h2>Subskrypcja</h2>
<div className="messages">
{messages.length === 0 ? (
<p className="empty">Brak wiadomości</p>
) : (
messages.map(msg => (
<div key={msg.id} className="message">
[{msg.time}] {msg.text}
</div>
))
)}
</div>
<button onClick={() => {
setSubscribed(!subscribed);
if (subscribed) setMessages([]);
}}>
{subscribed ? 'Anuluj subskrypcję' : 'Subskrybuj'}
</button>
</div>
);
}
// Komponent pokazujący problem z wyciekiem pamięci
function MemoryLeakDemo() {
const [showChild, setShowChild] = useState(true);
const [logs, setLogs] = useState([]);
const addLog = (msg) => setLogs(prev => [...prev.slice(-5), msg]);
return (
<div className="demo-card wide">
<h2>Demo Wycieków Pamięci</h2>
<button onClick={() => {
setShowChild(!showChild);
addLog(showChild ? 'Komponent odmontowany' : 'Komponent zamontowany');
}}>
{showChild ? 'Odmontuj komponent' : 'Zamontuj komponent'}
</button>
<div className="child-container">
{showChild && <ChildWithCleanup onLog={addLog} />}
</div>
<div className="logs">
<h3>Logi:</h3>
{logs.map((log, i) => <div key={i}>{log}</div>)}
</div>
</div>
);
}
function ChildWithCleanup({ onLog }) {
useEffect(() => {
onLog('Effect uruchomiony');
const timer = setInterval(() => {
onLog('⏰ Timer tick');
}, 2000);
return () => {
onLog('Cleanup wykonany - timer wyczyszczony');
clearInterval(timer);
};
}, []);
return <div className="child">Komponent potomny (z efektem)</div>;
}
function App() {
return (
<div className="app">
<h1>Czyszczenie Efektów (Cleanup)</h1>
<p className="subtitle">Zarządzanie zasobami w useEffect</p>
<div className="demos">
<TimerWithCleanup />
<MouseTrackerWithCleanup />
<SubscriptionWithCleanup />
<MemoryLeakDemo />
</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. Jak najlepiej organizować wiele efektów w komponencie?
2. Jak poprawnie obsługiwać błędy w asynchronicznych operacjach w useEffect?
Zadania praktyczne w grze
- Układanie w poziomie
Ułóż elementy składni cleanup w useEffect od lewej do prawej:
- Edytor kodu
LocalStorage settings sync
- Klikanie w kolejności
Ułóż składnię useEffect z funkcją cleanup:
- Układanie w pionie
Uporządkuj zaawansowane wzorce useEffect od podstawowych do skomplikowanych:
- Edytor kodu
Intersection Observer do lazy loading