Kurs JavaScript i React · Moduł 15: Wzorce i architektura

Inversion of Control w React - Elastyczne API komponentów

8 min czytania ·
W tej lekcji8

Komandor Nova chce kartę misji w trzech miejscach: na mostku z przyciskami akcji, w archiwum bez przycisków, ale ze stopką, a w raporcie z odnośnikiem do szczegółów. Pierwsza wersja karty dostaje więc kolejne flagi typu boolean i kolejne warunki w środku:

// Każdy nowy ekran dokłada flagę i kolejny warunek
function MissionCard({ mission, showActions, showFooter, compact }) {
  return (
    <div className={compact ? 'card card-compact' : 'card'}>
      <h3>{mission.name}</h3>
      {showActions && <button>Anuluj</button>}
      {showFooter && <span>Priorytet: {mission.priority}/10</span>}
    </div>
  );
}

Karta sama decyduje o wszystkim, więc każdy pomysł nowego ekranu oznacza zmianę jej kodu. Po miesiącu flag jest kilkanaście i nikt nie odważy się ich ruszyć. Na statku ten problem rozwiązano dawno temu: moduł ma standardowe gniazdo, a inżynier decyduje, czy podłączy do niego silnik plazmowy, czy napęd jonowy. W React ta zasada nazywa się Inversion of Control (IoC), czyli odwrócenie sterowania.

Czym jest Inversion of Control?

Inversion of Control polega na tym, że komponent oddaje konsumentowi, czyli komponentowi, który go renderuje, kontrolę nad swoim zachowaniem i wyglądem. Zamiast przewidywać każdy przypadek flagą, zostawia miejsca, które konsument wypełnia sam: propsy, sloty, render props i własne reguły stanu. Część tych narzędzi znasz już z lekcji o kompozycji. Teraz złożymy z nich elastyczne API, a na końcu ułożymy je od najmniejszego do największego oddania kontroli.

Slot Pattern - nazwane sloty

W lekcji o kompozycji karta miała tytuł i children. Teraz dostaje trzy nazwane sloty: header, actions i footer. Każdy z nich to zwykły prop, w którym przekazujesz gotowy element JSX:

function SpaceCard({ header, footer, actions, children }) {
  return (
    <div className="space-card">
      {header && <div className="card-header">{header}</div>}
      <div className="card-body">{children}</div>
      {actions && <div className="card-actions">{actions}</div>}
      {footer && <div className="card-footer">{footer}</div>}
    </div>
  );
}

Zapis {header && ...} renderuje ramkę slotu tylko wtedy, gdy konsument coś do niego przekazał, więc karta bez stopki nie zostawia pustego paska. children działa dokładnie tak jak wcześniej. Tak wypełnia sloty przebudowana MissionCard z mostka:

function MissionCard({ mission }) {
  return (
    <SpaceCard
      header={<h3>{mission.name}</h3>}
      actions={
        <>
          <button>Szczegóły</button>
          <button>Anuluj</button>
        </>
      }
      footer={<span>Priorytet: {mission.priority}/10</span>}
    >
      <p>Odległość: {mission.distance} l.ś.</p>
    </SpaceCard>
  );
}

Jeden slot może przyjąć kilka elementów: fragment <>...</> pakuje oba przyciski w jedną wartość. Archiwum użyje tej samej karty bez actions, a SpaceCard nie dostanie ani jednej nowej flagi.

Komponent polimorficzny - prop as

Przycisk akcji i odnośnik do raportu mają wyglądać tak samo, ale w HTML to różne elementy: akcję wykonuje <button>, a pod adres prowadzi <a>. Zamiast pisać dwa komponenty z tymi samymi stylami, pozwól konsumentowi wybrać element propem as:

function SpaceButton({ as: Component = 'button', children, ...props }) {
  return <Component {...props}>{children}</Component>;
}

Zapis as: Component = 'button' odczytuje prop as, nazywa go Component i nadaje mu wartość domyślną 'button'. Wielka litera jest konieczna: JSX traktuje nazwy pisane małą literą jak znaczniki HTML, więc zapis <as> nie zadziała. Pozostałe propsy, na przykład href czy onClick, trafiają do props i przechodzą dalej bez zmian. Pełna wersja dokłada wariant i liczy klasy w zmiennej cls:

function SpaceButton({ as: Component = 'button', variant = 'primary', children, ...props }) {
  const cls = `space-btn btn-${variant}`;
  return (
    <Component className={cls} {...props}>
      {children}
    </Component>
  );
}

{...props} stoi po className, więc konsument może w razie potrzeby nadpisać nawet klasę. W React 19 także ref jest zwykłym propem, więc dotrze do elementu razem z resztą, bez forwardRef. Pozostaje użycie. Link z biblioteki React Router przyjmuje adres w propie to, a nie href:

function MissionToolbar({ onStart }) {
  return (
    <nav>
      <SpaceButton onClick={onStart}>Start</SpaceButton>
      <SpaceButton as="a" href="/reports">Raporty</SpaceButton>
      <SpaceButton as={Link} to="/missions" variant="danger">Lista misji</SpaceButton>
    </nav>
  );
}

Pierwszy renderuje <button>, drugi <a href>, a trzeci komponent Link, który sam wyrenderuje odnośnik. Wszystkie trzy dostają klasy z jednego miejsca, a SpaceButton nie wie, czym zostanie. Używaj as, żeby wybrać właściwą semantykę, a nie żeby ją obejść: <SpaceButton as="div"> wygląda jak przycisk, ale nie dostaje fokusu i nie reaguje na Enter.

Wstrzykiwanie komponentu - renderItem

Lista misji na mostku pokazuje same nazwy, a ekran misji pełne karty. Gdyby MissionList importowała konkretną kartę, zostałaby przywiązana do jednego wyglądu. Zamiast tego konsument wstrzykuje sposób renderowania elementu: funkcję renderItem, czyli render prop znany Ci z lekcji o kompozycji:

function MissionList({ missions, renderItem, emptyState }) {
  if (missions.length === 0) {
    return emptyState || <p>Brak misji</p>;
  }
  return (
    <ul className="mission-list">
      {missions.map((mission, index) => (
        <li key={mission.id}>{renderItem(mission, index)}</li>
      ))}
    </ul>
  );
}

Lista nadal pilnuje tego, co wspólne: znacznika <ul>, klucza key i pustego stanu. O treści elementu decyduje konsument, a drugi argument, index, pozwala mu na przykład numerować misje. Gdy lista jest pusta, MissionList pokazuje slot emptyState albo domyślny tekst. Dwa ekrany, ta sama lista:

function BridgeScreen({ missions }) {
  return (
    <MissionList
      missions={missions}
      renderItem={(mission, index) => <span>{index + 1}. {mission.name}</span>}
    />
  );
}

function MissionsScreen({ missions }) {
  return (
    <MissionList
      missions={missions}
      renderItem={(mission) => <MissionCard mission={mission} />}
      emptyState={<p>Flota czeka na rozkazy.</p>}
    />
  );
}

Kod MissionList nie zmienił się ani o znak, a raz pokazuje ponumerowane nazwy, a raz pełne karty ze slotami. Nazwa component injection obejmuje też przekazanie samego komponentu: as={Link} z poprzedniej sekcji to właśnie wstrzyknięty komponent.

Props collection i prop getters

W poprzedniej lekcji getToggleProps() zwracał gotowy zestaw atrybutów. Ten pomysł ma dwie odmiany. Props collection to zwykły obiekt z propsami, który konsument rozkłada na swoim elemencie. Prop getter to funkcja, która zwraca taki obiekt, ale najpierw przyjmuje propsy konsumenta i łączy je z własnymi. Uproszczony useToggle pokazuje obie odmiany obok siebie:

function useToggle(initialState = false) {
  const [isOpen, setIsOpen] = useState(initialState);
  const toggle = () => setIsOpen((prev) => !prev);

  // props collection: gotowy obiekt
  const toggleProps = { onClick: toggle, 'aria-expanded': isOpen };

  // prop getter: funkcja, która łączy propsy konsumenta z naszymi
  const getToggleProps = ({ onClick, ...props } = {}) => ({
    ...props,
    'aria-expanded': isOpen,
    onClick: (event) => {
      onClick?.(event);
      toggle();
    },
  });

  return { isOpen, toggleProps, getToggleProps };
}

Różnica wychodzi na jaw, gdy konsument chce dodać własny onClick, na przykład wpis do dziennika. Przy <button {...toggleProps} onClick={log}> jego funkcja zastępuje naszą i panel przestaje się otwierać. Prop getter wywołuje obie: najpierw funkcję konsumenta, o ile ją podał (stąd onClick?.(event)), a potem toggle. Pozostałe propsy, takie jak className, przechodzą bez zmian:

function MissionReport({ onLog }) {
  const { isOpen, getToggleProps } = useToggle();

  return (
    <section>
      <button {...getToggleProps({ onClick: () => onLog('Raport przełączony') })}>
        Raport misji
      </button>
      {isOpen && <p>Wszystkie systemy działają.</p>}
    </section>
  );
}

Prop getters stosują biblioteki takie jak Downshift, a nazwy obu wzorców spopularyzował Kent C. Dodds. Dlatego polecam zwracać prop getters zamiast gotowych obiektów: kosztują kilka linijek więcej, a konsument nie zepsuje działania ani dostępności, dokładając własny onClick.

State Reducer - konsument zmienia reguły

Najdalej idzie State Reducer. Komponent ma domyślną logikę stanu, ale konsument może podmienić reguły przejść bez kopiowania kodu komponentu. Weźmy śluzę statku. Domyślnie reaguje na dwie akcje, OPEN i CLOSE, a opisuje je reducer, czyli funkcja, która ze stanu i akcji liczy nowy stan:

function airlockReducer(isOpen, action) {
  switch (action.type) {
    case 'OPEN': return true;
    case 'CLOSE': return false;
    default: return isOpen;
  }
}

Hook przyjmuje reducer w opcjach, a gdy konsument go nie poda, używa domyślnego. Stanem zarządza useReducer, a dispatch wysyła do reducera akcję:

function useAirlock({ reducer = airlockReducer } = {}) {
  const [isOpen, dispatch] = useReducer(reducer, false);
  const open = () => dispatch({ type: 'OPEN' });
  const close = () => dispatch({ type: 'CLOSE' });
  return { isOpen, open, close };
}

Wartość domyślna = {} pozwala wywołać useAirlock() bez argumentów. Teraz konsument dokłada własną regułę: dopóki statek nie zadokuje, śluza się nie otworzy:

function DockingBay({ docked }) {
  const airlock = useAirlock({
    reducer: (isOpen, action) => {
      if (action.type === 'OPEN' && !docked) {
        return isOpen; // w próżni śluza zostaje zamknięta
      }
      return airlockReducer(isOpen, action);
    },
  });

  return (
    <button onClick={airlock.isOpen ? airlock.close : airlock.open}>
      {airlock.isOpen ? 'Zamknij śluzę' : 'Otwórz śluzę'}
    </button>
  );
}

Konsument przechwytuje tylko jedną akcję, a resztę oddaje domyślnemu airlockReducer, więc useAirlock nie zmienił się wcale. Reducer musi pozostać czystą funkcją: bez window.confirm, zapytań do API i modyfikowania obiektów, bo w trybie deweloperskim, pod <StrictMode>, React wywołuje go dwa razy.

Który wzorzec wybrać?

Każda z tych technik odpowiada na inną potrzebę konsumenta:

SytuacjaPodejście
Ta sama struktura, różna zawartość częściSlot Pattern
Różne elementy HTML lub komponenty routeraKomponent polimorficzny (as)
Różny wygląd elementów listyWstrzykiwanie komponentu (renderItem)
Gotowe atrybuty i handlery do rozłożenia na elemencieProps collection, a lepiej prop getter
Inne reguły zmiany stanuState Reducer

Poziomy kontroli

Te same techniki można ułożyć według tego, ile kontroli oddajesz konsumentowi:

  1. Props: najmniej IoC, komponent dostaje dane i sam decyduje, jak je wyświetlić.
  2. Sloty i children: konsument decyduje o zawartości wybranych miejsc.
  3. Render props i component injection: konsument decyduje o całym renderowaniu elementu.
  4. State reducer: najwięcej IoC, konsument zmienia nawet logikę stanu.

Im wyżej na tej liście, tym komponent elastyczniejszy, ale też trudniejszy w użyciu i w opisaniu. Jak na mostku: za mało przełączników nie pozwala pilotowi zareagować na niespodziankę, a za dużo spowalnia go przy każdym manewrze. Moja rada: zaczynaj od najniższego poziomu, który rozwiązuje problem, i wspinaj się wyżej dopiero wtedy, gdy konsument naprawdę potrzebuje więcej. W następnej lekcji oddasz kontrolę jeszcze dalej: zespół będzie włączał i wyłączał całe funkcje flagami, bez wdrażania nowego kodu.

Pamiętaj: komponent z odwróconym sterowaniem to gniazdo na statku, które daje złącze, a o tym, co do niego podłączyć, decyduje konsument.

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

// === SLOT PATTERN (nazwane sloty): SpaceCard ===
function SpaceCard({ header, footer, actions, children }) {
  return (
    <div className="space-card">
      {header && <div className="card-header">{header}</div>}
      <div className="card-body">{children}</div>
      {actions && <div className="card-actions">{actions}</div>}
      {footer && <div className="card-footer">{footer}</div>}
    </div>
  );
}

// === KOMPONENT POLIMORFICZNY: SpaceButton z propem "as" ===
function SpaceButton({ as: Component = 'button', variant = 'primary', children, ...props }) {
  const cls = `space-btn btn-${variant}`;
  return (
    <Component className={cls} {...props}>
      {children}
    </Component>
  );
}

// === WSTRZYKIWANIE KOMPONENTU: MissionList z renderItem i emptyState ===
function MissionList({ missions, renderItem, emptyState }) {
  if (missions.length === 0) {
    return emptyState || <p className="empty">Brak misji</p>;
  }
  return (
    <ul className="mission-list">
      {missions.map((mission, index) => (
        <li key={mission.id}>{renderItem(mission, index)}</li>
      ))}
    </ul>
  );
}

// Karta misji wypełnia sloty SpaceCard
function MissionCard({ mission, onCancel }) {
  const [showStatus, setShowStatus] = useState(false);
  return (
    <SpaceCard
      header={<h4>{mission.name}</h4>}
      actions={
        <>
          <SpaceButton aria-expanded={showStatus} onClick={() => setShowStatus((s) => !s)}>Szczegóły</SpaceButton>
          <SpaceButton variant="danger" onClick={onCancel}>Anuluj</SpaceButton>
        </>
      }
      footer={<span className="meta">Priorytet: {mission.priority}/10</span>}
    >
      <p>Odległość: {mission.distance} l.ś.</p>
      {showStatus && <p>Status: {STATUS_LABELS[mission.status]}</p>}
    </SpaceCard>
  );
}

// === PROPS COLLECTION I PROP GETTER: useToggle ===
function useToggle(initialState = false) {
  const [isOpen, setIsOpen] = useState(initialState);
  const toggle = () => setIsOpen((prev) => !prev);

  // props collection: gotowy obiekt
  const toggleProps = { onClick: toggle, 'aria-expanded': isOpen };

  // prop getter: łączy propsy konsumenta z naszymi
  const getToggleProps = ({ onClick, ...props } = {}) => ({
    ...props,
    'aria-expanded': isOpen,
    onClick: (event) => {
      onClick?.(event);
      toggle();
    },
  });

  return { isOpen, toggleProps, getToggleProps };
}

// === STATE REDUCER: śluza z domyślnymi regułami ===
function airlockReducer(isOpen, action) {
  switch (action.type) {
    case 'OPEN': return true;
    case 'CLOSE': return false;
    default: return isOpen;
  }
}

function useAirlock({ reducer = airlockReducer } = {}) {
  const [isOpen, dispatch] = useReducer(reducer, false);
  const open = () => dispatch({ type: 'OPEN' });
  const close = () => dispatch({ type: 'CLOSE' });
  return { isOpen, open, close };
}

// === ETYKIETY I DANE ===
// Statusy zostają w danych po angielsku (z nich powstają klasy CSS), a na ekranie widać polskie etykiety
const STATUS_LABELS = { active: 'W toku', completed: 'Ukończona' };

const INITIAL_MISSIONS = [
  { id: 1, name: 'Wyprawa na Alfa Centauri', distance: '4,37', status: 'active', priority: 9 },
  { id: 2, name: 'Patrol przy Syriuszu', distance: '8,6', status: 'completed', priority: 5 },
  { id: 3, name: 'Badanie układu Tau Ceti', distance: '11,9', status: 'active', priority: 8 },
];

// === GŁÓWNY KOMPONENT ===
export default function App() {
  const [updatedAt, setUpdatedAt] = useState('teraz');
  const [lastTag, setLastTag] = useState(null);
  const [view, setView] = useState('compact');
  const [missions, setMissions] = useState(INITIAL_MISSIONS);
  const [notes, setNotes] = useState(0);
  const [docked, setDocked] = useState(false);
  const report = useToggle();
  const airlock = useAirlock({
    // reguła konsumenta: bez dokowania akcja OPEN niczego nie zmienia
    reducer: (isOpen, action) => {
      if (action.type === 'OPEN' && !docked) return isOpen;
      return airlockReducer(isOpen, action);
    },
  });

  const showTag = (e) => {
    e.preventDefault();
    setLastTag(e.currentTarget.tagName.toLowerCase());
  };
  const addNote = () => setNotes((n) => n + 1);
  const cancelMission = (id) => setMissions((prev) => prev.filter((m) => m.id !== id));

  return (
    <div className="app">
      <h1>Demo: Inversion of Control</h1>
      <p className="subtitle">Sloty, prop as, renderItem, prop getter i state reducer</p>

      <section className="section">
        <h3>Sloty (SpaceCard)</h3>
        <SpaceCard
          header={<h4>Stan statku</h4>}
          actions={<SpaceButton onClick={() => setUpdatedAt(new Date().toLocaleTimeString('pl-PL'))}>Odśwież</SpaceButton>}
          footer={<span className="meta">Ostatnia aktualizacja: {updatedAt}</span>}
        >
          <p>Paliwo: 87% | Prędkość: 14,2 tys. km/s</p>
        </SpaceCard>
        <SpaceCard header={<h4>Archiwum</h4>}>
          <p>Bez slotów actions i footer karta nie rysuje pustych pasków.</p>
        </SpaceCard>
      </section>

      <section className="section">
        <h3>Komponent polimorficzny (prop as)</h3>
        <div className="btn-row">
          <SpaceButton onClick={showTag}>Przycisk</SpaceButton>
          <SpaceButton as="a" href="#raporty" onClick={showTag}>Odnośnik</SpaceButton>
          <SpaceButton as="a" href="#archiwum" variant="danger" onClick={showTag}>Odnośnik (danger)</SpaceButton>
        </div>
        <p className="meta">Kliknięty element: {lastTag ? '<' + lastTag + '>' : 'jeszcze żaden'}</p>
      </section>

      <section className="section">
        <h3>Wstrzykiwanie komponentu (renderItem)</h3>
        <p className="hint">W widoku szczegółowym Anuluj usuwa misję. Usuń wszystkie, a zobaczysz slot emptyState.</p>
        <div className="toggle-row">
          <button className={'chip ' + (view === 'compact' ? 'active' : '')} aria-pressed={view === 'compact'} onClick={() => setView('compact')}>Kompaktowy</button>
          <button className={'chip ' + (view === 'detailed' ? 'active' : '')} aria-pressed={view === 'detailed'} onClick={() => setView('detailed')}>Szczegółowy</button>
        </div>
        <MissionList
          missions={missions}
          renderItem={view === 'compact'
            ? (mission, index) => (
                <div className="compact-item">
                  <span>{index + 1}. {mission.name}</span>
                  <span className={'badge badge-' + mission.status}>{STATUS_LABELS[mission.status]}</span>
                </div>
              )
            : (mission) => <MissionCard mission={mission} onCancel={() => cancelMission(mission.id)} />
          }
          emptyState={
            <div className="empty">
              <p>Flota czeka na rozkazy.</p>
              <SpaceButton onClick={() => setMissions(INITIAL_MISSIONS)}>Przywróć misje</SpaceButton>
            </div>
          }
        />
      </section>

      <section className="section">
        <h3>Props collection a prop getter (useToggle)</h3>
        <p className="hint">Oba przyciski dostają onClick konsumenta, który dodaje wpis. Przy kolekcji zastępuje on onClick hooka, więc raport się nie przełącza. Getter wywołuje oba.</p>
        <div className="btn-row">
          <button className="chip" {...report.toggleProps} onClick={addNote}>Kolekcja + własny onClick</button>
          <button className="chip" {...report.getToggleProps({ onClick: addNote })}>Getter + własny onClick</button>
        </div>
        <p className="meta">Wpisy konsumenta: {notes} | Raport: {report.isOpen ? 'otwarty' : 'zamknięty'}</p>
        {report.isOpen && <p className="report">Raport misji: wszystkie systemy działają.</p>}
      </section>

      <section className="section">
        <h3>State Reducer (useAirlock)</h3>
        <label className="check">
          <input type="checkbox" checked={docked} onChange={(e) => setDocked(e.target.checked)} />
          Statek zadokowany
        </label>
        <div className="btn-row">
          <SpaceButton onClick={airlock.open}>Otwórz śluzę</SpaceButton>
          <SpaceButton variant="danger" onClick={airlock.close}>Zamknij śluzę</SpaceButton>
        </div>
        <p className="meta">Śluza: {airlock.isOpen ? 'otwarta' : 'zamknięta'}{docked ? '' : ' (bez dokowania reguła konsumenta ignoruje OPEN)'}</p>
      </section>
    </div>
  );
}

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. Na czym polega Inversion of Control (IoC) w kontekście komponentów React?

  2. 2. Co umożliwia prop 'as' w polymorphic components, np. <SpaceButton as="a" href="/link">?

Zadania praktyczne w grze

  • Edytor kodu

    Dokończ trzy komponenty, które oddają kontrolę konsumentowi. SpaceCard (Slot Pattern): ___BLANK1___ i ___BLANK2___ to warunki, dzięki którym <header> i <footer> pojawiają się tylko wtedy, gdy konsument podał prop header albo footer (tak jak już działa actions). SpaceButton (polymorphic): ___BLANK3___ to nazwa, pod którą zmieniamy prop as, żeby użyć jej w JSX jako elementu, a ___BLANK4___ przekazuje elementowi resztę propsów (onClick, href, to). MissionList (Component Injection): ___BLANK5___ to element pokazywany zamiast pustej listy (gdy go nie podano, zostaje domyślny komunikat), a ___BLANK6___ wywołuje funkcję renderItem z misją i jej indeksem.

  • Układanie w pionie

    Ułóż poziomy Inversion of Control w React od NAJMNIEJSZEGO do NAJWIĘKSZEGO oddania kontroli:

  • Układanie w poziomie

    Ułóż składnię definicji polymorphic component z prop 'as':

  1. Zadanie z kodemPraktyka: Slot Pattern i Component Injection
  2. PytanieDefinicja Inversion of Control
  3. PytaniePolymorphic prop as
  4. Ułóż w kolejnościPoziomy IoC w React
  5. Ułóż w kolejnościSkładnia polymorphic component

Przydatne artykuły