Kurs JavaScript i React · Moduł 8: Zaawansowane wzorce React
Wzorce projektowe i reużywalność logiki
W tej lekcji5
W kosmicznej podróży przez świat Reacta, efektywne wykorzystanie zasobów jest kluczowe dla sukcesu misji. Podobnie jak inżynierowie kosmiczni używają sprawdzonych projektów dla różnych modułów statku kosmicznego, tak i my możemy korzystać z wzorców projektowych w React, aby maksymalizować reużywalność kodu i tworzyć bardziej skalowalne aplikacje.
Wzorce renderowania i kompozycji
1. Komponenty wysokiego rzędu (HOC)
Higher-Order Components (HOC) to funkcje, które przyjmują komponent i zwracają nowy, wzbogacony komponent. To wzorzec oparty na zasadzie kompozycji, a nie dziedziczenia.
// Prosty HOC dodający funkcjonalność śledzenia czasu
function withTimer(WrappedComponent) {
return function WithTimer(props) {
const [startTime] = useState(Date.now());
const [currentTime, setCurrentTime] = useState(Date.now());
useEffect(() => {
const timer = setInterval(() => {
setCurrentTime(Date.now());
}, 1000);
return () => clearInterval(timer);
}, []);
const elapsedTime = (currentTime - startTime) / 1000;
return (
<WrappedComponent
{...props}
elapsedTime={elapsedTime}
/>
);
};
}
// Użycie HOC
function MissionControl({ missionName, elapsedTime }) {
return (
<div className="mission-control">
<h2>Misja: {missionName}</h2>
<p>Czas trwania: {elapsedTime.toFixed(0)} sekund</p>
{/* reszta komponentu */}
</div>
);
}
const MissionControlWithTimer = withTimer(MissionControl);
// Renderowanie wzbogaconego komponentu
function App() {
return <MissionControlWithTimer missionName="Apollo" />;
}2. Render Props
Render Props to wzorzec, w którym komponent otrzymuje funkcję, która mówi mu, co ma renderować. Dzięki temu logika może być współdzielona między komponentami.
function MouseTracker({ render }) {
const [position, setPosition] = useState({ x: 0, y: 0 });
useEffect(() => {
function handleMouseMove(event) {
setPosition({
x: event.clientX,
y: event.clientY
});
}
window.addEventListener('mousemove', handleMouseMove);
return () => {
window.removeEventListener('mousemove', handleMouseMove);
};
}, []);
return render(position);
}
// Użycie render props
function App() {
return (
<MouseTracker
render={({ x, y }) => (
<div className="space-map">
<h2>Mapa gwiezdna</h2>
<p>Współrzędne kursora: ({x}, {y})</p>
<div
className="space-ship"
style={{
position: 'absolute',
left: x,
top: y
}}
>
▲
</div>
</div>
)}
/>
);
}3. Wzorzec Compound Components
Ten wzorzec pozwala tworzyć komponenty, które współpracują ze sobą, zachowując elastyczność i czytelność kodu.
function Spaceship({ children }) {
const [power, setPower] = useState(0);
const [shields, setShields] = useState(false);
const contextValue = {
power,
setPower,
shields,
setShields
};
return (
<SpaceshipContext.Provider value={contextValue}>
<div className="spaceship">
{children}
</div>
</SpaceshipContext.Provider>
);
}
// Komponenty potomne
Spaceship.Engine = function Engine() {
const { power, setPower } = useContext(SpaceshipContext);
return (
<div className="engine">
<h3>Silnik</h3>
<p>Moc: {power}%</p>
<input
type="range"
min="0"
max="100"
value={power}
onChange={e => setPower(Number(e.target.value))}
/>
</div>
);
};
Spaceship.Shields = function Shields() {
const { shields, setShields } = useContext(SpaceshipContext);
return (
<div className="shields">
<h3>Tarcze</h3>
<button onClick={() => setShields(!shields)}>
{shields ? 'Dezaktywuj' : 'Aktywuj'} tarcze
</button>
<p>Status: {shields ? 'Aktywne' : 'Nieaktywne'}</p>
</div>
);
};
// Użycie
function App() {
return (
<Spaceship>
<h2>Panel kontrolny statku kosmicznego</h2>
<Spaceship.Engine />
<Spaceship.Shields />
</Spaceship>
);
}Wzorce zarządzania stanem
1. Flux / Redux
Redux implementuje wzorzec Flux, który zakłada jednokierunkowy przepływ danych. Stan aplikacji jest przechowywany w jednym obiekcie (store), a modyfikacje stanu mogą nastąpić tylko przez emisję akcji, które są przetwarzane przez reduktory.
// Akcje
const ADD_CREWMEMBER = 'ADD_CREWMEMBER';
const REMOVE_CREWMEMBER = 'REMOVE_CREWMEMBER';
// Action creators
function addCrewmember(member) {
return {
type: ADD_CREWMEMBER,
payload: member
};
}
function removeCrewmember(id) {
return {
type: REMOVE_CREWMEMBER,
payload: id
};
}
// Reduktor
function crewReducer(state = [], action) {
switch (action.type) {
case ADD_CREWMEMBER:
return [...state, action.payload];
case REMOVE_CREWMEMBER:
return state.filter(member => member.id !== action.payload);
default:
return state;
}
}
// W komponencie z react-redux
function CrewManagement() {
const crew = useSelector(state => state.crew);
const dispatch = useDispatch();
function handleAddCrewmember() {
const newMember = {
id: Date.now(),
name: 'Nowy członek załogi',
role: 'Kadet'
};
dispatch(addCrewmember(newMember));
}
return (
<div>
<h2>Zarządzanie załogą</h2>
<button onClick={handleAddCrewmember}>Dodaj członka załogi</button>
<ul>
{crew.map(member => (
<li key={member.id}>
{member.name} - {member.role}
<button onClick={() => dispatch(removeCrewmember(member.id))}>
Usuń
</button>
</li>
))}
</ul>
</div>
);
}2. Context API
Context API pozwala na przekazywanie danych przez drzewo komponentów bez konieczności przekazywania props na każdym poziomie.
// Stworzenie kontekstu
const MissionContext = createContext();
// Provider
function MissionProvider({ children }) {
const [mission, setMission] = useState({
name: 'Apollo 11',
status: 'W trakcie',
crewMembers: [
{ id: 1, name: 'Neil Armstrong', role: 'Dowódca' },
{ id: 2, name: 'Buzz Aldrin', role: 'Pilot modułu księżycowego' },
{ id: 3, name: 'Michael Collins', role: 'Pilot modułu dowodzenia' }
]
});
function updateMissionStatus(newStatus) {
setMission(prev => ({ ...prev, status: newStatus }));
}
function addCrewMember(member) {
setMission(prev => ({
...prev,
crewMembers: [...prev.crewMembers, member]
}));
}
const value = {
mission,
updateMissionStatus,
addCrewMember
};
return (
<MissionContext.Provider value={value}>
{children}
</MissionContext.Provider>
);
}
// Custom hook dla łatwiejszego użycia
function useMission() {
const context = useContext(MissionContext);
if (!context) {
throw new Error('useMission must be used within a MissionProvider');
}
return context;
}
// Użycie w komponentach
function MissionDashboard() {
const { mission } = useMission();
return (
<div>
<h1>Misja: {mission.name}</h1>
<p>Status: {mission.status}</p>
</div>
);
}
function MissionControl() {
const { updateMissionStatus } = useMission();
return (
<div>
<h2>Centrum kontroli misji</h2>
<button onClick={() => updateMissionStatus('Zakończona pomyślnie')}>
Zakończ misję
</button>
<button onClick={() => updateMissionStatus('Przerwana')}>
Przerwij misję
</button>
</div>
);
}
function CrewList() {
const { mission, addCrewMember } = useMission();
return (
<div>
<h2>Załoga misji</h2>
<ul>
{mission.crewMembers.map(member => (
<li key={member.id}>
{member.name} - {member.role}
</li>
))}
</ul>
<button
onClick={() =>
addCrewMember({
id: Date.now(),
name: 'Nowy astronauta',
role: 'Specjalista misji'
})
}
>
Dodaj członka załogi
</button>
</div>
);
}
// Połączenie wszystkiego
function App() {
return (
<MissionProvider>
<div className="mission-app">
<MissionDashboard />
<MissionControl />
<CrewList />
</div>
</MissionProvider>
);
}3. Custom hooks dla stanu
Jak widzieliśmy w poprzednim module, custom hooki są potężnym narzędziem do enkapsulacji i ponownego wykorzystania logiki związanej ze stanem.
function useSpaceshipSystems() {
const [engines, setEngines] = useState({
mainEngine: { power: 0, status: 'offline' },
leftThruster: { power: 0, status: 'offline' },
rightThruster: { power: 0, status: 'offline' }
});
const [lifeSupportSystem, setLifeSupportSystem] = useState({
oxygen: 100,
temperature: 21,
pressure: 1
});
function startEngine(engineName) {
setEngines(prev => ({
...prev,
[engineName]: {
...prev[engineName],
status: 'online',
power: 10
}
}));
}
function setEnginePower(engineName, power) {
if (engines[engineName].status === 'offline') {
console.warn(`Nie można ustawić mocy - silnik ${engineName} jest wyłączony`);
return;
}
setEngines(prev => ({
...prev,
[engineName]: {
...prev[engineName],
power: Math.max(0, Math.min(100, power))
}
}));
}
function stopEngine(engineName) {
setEngines(prev => ({
...prev,
[engineName]: {
...prev[engineName],
status: 'offline',
power: 0
}
}));
}
function adjustLifeSupport({ oxygen, temperature, pressure }) {
setLifeSupportSystem(prev => ({
...prev,
...(oxygen !== undefined ? { oxygen } : {}),
...(temperature !== undefined ? { temperature } : {}),
...(pressure !== undefined ? { pressure } : {})
}));
}
return {
engines,
lifeSupportSystem,
startEngine,
setEnginePower,
stopEngine,
adjustLifeSupport
};
}
// Użycie
function SpaceshipControls() {
const {
engines,
lifeSupportSystem,
startEngine,
setEnginePower,
stopEngine,
adjustLifeSupport
} = useSpaceshipSystems();
return (
<div className="spaceship-controls">
<h2>Kontrola systemów statku</h2>
<div className="engines-section">
<h3>Silniki</h3>
{Object.entries(engines).map(([name, engine]) => (
<div key={name} className="engine-control">
<h4>{formatEngineName(name)}</h4>
<p>Status: {engine.status}</p>
<p>Moc: {engine.power}%</p>
{engine.status === 'offline' ? (
<button onClick={() => startEngine(name)}>Start</button>
) : (
<>
<input
type="range"
min="0"
max="100"
value={engine.power}
onChange={e => setEnginePower(name, Number(e.target.value))}
/>
<button onClick={() => stopEngine(name)}>Stop</button>
</>
)}
</div>
))}
</div>
<div className="life-support">
<h3>System podtrzymywania życia</h3>
<p>Poziom tlenu: {lifeSupportSystem.oxygen}%</p>
<p>Temperatura: {lifeSupportSystem.temperature}°C</p>
<p>Ciśnienie: {lifeSupportSystem.pressure} atm</p>
<div className="controls">
<button
onClick={() =>
adjustLifeSupport({
oxygen: lifeSupportSystem.oxygen + 5
})
}
>
Zwiększ poziom tlenu
</button>
<button
onClick={() =>
adjustLifeSupport({
temperature: lifeSupportSystem.temperature - 1
})
}
>
Obniż temperaturę
</button>
</div>
</div>
</div>
);
}
function formatEngineName(name) {
return name
.replace(/([A-Z])/g, ' $1')
.replace(/^./, str => str.toUpperCase());
}Wzorce komponentów UI
1. Container / Presentational Pattern
Ten wzorzec rozdziela logikę biznesową (kontener) od prezentacji (komponent prezentacyjny), co zwiększa reużywalność komponentów i ułatwia testowanie.
// Komponent kontenerowy - zajmuje się logiką i pobieraniem danych
function PlanetDataContainer({ planetId, children }) {
const [planet, setPlanet] = useState(null);
const [loading, setLoading] = useState(true);
const [error, setError] = useState(null);
useEffect(() => {
setLoading(true);
fetch(`https://api.planets.com/${planetId}`)
.then(response => {
if (!response.ok) throw new Error('Nie udało się pobrać danych planety');
return response.json();
})
.then(data => {
setPlanet(data);
setLoading(false);
})
.catch(err => {
setError(err.message);
setLoading(false);
});
}, [planetId]);
// Wywołanie funkcji children z danymi
return children({ planet, loading, error });
}
// Komponent prezentacyjny - zajmuje się tylko wyświetlaniem
function PlanetInfo({ planet, loading, error }) {
if (loading) return <div>Ładowanie danych planety...</div>;
if (error) return <div>Błąd: {error}</div>;
if (!planet) return null;
return (
<div className="planet-info">
<h2>{planet.name}</h2>
<div className="planet-details">
<p>Typ: {planet.type}</p>
<p>Średnica: {planet.diameter} km</p>
<p>Odległość od Słońca: {planet.distanceFromSun} mln km</p>
<p>Okres orbitalny: {planet.orbitalPeriod} dni</p>
<p>Temperatura powierzchni: {planet.surfaceTemperature}°C</p>
</div>
{planet.moons && planet.moons.length > 0 && (
<div className="moons">
<h3>Księżyce ({planet.moons.length}):</h3>
<ul>
{planet.moons.map(moon => (
<li key={moon.id}>{moon.name}</li>
))}
</ul>
</div>
)}
</div>
);
}
// Użycie
function SolarSystemExplorer() {
const [selectedPlanet, setSelectedPlanet] = useState('earth');
return (
<div className="solar-system-explorer">
<h1>Eksploracja Układu Słonecznego</h1>
<div className="planet-selector">
<label>Wybierz planetę: </label>
<select
value={selectedPlanet}
onChange={e => setSelectedPlanet(e.target.value)}
>
<option value="mercury">Merkury</option>
<option value="venus">Wenus</option>
<option value="earth">Ziemia</option>
<option value="mars">Mars</option>
<option value="jupiter">Jowisz</option>
<option value="saturn">Saturn</option>
<option value="uranus">Uran</option>
<option value="neptune">Neptun</option>
</select>
</div>
<PlanetDataContainer planetId={selectedPlanet}>
{({ planet, loading, error }) => (
<PlanetInfo planet={planet} loading={loading} error={error} />
)}
</PlanetDataContainer>
</div>
);
}2. Composition vs Inheritance
React preferuje kompozycję nad dziedziczeniem. Ten wzorzec pozwala tworzyć elastyczne komponenty poprzez zagnieżdżanie i przekazywanie props.
// Komponent bazowy - Karta
function Card({ title, children, footer, className }) {
return (
<div className={`card ${className || ''}`}>
{title && <div className="card-header">{title}</div>}
<div className="card-body">{children}</div>
{footer && <div className="card-footer">{footer}</div>}
</div>
);
}
// Specjalizowane komponenty przy użyciu kompozycji
function MissionCard({ mission, onComplete }) {
return (
<Card
title={<h3>{mission.name}</h3>}
footer={
<button onClick={() => onComplete(mission.id)}>
Zakończ misję
</button>
}
className="mission-card"
>
<p><strong>Cel:</strong> {mission.objective}</p>
<p><strong>Status:</strong> {mission.status}</p>
<p><strong>Postęp:</strong> {mission.progress}%</p>
<div className="progress-bar">
<div
className="progress"
style={{ width: `${mission.progress}%` }}
/>
</div>
</Card>
);
}
function AstronautCard({ astronaut, onAssign }) {
return (
<Card
title={<h3>{astronaut.name}</h3>}
footer={
<button onClick={() => onAssign(astronaut.id)}>
Przydziel do misji
</button>
}
className="astronaut-card"
>
<div className="astronaut-info">
<img
src={astronaut.avatar}
alt={astronaut.name}
className="astronaut-avatar"
/>
<div>
<p><strong>Ranga:</strong> {astronaut.rank}</p>
<p><strong>Specjalizacja:</strong> {astronaut.specialization}</p>
<p><strong>Misje:</strong> {astronaut.missionCount}</p>
</div>
</div>
</Card>
);
}
// Użycie
function Dashboard() {
const missions = [
{ id: 1, name: 'Eksploracja Marsa', objective: 'Zbadać powierzchnię', status: 'W toku', progress: 65 },
{ id: 2, name: 'Stacja kosmiczna ISS', objective: 'Konserwacja modułów', status: 'Zaplanowana', progress: 0 }
];
const astronauts = [
{ id: 1, name: 'Jan Kowalski', rank: 'Kapitan', specialization: 'Pilot', missionCount: 5, avatar: '/avatars/jk.png' },
{ id: 2, name: 'Anna Nowak', rank: 'Porucznik', specialization: 'Inżynier', missionCount: 3, avatar: '/avatars/an.png' }
];
return (
<div className="dashboard">
<h1>Panel kontrolny centrum kosmicznego</h1>
<section className="missions-section">
<h2>Aktywne misje</h2>
<div className="missions-grid">
{missions.map(mission => (
<MissionCard
key={mission.id}
mission={mission}
onComplete={id => console.log(`Zakończono misję ${id}`)}
/>
))}
</div>
</section>
<section className="astronauts-section">
<h2>Dostępni astronauci</h2>
<div className="astronauts-grid">
{astronauts.map(astronaut => (
<AstronautCard
key={astronaut.id}
astronaut={astronaut}
onAssign={id => console.log(`Przydzielono astronautę ${id}`)}
/>
))}
</div>
</section>
</div>
);
}3. Wzorzec Headless Components
Ten wzorzec rozdziela logikę zachowania komponentu od jego wyglądu, pozwalając na maksymalną elastyczność stylistyczną.
// Komponent bezgłowy (Headless) - zawiera tylko logikę, bez UI
function useTabControl(initialTab = 0) {
const [activeTab, setActiveTab] = useState(initialTab);
function activateTab(index) {
setActiveTab(index);
}
return {
activeTab,
activateTab
};
}
// Użycie z dowolnym UI
function MissionTabs() {
const tabs = [
{ id: 'overview', label: 'Przegląd' },
{ id: 'crew', label: 'Załoga' },
{ id: 'timeline', label: 'Harmonogram' },
{ id: 'systems', label: 'Systemy' }
];
const { activeTab, activateTab } = useTabControl();
return (
<div className="mission-tabs">
<div className="tabs-header">
{tabs.map((tab, index) => (
<button
key={tab.id}
className={`tab-button ${activeTab === index ? 'active' : ''}`}
onClick={() => activateTab(index)}
>
{tab.label}
</button>
))}
</div>
<div className="tab-content">
{activeTab === 0 && (
<div className="overview-tab">
<h3>Przegląd misji</h3>
<p>Misja Apollo 11 była pierwszą załogową misją na Księżyc...</p>
</div>
)}
{activeTab === 1 && (
<div className="crew-tab">
<h3>Załoga</h3>
<ul>
<li>Neil Armstrong - Dowódca</li>
<li>Edwin "Buzz" Aldrin - Pilot modułu księżycowego</li>
<li>Michael Collins - Pilot modułu dowodzenia</li>
</ul>
</div>
)}
{activeTab === 2 && (
<div className="timeline-tab">
<h3>Harmonogram</h3>
<div className="timeline">
<div className="timeline-event">
<span className="date">16 lipca 1969</span>
<span className="description">Start z Przylądka Kennedy'ego</span>
</div>
<div className="timeline-event">
<span className="date">20 lipca 1969</span>
<span className="description">Lądowanie na Księżycu</span>
</div>
<div className="timeline-event">
<span className="date">21 lipca 1969</span>
<span className="description">Pierwszy krok na Księżycu</span>
</div>
<div className="timeline-event">
<span className="date">24 lipca 1969</span>
<span className="description">Powrót na Ziemię</span>
</div>
</div>
</div>
)}
{activeTab === 3 && (
<div className="systems-tab">
<h3>Systemy statku</h3>
<p>Moduł dowodzenia: Columbia</p>
<p>Moduł księżycowy: Eagle</p>
<p>Rakieta nośna: Saturn V</p>
</div>
)}
</div>
</div>
);
}Wzorce optymalizacyjne
1. Memoizacja
Memoizacja pomaga unikać niepotrzebnych renderowań przez zapamiętywanie rezultatów kosztownych obliczeń.
// Memoizacja komponentu
const MemoizedTelemetryChart = React.memo(function TelemetryChart({ data }) {
// Symulacja kosztownych obliczeń
const processedData = useMemo(() => {
console.log('Przetwarzanie danych telemetrycznych...');
// Kosztowne przetwarzanie danych
return data.map(point => ({
x: new Date(point.timestamp).toLocaleTimeString(),
y: calculateAverage(point.readings),
anomaly: detectAnomaly(point.readings)
}));
}, [data]); // Recalculate only when data changes
return (
<div className="telemetry-chart">
<h3>Wykres telemetrii</h3>
<div className="chart-container">
{/* Wykres z przetworzonymi danymi */}
{processedData.map((point, index) => (
<div
key={index}
className={`data-point ${point.anomaly ? 'anomaly' : ''}`}
style={{
height: `${point.y * 2}px`,
backgroundColor: point.anomaly ? 'red' : 'blue'
}}
title={`${point.x}: ${point.y} ${point.anomaly ? '(anomalia)' : ''}`}
/>
))}
</div>
</div>
);
}, (prevProps, nextProps) => {
// Własna logika porównania props
if (prevProps.data.length !== nextProps.data.length) {
return false; // renderuj ponownie jeśli zmienił się rozmiar danych
}
// Porównaj tylko ostatnie 5 punktów danych
const prevLastFive = prevProps.data.slice(-5);
const nextLastFive = nextProps.data.slice(-5);
for (let i = 0; i < 5; i++) {
if (!prevLastFive[i] || !nextLastFive[i]) continue;
if (
prevLastFive[i].timestamp !== nextLastFive[i].timestamp ||
!arraysEqual(prevLastFive[i].readings, nextLastFive[i].readings)
) {
return false; // renderuj ponownie jeśli dane się różnią
}
}
return true; // nie renderuj ponownie
});
// Funkcje pomocnicze
function calculateAverage(readings) {
return readings.reduce((sum, val) => sum + val, 0) / readings.length;
}
function detectAnomaly(readings) {
const avg = calculateAverage(readings);
const threshold = avg * 1.5;
return readings.some(val => val > threshold);
}
function arraysEqual(a, b) {
if (a.length !== b.length) return false;
for (let i = 0; i < a.length; i++) {
if (a[i] !== b[i]) return false;
}
return true;
}2. Wirtualizacja list
Dla dużych list danych, wirtualizacja pozwala renderować tylko te elementy, które są aktualnie widoczne na ekranie.
// Implementacja prostej wirtualizacji (w rzeczywistych aplikacjach
// warto użyć bibliotek jak react-window lub react-virtualized)
function VirtualizedAsteroidList({ asteroids, rowHeight = 50, visibleRows = 10 }) {
const [scrollTop, setScrollTop] = useState(0);
const containerRef = useRef();
const totalHeight = asteroids.length * rowHeight;
const startIndex = Math.floor(scrollTop / rowHeight);
const endIndex = Math.min(
startIndex + visibleRows + 1,
asteroids.length
);
const visibleAsteroids = useMemo(() => {
return asteroids.slice(startIndex, endIndex);
}, [asteroids, startIndex, endIndex]);
const handleScroll = useCallback(() => {
if (containerRef.current) {
setScrollTop(containerRef.current.scrollTop);
}
}, []);
return (
<div className="asteroids-list">
<h2>Katalog asteroid</h2>
<p>Liczba asteroid: {asteroids.length}</p>
<div
ref={containerRef}
className="virtual-list-container"
style={{ height: rowHeight * visibleRows, overflow: 'auto' }}
onScroll={handleScroll}
>
<div
className="total-height"
style={{ height: totalHeight }}
>
<div
className="visible-items"
style={{
transform: `translateY(${startIndex * rowHeight}px)`
}}
>
{visibleAsteroids.map(asteroid => (
<div
key={asteroid.id}
className="asteroid-item"
style={{ height: rowHeight }}
>
<span className="name">{asteroid.name}</span>
<span className="diameter">Średnica: {asteroid.diameter} km</span>
<span className="distance">
Odległość: {asteroid.distance} mln km
</span>
<span
className={`hazard-level ${asteroid.hazardLevel}`}
>
{formatHazardLevel(asteroid.hazardLevel)}
</span>
</div>
))}
</div>
</div>
</div>
</div>
);
}
function formatHazardLevel(level) {
switch (level) {
case 'high': return 'Wysokie zagrożenie';
case 'medium': return 'Średnie zagrożenie';
case 'low': return 'Niskie zagrożenie';
default: return 'Brak zagrożenia';
}
}3. Lazy loading
Leniwne ładowanie komponentów pozwala odroczyć ładowanie części aplikacji, dopóki nie są potrzebne, co może znacznie przyspieszyć inicjalne ładowanie aplikacji.
// Lazy loading komponentów
const LazyMarsExplorer = lazy(() => import('./MarsExplorer'));
const LazyJupiterMoons = lazy(() => import('./JupiterMoons'));
const LazySaturnRings = lazy(() => import('./SaturnRings'));
function SolarSystemExplorer() {
const [activeSection, setActiveSection] = useState(null);
return (
<div className="solar-system-explorer">
<h1>Eksploracja układu słonecznego</h1>
<div className="planet-selector">
<button onClick={() => setActiveSection('mars')}>
Eksploracja Marsa
</button>
<button onClick={() => setActiveSection('jupiter')}>
Księżyce Jowisza
</button>
<button onClick={() => setActiveSection('saturn')}>
Pierścienie Saturna
</button>
</div>
<Suspense fallback={<div className="loading">Ładowanie modułu eksploracji...</div>}>
{activeSection === 'mars' && <LazyMarsExplorer />}
{activeSection === 'jupiter' && <LazyJupiterMoons />}
{activeSection === 'saturn' && <LazySaturnRings />}
</Suspense>
</div>
);
}Podsumowanie
Wzorce projektowe w React dostarczają sprawdzonych rozwiązań dla typowych problemów programistycznych. Pozwalają na tworzenie kodu, który jest:
- Reużywalny - komponenty i logikę można łatwo wykorzystać w różnych częściach aplikacji
- Testowalny - separacja obowiązków ułatwia pisanie testów
- Skalowalny - aplikacja może rosnąć bez drastycznego wzrostu złożoności
- Łatwy w utrzymaniu - jasna struktura i organizacja ułatwiają wprowadzanie zmian
W kosmicznej podróży przez React, wzorce te są jak sprawdzone trasy międzygwiezdne, które pozwalają dotrzeć do celu szybciej i bezpieczniej. Eksperymentuj z różnymi wzorcami i wybieraj te, które najlepiej pasują do konkretnych potrzeb Twojej aplikacji.
Kod do tej lekcji: App.jsx
import React, { useState, useEffect, useCallback } from 'react';
// Custom Hook: useLocalStorage
function useLocalStorage(key, initialValue) {
// Stan do przechowywania wartości
const [storedValue, setStoredValue] = useState(() => {
try {
const item = window.localStorage.getItem(key);
return item ? JSON.parse(item) : initialValue;
} catch (error) {
console.log('Error reading localStorage:', error);
return initialValue;
}
});
// Funkcja do aktualizacji wartości
const setValue = useCallback((value) => {
setStoredValue((prev) => (value instanceof Function ? value(prev) : value));
}, []);
// Zapisz do localStorage przy każdej zmianie
useEffect(() => {
try {
window.localStorage.setItem(key, JSON.stringify(storedValue));
} catch (error) {
console.log('Error saving to localStorage:', error);
}
}, [key, storedValue]);
return [storedValue, setValue];
}
// Custom Hook: useToggle
function useToggle(initialValue = false) {
const [value, setValue] = useState(initialValue);
const toggle = useCallback(() => {
setValue(v => !v);
}, []);
const setTrue = useCallback(() => {
setValue(true);
}, []);
const setFalse = useCallback(() => {
setValue(false);
}, []);
return { value, toggle, setTrue, setFalse };
}
// Custom Hook: useCounter
function useCounter(initialValue = 0, step = 1) {
const [count, setCount] = useState(initialValue);
const increment = useCallback(() => {
setCount(c => c + step);
}, [step]);
const decrement = useCallback(() => {
setCount(c => c - step);
}, [step]);
const reset = useCallback(() => {
setCount(initialValue);
}, [initialValue]);
return { count, increment, decrement, reset, setCount };
}
// Demonstracja custom hooks
function CustomHooksDemo() {
// useLocalStorage - przechowywanie ustawień
const [username, setUsername] = useLocalStorage('username', '');
const [settings, setSettings] = useLocalStorage('settings', {
darkMode: true,
notifications: true,
language: 'pl'
});
// useToggle - przełączniki
const darkMode = useToggle(settings.darkMode);
const showPanel = useToggle(false);
const isEditing = useToggle(false);
// useCounter - liczniki
const visits = useCounter(0);
const score = useCounter(100, 10);
// Efekt synchronizacji z localStorage
useEffect(() => {
setSettings(prev => ({ ...prev, darkMode: darkMode.value }));
}, [darkMode.value, setSettings]);
const containerStyle = {
minHeight: '100vh',
background: darkMode.value
? 'linear-gradient(135deg, #1a1a2e 0%, #16213e 100%)'
: 'linear-gradient(135deg, #f5f7fa 0%, #c3cfe2 100%)',
padding: '30px',
fontFamily: "'Segoe UI', sans-serif",
color: darkMode.value ? '#fff' : '#1a1a2e',
transition: 'all 0.5s ease',
};
const cardStyle = {
background: darkMode.value ? 'rgba(255,255,255,0.05)' : 'rgba(0,0,0,0.05)',
borderRadius: '15px',
padding: '25px',
marginBottom: '25px',
border: '1px solid ' + (darkMode.value ? 'rgba(255,255,255,0.1)' : 'rgba(0,0,0,0.1)'),
};
return (
<div style={containerStyle}>
<header style={{ textAlign: 'center', marginBottom: '40px' }}>
<h1 style={{ color: '#00d4ff', fontSize: '2.5em' }}>
Custom Hooks Demo
</h1>
<p style={{ opacity: 0.7 }}>Tworzenie własnych hooków w React</p>
</header>
<div style={{ maxWidth: '900px', margin: '0 auto' }}>
{/* useLocalStorage Demo */}
<div style={cardStyle}>
<h2 style={{ color: '#ffd700', marginBottom: '20px' }}>
useLocalStorage
</h2>
<p style={{ marginBottom: '15px' }}>
Przechowuje dane w localStorage z automatyczną synchronizacją
</p>
<div style={{ marginBottom: '15px' }}>
<label style={{ display: 'block', marginBottom: '5px' }}>
Nazwa użytkownika (zapisana w localStorage):
</label>
<input
type="text"
value={username}
onChange={(e) => setUsername(e.target.value)}
placeholder="Wpisz swoją nazwę"
style={{
padding: '10px 15px',
borderRadius: '8px',
border: '2px solid #00d4ff',
background: 'transparent',
color: 'inherit',
width: '300px',
}}
/>
</div>
<p style={{ fontSize: '14px', opacity: 0.7 }}>
Odśwież stronę - wartość zostanie zachowana!
</p>
</div>
{/* useToggle Demo */}
<div style={cardStyle}>
<h2 style={{ color: '#ffd700', marginBottom: '20px' }}>
useToggle
</h2>
<div style={{ display: 'flex', gap: '20px', flexWrap: 'wrap' }}>
<div style={{ flex: '1', minWidth: '200px' }}>
<p style={{ marginBottom: '10px' }}>Dark Mode:</p>
<button
onClick={darkMode.toggle}
style={{
padding: '10px 20px',
background: darkMode.value ? '#4CAF50' : '#f44336',
color: 'white',
border: 'none',
borderRadius: '8px',
cursor: 'pointer',
}}
>
{darkMode.value ? 'ON' : 'OFF'}
</button>
</div>
<div style={{ flex: '1', minWidth: '200px' }}>
<p style={{ marginBottom: '10px' }}>Show Panel:</p>
<button
onClick={showPanel.toggle}
style={{
padding: '10px 20px',
background: showPanel.value ? '#4CAF50' : '#9e9e9e',
color: 'white',
border: 'none',
borderRadius: '8px',
cursor: 'pointer',
}}
>
{showPanel.value ? 'Ukryj' : 'Pokaż'}
</button>
{showPanel.value && (
<div style={{
marginTop: '15px',
padding: '15px',
background: 'rgba(0,212,255,0.1)',
borderRadius: '8px',
}}>
Panel widoczny!
</div>
)}
</div>
</div>
</div>
{/* useCounter Demo */}
<div style={cardStyle}>
<h2 style={{ color: '#ffd700', marginBottom: '20px' }}>
useCounter
</h2>
<div style={{ display: 'flex', gap: '40px', flexWrap: 'wrap' }}>
<div>
<p style={{ marginBottom: '10px' }}>Visits (step: 1):</p>
<div style={{ display: 'flex', alignItems: 'center', gap: '10px' }}>
<button onClick={visits.decrement} style={btnStyle}>-</button>
<span style={{ fontSize: '2em', minWidth: '60px', textAlign: 'center' }}>
{visits.count}
</span>
<button onClick={visits.increment} style={btnStyle}>+</button>
<button onClick={visits.reset} style={{ ...btnStyle, background: '#ff9800' }}>
Reset
</button>
</div>
</div>
<div>
<p style={{ marginBottom: '10px' }}>Score (step: 10):</p>
<div style={{ display: 'flex', alignItems: 'center', gap: '10px' }}>
<button onClick={score.decrement} style={btnStyle}>-10</button>
<span style={{ fontSize: '2em', minWidth: '80px', textAlign: 'center' }}>
{score.count}
</span>
<button onClick={score.increment} style={btnStyle}>+10</button>
<button onClick={score.reset} style={{ ...btnStyle, background: '#ff9800' }}>
Reset
</button>
</div>
</div>
</div>
</div>
</div>
<footer style={{ textAlign: 'center', marginTop: '40px', opacity: 0.7 }}>
<p>Custom hooks pozwalają na wydzielenie i współdzielenie logiki</p>
</footer>
</div>
);
}
const btnStyle = {
padding: '10px 20px',
background: '#00d4ff',
color: '#000',
border: 'none',
borderRadius: '8px',
cursor: 'pointer',
fontWeight: 'bold',
fontSize: '16px',
};
export default CustomHooksDemo;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. Które z poniższych jest zasadą korzystania z hooks?
2. Czym charakteryzuje się wzorzec Render Props?
To 2 z 4 pytań do tej lekcji. Pozostałe rozwiążesz w grze.
Zadania praktyczne w grze
- Edytor kodu
Custom hook dla stacji kosmicznej
- Układanie w poziomie
Ułóż składnię wywołania Higher-Order Component:
- Układanie w pionie
Uporządkuj strukturę custom hook:
- Edytor kodu
Zaawansowany data fetching hook
- Edytor kodu
HOC z autoryzacją i monitoringiem
- Klikanie w kolejności
Ułóż poprawną składnię Higher-Order Component:
- Edytor kodu
Render Props dla sieci sensorów
Zadania po tej lekcji
- PytanieWprowadzenie: Zasady hooków
- Zadanie z kodemPraktyka: Custom hook
- Ułóż w kolejnościWprowadzenie: Higher Order Components (HOC)
- Ułóż w kolejnościPrzepływ wzorców własnych hooków
- Zadanie z kodemPraktyka: useFetch hook
- PytanieWprowadzenie: Wzorzec Render Props
- PytanieWprowadzenie: Compound Components
- Zadanie z kodemWprowadzenie: Praktyka: Wzorzec HOC
- Kliknij w kolejnościWprowadzenie: Składnia HOC w React
- PytanieContainer vs Presentational
- Zadanie z kodemWprowadzenie: Praktyka: Render props