0Pricing
Next.js 15 Fullstack (App Router + Server Actions) · Leçon

Gestion des erreurs dans les actions

Implémentez des stratégies efficaces de gestion des erreurs dans les actions serveur afin de fournir un retour fiable aux utilisateurs.

Gestion des erreurs dans les actions est une leçon Next.js 15 Fullstack (App Router + Server Actions) gratuite sur CoddyKit. Ceci est la leçon 3 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Next.js 15 Fullstack (App Router + Server Actions), et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Next.js 15 Fullstack (App Router + Server Actions) comprend 4 leçons au total.

Certaines parties de cette leçon n'ont pas encore été traduites et s'affichent en anglais.

Robust Server Actions

When building applications, things can go wrong! Data might be invalid, a database might be unreachable, or an external API could fail.

Effective error handling in Server Actions is crucial for a smooth user experience and maintaining data integrity. It prevents crashes and provides clear feedback.

The `try-catch` Block

In JavaScript/TypeScript, the fundamental way to handle potential errors is using a try-catch block. It allows you to 'try' executing code and 'catch' any errors that occur.

  • Code inside the try block is executed.
  • If an error occurs, execution jumps to the catch block.
  • The catch block receives the error object, allowing you to handle it gracefully.

Server Action Error Example

Let's look at a simple Server Action that might fail. Imagine an action that divides two numbers, but one could be zero.

Without error handling, a division by zero would crash the action and potentially the client-side form submission.

export async function divideNumbers(formData: FormData) {
  const num1 = Number(formData.get('num1'));
  const num2 = Number(formData.get('num2'));

  if (num2 === 0) {
    throw new Error('Cannot divide by zero!');
  }

  const result = num1 / num2;
  return { success: true, result };
}

Catching Errors on the Server

To prevent the action from crashing, we wrap the risky code in a try-catch block. This allows us to log the error on the server and prevent sensitive error details from reaching the client.

export async function divideNumbers(formData: FormData) {
  try {
    const num1 = Number(formData.get('num1'));
    const num2 = Number(formData.get('num2'));

    if (num2 === 0) {
      throw new Error('Cannot divide by zero!');
    }

    const result = num1 / num2;
    return { success: true, result };
  } catch (error: any) {
    console.error('Action Error:', error.message); // Log on server
    // Do NOT return `error` object directly to client!
    return { success: false, error: 'An unexpected error occurred.' };
  }
}

Returning Client-Friendly Errors

After catching an error on the server, we need to return a meaningful, client-friendly message. This message helps users understand what went wrong without exposing internal server details.

  • Return an object with a success: false flag.
  • Include an error property with a user-friendly message.
  • Avoid sending raw error stack traces to the client for security.

Action with Client Error Return

Here's how our divideNumbers action looks when returning specific error messages to the client:

Notice how different errors get different messages, and a generic message is used for unexpected errors.

export async function divideNumbers(formData: FormData) {
  try {
    const num1 = Number(formData.get('num1'));
    const num2 = Number(formData.get('num2'));

    if (isNaN(num1) || isNaN(num2)) {
      throw new Error('Invalid input: Please enter numbers.');
    }
    if (num2 === 0) {
      throw new Error('Division by zero is not allowed.');
    }

    const result = num1 / num2;
    return { success: true, result };
  } catch (error: any) {
    console.error('Server Action Failed:', error.message);
    return { success: false, error: error.message || 'Unknown error occurred.' };
  }
}

Client-Side Error Display

On the client, after calling a Server Action, you'll receive the returned object. You can then check the success and error properties to update your UI.

This allows you to show an error message to the user, disable parts of the form, or take other corrective actions.

import { useState } from 'react';
import { divideNumbers } from './actions'; // Your Server Action

export default function CalculatorForm() {
  const [message, setMessage] = useState('');

  async function handleSubmit(formData: FormData) {
    const res = await divideNumbers(formData);
    if (res.success) {
      setMessage(`Result: ${res.result}`);
    } else {
      setMessage(`Error: ${res.error}`);
    }
  }

  return (
    <form action={handleSubmit}>
      <input type="number" name="num1" />
      <input type="number" name="num2" />
      <button type="submit">Calculate</button>
      {message && <p>{message}</p>}
    </form>
  );
}

React `useFormState` Hook

For forms, React's useFormState hook is specifically designed to manage state returned by a Server Action. It simplifies displaying feedback (like success or error messages) after a form submission.

It takes your action and an initial state, and returns the current state and an updated action that you pass to your <form>'s action prop.

Using `useFormState` for Errors

Here's how to integrate useFormState to display error messages directly within your form component. It makes handling the action's response very clean.

import { useFormState } from 'react-dom';
import { divideNumbers } from './actions';

const initialState = { success: false, error: '', result: null };

export default function CalculatorForm() {
  const [state, formAction] = useFormState(divideNumbers, initialState);

  return (
    <form action={formAction}>
      <input type="number" name="num1" placeholder="Number 1" />
      <input type="number" name="num2" placeholder="Number 2" />
      <button type="submit">Calculate</button>
      {state.success && <p>Result: {state.result}</p>}
      {!state.success && state.error && <p style={{ color: 'red' }}>{state.error}</p>}
    </form>
  );
}

Handling Server Action Errors

Which of the following is the BEST practice for handling errors caught within a Next.js Server Action?

Recap: Error Handling

You've mastered error handling in Next.js Server Actions!

  • Use try-catch blocks to gracefully handle errors on the server.
  • Log server-side errors for debugging and monitoring.
  • Return client-friendly error messages using a structured object (e.g., { success: false, error: 'message' }).
  • Utilize React's useFormState hook to easily manage and display action results and errors in your forms.

Robust error handling makes your applications more reliable and user-friendly!

Questions Fréquemment Posées

La leçon « Gestion des erreurs dans les actions » est-elle gratuite ?

Oui — le texte complet de « Gestion des erreurs dans les actions » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Next.js 15 Fullstack (App Router + Server Actions), passe à CoddyKit PRO. Le cours Next.js 15 Fullstack (App Router + Server Actions) comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Gestion des erreurs dans les actions » ?

Implémentez des stratégies efficaces de gestion des erreurs dans les actions serveur afin de fournir un retour fiable aux utilisateurs. Tu pratiques Next.js 15 Fullstack (App Router + Server Actions) avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer Next.js 15 Fullstack (App Router + Server Actions) ?

Aucune expérience préalable n'est requise. Next.js 15 Fullstack (App Router + Server Actions) sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 3 sur 4.

Combien de temps prend la leçon « Gestion des erreurs dans les actions » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon Next.js 15 Fullstack (App Router + Server Actions) ?

Oui. Chaque leçon Next.js 15 Fullstack (App Router + Server Actions) inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

  1. Formulaires élémentaires avec des actions serveur
  2. Modifier les données et revalider
  3. Gestion des erreurs dans les actions
  4. Interface optimiste et états d’attente avec les actions serveur
← Retour à Next.js 15 Fullstack (App Router + Server Actions)