Kurs Next.js · Moduł 2: Routing i layouty
Dynamiczne segmenty ścieżki i parametry
W tej lekcji7
W Metropolii Quantum najnowocześniejszy system transportowy posiada niezwykłą zdolność dostosowywania się do potrzeb obywateli. Trasy transportowe nie są sztywno określone - mogą dynamicznie reorganizować się, aby doprowadzić podróżnych do dowolnego miejsca w mieście. Ta elastyczność jest kluczowa dla efektywnego funkcjonowania tak złożonego organizmu miejskiego.
W świecie Next.js 16 analogiczną funkcję pełnią dynamiczne segmenty ścieżki, które pozwalają tworzyć trasy, które adaptują się do różnych parametrów i kontekstów. To one sprawiają, że nawigacja w aplikacji staje się prawdziwie interaktywna i dostosowana do potrzeb użytkownika.
Dynamiczne segmenty w App Routerze
W Next.js 16 dynamiczne segmenty ścieżki tworzy się poprzez umieszczenie nazwy parametru w nawiasach kwadratowych [param]. Taki folder będzie dopasowywał się do różnych wartości w tym segmencie URL, a wartość parametru będzie dostępna wewnątrz komponentów strony.
Podstawowe dynamiczne segmenty
Oto jak wygląda struktura plików dla aplikacji z dynamicznymi segmentami:
app/
├── destinations/
│ ├── page.tsx # pasuje do /destinations
│ └── [planetId]/ # pasuje do /destinations/:planetId (dynamiczny segment)
│ └── page.tsx # pasuje do /destinations/mars, /destinations/venus, etc.W tym przykładzie [planetId] to dynamiczny segment, który może przyjąć dowolną wartość, np. "mars", "venus", czy "jupiter". Ta wartość jest następnie dostępna w komponencie strony przez prop params. W Next.js 16 params to obietnica (Promise), więc odczytujesz ją przez const { planetId } = await params.
Implementacja strony z dynamicznym segmentem
Spójrzmy na implementację strony, która wykorzystuje dynamiczny segment [planetId]:
// app/destinations/[planetId]/page.tsx
import Image from 'next/image';
import { notFound } from 'next/navigation';
// Ten typ definiuje strukturę parametrów dla tej strony
type PlanetPageParams = {
params: Promise<{
planetId: string;
}>;
};
async function getPlanetData(planetId: string) {
// Tutaj normalnie pobieralibyśmy dane z API lub bazy danych
// Na potrzeby przykładu używamy statycznych danych
const planets: Record<string, {
name: string;
description: string;
gravity: string;
diameter: string;
dayLength: string;
yearLength: string;
temperature: string;
imageUrl: string;
}> = {
'mars': {
name: 'Mars',
description: 'Czerwona planeta znana z trudnych warunków i fascynujących zjawisk geologicznych.',
gravity: '3.721 m/s²',
diameter: '6,779 km',
dayLength: '24h 37m',
yearLength: '687 dni ziemskich',
temperature: '-63°C (średnia)',
imageUrl: '/images/mars.jpg'
},
'venus': {
name: 'Wenus',
description: 'Druga planeta od Słońca, znana z ekstremalnie gorącego klimatu i gęstej atmosfery.',
gravity: '8.87 m/s²',
diameter: '12,104 km',
dayLength: '243 dni ziemskie',
yearLength: '225 dni ziemskich',
temperature: '462°C (średnia)',
imageUrl: '/images/venus.jpg'
},
'jupiter': {
name: 'Jowisz',
description: 'Największa planeta Układu Słonecznego, znana z Wielkiej Czerwonej Plamy i licznych księżyców.',
gravity: '24.79 m/s²',
diameter: '139,820 km',
dayLength: '9h 56m',
yearLength: '11.86 lat ziemskich',
temperature: '-108°C (średnia)',
imageUrl: '/images/jupiter.jpg'
}
};
return planets[planetId];
}
// Komponent otrzymuje params jako props
export default async function PlanetPage({ params }: PlanetPageParams) {
// Pobranie danych planety na podstawie planetId
const planet = await getPlanetData((await params).planetId);
// Jeśli planeta nie istnieje, wyświetl stronę 404
if (!planet) {
notFound();
}
return (
<div className="container mx-auto px-4 py-12">
<h1 className="text-4xl font-bold mb-8">{planet.name}</h1>
<div className="grid grid-cols-1 lg:grid-cols-2 gap-12">
<div className="relative h-96 lg:h-auto rounded-lg overflow-hidden">
<Image
src={planet.imageUrl}
alt={planet.name}
fill
className="object-cover"
preload
/>
</div>
<div className="space-y-6">
<p className="text-lg text-gray-700">{planet.description}</p>
<div className="bg-gray-50 p-6 rounded-lg shadow-sm">
<h2 className="text-2xl font-semibold mb-4">Dane planetarne</h2>
<table className="w-full">
<tbody>
<tr className="border-b">
<th className="text-left py-2">Grawitacja</th>
<td className="text-right py-2">{planet.gravity}</td>
</tr>
<tr className="border-b">
<th className="text-left py-2">Średnica</th>
<td className="text-right py-2">{planet.diameter}</td>
</tr>
<tr className="border-b">
<th className="text-left py-2">Długość dnia</th>
<td className="text-right py-2">{planet.dayLength}</td>
</tr>
<tr className="border-b">
<th className="text-left py-2">Długość roku</th>
<td className="text-right py-2">{planet.yearLength}</td>
</tr>
<tr>
<th className="text-left py-2">Temperatura</th>
<td className="text-right py-2">{planet.temperature}</td>
</tr>
</tbody>
</table>
</div>
<div className="flex space-x-4">
<a
href={`/destinations/${(await params).planetId}/colonies`}
className="px-6 py-3 bg-indigo-600 text-white rounded-lg hover:bg-indigo-700 transition-colors"
>
Kolonie
</a>
<a
href={`/destinations/${(await params).planetId}/tours`}
className="px-6 py-3 border border-indigo-600 text-indigo-600 rounded-lg hover:bg-indigo-50 transition-colors"
>
Wycieczki
</a>
</div>
</div>
</div>
</div>
);
}W powyższym kodzie:
- Definiujemy typ
PlanetPageParams, który określa strukturę parametrów otrzymywanych przez komponent - Komponent
PlanetPageotrzymuje obiektparamszawierającyplanetIdz URL - Używamy tego
planetIddo pobrania danych o planecie - Wyświetlamy szczegółowe informacje o planecie, a także linki do podstron, które również wykorzystują ten sam parametr
Generowanie statycznych stron dla znanych parametrów
Jeśli znamy z góry wszystkie możliwe wartości dla dynamicznego segmentu, możemy wygenerować statyczne strony podczas budowania aplikacji, co znacznie poprawi wydajność. Służy do tego funkcja generateStaticParams:
// app/destinations/[planetId]/page.tsx
// Ta funkcja definiuje statyczne ścieżki, które zostaną wygenerowane podczas budowania
export async function generateStaticParams() {
// Tutaj normalnie pobieralibyśmy dane z API lub bazy danych
// Zwracamy tablicę obiektów z parametrami, które mają być wygenerowane statycznie
return [
{ planetId: 'mars' },
{ planetId: 'venus' },
{ planetId: 'jupiter' }
];
}
// Reszta komponentu...Dzięki temu Next.js wygeneruje trzy statyczne strony podczas budowania: dla Marsa, Wenus i Jowisza. To znacznie przyspieszy ich ładowanie, ponieważ nie będą musiały być generowane dynamicznie przy każdym żądaniu.
Wielopoziomowe dynamiczne segmenty
W Metropolii Quantum system transportowy umożliwia podróżowanie do dowolnego celu poprzez serię precyzyjnych przesiadek, z których każda zawęża przestrzeń do wybranego celu. Podobnie w Next.js 16 możemy tworzyć wielopoziomowe dynamiczne segmenty, aby dokładnie określić żądane zasoby.
Struktura z wieloma dynamicznymi segmentami
app/
├── destinations/
│ ├── [planetId]/ # pasuje do /destinations/:planetId
│ │ ├── page.tsx # pasuje do /destinations/mars
│ │ └── [moonId]/ # pasuje do /destinations/:planetId/:moonId
│ │ └── page.tsx # pasuje do /destinations/mars/phobos
│ └── page.tsx # pasuje do /destinationsW tej strukturze mamy dwa poziomy dynamicznych segmentów:
[planetId]- identyfikator planety[moonId]- identyfikator księżyca danej planety
Implementacja strony z zagnieżdżonymi parametrami
// app/destinations/[planetId]/[moonId]/page.tsx
import Image from 'next/image';
import Link from 'next/link';
import { notFound } from 'next/navigation';
type MoonPageParams = {
params: Promise<{
planetId: string;
moonId: string;
}>;
};
async function getMoonData(planetId: string, moonId: string) {
// System mapowania księżyców do planet
const moonData: Record<string, Record<string, {
name: string;
description: string;
diameter: string;
orbitDistance: string;
discovered: string;
imageUrl: string;
}>> = {
'mars': {
'phobos': {
name: 'Phobos',
description: 'Większy i bliższy z dwóch naturalnych satelitów Marsa, krąży wokół planety co 7 godzin i 39 minut.',
diameter: '22.2 km',
orbitDistance: '9,376 km',
discovered: '1877',
imageUrl: '/images/phobos.jpg'
},
'deimos': {
name: 'Deimos',
description: 'Mniejszy i dalszy z dwóch naturalnych satelitów Marsa, o nieregularnym kształcie.',
diameter: '12.6 km',
orbitDistance: '23,463 km',
discovered: '1877',
imageUrl: '/images/deimos.jpg'
}
},
'jupiter': {
'europa': {
name: 'Europa',
description: 'Księżyc Jowisza, który może posiadać podpowierzchniowy ocean wody pod lodową skorupą.',
diameter: '3,121.6 km',
orbitDistance: '670,900 km',
discovered: '1610',
imageUrl: '/images/europa.jpg'
},
'io': {
name: 'Io',
description: 'Najbardziej aktywny wulkanicznie obiekt w Układzie Słonecznym, z ponad 400 aktywnymi wulkanami.',
diameter: '3,643.2 km',
orbitDistance: '421,700 km',
discovered: '1610',
imageUrl: '/images/io.jpg'
},
'ganymede': {
name: 'Ganimedes',
description: 'Największy księżyc w Układzie Słonecznym, większy nawet od planety Merkury.',
diameter: '5,268.2 km',
orbitDistance: '1,070,400 km',
discovered: '1610',
imageUrl: '/images/ganymede.jpg'
}
}
};
// Sprawdzenie, czy planeta i księżyc istnieją
if (!moonData[planetId] || !moonData[planetId][moonId]) {
return null;
}
return {
...moonData[planetId][moonId],
planet: planetId
};
}
export default async function MoonPage({ params }: MoonPageParams) {
const { planetId, moonId } = await params;
const moon = await getMoonData(planetId, moonId);
if (!moon) {
notFound();
}
return (
<div className="container mx-auto px-4 py-12">
<div className="flex items-center mb-8">
<Link
href={`/destinations/${planetId}`}
className="text-indigo-600 hover:underline flex items-center"
>
<svg className="w-4 h-4 mr-2" fill="none" stroke="currentColor" viewBox="0 0 24 24">
<path strokeLinecap="round" strokeLinejoin="round" strokeWidth={2} d="M15 19l-7-7 7-7" />
</svg>
Wróć do {planetId.charAt(0).toUpperCase() + planetId.slice(1)}
</Link>
</div>
<h1 className="text-4xl font-bold mb-8">{moon.name}</h1>
<div className="grid grid-cols-1 lg:grid-cols-2 gap-12">
<div className="relative h-96 lg:h-auto rounded-lg overflow-hidden">
<Image
src={moon.imageUrl}
alt={moon.name}
fill
className="object-cover"
preload
/>
</div>
<div className="space-y-6">
<p className="text-lg text-gray-700">{moon.description}</p>
<div className="bg-gray-50 p-6 rounded-lg shadow-sm">
<h2 className="text-2xl font-semibold mb-4">Informacje</h2>
<table className="w-full">
<tbody>
<tr className="border-b">
<th className="text-left py-2">Planeta</th>
<td className="text-right py-2">{moon.planet.charAt(0).toUpperCase() + moon.planet.slice(1)}</td>
</tr>
<tr className="border-b">
<th className="text-left py-2">Średnica</th>
<td className="text-right py-2">{moon.diameter}</td>
</tr>
<tr className="border-b">
<th className="text-left py-2">Odległość orbity</th>
<td className="text-right py-2">{moon.orbitDistance}</td>
</tr>
<tr>
<th className="text-left py-2">Odkryty</th>
<td className="text-right py-2">{moon.discovered}</td>
</tr>
</tbody>
</table>
</div>
<div className="flex space-x-4">
<a
href={`/destinations/${planetId}/${moonId}/research`}
className="px-6 py-3 bg-indigo-600 text-white rounded-lg hover:bg-indigo-700 transition-colors"
>
Badania naukowe
</a>
<a
href={`/destinations/${planetId}/${moonId}/landing-sites`}
className="px-6 py-3 border border-indigo-600 text-indigo-600 rounded-lg hover:bg-indigo-50 transition-colors"
>
Miejsca lądowań
</a>
</div>
</div>
</div>
</div>
);
}
export async function generateStaticParams() {
// Generujemy wszystkie możliwe kombinacje planet i ich księżyców
return [
{ planetId: 'mars', moonId: 'phobos' },
{ planetId: 'mars', moonId: 'deimos' },
{ planetId: 'jupiter', moonId: 'europa' },
{ planetId: 'jupiter', moonId: 'io' },
{ planetId: 'jupiter', moonId: 'ganymede' }
];
}W tym przykładzie:
- Komponent otrzymuje dwa parametry:
planetIdimoonId - Używamy obu parametrów do pobrania danych o konkretnym księżycu konkretnej planety
- Implementujemy nawigację z powrotem do strony planety
- Generujemy statycznie wszystkie znane kombinacje planet i księżyców
Parametry typu catch-all i opcjonalne catch-all
W Metropolii Quantum niektóre linie transportowe są tak elastyczne, że mogą docierać do dowolnej liczby punktów wzdłuż trasy, pobierając wszystkie istotne dane o trasie jako parametry podróży. W Next.js 16 odpowiednikami są segmenty typu catch-all i opcjonalne catch-all.
Segmenty catch-all ([...param])
Segment catch-all, oznaczony jako [...param], dopasowuje ścieżkę o dowolnej liczbie segmentów. Wszystkie dopasowane segmenty są przekazywane jako tablica.
app/
├── stellar-objects/
│ ├── [...path]/ # pasuje do /stellar-objects/any/number/of/segments
│ │ └── page.tsx
│ └── page.tsx # pasuje do /stellar-objectsImplementacja strony z segmentem catch-all:
// app/stellar-objects/[...path]/page.tsx
type CatchAllParams = {
params: Promise<{
path: string[];
}>;
};
export default async function StellarObjectsPage({ params }: CatchAllParams) {
const { path } = await params;
return (
<div className="container mx-auto px-4 py-12">
<h1 className="text-4xl font-bold mb-8">Przeglądarka obiektów kosmicznych</h1>
<div className="bg-gray-100 p-4 rounded mb-8">
<p className="font-mono">Ścieżka: /{path.join('/')}</p>
<p>Segmenty: {path.length}</p>
<ul className="list-disc pl-6 mt-2">
{path.map((segment, index) => (
<li key={index}>Segment {index + 1}: {segment}</li>
))}
</ul>
</div>
{/* Tutaj normalna zawartość strony... */}
</div>
);
}Przykładowy URL: /stellar-objects/stars/main-sequence/g-type zostanie dopasowany do tej strony, a path odczytane przez await params będzie tablicą ["stars", "main-sequence", "g-type"].
Opcjonalne segmenty catch-all ([[...param]])
Opcjonalny segment catch-all, oznaczony jako [[...param]] (podwójne nawiasy kwadratowe), działa podobnie do standardowego catch-all, ale dopasowuje również ścieżkę bez dodatkowych segmentów.
app/
├── knowledge-base/
├── [[...topic]]/ # pasuje do /knowledge-base, /knowledge-base/planets, /knowledge-base/planets/terrestrial, etc.
└── page.tsxImplementacja:
// app/knowledge-base/[[...topic]]/page.tsx
type OptionalCatchAllParams = {
params: Promise<{
topic?: string[];
}>;
};
export default async function KnowledgeBasePage({ params }: OptionalCatchAllParams) {
const { topic } = await params;
// Jeśli topic nie istnieje, to jesteśmy na głównej stronie bazy wiedzy
const isRoot = !topic || topic.length === 0;
return (
<div className="container mx-auto px-4 py-12">
<h1 className="text-4xl font-bold mb-8">
{isRoot ? 'Baza wiedzy kosmicznej' : 'Temat: ' + topic.join(' > ')}
</h1>
{isRoot ? (
<div className="grid grid-cols-1 md:grid-cols-3 gap-6">
<TopicCard title="Planety" href="/knowledge-base/planets" />
<TopicCard title="Gwiazdy" href="/knowledge-base/stars" />
<TopicCard title="Galaktyki" href="/knowledge-base/galaxies" />
{/* Więcej kart tematów... */}
</div>
) : (
<div>
<div className="bg-gray-100 p-4 rounded mb-8">
<p>Przeglądasz temat: <strong>{topic.join(' > ')}</strong></p>
<div className="mt-4">
<a href="/knowledge-base" className="text-indigo-600 hover:underline">
Wróć do głównej strony bazy wiedzy
</a>
</div>
</div>
{/* Zawartość konkretnego tematu... */}
</div>
)}
</div>
);
}
function TopicCard({ title, href }: { title: string; href: string }) {
return (
<a href={href} className="block p-6 bg-white rounded-lg shadow-md hover:shadow-lg transition-shadow">
<h2 className="text-xl font-semibold mb-2">{title}</h2>
<p className="text-gray-600">Odkryj wiedzę o {title.toLowerCase()}.</p>
</a>
);
}Ta strona dopasuje zarówno /knowledge-base (główna strona bazy wiedzy), jak i /knowledge-base/planets/terrestrial (konkretny temat).
Parametry w Route Handlers
W Metropolii Quantum nie tylko linie transportowe dla obywateli używają parametrów trasy - również zautomatyzowane systemy komunikują się ze sobą poprzez dynamicznie konfigurowane kanały. W Next.js 16 odpowiednikiem są Route Handlers, które również mogą wykorzystywać dynamiczne segmenty.
Dynamiczne segmenty w API Routes
app/
├── api/
├── planets/
├── [id]/
│ └── route.ts # pasuje do /api/planets/:id
└── route.ts # pasuje do /api/planetsImplementacja Route Handler z dynamicznym segmentem:
// app/api/planets/[id]/route.ts
import { NextRequest, NextResponse } from 'next/server';
// Typ dla parametrów
type PlanetRouteContext = {
params: Promise<{
id: string;
}>;
};
// Przykładowe dane
const planetData: Record<string, { id: string; name: string; type: string; habitable: boolean }> = {
'mars': {
id: 'mars',
name: 'Mars',
type: 'terrestrial',
habitable: false
},
'earth': {
id: 'earth',
name: 'Ziemia',
type: 'terrestrial',
habitable: true
},
'jupiter': {
id: 'jupiter',
name: 'Jowisz',
type: 'gas-giant',
habitable: false
}
};
export async function GET(
request: NextRequest,
{ params }: PlanetRouteContext
) {
const { id } = await params;
// Sprawdzenie, czy planeta istnieje
if (!planetData[id]) {
return NextResponse.json(
{ error: 'Planeta nie znaleziona' },
{ status: 404 }
);
}
// Zwrócenie danych planety
return NextResponse.json(planetData[id]);
}
export async function PUT(
request: NextRequest,
{ params }: PlanetRouteContext
) {
const { id } = await params;
// Sprawdzenie, czy planeta istnieje
if (!planetData[id]) {
return NextResponse.json(
{ error: 'Planeta nie znaleziona' },
{ status: 404 }
);
}
try {
// Pobranie danych z żądania
const updateData = await request.json();
// Aktualizacja danych planety (tu tylko symulacja)
// W rzeczywistej aplikacji zapisalibyśmy to do bazy danych
const updatedPlanet = {
...planetData[id],
...updateData
};
// Zwrócenie zaktualizowanych danych
return NextResponse.json(updatedPlanet);
} catch (error) {
return NextResponse.json(
{ error: 'Nieprawidłowe dane' },
{ status: 400 }
);
}
}
export async function DELETE(
request: NextRequest,
{ params }: PlanetRouteContext
) {
const { id } = await params;
// Sprawdzenie, czy planeta istnieje
if (!planetData[id]) {
return NextResponse.json(
{ error: 'Planeta nie znaleziona' },
{ status: 404 }
);
}
// Usunięcie planety (tu tylko symulacja)
// W rzeczywistej aplikacji usunęlibyśmy to z bazy danych
return NextResponse.json({ success: true });
}W tym przykładzie:
- Route Handler obsługuje żądania dla konkretnej planety określonej przez
id - Implementujemy metody GET, PUT i DELETE dla zarządzania danymi planety
- Parametr
idjest dostępny przez obiektparamsprzekazywany do funkcji obsługujących
Pobieranie parametrów zapytania (query parameters)
W Metropolii Quantum, poza głównymi trasami, system transportowy może być dodatkowo konfigurowany przez opcjonalne parametry, takie jak "expressFlight" czy "comfortLevel". W świecie Next.js te opcjonalne ustawienia są reprezentowane przez parametry zapytania (query parameters).
Dostęp do parametrów zapytania w Server Components
// app/search/page.tsx
import { Suspense } from 'react';
// To jest komponent serwerowy
export default async function SearchPage({
searchParams
}: {
searchParams: Promise<{ [key: string]: string | string[] | undefined }>
}) {
// Pobranie parametrów zapytania
const query = (await searchParams).q || '';
const category = (await searchParams).category || 'all';
const page = Number((await searchParams).page) || 1;
return (
<div className="container mx-auto px-4 py-12">
<h1 className="text-4xl font-bold mb-8">Wyszukiwarka kosmiczna</h1>
<div className="mb-8">
<p>Wyszukiwanie: <strong>{query}</strong></p>
<p>Kategoria: <strong>{category}</strong></p>
<p>Strona: <strong>{page}</strong></p>
</div>
<Suspense fallback={<div>Ładowanie wyników...</div>}>
<SearchResults query={query} category={category} page={page} />
</Suspense>
</div>
);
}
// Ten komponent pobiera i wyświetla wyniki
async function SearchResults({
query,
category,
page
}: {
query: string | string[],
category: string | string[],
page: number
}) {
// Tutaj normalnie pobieralibyśmy dane na podstawie parametrów
// Symulacja opóźnienia dla demonstracji Suspense
await new Promise(resolve => setTimeout(resolve, 1000));
// Jeśli nie ma zapytania, wyświetl komunikat
if (!query) {
return (
<div className="bg-gray-100 p-8 rounded-lg text-center">
<p className="text-lg">Wpisz frazę, aby rozpocząć wyszukiwanie.</p>
</div>
);
}
// Tutaj normalnie wyświetlalibyśmy wyniki wyszukiwania
return (
<div className="space-y-6">
<div className="p-6 bg-white rounded-lg shadow">
<h2 className="text-xl font-semibold mb-2">Wynik 1</h2>
<p>Znaleziono dla: {query}</p>
</div>
<div className="p-6 bg-white rounded-lg shadow">
<h2 className="text-xl font-semibold mb-2">Wynik 2</h2>
<p>Znaleziono dla: {query}</p>
</div>
<div className="p-6 bg-white rounded-lg shadow">
<h2 className="text-xl font-semibold mb-2">Wynik 3</h2>
<p>Znaleziono dla: {query}</p>
</div>
<div className="flex justify-center space-x-2 mt-8">
<a
href={`/search?q=${query}&category=${category}&page=${Math.max(1, page - 1)}`}
className={`px-4 py-2 border rounded ${page === 1 ? 'text-gray-400 cursor-not-allowed' : 'text-indigo-600 hover:bg-indigo-50'}`}
>
Poprzednia
</a>
<span className="px-4 py-2 bg-indigo-600 text-white rounded">
{page}
</span>
<a
href={`/search?q=${query}&category=${category}&page=${page + 1}`}
className="px-4 py-2 border rounded text-indigo-600 hover:bg-indigo-50"
>
Następna
</a>
</div>
</div>
);
}W tym przykładzie:
- Komponent
SearchPageotrzymujesearchParamsjako props, zawierający wszystkie parametry zapytania z URL - Wykorzystujemy te parametry do konfiguracji wyszukiwania
- Implementujemy komponent
SearchResults, który pobiera dane na podstawie parametrów - Używamy
Suspensedo obsługi stanu ładowania
Dostęp do parametrów zapytania w Route Handlers
// app/api/search/route.ts
import { NextRequest, NextResponse } from 'next/server';
export async function GET(request: NextRequest) {
// Pobranie URL z żądania
const { searchParams } = new URL(request.url);
// Pobranie parametrów zapytania
const query = searchParams.get('q');
const category = searchParams.get('category') || 'all';
const page = Number(searchParams.get('page')) || 1;
const limit = Number(searchParams.get('limit')) || 10;
// Sprawdzenie czy query istnieje
if (!query) {
return NextResponse.json(
{ error: 'Parametr q (zapytanie) jest wymagany' },
{ status: 400 }
);
}
// Tutaj normalnie pobieralibyśmy dane z bazy danych
// Na potrzeby przykładu zwracamy symulowane dane
const results = Array.from({ length: limit }, (_, i) => ({
id: `result-${(page - 1) * limit + i + 1}`,
title: `Wynik ${(page - 1) * limit + i + 1} dla "${query}"`,
category,
relevance: Math.round(Math.random() * 100)
}));
return NextResponse.json({
query,
category,
page,
limit,
totalResults: 100, // Symulowana całkowita liczba wyników
results
});
}W tym przykładzie:
- Używamy
new URL(request.url).searchParamsdo pobrania parametrów zapytania - Wyciągamy i walidujemy konkretne parametry
- Zwracamy dane odpowiednie dla podanych parametrów
Generowanie dynamicznych metadanych
W Metropolii Quantum każda linia transportowa posiada dynamicznie generowane informacje dotyczące trasy, dostępne poprzez system informacyjny miasta. W Next.js 16 możemy generować dynamiczne metadane dla każdej strony, korzystając z funkcji generateMetadata.
// app/destinations/[planetId]/page.tsx
import type { Metadata } from 'next';
// Typ dla parametrów
type PlanetParams = {
params: Promise<{
planetId: string;
}>;
};
// Funkcja generująca metadane na podstawie planetId
export async function generateMetadata(
{ params }: PlanetParams
): Promise<Metadata> {
const { planetId } = await params;
// Pobieranie danych o planecie
const planet = await getPlanetData(planetId);
// Jeśli planeta nie istnieje, zwróć domyślne metadane
if (!planet) {
return {
title: 'Planeta nie znaleziona | Quantum Voyages',
description: 'Nie znaleziono informacji o żądanej planecie.'
};
}
// Zwróć metadane specyficzne dla planety
return {
title: `${planet.name} | Quantum Voyages`,
description: planet.description.substring(0, 160), // Ogranicz do 160 znaków dla SEO
openGraph: {
title: `Odkryj ${planet.name} z Quantum Voyages`,
description: planet.description.substring(0, 160),
images: [
{
url: `https://example.com${planet.imageUrl}`,
width: 1200,
height: 630,
alt: planet.name
}
]
}
};
}
// Reszta kodu komponentu...W tym przykładzie:
generateMetadataotrzymuje te sameparamsco komponent strony- Używamy
planetIddo pobrania danych o planecie - Generujemy dynamiczne metadane, w tym tytuł, opis i dane dla Open Graph
- Metadane te są używane do zoptymalizowania SEO strony
Metadane są zbierane od głównego layoutu w dół, aż do strony: Next.js płytko scala obiekty z kolejnych segmentów (pola zdefiniowane w stronie nadpisują te same pola z layoutu), a wynik trafia do sekcji <head> dokumentu.
Podsumowanie
Dynamiczne segmenty ścieżki i parametry w Next.js 16 to potężne narzędzia, które umożliwiają tworzenie elastycznych i interaktywnych aplikacji. Podobnie jak w Metropolii Quantum, gdzie system transportowy adaptuje się do potrzeb obywateli, tak dynamiczny routing w Next.js dostosowuje się do potrzeb użytkowników.
Kluczowe punkty do zapamiętania:
- Dynamiczne segmenty tworzy się poprzez umieszczenie nazwy parametru w nawiasach kwadratowych
[param] - Wartości parametrów są dostępne w komponentach strony poprzez prop
params - Segmenty catch-all (
[...param]) umożliwiają dopasowanie wielu segmentów ścieżki - Opcjonalne segmenty catch-all (
[[...param]]) działają podobnie, ale dopasowują również ścieżkę bez dodatkowych segmentów - Parametry zapytania są dostępne przez prop
searchParamsw komponentach strony - Dynamiczne metadane mogą być generowane na podstawie parametrów ścieżki
Dzięki tym funkcjom możesz tworzyć zaawansowane aplikacje z intuicyjną nawigacją i bogatymi funkcjami dopasowanymi do konkretnych potrzeb użytkownika.
W następnym rozdziale odkryjemy, jak efektywnie nawigować pomiędzy różnymi stronami w naszej aplikacji przy użyciu komponentu Link i hooka useRouter.
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. Dynamiczne segmenty URL w App Routerze tworzy się używając:
2. Plik loading.js w App Routerze wyświetla się:
3. Plik error.js w App Routerze służy do:
Zadania praktyczne w grze
- Edytor kodu
Utwórz stronę app/product/[id]/page.js: wyeksportuj domyślnie async komponent ProductPage({ params }). W Next.js 16 params to Promise, więc odczytaj id przez const { id } = await params i wyświetl nagłówek h1 z tekstem „Produkt {id}”.
- Układanie w pionie
Ułóż składnię funkcji generateStaticParams w App Routerze
- Edytor kodu
Utwórz plik loading.js z eksportowanym domyślnie komponentem Loading, który wyświetla tekst „Ładowanie...” (możesz dodać obok spinner, np. div z klasą spinner).