Kurs JavaScript i React · Moduł 6: React Router
Zagnieżdżone ścieżki w intergalaktycznej nawigacji
W tej lekcji9
W naszej kosmicznej podróży przez świat React Router, nadszedł czas na zgłębienie koncepcji zagnieżdżonych ścieżek. Podobnie jak w rzeczywistej przestrzeni kosmicznej, gdzie mamy galaktyki zawierające układy słoneczne, które z kolei zawierają planety z ich księżycami - w aplikacjach React możemy tworzyć hierarchiczne struktury nawigacyjne.
Czym są zagnieżdżone ścieżki?
Zagnieżdżone ścieżki to technika organizowania routingu w aplikacji, gdzie jedne ścieżki (komponenty) zawierają w sobie inne ścieżki (komponenty). Pozwala to na tworzenie bardziej intuicyjnych, hierarchicznych struktur nawigacyjnych, które odzwierciedlają logiczny układ aplikacji.
Zagnieżdżone ścieżki są szczególnie przydatne w większych aplikacjach, gdzie mamy wiele podsekcji z własnymi widokami.
Implementacja zagnieżdżonych ścieżek w React Router
W React Router v6 zagnieżdżone ścieżki implementuje się poprzez umieszczanie komponentów Route wewnątrz innych komponentów Route oraz używanie komponentu Outlet do określenia, gdzie mają być renderowane komponenty podścieżek.
Podstawowa struktura zagnieżdżonych ścieżek
import { BrowserRouter, Routes, Route, Outlet } from 'react-router-dom';
function App() {
return (
<BrowserRouter>
<Routes>
<Route path="/" element={<Layout />}>
<Route index element={<Home />} />
<Route path="galaxies" element={<GalaxiesList />} />
<Route path="galaxies/:galaxyId" element={<GalaxyLayout />}>
<Route index element={<GalaxyOverview />} />
<Route path="systems" element={<SolarSystemsList />} />
<Route path="systems/:systemId" element={<SolarSystemDetail />} />
</Route>
</Route>
</Routes>
</BrowserRouter>
);
}W powyższym przykładzie:
Layoutto główny komponent, który będzie zawierał wszystkie zagnieżdżone widokiGalaxyLayoutto komponent, który będzie służył jako "kontener" dla szczegółów galaktyki- Atrybut
indexokreśla, co ma być renderowane, gdy URL pasuje dokładnie do ścieżki rodzica
Komponent Outlet
Kluczowym elementem zagnieżdżonych ścieżek jest komponent Outlet, który działa jak "placeholder" dla komponentów potomnych. Określa on, gdzie w komponencie nadrzędnym mają być renderowane komponenty podścieżek:
import { Outlet, Link } from 'react-router-dom';
function Layout() {
return (
<div className="app-layout">
<header>
<h1>Kosmiczny Atlas</h1>
<nav>
<Link to="/">Strona główna</Link>
<Link to="/galaxies">Galaktyki</Link>
</nav>
</header>
<main>
{/* Tutaj będą renderowane komponenty podścieżek */}
<Outlet />
</main>
<footer>© 2150 Międzygalaktyczne Centrum Nawigacji</footer>
</div>
);
}
function GalaxyLayout() {
const { galaxyId } = useParams();
return (
<div className="galaxy-layout">
<h2>Galaktyka: {galaxyId}</h2>
<nav className="galaxy-navigation">
<Link to={`/galaxies/${galaxyId}`}>Przegląd</Link>
<Link to={`/galaxies/${galaxyId}/systems`}>Układy słoneczne</Link>
</nav>
<div className="galaxy-content">
{/* Tutaj będą renderowane komponenty podścieżek galaktyki */}
<Outlet />
</div>
</div>
);
}Względne i indeksowe ścieżki
React Router v6 wprowadził kilka użytecznych funkcji dla lepszej obsługi zagnieżdżonych ścieżek:
1. Ścieżki indeksowe (index routes)
Ścieżka indeksowa określa, co powinno być renderowane, gdy URL pasuje dokładnie do ścieżki nadrzędnej:
<Route path="galaxies" element={<GalaxiesLayout />}>
{/* To będzie renderowane dla /galaxies */}
<Route index element={<GalaxiesList />} />
{/* To będzie renderowane dla /galaxies/:galaxyId */}
<Route path=":galaxyId" element={<GalaxyDetails />} />
</Route>2. Względne linki
W komponentach zagnieżdżonych możemy używać względnych linków, które są rozwiązywane względem bieżącej ścieżki:
import { Link, useParams } from 'react-router-dom';
function GalaxySystemsList() {
const { galaxyId } = useParams();
return (
<div>
<h3>Układy słoneczne w galaktyce {galaxyId}</h3>
<ul>
{systems.map(system => (
<li key={system.id}>
{/* Względny link - zostanie rozwiązany do /galaxies/:galaxyId/systems/:systemId */}
<Link to={system.id}>{system.name}</Link>
</li>
))}
</ul>
{/* Względny link "w górę" - cofnij się o jeden poziom */}
<Link to="..">Powrót do przeglądu galaktyki</Link>
</div>
);
}Przekazywanie kontekstu między poziomami zagnieżdżenia
Jednym z wyzwań przy pracy z zagnieżdżonymi ścieżkami jest przekazywanie danych między różnymi poziomami zagnieżdżenia. React Router v6 oferuje kilka rozwiązań:
1. Hooki useOutletContext i useOutlet
Hook useOutletContext pozwala na przekazywanie danych z komponentu nadrzędnego do podrzędnego:
import { Outlet, useOutletContext, useParams } from 'react-router-dom';
function GalaxyLayout() {
const { galaxyId } = useParams();
const [galaxy, setGalaxy] = useState(null);
useEffect(() => {
// Pobierz dane galaktyki
fetchGalaxy(galaxyId).then(data => setGalaxy(data));
}, [galaxyId]);
// Przekaż dane galaktyki do komponentów potomnych
return (
<div className="galaxy-layout">
<h2>{galaxy?.name || 'Ładowanie...'}</h2>
<Outlet context={{ galaxy, updateGalaxy: setGalaxy }} />
</div>
);
}
function GalaxyOverview() {
// Odbierz kontekst z komponentu nadrzędnego
const { galaxy, updateGalaxy } = useOutletContext();
if (!galaxy) return <div>Ładowanie danych galaktyki...</div>;
return (
<div className="galaxy-overview">
<h3>Przegląd galaktyki {galaxy.name}</h3>
<p>Typ: {galaxy.type}</p>
<p>Liczba układów: {galaxy.systemsCount}</p>
{/* Reszta komponentu */}
</div>
);
}2. Wspólny stan z React Context
Dla bardziej złożonych scenariuszy można wykorzystać React Context do udostępniania stanu między komponentami:
import { createContext, useContext, useState } from 'react';
import { Outlet } from 'react-router-dom';
// Stwórz kontekst
const GalaxyContext = createContext();
// Hook do łatwego dostępu do kontekstu
function useGalaxy() {
return useContext(GalaxyContext);
}
function GalaxyProvider({ children }) {
const [selectedGalaxy, setSelectedGalaxy] = useState(null);
const [favoritesSystems, setFavoriteSystems] = useState([]);
const addFavoriteSystem = (system) => {
setFavoriteSystems(prev => [...prev, system]);
};
// Wartość kontekstu
const value = {
selectedGalaxy,
setSelectedGalaxy,
favoritesSystems,
addFavoriteSystem
};
return (
<GalaxyContext.Provider value={value}>
{children}
</GalaxyContext.Provider>
);
}
function GalaxiesRoot() {
return (
<GalaxyProvider>
<div className="galaxies-section">
<h2>Eksploracja Galaktyk</h2>
<Outlet />
</div>
</GalaxyProvider>
);
}
// Użycie w komponencie potomnym
function SolarSystemDetail() {
const { favoritesSystems, addFavoriteSystem } = useGalaxy();
const { systemId } = useParams();
// Reszta komponentu
}Zaawansowane wzorce zagnieżdżania ścieżek
Zagnieżdżone ścieżki mogą być wykorzystywane do implementacji różnych wzorców nawigacyjnych:
1. Layout wielopoziomowy
<Routes>
<Route path="/" element={<MainLayout />}>
<Route element={<AuthLayout />}>
<Route path="dashboard" element={<Dashboard />} />
<Route path="profile" element={<Profile />} />
<Route path="settings" element={<SettingsLayout />}>
<Route path="account" element={<AccountSettings />} />
<Route path="notifications" element={<NotificationSettings />} />
</Route>
</Route>
<Route path="about" element={<About />} />
<Route path="contact" element={<Contact />} />
</Route>
</Routes>W tym przykładzie:
MainLayoutzawiera ogólną strukturę stronyAuthLayoutobsługuje uwierzytelnianie dla chronionych ścieżekSettingsLayouttworzy dodatkowy poziom nawigacji dla ustawień
2. Dynamiczne segmenty i zagnieżdżenie
<Routes>
<Route path="galaxies" element={<GalaxiesList />} />
<Route path="galaxies/:galaxyId" element={<GalaxyLayout />}>
<Route index element={<GalaxyOverview />} />
<Route path="systems" element={<SystemsList />} />
<Route path="systems/:systemId" element={<SystemLayout />}>
<Route index element={<SystemOverview />} />
<Route path="planets" element={<PlanetsList />} />
<Route path="planets/:planetId" element={<PlanetDetails />} />
</Route>
</Route>
</Routes>Ta struktura tworzy głębokie zagnieżdżenie ścieżek, które odzwierciedla hierarchię galaktyka > układ słoneczny > planeta.
3. Wiele slotów w jednym layoucie
Panel dowodzenia galaktyki ma trzy strefy: nawigację po lewej, główny widok w środku i telemetrię po prawej. Jeśli znasz nazwane router-outlet z Angulara albo nazwane widoki z Vue Router, możesz szukać w React Router czegoś podobnego. Nazwanych outletów tu nie ma: Outlet przyjmuje tylko jeden prop, context, i renderuje komponent dopasowanej podścieżki (albo nic, gdy żadna nie pasuje). Gdybyś napisał <Outlet name="sidebar" />, React Router zignorowałby nieznany prop i wyrenderował w tym miejscu tę samą podścieżkę co główny Outlet.
Zamiast nazwanych slotów layout ma jeden Outlet na główny widok, a pozostałe strefy wypełniają zwykłe komponenty:
import { Outlet } from 'react-router-dom';
function DashboardLayout() {
return (
<div className="dashboard">
<aside className="sidebar">
{/* Zwykły komponent nawigacji bocznej */}
<MissionSidebar />
</aside>
<div className="main-content">
{/* Jedyny Outlet: tu trafia dopasowana podścieżka */}
<Outlet />
</div>
<aside className="auxiliary-panel">
{/* Zwykły komponent panelu pomocniczego */}
<AuxiliaryPanel />
</aside>
</div>
);
}Układ trzech stref się nie zmienił, zmieniło się tylko to, kto je wypełnia. Środek zależy od adresu, a panele boczne renderują się zawsze i same decydują, co pokazać.
Załóżmy, że DashboardLayout jest elementem trasy galaxies/:galaxyId z wcześniejszych przykładów. Panel boczny może wtedy czytać adres hookami: znanym Ci useParams oraz useLocation, który zwraca obiekt z bieżącym adresem, m.in. ze ścieżką w polu pathname. Więcej o useLocation dowiesz się w kolejnych lekcjach.
import { useLocation, useParams } from 'react-router-dom';
function AuxiliaryPanel() {
const { galaxyId } = useParams();
const { pathname } = useLocation();
return (
<div>
<h3>Telemetria galaktyki {galaxyId}</h3>
<p>Aktualny widok: {pathname}</p>
</div>
);
}Na adresie /galaxies/andromeda/systems panel pokaże nagłówek z identyfikatorem andromeda i pełną ścieżkę. Sam panel nie zna konfiguracji podścieżek: czyta tylko parametry swojej trasy i adres.
Czasem to podścieżka powinna zdecydować, co pojawi się w panelu. Służy do tego właściwość trasy handle, czyli dowolne dane, które trasa dołącza do swojego dopasowania. Odczytuje się je hookiem useMatches(), który zwraca wszystkie aktywne dopasowania, od layoutu do najgłębszej podścieżki. Dokumentacja React Router pokazuje ten wzorzec przy okruszkach nawigacyjnych (breadcrumbs). Jest jeden warunek: useMatches działa tylko w routerze danych (data router), czyli gdy trasy przekazujesz funkcji createBrowserRouter, a aplikację renderujesz przez <RouterProvider router={router} />. Taki router zna całe drzewo tras z góry. W <BrowserRouter> hook rzuci błąd.
import { createBrowserRouter } from 'react-router-dom';
const router = createBrowserRouter([
{
path: '/galaxies/:galaxyId',
element: <DashboardLayout />,
children: [
{ index: true, element: <GalaxyOverview /> },
{
path: 'systems',
element: <SystemsList />,
// handle: dowolne dane dołączone do dopasowania tej trasy
handle: { sidebar: () => <SystemsFilter /> },
},
],
},
]);Trasy opisuje tu tablica obiektów zamiast komponentów <Route>, ale struktura jest ta sama: layout z podścieżkami w children, a index: true pełni rolę atrybutu index. Nowa jest tylko właściwość handle przy trasie systems: jej pole sidebar to funkcja zwracająca panel. Teraz MissionSidebar przegląda dopasowania od najgłębszego i używa pierwszego znalezionego handle.sidebar:
import { useMatches } from 'react-router-dom';
function MissionSidebar() {
const matches = useMatches();
const match = [...matches].reverse().find((m) => m.handle?.sidebar);
return match ? match.handle.sidebar() : <p>Wybierz układ słoneczny</p>;
}Kopia tablicy ([...matches]) jest potrzebna, bo reverse() odwraca tablicę w miejscu. Na /galaxies/andromeda/systems lewy panel pokaże SystemsFilter, bo tak zdecydowała trasa systems. Na /galaxies/andromeda trasa indeksowa nie ma handle, więc panel wyświetli tekst domyślny, a layout przez cały czas ma dokładnie jeden Outlet. Polecam zaczynać od zwykłych komponentów z useParams i useLocation, a po handle sięgać dopiero wtedy, gdy każda podścieżka ma mieć w panelu własną treść. Z routerem danych spotkasz się ponownie przy blokowaniu nawigacji, w lekcji o historii przeglądarki.
Optymalizacja zagnieżdżonych ścieżek
Przy pracy z zagnieżdżonymi ścieżkami, warto pamiętać o kilku technikach optymalizacji:
1. Lazy Loading komponentów
Dla poprawy wydajności, komponenty mogą być ładowane dynamicznie tylko wtedy, gdy są potrzebne:
import { Suspense, lazy } from 'react';
import { Routes, Route } from 'react-router-dom';
// Lazy loading komponentów
const GalaxyLayout = lazy(() => import('./GalaxyLayout'));
const GalaxiesList = lazy(() => import('./GalaxiesList'));
const SolarSystemDetails = lazy(() => import('./SolarSystemDetails'));
function App() {
return (
<Routes>
<Route path="/" element={<MainLayout />}>
{/* Komponent ładowany leniwie */}
<Route
path="galaxies"
element={
<Suspense fallback={<div>Ładowanie galaktyk...</div>}>
<GalaxiesList />
</Suspense>
}
/>
<Route
path="galaxies/:galaxyId/*"
element={
<Suspense fallback={<div>Ładowanie danych galaktyki...</div>}>
<GalaxyLayout />
</Suspense>
}
/>
</Route>
</Routes>
);
}2. Optymalizacja renderowania
Optymalizacja renderowania może być szczególnie ważna przy głębokim zagnieżdżeniu, gdy zmiana parametru URL na głębokim poziomie może spowodować zbędne rerenderowanie komponentów wyższego poziomu:
import { memo } from 'react';
import { Outlet, useParams } from 'react-router-dom';
// Komponent zoptymalizowany - nie będzie się rerenderował, jeśli jego props się nie zmienią
const MemoizedGalaxyLayout = memo(function GalaxyLayout() {
const { galaxyId } = useParams();
console.log(`Renderowanie GalaxyLayout dla galaktyki ${galaxyId}`);
return (
<div className="galaxy-layout">
<h2>Galaktyka: {galaxyId}</h2>
<Outlet />
</div>
);
});Przykład kompletnej aplikacji z zagnieżdżonymi ścieżkami
Poniżej znajduje się przykład kompletnej aplikacji kosmicznej z zagnieżdżonymi ścieżkami:
import React from 'react';
import {
BrowserRouter,
Routes,
Route,
Outlet,
Link,
NavLink,
useParams,
useOutletContext,
useNavigate
} from 'react-router-dom';
// Główny layout aplikacji
function AppLayout() {
return (
<div className="cosmos-explorer">
<header className="main-header">
<h1>Kosmiczny Atlas Podróżnika</h1>
<MainNavigation />
</header>
<main className="main-content">
<Outlet />
</main>
<footer className="main-footer">
<p>© 2150 Międzygalaktyczna Agencja Podróży</p>
</footer>
</div>
);
}
// Główna nawigacja
function MainNavigation() {
return (
<nav className="main-nav">
<ul>
<li><NavLink to="/" end>Centrum Dowodzenia</NavLink></li>
<li><NavLink to="/galaxies">Galaktyki</NavLink></li>
<li><NavLink to="/missions">Misje</NavLink></li>
<li><NavLink to="/crew">Załoga</NavLink></li>
</ul>
</nav>
);
}
// Strona główna
function Dashboard() {
return (
<div className="dashboard">
<h2>Centrum Dowodzenia Statku Kosmicznego</h2>
<p>Witaj, Kapitanie! Jaką lokalizację chcesz dziś eksplorować?</p>
<div className="dashboard-tiles">
<div className="tile">
<h3>Galaktyki</h3>
<p>Eksploruj różne galaktyki we wszechświecie</p>
<Link to="/galaxies" className="tile-link">Przejdź do galaktyk</Link>
</div>
<div className="tile">
<h3>Misje</h3>
<p>Przeglądaj aktualne i przyszłe misje kosmiczne</p>
<Link to="/missions" className="tile-link">Przejdź do misji</Link>
</div>
<div className="tile">
<h3>Załoga</h3>
<p>Zarządzaj członkami załogi statku kosmicznego</p>
<Link to="/crew" className="tile-link">Przejdź do załogi</Link>
</div>
</div>
</div>
);
}
// ===== SEKCJA GALAKTYK =====
// Layout dla galaktyk
function GalaxiesLayout() {
return (
<div className="galaxies-section">
<h2>Eksploracja Galaktyk</h2>
<Outlet />
</div>
);
}
// Lista galaktyk
function GalaxiesList() {
const galaxies = [
{ id: 'milky-way', name: 'Droga Mleczna', type: 'Spiralna' },
{ id: 'andromeda', name: 'Andromeda', type: 'Spiralna' },
{ id: 'triangulum', name: 'Galaktyka Trójkąta', type: 'Spiralna' },
{ id: 'large-magellanic', name: 'Wielki Obłok Magellana', type: 'Nieregularna' }
];
return (
<div className="galaxies-list">
<h3>Dostępne Galaktyki</h3>
<div className="galaxy-cards">
{galaxies.map(galaxy => (
<div key={galaxy.id} className="galaxy-card">
<h4>{galaxy.name}</h4>
<p>Typ: {galaxy.type}</p>
<Link to={galaxy.id} className="galaxy-link">
Eksploruj galaktykę
</Link>
</div>
))}
</div>
</div>
);
}
// Layout szczegółów galaktyki
function GalaxyLayout() {
const { galaxyId } = useParams();
const navigate = useNavigate();
// Symulacja danych galaktyki (w prawdziwej aplikacji pobierane z API)
const galaxyData = {
'milky-way': {
name: 'Droga Mleczna',
type: 'Spiralna',
diameter: '100,000 lat świetlnych',
stars: '200-400 miliardów',
systems: [
{ id: 'solar', name: 'Układ Słoneczny' },
{ id: 'alpha-centauri', name: 'Alfa Centauri' },
{ id: 'sirius', name: 'Syriusz' }
]
},
'andromeda': {
name: 'Andromeda',
type: 'Spiralna',
diameter: '220,000 lat świetlnych',
stars: '1 bilion',
systems: [
{ id: 'system-1', name: 'Układ M31-A' },
{ id: 'system-2', name: 'Układ M31-B' }
]
},
'triangulum': {
name: 'Galaktyka Trójkąta',
type: 'Spiralna',
diameter: '60,000 lat świetlnych',
stars: '40 miliardów',
systems: [
{ id: 'system-1', name: 'Układ T1' }
]
},
'large-magellanic': {
name: 'Wielki Obłok Magellana',
type: 'Nieregularna',
diameter: '14,000 lat świetlnych',
stars: '30 miliardów',
systems: []
}
};
const galaxy = galaxyData[galaxyId];
if (!galaxy) {
return (
<div className="galaxy-not-found">
<h3>Galaktyka nie znaleziona</h3>
<p>Nie znaleziono galaktyki o identyfikatorze: {galaxyId}</p>
<button onClick={() => navigate('/galaxies')}>
Powrót do listy galaktyk
</button>
</div>
);
}
return (
<div className="galaxy-details">
<h3>Galaktyka: {galaxy.name}</h3>
<nav className="galaxy-nav">
<NavLink to="" end>Przegląd</NavLink>
<NavLink to="systems">Układy Słoneczne</NavLink>
<NavLink to="map">Mapa Galaktyki</NavLink>
</nav>
<div className="galaxy-content">
<Outlet context={{ galaxy }} />
</div>
<div className="back-navigation">
<Link to="/galaxies">← Powrót do listy galaktyk</Link>
</div>
</div>
);
}
// Przegląd galaktyki (domyślny widok)
function GalaxyOverview() {
const { galaxy } = useOutletContext();
return (
<div className="galaxy-overview">
<h4>Przegląd: {galaxy.name}</h4>
<table className="galaxy-stats">
<tbody>
<tr>
<th>Typ:</th>
<td>{galaxy.type}</td>
</tr>
<tr>
<th>Średnica:</th>
<td>{galaxy.diameter}</td>
</tr>
<tr>
<th>Liczba gwiazd:</th>
<td>{galaxy.stars}</td>
</tr>
<tr>
<th>Odkryte układy:</th>
<td>{galaxy.systems.length}</td>
</tr>
</tbody>
</table>
<h5>Ciekawostki</h5>
<p>Tutaj znajdą się unikalne ciekawostki o galaktyce {galaxy.name}...</p>
</div>
);
}
// Lista układów słonecznych w galaktyce
function GalaxySystems() {
const { galaxy } = useOutletContext();
const { galaxyId } = useParams();
return (
<div className="galaxy-systems">
<h4>Układy Słoneczne w {galaxy.name}</h4>
{galaxy.systems.length > 0 ? (
<ul className="systems-list">
{galaxy.systems.map(system => (
<li key={system.id} className="system-item">
<div className="system-info">
<h5>{system.name}</h5>
</div>
<Link to={`/galaxies/${galaxyId}/systems/${system.id}`}>
Eksploruj układ
</Link>
</li>
))}
</ul>
) : (
<p>Nie odkryto jeszcze żadnych układów w tej galaktyce.</p>
)}
</div>
);
}
// Mapa galaktyki
function GalaxyMap() {
const { galaxy } = useOutletContext();
return (
<div className="galaxy-map">
<h4>Mapa Galaktyki: {galaxy.name}</h4>
<div className="map-placeholder">
<p>Tutaj będzie interaktywna mapa galaktyki {galaxy.name}.</p>
<p>Obecnie w fazie rozwoju...</p>
</div>
</div>
);
}
// ===== SEKCJA UKŁADÓW SŁONECZNYCH =====
// Szczegóły układu słonecznego
function SolarSystemDetails() {
const { galaxyId, systemId } = useParams();
const navigate = useNavigate();
// W prawdziwej aplikacji, dane byłyby pobierane na podstawie galaxyId i systemId
const systemData = {
'solar': {
name: 'Układ Słoneczny',
star: 'Słońce',
planets: 8,
age: '4.6 miliarda lat'
},
'alpha-centauri': {
name: 'Alfa Centauri',
star: 'Alfa Centauri A i B, Proxima Centauri',
planets: 3,
age: '4.85 miliarda lat'
},
'sirius': {
name: 'Syriusz',
star: 'Syriusz A i B',
planets: 0,
age: '230 milionów lat'
},
'system-1': {
name: 'Układ M31-A',
star: 'Gwiazda M31-A',
planets: 5,
age: '2.3 miliarda lat'
},
'system-2': {
name: 'Układ M31-B',
star: 'Gwiazda M31-B',
planets: 7,
age: '3.1 miliarda lat'
}
};
const system = systemData[systemId];
if (!system) {
return (
<div className="system-not-found">
<h4>Układ nie znaleziony</h4>
<p>Nie znaleziono układu słonecznego o identyfikatorze: {systemId}</p>
<button onClick={() => navigate(`/galaxies/${galaxyId}/systems`)}>
Powrót do listy układów
</button>
</div>
);
}
return (
<div className="system-details">
<h4>Układ Słoneczny: {system.name}</h4>
<table className="system-stats">
<tbody>
<tr>
<th>Gwiazda(y):</th>
<td>{system.star}</td>
</tr>
<tr>
<th>Liczba planet:</th>
<td>{system.planets}</td>
</tr>
<tr>
<th>Wiek:</th>
<td>{system.age}</td>
</tr>
</tbody>
</table>
<div className="back-navigation">
<Link to={`/galaxies/${galaxyId}/systems`}>
← Powrót do układów słonecznych
</Link>
</div>
</div>
);
}
// ===== SEKCJA MISJI =====
// Layout misji
function MissionsLayout() {
return (
<div className="missions-section">
<h2>Misje Kosmiczne</h2>
<Outlet />
</div>
);
}
// Lista misji
function MissionsList() {
const missions = [
{ id: 'apollo', name: 'Apollo', status: 'Zakończona' },
{ id: 'artemis', name: 'Artemis', status: 'W trakcie' },
{ id: 'mars-2030', name: 'Mars 2030', status: 'Planowana' }
];
return (
<div className="missions-list">
<h3>Misje kosmiczne</h3>
<ul>
{missions.map(mission => (
<li key={mission.id}>
<Link to={mission.id}>{mission.name}</Link> - {mission.status}
</li>
))}
</ul>
</div>
);
}
// Szczegóły misji
function MissionDetails() {
const { missionId } = useParams();
return (
<div className="mission-details">
<h3>Szczegóły misji: {missionId}</h3>
<p>Tutaj będą szczegóły misji {missionId}...</p>
<Link to="/missions">← Powrót do listy misji</Link>
</div>
);
}
// ===== SEKCJA ZAŁOGI =====
// Layout załogi
function CrewLayout() {
return (
<div className="crew-section">
<h2>Zarządzanie Załogą</h2>
<Outlet />
</div>
);
}
// Lista członków załogi
function CrewList() {
const crewMembers = [
{ id: 'crew1', name: 'Jan Kowalski', role: 'Kapitan' },
{ id: 'crew2', name: 'Anna Nowak', role: 'Nawigator' },
{ id: 'crew3', name: 'Piotr Wiśniewski', role: 'Inżynier' }
];
return (
<div className="crew-list">
<h3>Członkowie załogi</h3>
<ul>
{crewMembers.map(member => (
<li key={member.id}>
<Link to={member.id}>{member.name}</Link> - {member.role}
</li>
))}
</ul>
</div>
);
}
// Szczegóły członka załogi
function CrewMemberDetails() {
const { crewId } = useParams();
return (
<div className="crew-member-details">
<h3>Profil członka załogi: {crewId}</h3>
<p>Tutaj będzie profil członka załogi {crewId}...</p>
<Link to="/crew">← Powrót do listy załogi</Link>
</div>
);
}
// ===== GŁÓWNY KOMPONENT APLIKACJI =====
function App() {
return (
<BrowserRouter>
<Routes>
<Route path="/" element={<AppLayout />}>
{/* Strona główna */}
<Route index element={<Dashboard />} />
{/* Sekcja galaktyk */}
<Route path="galaxies" element={<GalaxiesLayout />}>
<Route index element={<GalaxiesList />} />
<Route path=":galaxyId" element={<GalaxyLayout />}>
<Route index element={<GalaxyOverview />} />
<Route path="systems" element={<GalaxySystems />} />
<Route path="map" element={<GalaxyMap />} />
</Route>
<Route path=":galaxyId/systems/:systemId" element={<SolarSystemDetails />} />
</Route>
{/* Sekcja misji */}
<Route path="missions" element={<MissionsLayout />}>
<Route index element={<MissionsList />} />
<Route path=":missionId" element={<MissionDetails />} />
</Route>
{/* Sekcja załogi */}
<Route path="crew" element={<CrewLayout />}>
<Route index element={<CrewList />} />
<Route path=":crewId" element={<CrewMemberDetails />} />
</Route>
{/* Obsługa 404 */}
<Route path="*" element={<NotFound />} />
</Route>
</Routes>
</BrowserRouter>
);
}
// Komponent dla nieistniejących ścieżek
function NotFound() {
return (
<div className="not-found">
<h2>404 - Zagubiony w kosmosie</h2>
<p>Ta ścieżka nie prowadzi do żadnego znanego celu w kosmosie.</p>
<Link to="/">Powrót do Centrum Dowodzenia</Link>
</div>
);
}
export default App;Najlepsze praktyki dla zagnieżdżonych ścieżek
- Utrzymuj Logiczną Hierarchię - Struktura zagnieżdżonych ścieżek powinna odzwierciedlać logiczną organizację aplikacji
- Używaj Komponentów Layout - Twórz dedykowane komponenty layout dla każdego poziomu zagnieżdżenia
- Optymalizuj Przekazywanie Danych - Używaj useOutletContext lub React Context dla efektywnego przekazywania danych
- Zapewnij Intuicyjną Nawigację - Zawsze dodawaj linki pozwalające na łatwą nawigację w górę i w dół hierarchii
- Dziel Kod - Używaj lazy loading dla optymalizacji wydajności, szczególnie dla głęboko zagnieżdżonych komponentów
- Utrzymuj Czystość URL - Projektuj URL-e tak, aby były czytelne i logiczne dla użytkownika
- Unikaj Zbyt Głębokiego Zagnieżdżenia - Staraj się nie przekraczać 3-4 poziomów zagnieżdżenia dla zachowania przejrzystości
Podsumowanie
Zagnieżdżone ścieżki w React Router to potężna technika organizacji nawigacji w aplikacjach React, pozwalająca na tworzenie intuicyjnych, hierarchicznych struktur interfejsu użytkownika. Kluczowe korzyści:
- Logiczna Organizacja - Struktura routingu odzwierciedla logiczną hierarchię aplikacji
- Ponowne Użycie Layoutów - Wspólne elementy UI mogą być współdzielone między podścieżkami
- Lepsze UX - Użytkownicy mogą łatwo orientować się w strukturze aplikacji
- Łatwiejsze Zarządzanie Stanem - Stan może być przechowywany na odpowiednim poziomie zagnieżdżenia
Podobnie jak w rzeczywistej eksploracji kosmosu, gdzie podróżujemy od galaktyki, przez układy słoneczne, do planet i księżyców - zagnieżdżone ścieżki pozwalają tworzyć intuicyjne systemy nawigacji, które prowadzą użytkownika przez różne poziomy naszej aplikacji kosmicznej.
Kod do tej lekcji: App.jsx
import React, { useState } from 'react';
import { BrowserRouter, Routes, Route, Link, useNavigate, useLocation } from 'react-router-dom';
// Strona logowania
function LoginPage() {
const [username, setUsername] = useState('');
const navigate = useNavigate();
const handleLogin = (e) => {
e.preventDefault();
if (username.trim()) {
// Nawigacja programowa z przekazaniem state
navigate('/dashboard', { state: { username } });
}
};
return (
<div className="page login">
<h1>Panel Logowania</h1>
<form onSubmit={handleLogin}>
<input
type="text"
value={username}
onChange={(e) => setUsername(e.target.value)}
placeholder="Wprowadź nazwę użytkownika"
/>
<button type="submit">Zaloguj się</button>
</form>
</div>
);
}
// Dashboard - używamy useLocation do odczytania state
function Dashboard() {
const location = useLocation();
const navigate = useNavigate();
const username = location.state?.username || 'Gość';
const handleLogout = () => {
// Nawigacja z replace: true - nie dodaje do historii
navigate('/', { replace: true });
};
const goToMission = (missionId) => {
navigate(`/mission/${missionId}`);
};
return (
<div className="page dashboard">
<h1>Witaj, {username}!</h1>
<p>Twój panel kontroli misji kosmicznych</p>
<div className="missions">
<h2>Dostępne misje:</h2>
<div className="mission-buttons">
<button onClick={() => goToMission('apollo')}>Apollo</button>
<button onClick={() => goToMission('artemis')}>Artemis</button>
<button onClick={() => goToMission('voyager')}>Voyager</button>
</div>
</div>
<div className="navigation-demo">
<h2>Nawigacja programowa:</h2>
<button onClick={() => navigate(-1)}>← Cofnij (go -1)</button>
<button onClick={() => navigate(1)}>Dalej (go 1) →</button>
<button onClick={handleLogout} className="logout">Wyloguj</button>
</div>
</div>
);
}
// Strona misji
function MissionPage() {
const navigate = useNavigate();
const location = useLocation();
// Pobierz ID misji z URL
const missionId = location.pathname.split('/').pop();
return (
<div className="page mission">
<h1>Misja: {missionId.toUpperCase()}</h1>
<p>Szczegóły misji {missionId}</p>
<div className="location-info">
<h3>Informacje o lokalizacji:</h3>
<pre>{JSON.stringify(location, null, 2)}</pre>
</div>
<button onClick={() => navigate('/dashboard', { state: location.state })}>
← Wróć do panelu
</button>
</div>
);
}
function App() {
return (
<BrowserRouter>
<div className="app">
<nav>
<Link to="/">Login</Link>
<Link to="/dashboard">Dashboard</Link>
</nav>
<Routes>
<Route path="/" element={<LoginPage />} />
<Route path="/dashboard" element={<Dashboard />} />
<Route path="/mission/:id" element={<MissionPage />} />
</Routes>
</div>
</BrowserRouter>
);
}
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. Hook useParams pozwala na:
2. Hook useSearchParams służy do:
Zadania praktyczne w grze
- Edytor kodu
Zagnieżdżone trasy z Outlet
- Układanie w poziomie
Ułóż elementy destrukturyzacji useParams od lewej do prawej:
- Edytor kodu
Search params i filtrowanie
- Układanie w pionie
Uporządkuj kroki konfiguracji zagnieżdżonych tras (nested routes):