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

Optymistyczne aktualizacje interfejsu

Zaimplementuj wzorce optymistycznych aktualizacji interfejsu za pomocą Server Actions, aby zapewnić użytkownikom natychmiastową informację zwrotną przed potwierdzeniem przez serwer

Optymistyczne aktualizacje interfejsu to bezpłatna lekcja Next.js 15 Fullstack (App Router + Server Actions) na CoddyKit. To lekcja 1 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.

Instant Feedback with Optimistic UI

Imagine clicking 'Like' on a post. Does it update instantly, or do you wait for a spinner?

Optimistic UI is a technique where the user interface updates immediately after an action, *before* the server confirms it. This gives users instant feedback and makes your app feel much faster and more responsive.

How Optimistic UI Works

The process is simple:

  • User Action: The user performs an action (e.g., submitting a form).
  • Instant UI Update: Your UI immediately updates to reflect the *expected* outcome.
  • Server Action: In the background, a server request (like a Next.js Server Action) is sent to perform the actual operation.
  • Reconciliation: If the server action succeeds, the UI stays as is. If it fails, the UI reverts to its previous state.

This creates a smooth, uninterrupted user experience.

Next.js 15 & useOptimistic

Next.js 15, powered by React, provides the useOptimistic hook to make implementing optimistic UI updates straightforward.

This hook is specifically designed to manage a temporary, speculative state that anticipates the result of an asynchronous operation (like a Server Action) before the final server response is received.

Understanding useOptimistic Syntax

The useOptimistic hook has a simple signature:

const [optimisticState, addOptimistic] = useOptimistic(state, updater);
  • state: The actual, authoritative state (e.g., data fetched from the server).
  • updater: A function that takes the current state and a payload, returning the new optimistic state.
  • optimisticState: The state that your UI should currently display. It will be either the actual state or the optimistically updated state.
  • addOptimistic: A function you call with a payload to trigger an optimistic update.

Code Demo: Basic Task List

Let's start with a simple client component that manages a list of tasks using standard React useState. Run this to see how it works normally.

'use client';

import { useState } from 'react';

export default function TaskList() {
  const [tasks, setTasks] = useState([
    { id: 1, text: 'Plan lesson' },
    { id: 2, text: 'Review code' }
  ]);
  const [input, setInput] = useState('');

  const handleAddTask = () => {
    if (input.trim() === '') return;
    const newTask = { id: Date.now(), text: input };
    setTasks((prev) => [...prev, newTask]);
    setInput('');
  };

  return (
    <div>
      <h3>My Daily Tasks</h3>
      <ul>
        {tasks.map(task => (
          <li key={task.id}>{task.text}</li>
        ))}
      </ul>
      <input
        type="text"
        value={input}
        onChange={(e) => setInput(e.target.value)}
        placeholder="Add new task..."
      />
      <button onClick={handleAddTask}>Add Task</button>
    </div>
  );
}

Code Demo: Adding Optimistic Updates

Now, let's enhance our task list with useOptimistic. When you add a task, it will appear instantly with a ' (pending...)' label, even before our simulated server action finishes.

'use client';

import { useState, useOptimistic } from 'react';

export default function OptimisticTaskList() {
  const [tasks, setTasks] = useState([
    { id: 1, text: 'Plan lesson' },
    { id: 2, text: 'Review code' }
  ]);
  const [input, setInput] = useState('');

  // useOptimistic hook setup
  const [optimisticTasks, addOptimisticTask] = useOptimistic(
    tasks, // The actual source of truth
    (currentTasks, newTaskText) => [ // Updater function
      ...currentTasks,
      { id: Date.now(), text: newTaskText + ' (pending...)' }
    ]
  );

  // Simulate a server action with a delay
  async function simulateServerAction(text) {
    await new Promise(resolve => setTimeout(resolve, 1500));
    // In a real Next.js app, this would be a Server Action
    // that updates a database and triggers revalidation.
    // Here, we simulate the *result* of that revalidation
    // by updating the actual 'tasks' state after the delay.
    const newServerTask = { id: Date.now(), text: text };
    setTasks((prev) => [...prev, newServerTask]);
  }

  async function handleSubmit(event) {
    event.preventDefault();
    if (input.trim() === '') return;
    const taskText = input;
    setInput(''); // Clear input immediately

    // Step 1: Optimistically update the UI
    addOptimisticTask(taskText);

    // Step 2: Call the 'server action' (simulated)
    await simulateServerAction(taskText);
  }

  return (
    <div>
      <h3>Optimistic Tasks</h3>
      <ul>
        {optimisticTasks.map(task => (
          <li key={task.id}>{task.text}</li>
        ))}
      </ul>
      <form onSubmit={handleSubmit}>
        <input
          type="text"
          value={input}
          onChange={(e) => setInput(e.target.value)}
          placeholder="Add new task..."
        />
        <button type="submit">Add Task</button>
      </form>
    </div>
  );
}

Connecting to Real Server Actions

In a live Next.js application, the simulateServerAction function from our example would be replaced by an actual Next.js Server Action.

A Server Action would typically:

  1. Update a database or external service.
  2. Call revalidatePath() or revalidateTag() to tell Next.js to fetch the latest data.

When Next.js revalidates, your component will re-render with the true, confirmed state from the server, automatically replacing the optimistic state.

Handling Errors and Reversion

What happens if the server action fails? This is where optimistic UI truly shines.

  • If the server action returns an error, Next.js's revalidation will fetch the *actual* data from the server.
  • Since the server didn't confirm the change, the UI will automatically revert to the previous correct state.

While the UI reverts, it's crucial to provide user feedback, like a toast notification, explaining why the action failed.

Best Practices for Optimistic UI

To make the most of optimistic updates:

  • Keep it Simple: Best for simple, predictable actions like toggling a 'like' or adding an item.
  • Predictable Outcomes: Only use when you're confident the server action will succeed.
  • Error Feedback: Always have a robust error handling strategy to inform users if an action fails.
  • Avoid Complex Logic: Don't use for actions with complex server-side validation or side effects that might lead to unexpected UI states.

Check Your Understanding

Which of the following are key benefits of implementing Optimistic UI updates?

Recap: Enhance User Experience

You've learned about Optimistic UI, a powerful technique to make your Next.js applications feel incredibly fast and responsive.

  • By using the useOptimistic hook, you can update the UI instantly, anticipating server responses.
  • This approach, combined with Next.js Server Actions and revalidation, ensures the UI eventually reflects the true server state, even in case of errors.

Mastering optimistic updates is a great step towards building highly engaging user experiences!

Często zadawane pytania

Czy lekcja „Optymistyczne aktualizacje interfejsu” jest bezpłatna?

Tak — pełny tekst „Optymistyczne aktualizacje interfejsu” 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 „Optymistyczne aktualizacje interfejsu”?

Zaimplementuj wzorce optymistycznych aktualizacji interfejsu za pomocą Server Actions, aby zapewnić użytkownikom natychmiastową informację zwrotną przed potwierdzeniem przez serwer Ć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 1 z 3.

Ile czasu zajmuje lekcja „Optymistyczne aktualizacje interfejsu”?

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. Optymistyczne aktualizacje interfejsu
  2. Przesyłanie plików za pomocą akcji
  3. Walidacja i obsługa błędów w Server Actions
← Powrót do Next.js 15 Fullstack (App Router + Server Actions)