Aujourd’hui plus que jamais, il est essentiel que les données contenues dans vos applications soient valides, exactes et conformes à toutes les exigences du système. Cela répond à la nécessité de maintenir la cohérence des données et d’éviter les vulnérabilités en matière de sécurité.

Laravel rend la validation des données facile et intuitive. Il suit une architecture modèle-vue-contrôleur (MVC) et ne nécessite qu’une connaissance générale de PHP et des concepts de programmation orientée objet (POO). De plus, Laravel propose plusieurs méthodes pour valider les données entrantes.

Découvrez certaines de ces approches et comment appliquer des règles de validation à votre ensemble de données.

Validation des données facilitée par Laravel

Laravel propose plusieurs règles de validation prêtes à l’emploi lorsque les utilisateurs de votre application soumettent des données via des formulaires. Vous pouvez rendre les champs de saisie obligatoires, définir une longueur minimale ou maximale, exiger des entrées uniques (sans doublon) et des adresses e-mail valides. Le validateur Laravel vérifie si l’entrée satisfait à ces règles ou à d’autres que vous spécifiez.

Les règles de validation de Laravel sont les suivantes

  • required – Les données du champ ne doivent pas être nulles ou vides.
  • array – Les données du champ doivent être un tableau PHP.
  • bail – La règle de validation cesse de s’exécuter après avoir rencontré son premier échec de validation.
  • email – Les données du champ doivent être une adresse e-mail valide.
  • unique – Les données du champ ne doivent pas être dupliquées dans la table de la base de données.

Toutes les méthodes de validation ont des avantages et des inconvénients, mais leur variété vous permet de choisir la meilleure approche pour vos besoins. En fonction de la méthode choisie, la validation Laravel peut se faire de plusieurs manières, avec des messages d’erreur manuels ou automatiques.

La méthode la plus courante est code>validate, utilisée pour les requêtes HTTP entrantes. Cette méthode est liée aux données de la requête et exécute les règles de validation. Vous pouvez séparer les règles de chaque champ par des virgules, comme dans l’exemple ci-dessous.

use IlluminateHttpRequest;
 
public function store (Request $request){
  $validated = $request->validate([
        'email' => ['required, unique:users, email, bail'],
        'name' => ['required'],
    ]);

}

Ici, email est un champ obligatoire, ce qui signifie qu’il ne peut pas être nul. En outre, il doit être unique dans la table de la base de données users, ce qui garantit que la même adresse électronique n’est pas enregistrée deux fois. La dernière règle stipule que l’adresse e-mail doit également être valide. Dans le cas contraire, le processus de validation s’arrête. Le champ nom est obligatoire mais n’est soumis à aucune autre règle.

Si une règle de validation Laravel échoue, une réponse est générée automatiquement.

Notions de base sur la validation

Pour mieux comprendre les méthodes de validation, prenez l’exemple suivant. Vous allez définir une route pour le point de terminaison et créer un contrôleur pour valider et traiter les données de la requête.

Tout d’abord, créez un point d’accès simple qui permet aux utilisateurs de stocker leurs adresses e-mail et leurs mots de passe.

Définir la route

Les routes Laravel sont définies dans le fichier routes/web.php pour une application web ou routes/api.php pour une API. Pour cet exemple, utilisez api.php:

use AppHttpControllersUserController;
 
Route::post('/store', [UserController::class]);

Créer le contrôleur

Exécutez cette commande Artisan pour créer le contrôleur :

php artisan make:controller

UserController

Cette commande crée un fichier UserController.php dans le répertoire app/Http/Controllers.

Maintenant, définissez une méthode store pour valider les données entrant dans le point de terminaison avant de les stocker.

Cet exemple validera les champs suivants en utilisant ces règles :

  • email – Doit être unique, un e-mail valide, et doit être obligatoire
  • password: doit avoir une longueur minimale, une confirmation de mot de passe et doit être obligatoire
  • age – Doit être un nombre et doit être obligatoire
<?php

namespace AppHttpControllers;
use IlluminateHttpRequest;
class UserController extends Controller
{
    /**
     * Store new user details.
     *
     */
    public function store(Request $request){
        $validated = $request->validate([
            'email' => 'required|unique:users|email',
            'age' => 'required|numeric',
            'password' => 'required|min:7|confirmed'
        ]);
        // After user data is validated, logic to store the data
    }

}

La règle confirmed vous permet d’exiger deux fois un champ particulier pour vérifier que les données sont exactes, par exemple lorsque les utilisateurs saisissent à nouveau leur mot de passe lors de l’enregistrement. Cette règle nécessite un champ appelé password_confirmation, dont les données doivent correspondre au champ password.

Affichage des messages d’erreur

Si les critères de validation sont respectés, votre code continuera à s’exécuter normalement. Si la validation échoue, une exception IlluminateValidationValidationException est levée et la réponse d’erreur appropriée est renvoyée.

L’exemple est basé sur une API qui renvoie une réponse HTTP 422 Unprocessable Entity au format JSON. Pour les applications web, il redirigerait vers l’URL précédente pour afficher le message d’erreur, et les données de la demande seraient transmises à la session.

Vous pouvez utiliser la variable $errors dans vos vues pour afficher les erreurs renvoyées :

@if ($errors->any())
    <div class="alert alert-danger">
        <ul>
            @foreach ($errors->all() as $error)
                <li>{{ $error }}</li>
            @endforeach
        </ul>
    </div>
@endif

Vous pouvez également choisir de n’afficher que la première erreur ou de les afficher toutes en boucle.

// Fetch all errors
$errors->all()

// Fetch only the first error
$errors->first()

Remplir les formulaires

Le repeuplement des formulaires évite aux utilisateurs de ressaisir les informations et leur permet de se concentrer sur la correction de l’erreur. Dans l’exemple de l’adresse e-mail défaillante, vous pouvez remplir le reste du formulaire en appelant l’ancienne valeur du champ name.

$name = $request-> old('name')

//Blade helper
<input type="text" name="name" value="{{ old('name') }}">

Cette règle renvoie null s’il n’y a pas eu de saisie antérieure.

Validation avancée

Laravel propose une autre méthode pour écrire des validations appelées requêtes de formulaire. Une requête de formulaire est une classe de requête personnalisée qui organise les validations et désencombre votre contrôleur.

Elles possèdent leur propre logique de validation et d’autorisation, adaptée aux grands volumes d’entrée, et peuvent être utilisées pour définir des règles de validation et personnaliser les messages d’erreur.

Pour créer une demande de formulaire, exécutez cette commande Artisan :

php artisan make:request StoreUserRequest

Cette commande crée un fichier StoreUserRequest.php dans le répertoire app/Http/Requests et contient deux méthodes par défaut :

  • rules renvoie les règles de validation des données de la demande.
  • authorize renvoie un booléen indiquant si l’utilisateur a le droit d’effectuer l’action demandée.

Convertissez l’exemple précédent pour utiliser une demande de formulaire.

<?php

namespace AppHttpRequests;
use IlluminateFoundationHttpFormRequest;
class StoreUserRequest extends FormRequest
{
    /**
     * Determine if the user is authorized to make this request.
     *
     * @return bool
     */
    public function authorize()
    {
        // Add logic to check if the user is authorized to submit this data.
        return true;
    }
    /**
     * Get the validation rules that apply to the request.
     *
     * @return array<string, mixed>
     */
    public function rules()
    {
        return [
            'email' => 'required|unique:users|email',
            'age' => 'required|numeric',
            'password' => 'required|min:7|confirmed'
        ];
    }

}

Pour personnaliser les messages d’erreur de ces règles, vous pouvez remplacer la méthode messages de la classe FormRequest.

/**

     * Get the error messages for the defined validation rules.
     *
     * @return array
     */
    public function messages()
    {
        return [
            'email.required' => 'An email address is required',
            'email.email' => 'The email address must be valid',
            'password.confirmed'=>'Re-type your password as 
password_confirmation, passwords does not match'
        ];

    }

Remarque : le nom de la donnée et la règle de validation sont séparés par un point (.) avant les données du message.

Validation personnalisée

Pour créer une validation personnalisée, vous pouvez utiliser une façade Validator au lieu de validate. L’instance de validateur contient deux arguments : les données à valider et un tableau de règles de validation. Ces deux arguments sont transmis à la méthode ::make de la façade de validateur, qui génère une nouvelle instance de validateur.

use IlluminateHttpRequest; 

public function store (Request $request){
        $validator = Validator::make($request->all(),[
            'email' => 'required|unique:users|email',
            'age' => 'required|numeric',
            'password' => 'required|min:7|confirmed'
        ]);
        if ($validator->fails()) {
            // Return errors or redirect back with errors
            return $validator->errors();
        }
 
        // Retrieve the validated input...
        $validated = $validator->validated();
        // Continue logic to store the data

    }

Si vous souhaitez ajouter un direct automatique, vous pouvez exécuter la méthode validate sur une instance de validateur préexistante. Si la validation échoue, une requête XHR produit une réponse JSON avec 422 Unprocessable Entity comme code de statut, ou l’utilisateur sera redirigé immédiatement.

$validator = Validator::make($request->all(),[
'email' => 'required|unique:users|email',
'password' => 'required|min:7|confirmed'
])->validate();

Vous pouvez également personnaliser vos messages d’erreur en passant un troisième argument appelé messages à Validate::make method:

$validator = Validator::make($request->all(),[
            'email' => 'required|unique:users|email',
            'age' => 'required|numeric',
            'password' => 'required|min:7|confirmed'
        ], $messages = [
            'required' => 'The :attribute field is required.',
]);

Note : Le :attribute est remplacé par le nom du champ en cours de validation.

Résumé

La validation des données est essentielle pour que votre ensemble de données reste propre, correct et complet. La validation des données vous permet d’éliminer les erreurs dans vos données qui pourraient potentiellement corrompre ou avoir un impact sur votre projet. La validation devient de plus en plus importante lorsque vous travaillez à grande échelle et avec de grandes quantités de données.

Laravel propose de nombreuses approches flexibles pour garantir l’intégrité et l’exactitude des données qui passent par votre application. Vous pouvez réaliser des logiques de validation complexes avec des méthodes par défaut et personnalisables, ce qui rend votre base de code bien structurée et plus facilement réutilisable.

Livrez vos applications Laravel plus rapidement grâce aux services d’hébergement d’applications de Kinsta.

Jeremy Holcombe Kinsta

Rédacteur en chef du contenu et du marketing chez Kinsta, développeur web WordPress et rédacteur de contenu. En dehors de WordPress, j'aime la plage, le golf et le cinéma. J'ai aussi des problèmes avec les personnes de grande taille ;).