Kurs Next.js · Moduł 2: Routing i layouty

Dynamiczne segmenty ścieżki i parametry

16 min czytania ·
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:

  1. Definiujemy typ PlanetPageParams, który określa strukturę parametrów otrzymywanych przez komponent
  2. Komponent PlanetPage otrzymuje obiekt params zawierający planetId z URL
  3. Używamy tego planetId do pobrania danych o planecie
  4. 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 /destinations

W tej strukturze mamy dwa poziomy dynamicznych segmentów:

  1. [planetId] - identyfikator planety
  2. [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:

  1. Komponent otrzymuje dwa parametry: planetId i moonId
  2. Używamy obu parametrów do pobrania danych o konkretnym księżycu konkretnej planety
  3. Implementujemy nawigację z powrotem do strony planety
  4. 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-objects

Implementacja 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.tsx

Implementacja:

// 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/planets

Implementacja 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:

  1. Route Handler obsługuje żądania dla konkretnej planety określonej przez id
  2. Implementujemy metody GET, PUT i DELETE dla zarządzania danymi planety
  3. Parametr id jest dostępny przez obiekt params przekazywany 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:

  1. Komponent SearchPage otrzymuje searchParams jako props, zawierający wszystkie parametry zapytania z URL
  2. Wykorzystujemy te parametry do konfiguracji wyszukiwania
  3. Implementujemy komponent SearchResults, który pobiera dane na podstawie parametrów
  4. Używamy Suspense do 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:

  1. Używamy new URL(request.url).searchParams do pobrania parametrów zapytania
  2. Wyciągamy i walidujemy konkretne parametry
  3. 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:

  1. generateMetadata otrzymuje te same params co komponent strony
  2. Używamy planetId do pobrania danych o planecie
  3. Generujemy dynamiczne metadane, w tym tytuł, opis i dane dla Open Graph
  4. 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:

  1. Dynamiczne segmenty tworzy się poprzez umieszczenie nazwy parametru w nawiasach kwadratowych [param]
  2. Wartości parametrów są dostępne w komponentach strony poprzez prop params
  3. Segmenty catch-all ([...param]) umożliwiają dopasowanie wielu segmentów ścieżki
  4. Opcjonalne segmenty catch-all ([[...param]]) działają podobnie, ale dopasowują również ścieżkę bez dodatkowych segmentów
  5. Parametry zapytania są dostępne przez prop searchParams w komponentach strony
  6. 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. 1. Dynamiczne segmenty URL w App Routerze tworzy się używając:

  2. 2. Plik loading.js w App Routerze wyświetla się:

  3. 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).

  1. PytanieDynamiczne segmenty URL
  2. PytaniePlik loading.js w App Routerze
  3. Zadanie z kodemPraktyka: Dynamiczna strona produktu
  4. Ułóż w kolejnościSkładnia generateStaticParams
  5. PytaniePlik error.js w App Routerze
  6. Zadanie z kodemPraktyka: Loading UI

Przydatne artykuły