Kurs JavaScript i React · Moduł 4: Context API i useReducer
useReducer - zaawansowane zarządzanie stanem
W tej lekcji8
W centrum dowodzenia statku kosmicznego, prosty panel z jednym przyciskiem to za mało. Gdy systemy pokładowe stają się coraz bardziej złożone - tarcze, silniki, systemy nawigacji, alarmy - potrzebujemy bardziej uporządkowanego sposobu zarządzania stanem. Hook useReducer to jak centralny komputer pokładowy, który przyjmuje rozkazy (akcje) i na ich podstawie aktualizuje stan wszystkich systemów według ściśle określonych reguł.
Czym jest useReducer?
useReducer to alternatywa dla useState, zaprojektowana do obsługi bardziej złożonej logiki stanu. Zamiast bezpośrednio ustawiać nową wartość, wysyłasz akcję (rozkaz), a specjalna funkcja zwana reducerem decyduje, jak stan powinien się zmienić.
Podstawowa składnia
const [state, dispatch] = useReducer(reducer, initialState);Gdzie:
state- aktualny stan (dane systemów statku)dispatch- funkcja do wysyłania akcji (wydawania rozkazów)reducer- funkcja, która na podstawie bieżącego stanu i akcji zwraca nowy staninitialState- początkowa wartość stanu
Analogia kosmiczna: Pomyśl o dispatch jako o panelu sterowania, na którym wciskasz przyciski (akcje). Komputer pokładowy (reducer) odbiera rozkaz i na podstawie aktualnego stanu statku oblicza nowy stan. Nigdy nie modyfikujesz systemów ręcznie - zawsze przez komputer!
Funkcja reducer
Reducer to czysta funkcja, która przyjmuje dwa argumenty: aktualny stan i akcję. Na ich podstawie zwraca nowy obiekt stanu. Najczęściej używamy instrukcji switch do obsługi różnych typów akcji:
function spaceshipReducer(state, action) {
switch (action.type) {
case 'ACTIVATE_SHIELDS':
return { ...state, shields: 100, status: 'defended' };
case 'FIRE_ENGINES':
return { ...state, speed: state.speed + action.payload, fuel: state.fuel - 10 };
case 'EMERGENCY_STOP':
return { ...state, speed: 0, status: 'stopped' };
default:
return state;
}
}Kluczowe zasady reducera:
- Zawsze zwracaj nowy obiekt stanu (nie mutuj poprzedniego)
- Obsłuż
default- zwracaj niezmieniony stan dla nieznanych akcji - Reducer powinien być czystą funkcją - bez side effects, bez losowości
Dispatch i obiekty akcji
Akcja to zwykły obiekt JavaScript z polem type opisującym rodzaj operacji. Opcjonalnie możesz dodać pole payload z dodatkowymi danymi:
// Prosta akcja - tylko typ
dispatch({ type: 'ACTIVATE_SHIELDS' });
// Akcja z danymi (payload)
dispatch({ type: 'FIRE_ENGINES', payload: 50 });
// Akcja ze złożonym payloadem
dispatch({
type: 'ADD_CREW_MEMBER',
payload: { name: 'Kapitan Nova', role: 'pilot' }
});Praktyczny przykład - panel sterowania statkiem
Zobaczmy, jak useReducer sprawdza się w zarządzaniu złożonym stanem panelu kontrolnego:
import { useReducer } from 'react';
const initialShipState = {
fuel: 100,
shields: 0,
speed: 0,
status: 'docked',
log: []
};
function shipReducer(state, action) {
switch (action.type) {
case 'LAUNCH':
if (state.fuel < 20) return state;
return {
...state,
status: 'flying',
fuel: state.fuel - 20,
speed: 50,
log: [...state.log, 'Statek wystartował']
};
case 'BOOST':
if (state.status !== 'flying' || state.fuel < 10) return state;
return {
...state,
speed: state.speed + action.payload,
fuel: state.fuel - 10,
log: [...state.log, `Przyspieszono o ${action.payload} km/s`]
};
case 'TOGGLE_SHIELDS':
return {
...state,
shields: state.shields > 0 ? 0 : 100,
log: [...state.log, state.shields > 0 ? 'Tarcze wyłączone' : 'Tarcze aktywowane']
};
case 'DOCK':
return {
...state,
status: 'docked',
speed: 0,
log: [...state.log, 'Statek zadokował']
};
case 'REFUEL':
return {
...state,
fuel: 100,
log: [...state.log, 'Zatankowano paliwo']
};
default:
return state;
}
}
function ShipControlPanel() {
const [ship, dispatch] = useReducer(shipReducer, initialShipState);
return (
<div className="control-panel">
<h2>Panel sterowania</h2>
<p>Status: {ship.status}</p>
<p>Paliwo: {ship.fuel}%</p>
<p>Tarcze: {ship.shields}%</p>
<p>Prędkość: {ship.speed} km/s</p>
<button onClick={() => dispatch({ type: 'LAUNCH' })}
disabled={ship.status === 'flying'}>
Start
</button>
<button onClick={() => dispatch({ type: 'BOOST', payload: 25 })}
disabled={ship.status !== 'flying'}>
Przyspiesz (+25)
</button>
<button onClick={() => dispatch({ type: 'TOGGLE_SHIELDS' })}>
{ship.shields > 0 ? 'Wyłącz tarcze' : 'Włącz tarcze'}
</button>
<button onClick={() => dispatch({ type: 'DOCK' })}
disabled={ship.status === 'docked'}>
Dokuj
</button>
<button onClick={() => dispatch({ type: 'REFUEL' })}
disabled={ship.status === 'flying'}>
Zatankuj
</button>
<div className="ship-log">
<h3>Dziennik pokładowy:</h3>
<ul>
{ship.log.map((entry, i) => (
<li key={i}>{entry}</li>
))}
</ul>
</div>
</div>
);
}Zwróć uwagę, jak reducer centralizuje całą logikę aktualizacji stanu. Komponent nie musi wiedzieć, jak dokładnie zmienia się stan - wystarczy, że wyśle odpowiednią akcję. To ogromna zaleta przy rozbudowanych interfejsach.
Kiedy useReducer zamiast useState?
Oba hooki służą do zarządzania stanem, ale mają różne zastosowania:
Wybierz useState gdy:
- Stan jest prosty (liczba, string, boolean)
- Logika aktualizacji jest prosta (bezpośrednie przypisanie)
- Masz kilka niezależnych wartości
Wybierz useReducer gdy:
- Stan jest złożonym obiektem z wieloma polami
- Aktualizacja jednego pola wymaga zmiany innych pól
- Masz wiele powiązanych akcji (np. start, stop, reset, boost)
- Logika aktualizacji zawiera warunki (np. nie startuj bez paliwa)
- Chcesz łatwo testować logikę stanu oddzielnie od komponentu
// useState - wystarczy dla prostych przypadków
const [isOpen, setIsOpen] = useState(false);
const [count, setCount] = useState(0);
// useReducer - lepszy dla złożonego stanu
const [shipState, dispatch] = useReducer(shipReducer, {
fuel: 100,
shields: 0,
speed: 0,
status: 'docked',
crew: [],
alerts: [],
systems: { engine: 'online', navigation: 'online', weapons: 'offline' }
});Wzorzec switch-case w reducerze
Instrukcja switch to standardowy wzorzec w reducerach. Oto kilka dobrych praktyk:
// Definiuj stałe dla typów akcji - unikasz literówek
const ACTIONS = {
LAUNCH: 'LAUNCH',
DOCK: 'DOCK',
BOOST: 'BOOST',
TAKE_DAMAGE: 'TAKE_DAMAGE',
REPAIR: 'REPAIR'
};
function shipReducer(state, action) {
switch (action.type) {
case ACTIONS.LAUNCH:
return { ...state, status: 'flying', speed: 50 };
case ACTIONS.DOCK:
return { ...state, status: 'docked', speed: 0 };
case ACTIONS.BOOST:
return {
...state,
speed: Math.min(state.speed + action.payload, 300)
};
case ACTIONS.TAKE_DAMAGE: {
const newShields = Math.max(0, state.shields - action.payload);
return {
...state,
shields: newShields,
status: newShields === 0 ? 'critical' : state.status
};
}
case ACTIONS.REPAIR:
return { ...state, shields: 100, status: 'docked' };
default:
throw new Error(`Nieznana akcja: ${action.type}`);
}
}
// Użycie ze stałymi
dispatch({ type: ACTIONS.BOOST, payload: 50 });
dispatch({ type: ACTIONS.TAKE_DAMAGE, payload: 30 });Zauważ, że w TAKE_DAMAGE użyliśmy bloku {} wewnątrz case - to pozwala na deklarację zmiennych lokalnych (newShields) bez konfliktów z innymi case'ami. Dodatkowo, zamiast default: return state, rzucamy błąd - to pomaga wyłapać literówki w nazwach akcji podczas programowania.
Kreatory akcji (action creators)
Dla wygody i czytelności możesz tworzyć funkcje, które generują obiekty akcji:
// Kreatory akcji
const launch = () => ({ type: 'LAUNCH' });
const boost = (amount) => ({ type: 'BOOST', payload: amount });
const takeDamage = (amount) => ({ type: 'TAKE_DAMAGE', payload: amount });
const addCrewMember = (name, role) => ({
type: 'ADD_CREW_MEMBER',
payload: { name, role }
});
// Użycie - czytelniejsze niż ręczne tworzenie obiektów
dispatch(launch());
dispatch(boost(50));
dispatch(takeDamage(25));
dispatch(addCrewMember('Nova', 'pilot'));Kreatory akcji zmniejszają ryzyko literówek i centralizują logikę tworzenia akcji w jednym miejscu.
Podsumowanie
useReducer to potężne narzędzie do zarządzania złożonym stanem w React:
- Składnia:
const [state, dispatch] = useReducer(reducer, initialState) - Reducer: czysta funkcja
(state, action) => newStatez wzorcem switch-case - Dispatch: wysyłanie akcji
dispatch({ type: 'ACTION', payload: data }) - Kiedy używać: złożony stan, powiązane aktualizacje, logika biznesowa w stanie
- Dobre praktyki: stałe dla typów akcji, kreatory akcji, bloki
{}w case, rzucanie błędów w default
Tak jak centralny komputer pokładowy statku kosmicznego koordynuje pracę wszystkich systemów na podstawie rozkazów z mostka kapitańskiego, tak useReducer centralizuje logikę stanu, czyniąc ją przewidywalną i łatwą do zarządzania.
Kod do tej lekcji: App.jsx
import React, { useState, useMemo, useCallback, memo } from 'react';
// Komponent bez optymalizacji (dla porównania)
function UnoptimizedItem({ name, onSelect }) {
console.log('Rendering UnoptimizedItem:', name);
return (
<div style={{
padding: '10px',
backgroundColor: '#ffebee',
marginBottom: '5px',
borderRadius: '4px'
}}>
{name}
<button onClick={() => onSelect(name)} style={{ marginLeft: '10px' }}>Select</button>
</div>
);
}
// Komponent zoptymalizowany z React.memo
const OptimizedItem = memo(function OptimizedItem({ name, onSelect }) {
console.log('Rendering OptimizedItem:', name);
return (
<div style={{
padding: '10px',
backgroundColor: '#e8f5e9',
marginBottom: '5px',
borderRadius: '4px'
}}>
{name}
<button onClick={() => onSelect(name)} style={{ marginLeft: '10px' }}>Select</button>
</div>
);
});
// Ciężkie obliczenia (symulacja)
function expensiveCalculation(numbers) {
console.log('Running expensive calculation...');
let result = 0;
for (let i = 0; i < 100000000; i++) {
result += numbers.reduce((a, b) => a + b, 0);
}
return numbers.reduce((a, b) => a + b, 0);
}
function PerformanceDemo() {
const [count, setCount] = useState(0);
const [numbers] = useState([1, 2, 3, 4, 5]);
const [selectedItem, setSelectedItem] = useState('');
const [darkMode, setDarkMode] = useState(false);
const items = ['Mars', 'Jowisz', 'Saturn', 'Uran', 'Neptun'];
// Bez useMemo - obliczenie przy każdym renderze
// const sum = expensiveCalculation(numbers);
// Z useMemo - obliczenie tylko gdy zmieni się 'numbers'
const sum = useMemo(() => {
console.log('Computing sum with useMemo...');
return numbers.reduce((a, b) => a + b, 0);
}, [numbers]);
// Bez useCallback - nowa funkcja przy każdym renderze
// const handleSelect = (name) => setSelectedItem(name);
// Z useCallback - stabilna referencja
const handleSelect = useCallback((name) => {
setSelectedItem(name);
}, []);
// Style zoptymalizowane z useMemo
const containerStyle = useMemo(() => ({
fontFamily: 'Arial, sans-serif',
padding: '20px',
maxWidth: '900px',
margin: '0 auto',
backgroundColor: darkMode ? '#1a1a2e' : '#f5f5f5',
color: darkMode ? 'white' : '#333',
minHeight: '100vh',
transition: 'all 0.3s ease'
}), [darkMode]);
return (
<div style={containerStyle}>
<h1 style={{ textAlign: 'center', color: '#667eea' }}>Performance Optimization</h1>
<div style={{
display: 'flex',
justifyContent: 'space-between',
alignItems: 'center',
marginBottom: '30px',
padding: '15px',
backgroundColor: darkMode ? '#252545' : '#fff',
borderRadius: '12px'
}}>
<div>
<button
onClick={() => setCount(c => c + 1)}
style={{
padding: '10px 20px',
backgroundColor: '#667eea',
color: 'white',
border: 'none',
borderRadius: '8px',
cursor: 'pointer',
marginRight: '10px'
}}
>
Count: {count}
</button>
<button
onClick={() => setDarkMode(!darkMode)}
style={{
padding: '10px 20px',
backgroundColor: darkMode ? '#fff' : '#333',
color: darkMode ? '#333' : 'white',
border: 'none',
borderRadius: '8px',
cursor: 'pointer'
}}
>
{darkMode ? 'Light' : 'Dark'}
</button>
</div>
<div>
Selected: <strong>{selectedItem || 'None'}</strong>
</div>
</div>
<div style={{ display: 'grid', gridTemplateColumns: '1fr 1fr', gap: '20px' }}>
{/* useMemo Demo */}
<section style={{
padding: '20px',
backgroundColor: darkMode ? '#252545' : '#fff',
borderRadius: '12px'
}}>
<h2 style={{ color: '#4caf50' }}>useMemo</h2>
<p>Suma tablicy: <strong>{sum}</strong></p>
<p style={{ fontSize: '14px', color: '#888' }}>
Obliczenia wykonywane tylko gdy zmieni się tablica 'numbers'.
Kliknij "Count" - suma nie będzie przeliczana!
</p>
<pre style={{
backgroundColor: darkMode ? '#1a1a2e' : '#f5f5f5',
padding: '10px',
borderRadius: '8px',
fontSize: '12px',
overflow: 'auto'
}}>
{`const sum = useMemo(() => {
return numbers.reduce((a, b) => a + b, 0);
}, [numbers]);`}
</pre>
</section>
{/* React.memo Demo */}
<section style={{
padding: '20px',
backgroundColor: darkMode ? '#252545' : '#fff',
borderRadius: '12px'
}}>
<h2 style={{ color: '#2196f3' }}>React.memo + useCallback</h2>
<p style={{ fontSize: '14px', color: '#888', marginBottom: '15px' }}>
Sprawdź konsolę! Zoptymalizowane elementy nie renderują się przy zmianie count.
</p>
<h4>Bez optymalizacji:</h4>
{items.slice(0, 2).map(item => (
<UnoptimizedItem
key={item}
name={item}
onSelect={(name) => setSelectedItem(name)}
/>
))}
<h4 style={{ marginTop: '20px' }}>Z React.memo + useCallback:</h4>
{items.slice(0, 2).map(item => (
<OptimizedItem
key={item}
name={item}
onSelect={handleSelect}
/>
))}
</section>
</div>
<section style={{
marginTop: '20px',
padding: '20px',
backgroundColor: darkMode ? '#252545' : '#fff',
borderRadius: '12px'
}}>
<h2 style={{ color: '#ff9800' }}>Kiedy optymalizować?</h2>
<ul style={{ lineHeight: '1.8' }}>
<li><strong>useMemo:</strong> Kosztowne obliczenia, tworzenie obiektów/tablic</li>
<li><strong>useCallback:</strong> Callbacki przekazywane do zoptymalizowanych dzieci</li>
<li><strong>React.memo:</strong> Komponenty, które często się nie zmieniają</li>
<li><strong>Uwaga:</strong> Nie optymalizuj przedwcześnie! Mierz najpierw.</li>
</ul>
</section>
</div>
);
}
export default PerformanceDemo;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 zwraca hook useReducer?
Zadania praktyczne w grze
- Klikanie w kolejności
Zbuduj poprawną deklarację useReducer:
- Edytor kodu
Utwórz system stacji badawczej
- Układanie w poziomie
Ułóż poprawną strukturę obiektu akcji w useReducer:
- Układanie w pionie
Uporządkuj komponenty architektury aplikacji kosmicznej od najbardziej ogólnych do szczegółowych:
- Edytor kodu
Stwórz galaktyczny bank danych