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

Zagnieżdżone ścieżki i parametry catch-all

14 min czytania ·
W tej lekcji10

W Metropolii Quantum system transportowy umożliwia mieszkańcom dotarcie do każdego zakątka miasta, a nawet do niezbadanych jeszcze terytoriów. Specjalne pojazdy Q-Hoppery potrafią zebrać wiele celów podróży i odwiedzić je wszystkie po kolei, dostosowując się dynamicznie do potrzeb pasażerów. Ta elastyczność jest kluczowa dla funkcjonowania tak zaawansowanej struktury miejskiej.

W świecie Next.js 16 podobną elastyczność zapewniają zaawansowane funkcje routingu, takie jak zagnieżdżone ścieżki i parametry catch-all. Pozwalają one na obsługę złożonych struktur URL i dynamiczne generowanie tras w oparciu o dane.

Zagnieżdżone ścieżki dynamiczne

W Next.js 16 możemy tworzyć zagnieżdżone ścieżki dynamiczne, łącząc segmenty statyczne i dynamiczne na różnych poziomach hierarchii:

app/
  ├── destinations/              # /destinations
  │   ├── page.tsx               # Strona z listą destynacji
  │   └── [destinationId]/       # Dynamiczny segment dla ID destynacji
  │       ├── page.tsx           # /destinations/:destinationId
  │       └── attractions/       # /destinations/:destinationId/attractions
  │           ├── page.tsx       # Strona z atrakcjami dla destynacji
  │           └── [attractionId] # Zagnieżdżony segment dynamiczny
  │               └── page.tsx   # /destinations/:destinationId/attractions/:attractionId

W tej strukturze mamy dwa poziomy dynamicznych segmentów: [destinationId] i [attractionId]. To pozwala na tworzenie ścieżek takich jak /destinations/mars/attractions/olympus-mons.

Implementacja zagnieżdżonych ścieżek dynamicznych

Oto przykład jak zaimplementować system zagnieżdżonych ścieżek dla naszej aplikacji Quantum Voyages:

// app/destinations/[destinationId]/page.tsx
import { getDestinationById } from '@/lib/api';
import { DestinationDetails } from '@/components/destinations/DestinationDetails';
import { AttractionsPreview } from '@/components/destinations/AttractionsPreview';
import Link from 'next/link';
import { notFound } from 'next/navigation';

// Generowanie statycznych parametrów dla najpopularniejszych destynacji
export async function generateStaticParams() {
  // Pobierz najpopularniejsze destynacje dla prerendering
  const destinations = await getPopularDestinations();

  return destinations.map((destination) => ({
    destinationId: destination.id,
  }));
}

export default async function DestinationPage({ params }: { params: Promise<{ destinationId: string }> }) {
  const { destinationId } = await params;
  const destination = await getDestinationById(destinationId);

  // Jeśli destynacja nie istnieje, wyświetl stronę 404
  if (!destination) {
    notFound();
  }

  return (
    <div className="container mx-auto px-4 py-12">
      <h1 className="text-4xl font-bold mb-6">{destination.name}</h1>

      <DestinationDetails destination={destination} />

      <section className="mt-12">
        <div className="flex justify-between items-center mb-6">
          <h2 className="text-2xl font-semibold">Popularne atrakcje</h2>
          <Link
            href={`/destinations/${destinationId}/attractions`}
            className="text-indigo-600 hover:underline"
          >
            Zobacz wszystkie atrakcje
          </Link>
        </div>

        <AttractionsPreview destinationId={destinationId} />
      </section>
    </div>
  );
}
// app/destinations/[destinationId]/attractions/page.tsx
import { getDestinationById, getAttractionsForDestination } from '@/lib/api';
import Link from 'next/link';
import Image from 'next/image';
import { notFound } from 'next/navigation';

export default async function DestinationAttractionsPage({ params }: { params: Promise<{ destinationId: string }> }) {
  const { destinationId } = await params;
  const destination = await getDestinationById(destinationId);

  if (!destination) {
    notFound();
  }

  const attractions = await getAttractionsForDestination(destinationId);

  return (
    <div className="container mx-auto px-4 py-12">
      <div className="flex items-center gap-2 mb-8 text-sm text-gray-500">
        <Link href="/destinations" className="hover:text-indigo-600">Destynacje</Link>
        <span>/</span>
        <Link href={`/destinations/${destinationId}`} className="hover:text-indigo-600">
          {destination.name}
        </Link>
        <span>/</span>
        <span>Atrakcje</span>
      </div>

      <h1 className="text-3xl font-bold mb-2">Atrakcje na {destination.name}</h1>
      <p className="text-gray-600 mb-8">{destination.description}</p>

      <div className="grid grid-cols-1 md:grid-cols-2 lg:grid-cols-3 gap-8">
        {attractions.map((attraction) => (
          <Link
            key={attraction.id}
            href={`/destinations/${destinationId}/attractions/${attraction.id}`}
            className="block group"
          >
            <div className="rounded-lg overflow-hidden shadow-md hover:shadow-lg transition-shadow">
              <div className="relative h-48">
                <Image
                  src={attraction.imageUrl}
                  alt={attraction.name}
                  fill
                  className="object-cover transition-transform group-hover:scale-105"
                />
              </div>
              <div className="p-4">
                <h2 className="text-xl font-semibold mb-2">{attraction.name}</h2>
                <p className="text-gray-600 line-clamp-2">{attraction.shortDescription}</p>
              </div>
            </div>
          </Link>
        ))}
      </div>
    </div>
  );
}
// app/destinations/[destinationId]/attractions/[attractionId]/page.tsx
import { getDestinationById, getAttractionById } from '@/lib/api';
import Link from 'next/link';
import Image from 'next/image';
import { notFound } from 'next/navigation';

export default async function AttractionPage({
  params
}: {
  params: Promise<{ destinationId: string; attractionId: string }>
}) {
  const { destinationId, attractionId } = await params;

  const [destination, attraction] = await Promise.all([
    getDestinationById(destinationId),
    getAttractionById(destinationId, attractionId)
  ]);

  if (!destination || !attraction) {
    notFound();
  }

  return (
    <div className="container mx-auto px-4 py-12">
      <div className="flex items-center gap-2 mb-8 text-sm text-gray-500">
        <Link href="/destinations" className="hover:text-indigo-600">Destynacje</Link>
        <span>/</span>
        <Link href={`/destinations/${destinationId}`} className="hover:text-indigo-600">
          {destination.name}
        </Link>
        <span>/</span>
        <Link href={`/destinations/${destinationId}/attractions`} className="hover:text-indigo-600">
          Atrakcje
        </Link>
        <span>/</span>
        <span>{attraction.name}</span>
      </div>

      <div className="grid grid-cols-1 lg:grid-cols-2 gap-12">
        <div className="relative h-[400px] lg:h-[600px] rounded-lg overflow-hidden">
          <Image
            src={attraction.imageUrl}
            alt={attraction.name}
            fill
            className="object-cover"
            preload
          />
        </div>

        <div>
          <h1 className="text-4xl font-bold mb-4">{attraction.name}</h1>
          <div className="flex items-center mb-6">
            <span className="px-3 py-1 bg-indigo-100 text-indigo-800 rounded-full text-sm">
              {attraction.category}
            </span>
            <span className="mx-4 text-gray-300">|</span>
            <div className="flex items-center text-amber-500">
              {/* Gwiazdki oceny */}
              {Array.from({ length: 5 }).map((_, i) => (
                <svg key={i} xmlns="http://www.w3.org/2000/svg" className={`h-5 w-5 ${i < attraction.rating ? 'fill-current' : 'text-gray-300'}`} viewBox="0 0 20 20" fill="currentColor">
                  <path d="M9.049 2.927c.3-.921 1.603-.921 1.902 0l1.07 3.292a1 1 0 00.95.69h3.462c.969 0 1.371 1.24.588 1.81l-2.8 2.034a1 1 0 00-.364 1.118l1.07 3.292c.3.921-.755 1.688-1.54 1.118l-2.8-2.034a1 1 0 00-1.175 0l-2.8 2.034c-.784.57-1.838-.197-1.539-1.118l1.07-3.292a1 1 0 00-.364-1.118L2.98 8.72c-.783-.57-.38-1.81.588-1.81h3.461a1 1 0 00.951-.69l1.07-3.292z" />
                </svg>
              ))}
              <span className="ml-2 text-gray-700">{attraction.rating.toFixed(1)}</span>
            </div>
          </div>

          <p className="text-gray-700 mb-6">{attraction.description}</p>

          <div className="space-y-4 mb-8">
            <div className="flex">
              <div className="w-32 font-semibold">Lokalizacja:</div>
              <div>{attraction.location}</div>
            </div>
            <div className="flex">
              <div className="w-32 font-semibold">Koszt zwiedzania:</div>
              <div>{attraction.price} kredytów</div>
            </div>
            <div className="flex">
              <div className="w-32 font-semibold">Czas zwiedzania:</div>
              <div>{attraction.duration}</div>
            </div>
          </div>

          <button className="w-full py-3 bg-indigo-600 text-white rounded-lg hover:bg-indigo-700 transition-colors">
            Zarezerwuj wizytę
          </button>
        </div>
      </div>
    </div>
  );
}

Parametry catch-all

W Metropolii Quantum technologia Q-Route umożliwia podróżowanie do dowolnej liczby miejsc na podstawie jednego kodu trasy. Podobnie w Next.js 16 parametry catch-all umożliwiają obsługę ścieżek z dowolną liczbą segmentów.

Składnia parametrów catch-all

Parametry catch-all są oznaczane trzema kropkami przed nazwą parametru w nawiasach kwadratowych:

[...param]

Ta notacja pozwala na dopasowanie dowolnej liczby segmentów URL, które zostaną przekazane jako tablica do komponentu.

Struktura katalogów

app/
  ├── shop/                   # /shop
  │   └── [...categories]/    # /shop/category1
  │       └── page.tsx        # /shop/category1/category2/category3/etc.

W tym przykładzie ścieżka /shop/clothing/men/shirts zostanie dopasowana przez [...categories] i parametr categories będzie zawierał tablicę ['clothing', 'men', 'shirts'].

Implementacja dla Quantum Voyages

Implementacja systemu kategorii produktów z parametrami catch-all:

// app/shop/[...categories]/page.tsx
import { fetchCategorizedProducts } from '@/lib/api/products';
import { Breadcrumbs } from '@/components/shop/Breadcrumbs';
import { ProductGrid } from '@/components/shop/ProductGrid';
import { CategoryFilters } from '@/components/shop/CategoryFilters';

export default async function CategoriesPage({ params }: { params: Promise<{ categories: string[] }> }) {
  const { categories } = await params;

  // Pobieranie produktów na podstawie wszystkich przekazanych kategorii
  const { products, availableFilters } = await fetchCategorizedProducts(categories);

  // Konstruowanie tytułu na podstawie ostatniej kategorii
  const currentCategory = categories[categories.length - 1];
  const formattedCategoryName = currentCategory
    .split('-')
    .map(word => word.charAt(0).toUpperCase() + word.slice(1))
    .join(' ');

  return (
    <div className="container mx-auto px-4 py-12">
      <Breadcrumbs categories={categories} />

      <h1 className="text-3xl font-bold mb-8">{formattedCategoryName}</h1>

      <div className="grid grid-cols-1 lg:grid-cols-4 gap-8">
        <div className="lg:col-span-1">
          <CategoryFilters
            categories={categories}
            availableFilters={availableFilters}
          />
        </div>

        <div className="lg:col-span-3">
          <ProductGrid products={products} />
        </div>
      </div>
    </div>
  );
}

Komponenty pomocnicze

// components/shop/Breadcrumbs.tsx
import Link from 'next/link';

export function Breadcrumbs({ categories }: { categories: string[] }) {
  return (
    <div className="flex items-center flex-wrap gap-2 mb-8 text-sm text-gray-500">
      <Link href="/shop" className="hover:text-indigo-600">
        Sklep
      </Link>

      {categories.map((category, index) => {
        // Budowanie ścieżki URL dla tej kategorii
        const url = `/shop/${categories.slice(0, index + 1).join('/')}`;
        const isLast = index === categories.length - 1;

        const formattedName = category
          .split('-')
          .map(word => word.charAt(0).toUpperCase() + word.slice(1))
          .join(' ');

        return (
          <div key={category} className="flex items-center">
            <span className="mx-2">/</span>
            {isLast ? (
              <span>{formattedName}</span>
            ) : (
              <Link href={url} className="hover:text-indigo-600">
                {formattedName}
              </Link>
            )}
          </div>
        );
      })}
    </div>
  );
}

Opcjonalne parametry catch-all

W Next.js 16 możemy też zdefiniować opcjonalne parametry catch-all, używając podwójnych nawiasów kwadratowych:

[[...param]]

Główna różnica polega na tym, że opcjonalny parametr catch-all dopasuje też ścieżkę bez żadnych segmentów. Na przykład, app/shop/[[...categories]]/page.tsx dopasuje:

  • /shop (tu categories w ogóle nie ma, czyli jest undefined, dlatego kod niżej używa || [])
  • /shop/clothing (categories = ['clothing'])
  • /shop/clothing/men/shirts (categories = ['clothing', 'men', 'shirts'])

Implementacja sklepu z opcjonalnymi parametrami catch-all

// app/shop/[[...categories]]/page.tsx
import { fetchCategorizedProducts, fetchFeaturedProducts } from '@/lib/api/products';
import { Breadcrumbs } from '@/components/shop/Breadcrumbs';
import { ProductGrid } from '@/components/shop/ProductGrid';
import { CategoryFilters } from '@/components/shop/CategoryFilters';
import { FeaturedProducts } from '@/components/shop/FeaturedProducts';
import { CategoryPreview } from '@/components/shop/CategoryPreview';

export default async function ShopPage({ params }: { params: Promise<{ categories?: string[] }> }) {
  const categories = (await params).categories || [];
  const isRootShopPage = categories.length === 0;

  if (isRootShopPage) {
    // Jesteśmy na głównej stronie sklepu
    const featuredProducts = await fetchFeaturedProducts();
    const topCategories = await fetchTopCategories();

    return (
      <div className="container mx-auto px-4 py-12">
        <h1 className="text-4xl font-bold mb-12">Sklep Quantum Voyages</h1>

        <section className="mb-16">
          <h2 className="text-2xl font-semibold mb-8">Polecane produkty</h2>
          <FeaturedProducts products={featuredProducts} />
        </section>

        <section>
          <h2 className="text-2xl font-semibold mb-8">Przeglądaj kategorie</h2>
          <div className="grid grid-cols-1 md:grid-cols-2 lg:grid-cols-3 gap-8">
            {topCategories.map(category => (
              <CategoryPreview key={category.id} category={category} />
            ))}
          </div>
        </section>
      </div>
    );
  } else {
    // Jesteśmy na stronie kategorii
    const { products, availableFilters } = await fetchCategorizedProducts(categories);

    // Konstruowanie tytułu na podstawie ostatniej kategorii
    const currentCategory = categories[categories.length - 1];
    const formattedCategoryName = currentCategory
      .split('-')
      .map(word => word.charAt(0).toUpperCase() + word.slice(1))
      .join(' ');

    return (
      <div className="container mx-auto px-4 py-12">
        <Breadcrumbs categories={categories} />

        <h1 className="text-3xl font-bold mb-8">{formattedCategoryName}</h1>

        <div className="grid grid-cols-1 lg:grid-cols-4 gap-8">
          <div className="lg:col-span-1">
            <CategoryFilters
              categories={categories}
              availableFilters={availableFilters}
            />
          </div>

          <div className="lg:col-span-3">
            <ProductGrid products={products} />
          </div>
        </div>
      </div>
    );
  }
}

Dostęp do parametrów w komponentach

W Next.js 16 możemy uzyskać dostęp do parametrów ścieżki na kilka sposobów:

W komponentach po stronie serwera (Server Components)

// Server Component
export default async function ProductPage({ params }: { params: Promise<{ productId: string }> }) {
  // Użycie (await params).productId
  return <div>Product ID: {(await params).productId}</div>;
}

W komponentach po stronie klienta (Client Components)

W komponentach po stronie klienta możemy używać hooka useParams z next/navigation:

'use client';

import { useParams } from 'next/navigation';

export default function ClientProductDetails() {
  const params = useParams();
  const productId = params.productId;

  return <div>Viewing product: {productId}</div>;
}

W funkcjach generowania

Next.js 16 oferuje funkcje do generowania statycznych parametrów i metadanych:

// Generowanie statycznych parametrów
export async function generateStaticParams() {
  const products = await fetchTopProducts();

  return products.map((product) => ({
    productId: product.id,
  }));
}

// Generowanie metadanych
export async function generateMetadata({ params }: { params: Promise<{ productId: string }> }) {
  const product = await fetchProductById((await params).productId);

  return {
    title: product.name,
    description: product.description,
    openGraph: {
      images: [{ url: product.imageUrl }],
    },
  };
}

Walidacja i obsługa parametrów

Podczas pracy z parametrami dynamicznymi ważne jest, aby przeprowadzić ich walidację:

export default async function ProductPage({ params }: { params: Promise<{ productId: string }> }) {
  // Sprawdź, czy productId jest poprawnym UUID
  if (!/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test((await params).productId)) {
    // Wyrzuć błąd, który zostanie przechwycony przez najbliższy error.js
    throw new Error('Invalid product ID format');
  }

  const product = await fetchProductById((await params).productId);

  // Jeśli produkt nie istnieje, wyświetl stronę 404
  if (!product) {
    notFound();
  }

  return <ProductDetails product={product} />;
}

Obsługa błędów i brakujących zasobów

Next.js 16 umożliwia eleganckie obsługiwanie sytuacji, gdy zasób nie zostanie znaleziony lub wystąpi błąd:

Obsługa błędów z error.js

Plik error.tsx musi być Client Component (dyrektywa 'use client'): granica błędów w React działa na metodach cyklu życia dostępnych tylko w przeglądarce, a przycisk z reset() potrzebuje obsługi kliknięcia.

// app/products/[productId]/error.tsx
'use client';

import { useEffect } from 'react';

export default function ProductError({
  error,
  reset,
}: {
  error: Error & { digest?: string };
  reset: () => void;
}) {
  useEffect(() => {
    // Możesz zalogować błąd do zewnętrznego serwisu
    console.error(error);
  }, [error]);

  return (
    <div className="container mx-auto px-4 py-16 text-center">
      <h2 className="text-2xl font-bold mb-4">Coś poszło nie tak!</h2>
      <p className="mb-8 text-gray-600">{error.message}</p>
      <button
        onClick={reset}
        className="px-4 py-2 bg-indigo-600 text-white rounded hover:bg-indigo-700"
      >
        Spróbuj ponownie
      </button>
    </div>
  );
}

Obsługa brakujących zasobów z not-found.js

// app/products/[productId]/not-found.tsx
import Link from 'next/link';

export default function ProductNotFound() {
  return (
    <div className="container mx-auto px-4 py-16 text-center">
      <h2 className="text-3xl font-bold mb-4">Produkt nie znaleziony</h2>
      <p className="mb-8 text-gray-600">
        Przepraszamy, nie mogliśmy znaleźć szukanego produktu.
      </p>
      <Link
        href="/products"
        className="px-4 py-2 bg-indigo-600 text-white rounded hover:bg-indigo-700"
      >
        Wróć do wszystkich produktów
      </Link>
    </div>
  );
}

Przykład: zaawansowany system dokumentacji

W Metropolii Quantum interaktywny system dokumentacji pozwala na nawigację przez złożone hierarchie informacji. Zaimplementujmy podobny system w Next.js 16:

app/
  ├── docs/
  │   └── [[...slug]]/     # Opcjonalny catch-all
  │       └── page.tsx     # /docs, /docs/guides, /docs/guides/routing, etc.
// app/docs/[[...slug]]/page.tsx
import { fetchDocumentBySlug, fetchDocCategories } from '@/lib/api/documentation';
import { DocSidebar } from '@/components/docs/DocSidebar';
import { DocContent } from '@/components/docs/DocContent';
import { DocBreadcrumbs } from '@/components/docs/DocBreadcrumbs';
import { DocPagination } from '@/components/docs/DocPagination';
import { notFound } from 'next/navigation';

export default async function DocPage({ params }: { params: Promise<{ slug?: string[] }> }) {
  const slug = (await params).slug || [];
  const slugPath = slug.join('/');

  // Pobierz kategorie dokumentacji do menu bocznego
  const categories = await fetchDocCategories();

  // Jeśli nie podano ścieżki, wyświetl stronę główną dokumentacji
  if (slug.length === 0) {
    return (
      <div className="container mx-auto px-4 py-12">
        <div className="flex flex-col lg:flex-row gap-8">
          <DocSidebar categories={categories} currentSlug="" />

          <main className="flex-1">
            <h1 className="text-4xl font-bold mb-8">Dokumentacja Quantum Voyages</h1>

            <div className="prose prose-indigo max-w-none">
              <p>
                Witaj w centrum dokumentacji Quantum Voyages. Znajdziesz tutaj wszystkie informacje
                potrzebne do zaplanowania i odbycia podróży kosmicznej, od podstawowych przewodników
                po zaawansowane instrukcje techniczne.
              </p>

              <h2>Popularne sekcje</h2>

              <div className="grid grid-cols-1 md:grid-cols-2 gap-6 not-prose">
                {categories.map(category => (
                  <div key={category.slug} className="border rounded-lg p-6 hover:shadow-md transition-shadow">
                    <h3 className="text-xl font-semibold mb-2">{category.title}</h3>
                    <p className="text-gray-600 mb-4">{category.description}</p>
                    <a href={`/docs/${category.slug}`} className="text-indigo-600 hover:underline">
                      Przeglądaj {category.title.toLowerCase()} →
                    </a>
                  </div>
                ))}
              </div>
            </div>
          </main>
        </div>
      </div>
    );
  }

  // Pobierz dokument na podstawie ścieżki
  const document = await fetchDocumentBySlug(slugPath);

  // Jeśli dokument nie istnieje, wyświetl stronę 404
  if (!document) {
    notFound();
  }

  // Pobierz poprzedni i następny dokument dla nawigacji
  const { previousDoc, nextDoc } = await fetchAdjacentDocs(slugPath);

  return (
    <div className="container mx-auto px-4 py-12">
      <DocBreadcrumbs slug={slug} />

      <div className="flex flex-col lg:flex-row gap-8">
        <DocSidebar categories={categories} currentSlug={slugPath} />

        <main className="flex-1">
          <h1 className="text-4xl font-bold mb-8">{document.title}</h1>

          <DocContent content={document.content} />

          <DocPagination previousDoc={previousDoc} nextDoc={nextDoc} />
        </main>
      </div>
    </div>
  );
}

// Generowanie statycznych parametrów dla popularnych ścieżek dokumentacji
export async function generateStaticParams() {
  const popularDocs = await fetchPopularDocs();

  return popularDocs.map(doc => ({
    slug: doc.slug.split('/'),
  }));
}

Łączenie parametrów catch-all z innymi funkcjami

Next.js 16 pozwala na łączenie parametrów catch-all z innymi zaawansowanymi funkcjami routingu:

1. Grupowanie tras z parametrami catch-all

app/
  ├── (dashboard)/
  │   └── admin/
  │       └── users/
  │           └── [...roles]/    # /admin/users/admin/editor/etc.
  │               └── page.tsx

2. Interceptowanie tras z parametrami catch-all

// app/(shop)/products/@modal/(.)[...categories]/page.tsx
// Przechwytuje /products/category1/category2 jako modal podczas nawigacji z /products.
// Segment catch-all musi być ostatni w ścieżce: po [...categories] nie może już stać [productId].

3. Równoległe trasy z parametrami catch-all

app/
  ├── trips/
  │   ├── page.tsx              # /trips
  │   ├── @filters/
  │   │   ├── default.tsx       # Wymagany w Next.js 16
  │   │   └── [...params]/      # Równoległa trasa dla filtrów
  │   │       └── page.tsx
  │   └── @map/
  │       ├── default.tsx       # Wymagany w Next.js 16
  │       └── [...location]/    # Równoległa trasa dla mapy
  │           └── page.tsx

Zaawansowane warianty nawigacji z parametrami

Nawigacja z parametrami dynamicznymi

'use client';

import { useRouter } from 'next/navigation';
import { useState } from 'react';

export function CategoryNavigator({ categories, subcategories }) {
  const router = useRouter();
  const [selectedCategoryId, setSelectedCategoryId] = useState('');

  const handleCategoryChange = (categoryId) => {
    setSelectedCategoryId(categoryId);
    const selectedCategory = categories.find(c => c.id === categoryId);
    router.push(`/shop/${selectedCategory.slug}`);
  };

  const handleSubcategoryChange = (categoryId, subcategoryId) => {
    const selectedCategory = categories.find(c => c.id === categoryId);
    const selectedSubcategory = subcategories.find(sc => sc.id === subcategoryId);
    router.push(`/shop/${selectedCategory.slug}/${selectedSubcategory.slug}`);
  };

  return (
    <div className="space-y-4">
      <div>
        <label className="block mb-2 text-sm font-medium">Kategoria</label>
        <select
          className="w-full p-2 border rounded"
          onChange={(e) => handleCategoryChange(e.target.value)}
        >
          <option value="">Wybierz kategorię</option>
          {categories.map(category => (
            <option key={category.id} value={category.id}>
              {category.name}
            </option>
          ))}
        </select>
      </div>

      <div>
        <label className="block mb-2 text-sm font-medium">Podkategoria</label>
        <select
          className="w-full p-2 border rounded"
          onChange={(e) => handleSubcategoryChange(selectedCategoryId, e.target.value)}
        >
          <option value="">Wybierz podkategorię</option>
          {/* Opcje podkategorii */}
        </select>
      </div>
    </div>
  );
}

Wyszukiwanie zaawansowane z parametrami catch-all

// app/search/[[...query]]/page.tsx
import { searchProducts } from '@/lib/api/search';

export default async function SearchPage({
  params,
  searchParams,
}: {
  params: Promise<{ query?: string[] }>;
  searchParams: Promise<{ category?: string; sort?: string; filters?: string }>;
}) {
  const query = (await params).query || [];
  const searchTerm = query.join(' ');

  // Pobieranie parametrów zapytania
  const { category, sort, filters } = await searchParams;

  // Wykonanie wyszukiwania
  const results = await searchProducts({
    searchTerm,
    category,
    sort,
    filters: filters ? JSON.parse(filters) : undefined
  });

  return (
    <div className="container mx-auto px-4 py-12">
      <h1 className="text-3xl font-bold mb-8">
        {searchTerm
          ? `Wyniki wyszukiwania dla: "${searchTerm}"`
          : 'Wyszukiwanie produktów'
        }
      </h1>

      {/* Filtry wyszukiwania */}
      <SearchFilters
        initialCategory={category}
        initialSort={sort}
        initialFilters={filters ? JSON.parse(filters) : {}}
      />

      {/* Wyniki wyszukiwania */}
      <SearchResults results={results} />
    </div>
  );
}

Podsumowanie

Zagnieżdżone ścieżki dynamiczne i parametry catch-all w Next.js 16 oferują niezwykle elastyczny system routingu, który może obsłużyć praktycznie każdy scenariusz nawigacji w nowoczesnych aplikacjach webowych:

  1. Zagnieżdżone parametry dynamiczne umożliwiają tworzenie złożonych hierarchicznych struktur URL, takich jak /destinations/:destinationId/attractions/:attractionId.

  2. Parametry catch-all ([...param]) pozwalają na dopasowanie dowolnej liczby segmentów URL, co jest idealne dla systemów dokumentacji, kategorii produktów i elastycznych interfejsów wyszukiwania.

  3. Opcjonalne parametry catch-all ([[...param]]) dodatkowo obsługują przypadek braku segmentów, co umożliwia użycie tego samego komponentu dla ścieżki bazowej i wszystkich jej podścieżek.

  4. Obsługa błędów i brakujących zasobów dzięki plikom error.js i not-found.js zapewnia eleganckie doświadczenie użytkownika nawet w przypadku problemów.

  5. Walidacja parametrów zapobiega błędom i zapewnia bezpieczeństwo aplikacji.

Łącząc te techniki z funkcjami takimi jak generowanie statycznych parametrów (generateStaticParams), możemy tworzyć wydajne, dynamiczne i łatwe w utrzymaniu systemy nawigacji dla aplikacji o dowolnej skali i złożoności.

W następnej lekcji zobaczysz, jak layouty i pliki loading.tsx tworzą stałą infrastrukturę stron.

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. Route Groups w App Routerze oznacza się używając:

  2. 2. Catch-all segments w App Routerze tworzy się używając:

Zadania praktyczne w grze

  • Edytor kodu

    Utwórz plik error.js: zacznij od dyrektywy 'use client' (error.js musi być Client Component) i wyeksportuj domyślnie komponent ErrorPage({ error, reset }). Wyświetl przyjazny komunikat błędu, np. nagłówek h2 „Coś poszło nie tak!”, oraz przycisk „Spróbuj ponownie”, który po kliknięciu wywołuje reset().

  • Układanie w pionie

    Ułóż kroki tworzenia dynamicznej trasy w App Routerze

  • Klikanie w kolejności

    Ułóż składnię eksportu domyślnego komponentu strony w Next.js

  • Edytor kodu

    Utwórz Client Component Counter (eksport domyślny): plik zaczyna się od 'use client', stan count tworzysz przez useState(0), wyświetlasz go w akapicie p, a przycisk „+1” po każdym kliknięciu zwiększa licznik o 1.

  1. PytanieRoute Groups w App Routerze
  2. PytanieCatch-all segments
  3. Zadanie z kodemPraktyka: Obsługa błędów error.js
  4. Ułóż w kolejnościTworzenie dynamicznej trasy
  5. Kliknij w kolejnościEksport komponentu strony
  6. Zadanie z kodemPraktyka: Client Component z licznikiem

Przydatne artykuły