Kurs JavaScript i React · Moduł 4: Context API i useReducer

Context i useReducer w praktyce

5 min czytania ·
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 dispatch każ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. 1. Dlaczego funkcje reducer muszą być 'pure functions' i nie mutować stanu?

  2. 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

  1. PytanieImmutability w reducerach
  2. Ułóż w kolejnościOd useState do useReducer - progresja złożoności
  3. Ułóż w kolejnościStruktura switch w reducer
  4. Zadanie z kodemPraktyka: useContext hook
  5. Kliknij w kolejnościStruktura reducer'a
  6. Zadanie z kodemPraktyka: Kompozycja kontekstów
  7. PytanieLazy initialization

Przydatne artykuły