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

Atualizações otimistas da interface

Implemente padrões de interface otimista com Server Actions para fornecer retorno instantâneo aos usuários antes da confirmação do servidor.

Atualizações otimistas da interface é uma aula grátis de Next.js 15 Fullstack (App Router + Server Actions) no CoddyKit. Esta é a aula 1 de 3. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Next.js 15 Fullstack (App Router + Server Actions), e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Next.js 15 Fullstack (App Router + Server Actions) inclui 3 aulas no total.

Partes desta aula ainda não foram traduzidas e aparecem em inglês.

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!

Perguntas Frequentes

A aula “Atualizações otimistas da interface” é grátis?

Sim — o texto completo de “Atualizações otimistas da interface” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Next.js 15 Fullstack (App Router + Server Actions), atualize para CoddyKit PRO. O curso de Next.js 15 Fullstack (App Router + Server Actions) inclui 3 aulas no total.

O que vou aprender em “Atualizações otimistas da interface”?

Implemente padrões de interface otimista com Server Actions para fornecer retorno instantâneo aos usuários antes da confirmação do servidor. Você pratica Next.js 15 Fullstack (App Router + Server Actions) com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar Next.js 15 Fullstack (App Router + Server Actions)?

Nenhuma experiência prévia é necessária. Next.js 15 Fullstack (App Router + Server Actions) no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 1 de 3.

Quanto tempo leva a aula “Atualizações otimistas da interface”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de Next.js 15 Fullstack (App Router + Server Actions)?

Sim. Cada aula de Next.js 15 Fullstack (App Router + Server Actions) inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

  1. Atualizações otimistas da interface
  2. Envio de arquivos com Actions
  3. Validação e Tratamento de Erros em Ações de Servidor
← Voltar para Next.js 15 Fullstack (App Router + Server Actions)