Kurs JavaScript i React · Moduł 4: Context API i useReducer
Optymalizacja Context API
W tej lekcji6
Centrum dowodzenia misji obsługuje setki sygnałów na sekundę. Gdyby każdy sygnał powodował restart wszystkich systemów - statek by nie dolecieł na orbitę. Podobnie działa React: gdy wartość kontekstu się zmienia, każdy komponent korzystający z tego kontekstu jest przerenderowywany. W małych aplikacjach to niewidoczne, ale w złożonych systemach może znacznie spowolnić działanie.
Problem: nadmierne renderowanie z kontekstem
Rozważmy prosty przykład. Mamy jeden kontekst przechowujący cały stan statku:
const ShipContext = createContext();
function ShipProvider({ children }) {
const [state, dispatch] = useReducer(shipReducer, {
status: 'docked',
fuel: 100,
crewCount: 5,
alerts: []
});
return (
<ShipContext.Provider value={{ state, dispatch }}>
{children}
</ShipContext.Provider>
);
}
function FuelGauge() {
const { state } = useContext(ShipContext);
console.log('FuelGauge renderuje się');
return <p>Paliwo: {state.fuel}%</p>;
}
function AlertBell() {
const { state } = useContext(ShipContext);
console.log('AlertBell renderuje się');
return <p>Alerty: {state.alerts.length}</p>;
}Gdy zmienia się alerts (np. nowy alert), FuelGauge też się rerenderuje - mimo że poziom paliwa się nie zmienił. Każda zmiana dowolnego pola w state wyzwala renderowanie wszystkich konsumentów kontekstu.
Rozwiązanie 1: Podział kontekstu na stan i dispatch
Najprostszą i najskuteczniejszą optymalizacją jest rozdzielenie kontekstu na dwa osobne: jeden dla stanu (który zmienia się często), drugi dla dispatch (który jest stały przez cały czas życia komponentu):
const ShipStateContext = createContext();
const ShipDispatchContext = createContext();
function ShipProvider({ children }) {
const [state, dispatch] = useReducer(shipReducer, initialState);
return (
<ShipDispatchContext.Provider value={dispatch}>
<ShipStateContext.Provider value={state}>
{children}
</ShipStateContext.Provider>
</ShipDispatchContext.Provider>
);
}
// Dedykowane hooki dla każdego kontekstu
function useShipState() {
return useContext(ShipStateContext);
}
function useShipDispatch() {
return useContext(ShipDispatchContext);
}Dlaczego to działa? dispatch zwracany przez useReducer jest stabilną referencją - React gwarantuje, że nie zmienia się między renderowaniami. Komponenty, które tylko wysyłają akcje (i nie wyświetlają stanu), nie będą rerenderowane gdy stan się zmieni:
// Ten komponent rerenderuje się tylko gdy zmienia się stan
function FuelGauge() {
const state = useShipState();
return <p>Paliwo: {state.fuel}%</p>;
}
// Ten komponent NIE rerenderuje się gdy zmienia się stan statku
// (bo korzysta tylko z dispatch, a dispatch jest stabilny)
function LaunchButton() {
const dispatch = useShipDispatch();
return (
<button onClick={() => dispatch({ type: 'LAUNCH' })}>
Start
</button>
);
}Rozwiązanie 2: Podział na wiele wyspecjalizowanych kontekstów
Zamiast jednego kontekstu dla całego stanu, możemy tworzyć osobne konteksty dla różnych obszarów funkcjonalnych. Komponenty subskrybują tylko ten kontekst, który ich dotyczy:
// Osobny kontekst dla paliwa
const FuelContext = createContext();
function FuelProvider({ children }) {
const [fuel, setFuel] = useState(100);
const refuel = () => setFuel(100);
const consumeFuel = (amount) => setFuel(prev => Math.max(0, prev - amount));
return (
<FuelContext.Provider value={{ fuel, refuel, consumeFuel }}>
{children}
</FuelContext.Provider>
);
}
// Osobny kontekst dla alertów
const AlertContext = createContext();
function AlertProvider({ children }) {
const [alerts, setAlerts] = useState([]);
const addAlert = (msg) => setAlerts(prev => [...prev, { id: Date.now(), msg }]);
const dismissAlert = (id) => setAlerts(prev => prev.filter(a => a.id !== id));
return (
<AlertContext.Provider value={{ alerts, addAlert, dismissAlert }}>
{children}
</AlertContext.Provider>
);
}
// FuelGauge rerenderuje się tylko gdy zmienia się paliwo
function FuelGauge() {
const { fuel } = useContext(FuelContext);
return <p>Paliwo: {fuel}%</p>;
}
// AlertBell rerenderuje się tylko gdy zmieniają się alerty
function AlertBell() {
const { alerts } = useContext(AlertContext);
return <p>Alerty: {alerts.length}</p>;
}Rozwiązanie 3: React.memo dla komponentów potomnych
React.memo to HOC (Higher-Order Component), który opakowuje komponent i sprawia, że rerenderuje się tylko wtedy, gdy jego props się zmieniły. To szczególnie przydatne dla komponentów-dzieci providerów:
// Bez memo - rerenderuje się za każdym razem, gdy rodzic się rerenderuje
function CrewMember({ name, role }) {
console.log(`Renderuję: ${name}`);
return <li>{name} - {role}</li>;
}
// Z memo - rerenderuje się tylko gdy name lub role się zmienią
const CrewMemberOptimized = React.memo(function CrewMember({ name, role }) {
console.log(`Renderuję: ${name}`);
return <li>{name} - {role}</li>;
});
function CrewList() {
const { state } = useShipState();
return (
<ul>
{state.crew.map(member => (
// CrewMemberOptimized nie rerenderuje się gdy zmienia się paliwo lub status
<CrewMemberOptimized
key={member.id}
name={member.name}
role={member.role}
/>
))}
</ul>
);
}Kiedy Context, a kiedy props?
Nie każde dane powinny trafić do kontekstu. Oto praktyczny przewodnik decyzyjny:
Używaj Context gdy:
- Dane są potrzebne w wielu komponentach na różnych poziomach drzewa
- Unikasz przekazywania props przez więcej niż 2-3 poziomy (prop drilling)
- Dane zmieniają się rzadko lub dotyczą szerokiego kontekstu aplikacji (motyw, język, dane użytkownika)
// Dobre kandydaty do Context
const ThemeContext = createContext(); // motyw (ciemny/jasny)
const AuthContext = createContext(); // zalogowany użytkownik
const LanguageContext = createContext(); // język interfejsuUżywaj props gdy:
- Dane przepływają tylko przez 1-2 poziomy komponentów
- Komponent jest wielokrotnie używany w różnych kontekstach (reużywalny)
- Dane są specyficzne dla konkretnej sekcji UI
// Lepiej jako props - to dane specyficzne dla komponentu
function MissionCard({ mission, onSelect, isActive }) {
return (
<div className={isActive ? 'active' : ''} onClick={() => onSelect(mission)}>
<h3>{mission.name}</h3>
<p>{mission.status}</p>
</div>
);
}Praktyczna zasada
Zanim dodasz coś do kontekstu, zadaj sobie pytanie: "Czy naprawdę potrzebuję tego globalnie, czy to tylko prop drilling, który mogę rozwiązać lepszą strukturą komponentów?"
// Czasem problem prop drilling można rozwiązać przez composition
// zamiast Context:
// Zamiast przekazywać onSelectMission przez 3 poziomy...
function MissionControl() {
const [selected, setSelected] = useState(null);
return (
// Przekaż gotowy komponent jako children, zamiast funkcji jako prop
<MissionList
renderItem={(mission) => (
<MissionCard
mission={mission}
isActive={selected?.id === mission.id}
onSelect={setSelected}
/>
)}
/>
);
}Optymalizacja kontekstu to balans między wygodą a wydajnością. W większości aplikacji podstawowy podział na kontekst stanu i kontekst dispatch wystarczy. Bardziej zaawansowane techniki warto stosować, gdy faktycznie zaobserwujesz problemy z wydajnością.
Kod do tej lekcji: App.jsx
import React, { createContext, useContext, useReducer, memo } from 'react';
// --- Osobne konteksty dla stanu i dispatch ---
// Optymalizacja: komponenty które tylko dispatchują nie re-renderują się przy zmianie stanu
const StateContext = createContext();
const DispatchContext = createContext();
const initialState = {
ships: [
{ id: 1, name: 'Apollo VII', fuel: 80, active: true },
{ id: 2, name: 'Orion II', fuel: 45, active: false },
{ id: 3, name: 'Hermes', fuel: 100, active: true },
],
selectedId: null,
};
function reducer(state, action) {
switch (action.type) {
case 'SELECT_SHIP':
return { ...state, selectedId: action.id };
case 'REFUEL':
return {
...state,
ships: state.ships.map(s =>
s.id === action.id ? { ...s, fuel: Math.min(100, s.fuel + 20) } : s
),
};
case 'TOGGLE_ACTIVE':
return {
...state,
ships: state.ships.map(s =>
s.id === action.id ? { ...s, active: !s.active } : s
),
};
default:
return state;
}
}
function FleetProvider({ children }) {
const [state, dispatch] = useReducer(reducer, initialState);
return (
<StateContext.Provider value={state}>
<DispatchContext.Provider value={dispatch}>
{children}
</DispatchContext.Provider>
</StateContext.Provider>
);
}
// Hooki dostępu do kontekstów
function useFleetState() { return useContext(StateContext); }
function useFleetDispatch() { return useContext(DispatchContext); }
// --- Komponenty zoptymalizowane z React.memo ---
// Ten komponent re-renderuje się TYLKO gdy zmienia się konkretny statek
const ShipCard = memo(function ShipCard({ ship }) {
const dispatch = useFleetDispatch();
console.log(`[RENDER] ShipCard: ${ship.name}`);
return (
<div style={{ ...cardStyle, border: ship.active ? '1px solid #4fc3f7' : '1px solid #333' }}>
<div style={{ display: 'flex', justifyContent: 'space-between', alignItems: 'center' }}>
<span style={{ color: ship.active ? '#4fc3f7' : '#888', fontWeight: 'bold' }}>
{ship.name}
</span>
<span style={{ fontSize: 12, color: ship.active ? '#4caf50' : '#f44336' }}>
{ship.active ? '● AKTYWNY' : '○ NIEAKTYWNY'}
</span>
</div>
<div style={{ margin: '8px 0' }}>
<div style={{ fontSize: 12, color: '#adb5bd', marginBottom: 4 }}>
Paliwo: {ship.fuel}%
</div>
<div style={{ background: '#0a0e1a', borderRadius: 4, height: 8 }}>
<div style={{
width: `${ship.fuel}%`, height: '100%', borderRadius: 4,
background: ship.fuel > 50 ? '#4caf50' : ship.fuel > 25 ? '#ff9800' : '#f44336',
}} />
</div>
</div>
<div style={{ display: 'flex', gap: 6 }}>
<button onClick={() => dispatch({ type: 'REFUEL', id: ship.id })} style={btnStyle}>
Zatankuj +20%
</button>
<button onClick={() => dispatch({ type: 'TOGGLE_ACTIVE', id: ship.id })} style={btnStyle}>
{ship.active ? 'Dezaktywuj' : 'Aktywuj'}
</button>
</div>
</div>
);
});
// Ten komponent re-renderuje się przy każdej zmianie stanu (czyta cały state)
const FleetStats = memo(function FleetStats() {
const { ships } = useFleetState();
console.log('[RENDER] FleetStats');
const active = ships.filter(s => s.active).length;
const avgFuel = Math.round(ships.reduce((sum, s) => sum + s.fuel, 0) / ships.length);
return (
<div style={{ ...cardStyle, display: 'flex', gap: 20, justifyContent: 'center' }}>
<span style={{ color: '#adb5bd' }}>Aktywne: <b style={{ color: '#4fc3f7' }}>{active}/{ships.length}</b></span>
<span style={{ color: '#adb5bd' }}>Śr. paliwo: <b style={{ color: '#ffd700' }}>{avgFuel}%</b></span>
</div>
);
});
// Ten komponent tylko dispatchuje - NIE re-renderuje się przy zmianie stanu
const ResetButton = memo(function ResetButton() {
const dispatch = useFleetDispatch();
console.log('[RENDER] ResetButton - powinien renderować się tylko raz!');
return (
<button
onClick={() => dispatch({ type: 'RESET' })}
style={{ ...btnStyle, width: '100%', padding: '10px', marginTop: 8 }}
>
Reset floty
</button>
);
});
function ShipList() {
const { ships } = useFleetState();
console.log('[RENDER] ShipList');
return (
<div>
{ships.map(ship => (
<ShipCard key={ship.id} ship={ship} />
))}
</div>
);
}
export default function App() {
return (
<FleetProvider>
<div style={{ minHeight: '100vh', background: '#0a0e1a', padding: 24, fontFamily: 'Arial', color: 'white' }}>
<h1 style={{ textAlign: 'center', color: '#ffd700', marginBottom: 8 }}>
Optymalizacja Context API
</h1>
<p style={{ textAlign: 'center', color: '#778da9', marginBottom: 20, fontSize: 13 }}>
Otwórz konsolę (F12) aby zobaczyć które komponenty się re-renderują
</p>
<FleetStats />
<ShipList />
<ResetButton />
</div>
</FleetProvider>
);
}
const cardStyle = {
background: '#1a2035', borderRadius: 10, padding: 14,
marginBottom: 12, border: '1px solid rgba(255,255,255,0.1)',
};
const btnStyle = {
background: 'rgba(79,195,247,0.1)', color: '#4fc3f7',
border: '1px solid rgba(79,195,247,0.3)', borderRadius: 6,
padding: '5px 10px', cursor: 'pointer', fontSize: 12,
};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. Jak React.memo może pomóc w optymalizacji komponentów używających Context API?
2. Jak zapobiec niepotrzebnym re-renderom komponentów korzystających z Context API?
To 2 z 8 pytań do tej lekcji. Pozostałe rozwiążesz w grze.
Zadania praktyczne w grze
- Edytor kodu
Utwórz system uniwersytetu kosmicznego
- Edytor kodu
Implementuj laboratorium genetyczne
- Edytor kodu
Zbuduj galaktyczną sieć społecznościową
- Układanie w pionie
Uporządkuj zagnieżdżenie Providerów w typowej aplikacji React - od najzewnętrzniejszego:
- Edytor kodu
Zbuduj system Context API z useReducer dla zarządzania flotą: ThemeContext, FleetContext, dispatch actions i custom hooks
- Układanie w poziomie
Ułóż poprawne wywołanie dispatch z obiektem akcji:
- Układanie w pionie
Uporządkuj kiedy przejść z props na Context API - od najprostszego przypadku:
- Klikanie w kolejności
Uporządkuj kod Provider'a kosmicznego:
- Układanie w pionie
Uporządkuj Provider'y w hierarchii aplikacji kosmicznej:
- Układanie w pionie
Uporządkuj lifecycle events przy inicjalizacji kontekstu kosmicznego:
- Klikanie w kolejności
Uporządkuj custom hook dla kontekstu:
- Układanie w poziomie
Ułóż składnię tworzenia kontekstu w React:
- Klikanie w kolejności
Uporządkuj action creators kosmiczne:
- Układanie w poziomie
Ułóż składnię tworzenia nowego kontekstu z wartością domyślną:
- Układanie w pionie
Uporządkuj etapy testowania komponentów z Context API:
- Układanie w poziomie
Ułóż składnię inicjalizacji useReducer z reducerem i stanem początkowym:
- Układanie w pionie
Uporządkuj proces migracji starych systemów kosmicznych do Context API:
Zadania po tej lekcji
- PytanieReact.memo
- Zadanie z kodemPraktyka: Optymalizacja re-renderów
- PytanieOptymalizacja Context API
- Zadanie z kodemPraktyka: Context z TypeScript
- PytaniePodział kontekstów
- PytanieObsługa błędów
- Zadanie z kodemPraktyka: Złożone reducery
- Ułóż w kolejnościKolejność zagnieżdżania Providerów
- Zadanie z kodemPraktyka: System zarządzania flotą
- Ułóż w kolejnościWywołanie dispatch z akcją
- Ułóż w kolejnościKiedy używać Context zamiast props
- Kliknij w kolejnościProvider setup
- Ułóż w kolejnościHierarchia kontekstów w aplikacji
- Ułóż w kolejnościHooki cyklu życia w Context API
- Kliknij w kolejnościWzorzec własnego hooka
- PytanieCustom hook dla Context API
- Ułóż w kolejnościTworzenie kontekstu
- Kliknij w kolejnościAction creators
- PytanieuseReducer vs useState
- Ułóż w kolejnościTworzenie kontekstu z createContext
- Ułóż w kolejnościTestowanie Context API
- Ułóż w kolejnościInicjalizacja useReducer
- PytanieMemoizacja wartości Provider
- PytanieAction creator w useReducer
- Ułóż w kolejnościStrategie migracji starszych systemów