> ## Documentation Index
> Fetch the complete documentation index at: https://kawax.biz/llms.txt
> Use this file to discover all available pages before exploring further.

# Réponses

> Types de réponses Laravel et comment retourner la réponse appropriée depuis un contrôleur.

## Qu'est-ce qu'une réponse

Un contrôleur ou une route doit renvoyer une **réponse** au navigateur.
Laravel propose des mécanismes simples pour retourner divers formats : chaîne, tableau, vue, redirection, JSON, etc.

## Réponses de base

### Retourner une chaîne

La réponse la plus simple est une chaîne.
Laravel la convertit automatiquement en réponse HTTP appropriée.

```php theme={null}
Route::get('/', function () {
    return 'Hello World';
});
```

### Retourner un tableau

Un tableau retourné est automatiquement converti en JSON.

```php theme={null}
Route::get('/users', function () {
    return [
        ['id' => 1, 'name' => 'Tanaka'],
        ['id' => 2, 'name' => 'Suzuki'],
    ];
});
```

<Info>
  Retourner directement un modèle ou une collection Eloquent produit également une conversion automatique en JSON. Un pattern très utilisé pour créer rapidement des API.
</Info>

### Retourner un modèle Eloquent

```php theme={null}
use App\Models\User;

Route::get('/user/{user}', function (User $user) {
    return $user;
});
```

## L'objet Response

Le helper `response()` permet de retourner une réponse détaillée avec code HTTP et en-têtes personnalisés.

```php theme={null}
Route::get('/home', function () {
    return response('Hello World', 200)
        ->header('Content-Type', 'text/plain');
});
```

Le premier argument est le corps de la réponse, le second le code HTTP.

### Codes HTTP courants

| Code  | Signification                               |
| ----- | ------------------------------------------- |
| `200` | OK (succès)                                 |
| `201` | Created (ressource créée)                   |
| `204` | No Content                                  |
| `301` | Moved Permanently (redirection permanente)  |
| `302` | Found (redirection temporaire)              |
| `404` | Not Found                                   |
| `422` | Unprocessable Entity (erreur de validation) |
| `500` | Internal Server Error                       |

## Réponse de vue

Pour afficher un template Blade depuis un contrôleur, utilisez `view()`.
C'est la réponse la plus courante dans une application web.

```php theme={null}
<?php

namespace App\Http\Controllers;

use Illuminate\View\View;

class HomeController extends Controller
{
    public function index(): View
    {
        $users = [
            ['name' => 'Tanaka', 'email' => 'tanaka@example.com'],
            ['name' => 'Suzuki', 'email' => 'suzuki@example.com'],
        ];

        return view('users.index', ['users' => $users]);
    }
}
```

Le premier argument est le nom de la vue, le second un tableau de données pour la vue.

<Tip>
  Typer le retour avec `Illuminate\View\View` clarifie l'intention du code.
</Tip>

### Contrôler les détails avec `response()->view()`

Pour spécifier aussi le code HTTP et les en-têtes, utilisez `response()->view()`.

```php theme={null}
return response()
    ->view('errors.404', ['message' => 'Page introuvable'], 404);
```

## Redirections

### Redirection de base

Le helper `redirect()` retourne une réponse de redirection.
Souvent utilisé après l'envoi d'un formulaire.

```php theme={null}
use Illuminate\Http\RedirectResponse;

Route::get('/old-page', function (): RedirectResponse {
    return redirect('/new-page');
});
```

Exemple en contrôleur :

```php theme={null}
<?php

namespace App\Http\Controllers;

use Illuminate\Http\RedirectResponse;
use Illuminate\Http\Request;

class PostController extends Controller
{
    public function store(Request $request): RedirectResponse
    {
        // Sauvegarde de la publication...

        return redirect('/posts');
    }
}
```

### Redirection vers une route nommée

`route()` évite d'écrire l'URL directement.
Pour ne pas devoir modifier le code si l'URL change, préférez les routes nommées.

```php theme={null}
// Nommer les routes
Route::get('/posts', [PostController::class, 'index'])->name('posts.index');
Route::get('/posts/{post}', [PostController::class, 'show'])->name('posts.show');
```

```php theme={null}
// Redirection vers une route nommée
return redirect()->route('posts.index');

// Avec des paramètres de route
return redirect()->route('posts.show', ['post' => $post->id]);
```

### Retour à la page précédente

`back()` renvoie vers la page précédente.
Souvent utilisé lors d'un échec de validation.

```php theme={null}
return back();

// En conservant l'input
return back()->withInput();
```

### Redirection avec message flash

`with()` ajoute un message en session lors de la redirection.
Idéal pour confirmer un envoi de formulaire.

```php theme={null}
return redirect('/posts')->with('success', 'Publication créée.');
```

Affichez le message dans Blade :

```blade theme={null}
@if (session('success'))
    <div class="alert alert-success">
        {{ session('success') }}
    </div>
@endif
```

## Réponses JSON

Pour une API, retournez du JSON avec `response()->json()`.
L'en-tête `Content-Type: application/json` est ajouté automatiquement.

```php theme={null}
use Illuminate\Http\JsonResponse;

Route::get('/api/users', function (): JsonResponse {
    $users = [
        ['id' => 1, 'name' => 'Tanaka'],
        ['id' => 2, 'name' => 'Suzuki'],
    ];

    return response()->json($users);
});
```

Vous pouvez spécifier le code HTTP.

```php theme={null}
return response()->json(['message' => 'Créé'], 201);
```

Exemple en contrôleur :

```php theme={null}
<?php

namespace App\Http\Controllers;

use App\Models\User;
use Illuminate\Http\JsonResponse;
use Illuminate\Http\Request;

class UserController extends Controller
{
    public function index(): JsonResponse
    {
        $users = User::all();

        return response()->json($users);
    }

    public function store(Request $request): JsonResponse
    {
        // Création avec les données validées (form request ou $request->validate())
        $user = User::create($request->validated());

        return response()->json($user, 201);
    }
}
```

<Info>
  Retourner simplement un tableau ou un modèle Eloquent produit du JSON, mais `response()->json()` offre un contrôle fin sur code HTTP et en-têtes.
</Info>

## En-têtes de réponse

`header()` ajoute un en-tête HTTP.

```php theme={null}
return response('Hello World')
    ->header('Content-Type', 'text/plain')
    ->header('X-Custom-Header', 'MyValue');
```

Utilisez `withHeaders()` pour en ajouter plusieurs.

```php theme={null}
return response('Hello World')
    ->withHeaders([
        'Content-Type' => 'text/plain',
        'X-Custom-Header' => 'MyValue',
        'Cache-Control' => 'no-cache',
    ]);
```

## Exemple : quelle réponse choisir dans un contrôleur

Exemple récapitulatif adaptant la réponse à l'usage.

<Steps>
  <Step title="Définition des routes">
    ```php theme={null}
    use App\Http\Controllers\PostController;

    Route::get('/posts', [PostController::class, 'index'])->name('posts.index');
    Route::get('/posts/create', [PostController::class, 'create'])->name('posts.create');
    Route::post('/posts', [PostController::class, 'store'])->name('posts.store');
    Route::get('/posts/{post}', [PostController::class, 'show'])->name('posts.show');
    Route::delete('/posts/{post}', [PostController::class, 'destroy'])->name('posts.destroy');
    ```
  </Step>

  <Step title="Implémentation du contrôleur">
    ```php theme={null}
    <?php

    namespace App\Http\Controllers;

    use App\Models\Post;
    use Illuminate\Http\RedirectResponse;
    use Illuminate\Http\Request;
    use Illuminate\View\View;

    class PostController extends Controller
    {
        // Liste : retourne une vue
        public function index(): View
        {
            $posts = Post::latest()->get();

            return view('posts.index', ['posts' => $posts]);
        }

        // Formulaire de création : retourne une vue
        public function create(): View
        {
            return view('posts.create');
        }

        // Enregistrement : retourne une redirection
        public function store(Request $request): RedirectResponse
        {
            // Création avec les données validées (via un form request)
            $post = Post::create($request->validated());

            return redirect()
                ->route('posts.show', ['post' => $post->id])
                ->with('success', 'Publication créée.');
        }

        // Détail : retourne une vue
        public function show(Post $post): View
        {
            return view('posts.show', ['post' => $post]);
        }

        // Suppression : retourne une redirection
        public function destroy(Post $post): RedirectResponse
        {
            $post->delete();

            return redirect()
                ->route('posts.index')
                ->with('success', 'Publication supprimée.');
        }
    }
    ```
  </Step>
</Steps>

<Tip>
  Dans une application web, le choix se fait généralement entre `View` et `RedirectResponse`. Les actions d'affichage renvoient une `View`, tandis que les actions de modification (création, mise à jour, suppression) renvoient une `RedirectResponse` après le traitement.
</Tip>

## Prochaines étapes

<Card title="Validation" icon="check-circle" href="/fr/validation">
  Vérifiez les données d'entrée avec la validation avant de retourner une réponse.
</Card>


## Related topics

- [Demandes de permission](/fr/packages/laravel-copilot-sdk/permission-request.md)
- [Cycle de vie d'une requête](/fr/lifecycle.md)
- [Laravel Chisel — la bibliothèque de scripts post-installation des starter kits](/fr/blog/chisel-introduction.md)
- [Tutoriel bot - Laravel Bluesky](/fr/packages/laravel-bluesky/bot-tutorial.md)
- [Créer un serveur MCP avec Laravel](/fr/advanced/mcp-server.md)