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

# Requêtes HTTP

> Comment récupérer les données d'une requête HTTP avec l'objet Illuminate\Http\Request de Laravel.

## Qu'est-ce que l'objet Request

`Illuminate\Http\Request` est la classe qui permet de manipuler de manière orientée objet les requêtes HTTP reçues par votre application.
Elle donne accès à toutes les informations d'une requête : données de formulaire, chaîne de requête, fichiers, en-têtes, etc.

## Injection de la requête dans un contrôleur

Lorsque vous typez une méthode de contrôleur avec `Illuminate\Http\Request`, le conteneur de services Laravel injecte automatiquement l'instance de la requête.

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

namespace App\Http\Controllers;

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

class UserController extends Controller
{
    public function store(Request $request): RedirectResponse
    {
        $name = $request->input('name');

        // Sauvegarde de l'utilisateur...

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

Vous pouvez faire de même dans une closure de route.

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

Route::get('/', function (Request $request) {
    // ...
});
```

### Combinaison avec les paramètres de route

Si votre méthode reçoit aussi des paramètres de route, placez ces derniers après `Request`.

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

Route::put('/user/{id}', [UserController::class, 'update']);
```

```php theme={null}
public function update(Request $request, string $id): RedirectResponse
{
    // $request pour la requête, $id pour le paramètre de route

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

## Récupération des données de la requête

### Récupérer toutes les entrées

La méthode `all` retourne toutes les entrées sous forme de tableau.
Elle fonctionne aussi bien pour les formulaires HTML que pour les requêtes XHR.

```php theme={null}
$input = $request->all();
```

### Récupérer un champ spécifique

La méthode `input` récupère une valeur depuis la charge utile de la requête (y compris la chaîne de requête), quel que soit le verbe HTTP.

```php theme={null}
$name = $request->input('name');
```

Vous pouvez fournir une valeur par défaut en deuxième argument.

```php theme={null}
$name = $request->input('name', 'Sally');
```

Pour les entrées de tableau, utilisez la notation « point ».

```php theme={null}
$name = $request->input('products.0.name');

$names = $request->input('products.*.name');
```

### Récupérer la chaîne de requête

La méthode `query` ne récupère la valeur que depuis la chaîne de requête (après `?`).

```php theme={null}
$name = $request->query('name');

$name = $request->query('name', 'Helen');

// Récupère toute la chaîne de requête sous forme de tableau
$query = $request->query();
```

<Info>
  `input` cible à la fois le corps de la requête et la chaîne de requête, tandis que `query` ne cible que la chaîne de requête.
  Utilisez `query` si vous voulez distinguer les données POST du formulaire des paramètres d'URL.
</Info>

### Récupération typée

Au-delà de `input`, il existe des méthodes pour récupérer les valeurs avec un type spécifique.

```php theme={null}
// Récupère en tant que chaîne (instance Stringable)
$name = $request->string('name')->trim();

// Récupère en tant qu'entier
$perPage = $request->integer('per_page');

// Récupère en tant que booléen ("1", "true", "on", "yes" → true)
$archived = $request->boolean('archived');

// Récupère en tant que tableau
$versions = $request->array('versions');

// Récupère en tant qu'instance Carbon
$birthday = $request->date('birthday');
```

### Propriétés dynamiques

Vous pouvez également accéder aux champs comme à des propriétés.

```php theme={null}
$name = $request->name;
```

<Tip>
  Les propriétés dynamiques cherchent d'abord dans la charge utile de la requête, puis dans les paramètres de route.
</Tip>

### Récupérer un sous-ensemble d'entrées

Utilisez `only` ou `except` pour récupérer un sous-ensemble.

```php theme={null}
$input = $request->only(['username', 'password']);

$input = $request->except(['credit_card']);
```

## Vérifier la présence d'une entrée

`has` vérifie si une valeur est présente dans la requête.

```php theme={null}
if ($request->has('name')) {
    // ...
}

// Vérifie que toutes les clés sont présentes
if ($request->has(['name', 'email'])) {
    // ...
}
```

Pour vérifier qu'une valeur est présente et non vide, utilisez `filled`.

```php theme={null}
if ($request->filled('name')) {
    // ...
}
```

Pour vérifier qu'une valeur est absente ou vide, utilisez `isNotFilled`.

```php theme={null}
if ($request->isNotFilled('name')) {
    // ...
}
```

## Chemin et méthode de la requête

### Récupérer et vérifier le chemin

```php theme={null}
// Récupère le chemin (ex. : "foo/bar")
$uri = $request->path();

// Vérifie une correspondance avec un pattern (le joker * est autorisé)
if ($request->is('admin/*')) {
    // ...
}

// Vérifie la correspondance avec une route nommée
if ($request->routeIs('admin.*')) {
    // ...
}
```

### Récupérer l'URL

```php theme={null}
// URL sans chaîne de requête
$url = $request->url();

// URL avec chaîne de requête
$urlWithQueryString = $request->fullUrl();
```

### Vérifier la méthode HTTP

`isMethod` permet de vérifier la méthode HTTP.

```php theme={null}
$method = $request->method();

if ($request->isMethod('post')) {
    // Ne traite que les requêtes POST
}
```

## Upload de fichiers

### Récupérer les fichiers uploadés

La méthode `file` retourne le fichier uploadé.
Elle retourne une instance de `Illuminate\Http\UploadedFile`.

```php theme={null}
$file = $request->file('photo');

// Accessible aussi via une propriété dynamique
$file = $request->photo;
```

Pour vérifier la présence d'un fichier, utilisez `hasFile`.

```php theme={null}
if ($request->hasFile('photo')) {
    // ...
}
```

### Sauvegarder le fichier

La méthode `store` sauvegarde le fichier sur le stockage.
Le nom du fichier est généré automatiquement.

```php theme={null}
// Sauvegarde dans le répertoire "images" du disque par défaut
$path = $request->photo->store('images');

// Sauvegarde sur S3
$path = $request->photo->store('images', 's3');
```

Pour choisir le nom, utilisez `storeAs`.

```php theme={null}
$path = $request->photo->storeAs('images', 'filename.jpg');
```

<Warning>
  Si vous acceptez des uploads de fichiers, validez toujours leur type et leur taille.
  Il est recommandé de traiter cela via la validation.
</Warning>

## Exemple : réception de données de formulaire

Exemple de réception d'un formulaire d'inscription dans un contrôleur.

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

namespace App\Http\Controllers;

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

class RegisterController extends Controller
{
    public function store(Request $request): RedirectResponse
    {
        // Récupère les données du formulaire
        $name = $request->input('name');
        $email = $request->input('email');
        $password = $request->input('password');

        // Récupère uniquement les champs nécessaires
        $data = $request->only(['name', 'email', 'password']);

        // Création de l'utilisateur...

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

Route correspondante :

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

Route::post('/register', [RegisterController::class, 'store']);
```

## Prochaines étapes

<Card title="Middleware" icon="shield" href="/fr/middleware">
  Revenez sur l'utilisation des middlewares pour filtrer les requêtes.
</Card>


## Related topics

- [Construire une SPA avec Inertia.js](/fr/blog/inertia-introduction.md)
- [Client HTTP](/fr/http-client.md)
- [Cycle de vie d'une requête](/fr/lifecycle.md)
- [Tests HTTP](/fr/http-tests.md)
- [Middleware](/fr/middleware.md)