Next.js 15 Fullstack (App Router + Server Actions) · Lektion

Optimistische UI-Aktualisierungen

Implementieren Sie mit Server Actions optimistische UI-Muster, um Benutzern bereits vor der Serverbestätigung sofortiges Feedback zu geben.

Optimistische UI-Aktualisierungen ist eine kostenlose Next.js 15 Fullstack (App Router + Server Actions)-Lektion auf CoddyKit. Dies ist Lektion 1 von 3. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des Next.js 15 Fullstack (App Router + Server Actions)-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der Next.js 15 Fullstack (App Router + Server Actions)-Kurs umfasst insgesamt 3 Lektionen.

Teile dieser Lektion wurden noch nicht übersetzt und werden auf Englisch angezeigt.

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:

Update a database or external service.
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!

Häufig gestellte Fragen

Ist die Lektion „Optimistische UI-Aktualisierungen“ kostenlos?

Ja — der vollständige Text von „Optimistische UI-Aktualisierungen“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des Next.js 15 Fullstack (App Router + Server Actions)-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der Next.js 15 Fullstack (App Router + Server Actions)-Kurs umfasst insgesamt 3 Lektionen.

Was lerne ich in „Optimistische UI-Aktualisierungen“?

Implementieren Sie mit Server Actions optimistische UI-Muster, um Benutzern bereits vor der Serverbestätigung sofortiges Feedback zu geben. Du übst Next.js 15 Fullstack (App Router + Server Actions) mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um Next.js 15 Fullstack (App Router + Server Actions) zu starten?

Keine Vorkenntnisse erforderlich. Next.js 15 Fullstack (App Router + Server Actions) auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 1 von 3.

Wie lange dauert die Lektion „Optimistische UI-Aktualisierungen“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser Next.js 15 Fullstack (App Router + Server Actions)-Lektion Code schreiben und ausführen?

Ja. Jede Next.js 15 Fullstack (App Router + Server Actions)-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

Optimistische UI-Aktualisierungen
Datei-Uploads mit Actions
Validierung und Fehlerbehandlung in Server Actions

← Zurück zu Next.js 15 Fullstack (App Router + Server Actions)