Kurs JavaScript i React · Moduł 5: useEffect i własne hooki
Własne hooki (Custom Hooks) do efektów
W tej lekcji6
W kosmicznej podróży przez React, wielokrotne pisanie tych samych wzorców useEffect w różnych komponentach to jak budowanie od zera identycznych systemów nawigacyjnych dla każdego statku we flocie. Custom Hooks pozwalają wyekstrahować powtarzalną logikę efektów do jednej, wielokrotnie używanej funkcji - jak stworzenie modułu napędowego, który można zainstalować w dowolnym statku.
Czym są Custom Hooks?
Custom Hook to zwykła funkcja JavaScript, której nazwa zaczyna się od use i która może wywoływać inne hooki (useState, useEffect, useRef itp.). Nie jest to żadna specjalna składnia Reacta - jedyną konwencją jest prefiks use.
// Custom Hook - wyekstrahowana logika
function useWindowSize() {
const [size, setSize] = useState({
width: window.innerWidth,
height: window.innerHeight
});
useEffect(() => {
const handleResize = () => {
setSize({ width: window.innerWidth, height: window.innerHeight });
};
window.addEventListener('resize', handleResize);
return () => window.removeEventListener('resize', handleResize);
}, []);
return size;
}
// Użycie w komponencie - czysto i prosto
function SpaceshipCockpit() {
const { width, height } = useWindowSize();
return (
<p>
Rozmiar ekranu kokpitu: {width} x {height}
</p>
);
}Zauważ, że useWindowSize zawiera wewnątrz useState i useEffect z cleanup - cała logika jest zamknięta w jednym hooku, a komponent dostaje gotowy wynik.
useFetch - pobieranie danych
Jednym z najczęstszych custom hooków jest hook do pobierania danych. Zamiast powtarzać wzorzec loading/error/data w każdym komponencie, zamykamy go w useFetch:
function useFetch(url) {
const [data, setData] = useState(null);
const [isLoading, setIsLoading] = useState(true);
const [error, setError] = useState(null);
useEffect(() => {
const controller = new AbortController();
setIsLoading(true);
setError(null);
fetch(url, { signal: controller.signal })
.then(response => {
if (!response.ok) throw new Error('Błąd sieci');
return response.json();
})
.then(data => {
setData(data);
setIsLoading(false);
})
.catch(err => {
if (err.name !== 'AbortError') {
setError(err.message);
setIsLoading(false);
}
});
// Cleanup - anuluj request przy odmontowaniu lub zmianie URL
return () => controller.abort();
}, [url]);
return { data, isLoading, error };
}Teraz każdy komponent potrzebujący danych z API może użyć jednej linii:
function CrewList() {
const { data: crew, isLoading, error } = useFetch('/api/crew');
if (isLoading) return <p>Ładowanie załogi...</p>;
if (error) return <p>Błąd: {error}</p>;
return (
<ul>
{crew.map(member => (
<li key={member.id}>{member.name}</li>
))}
</ul>
);
}
function MissionLog() {
const { data: missions, isLoading } = useFetch('/api/missions');
if (isLoading) return <p>Ładowanie misji...</p>;
return missions.map(m => <div key={m.id}>{m.name}</div>);
}Dwa komponenty, ten sam wzorzec pobierania danych - zero duplikacji kodu.
useInterval - bezpieczny timer
Timer z setInterval wymaga cleanup i poprawnej obsługi zależności. Custom hook zamyka tę logikę:
function useInterval(callback, delay) {
const savedCallback = useRef();
// Zapamiętaj najnowszą wersję callback
useEffect(() => {
savedCallback.current = callback;
}, [callback]);
// Ustaw timer
useEffect(() => {
if (delay === null) return; // null = pauzuj timer
const tick = () => savedCallback.current();
const id = setInterval(tick, delay);
return () => clearInterval(id);
}, [delay]);
}
// Użycie
function MissionClock() {
const [seconds, setSeconds] = useState(0);
const [isRunning, setIsRunning] = useState(false);
useInterval(() => {
setSeconds(prev => prev + 1);
}, isRunning ? 1000 : null); // null = pauzuj
return (
<div>
<p>Czas misji: {seconds}s</p>
<button onClick={() => setIsRunning(!isRunning)}>
{isRunning ? 'Pauza' : 'Start'}
</button>
</div>
);
}Dzięki useRef dla callback, timer zawsze wywołuje najnowszą wersję funkcji bez konieczności restartowania interwału.
useLocalStorage - trwały stan
Hook synchronizujący stan z localStorage:
function useLocalStorage(key, initialValue) {
const [storedValue, setStoredValue] = useState(() => {
try {
const item = window.localStorage.getItem(key);
return item ? JSON.parse(item) : initialValue;
} catch (error) {
return initialValue;
}
});
useEffect(() => {
try {
window.localStorage.setItem(key, JSON.stringify(storedValue));
} catch (error) {
console.error('Błąd zapisu do localStorage:', error);
}
}, [key, storedValue]);
return [storedValue, setStoredValue];
}
// Użycie - działa jak useState, ale persystuje dane
function ShipSettings() {
const [theme, setTheme] = useLocalStorage('theme', 'dark');
const [volume, setVolume] = useLocalStorage('volume', 50);
return (
<div>
<select value={theme} onChange={e => setTheme(e.target.value)}>
<option value="dark">Ciemny</option>
<option value="light">Jasny</option>
</select>
<input
type="range"
value={volume}
onChange={e => setVolume(Number(e.target.value))}
/>
</div>
);
}Po odświeżeniu strony ustawienia są zachowane - localStorage pamięta wartości między sesjami.
Zasady tworzenia Custom Hooks
- Nazwa zaczyna się od
use- to nie jest opcjonalne. React wymaga tego prefiksu, aby móc sprawdzać reguły hooków - Mogą wywoływać inne hooki - useState, useEffect, useRef, a nawet inne custom hooki
- Każde wywołanie ma własny stan - dwa komponenty używające tego samego hooka mają niezależne kopie stanu
- Zwracają to, czego potrzebuje komponent - mogą zwracać wartości, tablice, obiekty, funkcje
// Custom Hook z wieloma wartościami zwracanymi
function useToggle(initialValue = false) {
const [value, setValue] = useState(initialValue);
const toggle = () => setValue(prev => !prev);
const setTrue = () => setValue(true);
const setFalse = () => setValue(false);
return { value, toggle, setTrue, setFalse };
}
// Użycie
function ShieldControl() {
const shields = useToggle(false);
return (
<div>
<p>Tarcze: {shields.value ? 'AKTYWNE' : 'WYŁĄCZONE'}</p>
<button onClick={shields.toggle}>Przełącz</button>
<button onClick={shields.setTrue}>Aktywuj</button>
<button onClick={shields.setFalse}>Dezaktywuj</button>
</div>
);
}Podsumowanie
Custom Hooks to jedno z najpotężniejszych narzędzi w React do organizacji kodu:
- Eliminują duplikację - powtarzalna logika efektów w jednym miejscu
- Poprawiają czytelność - komponenty stają się krótsze i bardziej deklaratywne
- Ułatwiają testowanie - logikę hooka można testować niezależnie od komponentu
- Są kompozycyjne - custom hooki mogą wywoływać inne custom hooki
Jak modułowe systemy statku kosmicznego - system nawigacyjny, system komunikacyjny, system obronny - każdy jest osobnym modułem (hookiem), który można zainstalować w dowolnym statku (komponencie).
Kod do tej lekcji: App.jsx
import React, { useState, useEffect, useRef } from 'react';
// Custom Hook: useToggle
function useToggle(initialValue = false) {
const [value, setValue] = useState(initialValue);
const toggle = () => setValue(prev => !prev);
const setTrue = () => setValue(true);
const setFalse = () => setValue(false);
return { value, toggle, setTrue, setFalse };
}
// Custom Hook: useInterval
function useInterval(callback, delay) {
const savedCallback = useRef();
useEffect(() => {
savedCallback.current = callback;
}, [callback]);
useEffect(() => {
if (delay === null) return;
const tick = () => savedCallback.current();
const id = setInterval(tick, delay);
return () => clearInterval(id);
}, [delay]);
}
// Custom Hook: useLocalStorage
function useLocalStorage(key, initialValue) {
const [storedValue, setStoredValue] = useState(() => {
try {
const item = window.localStorage.getItem(key);
return item ? JSON.parse(item) : initialValue;
} catch {
return initialValue;
}
});
useEffect(() => {
try {
window.localStorage.setItem(key, JSON.stringify(storedValue));
} catch (error) {
console.error('Blad zapisu:', error);
}
}, [key, storedValue]);
return [storedValue, setStoredValue];
}
// Demo 1: useToggle
function ShieldControls() {
const shields = useToggle(false);
const weapons = useToggle(false);
const engines = useToggle(true);
return (
<div className="demo-card">
<h2>useToggle</h2>
<div className="system-row">
<span>Tarcze</span>
<span className={shields.value ? 'on' : 'off'}>{shields.value ? 'ON' : 'OFF'}</span>
<button onClick={shields.toggle}>Przelacz</button>
</div>
<div className="system-row">
<span>Uzbrojenie</span>
<span className={weapons.value ? 'on' : 'off'}>{weapons.value ? 'ON' : 'OFF'}</span>
<button onClick={weapons.toggle}>Przelacz</button>
</div>
<div className="system-row">
<span>Silniki</span>
<span className={engines.value ? 'on' : 'off'}>{engines.value ? 'ON' : 'OFF'}</span>
<button onClick={engines.toggle}>Przelacz</button>
</div>
</div>
);
}
// Demo 2: useInterval
function MissionClock() {
const [seconds, setSeconds] = useState(0);
const isRunning = useToggle(false);
useInterval(() => {
setSeconds(prev => prev + 1);
}, isRunning.value ? 1000 : null);
const mins = String(Math.floor(seconds / 60)).padStart(2, '0');
const secs = String(seconds % 60).padStart(2, '0');
return (
<div className="demo-card">
<h2>useInterval</h2>
<div className="clock">{mins}:{secs}</div>
<div className="clock-controls">
<button onClick={isRunning.toggle}>
{isRunning.value ? 'Pauza' : 'Start'}
</button>
<button onClick={() => { isRunning.setFalse(); setSeconds(0); }}>
Reset
</button>
</div>
</div>
);
}
// Demo 3: useLocalStorage
function ShipSettings() {
const [pilotName, setPilotName] = useLocalStorage('pilotName', '');
const [theme, setTheme] = useLocalStorage('theme', 'dark');
const [volume, setVolume] = useLocalStorage('volume', 50);
return (
<div className="demo-card">
<h2>useLocalStorage</h2>
<p className="hint">Dane przetrwaja odswiezenie strony!</p>
<div className="setting">
<label>Pilot:</label>
<input
value={pilotName}
onChange={e => setPilotName(e.target.value)}
placeholder="Wpisz imie..."
/>
</div>
<div className="setting">
<label>Motyw:</label>
<select value={theme} onChange={e => setTheme(e.target.value)}>
<option value="dark">Ciemny</option>
<option value="light">Jasny</option>
<option value="blue">Kosmiczny</option>
</select>
</div>
<div className="setting">
<label>Glosnosc: {volume}%</label>
<input
type="range"
min="0"
max="100"
value={volume}
onChange={e => setVolume(Number(e.target.value))}
/>
</div>
</div>
);
}
function App() {
return (
<div className="app">
<h1>Custom Hooks - Modulowe systemy statku</h1>
<div className="demos">
<ShieldControls />
<MissionClock />
<ShipSettings />
</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óre z poniższych NIE jest typowym zastosowaniem useEffect?
2. Który hook React zastępuje metodę componentDidMount z komponentów klasowych?
Zadania praktyczne w grze
- Edytor kodu
Własny hook media query
- Edytor kodu
Monitorowanie stanu baterii