Kurs JavaScript i React · Moduł 5: useEffect i własne hooki
Tworzenie własnych hooków (Custom Hooks) - zaawansowane wzorce
W tej lekcji7
W kosmicznej flocie React, jednym z najcenniejszych umiejętności inżyniera jest projektowanie modułów wielokrotnego użytku. Wyobraź sobie, że budujesz systemy nawigacyjne, komunikacyjne i diagnostyczne dla setek statków kosmicznych. Zamiast pisać każdy system od zera dla każdego statku, tworzysz uniwersalne moduły, które można podłączyć do dowolnego pojazdu. Dokładnie tak działają Custom Hooks w React.
W poprzedniej lekcji poznaliśmy podstawy custom hooków - useFetch, useInterval, useLocalStorage i useToggle. Teraz zagłębimy się w zaawansowane wzorce, reguły hooków i kompozycję, które uczynią Twoje hooki naprawdę profesjonalnymi.
Reguły Hooków (Rules of Hooks)
Zanim zaczniemy tworzyć zaawansowane hooki, musimy znać dwie fundamentalne reguły, których złamanie powoduje nieprzewidywalne błędy:
Reguła 1: Wywoływanie hooków tylko na najwyższym poziomie
Hooki muszą być wywoływane zawsze w tej samej kolejności przy każdym renderowaniu. Nigdy nie umieszczaj hooków wewnątrz warunków, pętli ani zagnieżdżonych funkcji:
// ŹLE - hook wewnątrz warunku
function SpaceShip({ hasRadar }) {
if (hasRadar) {
const [signal, setSignal] = useState(null); // BŁĄD!
}
}
// DOBRZE - warunek wewnątrz hooka
function SpaceShip({ hasRadar }) {
const [signal, setSignal] = useState(null);
useEffect(() => {
if (hasRadar) {
// logika radaru
}
}, [hasRadar]);
}React śledzi hooki na podstawie ich kolejności wywołania. Jeśli warunek spowoduje pominięcie jednego hooka, wszystkie następne będą miały błędne wartości - jak gdyby przesunęły się wszystkie moduły w statku kosmicznym.
Reguła 2: Wywoływanie hooków tylko z komponentów React lub custom hooków
Nie możesz wywoływać hooków z zwykłych funkcji JavaScript. Tylko:
- Komponenty funkcyjne React
- Custom Hooki (funkcje zaczynające się od
use)
// ŹLE - zwykła funkcja
function calculateTrajectory() {
const [speed] = useState(0); // BŁĄD!
}
// DOBRZE - custom hook
function useTrajectory() {
const [speed, setSpeed] = useState(0);
return { speed, setSpeed };
}useDebounce - opóźnianie akcji
Hook useDebounce jest niezwykle przydatny do wyszukiwania w czasie rzeczywistym. Zamiast wysyłać zapytanie do API po każdym naciśnięciu klawisza, czekamy aż użytkownik skończy pisać:
function useDebounce(value, delay) {
const [debouncedValue, setDebouncedValue] = useState(value);
useEffect(() => {
const timer = setTimeout(() => {
setDebouncedValue(value);
}, delay);
return () => clearTimeout(timer);
}, [value, delay]);
return debouncedValue;
}
// Użycie - wyszukiwanie planet
function PlanetSearch() {
const [query, setQuery] = useState('');
const debouncedQuery = useDebounce(query, 500);
useEffect(() => {
if (debouncedQuery) {
// Zapytanie wysyłane dopiero po 500ms przerwy w pisaniu
fetch(`/api/planets?search=${debouncedQuery}`);
}
}, [debouncedQuery]);
return (
<input
value={query}
onChange={e => setQuery(e.target.value)}
placeholder="Szukaj planet..."
/>
);
}Timer jest czyszczony przy każdej zmianie wartości. Dopiero gdy użytkownik przestanie pisać na 500ms, wartość zostanie zaktualizowana i zapytanie API wysłane.
usePrevious - zapamiętywanie poprzedniej wartości
Ten prosty hook pozwala porównywać aktualną wartość z poprzednią:
function usePrevious(value) {
const ref = useRef();
useEffect(() => {
ref.current = value;
}, [value]);
return ref.current;
}
// Użycie - monitorowanie zmian prędkości
function SpeedMonitor() {
const [speed, setSpeed] = useState(0);
const previousSpeed = usePrevious(speed);
const trend = speed > previousSpeed
? 'Przyspieszanie'
: speed < previousSpeed
? 'Hamowanie'
: 'Stała prędkość';
return <p>{trend}: {speed} km/s (było: {previousSpeed})</p>;
}useArray - zarządzanie tablicami
Tablice wymagają specyficznych operacji (dodawanie, usuwanie, filtrowanie). Custom hook zamyka te operacje w czytelny interfejs:
function useArray(initialArray = []) {
const [array, setArray] = useState(initialArray);
const push = (element) => setArray(a => [...a, element]);
const removeByIndex = (index) =>
setArray(a => a.filter((_, i) => i !== index));
const update = (index, newElement) =>
setArray(a => a.map((item, i) => (i === index ? newElement : item)));
const clear = () => setArray([]);
const filter = (fn) => setArray(a => a.filter(fn));
return { array, set: setArray, push, removeByIndex, update, clear, filter };
}
// Użycie - lista załogantów
function CrewManager() {
const crew = useArray(['Kapitan Nova', 'Nawigator Rex']);
return (
<div>
{crew.array.map((member, i) => (
<div key={i}>
{member}
<button onClick={() => crew.removeByIndex(i)}>Usuń</button>
</div>
))}
<button onClick={() => crew.push('Nowy członek')}>
Dodaj członka załogi
</button>
<button onClick={crew.clear}>Zwolnij załogę</button>
</div>
);
}Kompozycja hooków - łączenie modułów
Prawdziwa siła custom hooków ujawnia się, gdy łączymy je ze sobą. Hooki mogą wywoływać inne hooki, tworząc złożone zachowania z prostych bloków:
// Hook 1: Prosty hook stanu z walidacją
function useValidatedInput(initialValue, validator) {
const [value, setValue] = useState(initialValue);
const [error, setError] = useState(null);
const handleChange = (newValue) => {
setValue(newValue);
const validationError = validator(newValue);
setError(validationError);
};
return { value, error, onChange: handleChange, isValid: !error };
}
// Hook 2: Kompozycja - formularz z wieloma polami
function useSpaceshipForm() {
const name = useValidatedInput('', (v) =>
v.length < 3 ? 'Min. 3 znaki' : null
);
const fuel = useValidatedInput(100, (v) =>
v < 0 || v > 100 ? 'Zakres 0-100' : null
);
const isFormValid = name.isValid && fuel.isValid;
const reset = () => {
name.onChange('');
fuel.onChange(100);
};
return { name, fuel, isFormValid, reset };
}
// Użycie
function ShipRegistration() {
const form = useSpaceshipForm();
return (
<form>
<input
value={form.name.value}
onChange={e => form.name.onChange(e.target.value)}
/>
{form.name.error && <span>{form.name.error}</span>}
<input
type="number"
value={form.fuel.value}
onChange={e => form.fuel.onChange(Number(e.target.value))}
/>
{form.fuel.error && <span>{form.fuel.error}</span>}
<button disabled={!form.isFormValid}>Zarejestruj statek</button>
</form>
);
}useSpaceshipForm używa useValidatedInput dwukrotnie - każde wywołanie tworzy niezależną instancję ze swoim stanem.
Wzorzec: useToggle, useCounter, useForm
Popularne wzorce custom hooków, które warto znać:
| Hook | Zastosowanie | Zwraca |
|---|---|---|
useToggle | Przełącznik on/off | { value, toggle, setTrue, setFalse } |
useCounter | Licznik z min/max | { count, increment, decrement, reset } |
useFetch | Pobieranie danych | { data, loading, error, refetch } |
useDebounce | Opóźnianie wartości | Opóźniona wartość |
usePrevious | Poprzednia wartość | Poprzednia wartość |
useArray | Operacje na tablicach | { array, push, remove, update, clear } |
useLocalStorage | Persystentny stan | [value, setValue] |
Podsumowanie
Custom Hooks to fundament dobrze zorganizowanej aplikacji React:
- Reguły hooków - zawsze na najwyższym poziomie, tylko w komponentach i hookach
- Prefiks
use- obowiązkowy, pozwala Reactowi weryfikować reguły - Kompozycja - hooki mogą wywoływać inne hooki, budując złożone zachowania
- Niezależne instancje - każde wywołanie hooka ma własny, izolowany stan
- Reużywalność - jedna logika, wiele komponentów
Jak modułowe systemy kosmicznego statku - każdy hook to samodzielny moduł, który można zainstalować, skonfigurować i połączyć z innymi modułami w dowolnej konfiguracji.
Kod do tej lekcji: App.jsx
import React, { useState, useEffect, useRef } from 'react';
// === useDebounce ===
function useDebounce(value, delay) {
const [debouncedValue, setDebouncedValue] = useState(value);
useEffect(() => {
const timer = setTimeout(() => setDebouncedValue(value), delay);
return () => clearTimeout(timer);
}, [value, delay]);
return debouncedValue;
}
// === usePrevious ===
function usePrevious(value) {
const ref = useRef();
useEffect(() => { ref.current = value; }, [value]);
return ref.current;
}
// === useToggle ===
function useToggle(initial = false) {
const [value, setValue] = useState(initial);
const toggle = () => setValue(v => !v);
const setTrue = () => setValue(true);
const setFalse = () => setValue(false);
return { value, toggle, setTrue, setFalse };
}
// === useArray ===
function useArray(initialArray = []) {
const [array, setArray] = useState(initialArray);
const push = (el) => setArray(a => [...a, el]);
const removeByIndex = (i) => setArray(a => a.filter((_, idx) => idx !== i));
const clear = () => setArray([]);
return { array, push, removeByIndex, clear, set: setArray };
}
// === 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 (e) { console.error(e); }
}, [key, storedValue]);
return [storedValue, setStoredValue];
}
// --- Demo Components ---
function DebounceDemo() {
const [text, setText] = useState('');
const debouncedText = useDebounce(text, 600);
const [results, setResults] = useState([]);
useEffect(() => {
if (debouncedText) {
const planets = ['Merkury','Wenus','Ziemia','Mars','Jowisz','Saturn','Uran','Neptun'];
setResults(planets.filter(p =>
p.toLowerCase().includes(debouncedText.toLowerCase())
));
} else {
setResults([]);
}
}, [debouncedText]);
return (
<div className="demo-card">
<h3>useDebounce</h3>
<input value={text} onChange={e => setText(e.target.value)} placeholder="Szukaj planet..." />
<p className="hint">Debounced: "{debouncedText}"</p>
{results.length > 0 && (
<ul className="results">{results.map(r => <li key={r}>{r}</li>)}</ul>
)}
</div>
);
}
function PreviousDemo() {
const [speed, setSpeed] = useState(0);
const prevSpeed = usePrevious(speed);
const trend = speed > (prevSpeed || 0) ? 'Przyspieszanie' :
speed < (prevSpeed || 0) ? 'Hamowanie' : 'Stala predkosc';
return (
<div className="demo-card">
<h3>usePrevious</h3>
<p className="speed-display">{speed} km/s</p>
<p className="hint">Poprzednio: {prevSpeed ?? 0} km/s | {trend}</p>
<div className="btn-row">
<button onClick={() => setSpeed(s => s + 10)}>+10</button>
<button onClick={() => setSpeed(s => Math.max(0, s - 10))}>-10</button>
<button onClick={() => setSpeed(0)}>Reset</button>
</div>
</div>
);
}
function ToggleDemo() {
const shields = useToggle(false);
const engines = useToggle(true);
return (
<div className="demo-card">
<h3>useToggle</h3>
<div className="toggle-item">
<span>Tarcze: <b style={{color: shields.value ? '#2ecc71' : '#e74c3c'}}>
{shields.value ? 'AKTYWNE' : 'WYLACZONE'}
</b></span>
<button onClick={shields.toggle}>Przelacz</button>
</div>
<div className="toggle-item">
<span>Silniki: <b style={{color: engines.value ? '#2ecc71' : '#e74c3c'}}>
{engines.value ? 'AKTYWNE' : 'WYLACZONE'}
</b></span>
<button onClick={engines.toggle}>Przelacz</button>
</div>
</div>
);
}
function ArrayDemo() {
const crew = useArray(['Kapitan Nova', 'Nawigator Rex']);
const [name, setName] = useState('');
const addMember = () => {
if (name.trim()) { crew.push(name.trim()); setName(''); }
};
return (
<div className="demo-card">
<h3>useArray</h3>
<div className="crew-list">
{crew.array.map((member, i) => (
<div key={i} className="crew-member">
<span>{member}</span>
<button onClick={() => crew.removeByIndex(i)} className="btn-small">X</button>
</div>
))}
</div>
<div className="add-row">
<input value={name} onChange={e => setName(e.target.value)}
placeholder="Imie czlonka zalogi..." onKeyDown={e => e.key === 'Enter' && addMember()} />
<button onClick={addMember}>Dodaj</button>
</div>
<button onClick={crew.clear} className="btn-danger">Zwolnij zaloge</button>
</div>
);
}
function StorageDemo() {
const [theme, setTheme] = useLocalStorage('space-theme', 'dark');
const [volume, setVolume] = useLocalStorage('space-volume', 50);
return (
<div className="demo-card">
<h3>useLocalStorage</h3>
<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="cosmic">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>
<p className="hint">Wartosci zapisywane w localStorage</p>
</div>
);
}
export default function App() {
return (
<div className="app">
<h1>Custom Hooks - Moduly statku kosmicznego</h1>
<div className="grid">
<DebounceDemo />
<PreviousDemo />
<ToggleDemo />
<ArrayDemo />
<StorageDemo />
</div>
</div>
);
}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. Dlaczego NIE można wywoływać hooków wewnątrz instrukcji warunkowych (if/else)?
2. Czym custom hook różni się od zwykłej funkcji JavaScript?
To 2 z 3 pytań do tej lekcji. Pozostałe rozwiążesz w grze.
Zadania praktyczne w grze
- Edytor kodu
Stwórz custom hook useDebounce(value, delay) zwracający opóźnioną wartość oraz useToggle(initialValue) zwracający { value, toggle, setTrue, setFalse }. Oba hooki powinny działać z komponentami testowymi na stronie.
- Układanie w pionie
Uporządkuj etapy tworzenia custom hooka od początku do końca:
- Edytor kodu
Stwórz custom hook useArray(initialArray) zwracający { array, set, push, removeByIndex, update, clear, filter } oraz usePrevious(value) zwracający poprzednią wartość. Hooki powinny działać z komponentem zarządzania załogą na stronie.
- Klikanie w kolejności
Ułóż składnię custom hooka useDebounce w poprawnej kolejności:
- Edytor kodu
Zbuduj kompleksowy Saturn Ring Observatory Control Panel zawierający: useEffect dla monitoring różnych faz orbitalnych pierścieni, useLayoutEffect dla synchronizacji pomiarów w czasie rzeczywistym, cleanup functions dla proper unmounting sensors, dependency arrays dla precyzyjnej kontroli re-runs, multiple effects dla niezależnych systemów monitoringu (RingA, RingB, RingC monitoring), effect optimization patterns, async effects dla data fetching z sond kosmicznych, oraz conditional effects reagujące na różne stany obserwatorium. Stwórz system monitoringu godny najbardziej zaawansowanego obserwatorium pierścieni Saturna!
Zadania po tej lekcji
- PytanieReguły hooków w React
- PytanieCustom hook vs funkcja JavaScript
- Zadanie z kodemPraktyka: useDebounce i useToggle
- PytanieStan w custom hookach
- Ułóż w kolejnościEtapy tworzenia custom hooka
- Zadanie z kodemPraktyka: useArray i usePrevious
- Kliknij w kolejnościSkładnia custom hooka useDebounce
- Zadanie z kodemProjekt: Saturn Ring Monitor
- Projekt do wysłaniaProjekt do mentora: Centrum Monitorowania Czasu
- WideoVideo: Podsumowanie modułu