Kurs JavaScript i React · Moduł 2: Komponenty i props
Kompozycja komponentów
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:
- Container (kontener) - odpowiada za logikę: pobieranie danych, zarządzanie stanem, obsługę zdarzeń
- 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:
- Znajdź w JSX niezależne sekcje (np. nagłówek, lista załogi, panel systemów).
- Ustal, jakich danych (props) potrzebuje każda sekcja.
- Wydziel każdą sekcję do osobnego komponentu.
- 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?
| Wzorzec | Zastosowanie |
|---|---|
children | Proste kontenery, layouty, karty, panele |
| Sloty (props) | Złożone layouty z wieloma obszarami treści |
| Container/Presentational | Oddzielenie logiki od prezentacji |
| HOC | Współdzielenie logiki między wieloma komponentami |
| Render Props | Elastyczne 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. Kiedy warto użyć props.children w komponencie React?
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:
Zadania po tej lekcji
- Ułóż w kolejnościKompozycja komponentów - od prostych do złożonych
- Zadanie z kodemPraktyka: Kompozycja komponentów
- Ułóż w kolejnościHierarchia zagnieżdżonych komponentów
- PytanieZastosowanie children prop
- Ułóż w kolejnościSortowanie pionowe: Wzorzec kompozycji komponentów
- PytanieKompozycja z props.children
- Kliknij w kolejnościEksport komponentu React