Kurs Next.js · Moduł 2: Routing i layouty
Nawigacja z komponentem Link i useRouter
W tej lekcji6
W Metropolii Quantum system transportowy pozwala mieszkańcom przemieszczać się płynnie między różnymi dzielnicami i obiektami. Te zaawansowane pojazdy, nazywane Q-Linkami, potrafią natychmiastowo przenosić pasażerów do właściwie dowolnego miejsca w mieście, bez potrzeby przeładowywania całej infrastruktury transportowej.
W świecie Next.js 16 podobną rolę odgrywają komponenty Link oraz hook useRouter. Te narzędzia umożliwiają tworzenie płynnej, wydajnej nawigacji między różnymi częściami aplikacji, bez konieczności przeładowywania całej strony.
Link - najważniejszy komponent transportowy
Komponent Link to podstawowy element nawigacyjny w Next.js 16, działający jak Q-Link w Metropolii Quantum - przenosi użytkownika do określonego punktu docelowego bez zbędnych opóźnień czy zakłóceń.
Podstawowe użycie komponentu Link
import Link from 'next/link';
export default function Navigation() {
return (
<nav className="flex space-x-6 py-4">
<Link
href="/"
className="text-indigo-600 hover:text-indigo-800 transition-colors"
>
Strona główna
</Link>
<Link
href="/destinations"
className="text-indigo-600 hover:text-indigo-800 transition-colors"
>
Destynacje
</Link>
<Link
href="/flights"
className="text-indigo-600 hover:text-indigo-800 transition-colors"
>
Loty
</Link>
<Link
href="/about"
className="text-indigo-600 hover:text-indigo-800 transition-colors"
>
O nas
</Link>
</nav>
);
}Ten prosty kod tworzy podstawowy pasek nawigacyjny, który umożliwia użytkownikom poruszanie się między różnymi sekcjami aplikacji. Zauważ, że komponent Link przyjmuje właściwości takie jak href (cel nawigacji) oraz możemy przekazać mu klasyczne atrybuty HTML, takie jak className do stylowania.
Kluczowe przewagi komponentu Link nad zwykłym tagiem <a>
Podobnie jak Q-Linki w Metropolii Quantum, które oferują znacznie więcej niż tradycyjne pojazdy, komponent Link w Next.js 16 przewyższa zwykły tag HTML <a> pod wieloma względami:
- Prefetching (wstępne ładowanie) - automatycznie ładuje docelową stronę w tle, gdy link jest widoczny w oknie przeglądarki, co drastycznie przyspiesza nawigację.
- Client-side navigation - przechodzi między stronami bez pełnego przeładowania strony, aktualizując tylko to, co konieczne.
- Automatyczna optymalizacja - komponenty
Linksą automatycznie optymalizowane dla aplikacji App Router, uwzględniając funkcje takie jak prefetching dynamicznych tras. - Zarządzanie fokusem - po nawigacji, focus jest odpowiednio przenoszony, co poprawia dostępność aplikacji.
Zaawansowane opcje Link
Komponent Link oferuje kilka zaawansowanych opcji, które zwiększają jego funkcjonalność:
1. Dynamiczne trasy
// Komponent karty destynacji
function DestinationCard({ destination }: { destination: { id: string; name: string; shortDescription: string } }) {
return (
<Link
href={`/destinations/${destination.id}`}
className="block p-4 border rounded-lg hover:shadow-md transition-shadow"
>
<h2 className="text-xl font-semibold">{destination.name}</h2>
<p className="text-gray-600">{destination.shortDescription}</p>
</Link>
);
}2. Przekazywanie parametrów zapytania
// Komponent filtru wyszukiwania
function SearchFilter({ currentCategory, currentSort }: { currentCategory: string; currentSort: string }) {
return (
<div className="flex space-x-4">
<Link
href={{
pathname: '/search',
query: { category: 'planets', sort: currentSort },
}}
className={`px-3 py-1 rounded ${currentCategory === 'planets' ? 'bg-indigo-600 text-white' : 'bg-gray-200'}`}
>
Planety
</Link>
<Link
href={{
pathname: '/search',
query: { category: 'moons', sort: currentSort },
}}
className={`px-3 py-1 rounded ${currentCategory === 'moons' ? 'bg-indigo-600 text-white' : 'bg-gray-200'}`}
>
Księżyce
</Link>
<Link
href={{
pathname: '/search',
query: { category: 'stars', sort: currentSort },
}}
className={`px-3 py-1 rounded ${currentCategory === 'stars' ? 'bg-indigo-600 text-white' : 'bg-gray-200'}`}
>
Gwiazdy
</Link>
</div>
);
}3. Zastępowanie domyślnego zachowania
// Komponent przycisku "Wróć do góry"
function ScrollToTopButton() {
const handleClick = (e) => {
e.preventDefault();
window.scrollTo({ top: 0, behavior: 'smooth' });
};
return (
<Link
href="#top"
onClick={handleClick}
className="fixed bottom-4 right-4 p-2 bg-indigo-600 text-white rounded-full"
aria-label="Przewiń do góry"
>
<svg xmlns="http://www.w3.org/2000/svg" className="h-6 w-6" fill="none" viewBox="0 0 24 24" stroke="currentColor">
<path strokeLinecap="round" strokeLinejoin="round" strokeWidth={2} d="M5 10l7-7m0 0l7 7m-7-7v18" />
</svg>
</Link>
);
}4. Obsługa przewijania i fokusa
<Link
href="/destinations"
scroll={false} // Wyłącza automatyczne przewijanie do góry strony
>
Destynacje (bez przewijania)
</Link>5. Prefetch
<Link
href="/rarely-visited-page"
prefetch={false} // Wyłącza automatyczny prefetching
>
Rzadko odwiedzana strona
</Link>Domyślnie, Link automatycznie ładuje wstępnie (prefetch) strony, które są widoczne w viewporcie. Można to kontrolować za pomocą właściwości prefetch.
Zastosowanie tagów <a> z komponentem Link
Od Next.js 13 komponent Link sam renderuje tag <a> i przekazuje mu odpowiednie atrybuty, więc w Next.js 16 nie musisz zagnieżdżać dodatkowego tagu <a> wewnątrz komponentu Link. To usprawnienie pozwala na bardziej zwięzły kod:
// Poprawne użycie w Next.js 16
<Link
href="/destinations"
className="text-blue-600 hover:underline"
target="_blank"
rel="noopener noreferrer"
>
Zobacz destynacje
</Link>useRouter - nawigacja programistyczna
Podczas gdy komponent Link jest idealny do nawigacji deklaratywnej (widocznej w UI), czasami potrzebujemy nawigować programistycznie - podobnie jak w Metropolii Quantum, gdzie centralna sztuczna inteligencja może kierować Q-Linki do nowych lokalizacji na podstawie różnych warunków czy zdarzeń.
W Next.js 16 hook useRouter z pakietu next/navigation umożliwia właśnie taką dynamiczną nawigację.
Podstawowe użycie useRouter
'use client';
import { useRouter } from 'next/navigation';
export default function BookingForm() {
const router = useRouter();
const handleSubmit = async (event) => {
event.preventDefault();
// Logika przetwarzania formularza...
const bookingSuccess = await submitBooking(formData);
if (bookingSuccess) {
// Po udanym przesłaniu, przekieruj użytkownika
router.push('/booking/confirmation');
}
};
return (
<form onSubmit={handleSubmit} className="space-y-6">
{/* Pola formularza... */}
<button
type="submit"
className="w-full py-2 px-4 bg-indigo-600 text-white rounded"
>
Zarezerwuj podróż
</button>
</form>
);
}Uwaga: Pamiętaj, że useRouter to hook Reacta, więc może być używany tylko w komponentach klienckich (oznaczonych jako 'use client';).
Metody hooka useRouter
Hook useRouter udostępnia kilka przydatnych metod:
1. router.push(url)
Nawiguje do podanego URL, dodając nowy wpis do historii przeglądarki:
const router = useRouter();
function navigateToHome() {
router.push('/');
}
function navigateToDestination(destinationId) {
router.push(`/destinations/${destinationId}`);
}
function navigateWithQueryParams() {
router.push('/search?category=planets&sort=distance');
}2. router.replace(url)
Podobnie jak push, ale zastępuje bieżący wpis w historii zamiast dodawać nowy:
function redirectToLogin() {
router.replace('/login'); // Użytkownik nie będzie mógł wrócić do poprzedniej strony przyciskiem "Wstecz"
}3. router.refresh()
Odświeża bieżącą stronę, ponownie pobierając dane, ale zachowując stan DOM:
function refreshData() {
router.refresh(); // Ponownie pobiera dane z serwera bez pełnego przeładowania strony
}4. router.back()
Przechodzi do poprzedniej strony w historii przeglądarki:
function goBack() {
router.back();
}5. router.forward()
Przechodzi do następnej strony w historii przeglądarki:
function goForward() {
router.forward();
}6. router.prefetch(href)
Wstępnie ładuje podany URL:
function prefetchImportantPage() {
router.prefetch('/important-page');
}Praktyczne przykłady użycia useRouter
Przykład 1: Asystent nawigacji
'use client';
import { useState, useEffect } from 'react';
import { useRouter } from 'next/navigation';
export default function NavigationAssistant() {
const router = useRouter();
const [destination, setDestination] = useState('');
const [suggestions, setSuggestions] = useState([]);
useEffect(() => {
if (destination.length < 2) {
setSuggestions([]);
return;
}
// Symulacja pobierania sugestii z API
const fetchSuggestions = async () => {
// W rzeczywistej aplikacji, pobieralibyśmy dane z API
const mockSuggestions = [
{ id: 'mars', name: 'Mars', type: 'planet' },
{ id: 'mars-colony-alpha', name: 'Kolonia Alpha na Marsie', type: 'colony' },
{ id: 'martian-canyon', name: 'Wielki Kanion Marsjański', type: 'landmark' }
].filter(item =>
item.name.toLowerCase().includes(destination.toLowerCase())
);
setSuggestions(mockSuggestions);
};
fetchSuggestions();
}, [destination]);
const handleSelect = (suggestion) => {
// Wybór trasy w zależności od typu sugestii
switch(suggestion.type) {
case 'planet':
router.push(`/destinations/${suggestion.id}`);
break;
case 'colony':
router.push(`/colonies/${suggestion.id}`);
break;
case 'landmark':
router.push(`/landmarks/${suggestion.id}`);
break;
default:
router.push(`/search?q=${encodeURIComponent(suggestion.name)}`);
}
};
return (
<div className="relative w-full max-w-md">
<input
type="text"
value={destination}
onChange={(e) => setDestination(e.target.value)}
className="w-full p-3 border border-gray-300 rounded-lg shadow-sm focus:outline-none focus:ring-2 focus:ring-indigo-500 focus:border-indigo-500"
/>
{suggestions.length > 0 && (
<div className="absolute z-10 w-full mt-1 bg-white rounded-lg shadow-lg border border-gray-200">
<ul>
{suggestions.map((suggestion) => (
<li
key={suggestion.id}
className="px-4 py-3 hover:bg-gray-100 cursor-pointer flex items-center"
onClick={() => handleSelect(suggestion)}
>
<div className="w-8 h-8 mr-3 flex items-center justify-center rounded-full bg-indigo-100 text-indigo-800">
{suggestion.type === 'planet' ? 'P' : suggestion.type === 'colony' ? 'K' : 'M'}
</div>
<div>
<div className="font-medium">{suggestion.name}</div>
<div className="text-sm text-gray-500 capitalize">{suggestion.type}</div>
</div>
</li>
))}
</ul>
</div>
)}
</div>
);
}Przykład 2: Wieloetapowy formularz rezerwacji
'use client';
import { useState } from 'react';
import { useRouter } from 'next/navigation';
export default function MultiStepBookingForm() {
const router = useRouter();
const [step, setStep] = useState(1);
const [formData, setFormData] = useState({
destination: '',
departureDate: '',
returnDate: '',
passengers: 1,
contactEmail: '',
contactPhone: ''
});
const updateFormData = (field, value) => {
setFormData(prev => ({ ...prev, [field]: value }));
};
const goToNextStep = () => {
setStep(prev => prev + 1);
};
const goToPreviousStep = () => {
setStep(prev => prev - 1);
};
const submitForm = async () => {
try {
// Tutaj normalnie wysłalibyśmy dane do API
console.log('Wysyłanie danych:', formData);
// Symulacja oczekiwania na odpowiedź API
await new Promise(resolve => setTimeout(resolve, 1000));
// Przekierowanie do strony potwierdzenia z ID rezerwacji
router.push('/booking/confirmation?id=QV123456789');
} catch (error) {
console.error('Błąd podczas rezerwacji:', error);
// Obsługa błędu
}
};
return (
<div className="max-w-3xl mx-auto p-6 bg-white rounded-lg shadow-md">
<div className="mb-8">
<div className="flex items-center">
{[1, 2, 3].map((i) => (
<div key={i} className="flex items-center">
<div className={`w-10 h-10 rounded-full flex items-center justify-center ${
i === step ? 'bg-indigo-600 text-white' :
i < step ? 'bg-green-500 text-white' : 'bg-gray-200 text-gray-700'
}`}>
{i < step ? 'OK' : i}
</div>
{i < 3 && (
<div className={`h-1 w-16 ${i < step ? 'bg-green-500' : 'bg-gray-200'}`}></div>
)}
</div>
))}
</div>
<div className="flex justify-between mt-2">
<span>Destynacja</span>
<span>Szczegóły podróży</span>
<span>Dane kontaktowe</span>
</div>
</div>
{step === 1 && (
<div className="space-y-4">
<h2 className="text-2xl font-semibold">Wybierz destynację</h2>
<div className="grid grid-cols-1 md:grid-cols-3 gap-4">
{['Mars', 'Europa', 'Tytan'].map((dest) => (
<div
key={dest}
onClick={() => updateFormData('destination', dest)}
className={`p-4 border rounded-lg cursor-pointer ${
formData.destination === dest ? 'border-indigo-600 bg-indigo-50' : 'border-gray-200'
}`}
>
<h3 className="font-semibold">{dest}</h3>
<p className="text-sm text-gray-600">Odkryj cuda {dest}</p>
</div>
))}
</div>
<div className="flex justify-end mt-6">
<button
onClick={goToNextStep}
disabled={!formData.destination}
className={`px-6 py-2 rounded-lg ${
formData.destination ? 'bg-indigo-600 text-white' : 'bg-gray-200 text-gray-500 cursor-not-allowed'
}`}
>
Dalej
</button>
</div>
</div>
)}
{step === 2 && (
<div className="space-y-4">
<h2 className="text-2xl font-semibold">Szczegóły podróży</h2>
<div className="space-y-4">
<div>
<label className="block mb-1">Data wylotu</label>
<input
type="date"
value={formData.departureDate}
onChange={(e) => updateFormData('departureDate', e.target.value)}
className="w-full p-2 border border-gray-300 rounded"
min={new Date().toISOString().split('T')[0]}
/>
</div>
<div>
<label className="block mb-1">Data powrotu</label>
<input
type="date"
value={formData.returnDate}
onChange={(e) => updateFormData('returnDate', e.target.value)}
className="w-full p-2 border border-gray-300 rounded"
min={formData.departureDate || new Date().toISOString().split('T')[0]}
/>
</div>
<div>
<label className="block mb-1">Liczba pasażerów</label>
<input
type="number"
value={formData.passengers}
onChange={(e) => updateFormData('passengers', e.target.value)}
className="w-full p-2 border border-gray-300 rounded"
min="1"
max="10"
/>
</div>
</div>
<div className="flex justify-between mt-6">
<button
onClick={goToPreviousStep}
className="px-6 py-2 border border-gray-300 rounded-lg"
>
Wstecz
</button>
<button
onClick={goToNextStep}
disabled={!formData.departureDate || !formData.returnDate}
className={`px-6 py-2 rounded-lg ${
formData.departureDate && formData.returnDate ?
'bg-indigo-600 text-white' :
'bg-gray-200 text-gray-500 cursor-not-allowed'
}`}
>
Dalej
</button>
</div>
</div>
)}
{step === 3 && (
<div className="space-y-4">
<h2 className="text-2xl font-semibold">Dane kontaktowe</h2>
<div className="space-y-4">
<div>
<label className="block mb-1">Email</label>
<input
type="email"
value={formData.contactEmail}
onChange={(e) => updateFormData('contactEmail', e.target.value)}
className="w-full p-2 border border-gray-300 rounded"
/>
</div>
<div>
<label className="block mb-1">Telefon</label>
<input
type="tel"
value={formData.contactPhone}
onChange={(e) => updateFormData('contactPhone', e.target.value)}
className="w-full p-2 border border-gray-300 rounded"
/>
</div>
</div>
<div className="mt-6 p-4 bg-gray-50 rounded-lg">
<h3 className="font-semibold mb-2">Podsumowanie</h3>
<div className="grid grid-cols-2 gap-2 text-sm">
<div>Destynacja:</div>
<div className="font-medium">{formData.destination}</div>
<div>Data wylotu:</div>
<div className="font-medium">{formData.departureDate}</div>
<div>Data powrotu:</div>
<div className="font-medium">{formData.returnDate}</div>
<div>Pasażerowie:</div>
<div className="font-medium">{formData.passengers}</div>
</div>
</div>
<div className="flex justify-between mt-6">
<button
onClick={goToPreviousStep}
className="px-6 py-2 border border-gray-300 rounded-lg"
>
Wstecz
</button>
<button
onClick={submitForm}
disabled={!formData.contactEmail || !formData.contactPhone}
className={`px-6 py-2 rounded-lg ${
formData.contactEmail && formData.contactPhone ?
'bg-indigo-600 text-white' :
'bg-gray-200 text-gray-500 cursor-not-allowed'
}`}
>
Zarezerwuj podróż
</button>
</div>
</div>
)}
</div>
);
}usePathname i useSearchParams - monitorowanie trasy
W Metropolii Quantum system monitorowania ruchu nieustannie śledzi pozycje Q-Linków, umożliwiając centralnej AI dostosowywanie parametrów transportowych w czasie rzeczywistym. W Next.js 16 podobną funkcję pełnią hooki usePathname i useSearchParams.
usePathname - śledzenie bieżącej ścieżki
'use client';
import Link from 'next/link';
import { usePathname } from 'next/navigation';
export default function MainNavigation() {
const pathname = usePathname();
const navItems = [
{ label: 'Strona główna', href: '/' },
{ label: 'Destynacje', href: '/destinations' },
{ label: 'Loty', href: '/flights' },
{ label: 'Promocje', href: '/offers' },
{ label: 'O nas', href: '/about' }
];
return (
<nav className="bg-white shadow">
<div className="max-w-7xl mx-auto px-4 sm:px-6 lg:px-8">
<div className="flex justify-between h-16">
<div className="flex">
<div className="shrink-0 flex items-center">
<img className="h-8 w-auto" src="/logo.svg" alt="Quantum Voyages" />
</div>
<div className="hidden sm:ml-6 sm:flex sm:space-x-8">
{navItems.map((item) => {
const isActive = pathname === item.href ||
(item.href !== '/' && pathname.startsWith(item.href));
return (
<Link
key={item.href}
href={item.href}
className={`inline-flex items-center px-1 pt-1 border-b-2 text-sm font-medium ${
isActive
? 'border-indigo-500 text-gray-900'
: 'border-transparent text-gray-500 hover:border-gray-300 hover:text-gray-700'
}`}
>
{item.label}
</Link>
);
})}
</div>
</div>
<div className="hidden sm:ml-6 sm:flex sm:items-center">
<Link
href="/dashboard"
className="px-4 py-2 text-sm rounded-md text-white bg-indigo-600 hover:bg-indigo-700"
>
Moje konto
</Link>
</div>
</div>
</div>
</nav>
);
}W tym przykładzie usePathname pozwala nam określić aktualną ścieżkę, co umożliwia podświetlenie aktywnej pozycji w menu nawigacyjnym.
useSearchParams - dostęp do parametrów zapytania
'use client';
import { useSearchParams } from 'next/navigation';
export default function SearchResultsHeader() {
const searchParams = useSearchParams();
const query = searchParams.get('q') || '';
const category = searchParams.get('category') || 'all';
const sort = searchParams.get('sort') || 'relevance';
return (
<div className="mb-6">
<h1 className="text-3xl font-bold mb-2">
{query ? `Wyniki wyszukiwania dla "${query}"` : 'Wszystkie destynacje'}
</h1>
<div className="flex items-center text-sm text-gray-600">
<span>Kategoria: <strong className="capitalize">{category}</strong></span>
<span className="mx-2">•</span>
<span>Sortowanie: <strong className="capitalize">{
sort === 'relevance' ? 'Trafność' :
sort === 'price-asc' ? 'Cena: od najniższej' :
sort === 'price-desc' ? 'Cena: od najwyższej' :
sort === 'rating' ? 'Ocena' : 'Trafność'
}</strong></span>
</div>
</div>
);
}Ten kod demonstruje, jak useSearchParams umożliwia odczytanie i wykorzystanie parametrów zapytania z URL, które mogą określać różne aspekty wyświetlanej strony.
Łączenie useSearchParams z nawigacją
'use client';
import { useSearchParams, useRouter, usePathname } from 'next/navigation';
export default function SearchFilters() {
const router = useRouter();
const pathname = usePathname();
const searchParams = useSearchParams();
// Pobranie aktualnych parametrów wyszukiwania
const currentCategory = searchParams.get('category') || 'all';
const currentSort = searchParams.get('sort') || 'relevance';
const currentQuery = searchParams.get('q') || '';
// Funkcja do aktualizacji parametrów z zachowaniem istniejących
const createQueryString = (name, value) => {
const params = new URLSearchParams(searchParams);
params.set(name, value);
return params.toString();
};
const handleCategoryChange = (category) => {
router.push(`${pathname}?${createQueryString('category', category)}`);
};
const handleSortChange = (sort) => {
router.push(`${pathname}?${createQueryString('sort', sort)}`);
};
return (
<div className="mb-8 space-y-4">
<div>
<h2 className="text-lg font-medium mb-2">Kategorie</h2>
<div className="flex flex-wrap gap-2">
{['all', 'planets', 'moons', 'stations'].map((category) => (
<button
key={category}
onClick={() => handleCategoryChange(category)}
className={`px-4 py-2 rounded-full text-sm ${
currentCategory === category
? 'bg-indigo-600 text-white'
: 'bg-gray-200 text-gray-800 hover:bg-gray-300'
}`}
>
{category === 'all' ? 'Wszystkie' :
category === 'planets' ? 'Planety' :
category === 'moons' ? 'Księżyce' : 'Stacje kosmiczne'}
</button>
))}
</div>
</div>
<div>
<h2 className="text-lg font-medium mb-2">Sortowanie</h2>
<select
value={currentSort}
onChange={(e) => handleSortChange(e.target.value)}
className="w-full sm:w-auto p-2 border border-gray-300 rounded-md"
>
<option value="relevance">Trafność</option>
<option value="price-asc">Cena: od najniższej</option>
<option value="price-desc">Cena: od najwyższej</option>
<option value="rating">Ocena</option>
<option value="distance">Odległość</option>
</select>
</div>
</div>
);
}Ten przykład demonstruje, jak efektywnie łączyć useSearchParams z useRouter i usePathname w celu tworzenia interaktywnych filtrów, które aktualizują URL i zawartość strony bez pełnego przeładowania.
Intercepting Routes - przechwytywanie tras
W Metropolii Quantum czasami Q-Link może zmienić swoją trasę w locie, aby obsłużyć specjalne zapytanie pasażera nie przerywając głównej podróży. W Next.js 16 koncepcja ta jest realizowana przez "Intercepting Routes" (przechwytywanie tras).
Podstawowa koncepcja przechwytywania tras
Przechwytywanie tras pozwala na "przechwycenie" normalnej nawigacji do określonej ścieżki i wyświetlenie alternatywnego UI, często nakładki (modal) na bieżącą stronę, zamiast całkowitej zmiany strony.
Implementacja opiera się na specjalnej konwencji nazewnictwa folderów:
(.)- przechwytuje segmenty na tym samym poziomie(..)- przechwytuje segmenty o jeden poziom wyżej(..)(..)- przechwytuje segmenty dwa poziomy wyżej(...)- przechwytuje segmenty od korzenia aplikacji
Przykład: Galeria zdjęć z modalem
Struktura katalogów:
app/
├── destinations/
│ ├── page.tsx # Strona z listą destynacji /destinations
│ └── [planet]/
│ ├── layout.tsx # Renderuje {children} i slot {modal}
│ ├── page.tsx # Strona konkretnej planety /destinations/mars
│ ├── gallery/
│ │ └── page.tsx # Pełna galeria /destinations/mars/gallery
│ └── @modal/
│ ├── default.tsx # Zwraca null, gdy modal jest zamknięty (wymagany w Next.js 16)
│ └── (.)gallery/
│ └── page.tsx # Przechwytuje /destinations/mars/gallery jako modalFolder slotu @modal nie jest segmentem adresu, dlatego galerię z tego samego segmentu [planet] przechwytuje (.)gallery, a nie (..)gallery (to przechwyciłoby /destinations/gallery).
Implementacja:
// app/destinations/page.tsx - Strona główna destynacji
import Link from 'next/link';
export default function DestinationsPage() {
const destinations = [
{ id: 'mars', name: 'Mars', imageUrl: '/images/mars.jpg' },
{ id: 'europa', name: 'Europa', imageUrl: '/images/europa.jpg' },
{ id: 'titan', name: 'Tytan', imageUrl: '/images/titan.jpg' }
];
return (
<div className="container mx-auto py-12 px-4">
<h1 className="text-4xl font-bold mb-8">Galaktyczne destynacje</h1>
<div className="grid grid-cols-1 md:grid-cols-2 lg:grid-cols-3 gap-8">
{destinations.map(destination => (
<Link
key={destination.id}
href={`/destinations/${destination.id}`}
className="block group"
>
<div className="relative h-64 rounded-lg overflow-hidden shadow-lg">
<img
src={destination.imageUrl}
alt={destination.name}
className="w-full h-full object-cover transition-transform group-hover:scale-105"
/>
<div className="absolute inset-0 bg-gradient-to-t from-black/70 to-transparent flex items-end">
<h2 className="text-white text-2xl font-bold p-4">
{destination.name}
</h2>
</div>
</div>
</Link>
))}
</div>
</div>
);
}// app/destinations/[planet]/page.tsx - Strona konkretnej planety
import Link from 'next/link';
export default async function PlanetPage({ params }: { params: Promise<{ planet: string }> }) {
const { planet } = await params;
// Symulowane dane galerii
const galleryImages = Array.from({ length: 6 }, (_, i) => ({
id: i + 1,
src: `/images/${planet}/${i + 1}.jpg`,
alt: `Zdjęcie ${planet} #${i + 1}`
}));
return (
<div className="container mx-auto py-12 px-4">
<h1 className="text-4xl font-bold mb-8 capitalize">
{planet}
</h1>
<div className="mb-12">
{/* Informacje o planecie... */}
</div>
<section>
<div className="flex justify-between items-center mb-6">
<h2 className="text-2xl font-bold">Galeria</h2>
<Link
href={`/destinations/${planet}/gallery`}
className="text-indigo-600 hover:text-indigo-800"
>
Zobacz wszystkie
</Link>
</div>
<div className="grid grid-cols-2 md:grid-cols-3 gap-4">
{galleryImages.slice(0, 3).map(image => (
<Link
key={image.id}
href={`/destinations/${planet}/gallery?image=${image.id}`}
className="block aspect-square rounded-lg overflow-hidden"
>
<img
src={image.src}
alt={image.alt}
className="w-full h-full object-cover hover:scale-105 transition-transform"
/>
</Link>
))}
</div>
</section>
</div>
);
}// app/destinations/[planet]/gallery/page.tsx - Pełna galeria
import Link from 'next/link';
import { notFound } from 'next/navigation';
export default async function GalleryPage({
params,
searchParams,
}: {
params: Promise<{ planet: string }>;
searchParams: Promise<{ image?: string }>;
}) {
const { planet } = await params;
const imageId = (await searchParams).image;
// Weryfikacja, czy planeta istnieje
const validPlanets = ['mars', 'europa', 'titan'];
if (!validPlanets.includes(planet)) {
notFound();
}
// Symulowane dane galerii
const galleryImages = Array.from({ length: 12 }, (_, i) => ({
id: i + 1,
src: `/images/${planet}/${i + 1}.jpg`,
alt: `Zdjęcie ${planet} #${i + 1}`,
title: `${planet.charAt(0).toUpperCase() + planet.slice(1)} - widok #${i + 1}`
}));
return (
<div className="container mx-auto py-12 px-4">
<div className="flex items-center mb-8">
<Link
href={`/destinations/${planet}`}
className="text-indigo-600 hover:underline mr-4"
>
← Wróć do {planet}
</Link>
<h1 className="text-3xl font-bold capitalize">
Galeria: {planet}
</h1>
</div>
<div className="grid grid-cols-2 md:grid-cols-3 lg:grid-cols-4 gap-4">
{galleryImages.map(image => (
<Link
key={image.id}
href={`/destinations/${planet}/gallery?image=${image.id}`}
className="block aspect-square rounded-lg overflow-hidden"
>
<img
src={image.src}
alt={image.alt}
className="w-full h-full object-cover hover:scale-105 transition-transform"
/>
</Link>
))}
</div>
</div>
);
}Slot @modal trafia do layoutu segmentu [planet] jako prop modal, obok children. Plik default.tsx mówi, co pokazać w slocie, gdy żaden modal nie jest otwarty:
// app/destinations/[planet]/layout.tsx - renderuje stronę i slot @modal
export default function PlanetLayout({
children,
modal,
}: {
children: React.ReactNode;
modal: React.ReactNode;
}) {
return (
<>
{children}
{modal}
</>
);
}// app/destinations/[planet]/@modal/default.tsx - modal zamknięty
export default function Default() {
return null;
}Sam modal czyta params hookiem use(), bo w Next.js 16 params to obietnica także w Client Component:
// app/destinations/[planet]/@modal/(.)gallery/page.tsx - Modal galerii
'use client';
import { useRouter, useSearchParams } from 'next/navigation';
import { use, useEffect, useRef, useState } from 'react';
export default function GalleryModal({ params }: { params: Promise<{ planet: string }> }) {
const router = useRouter();
const searchParams = useSearchParams();
const overlayRef = useRef(null);
const { planet } = use(params);
const imageId = searchParams.get('image');
const [isClosing, setIsClosing] = useState(false);
// Bez ?image (link „Zobacz wszystkie”) otwórz pełną galerię: twarda nawigacja omija przechwytywanie
useEffect(() => {
if (!imageId) {
window.location.assign(`/destinations/${planet}/gallery`);
}
}, [imageId, planet]);
// Obsługa klawisza ESC
useEffect(() => {
const handleKeyDown = (e) => {
if (e.key === 'Escape') {
handleClose();
}
};
window.addEventListener('keydown', handleKeyDown);
return () => window.removeEventListener('keydown', handleKeyDown);
}, []);
const handleClose = () => {
setIsClosing(true);
setTimeout(() => {
router.back();
}, 300);
};
const handleOverlayClick = (e) => {
if (e.target === overlayRef.current) {
handleClose();
}
};
if (!imageId) return null;
// Pobierz dane obrazu
const imageIndex = parseInt(imageId) - 1;
const galleryImages = Array.from({ length: 12 }, (_, i) => ({
id: i + 1,
src: `/images/${planet}/${i + 1}.jpg`,
alt: `Zdjęcie ${planet} #${i + 1}`,
title: `${planet.charAt(0).toUpperCase() + planet.slice(1)} - widok #${i + 1}`,
description: `Szczegółowy opis obrazu #${i + 1} z planety ${planet}.`
}));
const image = galleryImages[imageIndex] || galleryImages[0];
const prevImageId = image.id > 1 ? image.id - 1 : null;
const nextImageId = image.id < galleryImages.length ? image.id + 1 : null;
return (
<div
ref={overlayRef}
onClick={handleOverlayClick}
className={`fixed inset-0 z-50 bg-black/70 flex items-center justify-center p-4 transition-opacity duration-300 ${
isClosing ? 'opacity-0' : 'opacity-100'
}`}
>
<div
className={`relative bg-white rounded-lg max-w-6xl w-full max-h-[90vh] overflow-hidden shadow-xl transition-transform duration-300 ${
isClosing ? 'scale-95' : 'scale-100'
}`}
onClick={(e) => e.stopPropagation()}
>
<div className="flex h-full">
<div className="w-2/3 bg-black flex items-center justify-center">
<img
src={image.src}
alt={image.alt}
className="max-h-[85vh] max-w-full object-contain"
/>
</div>
<div className="w-1/3 p-6 flex flex-col h-[85vh]">
<button
onClick={handleClose}
className="absolute top-4 right-4 w-8 h-8 rounded-full flex items-center justify-center bg-gray-200 hover:bg-gray-300"
aria-label="Zamknij"
>
×
</button>
<h2 className="text-2xl font-bold mb-2">{image.title}</h2>
<p className="text-gray-600 mb-6">{image.description}</p>
<div className="mt-auto flex justify-between">
{prevImageId ? (
<button
onClick={() => router.replace(`/destinations/${planet}/gallery?image=${prevImageId}`)}
className="px-4 py-2 rounded border border-gray-300 hover:bg-gray-100"
>
← Poprzednie
</button>
) : <div />}
{nextImageId && (
<button
onClick={() => router.replace(`/destinations/${planet}/gallery?image=${nextImageId}`)}
className="px-4 py-2 rounded border border-gray-300 hover:bg-gray-100"
>
Następne →
</button>
)}
</div>
</div>
</div>
</div>
</div>
);
}W tym zaawansowanym przykładzie:
- Przy nawigacji do
/destinations/mars/gallery?image=1strona jest przechwytywana przez modal - Użytkownik może przeglądać obrazy w modalu bez opuszczania kontekstu strony głównej
- Po zamknięciu modalu użytkownik wraca do poprzedniej strony bez utraty kontekstu
Parallel Routing - równoległe trasy
W Metropolii Quantum zaawansowane Q-Linki potrafią podzielić się na dwie ścieżki, aby jednocześnie obsługiwać różne punkty docelowe, a następnie połączyć się ponownie, optymalizując miejski przepływ transportowy. W Next.js 16 odpowiednikiem tej technologii jest "Parallel Routing" (równoległe trasy).
Podstawowa koncepcja równoległych tras
Równoległe trasy w Next.js 16 umożliwiają renderowanie wielu stron lub komponentów w tym samym widoku, co jest szczególnie przydatne do:
- Równoległego ładowania zawartości o różnych priorytetach
- Niezależnej nawigacji między wieloma komponentami stron
- Tworzenia złożonych układów z kilkoma regionami nawigacyjnymi
Implementacja wykorzystuje foldery ze znakiem @ na początku:
app/
├── dashboard/
│ ├── layout.tsx # Układ strony
│ ├── page.tsx # Główna zawartość
│ ├── @stats/ # Slot "stats"
│ │ ├── page.tsx # Domyślna strona w slocie "stats"
│ │ └── default.tsx # Wymagany od Next.js 16
│ └── @activity/ # Slot "activity"
│ ├── page.tsx # Domyślna strona w slocie "activity"
│ └── default.tsx # Wymagany od Next.js 16Od Next.js 16 każdy slot potrzebuje własnego pliku default.tsx - bez niego next build kończy się błędem. Next.js pokazuje ten plik, gdy nie potrafi dopasować strony slotu do bieżącego adresu, np. po odświeżeniu przeglądarki na podstronie. Najprostsza wersja nic nie wyświetla:
// app/dashboard/@stats/default.tsx
export default function Default() {
return null;
}Taki plik niczego nie zmienia w wyglądzie strony, ale spełnia wymóg Next.js 16. Jeśli wolisz w tej sytuacji pokazać stronę 404, wywołaj w nim notFound().
Przykład: Dashboard kosmicznej agencji podróży
Implementacja:
// app/dashboard/layout.tsx - Układ z równoległymi trasami
export default function DashboardLayout({
children, // Główna zawartość
stats, // Slot @stats
activity // Slot @activity
}) {
return (
<div className="container mx-auto px-4 py-8">
<h1 className="text-3xl font-bold mb-8">Panel kontrolny Quantum Voyages</h1>
<div className="grid grid-cols-12 gap-8">
{/* Główna zawartość */}
<div className="col-span-12 lg:col-span-6">
{children}
</div>
{/* Panel statystyk */}
<div className="col-span-12 md:col-span-6 lg:col-span-3">
<div className="bg-white shadow rounded-lg p-4 h-full">
{stats}
</div>
</div>
{/* Panel aktywności */}
<div className="col-span-12 md:col-span-6 lg:col-span-3">
<div className="bg-white shadow rounded-lg p-4 h-full">
{activity}
</div>
</div>
</div>
</div>
);
}// app/dashboard/page.tsx - Główna zawartość
export default function DashboardPage() {
return (
<div className="bg-white shadow rounded-lg p-6">
<h2 className="text-2xl font-semibold mb-4">Przegląd rezerwacji</h2>
<div className="space-y-6">
<div className="p-4 border rounded-lg">
<h3 className="font-semibold">Nadchodząca podróż</h3>
<p className="mt-2">Mars - Kolonia Alpha, 12 czerwca 2150</p>
<div className="mt-4 flex justify-between">
<span className="text-indigo-600">Status: Potwierdzona</span>
<button className="text-sm text-indigo-600 hover:underline">
Szczegóły
</button>
</div>
</div>
<div className="p-4 border rounded-lg">
<h3 className="font-semibold">Historia podróży</h3>
<ul className="mt-2 space-y-2">
<li className="flex justify-between">
<span>Europa - Stacja Badawcza</span>
<span>24 marca 2150</span>
</li>
<li className="flex justify-between">
<span>Księżyc - Baza Armstrong</span>
<span>12 stycznia 2150</span>
</li>
</ul>
</div>
<div className="p-4 border rounded-lg">
<h3 className="font-semibold">Rekomendowane destynacje</h3>
<ul className="mt-2 space-y-2">
<li>
<a href="/destinations/titan" className="text-indigo-600 hover:underline">
Tytan - nowo otwarte kolonie
</a>
</li>
<li>
<a href="/destinations/venus-orbiter" className="text-indigo-600 hover:underline">
Orbiter Wenus - pobyt naukowy
</a>
</li>
</ul>
</div>
</div>
</div>
);
}// app/dashboard/@stats/page.tsx - Statystyki
export default function StatsPage() {
// W rzeczywistej aplikacji, te dane byłyby pobierane z API
const stats = [
{ label: 'Łączna liczba lotów', value: '7' },
{ label: 'Odwiedzone planety', value: '3' },
{ label: 'Punkty lojalnościowe', value: '12,540' },
{ label: 'Status członka', value: 'Gold' }
];
return (
<div>
<h2 className="text-xl font-semibold mb-4">Statystyki podróży</h2>
<div className="space-y-4">
{stats.map((stat, index) => (
<div key={index} className="flex justify-between">
<span className="text-gray-600">{stat.label}:</span>
<span className="font-semibold">{stat.value}</span>
</div>
))}
</div>
<div className="mt-6 pt-4 border-t">
<div className="flex justify-between items-center">
<span className="text-gray-600">Poziom następnego statusu:</span>
<span className="text-sm font-medium">Platinum</span>
</div>
<div className="mt-2 w-full bg-gray-200 rounded-full h-2.5">
<div className="bg-indigo-600 h-2.5 rounded-full" style={{ width: '70%' }}></div>
</div>
<p className="mt-1 text-xs text-right text-gray-500">7,460 punktów do następnego poziomu</p>
</div>
</div>
);
}// app/dashboard/@activity/page.tsx - Aktywność
export default function ActivityPage() {
// W rzeczywistej aplikacji, te dane byłyby pobierane z API
const activities = [
{ type: 'reservation', message: 'Zarezerwowałeś podróż na Mars', time: '2 godziny temu' },
{ type: 'check-in', message: 'Odbyto odprawę online na lot QV-105', time: '3 dni temu' },
{ type: 'payment', message: 'Dokonano płatności 12,500 CR', time: '1 tydzień temu' },
{ type: 'review', message: 'Napisałeś recenzję dla Bazy Armstrong', time: '2 tygodnie temu' }
];
return (
<div>
<h2 className="text-xl font-semibold mb-4">Ostatnia aktywność</h2>
<div className="space-y-4">
{activities.map((activity, index) => (
<div key={index} className="flex items-start">
<div className={`mt-1 rounded-full w-2 h-2 mr-2 ${
activity.type === 'reservation' ? 'bg-green-500' :
activity.type === 'check-in' ? 'bg-blue-500' :
activity.type === 'payment' ? 'bg-purple-500' :
'bg-yellow-500'
}`}></div>
<div>
<p className="text-sm">{activity.message}</p>
<p className="text-xs text-gray-500">{activity.time}</p>
</div>
</div>
))}
</div>
<div className="mt-6 flex justify-center">
<button className="text-sm text-indigo-600 hover:underline">
Zobacz wszystkie aktywności
</button>
</div>
</div>
);
}Ten przykład demonstruje, jak równoległe trasy umożliwiają tworzenie złożonych układów, gdzie różne części strony mogą być niezależnie aktualizowane i ładowane.
Podsumowanie
Podobnie jak zaawansowany system transportowy w Metropolii Quantum umożliwia mieszkańcom płynne przemieszczanie się pomiędzy różnymi częściami miasta, tak nawigacja w Next.js 16 oferuje deweloperom i użytkownikom niezwykle wydajny i intuicyjny system poruszania się po aplikacji.
Kluczowe elementy nawigacji w Next.js 16:
Komponent Link - podstawowy element nawigacji, który umożliwia szybkie przejścia między stronami bez pełnego przeładowania, dzięki automatycznemu prefetchingowi i optymalizacjom.
useRouter - hook umożliwiający programistyczną nawigację, idealne do dynamicznego kierowania użytkowników na podstawie określonych warunków czy zdarzeń.
usePathname i useSearchParams - hooki do monitorowania bieżącej ścieżki i parametrów zapytania, umożliwiające reaktywne dostosowywanie UI.
Intercepting Routes - zaawansowana funkcja pozwalająca na przechwytywanie nawigacji do określonych ścieżek i wyświetlanie alternatywnego UI, często w formie modalu.
Parallel Routing - umożliwia renderowanie wielu stron lub komponentów w jednym widoku, idealne do złożonych dashboardów i interfejsów z wieloma regionami nawigacyjnymi.
Te narzędzia, wykorzystane razem, umożliwiają tworzenie wydajnych, intuicyjnych i zaawansowanych systemów nawigacji, które znacząco poprawiają doświadczenie użytkownika i wydajność aplikacji.
W następnym rozdziale odkryjemy techniki grupowania i organizacji tras, które pomogą utrzymać porządek i strukturę w bardziej złożonych aplikacjach, podobnie jak planowanie stref w Metropolii Quantum pomaga utrzymać miasto zorganizowane i efektywne.
Hasła z dokumentacji w tej lekcji
Widzisz błąd w tej lekcji?