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

Wzorce zarządzania stanem

7 min czytania ·
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

CechaContext APIRedux ToolkitZustand
Rozmiar0 KB (wbudowany)~11 KB~1.5 KB
BoilerplateŚredniDuży (ale RTK pomaga)Minimalny
Re-renderyWszyscy konsumenciZoptymalizowane (selektory)Zoptymalizowane (selektory)
DevToolsBrak dedykowanychRozbudowane (time-travel)Rozszerzenie Redux DevTools
Krzywa naukiŁatwaStromaŁatwa
Najlepsze dlaTheme, auth, localeDuże aplikacje, duże zespołyWiększość aplikacji

Zasada wyboru narzędzia

Na Stacji Jupiter każdy system ma swoje przeznaczenie. Podobnie z zarządzaniem stanem:

  1. Stan lokalny (useState) - dane potrzebne tylko jednemu komponentowi lub jego bezpośrednim dzieciom
  2. Lifted state (stan podniesiony) - dane współdzielone przez 2-3 bliskie komponenty, przenieś do ich wspólnego rodzica
  3. Context API - dane globalne zmieniające się rzadko: theme, auth, locale, język
  4. Zustand - stan globalny w małych/średnich aplikacjach, gdy potrzebujesz wydajności i prostoty
  5. 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. 1. Kiedy warto użyć Context API zamiast przekazywania propsów (props drilling)?

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

  1. PytanieContext API vs props drilling
  2. PytaniePułapka re-renderów w Context API
  3. Zadanie z kodemPraktyka: Rozdzielone konteksty
  4. PytanieRozdzielanie kontekstów
  5. Kliknij w kolejnościTworzenie custom hooka dla kontekstu
  6. Ułóż w kolejnościKompozycja providerów
  7. Zadanie z kodemPraktyka: Custom hook z walidacją kontekstu
  8. PytanieKiedy NIE używać Context API
  9. PytanieDebugowanie złożonych przepływów stanu

Przydatne artykuły