Kurs JavaScript i React · Moduł 4: Context API i useReducer
Wzorce zarządzania stanem
W tej lekcji7
Na Stacji Jupiter zarządzasz wieloma systemami jednocześnie - nawigacją, paliwem, załogą, komunikacją. Każdy system potrzebuje danych i musi je udostępniać innym modułom. W React zarządzanie stanem to jedno z najważniejszych wyzwań architektonicznych. Wybór odpowiedniego wzorca determinuje, czy Twoja aplikacja będzie łatwa w utrzymaniu i skalowalna, czy stanie się chaotycznym labiryntem zależności.
Problem: Prop drilling
Zanim poznałeś Context API, jedynym sposobem na przekazywanie danych w dół drzewa komponentów było prop drilling - ręczne przekazywanie propsów przez każdy poziom. To jak przesyłanie wiadomości przez łańcuch członków załogi, gdzie każdy musi powtórzyć komunikat dalej, choć sam go nie potrzebuje.
// Prop drilling - 4 poziomy przekazywania!
function SpaceStation({ missionData }) {
return <Deck missionData={missionData} />;
}
function Deck({ missionData }) {
// Deck nie używa missionData - tylko przekazuje dalej
return <Room missionData={missionData} />;
}
function Room({ missionData }) {
// Room też nie używa - przekazuje dalej
return <Terminal missionData={missionData} />;
}
function Terminal({ missionData }) {
// Dopiero tutaj dane są potrzebne!
return <p>Misja: {missionData.name}</p>;
}Przy 4 poziomach to jeszcze znośne, ale przy 8-10 poziomach (co w dużych aplikacjach jest normą) kod staje się nieczytelny, a każda zmiana w strukturze danych wymaga modyfikacji wielu pośrednich komponentów.
State colocation - trzymaj stan blisko miejsca użycia
Zanim sięgniesz po globalne rozwiązania, rozważ state colocation - zasadę trzymania stanu jak najbliżej komponentów, które go potrzebują. Nie każda dana musi być globalna. To jak na statku kosmicznym: temperatura kabiny pilota nie musi być znana w maszynowni.
// ZŁE: Globalny stan dla lokalnych danych
function App() {
const [searchQuery, setSearchQuery] = useState('');
const [isModalOpen, setIsModalOpen] = useState(false);
const [formData, setFormData] = useState({});
// ... 20 innych stanów
return (
<GlobalContext.Provider value={/* wszystko */}>
<Dashboard />
</GlobalContext.Provider>
);
}
// DOBRE: Stan blisko miejsca użycia
function App() {
// Tylko naprawdę globalne dane
const [user, setUser] = useState(null);
const [theme, setTheme] = useState('dark');
return (
<AppContext.Provider value={{ user, theme }}>
<Dashboard />
</AppContext.Provider>
);
}
function SearchPanel() {
// Lokalny stan - tylko ten komponent go potrzebuje
const [searchQuery, setSearchQuery] = useState('');
return <input value={searchQuery} onChange={e => setSearchQuery(e.target.value)} />;
}Reguła kciuka: jeśli stan jest używany tylko przez jeden komponent lub jego bezpośrednie dzieci - trzymaj go lokalnie. Przenoś do góry (lifting state up) lub do kontekstu dopiero, gdy potrzebują go odległe gałęzie drzewa komponentów.
Context API - wbudowane rozwiązanie
Context API rozwiązuje prop drilling bez dodatkowych bibliotek. Poznałeś go wcześniej w tym module. Jego główne zalety i ograniczenia:
Zalety:
- Wbudowany w React - zero dodatkowych zależności
- Prosty API:
createContext,Provider,useContext - Doskonały dla danych zmieniających się rzadko (theme, auth, locale)
Ograniczenia:
- Każda zmiana wartości re-renderuje WSZYSTKICH konsumentów
- Brak wbudowanego cache'owania danych z API
- Przy złożonym stanie wymaga łączenia z useReducer
- Trudna optymalizacja wydajności w dużych aplikacjach
// Context API - dobry wybór dla konfiguracji statku
const ShipConfigContext = createContext();
function ShipConfigProvider({ children }) {
const [config, setConfig] = useState({
theme: 'dark-nebula',
language: 'pl',
soundEnabled: true,
});
return (
<ShipConfigContext.Provider value={{ config, setConfig }}>
{children}
</ShipConfigContext.Provider>
);
}Redux - centrum dowodzenia dla dużych flot
Redux to sprawdzony wzorzec zarządzania stanem, inspirowany architekturą Flux. Działa jak centralne centrum dowodzenia floty - jeden store (magazyn) przechowuje cały stan aplikacji, a zmiany odbywają się wyłącznie przez dispatch akcji. Nowoczesny Redux piszemy z użyciem Redux Toolkit - createSlice definiuje stan i reducery, a configureStore buduje magazyn:
// Redux Toolkit - nowoczesny standard Redux
import { createSlice, configureStore } from '@reduxjs/toolkit';
// Slice = fragment stanu + reducery + akcje w jednym miejscu
const missionSlice = createSlice({
name: 'mission',
initialState: {
crew: [],
fuel: 100,
destination: null,
status: 'docked',
},
reducers: {
// Immer pozwala "mutować" stan - RTK zamienia to na bezpieczną aktualizację
addCrewMember: (state, action) => {
state.crew.push(action.payload);
},
setDestination: (state, action) => {
state.destination = action.payload;
},
burnFuel: (state, action) => {
state.fuel = Math.max(0, state.fuel - action.payload);
},
launch: (state) => {
state.status = 'in-flight';
},
},
});
// createSlice automatycznie generuje kreatory akcji
export const { addCrewMember, setDestination, burnFuel, launch } = missionSlice.actions;
// configureStore buduje magazyn (z DevTools i middleware w komplecie)
const store = configureStore({
reducer: {
mission: missionSlice.reducer,
},
});
// Użycie w komponencie:
function MissionControl() {
const dispatch = useDispatch();
const { crew, fuel, status } = useSelector(state => state.mission);
return (
<div>
<p>Status: {status} | Paliwo: {fuel}% | Załoga: {crew.length}</p>
<button onClick={() => dispatch(launch())}>Start!</button>
<button onClick={() => dispatch(burnFuel(10))}>Spal paliwo</button>
</div>
);
}Kiedy Redux?
- Aplikacja z wieloma developerami (jasne reguły, przewidywalny przepływ danych)
- Złożony stan z wieloma powiązanymi akcjami
- Potrzebujesz DevTools z time-travel debugging
- Middleware do obsługi side-effects (thunki, saga)
Kiedy NIE Redux?
- Prosta aplikacja z kilkoma stanami
- Mały zespół lub solo developer
- Głównie dane z API (lepiej React Query)
Zustand - lekki silnik manewrowy
Zustand to minimalistyczna biblioteka do zarządzania stanem. Jeśli Redux to potężny silnik główny, Zustand to zwinny silnik manewrowy - robi to samo, ale z mniejszym narzutem. Bez providerów, bez boilerplate'u, bez problemu re-renderów Context API.
// Zustand - prosty store bez providerów
// import { create } from 'zustand';
// Tworzenie store - to wszystko co potrzebujesz!
// const useShipStore = create((set) => ({
// fuel: 100,
// position: { x: 0, y: 0 },
// crew: 5,
//
// burnFuel: (amount) => set((state) => ({
// fuel: Math.max(0, state.fuel - amount)
// })),
//
// moveTo: (x, y) => set({ position: { x, y } }),
//
// addCrew: () => set((state) => ({
// crew: state.crew + 1
// })),
// }));
// Użycie w komponencie - bez Providera!
function FuelGauge() {
// Komponent re-renderuje się TYLKO gdy zmieni się fuel
// const fuel = useShipStore((state) => state.fuel);
// return <div>Paliwo: {fuel}%</div>;
}
function NavigationPanel() {
// Odczytuje TYLKO position - zmiana fuel nie powoduje re-renderu
// const position = useShipStore((state) => state.position);
// const moveTo = useShipStore((state) => state.moveTo);
// return <button onClick={() => moveTo(10, 20)}>Leć!</button>;
}Zustand automatycznie optymalizuje re-rendery dzięki selektorom. Każdy komponent subskrybuje się tylko na te dane, których faktycznie używa. Zmiana paliwa nie re-renderuje panelu nawigacji - i odwrotnie.
Porównanie wzorców - mapa galaktyki
| Cecha | Context API | Redux Toolkit | Zustand |
|---|---|---|---|
| Rozmiar | 0 KB (wbudowany) | ~11 KB | ~1.5 KB |
| Boilerplate | Średni | Duży (ale RTK pomaga) | Minimalny |
| Re-rendery | Wszyscy konsumenci | Zoptymalizowane (selektory) | Zoptymalizowane (selektory) |
| DevTools | Brak dedykowanych | Rozbudowane (time-travel) | Rozszerzenie Redux DevTools |
| Krzywa nauki | Łatwa | Stroma | Łatwa |
| Najlepsze dla | Theme, auth, locale | Duże aplikacje, duże zespoły | Większość aplikacji |
Zasada wyboru narzędzia
Na Stacji Jupiter każdy system ma swoje przeznaczenie. Podobnie z zarządzaniem stanem:
- Stan lokalny (
useState) - dane potrzebne tylko jednemu komponentowi lub jego bezpośrednim dzieciom - Lifted state (stan podniesiony) - dane współdzielone przez 2-3 bliskie komponenty, przenieś do ich wspólnego rodzica
- Context API - dane globalne zmieniające się rzadko: theme, auth, locale, język
- Zustand - stan globalny w małych/średnich aplikacjach, gdy potrzebujesz wydajności i prostoty
- Redux Toolkit - duże aplikacje z wieloma developerami, złożona logika biznesowa, potrzeba DevTools
Pamiętaj: nie ma jednego najlepszego rozwiązania. Najlepsi kosmiczni inżynierowie dobierają narzędzie do problemu, a nie problem do narzędzia.
Przetestuj porównanie wzorców w edytorze poniżej:
Kod do tej lekcji: App.jsx
import React, { createContext, useContext, useState, useReducer } from 'react';
// === WZORCE ZARZĄDZANIA STANEM ===
// Demo: Porównanie wzorców zarządzania stanem
// 1. Context API - wbudowany w React
const ThemeContext = React.createContext();
function ThemeProvider({ children }) {
const [theme, setTheme] = useState('dark-nebula');
const toggleTheme = () => setTheme(t => t === 'dark-nebula' ? 'light-star' : 'dark-nebula');
return (
<ThemeContext.Provider value={{ theme, toggleTheme }}>
{children}
</ThemeContext.Provider>
);
}
function useTheme() {
const ctx = useContext(ThemeContext);
if (!ctx) throw new Error('useTheme musi być wewnątrz ThemeProvider');
return ctx;
}
// 2. useReducer - wzorzec Redux-like wbudowany w React
const missionReducer = (state, action) => {
switch (action.type) {
case 'ADD_CREW':
return { ...state, crew: [...state.crew, action.payload] };
case 'SET_DESTINATION':
return { ...state, destination: action.payload };
case 'BURN_FUEL':
return { ...state, fuel: Math.max(0, state.fuel - action.payload) };
case 'LAUNCH':
return { ...state, status: 'in-flight' };
case 'DOCK':
return { ...state, status: 'docked', fuel: 100 };
default:
return state;
}
};
const initialMission = {
crew: ['Kapitan Ra', 'Nawigator Nova'],
fuel: 100,
destination: null,
status: 'docked',
};
// === PANELE DEMONSTRACYJNE ===
function ContextDemo() {
const { theme, toggleTheme } = useTheme();
const isDark = theme === 'dark-nebula';
return (
<div style={{ ...styles.panel, background: isDark ? '#1a2035' : '#e8eaf6' }}>
<h3 style={{ color: '#4fc3f7' }}>Context API</h3>
<p style={{ color: isDark ? '#ccc' : '#333', fontSize: 13 }}>
Motyw: <strong>{theme}</strong>
</p>
<p style={{ color: isDark ? '#888' : '#666', fontSize: 11 }}>
Idealny dla: theme, auth, locale
</p>
<button style={styles.btn} onClick={toggleTheme}>Zmień motyw</button>
</div>
);
}
function ReducerDemo() {
const [state, dispatch] = useReducer(missionReducer, initialMission);
const destinations = ['Mars', 'Europa', 'Tytan', 'Kepler-442b'];
return (
<div style={styles.panel}>
<h3 style={{ color: '#ffd700' }}>useReducer (Redux-like)</h3>
<div style={styles.stats}>
<div>Status: <span style={{ color: state.status === 'in-flight' ? '#69f0ae' : '#ffd700' }}>{state.status}</span></div>
<div>Paliwo: <span style={{ color: state.fuel < 30 ? '#ff5252' : '#69f0ae' }}>{state.fuel}%</span></div>
<div>Cel: <span style={{ color: '#4fc3f7' }}>{state.destination || 'brak'}</span></div>
<div>Załoga: {state.crew.join(', ')}</div>
</div>
<div style={styles.btnRow}>
{state.status === 'docked' ? (
<>
<button style={styles.btn} onClick={() => {
const dest = destinations[Math.floor(Math.random() * destinations.length)];
dispatch({ type: 'SET_DESTINATION', payload: dest });
}}>Wybierz cel</button>
{state.destination && (
<button style={{ ...styles.btn, background: 'rgba(105,240,174,0.2)', borderColor: '#69f0ae' }}
onClick={() => dispatch({ type: 'LAUNCH' })}>
Start!
</button>
)}
</>
) : (
<>
<button style={styles.btn} onClick={() => dispatch({ type: 'BURN_FUEL', payload: 15 })}>
Silniki (-15)
</button>
<button style={{ ...styles.btn, background: 'rgba(255,215,0,0.2)' }}
onClick={() => dispatch({ type: 'DOCK' })}>
Dokuj
</button>
</>
)}
</div>
</div>
);
}
function ColocationDemo() {
// Stan lokalny - nie potrzebuje Context ani Redux
const [localSearch, setLocalSearch] = useState('');
const [results, setResults] = useState([]);
const planets = ['Mars', 'Jupiter', 'Saturn', 'Neptune', 'Venus', 'Mercury', 'Uranus', 'Pluto'];
const handleSearch = (query) => {
setLocalSearch(query);
if (query.length > 0) {
setResults(planets.filter(p => p.toLowerCase().includes(query.toLowerCase())));
} else {
setResults([]);
}
};
return (
<div style={styles.panel}>
<h3 style={{ color: '#ce93d8' }}>State Colocation</h3>
<p style={{ color: '#888', fontSize: 11, marginBottom: 8 }}>
Stan lokalny - bez Context/Redux
</p>
<input
style={styles.input}
placeholder="Szukaj planety..."
value={localSearch}
onChange={e => handleSearch(e.target.value)}
/>
{results.length > 0 && (
<div style={styles.resultList}>
{results.map(r => (
<div key={r} style={styles.resultItem}>{r}</div>
))}
</div>
)}
</div>
);
}
function ComparisonTable() {
const data = [
{ pattern: 'useState', size: '0 KB', reRenders: 'Lokalne', bestFor: 'Stan jednego komponentu' },
{ pattern: 'Context API', size: '0 KB', reRenders: 'Wszyscy konsumenci', bestFor: 'Theme, auth, locale' },
{ pattern: 'useReducer', size: '0 KB', reRenders: 'Lokalne', bestFor: 'Złożona logika stanu' },
{ pattern: 'Redux (RTK)', size: '~11 KB', reRenders: 'Selektywne', bestFor: 'Duże aplikacje, zespoły' },
{ pattern: 'Zustand', size: '~1.5 KB', reRenders: 'Selektywne', bestFor: 'Większość aplikacji' },
];
return (
<div style={{ ...styles.panel, gridColumn: '1 / -1' }}>
<h3 style={{ color: '#ffd700', textAlign: 'center' }}>Porównanie wzorców</h3>
<div style={styles.table}>
<div style={styles.tableHeader}>
<span>Wzorzec</span><span>Rozmiar</span><span>Re-rendery</span><span>Najlepsze dla</span>
</div>
{data.map(row => (
<div key={row.pattern} style={styles.tableRow}>
<span style={{ color: '#4fc3f7' }}>{row.pattern}</span>
<span>{row.size}</span>
<span>{row.reRenders}</span>
<span style={{ color: '#888' }}>{row.bestFor}</span>
</div>
))}
</div>
</div>
);
}
function App() {
return (
<ThemeProvider>
<div style={styles.container}>
<h1 style={styles.title}>Wzorce Zarządzania Stanem</h1>
<p style={styles.subtitle}>
Porównanie Context API, useReducer i state colocation
</p>
<div style={styles.grid}>
<ContextDemo />
<ReducerDemo />
<ColocationDemo />
<ComparisonTable />
</div>
</div>
</ThemeProvider>
);
}
const styles = {
container: {
fontFamily: 'Arial, sans-serif',
background: 'linear-gradient(135deg, #0a0e1a 0%, #1a1a3e 100%)',
minHeight: '100vh',
padding: 24,
color: 'white',
},
title: { textAlign: 'center', color: '#ffd700', marginBottom: 4 },
subtitle: { textAlign: 'center', color: '#888', fontSize: 13, marginBottom: 24 },
grid: {
display: 'grid',
gridTemplateColumns: 'repeat(auto-fit, minmax(300px, 1fr))',
gap: 16,
maxWidth: 900,
margin: '0 auto',
},
panel: {
background: '#1a2035',
borderRadius: 10,
padding: 16,
border: '1px solid rgba(79,195,247,0.2)',
},
stats: {
fontSize: 13,
lineHeight: 1.8,
marginBottom: 12,
padding: '8px 12px',
background: 'rgba(0,0,0,0.3)',
borderRadius: 8,
},
btnRow: { display: 'flex', gap: 8, justifyContent: 'center', flexWrap: 'wrap' },
btn: {
padding: '6px 16px',
background: 'rgba(255,255,255,0.08)',
color: 'white',
border: '1px solid rgba(255,255,255,0.15)',
borderRadius: 6,
cursor: 'pointer',
fontSize: 13,
},
input: {
width: '100%',
padding: '8px 12px',
background: 'rgba(0,0,0,0.3)',
color: 'white',
border: '1px solid rgba(79,195,247,0.3)',
borderRadius: 6,
fontSize: 13,
outline: 'none',
boxSizing: 'border-box',
},
resultList: {
marginTop: 8,
background: 'rgba(0,0,0,0.2)',
borderRadius: 6,
overflow: 'hidden',
},
resultItem: {
padding: '6px 12px',
borderBottom: '1px solid rgba(255,255,255,0.05)',
fontSize: 13,
color: '#ce93d8',
},
table: { fontSize: 12 },
tableHeader: {
display: 'grid',
gridTemplateColumns: '1fr 0.7fr 1fr 1.3fr',
gap: 8,
padding: '8px 0',
borderBottom: '1px solid rgba(255,215,0,0.3)',
fontWeight: 'bold',
color: '#ffd700',
},
tableRow: {
display: 'grid',
gridTemplateColumns: '1fr 0.7fr 1fr 1.3fr',
gap: 8,
padding: '6px 0',
borderBottom: '1px solid rgba(255,255,255,0.05)',
color: '#ccc',
},
};
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. Kiedy warto użyć Context API zamiast przekazywania propsów (props drilling)?
2. Co się stanie, gdy jeden duży kontekst przechowuje pozycję statku (aktualizowaną 60x/s) i poziom paliwa, a komponent FuelGauge odczytuje tylko paliwo?
To 2 z 5 pytań do tej lekcji. Pozostałe rozwiążesz w grze.
Zadania praktyczne w grze
- Edytor kodu
Stwórz trzy osobne konteksty (FuelContext, PositionContext, CrewContext) z własnymi providerami. Skomponuj je razem w ShipProviders. Wyświetl dane z każdego kontekstu w osobnych komponentach.
- Klikanie w kolejności
Ułóż kroki tworzenia custom hooka dla bezpiecznego dostępu do kontekstu:
- Układanie w pionie
Uporządkuj etapy budowy systemu rozdzielonych kontekstów od zewnątrz do wewnątrz:
- Edytor kodu
Zaimplementuj custom hook useFuelContext z walidacją dostępności kontekstu. Stwórz FuelProvider i komponent FuelPanel korzystający z hooka.
Zadania po tej lekcji
- PytanieContext API vs props drilling
- PytaniePułapka re-renderów w Context API
- Zadanie z kodemPraktyka: Rozdzielone konteksty
- PytanieRozdzielanie kontekstów
- Kliknij w kolejnościTworzenie custom hooka dla kontekstu
- Ułóż w kolejnościKompozycja providerów
- Zadanie z kodemPraktyka: Custom hook z walidacją kontekstu
- PytanieKiedy NIE używać Context API
- PytanieDebugowanie złożonych przepływów stanu