Przejdź do treści

Wyszukiwarka z filtrami w Next.js: searchParams i URL state

Maciej Sala

Founder StriveLab

8 min czytaniaAktualizacja

Szybka odpowiedź: jak zbudować wyszukiwarkę z filtrami w Next.js?

  • Zatwierdzone filtry trzymaj w URL, a roboczy tekst pola w useState.
  • Parametry normalizuj na serwerze, bo każdy może być stringiem albo tablicą, i ograniczaj ich długość oraz zakres.
  • Debounce z router.replace i useTransition ogranicza liczbę nawigacji i daje stan oczekiwania.
  • Na statycznej trasie kliencki useSearchParams wymaga Suspense.
  • Indeksuj tylko wartościowe kombinacje filtrów, a resztę ograniczaj linkiem kanonicznym, noindex albo robots.txt.

Dlaczego URL state w Next.js zamiast useState?

Filtry zapisane wyłącznie w giną po odświeżeniu strony. Lokalny stan nadal przydaje się do tekstu, który użytkownik dopiero wpisuje przed zatwierdzeniem go w URL-u, podczas gdy (?q=next&tag=react&tag=seo&sort=newest) przetrwa zarówno odświeżenie, udostępnienie linku, jak i nawigację wstecz/wprzód oraz jest czytelny dla Server Components bez klienckiego JS do odczytania filtrów.

Architektura wyszukiwarki z filtrami w Next.js

Code
URL: /blog?q=next&tag=react&sort=newest
                    ↓
Server Component → czyta searchParams → pobiera dane z filtrami
                    ↓
Client Component → aktualizuje URL → Server Component re-renderuje

Server Component: odczyt searchParams i pobieranie danych

Przykład zakłada Next.js App Router (od wersji 15) z asynchronicznym searchParams i wyłączonym cacheComponents. Odczyt parametrów żądania oznacza tu renderowanie dynamiczne. Komponenty kart i skeletonów to elementy prezentacyjne aplikacji; poniżej prezentuję pełny przepływ filtrów i danych.

Code
// app/blog/page.tsx
import { Suspense } from 'react'
import {
  normalizeSearchParams,
  type RawSearchParams,
  type Filters,
} from '@/lib/filters'
import { getFilteredPosts } from '@/lib/queries'
import { FilterProvider } from '@/components/filter-provider'
import { ActiveFilters } from '@/components/active-filters'
import { SearchBar } from '@/components/search-bar'
import { FilterSidebar } from '@/components/filter-sidebar'
import { Pagination } from '@/components/pagination'
import { PostGrid } from '@/components/post-grid'
import { PostGridSkeleton } from '@/components/skeletons'
 
export default async function BlogPage({
  searchParams,
}: {
  searchParams: Promise<RawSearchParams>
}) {
  const filters = normalizeSearchParams(await searchParams)
  const resultsKey = JSON.stringify(filters)
 
  return (
    <FilterProvider filters={filters}>
      <main className="mx-auto max-w-6xl py-8">
        <h1 className="mb-6 text-3xl font-bold">Blog</h1>
        <SearchBar />
        <div className="mt-6 grid gap-8 md:grid-cols-4">
          <aside>
            <FilterSidebar />
          </aside>
          <div className="md:col-span-3">
            <ActiveFilters />
            <Suspense key={resultsKey} fallback={<PostGridSkeleton />}>
              <FilteredPosts filters={filters} />
            </Suspense>
          </div>
        </div>
      </main>
    </FilterProvider>
  )
}
 
async function FilteredPosts({ filters }: { filters: Filters }) {
  const { posts, hasNext } = await getFilteredPosts(filters)
 
  return (
    <>
      {posts.length > 0 ? (
        <PostGrid posts={posts} />
      ) : (
        <p className="py-12">
          Brak wyników na tej stronie. Usuń część filtrów lub wróć na pierwszą
          stronę.
        </p>
      )}
      <Pagination hasNext={hasNext} />
    </>
  )
}

key={resultsKey} resetuje granicę Suspense przy każdej zmianie znormalizowanych filtrów. Fallback wyrenderuje się tylko wtedy, gdy komponenty potomne zawieszą renderowanie – sam klucz nie wymusza bowiem nowego zapytania, nie unieważnia cache’u ani nie gwarantuje wyświetlenia skeletonu. Deduplikacja i sortowanie tagów na etapie normalizacji zapewniają ten sam klucz dla równoważnych zestawów filtrów.

Dla statycznej strony kliencki useSearchParams wymaga granicy Suspense — bez niej produkcyjny build może zakończyć się błędem, mimo że dev działa. Powyższa strona jest dynamiczna, więc nie potrzebuje osobnej granicy tylko z powodu tego hooka. Przy włączonych Cache Components przekaż obietnicę searchParams do komponentu potomnego i odczytaj ją pod nadrzędnym Suspense. Granica otaczająca jedynie wyniki nie obejmie wcześniejszego await searchParams w stronie.

Walidacja parametrów w URL wyszukiwarki

Każdy parametr URL może wystąpić wiele razy, nie tylko tag. Dla pojedynczych pól przyjmuję pierwszą wartość. Tagi są identyfikatorami z zamkniętej listy; etykiety służą wyłącznie do wyświetlania.

Code
// lib/filters.ts — moduł wspólny dla serwera i klienta
export const TAGS = [
  { value: 'react', label: 'React' },
  { value: 'nextjs', label: 'Next.js' },
  { value: 'typescript', label: 'TypeScript' },
  { value: 'seo', label: 'SEO' },
  { value: 'tailwind', label: 'Tailwind CSS' },
  { value: 'testing', label: 'Testing' },
] as const
 
export const SORT_OPTIONS = [
  { value: 'newest', label: 'Najnowsze' },
  { value: 'oldest', label: 'Najstarsze' },
  { value: 'popular', label: 'Najpopularniejsze' },
] as const
 
export const MAX_QUERY_LENGTH = 120
export const MAX_PAGE = 1000
export const PAGE_SIZE = 12
export type SortOption = (typeof SORT_OPTIONS)[number]['value']
export type RawSearchParams = Record<string, string | string[] | undefined>
export type Filters = {
  query: string
  tags: string[]
  sort: SortOption
  page: number
}
 
const first = (value: string | string[] | undefined) =>
  Array.isArray(value) ? (value[0] ?? '') : (value ?? '')
 
export function normalizeSearchParams(params: RawSearchParams): Filters {
  const query = first(params.q).trim().slice(0, MAX_QUERY_LENGTH)
  const rawTags = Array.isArray(params.tag) ? params.tag : [params.tag ?? '']
  const allowedTags = new Set<string>(TAGS.map(({ value }) => value))
  const tags = [...new Set(rawTags.map((tag) => tag.trim().toLowerCase()))]
    .filter((tag) => allowedTags.has(tag))
    .sort()
  const rawSort = first(params.sort)
  const sort =
    SORT_OPTIONS.find(({ value }) => value === rawSort)?.value ?? 'newest'
  const rawPage = first(params.page)
  const page = /^\d+$/.test(rawPage) ? Number(rawPage) : 1
 
  return {
    query: query.length >= 2 ? query : '',
    tags,
    sort,
    page:
      Number.isSafeInteger(page) && page >= 1 && page <= MAX_PAGE ? page : 1,
  }
}
 
export function toSearchParams(filters: Filters): URLSearchParams {
  const params = new URLSearchParams()
  if (filters.query) params.set('q', filters.query)
  filters.tags.forEach((tag) => params.append('tag', tag))
  if (filters.sort !== 'newest') params.set('sort', filters.sort)
  if (filters.page !== 1) params.set('page', String(filters.page))
  return params
}

page=2abc, ułamki i liczby spoza zakresu wracają do strony 1. Długość tekstu jest ograniczona, a liczba unikalnych tagów nie przekroczy rozmiaru listy dozwolonych wartości. Limit stron to decyzja dla tego przykładu — przy dużych zbiorach rozważ paginację kursorową zamiast coraz większego offsetu.

Zapytanie krótsze niż dwa znaki nie jest stosowane do wyników. Pole pokazuje wtedy wskazówkę, a etykiety aktywnych filtrów pokazują wyłącznie zatwierdzony stan. Normalizacja na serwerze nie zmienia sama adresu przeglądarki: zapis przez UI używa już uporządkowanego formatu i pomija wartości domyślne. Przykład traktuje query string jako stan tej wyszukiwarki; jeśli przechowujesz w nim także inne parametry, zachowuj jawnie uzgodnioną listę zamiast usuwać je przypadkiem.

Pole wyszukiwania z debounce w Next.js

Samo pole z i router.replace pokazuje kurs Next.js Learn w rozdziale o wyszukiwaniu i paginacji, więc nie będę go powtarzać. Problem zaczyna się wtedy, gdy obok pola są filtry, sortowanie i paginacja: kliknięcie filtra w trakcie oczekującego debounce potrafi nadpisać nowszy stan starszym. Dlatego wszystkie kontrolki korzystają z jednego providera, który anuluje oczekujący debounce przy każdej świadomej zmianie i na czas nawigacji blokuje kontrolki. To prosty kompromis, który przy wolnym serwerze będzie odczuwalny; wariant bez blokady wymaga stanu optymistycznego i scalania oczekujących zmian.

Code
// components/filter-provider.tsx
'use client'
 
import {
  createContext,
  useContext,
  useEffect,
  useRef,
  useState,
  useTransition,
  type ReactNode,
} from 'react'
import { usePathname, useRouter, useSearchParams } from 'next/navigation'
import {
  normalizeSearchParams,
  toSearchParams,
  type Filters,
} from '@/lib/filters'
 
type FilterContextValue = {
  filters: Filters
  query: string
  isPending: boolean
  editQuery: (value: string) => void
  apply: (patch: Partial<Filters>, method?: 'push' | 'replace') => void
}
const FilterContext = createContext<FilterContextValue | null>(null)
 
export function FilterProvider({
  filters,
  children,
}: {
  filters: Filters
  children: ReactNode
}) {
  const router = useRouter()
  const pathname = usePathname()
  const searchParams = useSearchParams()
  const urlKey = searchParams.toString()
  const [query, setQuery] = useState(filters.query)
  const [isPending, startTransition] = useTransition()
  const draft = useRef(filters.query)
  const busy = useRef(false)
  const timer = useRef<ReturnType<typeof setTimeout> | undefined>(undefined)
 
  function cancelDebounce() {
    clearTimeout(timer.current)
    timer.current = undefined
  }
 
  // Zatwierdzona nawigacja, także wstecz/wprzód, synchronizuje pole.
  useEffect(() => {
    clearTimeout(timer.current)
    draft.current = filters.query
    setQuery(filters.query)
  }, [urlKey, filters])
 
  useEffect(() => {
    if (!isPending) busy.current = false
  }, [isPending])
 
  useEffect(() => {
    const cancel = () => clearTimeout(timer.current)
    window.addEventListener('popstate', cancel)
    return () => {
      cancel()
      window.removeEventListener('popstate', cancel)
    }
  }, [])
 
  function apply(patch: Partial<Filters>, method: 'push' | 'replace' = 'push') {
    if (busy.current) return
    cancelDebounce()
    const candidate = { ...filters, query: draft.current, page: 1, ...patch }
    const params = toSearchParams(candidate)
    const next = normalizeSearchParams({
      q: params.get('q') ?? undefined,
      tag: params.getAll('tag'),
      sort: params.get('sort') ?? undefined,
      page: params.get('page') ?? undefined,
    })
    const nextKey = toSearchParams(next).toString()
    draft.current = next.query
    setQuery(next.query)
    if (nextKey === urlKey) return
 
    // Ref blokuje również dwa kliknięcia przed kolejnym renderem Reacta.
    busy.current = true
    const href = nextKey ? `${pathname}?${nextKey}` : pathname
    startTransition(() => {
      if (method === 'replace') router.replace(href, { scroll: false })
      else router.push(href, { scroll: false })
    })
  }
 
  function editQuery(value: string) {
    if (busy.current) return
    draft.current = value
    setQuery(value)
    cancelDebounce()
    // Jeden znak pozostaje tekstem roboczym; wyniki nadal odpowiadają URL-owi.
    if (value.trim().length === 1) return
    timer.current = setTimeout(() => apply({ query: value }, 'replace'), 300)
  }
 
  return (
    <FilterContext.Provider
      value={{ filters, query, isPending, editQuery, apply }}
    >
      <div aria-busy={isPending}>{children}</div>
      <p role="status" aria-atomic="true" className="sr-only">
        {isPending ? 'Aktualizowanie wyników' : 'Wyniki gotowe'}
      </p>
    </FilterContext.Provider>
  )
}
 
export function useFilters() {
  const context = useContext(FilterContext)
  if (!context) throw new Error('Brak FilterProvider')
  return context
}

Samo pole (components/search-bar.tsx) sprowadza się wtedy do kontrolowanego <input type="search"> z etykietą, którego value i onChange pochodzą z useFilters() (query i editQuery), a disabled z isPending. Pod polem warto pokazać wskazówkę powiązaną przez aria-describedby, że zapytanie wymaga co najmniej dwóch znaków.

useTransition daje stan oczekiwania, ale nie zastępuje debounce ani nie anuluje zapytania do bazy. Roboczy tekst aktualizujemy zwykłym setQuery, poza transition. Kliknięcie filtra zatwierdza również aktualny tekst roboczy, a reset jawnie określa, czy go zachować, czy usunąć.

router.replace czy router.push przy filtrach?

Praktyczna reguła jest prosta:

InterakcjaMetodaDlaczego
Wpisywanie w pole wyszukiwaniarouter.replace()Nie zaśmieca historii stanami pośrednimi
Kliknięcie filtrarouter.push()To świadoma zmiana widoku, do której można wrócić
Zmiana sortowaniarouter.push()Użytkownik często porównuje warianty
Paginacjarouter.push()Strony wyników powinny działać z przyciskiem „wstecz”
Zmiana czysto wizualna, bez pobrania listyHistory APINie musi ponownie renderować Server Component

W sytuacji, kiedy chcesz zmienić tylko lokalny stan URL-a i nie potrzebujesz nowego renderu Server Component, Next.js wspiera natywne window.history.pushState i window.history.replaceState, które współpracują z usePathname i useSearchParams. Do filtrowania wyników po stronie serwera zwykle jednak chcesz normalną nawigację przez router.

Panel filtrów w Next.js i stan w URL

Przyciski zapisują identyfikatory tagów, np. nextjs, a wyświetlają etykiety, np. „Next.js”. Wspólne apply() resetuje stronę do 1 i anuluje oczekującą zmianę tekstu.

Code
// components/filter-sidebar.tsx
'use client'
 
import { TAGS, SORT_OPTIONS, type SortOption } from '@/lib/filters'
import { useFilters } from './filter-provider'
 
export function FilterSidebar() {
  const { filters, query, isPending, apply } = useFilters()
  return (
    <fieldset disabled={isPending} className="space-y-6 disabled:opacity-60">
      <legend>Filtry artykułów</legend>
      <div>
        <h2>Tagi — wpis musi zawierać wszystkie zaznaczone</h2>
        {TAGS.map(({ value, label }) => (
          <button
            key={value}
            type="button"
            aria-pressed={filters.tags.includes(value)}
            onClick={() =>
              apply({
                tags: filters.tags.includes(value)
                  ? filters.tags.filter((tag) => tag !== value)
                  : [...filters.tags, value],
              })
            }
            className="block rounded border px-3 py-2 aria-pressed:bg-blue-100"
          >
            {label}
          </button>
        ))}
      </div>
      <div>
        <label htmlFor="blog-sort">Sortowanie</label>
        <select
          id="blog-sort"
          value={filters.sort}
          onChange={(e) => apply({ sort: e.target.value as SortOption })}
        >
          {SORT_OPTIONS.map(({ value, label }) => (
            <option key={value} value={value}>
              {label}
            </option>
          ))}
        </select>
      </div>
      {(filters.tags.length > 0 || filters.sort !== 'newest') && (
        <button
          type="button"
          onClick={() => apply({ tags: [], sort: 'newest' })}
        >
          Wyczyść filtry
        </button>
      )}
      {(query ||
        filters.query ||
        filters.tags.length > 0 ||
        filters.sort !== 'newest' ||
        filters.page !== 1) && (
        <button
          type="button"
          onClick={() => apply({ query: '', tags: [], sort: 'newest' })}
        >
          Wyczyść wszystko
        </button>
      )}
    </fieldset>
  )
}

„Wyczyść filtry” zachowuje aktualny tekst, podczas gdy „Wyczyść wszystko” usuwa także tekst roboczy i oczekujący debounce. Jest to istotne, bo bez anulowania timera zapytanie mogłoby wrócić do URL-a po resecie.

Aktywne filtry jako etykiety w UI

Etykiety korzystają z tych samych znormalizowanych filtrów co baza, więc nie pokażą nieznanego sortowania ani powtórzonych tagów jako aktywnych ustawień.

Code
// components/active-filters.tsx
'use client'
 
import { TAGS, SORT_OPTIONS } from '@/lib/filters'
import { useFilters } from './filter-provider'
 
type Chip = { key: 'q' | 'tag' | 'sort'; value: string; label: string }
 
export function ActiveFilters() {
  const { filters, isPending, apply } = useFilters()
  const chips: Chip[] = []
  if (filters.query)
    chips.push({ key: 'q', value: filters.query, label: `„${filters.query}”` })
  filters.tags.forEach((tag) =>
    chips.push({
      key: 'tag',
      value: tag,
      label: TAGS.find(({ value }) => value === tag)?.label ?? tag,
    }),
  )
  if (filters.sort !== 'newest')
    chips.push({
      key: 'sort',
      value: filters.sort,
      label: SORT_OPTIONS.find(({ value }) => value === filters.sort)!.label,
    })
 
  return (
    <div className="mb-4 flex flex-wrap gap-2">
      {chips.map(({ key, value, label }) => (
        <span
          key={`${key}:${value}`}
          className="rounded-full bg-blue-100 px-3 py-1"
        >
          {label}
          <button
            type="button"
            disabled={isPending}
            aria-label={`Usuń filtr ${label}`}
            onClick={() => {
              if (key === 'q') apply({ query: '' })
              else if (key === 'tag')
                apply({ tags: filters.tags.filter((tag) => tag !== value) })
              else apply({ sort: 'newest' })
            }}
          >
            ✕
          </button>
        </span>
      ))}
    </div>
  )
}

UX i dostępność wyszukiwarki z filtrami

Wyszukiwarka z filtrami jest elementem interaktywnym, więc sam działający URL nie wystarczy. Zadbaj o kilka drobiazgów:

  • input[type="search"] powinien mieć aria-label, jeśli placeholder jest jedynym opisem,
  • przyciski filtrów powinny mieć aria-pressed, bo zachowują się jak przełączniki,
  • przycisk usuwania etykiety powinien mieć aria-label, np. Usuń filtr React,
  • sortowanie powinno mieć powiązany <label>; sam nagłówek obok <select> go nie zastępuje,
  • użyj stałego obszaru role="status" do ogłaszania aktualizacji i aria-busy dla aktualizowanej zawartości; samo sr-only nie tworzy komunikatu live,
  • nie kasuj scrolla przy każdej zmianie filtrów, jeśli użytkownik pracuje w środku listy,
  • pokazuj pusty stan z informacją, które filtry można usunąć.

Przy blokowaniu kontrolek sprawdź również zachowanie fokusu po zakończeniu nawigacji i obsługę klawiatury. Dla wyszukiwania z językami korzystającymi z IME warto dodatkowo wstrzymać debounce między compositionstart i compositionend.

Największy błąd to traktowanie filtrów jak formularza, który „magicznie” zmienia wyniki bez sygnału zwrotnego. Użytkownik powinien widzieć, że wyniki są aktualizowane, które filtry są aktywne i jak wrócić do szerszego zestawu.

Zapytanie do bazy danych z filtrami z URL

Przykład używa API Prisma Client znanego z Prisma 6/7 i PostgreSQL. Zakłada model Post z polami published Boolean, title String, content String, excerpt String?, tags String[], createdAt DateTime, views Int i unikalnym id. db to skonfigurowana w projekcie instancja klienta Prisma; ścieżkę importu klienta i typów dopasuj do swojego generatora.

hasEvery oznacza wszystkie wybrane tagi. Jeśli produkt ma pokazywać wpisy z dowolnym zaznaczonym tagiem, użyj hasSome i zmień opis panelu. Przy modelu relacyjnym tagów potrzebny jest filtr relacji, a nie filtr listy skalarnej.

Code
// lib/queries.ts
import 'server-only'
import type { Prisma } from '@prisma/client'
import { db } from '@/lib/db'
import { PAGE_SIZE, MAX_PAGE, type Filters } from '@/lib/filters'
 
export async function getFilteredPosts(filters: Filters) {
  const { query, tags, sort, page } = filters
  const where: Prisma.PostWhereInput = { published: true }
 
  if (query) {
    where.OR = [
      { title: { contains: query, mode: 'insensitive' } },
      { content: { contains: query, mode: 'insensitive' } },
      { excerpt: { contains: query, mode: 'insensitive' } },
    ]
  }
  if (tags.length > 0) where.tags = { hasEvery: tags }
 
  const primaryOrder: Prisma.PostOrderByWithRelationInput =
    sort === 'oldest'
      ? { createdAt: 'asc' }
      : sort === 'popular'
        ? { views: 'desc' }
        : { createdAt: 'desc' }
 
  const rows = await db.post.findMany({
    where,
    orderBy: [primaryOrder, { id: 'asc' }],
    skip: (page - 1) * PAGE_SIZE,
    take: PAGE_SIZE + 1,
  })
 
  return {
    posts: rows.slice(0, PAGE_SIZE),
    hasNext: rows.length > PAGE_SIZE && page < MAX_PAGE,
  }
}

Dodatkowy rekord pozwala ustalić istnienie następnej strony bez osobnego count(). Drugie kryterium id rozstrzyga remisy dat lub liczby odsłon; nie gwarantuje jednak niezmienności paginacji offsetowej, gdy dane zmieniają się między żądaniami.

contains wyszukuje fragment tekstu, bez rankingu trafności. Dla PostgreSQL opiera się na LIKE/ILIKE; znaki % i _ mają znaczenie wzorców, więc ustal, czy dopuszczasz takie wyszukiwanie, czy je escapujesz. Parametryzacja chroni strukturę zapytania, ale nie usuwa kosztu szerokiego wzorca. Przy większej bazie rozważ indeksy pg_trgm dla tego rodzaju zapytań albo osobne wyszukiwanie pełnotekstowe. Debounce nie zastępuje indeksów, limitów i monitorowania czasu zapytań.

Minimalna paginacja korzysta z tej samej obsługi nawigacji co filtry:

Code
// components/pagination.tsx
'use client'
 
import { useFilters } from './filter-provider'
 
export function Pagination({ hasNext }: { hasNext: boolean }) {
  const { filters, isPending, apply } = useFilters()
  // Zmiana strony zachowuje zatwierdzone zapytanie, a nie tekst roboczy.
  const goTo = (page: number) => apply({ query: filters.query, page })
  return (
    <nav aria-label="Strony wyników" className="mt-6 flex gap-4">
      {filters.page > 1 && (
        <button disabled={isPending} onClick={() => goTo(1)}>
          Pierwsza strona
        </button>
      )}
      <button
        disabled={isPending || filters.page <= 1}
        onClick={() => goTo(filters.page - 1)}
      >
        Poprzednia
      </button>
      <span>Strona {filters.page}</span>
      <button
        disabled={isPending || !hasNext}
        onClick={() => goTo(filters.page + 1)}
      >
        Następna
      </button>
    </nav>
  )
}

Prezentowane przyciski nawigacji wymagają do działania obsługi JavaScriptu. W przypadku indeksowalnych archiwów należy jednak zapewnić standardowe linki HTML prowadzące do kolejnych stron. Jeżeli użytkownik poda poprawny składniowo, lecz zbyt wysoki numer strony, powyższy przykład wyświetli pusty stan z możliwością powrotu na początek – w przypadku w pełni indeksowanej paginacji zaleca się natomiast wdrożenie dedykowanej polityki zwracającej status HTTP 404.

Awaria bazy nie jest pustym wynikiem. Pozwól jej trafić do granicy błędu i pokaż możliwość ponowienia:

Code
// app/blog/error.tsx
'use client'
 
export default function Error({ reset }: { reset: () => void }) {
  return (
    <div role="alert">
      <p>Nie udało się pobrać wyników.</p>
      <button onClick={() => reset()}>Spróbuj ponownie</button>
    </div>
  )
}

SEO filtrowanych URL-i w Next.js

Filtry w URL są świetne dla użytkownika, ale mogą być kosztowne dla . Jeśli każdy parametr tworzy nowy indeksowalny adres, łatwo wygenerować tysiące podobnych stron:

Code
/blog?tag=react
/blog?tag=react&sort=popular
/blog?tag=react&tag=nextjs&sort=oldest
/blog?q=react&tag=nextjs&page=7

Nie każda kombinacja zasługuje na indeks. Główne kategorie i ważne tagi warto indeksować i linkować wewnętrznie. Canonical kieruj do duplikatu lub strony o bardzo podobnej treści — nie ustawiaj automatycznie /blog dla wszystkich zapytań i podzbiorów wyników. noindex służy wykluczeniu z indeksu, a robots.txt ograniczeniu crawlowania. Google musi móc pobrać stronę, aby odczytać noindex; blokada w robots.txt może to uniemożliwić i sama nie gwarantuje usunięcia adresu z indeksu. Pełną klasyfikację filtrowanych URL-i, wybór między linkiem kanonicznym, noindex, robots.txt i przekierowaniem oraz nawigację fasetową w dużych katalogach opisuję w artykule o obsłudze parametrów w URL bez duplikacji treści.

Elastyczne i wydajne narzędzia dla biznesu, które dotrzymają kroku Twojemu rozwojowi.
Next.js

Często zadawane pytania

Czy zmiana filtrów powoduje pełne przeładowanie strony?

Nie — router.push albo router.replace wykonuje miękką nawigację po stronie klienta. Opcja { scroll: false } dodatkowo zachowuje pozycję przewijania. Server Component renderuje nową listę wyników, ale wspólny layout, nawigacja i panel filtrów nie przeładowują całego dokumentu.

Jak obsłużyć wiele tagów naraz?

Użyj powtarzalnego parametru w URL: ?tag=react&tag=nextjs. W Client Component useSearchParams().getAll("tag") zwraca tablicę, a w Server Component searchParams może mieć tag jako string albo string[] — obsłuż oba przypadki w funkcji normalizującej.

Czy Google indeksuje strony z filtrami?

Może. Dla wartościowych filtrów przygotuj stabilne, linkowane URL-e. Canonical służy konsolidacji duplikatów lub bardzo podobnych stron, noindex wykluczeniu z indeksu, a robots.txt ograniczeniu crawlowania. Google musi pobrać stronę, aby zobaczyć noindex; blokada w robots.txt sama nie gwarantuje usunięcia adresu z indeksu.

Po co debounce, skoro mam useTransition?

Debounce odkłada aktualizację URL do momentu, gdy użytkownik przestanie pisać, np. na 300 ms. useTransition oznacza aktualizację jako przejście i udostępnia isPending. Nie zastępuje debounce, nie anuluje sam zapytań do bazy i nie rozwiązuje konfliktów między równoległymi zmianami filtrów.

Kiedy użyć router.replace, a kiedy router.push?

Dla wpisywania w pole wyszukiwania zwykle użyj router.replace, żeby nie zaśmiecać historii przeglądarki. Dla świadomych akcji, takich jak kliknięcie filtra, sortowanie albo paginacja, router.push ma sens, bo użytkownik może chcieć wrócić do poprzedniego widoku.

Dlaczego Suspense nie pokazuje skeletonu przy zmianie filtrów?

Podczas przejścia React może zachować wcześniej pokazaną treść. Zmiana key zależnego od znormalizowanych filtrów resetuje granicę, ale fallback jest potrzebny tylko, gdy potomkowie zawieszają renderowanie. Key nie wymusza pobrania danych ani unieważnienia cache. W statycznych trasach kliencki useSearchParams wymaga granicy Suspense; pokazany przykład odczytuje searchParams na serwerze i renderuje stronę dynamicznie.

O autorze

Maciej Sala

Maciej Sala — konsultant technologiczny produktów cyfrowych i web developer z bogatym doświadczeniem w marketingu internetowym oraz SEO. Na co dzień pracuje z Reactem, Next.js i TypeScriptem, a ostatnio także z Astro i narzędziami do automatyzacji procesów AI. Sprawnie łączy perspektywę produktową z praktycznym podejściem do kodu. Przez kilka lat był związany z branżą gier wideo jako project manager i game designer. Absolwent historii na Uniwersytecie Jagiellońskim oraz studiów podyplomowych z marketingu internetowego na AGH w Krakowie. Po godzinach trenuje na siłowni, maluje figurki i rozwija własne projekty.

Pomagam przekładać takie tematy na konkretne wdrożenia w frontendzie, SEO, analityce i procesie produktowym.

Skontaktuj się ze mną
LH.pl – Hosting Mango

Biblioteka wiedzy na temat Next.js i React

Czytaj dalej

Zobacz więcej wpisów
Duplikacja treści przez parametry w URL w Next.js i Astro

Parametry w URL mają, jak przysłowiowa moneta ma dwie strony. Z jednej, napędzają filtry, sortowanie, paginację i śledzenie kampanii, a z drugiej, jednocześnie potrafią cicho popsuć widoczność serwisu przez duplikacje treści, marnowany budżet indeksowania i rozwodnione link equity. W aplikacjach React, Next.js i Astro to problem architektoniczny i właśnie dlatego samo użycie rel="canonical" go nie rozwiązuje. W tym przewodniku przechodzę od klasyfikacji parametrów do decyzji o indeksacji, normalizacji URL-i, renderowania, paginacji oraz kontroli nawigacji fasetowej.

Maciej Sala

Maciej Sala

Founder StriveLab

Server i Client Components w Next.js: gdzie przebiega granica serwer–klient

Komponent działa lokalnie, ale po wdrożeniu na produkcję pojawia się niezgodność hydratacji ang. hydration mismatch , a prosta strona produktu pobiera kilkaset kilobajtów JavaScriptu. Zamiast natychmiast wyłączać SSR czy otaczać kod memoizacją, warto cofnąć się o krok. Problem rzadko leży w braku optymalizacji — częściej w braku decyzji, która część interfejsu realnie wymaga przeglądarki. React Server Components przesunęły granicę między serwerem a klientem. W App Routerze najpierw decydujemy, gdzie wykonać pracę, a dopiero potem dobieramy hooki i biblioteki.

Maciej Sala

Maciej Sala

Founder StriveLab

TanStack Table w Next.js: sortowanie, filtrowanie i paginacja

TanStack Table v9 dostarcza mechanikę tabeli, ale nie gotowy komponent. To zaleta, jeśli potrzebujesz własnego wyglądu i pełnej kontroli nad zachowaniem. Oznacza też odpowiedzialność za semantykę HTML, dostępność, stan ładowania, integrację z URL i poprawny podział pracy między przeglądarkę a serwer.

Maciej Sala

Maciej Sala

Founder StriveLab

LH.pl – Cloud Server 1C4G