Kurs JavaScript i React · Moduł 2: Komponenty i props

Kompozycja komponentów

6 min czytania ·
W tej lekcji8

Stacja kosmiczna nie powstaje z jednego kawałka metalu - składa się z modułów, które są dokowane do siebie w przemyślany sposób. Moduł laboratoryjny łączy się z modułem mieszkalnym, a ten z modułem energetycznym. Każdy z nich może funkcjonować samodzielnie, ale dopiero razem tworzą funkcjonalną całość.

W React kompozycja komponentów działa na identycznej zasadzie. Zamiast budować jeden ogromny komponent, tworzymy mniejsze, wyspecjalizowane elementy i łączymy je ze sobą. To jeden z najważniejszych wzorców projektowych w React i klucz do tworzenia skalowalnych aplikacji.

Children - zawartość wewnętrzna komponentu

Najprostszą formą kompozycji jest użycie specjalnego propsa children. Każdy komponent React może przyjmować elementy zagnieżdżone między znacznikami otwierającym i zamykającym:

function SpaceModule({ title, children }) {
  return (
    <div className="space-module">
      <div className="module-header">
        <h3>{title}</h3>
        <span className="status-light" />
      </div>
      <div className="module-content">
        {children}
      </div>
    </div>
  );
}

// Użycie - "dokujemy" dowolną zawartość do modułu
function SpaceStation() {
  return (
    <div className="station">
      <SpaceModule title="Laboratorium">
        <p>Badania mikrograwitacji</p>
        <p>Eksperymenty biologiczne</p>
      </SpaceModule>

      <SpaceModule title="Centrum dowodzenia">
        <button>Nawigacja</button>
        <button>Komunikacja</button>
        <button>Systemy podtrzymywania życia</button>
      </SpaceModule>
    </div>
  );
}

Prop children pozwala tworzyć komponenty-kontenery, które nie wiedzą z góry, co będą wyświetlać. To jak budowanie uniwersalnych portów dokowania - mogą przyjąć dowolny moduł.

Wzorzec slotów - wiele punktów kompozycji

Czasami jeden children nie wystarczy. Potrzebujemy kilku "miejsc" w komponencie, gdzie możemy wstawić różne treści. W React realizujemy to przez przekazywanie komponentów jako zwykłych propsów:

function MissionPanel({ header, sidebar, content, footer }) {
  return (
    <div className="mission-panel">
      <div className="panel-header">{header}</div>
      <div className="panel-body">
        <aside className="panel-sidebar">{sidebar}</aside>
        <main className="panel-content">{content}</main>
      </div>
      <div className="panel-footer">{footer}</div>
    </div>
  );
}

// Każdy "slot" otrzymuje inny komponent
function MissionDashboard() {
  return (
    <MissionPanel
      header={<h1>Misja Apollo</h1>}
      sidebar={<NavigationMenu />}
      content={<MissionDetails missionId="apollo-11" />}
      footer={<StatusBar status="active" />}
    />
  );
}

Ten wzorzec daje ogromną elastyczność - komponent MissionPanel definiuje układ, ale nie narzuca treści.

Container/Presentational - podział odpowiedzialności

Jednym z klasycznych wzorców kompozycji jest rozdzielenie komponentów na dwa rodzaje:

  1. Container (kontener) - odpowiada za logikę: pobieranie danych, zarządzanie stanem, obsługę zdarzeń
  2. Presentational (prezentacyjny) - odpowiada wyłącznie za wygląd: renderuje otrzymane dane, nie zarządza stanem

Wyobraź sobie to jak podział pracy na stacji kosmicznej: komputer pokładowy (kontener) przetwarza dane i podejmuje decyzje, a panele wyświetlaczy (prezentacyjne) pokazują te informacje załodze.

// Komponent prezentacyjny - tylko wyświetla dane
function CrewList({ members, onSelectMember }) {
  return (
    <ul className="crew-list">
      {members.map(member => (
        <li key={member.id} onClick={() => onSelectMember(member.id)}>
          <span>{member.name}</span>
          <span className="role">{member.role}</span>
        </li>
      ))}
    </ul>
  );
}

// Komponent kontenerowy - zarządza danymi i logiką
function CrewListContainer() {
  const [members, setMembers] = useState([]);
  const [selectedId, setSelectedId] = useState(null);

  useEffect(() => {
    // Pobieranie danych załogi z API
    fetchCrewData().then(data => setMembers(data));
  }, []);

  const handleSelectMember = (id) => {
    setSelectedId(id);
    logActivity(`Wybrano członka załogi: ${id}`);
  };

  return (
    <CrewList
      members={members}
      onSelectMember={handleSelectMember}
    />
  );
}

Dzięki temu podziałowi komponent CrewList jest łatwy do przetestowania i wielokrotnego użycia - wystarczy przekazać mu inne dane.

Higher-Order Components (HOC)

Higher-Order Component to funkcja, która przyjmuje komponent i zwraca nowy, rozszerzony komponent. Nazwa pochodzi od "higher-order functions" w programowaniu funkcyjnym. HOC to jak moduł ulepszający na stacji kosmicznej - dokładasz go do istniejącego modułu i ten zyskuje nowe możliwości, bez zmiany swojego wnętrza.

// HOC dodający funkcję ładowania danych
function withMissionData(WrappedComponent) {
  return function EnhancedComponent(props) {
    const [data, setData] = useState(null);
    const [loading, setLoading] = useState(true);

    useEffect(() => {
      fetchMissionData(props.missionId)
        .then(result => {
          setData(result);
          setLoading(false);
        });
    }, [props.missionId]);

    if (loading) {
      return <div className="loading">Ładowanie danych misji...</div>;
    }

    return <WrappedComponent {...props} missionData={data} />;
  };
}

// Prosty komponent wyświetlający dane
function MissionDetails({ missionData }) {
  return (
    <div>
      <h2>{missionData.name}</h2>
      <p>Cel: {missionData.destination}</p>
    </div>
  );
}

// Rozszerzony komponent z automatycznym ładowaniem danych
const MissionDetailsWithData = withMissionData(MissionDetails);

// Użycie - dane zostaną automatycznie pobrane
<MissionDetailsWithData missionId="apollo-11" />

Konwencja nazewnicza HOC to prefiks with - withMissionData, withAuth, withLoading. Dzięki temu łatwo rozpoznać, że mamy do czynienia z komponentem rozszerzonym.

Render Props - przekazywanie funkcji renderującej

Wzorzec render props polega na przekazaniu komponentowi funkcji, która mówi mu, co ma renderować. To daje ogromną elastyczność - komponent zarządza logiką, a konsument decyduje o wyglądzie:

function OrbitTracker({ satelliteId, render }) {
  const [position, setPosition] = useState({ x: 0, y: 0, altitude: 400 });

  useEffect(() => {
    const interval = setInterval(() => {
      // Symulacja zmiany pozycji na orbicie
      setPosition(prev => ({
        x: prev.x + Math.random() * 2 - 1,
        y: prev.y + Math.random() * 2 - 1,
        altitude: 400 + Math.sin(Date.now() / 1000) * 10
      }));
    }, 1000);
    return () => clearInterval(interval);
  }, [satelliteId]);

  // Wywołuje funkcję renderującą z danymi
  return render(position);
}

// Użycie - decydujemy jak wyświetlić dane pozycji
function SatelliteMonitor() {
  return (
    <OrbitTracker
      satelliteId="iss"
      render={(position) => (
        <div className="monitor">
          <p>Pozycja X: {position.x.toFixed(2)}</p>
          <p>Pozycja Y: {position.y.toFixed(2)}</p>
          <p>Wysokość: {position.altitude.toFixed(1)} km</p>
        </div>
      )}
    />
  );
}

Od atomów do stron - kompozycja w większej skali

Tę samą zasadę opisuje metoda Atomic Design: interfejs składa się z coraz większych części. Najpierw atomy (Button, Input, Label), z nich molekuły (SearchBar = Input + Button), z molekuł organizmy (Header = Logo + SearchBar + Nav), potem szablony (układ strony bez treści) i na końcu strony (szablon wypełniony prawdziwymi danymi).

Kiedy dzielić komponent na mniejsze?

Najważniejszy sygnał: komponent odpowiada za kilka niezwiązanych ze sobą rzeczy naraz, na przykład nawigację, formularz i listę. Zasada pojedynczej odpowiedzialności (Single Responsibility Principle) mówi, że każdy komponent powinien odpowiadać za jeden fragment interfejsu - jak moduł stacji, który ma jedno zadanie. Sama liczba linii kodu czy props nie przesądza o podziale.

Duży komponent refaktoryzujesz w czterech krokach:

  1. Znajdź w JSX niezależne sekcje (np. nagłówek, lista załogi, panel systemów).
  2. Ustal, jakich danych (props) potrzebuje każda sekcja.
  3. Wydziel każdą sekcję do osobnego komponentu.
  4. Połącz nowe komponenty w komponencie nadrzędnym.

Małe komponenty łatwiej też testować. Test jednostkowy sprawdza jeden komponent w izolacji (np. czy CrewList wyświetla wszystkich członków załogi), a test integracyjny sprawdza, czy kilka komponentów działa razem (np. czy SpaceStation przekazuje dane do CrewList).

Kiedy stosować poszczególne wzorce?

WzorzecZastosowanie
childrenProste kontenery, layouty, karty, panele
Sloty (props)Złożone layouty z wieloma obszarami treści
Container/PresentationalOddzielenie logiki od prezentacji
HOCWspółdzielenie logiki między wieloma komponentami
Render PropsElastyczne renderowanie z dostępem do stanu

Współcześnie wiele przypadków użycia HOC i Render Props zostało zastąpionych przez custom hooks, które poznamy w kolejnych modułach. Jednak znajomość tych wzorców jest ważna, ponieważ spotkasz je w istniejących kodach i bibliotekach.

Kod do tej lekcji: App.jsx
import React from 'react';

// =============================================
// KOMPOZYCJA KOMPONENTÓW
// Wzorce: children, wrapper components, HOC
// =============================================

// --- WZORZEC 1: Wrapper / Container z children ---
// Card to komponent-kontener, który opakowuje dowolną zawartość
function Card({ title, children, color = '#667eea' }) {
  return (
    <div style={{
      border: `2px solid ${color}`,
      borderRadius: '12px',
      overflow: 'hidden',
      marginBottom: '20px',
      boxShadow: '0 4px 12px rgba(0,0,0,0.1)'
    }}>
      {title && (
        <div style={{
          padding: '12px 20px',
          backgroundColor: color,
          color: 'white',
          fontWeight: 'bold',
          fontSize: '16px'
        }}>
          {title}
        </div>
      )}
      <div style={{ padding: '20px' }}>
        {children}
      </div>
    </div>
  );
}

// Layout opakowuje całą stronę i zapewnia spójny wygląd
function Layout({ header, children, footer }) {
  return (
    <div style={{
      maxWidth: '800px',
      margin: '0 auto',
      minHeight: '100vh',
      display: 'flex',
      flexDirection: 'column',
      fontFamily: 'Arial, sans-serif'
    }}>
      <header style={{
        background: 'linear-gradient(135deg, #667eea 0%, #764ba2 100%)',
        padding: '24px',
        color: 'white',
        textAlign: 'center'
      }}>
        {header}
      </header>
      <main style={{ flex: 1, padding: '24px', backgroundColor: '#f8f9fa' }}>
        {children}
      </main>
      {footer && (
        <footer style={{
          padding: '16px',
          backgroundColor: '#1a1a2e',
          color: '#888',
          textAlign: 'center',
          fontSize: '14px'
        }}>
          {footer}
        </footer>
      )}
    </div>
  );
}

// --- WZORZEC 2: Higher-Order Component (HOC) ---
// HOC to funkcja, która przyjmuje komponent i zwraca nowy,
// wzbogacony komponent z dodatkową funkcjonalnością.

function withLogger(WrappedComponent, componentLabel) {
  return function LoggedComponent(props) {
    React.useEffect(() => {
      console.log(
        `[LOG] <${componentLabel}> zamontowany z props:`,
        props
      );
      return () => {
        console.log(`[LOG] <${componentLabel}> odmontowany`);
      };
    }, []);

    // Przekazujemy wszystkie oryginalne props + dodatkowe info
    return <WrappedComponent {...props} isLogged={true} />;
  };
}

// Zwykły komponent wyświetlający misję
function MissionBadge({ name, status, priority, isLogged }) {
  const statusColors = {
    active: '#4caf50',
    pending: '#ff9800',
    completed: '#2196f3'
  };

  return (
    <div style={{
      display: 'flex',
      alignItems: 'center',
      justifyContent: 'space-between',
      padding: '14px 18px',
      backgroundColor: 'white',
      borderRadius: '8px',
      marginBottom: '10px',
      boxShadow: '0 1px 3px rgba(0,0,0,0.1)'
    }}>
      <div>
        <strong style={{ fontSize: '16px' }}>{name}</strong>
        <div style={{ color: '#888', fontSize: '13px', marginTop: '4px' }}>
          Priorytet: {priority}
        </div>
      </div>
      <div style={{ display: 'flex', alignItems: 'center', gap: '8px' }}>
        {isLogged && (
          <span style={{
            fontSize: '11px',
            color: '#888',
            padding: '2px 6px',
            border: '1px solid #ddd',
            borderRadius: '4px'
          }}>
            LOGGED
          </span>
        )}
        <span style={{
          padding: '4px 12px',
          borderRadius: '12px',
          color: 'white',
          backgroundColor: statusColors[status] || '#999',
          fontSize: '12px',
          fontWeight: 'bold'
        }}>
          {status.toUpperCase()}
        </span>
      </div>
    </div>
  );
}

// Tworzymy ulepszoną wersję MissionBadge za pomocą HOC
const LoggedMissionBadge = withLogger(MissionBadge, 'MissionBadge');

// --- GŁÓWNA APLIKACJA ---
function App() {
  const missions = [
    { id: 1, name: 'Rekonesans Krateru Tycho', status: 'active', priority: 'Wysoki' },
    { id: 2, name: 'Naprawa paneli słonecznych', status: 'pending', priority: 'Średni' },
    { id: 3, name: 'Analiza próbek regolitu', status: 'completed', priority: 'Niski' },
  ];

  return (
    <Layout
      header={<h1 style={{ margin: 0 }}>Kompozycja Komponentów</h1>}
      footer="Panel misji kosmicznych - React Composition Patterns"
    >
      {/* Card opakowuje listę misji */}
      <Card title="Aktywne misje (z HOC withLogger)" color="#667eea">
        <p style={{ color: '#555', marginTop: 0 }}>
          Otwórz konsolę przeglądarki (F12) - zobaczysz logi z HOC
          przy montowaniu każdego komponentu.
        </p>
        {missions.map((m) => (
          <LoggedMissionBadge
            key={m.id}
            name={m.name}
            status={m.status}
            priority={m.priority}
          />
        ))}
      </Card>

      {/* Zagnieżdżone karty - kompozycja w kompozycji */}
      <Card title="Zagnieżdżona kompozycja" color="#764ba2">
        <p style={{ marginTop: 0 }}>
          Card może zawierać inne Card - to siła wzorca children:
        </p>
        <Card title="Wewnętrzna karta A" color="#4caf50">
          <p style={{ margin: 0 }}>Dowolna treść wewnątrz.</p>
        </Card>
        <Card title="Wewnętrzna karta B" color="#ff9800">
          <p style={{ margin: 0 }}>Kolejna zagnieżdżona karta.</p>
        </Card>
      </Card>
    </Layout>
  );
}

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ć props.children w komponencie React?

  2. 2. Jak React przekazuje elementy zagnieżdżone wewnątrz komponentu do jego implementacji?

Zadania praktyczne w grze

  • Układanie w pionie

    Ułóż etapy kompozycji komponentów od najprostszego poziomu do najbardziej złożonego:

  • Edytor kodu

    Stwórz komponent CompleteMoonBase składający się z LunarModule, CrewQuarters i CommandCenter.

  • Układanie w pionie

    Ułóż hierarchię komponentów od zewnętrznego do wewnętrznego:

  • Układanie w pionie

    Ułóż wzorzec kompozycji komponentów (Atomic Design):

  • Klikanie w kolejności

    Zbuduj poprawną składnię eksportu komponentu React:

  1. Ułóż w kolejnościKompozycja komponentów - od prostych do złożonych
  2. Zadanie z kodemPraktyka: Kompozycja komponentów
  3. Ułóż w kolejnościHierarchia zagnieżdżonych komponentów
  4. PytanieZastosowanie children prop
  5. Ułóż w kolejnościSortowanie pionowe: Wzorzec kompozycji komponentów
  6. PytanieKompozycja z props.children
  7. Kliknij w kolejnościEksport komponentu React

Przydatne artykuły