0Pricing
Next.js 15 Fullstack (App Router + Server Actions) · Lekcja

Buforowanie i ponowna walidacja

Poznaj wydajne mechanizmy buforowania Next.js oraz dowiedz się, jak ponownie walidować dane w pamięci podręcznej, aby wyświetlać aktualne treści

Buforowanie i ponowna walidacja to bezpłatna lekcja Next.js 15 Fullstack (App Router + Server Actions) na CoddyKit. To lekcja 2 z 3. Możesz przeczytać całą lekcję poniżej za darmo — a potem ćwiczyć ją interaktywnie w przeglądarce z wbudowanym edytorem kodu i tutorem AI dostępnym 24/7. To część ścieżki edukacyjnej Next.js 15 Fullstack (App Router + Server Actions), a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs Next.js 15 Fullstack (App Router + Server Actions) zawiera 3 lekcji w sumie.

Części tej lekcji nie zostały jeszcze przetłumaczone i są wyświetlane po angielsku.

Why Caching Matters

Caching is a fundamental technique to improve the performance and responsiveness of web applications.

Imagine fetching the same data repeatedly from a database or an API. This creates unnecessary load and slows down your app.

Caching stores a copy of frequently accessed data, so it can be served faster on subsequent requests, reducing latency and resource usage.

Built-in Data Cache

Next.js 15, especially with the App Router, comes with powerful built-in caching mechanisms.

  • It intelligently caches data fetched using the native fetch API within Server Components.
  • This cache is stored on the server, ensuring faster responses for repeat visitors or multiple requests for the same data.
  • It helps your application deliver content quickly without constant re-fetching.

`fetch` Defaults in Server Components

When you use the standard fetch API inside a Next.js Server Component, Next.js automatically caches the data.

This means if the same fetch request is made again, Next.js will serve the data from its cache instead of hitting the external API.

This behavior is optimized for scenarios where data doesn't change frequently and can significantly boost performance.

Try Default Caching

Here's a simple example of a Server Component fetching data. Notice how Next.js caches the result implicitly.

If you were to run this and refresh, the fetch call might not hit the external API again immediately, depending on the cache lifetime.

// app/page.js
async function getUserData() {
  // This fetch request is automatically cached by Next.js
  const res = await fetch('https://jsonplaceholder.typicode.com/users/1');
  if (!res.ok) {
    throw new Error('Failed to fetch user data');
  }
  return res.json();
}

export default async function HomePage() {
  const user = await getUserData();
  return (
    <div>
      <h1>User Profile</h1>
      <p>Name: {user.name}</p>
      <p>Email: {user.email}</p>
      <p>Fetched at: {new Date().toLocaleTimeString()}</p>
    </div>
  );
}

Bypassing the Cache

Sometimes, you need to ensure data is always fresh and not served from the cache. For instance, when displaying real-time stock prices or user-specific data that changes often.

You can opt out of caching for a specific fetch request by setting the cache option to 'no-store'.

  • fetch('...', { cache: 'no-store' }) tells Next.js to always re-fetch data.
  • This ensures you get the latest information every time.

Try Bypassing Cache

This example demonstrates how to explicitly bypass the cache. Each time this component renders, a new request will be made to the API.

// app/live-data/page.js
async function getLiveTime() {
  // This fetch request explicitly opts out of caching
  const res = await fetch('https://worldtimeapi.org/api/ip', {
    cache: 'no-store', // Always re-fetch
  });
  if (!res.ok) {
    throw new Error('Failed to fetch live time');
  }
  return res.json();
}

export default async function LiveDataPage() {
  const timeData = await getLiveTime();
  return (
    <div>
      <h1>Live Time</h1>
      <p>Current time in your timezone:</p>
      <p><b>{new Date(timeData.datetime).toLocaleTimeString()}</b></p>
      <p>Last fetched: {new Date().toLocaleTimeString()}</p>
    </div>
  );
}

Revalidating Data Over Time

What if you want data to be cached but refresh after a certain period? Next.js supports time-based revalidation, similar to Incremental Static Regeneration (ISR).

You can specify a revalidate option within the next property of your fetch call:

  • fetch('...', { next: { revalidate: 60 } }) will cache the data for 60 seconds.
  • After 60 seconds, the next request will trigger a re-fetch in the background, serving stale data first, then fresh data.

Try Time-based Revalidation

In this example, the data will be cached for 10 seconds. If you refresh the page within 10 seconds, you'll see the cached time. After 10 seconds, a new fetch will occur.

// app/revalidated-data/page.js
async function getRevalidatedData() {
  // Data will be revalidated every 10 seconds
  const res = await fetch('https://worldtimeapi.org/api/timezone/Etc/UTC', {
    next: { revalidate: 10 }, // Revalidate after 10 seconds
  });
  if (!res.ok) {
    throw new Error('Failed to fetch revalidated data');
  }
  return res.json();
}

export default async function RevalidatedPage() {
  const data = await getRevalidatedData();
  return (
    <div>
      <h1>Revalidated UTC Time</h1>
      <p>Current UTC Time: <b>{new Date(data.datetime).toLocaleTimeString()}</b></p>
      <p>This data revalidates every 10 seconds.</p>
      <p>Last rendered: {new Date().toLocaleTimeString()}</p>
    </div>
  );
}

Manual Revalidation

Beyond time-based revalidation, Next.js also allows you to revalidate cached data manually, or "on-demand".

  • revalidatePath('/path'): Revalidates the cache for a specific page path.
  • revalidateTag('tag'): Revalidates all fetch requests that were tagged with a specific string (e.g., fetch('...', { next: { tags: ['products'] } })).

This is useful when data changes due to a user action (e.g., updating a product) and you want to ensure the UI shows the latest information immediately.

Test Your Knowledge

Which of the following Next.js fetch options ensures that data is ALWAYS fetched from the origin server on every request, bypassing any cache?

Caching & Revalidation Recap

In this lesson, you learned about Next.js's powerful data caching mechanisms.

  • Next.js caches fetch requests in Server Components by default.
  • You can bypass the cache with { cache: 'no-store' } for real-time data.
  • Time-based revalidation (ISR) is achieved with { next: { revalidate: N } }.
  • On-demand revalidation uses revalidatePath or revalidateTag to manually refresh cached data.

Mastering these techniques is crucial for building high-performance Next.js applications!

Często zadawane pytania

Czy lekcja „Buforowanie i ponowna walidacja” jest bezpłatna?

Tak — pełny tekst „Buforowanie i ponowna walidacja” jest dostępny za darmo tutaj w sieci. Aby ćwiczyć ją interaktywnie (wbudowany edytor kodu i tutor AI dostępny 24/7) i odblokować resztę kursu Next.js 15 Fullstack (App Router + Server Actions), przejdź na CoddyKit PRO. Kurs Next.js 15 Fullstack (App Router + Server Actions) zawiera 3 lekcji w sumie.

Co nauczysz się w „Buforowanie i ponowna walidacja”?

Poznaj wydajne mechanizmy buforowania Next.js oraz dowiedz się, jak ponownie walidować dane w pamięci podręcznej, aby wyświetlać aktualne treści Ćwiczysz Next.js 15 Fullstack (App Router + Server Actions) z praktycznym kodem, który uruchamiasz bezpośrednio w przeglądarce, a tutor AI dostępny 24/7 odpowiada na Twoje pytania podczas pracy nad lekcją.

Czy potrzebuję doświadczenia, aby zacząć Next.js 15 Fullstack (App Router + Server Actions)?

Nie wymagamy żadnego doświadczenia. Next.js 15 Fullstack (App Router + Server Actions) w CoddyKit jest strukturyzowany dla początkujących i zaawansowanych użytkowników, więc możesz zacząć tutaj lub od początku i uczyć się w swoim tempie. To lekcja 2 z 3.

Ile czasu zajmuje lekcja „Buforowanie i ponowna walidacja”?

Większość lekcji CoddyKit trwa około 5–10 minut. Każda lekcja to mały, interaktywny krok, dzięki czemu robisz systematyczne postępy i zawsze wracasz dokładnie do tego samego miejsca — na webie i w aplikacji.

Czy mogę pisać i uruchamiać kod w tej lekcji Next.js 15 Fullstack (App Router + Server Actions)?

Tak. Każda lekcja Next.js 15 Fullstack (App Router + Server Actions) zawiera wbudowany edytor kodu, więc piszesz i uruchamiasz prawdziwy kod bezpośrednio w przeglądarce i od razu otrzymujesz sprzężenie zwrotne od AI — bez konfiguracji na komputerze.

Wszystkie lekcje w tym kursie

  1. Pobieranie danych po stronie serwera
  2. Buforowanie i ponowna walidacja
  3. Równoległe, sekwencyjne i strumieniowe pobieranie danych
← Powrót do Next.js 15 Fullstack (App Router + Server Actions)