Kurs JavaScript i React · Moduł 4: Context API i useReducer
Context i useReducer w praktyce
W tej lekcji6
Poznałeś już Context API i useReducer osobno. Teraz czas połączyć te dwa narzędzia w jeden kompletny system zarządzania stanem - tak jak centrum dowodzenia misji kosmicznej łączy wszystkie systemy komunikacji w jeden spójny panel sterowania.
Dlaczego łączyć Context z useReducer?
Samo useReducer centralizuje logikę stanu, ale stan pozostaje lokalny w jednym komponencie. Samo Context API udostępnia dane globalnie, ale zarządzanie złożonymi aktualizacjami przez setState staje się nieuporządkowane. Połączenie obu daje nam najlepsze z dwóch światów:
- Context - udostępnia stan i
dispatchkażdemu komponentowi w drzewie bez prop drilling - useReducer - porządkuje całą logikę aktualizacji w jednej, testowalnej funkcji
Analogia kosmiczna: Context to sieć komunikacyjna statku, która dociera do każdej kabiny. useReducer to centralny komputer, który przetwarza wszystkie rozkazy. Razem tworzą Mission Control - każdy członek załogi może wysłać rozkaz i otrzymać aktualny status, bez konieczności biegania po korytarzach z karteczkami.
Wzorzec: kontekst ze stanem i dispatch
Kluczowy wzorzec polega na umieszczeniu zarówno state, jak i dispatch w wartości kontekstu:
import { createContext, useContext, useReducer } from 'react';
// Tworzymy kontekst
const MissionContext = createContext();
// Reducer z logiką stanu
function missionReducer(state, action) {
switch (action.type) {
case 'SET_STATUS':
return { ...state, status: action.payload };
case 'ADD_CREW':
return { ...state, crew: [...state.crew, action.payload] };
case 'UPDATE_FUEL':
return { ...state, fuel: Math.max(0, Math.min(100, action.payload)) };
default:
return state;
}
}
// Provider - łączy Context z useReducer
function MissionProvider({ children }) {
const initialState = {
status: 'docked',
crew: ['Kapitan Nova'],
fuel: 100
};
const [state, dispatch] = useReducer(missionReducer, initialState);
return (
<MissionContext.Provider value={{ state, dispatch }}>
{children}
</MissionContext.Provider>
);
}Niestandardowy hook dostępu do kontekstu
Zamiast wywoływać useContext(MissionContext) w każdym komponencie, tworzymy dedykowany hook. To standardowa konwencja, która:
- Chroni przed użyciem kontekstu poza providerem (zgłasza czytelny błąd)
- Upraszcza importy w komponentach
- Ułatwia przyszłe refaktoryzacje
function useMission() {
const context = useContext(MissionContext);
if (!context) {
throw new Error('useMission musi być używany wewnątrz MissionProvider');
}
return context;
}Używanie dispatch z komponentów potomnych
Każdy komponent wewnątrz providera może teraz bezpośrednio wysyłać akcje - bez przekazywania funkcji przez props:
function StatusPanel() {
const { state, dispatch } = useMission();
return (
<div className="status-panel">
<h3>Status misji: {state.status}</h3>
<button onClick={() => dispatch({ type: 'SET_STATUS', payload: 'launching' })}>
Rozpocznij start
</button>
<button onClick={() => dispatch({ type: 'SET_STATUS', payload: 'orbiting' })}>
Wejdź na orbitę
</button>
<button onClick={() => dispatch({ type: 'SET_STATUS', payload: 'docked' })}>
Dokuj
</button>
</div>
);
}
function CrewPanel() {
const { state, dispatch } = useMission();
const [newMember, setNewMember] = React.useState('');
const addMember = () => {
if (newMember.trim()) {
dispatch({ type: 'ADD_CREW', payload: newMember.trim() });
setNewMember('');
}
};
return (
<div className="crew-panel">
<h3>Załoga ({state.crew.length}):</h3>
<ul>
{state.crew.map((member, i) => (
<li key={i}>{member}</li>
))}
</ul>
<input
value={newMember}
onChange={(e) => setNewMember(e.target.value)}
placeholder="Imię nowego członka załogi"
/>
<button onClick={addMember}>Dodaj do załogi</button>
</div>
);
}Wzorzec wielu reducerów
Gdy aplikacja rośnie, jeden duży reducer staje się trudny w utrzymaniu. Możemy podzielić logikę na mniejsze reduktory według domeny i połączyć je w głównym reducerze:
// Reduktor dla systemu nawigacji
function navigationReducer(navState, action) {
switch (action.type) {
case 'SET_DESTINATION':
return { ...navState, destination: action.payload, status: 'en route' };
case 'ARRIVE':
return { ...navState, location: navState.destination, destination: null, status: 'arrived' };
default:
return navState;
}
}
// Reduktor dla systemów pokładowych
function systemsReducer(systemsState, action) {
switch (action.type) {
case 'TOGGLE_SHIELDS':
return { ...systemsState, shields: !systemsState.shields };
case 'SET_ENGINE_POWER':
return { ...systemsState, enginePower: action.payload };
default:
return systemsState;
}
}
// Główny reduktor łączący oba
function rootReducer(state, action) {
return {
navigation: navigationReducer(state.navigation, action),
systems: systemsReducer(state.systems, action)
};
}
// Provider z głównym reduktorem
function SpaceshipProvider({ children }) {
const initialState = {
navigation: { location: 'Earth', destination: null, status: 'docked' },
systems: { shields: false, enginePower: 0 }
};
const [state, dispatch] = useReducer(rootReducer, initialState);
return (
<SpaceshipContext.Provider value={{ state, dispatch }}>
{children}
</SpaceshipContext.Provider>
);
}Wzorzec wielu reducerów pozwala na czysty podział odpowiedzialności. Każdy mini-reduktor obsługuje swój obszar stanu, ale wszystkie akcje przepływają przez jeden dispatch. Dzięki temu akcja TOGGLE_SHIELDS może jednocześnie wpłynąć na systemy i nawigację, jeśli tego potrzebujemy.
Kompletna aplikacja Mission Control
Poniżej widzisz wszystkie elementy zebrane razem - od definicji kontekstu, przez provider, po komponenty używające useMission:
import { createContext, useContext, useReducer } from 'react';
const MissionContext = createContext();
function missionReducer(state, action) {
switch (action.type) {
case 'LAUNCH':
return { ...state, status: 'flying', fuel: state.fuel - 20 };
case 'DOCK':
return { ...state, status: 'docked', speed: 0 };
case 'ADD_LOG':
return { ...state, log: [...state.log, action.payload] };
default:
return state;
}
}
function MissionProvider({ children }) {
const [state, dispatch] = useReducer(missionReducer, {
status: 'docked',
fuel: 100,
speed: 0,
log: []
});
return (
<MissionContext.Provider value={{ state, dispatch }}>
{children}
</MissionContext.Provider>
);
}
function useMission() {
return useContext(MissionContext);
}
// Komponent A - panel sterowania
function ControlPanel() {
const { state, dispatch } = useMission();
return (
<div>
<button
onClick={() => {
dispatch({ type: 'LAUNCH' });
dispatch({ type: 'ADD_LOG', payload: 'Start misji!' });
}}
disabled={state.status === 'flying'}
>
Start
</button>
</div>
);
}
// Komponent B - wyświetlanie stanu (osobna gałąź drzewa)
function MissionLog() {
const { state } = useMission();
return (
<ul>
{state.log.map((entry, i) => <li key={i}>{entry}</li>)}
</ul>
);
}
// Aplikacja
function App() {
return (
<MissionProvider>
<ControlPanel />
<MissionLog />
</MissionProvider>
);
}Zauważ, że ControlPanel i MissionLog mogą znajdować się na różnych głębokościach drzewa komponentów i nie muszą o sobie nawzajem wiedzieć - łączy je tylko wspólny MissionProvider.
Kod do tej lekcji: App.jsx
import React, { createContext, useContext, useReducer } from 'react';
// --- Reducer dla misji ---
const initialState = {
missions: [
{ id: 1, name: 'Eksploracja Marsa', priority: 'high', completed: false },
{ id: 2, name: 'Sonda Jowisza', priority: 'medium', completed: false },
],
};
function missionReducer(state, action) {
switch (action.type) {
case 'ADD_MISSION':
return {
...state,
missions: [
...state.missions,
{ id: Date.now(), name: action.name, priority: action.priority, completed: false },
],
};
case 'COMPLETE_MISSION':
return {
...state,
missions: state.missions.map(m =>
m.id === action.id ? { ...m, completed: true } : m
),
};
case 'SET_PRIORITY':
return {
...state,
missions: state.missions.map(m =>
m.id === action.id ? { ...m, priority: action.priority } : m
),
};
default:
return state;
}
}
// --- Context ---
const MissionContext = createContext();
function MissionProvider({ children }) {
const [state, dispatch] = useReducer(missionReducer, initialState);
return (
<MissionContext.Provider value={{ state, dispatch }}>
{children}
</MissionContext.Provider>
);
}
function useMission() {
return useContext(MissionContext);
}
// --- Komponenty ---
const priorityColors = { high: '#f44336', medium: '#ff9800', low: '#4caf50' };
function MissionList() {
const { state, dispatch } = useMission();
return (
<div style={panel}>
<h2 style={{ color: '#4fc3f7', marginTop: 0 }}>Lista misji</h2>
{state.missions.map(m => (
<div key={m.id} style={{ ...missionItem, opacity: m.completed ? 0.5 : 1 }}>
<span style={{ flex: 1 }}>{m.name}</span>
<span style={{ color: priorityColors[m.priority], marginRight: 8 }}>
[{m.priority}]
</span>
{!m.completed && (
<>
<select
value={m.priority}
onChange={e => dispatch({ type: 'SET_PRIORITY', id: m.id, priority: e.target.value })}
style={selectStyle}
>
<option value="high">Wysoki</option>
<option value="medium">Średni</option>
<option value="low">Niski</option>
</select>
<button
onClick={() => dispatch({ type: 'COMPLETE_MISSION', id: m.id })}
style={btnStyle}
>
Zakończ
</button>
</>
)}
{m.completed && <span style={{ color: '#4caf50' }}>Ukończona</span>}
</div>
))}
</div>
);
}
function AddMission() {
const { dispatch } = useMission();
const [name, setName] = React.useState('');
const [priority, setPriority] = React.useState('medium');
const handleAdd = () => {
if (!name.trim()) return;
dispatch({ type: 'ADD_MISSION', name, priority });
setName('');
};
return (
<div style={panel}>
<h2 style={{ color: '#4fc3f7', marginTop: 0 }}>Nowa misja</h2>
<input
value={name}
onChange={e => setName(e.target.value)}
placeholder="Nazwa misji..."
style={inputStyle}
/>
<select value={priority} onChange={e => setPriority(e.target.value)} style={selectStyle}>
<option value="high">Wysoki priorytet</option>
<option value="medium">Średni priorytet</option>
<option value="low">Niski priorytet</option>
</select>
<button onClick={handleAdd} style={{ ...btnStyle, background: '#4fc3f7', color: '#0a0e1a' }}>
Dodaj misję
</button>
</div>
);
}
function MissionStats() {
const { state } = useMission();
const total = state.missions.length;
const done = state.missions.filter(m => m.completed).length;
return (
<div style={{ ...panel, display: 'flex', gap: 20 }}>
<span style={{ color: '#adb5bd' }}>Wszystkich: <b style={{ color: 'white' }}>{total}</b></span>
<span style={{ color: '#adb5bd' }}>Ukończonych: <b style={{ color: '#4caf50' }}>{done}</b></span>
<span style={{ color: '#adb5bd' }}>Aktywnych: <b style={{ color: '#4fc3f7' }}>{total - done}</b></span>
</div>
);
}
export default function App() {
return (
<MissionProvider>
<div style={{ minHeight: '100vh', background: '#0a0e1a', padding: 24, fontFamily: 'Arial', color: 'white' }}>
<h1 style={{ textAlign: 'center', color: '#ffd700', marginBottom: 24 }}>
Centrum Dowodzenia Misjami
</h1>
<MissionStats />
<AddMission />
<MissionList />
</div>
</MissionProvider>
);
}
// --- Style ---
const panel = {
background: '#1a2035',
borderRadius: 10,
padding: 16,
marginBottom: 16,
border: '1px solid rgba(79,195,247,0.2)',
};
const missionItem = {
display: 'flex', alignItems: 'center', gap: 8,
padding: '8px 0', borderBottom: '1px solid rgba(255,255,255,0.07)',
};
const btnStyle = {
background: 'rgba(255,255,255,0.1)', color: 'white',
border: '1px solid rgba(255,255,255,0.2)', borderRadius: 6,
padding: '4px 10px', cursor: 'pointer',
};
const selectStyle = {
background: '#0a0e1a', color: 'white',
border: '1px solid rgba(79,195,247,0.3)', borderRadius: 6, padding: '4px 6px',
};
const inputStyle = {
background: '#0a0e1a', color: 'white',
border: '1px solid rgba(79,195,247,0.3)', borderRadius: 6,
padding: '6px 10px', width: '100%', marginBottom: 8, boxSizing: 'border-box',
};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 funkcje reducer muszą być 'pure functions' i nie mutować stanu?
2. Jak zaimplementować lazy initialization w useReducer?
Zadania praktyczne w grze
- Układanie w pionie
Uporządkuj progresję złożoności stanu - od prostego do wymagającego useReducer:
- Układanie w poziomie
Ułóż elementy składni case w reducer od lewej do prawej:
- Edytor kodu
Implementuj portal międzygalaktyczny
- Klikanie w kolejności
Uporządkuj strukturę reducer'a kosmicznego:
- Edytor kodu
Zbuduj centrum handlowe galaktyki