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

# Routage

> Bases de la définition des routes Laravel, des paramètres de route et des routes nommées.

## Routage de base

La route la plus simple de Laravel prend un URI et une closure.
Sans fichier de configuration complexe, vous définissez facilement une route et son comportement.

```php theme={null}
use Illuminate\Support\Facades\Route;

Route::get('/greeting', function () {
    return 'Hello World';
});
```

### Fichiers de route par défaut

Toutes les routes Laravel sont définies dans les fichiers du répertoire `routes/`.
Ces fichiers sont chargés automatiquement par Laravel selon la configuration de `bootstrap/app.php`.

```mermaid theme={null}
flowchart LR
    A["Requête entrante"] --> B{{"Type de requête"}}
    B -->|"Navigateur<br>Session / CSRF"| C["routes/web.php<br>Groupe de middleware web"]
    B -->|"API<br>Sans état"| D["routes/api.php<br>Groupe de middleware api"]
    B -->|"Commande CLI"| E["routes/console.php<br>Définition de commandes Artisan"]
    C --> F["Contrôleur / Closure"]
    D --> F
    E --> G["Handler de commande"]
```

`routes/web.php` définit les routes destinées au navigateur.
Le groupe de middlewares `web` s'y applique, fournissant sessions, protection CSRF et chiffrement des cookies.

```php theme={null}
use App\Http\Controllers\UserController;

Route::get('/user', [UserController::class, 'index']);
```

### Routes d'API

Si votre application propose une API sans état, activez le routing API via la commande Artisan `install:api`.

```shell theme={null}
php artisan install:api
```

La commande `install:api` installe [Laravel Sanctum](/fr/sanctum) et crée le fichier `routes/api.php`.
Sanctum fournit une garde d'authentification par tokens API simple et robuste pour les consommateurs API tiers, les SPA et les applications mobiles.

```php theme={null}
Route::get('/user', function (Request $request) {
    return $request->user();
})->middleware('auth:sanctum');
```

Les routes de `routes/api.php` sont sans état et le groupe de [middlewares](/fr/middleware) `api` s'y applique.
De plus, le préfixe `/api` est ajouté automatiquement à toutes les routes ; vous n'avez pas à le préfixer manuellement.
Pour modifier le préfixe, éditez `bootstrap/app.php`.

```php theme={null}
->withRouting(
    api: __DIR__.'/../routes/api.php',
    apiPrefix: 'api/admin',
    // ...
)
```

### Verbes HTTP disponibles

Le routeur peut enregistrer des routes pour tous les verbes HTTP.

```php theme={null}
Route::get($uri, $callback);
Route::post($uri, $callback);
Route::put($uri, $callback);
Route::patch($uri, $callback);
Route::delete($uri, $callback);
Route::options($uri, $callback);
```

Pour répondre à plusieurs verbes, utilisez `match` ou `any`.

```php theme={null}
Route::match(['get', 'post'], '/', function () {
    // ...
});

Route::any('/', function () {
    // ...
});
```

<Info>
  Dans les formulaires HTML `POST`, `PUT`, `PATCH` ou `DELETE` du fichier `web`, incluez toujours la directive `@csrf`.
  Sinon la requête sera rejetée.
</Info>

## Routes retournant une vue

Si votre route ne fait que retourner une vue, `Route::view` est plus concis.

```php theme={null}
Route::view('/welcome', 'welcome');

// Passer des données à la vue
Route::view('/welcome', 'welcome', ['name' => 'Taylor']);
```

## Paramètres de route

### Paramètres obligatoires

Pour capturer une partie dynamique de l'URL, utilisez un paramètre de route.
Encadrez-le de `{}` et récupérez-le comme argument de la closure.

```php theme={null}
Route::get('/user/{id}', function (string $id) {
    return 'ID utilisateur : ' . $id;
});
```

Plusieurs paramètres sont possibles.

```php theme={null}
Route::get('/posts/{post}/comments/{comment}', function (string $postId, string $commentId) {
    return "Commentaire {$commentId} du post {$postId}";
});
```

<Warning>
  Un paramètre de route ne peut pas contenir le caractère `/`.
</Warning>

### Paramètres optionnels

Pour rendre un paramètre optionnel, ajoutez `?` à son nom et donnez une valeur par défaut à l'argument correspondant.

```php theme={null}
Route::get('/user/{name?}', function (?string $name = null) {
    return $name ?? 'Invité';
});

Route::get('/user/{name?}', function (?string $name = 'Invité') {
    return $name;
});
```

### Contraintes par expressions régulières

La méthode `where` permet de contraindre le format d'un paramètre par une regex.

```php theme={null}
Route::get('/user/{id}', function (string $id) {
    // ...
})->where('id', '[0-9]+');

Route::get('/user/{name}', function (string $name) {
    // ...
})->where('name', '[a-zA-Z]+');
```

Des méthodes pratiques existent pour les motifs courants.

```php theme={null}
Route::get('/user/{id}/{name}', function (string $id, string $name) {
    // ...
})->whereNumber('id')->whereAlpha('name');
```

## Routes nommées

Les routes nommées permettent de référencer une route par son nom lors de la génération d'URL ou des redirections.

```php theme={null}
Route::get('/user/profile', function () {
    // ...
})->name('profile');
```

### Génération d'URL vers une route nommée

Utilisez le helper `route` pour générer une URL depuis un nom de route.

```php theme={null}
// Génération d'URL
$url = route('profile');

// Génération d'URL avec paramètres
$url = route('user.show', ['id' => 1]);
```

### Redirection

```php theme={null}
return redirect()->route('profile');
```

## Groupes de routes

Regroupez des routes liées pour partager middlewares, contrôleur, préfixe, etc.

```mermaid theme={null}
flowchart TD
    A["Requête HTTP"] --> B["Routeur"]
    B --> C{{"Route correspondante ?"}}
    C -->|"Non"| D["Réponse 404"]
    C -->|"Oui"| E["Vérification des middlewares de la route"]
    E --> F{{"Middlewares passés ?"}}
    F -->|"Refus"| G["Redirection /<br>Réponse d'erreur"]
    F -->|"Passe"| H["Exécution du contrôleur /<br>de la closure"]
    H --> I["Génération de la réponse"]
    I --> J["Envoi au client"]
```

### Middleware

```php theme={null}
Route::middleware(['auth'])->group(function () {
    Route::get('/dashboard', function () {
        // Accessible uniquement aux utilisateurs authentifiés
    });

    Route::get('/account', function () {
        // Accessible uniquement aux utilisateurs authentifiés
    });
});
```

### Contrôleur

Regroupez les routes utilisant le même contrôleur.

```php theme={null}
use App\Http\Controllers\OrderController;

Route::controller(OrderController::class)->group(function () {
    Route::get('/orders', 'index');
    Route::post('/orders', 'store');
    Route::get('/orders/{id}', 'show');
});
```

### Préfixe

Vous pouvez ajouter un préfixe commun aux URI des routes.

```php theme={null}
Route::prefix('admin')->group(function () {
    Route::get('/users', function () {
        // Accessible sur /admin/users
    });
    Route::get('/posts', function () {
        // Accessible sur /admin/posts
    });
});
```

## Consultation des routes

Pour afficher toutes les routes définies, utilisez la commande Artisan.

```shell theme={null}
php artisan route:list
```

Pour inclure les informations sur les middlewares :

```shell theme={null}
php artisan route:list -v
```

Pour n'afficher que les routes commençant par une URI :

```shell theme={null}
php artisan route:list --path=user
```

## Prochaines étapes

<Card title="Vues" icon="eye" href="/fr/views">
  Découvrez comment créer des vues et leur transmettre des données depuis un contrôleur.
</Card>


## Related topics

- [Cycle de vie d'une requête](/fr/lifecycle.md)
- [Mises à jour Laravel — mars 2026](/fr/blog/changelog/202603.md)
- [Les nouveautés de Laravel 13](/fr/blog/laravel-13-new-features.md)
- [Laravel Folio](/fr/folio.md)
- [Structure d'application Laravel 11+](/fr/advanced/app-structure.md)