↓ Skip to main content
  1. Aides-mémoires/
  2. Laravel/

Requests

Tuto Site Web Framework Php Laravel
Table of Contents

Définition
#

Une Request représente une requête HTTP envoyée à l’application Laravel. Elle contient toutes les données transmises par le client :

  • paramètres de l’URL
  • données d’un formulaire
  • corps d’une requête JSON
  • fichiers envoyés
  • en-têtes HTTP (headers)
  • informations sur l’utilisateur authentifié

Laravel fournit deux principaux types de Requests :

  • Request : accès aux données de la requête.
  • Form Request : validation et autorisation centralisées.

Fonctionnement général
#

Flux d’une requête :

Client
   │
   ▼
Route
   │
   ▼
Request
   │
   ├── Lecture des données
   ├── Validation
   ├── Autorisation
   │
   ▼
Controller
   │
   ▼
Model
   │
   ▼
Réponse

Le Request classique
#

Le Request classique est une instance de :

Illuminate\Http\Request

Il est injecté automatiquement dans les méthodes du controller.

Exemple :

use Illuminate\Http\Request;

class UserController extends Controller
{
    public function store(Request $request)
    {
        //
    }
}

Récupérer des données
#

Tous les champs
#

$request->all();

Un champ
#

$request->input('name');

ou

$request->name;

Avec une valeur par défaut
#

$request->input('role', 'user');

Plusieurs champs
#

$request->only([
    'name',
    'email'
]);

Tous sauf certains champs
#

$request->except([
    'password'
]);

Vérifier la présence d’un champ
#

$request->has('email');

Vérifier qu’un champ est rempli
#

$request->filled('email');

Vérifier qu’un champ est absent
#

$request->missing('email');

Les fichiers
#

Vérifier la présence :

$request->hasFile('avatar');

Récupérer le fichier :

$file = $request->file('avatar');

Enregistrer le fichier :

$path = $request->file('avatar')->store('avatars');

Les données JSON
#

Laravel lit automatiquement le JSON.

Exemple :

{
    "name": "Alice",
    "email": "alice@test.com"
}

Accès :

$request->input('name');

Aucune différence avec un formulaire classique.

Les paramètres de route
#

Route :

Route::get('/users/{id}', ...);

Accès :

$id = $request->route('id');

Les informations utilisateur
#

Utilisateur connecté :

$request->user();

Vérifier l’authentification :

$request->user() !== null

Les en-têtes HTTP
#

Lire un header :

$request->header('Authorization');

Tous les headers :

$request->headers->all();

Validation rapide
#

Il est possible de valider directement dans un controller.

$request->validate([
    'name' => 'required',
    'email' => 'required|email'
]);

Cette méthode est adaptée aux petits projets ou à des validations simples.

Les Form Requests
#

Une Form Request est une classe dédiée à :

  • l’autorisation
  • la validation
  • la préparation des données

Elle permet d’alléger les controllers.

Création
#

Commande :

php artisan make:request StoreUserRequest

Le fichier est créé dans :

app/
└── Http/
    └── Requests/
        └── StoreUserRequest.php

Structure
#

class StoreUserRequest extends FormRequest
{
    public function authorize(): bool
    {
        return true;
    }

    public function rules(): array
    {
        return [
            //
        ];
    }
}

authorize()
#

Détermine si l’utilisateur peut effectuer l’action.

Exemple :

public function authorize(): bool
{
    return auth()->check();
}

Ou :

return $this->user()->isAdmin();

Si la méthode retourne :

false

Laravel renvoie automatiquement une réponse 403 Forbidden.

rules()
#

Contient toutes les règles de validation.

Exemple :

public function rules(): array
{
    return [
        'name' => 'required|max:255',
        'email' => 'required|email|unique:users',
        'age' => 'nullable|integer|min:18'
    ];
}

Utilisation dans un controller
#

Au lieu d’utiliser :

Request $request

on injecte :

StoreUserRequest $request

Exemple :

public function store(StoreUserRequest $request)
{
    //
}

La validation est exécutée automatiquement avant l’appel de la méthode.

Les données validées
#

Toutes les données validées :

$request->validated();

Un champ :

$request->validated('email');

Ou :

$request->safe()->only([
    'name',
    'email'
]);

Messages d’erreur personnalisés
#

Méthode :

public function messages(): array
{
    return [
        'name.required' => 'Le nom est obligatoire.',
        'email.email' => 'Adresse email invalide.'
    ];
}

Attributs personnalisés
#

Permet de remplacer les noms techniques des champs.

public function attributes(): array
{
    return [
        'name' => 'nom',
        'email' => 'adresse électronique'
    ];
}

Message obtenu :

Le champ nom est obligatoire.

Préparer les données
#

Méthode :

protected function prepareForValidation(): void
{
    $this->merge([
        'email' => strtolower($this->email)
    ]);
}

Exécutée avant la validation.

Ajouter une validation après les règles
#

public function after(): array
{
    return [
        function ($validator) {
            if ($this->age < 18) {
                $validator->errors()->add(
                    'age',
                    'Vous devez être majeur.'
                );
            }
        }
    ];
}

Pratique pour des validations complexes.

Règles de validation courantes
#

RègleDescription
requiredChamp obligatoire
nullableChamp facultatif
stringChaîne de caractères
integerNombre entier
numericNombre
booleanBooléen
arrayTableau
emailAdresse email valide
urlURL valide
dateDate valide
min:xValeur minimale
max:xValeur maximale
between:x,yValeur comprise entre x et y
size:xTaille exacte
confirmedVérifie le champ _confirmation
unique:tableValeur unique
exists:table,columnValeur existante en base
in:a,b,cValeur parmi une liste
regex:…Expression régulière
fileFichier
imageImage
mimes:jpg,png,pdfExtensions autorisées
max:2048Taille maximale (Ko pour les fichiers)

Validation conditionnelle
#

Exemple :

public function rules(): array
{
    return [
        'company' => [
            'required_if:type,professional'
        ]
    ];
}

Validation avec des objets Rule
#

use Illuminate\Validation\Rule;

public function rules(): array
{
    return [
        'status' => [
            Rule::in([
                'draft',
                'published',
                'archived'
            ])
        ]
    ];
}

Bonnes pratiques
#

  • Utiliser une Form Request par formulaire ou endpoint.
  • Laisser la logique métier dans des Services ou des Models, pas dans la Request.
  • Utiliser validated() plutôt que all() pour éviter de traiter des données non validées.
  • Centraliser les règles de validation dans les Form Requests.
  • Utiliser prepareForValidation() pour normaliser les données avant validation.
  • Réserver authorize() au contrôle d’accès lié à la requête.

Comparatif
#

CaractéristiqueRequestForm Request
Accès aux donnéesOuiOui
ValidationManuelleAutomatique
AutorisationNonOui (authorize())
Messages personnalisésLimitésOui
Préparation des donnéesNonOui
RéutilisableFaiblementOui
Controller allégéNonOui

Les commandes Artisan
#

Créer une Form Request :

php artisan make:request StoreUserRequest

Résumé
#

BesoinSolution recommandée
Lire les données d’une requêteRequest
Valider quelques champs rapidement$request->validate()
Validation complète et réutilisableFormRequest
Contrôler les permissions d’une actionauthorize()
Normaliser les données avant validationprepareForValidation()
Personnaliser les messages d’erreurmessages()
Récupérer uniquement les données validéesvalidated()