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

Optymalizacja Context API

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

Uż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. 1. Jak React.memo może pomóc w optymalizacji komponentów używających Context API?

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

  1. PytanieReact.memo
  2. Zadanie z kodemPraktyka: Optymalizacja re-renderów
  3. PytanieOptymalizacja Context API
  4. Zadanie z kodemPraktyka: Context z TypeScript
  5. PytaniePodział kontekstów
  6. PytanieObsługa błędów
  7. Zadanie z kodemPraktyka: Złożone reducery
  8. Ułóż w kolejnościKolejność zagnieżdżania Providerów
  9. Zadanie z kodemPraktyka: System zarządzania flotą
  10. Ułóż w kolejnościWywołanie dispatch z akcją
  11. Ułóż w kolejnościKiedy używać Context zamiast props
  12. Kliknij w kolejnościProvider setup
  13. Ułóż w kolejnościHierarchia kontekstów w aplikacji
  14. Ułóż w kolejnościHooki cyklu życia w Context API
  15. Kliknij w kolejnościWzorzec własnego hooka
  16. PytanieCustom hook dla Context API
  17. Ułóż w kolejnościTworzenie kontekstu
  18. Kliknij w kolejnościAction creators
  19. PytanieuseReducer vs useState
  20. Ułóż w kolejnościTworzenie kontekstu z createContext
  21. Ułóż w kolejnościTestowanie Context API
  22. Ułóż w kolejnościInicjalizacja useReducer
  23. PytanieMemoizacja wartości Provider
  24. PytanieAction creator w useReducer
  25. Ułóż w kolejnościStrategie migracji starszych systemów

Przydatne artykuły