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

useReducer - zaawansowane zarządzanie stanem

6 min czytania ·
W tej lekcji8

W centrum dowodzenia statku kosmicznego, prosty panel z jednym przyciskiem to za mało. Gdy systemy pokładowe stają się coraz bardziej złożone - tarcze, silniki, systemy nawigacji, alarmy - potrzebujemy bardziej uporządkowanego sposobu zarządzania stanem. Hook useReducer to jak centralny komputer pokładowy, który przyjmuje rozkazy (akcje) i na ich podstawie aktualizuje stan wszystkich systemów według ściśle określonych reguł.

Czym jest useReducer?

useReducer to alternatywa dla useState, zaprojektowana do obsługi bardziej złożonej logiki stanu. Zamiast bezpośrednio ustawiać nową wartość, wysyłasz akcję (rozkaz), a specjalna funkcja zwana reducerem decyduje, jak stan powinien się zmienić.

Podstawowa składnia

const [state, dispatch] = useReducer(reducer, initialState);

Gdzie:

  • state - aktualny stan (dane systemów statku)
  • dispatch - funkcja do wysyłania akcji (wydawania rozkazów)
  • reducer - funkcja, która na podstawie bieżącego stanu i akcji zwraca nowy stan
  • initialState - początkowa wartość stanu

Analogia kosmiczna: Pomyśl o dispatch jako o panelu sterowania, na którym wciskasz przyciski (akcje). Komputer pokładowy (reducer) odbiera rozkaz i na podstawie aktualnego stanu statku oblicza nowy stan. Nigdy nie modyfikujesz systemów ręcznie - zawsze przez komputer!

Funkcja reducer

Reducer to czysta funkcja, która przyjmuje dwa argumenty: aktualny stan i akcję. Na ich podstawie zwraca nowy obiekt stanu. Najczęściej używamy instrukcji switch do obsługi różnych typów akcji:

function spaceshipReducer(state, action) {
  switch (action.type) {
    case 'ACTIVATE_SHIELDS':
      return { ...state, shields: 100, status: 'defended' };

    case 'FIRE_ENGINES':
      return { ...state, speed: state.speed + action.payload, fuel: state.fuel - 10 };

    case 'EMERGENCY_STOP':
      return { ...state, speed: 0, status: 'stopped' };

    default:
      return state;
  }
}

Kluczowe zasady reducera:

  • Zawsze zwracaj nowy obiekt stanu (nie mutuj poprzedniego)
  • Obsłuż default - zwracaj niezmieniony stan dla nieznanych akcji
  • Reducer powinien być czystą funkcją - bez side effects, bez losowości

Dispatch i obiekty akcji

Akcja to zwykły obiekt JavaScript z polem type opisującym rodzaj operacji. Opcjonalnie możesz dodać pole payload z dodatkowymi danymi:

// Prosta akcja - tylko typ
dispatch({ type: 'ACTIVATE_SHIELDS' });

// Akcja z danymi (payload)
dispatch({ type: 'FIRE_ENGINES', payload: 50 });

// Akcja ze złożonym payloadem
dispatch({
  type: 'ADD_CREW_MEMBER',
  payload: { name: 'Kapitan Nova', role: 'pilot' }
});

Praktyczny przykład - panel sterowania statkiem

Zobaczmy, jak useReducer sprawdza się w zarządzaniu złożonym stanem panelu kontrolnego:

import { useReducer } from 'react';

const initialShipState = {
  fuel: 100,
  shields: 0,
  speed: 0,
  status: 'docked',
  log: []
};

function shipReducer(state, action) {
  switch (action.type) {
    case 'LAUNCH':
      if (state.fuel < 20) return state;
      return {
        ...state,
        status: 'flying',
        fuel: state.fuel - 20,
        speed: 50,
        log: [...state.log, 'Statek wystartował']
      };

    case 'BOOST':
      if (state.status !== 'flying' || state.fuel < 10) return state;
      return {
        ...state,
        speed: state.speed + action.payload,
        fuel: state.fuel - 10,
        log: [...state.log, `Przyspieszono o ${action.payload} km/s`]
      };

    case 'TOGGLE_SHIELDS':
      return {
        ...state,
        shields: state.shields > 0 ? 0 : 100,
        log: [...state.log, state.shields > 0 ? 'Tarcze wyłączone' : 'Tarcze aktywowane']
      };

    case 'DOCK':
      return {
        ...state,
        status: 'docked',
        speed: 0,
        log: [...state.log, 'Statek zadokował']
      };

    case 'REFUEL':
      return {
        ...state,
        fuel: 100,
        log: [...state.log, 'Zatankowano paliwo']
      };

    default:
      return state;
  }
}

function ShipControlPanel() {
  const [ship, dispatch] = useReducer(shipReducer, initialShipState);

  return (
    <div className="control-panel">
      <h2>Panel sterowania</h2>
      <p>Status: {ship.status}</p>
      <p>Paliwo: {ship.fuel}%</p>
      <p>Tarcze: {ship.shields}%</p>
      <p>Prędkość: {ship.speed} km/s</p>

      <button onClick={() => dispatch({ type: 'LAUNCH' })}
        disabled={ship.status === 'flying'}>
        Start
      </button>
      <button onClick={() => dispatch({ type: 'BOOST', payload: 25 })}
        disabled={ship.status !== 'flying'}>
        Przyspiesz (+25)
      </button>
      <button onClick={() => dispatch({ type: 'TOGGLE_SHIELDS' })}>
        {ship.shields > 0 ? 'Wyłącz tarcze' : 'Włącz tarcze'}
      </button>
      <button onClick={() => dispatch({ type: 'DOCK' })}
        disabled={ship.status === 'docked'}>
        Dokuj
      </button>
      <button onClick={() => dispatch({ type: 'REFUEL' })}
        disabled={ship.status === 'flying'}>
        Zatankuj
      </button>

      <div className="ship-log">
        <h3>Dziennik pokładowy:</h3>
        <ul>
          {ship.log.map((entry, i) => (
            <li key={i}>{entry}</li>
          ))}
        </ul>
      </div>
    </div>
  );
}

Zwróć uwagę, jak reducer centralizuje całą logikę aktualizacji stanu. Komponent nie musi wiedzieć, jak dokładnie zmienia się stan - wystarczy, że wyśle odpowiednią akcję. To ogromna zaleta przy rozbudowanych interfejsach.

Kiedy useReducer zamiast useState?

Oba hooki służą do zarządzania stanem, ale mają różne zastosowania:

Wybierz useState gdy:

  • Stan jest prosty (liczba, string, boolean)
  • Logika aktualizacji jest prosta (bezpośrednie przypisanie)
  • Masz kilka niezależnych wartości

Wybierz useReducer gdy:

  • Stan jest złożonym obiektem z wieloma polami
  • Aktualizacja jednego pola wymaga zmiany innych pól
  • Masz wiele powiązanych akcji (np. start, stop, reset, boost)
  • Logika aktualizacji zawiera warunki (np. nie startuj bez paliwa)
  • Chcesz łatwo testować logikę stanu oddzielnie od komponentu
// useState - wystarczy dla prostych przypadków
const [isOpen, setIsOpen] = useState(false);
const [count, setCount] = useState(0);

// useReducer - lepszy dla złożonego stanu
const [shipState, dispatch] = useReducer(shipReducer, {
  fuel: 100,
  shields: 0,
  speed: 0,
  status: 'docked',
  crew: [],
  alerts: [],
  systems: { engine: 'online', navigation: 'online', weapons: 'offline' }
});

Wzorzec switch-case w reducerze

Instrukcja switch to standardowy wzorzec w reducerach. Oto kilka dobrych praktyk:

// Definiuj stałe dla typów akcji - unikasz literówek
const ACTIONS = {
  LAUNCH: 'LAUNCH',
  DOCK: 'DOCK',
  BOOST: 'BOOST',
  TAKE_DAMAGE: 'TAKE_DAMAGE',
  REPAIR: 'REPAIR'
};

function shipReducer(state, action) {
  switch (action.type) {
    case ACTIONS.LAUNCH:
      return { ...state, status: 'flying', speed: 50 };

    case ACTIONS.DOCK:
      return { ...state, status: 'docked', speed: 0 };

    case ACTIONS.BOOST:
      return {
        ...state,
        speed: Math.min(state.speed + action.payload, 300)
      };

    case ACTIONS.TAKE_DAMAGE: {
      const newShields = Math.max(0, state.shields - action.payload);
      return {
        ...state,
        shields: newShields,
        status: newShields === 0 ? 'critical' : state.status
      };
    }

    case ACTIONS.REPAIR:
      return { ...state, shields: 100, status: 'docked' };

    default:
      throw new Error(`Nieznana akcja: ${action.type}`);
  }
}

// Użycie ze stałymi
dispatch({ type: ACTIONS.BOOST, payload: 50 });
dispatch({ type: ACTIONS.TAKE_DAMAGE, payload: 30 });

Zauważ, że w TAKE_DAMAGE użyliśmy bloku {} wewnątrz case - to pozwala na deklarację zmiennych lokalnych (newShields) bez konfliktów z innymi case'ami. Dodatkowo, zamiast default: return state, rzucamy błąd - to pomaga wyłapać literówki w nazwach akcji podczas programowania.

Kreatory akcji (action creators)

Dla wygody i czytelności możesz tworzyć funkcje, które generują obiekty akcji:

// Kreatory akcji
const launch = () => ({ type: 'LAUNCH' });
const boost = (amount) => ({ type: 'BOOST', payload: amount });
const takeDamage = (amount) => ({ type: 'TAKE_DAMAGE', payload: amount });
const addCrewMember = (name, role) => ({
  type: 'ADD_CREW_MEMBER',
  payload: { name, role }
});

// Użycie - czytelniejsze niż ręczne tworzenie obiektów
dispatch(launch());
dispatch(boost(50));
dispatch(takeDamage(25));
dispatch(addCrewMember('Nova', 'pilot'));

Kreatory akcji zmniejszają ryzyko literówek i centralizują logikę tworzenia akcji w jednym miejscu.

Podsumowanie

useReducer to potężne narzędzie do zarządzania złożonym stanem w React:

  1. Składnia: const [state, dispatch] = useReducer(reducer, initialState)
  2. Reducer: czysta funkcja (state, action) => newState z wzorcem switch-case
  3. Dispatch: wysyłanie akcji dispatch({ type: 'ACTION', payload: data })
  4. Kiedy używać: złożony stan, powiązane aktualizacje, logika biznesowa w stanie
  5. Dobre praktyki: stałe dla typów akcji, kreatory akcji, bloki {} w case, rzucanie błędów w default

Tak jak centralny komputer pokładowy statku kosmicznego koordynuje pracę wszystkich systemów na podstawie rozkazów z mostka kapitańskiego, tak useReducer centralizuje logikę stanu, czyniąc ją przewidywalną i łatwą do zarządzania.

Kod do tej lekcji: App.jsx
import React, { useState, useMemo, useCallback, memo } from 'react';

// Komponent bez optymalizacji (dla porównania)
function UnoptimizedItem({ name, onSelect }) {
  console.log('Rendering UnoptimizedItem:', name);
  return (
    <div style={{
      padding: '10px',
      backgroundColor: '#ffebee',
      marginBottom: '5px',
      borderRadius: '4px'
    }}>
      {name}
      <button onClick={() => onSelect(name)} style={{ marginLeft: '10px' }}>Select</button>
    </div>
  );
}

// Komponent zoptymalizowany z React.memo
const OptimizedItem = memo(function OptimizedItem({ name, onSelect }) {
  console.log('Rendering OptimizedItem:', name);
  return (
    <div style={{
      padding: '10px',
      backgroundColor: '#e8f5e9',
      marginBottom: '5px',
      borderRadius: '4px'
    }}>
      {name}
      <button onClick={() => onSelect(name)} style={{ marginLeft: '10px' }}>Select</button>
    </div>
  );
});

// Ciężkie obliczenia (symulacja)
function expensiveCalculation(numbers) {
  console.log('Running expensive calculation...');
  let result = 0;
  for (let i = 0; i < 100000000; i++) {
    result += numbers.reduce((a, b) => a + b, 0);
  }
  return numbers.reduce((a, b) => a + b, 0);
}

function PerformanceDemo() {
  const [count, setCount] = useState(0);
  const [numbers] = useState([1, 2, 3, 4, 5]);
  const [selectedItem, setSelectedItem] = useState('');
  const [darkMode, setDarkMode] = useState(false);

  const items = ['Mars', 'Jowisz', 'Saturn', 'Uran', 'Neptun'];

  // Bez useMemo - obliczenie przy każdym renderze
  // const sum = expensiveCalculation(numbers);

  // Z useMemo - obliczenie tylko gdy zmieni się 'numbers'
  const sum = useMemo(() => {
    console.log('Computing sum with useMemo...');
    return numbers.reduce((a, b) => a + b, 0);
  }, [numbers]);

  // Bez useCallback - nowa funkcja przy każdym renderze
  // const handleSelect = (name) => setSelectedItem(name);

  // Z useCallback - stabilna referencja
  const handleSelect = useCallback((name) => {
    setSelectedItem(name);
  }, []);

  // Style zoptymalizowane z useMemo
  const containerStyle = useMemo(() => ({
    fontFamily: 'Arial, sans-serif',
    padding: '20px',
    maxWidth: '900px',
    margin: '0 auto',
    backgroundColor: darkMode ? '#1a1a2e' : '#f5f5f5',
    color: darkMode ? 'white' : '#333',
    minHeight: '100vh',
    transition: 'all 0.3s ease'
  }), [darkMode]);

  return (
    <div style={containerStyle}>
      <h1 style={{ textAlign: 'center', color: '#667eea' }}>Performance Optimization</h1>

      <div style={{
        display: 'flex',
        justifyContent: 'space-between',
        alignItems: 'center',
        marginBottom: '30px',
        padding: '15px',
        backgroundColor: darkMode ? '#252545' : '#fff',
        borderRadius: '12px'
      }}>
        <div>
          <button
            onClick={() => setCount(c => c + 1)}
            style={{
              padding: '10px 20px',
              backgroundColor: '#667eea',
              color: 'white',
              border: 'none',
              borderRadius: '8px',
              cursor: 'pointer',
              marginRight: '10px'
            }}
          >
            Count: {count}
          </button>
          <button
            onClick={() => setDarkMode(!darkMode)}
            style={{
              padding: '10px 20px',
              backgroundColor: darkMode ? '#fff' : '#333',
              color: darkMode ? '#333' : 'white',
              border: 'none',
              borderRadius: '8px',
              cursor: 'pointer'
            }}
          >
            {darkMode ? 'Light' : 'Dark'}
          </button>
        </div>
        <div>
          Selected: <strong>{selectedItem || 'None'}</strong>
        </div>
      </div>

      <div style={{ display: 'grid', gridTemplateColumns: '1fr 1fr', gap: '20px' }}>
        {/* useMemo Demo */}
        <section style={{
          padding: '20px',
          backgroundColor: darkMode ? '#252545' : '#fff',
          borderRadius: '12px'
        }}>
          <h2 style={{ color: '#4caf50' }}>useMemo</h2>
          <p>Suma tablicy: <strong>{sum}</strong></p>
          <p style={{ fontSize: '14px', color: '#888' }}>
            Obliczenia wykonywane tylko gdy zmieni się tablica 'numbers'.
            Kliknij "Count" - suma nie będzie przeliczana!
          </p>
          <pre style={{
            backgroundColor: darkMode ? '#1a1a2e' : '#f5f5f5',
            padding: '10px',
            borderRadius: '8px',
            fontSize: '12px',
            overflow: 'auto'
          }}>
{`const sum = useMemo(() => {
  return numbers.reduce((a, b) => a + b, 0);
}, [numbers]);`}
          </pre>
        </section>

        {/* React.memo Demo */}
        <section style={{
          padding: '20px',
          backgroundColor: darkMode ? '#252545' : '#fff',
          borderRadius: '12px'
        }}>
          <h2 style={{ color: '#2196f3' }}>React.memo + useCallback</h2>
          <p style={{ fontSize: '14px', color: '#888', marginBottom: '15px' }}>
            Sprawdź konsolę! Zoptymalizowane elementy nie renderują się przy zmianie count.
          </p>

          <h4>Bez optymalizacji:</h4>
          {items.slice(0, 2).map(item => (
            <UnoptimizedItem
              key={item}
              name={item}
              onSelect={(name) => setSelectedItem(name)}
            />
          ))}

          <h4 style={{ marginTop: '20px' }}>Z React.memo + useCallback:</h4>
          {items.slice(0, 2).map(item => (
            <OptimizedItem
              key={item}
              name={item}
              onSelect={handleSelect}
            />
          ))}
        </section>
      </div>

      <section style={{
        marginTop: '20px',
        padding: '20px',
        backgroundColor: darkMode ? '#252545' : '#fff',
        borderRadius: '12px'
      }}>
        <h2 style={{ color: '#ff9800' }}>Kiedy optymalizować?</h2>
        <ul style={{ lineHeight: '1.8' }}>
          <li><strong>useMemo:</strong> Kosztowne obliczenia, tworzenie obiektów/tablic</li>
          <li><strong>useCallback:</strong> Callbacki przekazywane do zoptymalizowanych dzieci</li>
          <li><strong>React.memo:</strong> Komponenty, które często się nie zmieniają</li>
          <li><strong>Uwaga:</strong> Nie optymalizuj przedwcześnie! Mierz najpierw.</li>
        </ul>
      </section>
    </div>
  );
}

export default PerformanceDemo;

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. Co zwraca hook useReducer?

Zadania praktyczne w grze

  • Klikanie w kolejności

    Zbuduj poprawną deklarację useReducer:

  • Edytor kodu

    Utwórz system stacji badawczej

  • Układanie w poziomie

    Ułóż poprawną strukturę obiektu akcji w useReducer:

  • Układanie w pionie

    Uporządkuj komponenty architektury aplikacji kosmicznej od najbardziej ogólnych do szczegółowych:

  • Edytor kodu

    Stwórz galaktyczny bank danych

  1. PytanieHook useReducer
  2. Kliknij w kolejnościSkładnia deklaracji useReducer
  3. Zadanie z kodemPraktyka: Wzorzec Provider
  4. Ułóż w kolejnościStruktura obiektu akcji
  5. Ułóż w kolejnościArchitektura aplikacji galaktycznej
  6. Zadanie z kodemPraktyka: Custom Provider

Przydatne artykuły