Validatie

Wat is validatie

Validatie is het controleren of de gegevens die een gebruiker verstuurt voldoen aan het verwachte formaat en de gestelde voorwaarden. Laravel biedt een eenvoudige maar krachtige validatiefunctionaliteit via de validate methode van het request-object of via speciale form request-klassen.

Validatie in de controller

`$request->validate()` gebruiken

De eenvoudigste manier om te valideren is door $request->validate() aan te roepen in een controllermethode. Als de validatie mislukt, stuurt Laravel de gebruiker automatisch terug naar het vorige scherm en slaat het de foutinformatie op in de sessie. Definieer de routes.

use App\Http\Controllers\PostController;

Route::get('/post/create', [PostController::class, 'create']);
Route::post('/post', [PostController::class, 'store']);

Maak de controller.

<?php

namespace App\Http\Controllers;

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

class PostController extends Controller
{
    public function create(): View
    {
        return view('post.create');
    }

    public function store(Request $request): RedirectResponse
    {
        $validated = $request->validate([
            'title' => 'required|string|max:255',
            'body'  => 'required|string',
            'email' => 'required|email',
        ]);

        // Sla de post op met de gevalideerde data...

        return redirect('/posts');
    }
}

Aan de validate methode geef je een array door met veldnamen als sleutels en regels als waarden. Regels kun je scheiden met een pipe | of opgeven als array.

// Gescheiden met pipes
'title' => 'required|string|max:255',

// Als array
'title' => ['required', 'string', 'max:255'],

Belangrijke validatieregels

Regel	Beschrijving
`required`	De waarde moet aanwezig zijn en mag niet leeg zijn
`string`	De waarde moet een string zijn
`email`	De waarde moet een geldig e-mailadresformaat hebben
`min:waarde`	De stringlengte of het getal moet minimaal de opgegeven waarde zijn
`max:waarde`	De stringlengte of het getal mag maximaal de opgegeven waarde zijn
`unique:tabel`	De waarde moet uniek zijn in de opgegeven tabel
`nullable`	De waarde mag ook `null` zijn
`integer`	De waarde moet een geheel getal zijn
`boolean`	De waarde moet een boolean zijn (`true`/`false`, `1`/`0`, enz.)
`date`	De waarde moet een geldig datumformaat hebben
`confirmed`	De waarde moet overeenkomen met het veld `veldnaam_confirmation`
`array_keys:sleutel1,sleutel2,...`	De sleutels van de array mogen alleen uit de opgegeven sleutels bestaan

Uitgebreide validatie van e-mailadressen

Aan de email regel kun je parameters toevoegen die de validatiemethode bepalen.

'email' => ['email:rfc,dns'],

rfc valideert dat het formaat voldoet aan de RFC, en dns valideert dat het domein van het e-mailadres een geldig MX-record heeft. dns voert daadwerkelijk een DNS lookup uit, maar bepaalt niet of de individuele mailbox bestaat. Je kunt dezelfde validatie ook schrijven met de fluent Rule builder.

use Illuminate\Validation\Rule;

$request->validate([
    'email' => [
        'required',
        Rule::email()
            ->rfcCompliant(strict: false)
            ->validateMxRecord()
            ->preventSpoofing(),
    ],
]);

De dns validator voert daadwerkelijk een DNS lookup uit en controleert of het domein van het e-mailadres een geldig MX-record heeft. Hij bepaalt echter niet of de individuele mailbox bestaat. Om in tests niet afhankelijk te zijn van live DNS lookups, kun je de dns lookup faken met Validator::fakeDnsLookups. Andere opgegeven validaties, zoals rfc, worden gewoon uitgevoerd.

use Illuminate\Support\Facades\Validator;

Validator::fakeDnsLookups();

Zo kun je regels als de volgende testen terwijl je de bestaande validatieregels blijft gebruiken.

'email' => ['required', 'email:rfc,dns'],

Voor de validatie van dns en spoof is de PHP-extensie intl vereist.

Arraysleutels valideren

De array_keys regel valideert dat de waarde een PHP-array is en dat alle sleutels voorkomen in de opgegeven lijst. Geef minimaal één sleutel op.

'user' => ['array_keys:name,username'],

Als je rule-objecten gebruikt, kun je dit opgeven met de Rule::arrayKeys methode.

use Illuminate\Validation\Rule;

'user' => [Rule::arrayKeys('name', 'username')],

Alle beschikbare validatieregels vind je in de officiële documentatie.

Gevalideerde data gebruiken

De returnwaarde van de validate methode is een array die alleen de data bevat die de validatie heeft doorstaan. Je kunt deze veilig gebruiken als betrouwbare data.

$validated = $request->validate([
    'title' => 'required|string|max:255',
    'body'  => 'required|string',
]);

// $validated heeft de vorm ['title' => '...', 'body' => '...']
Post::create($validated);

Fouten weergeven in Blade-templates

Als de validatie mislukt, maakt Laravel de variabele $errors automatisch beschikbaar in alle views. De ShareErrorsFromSession middleware, die deel uitmaakt van de web middlewaregroep, zorgt hiervoor.

Alle fouten in een lijst weergeven

@if ($errors->any())
    <ul>
        @foreach ($errors->all() as $error)
            <li>{{ $error }}</li>
        @endforeach
    </ul>
@endif

Fouten per veld weergeven

Met de @error directive kun je fouten voor een specifiek veld inline weergeven.

<label for="title">Titel</label>

<input
    id="title"
    type="text"
    name="title"
    value="{{ old('title') }}"
    class="@error('title') is-invalid @enderror"
/>

@error('title')
    <div class="error-message">{{ $message }}</div>
@enderror

Met old('veldnaam') kun je de door de gebruiker ingevoerde waarde opnieuw in het formulier tonen nadat de validatie is mislukt.

Form requests

Wat is een form request

Wordt je validatielogica complexer, dan is het effectief om deze onder te brengen in een “form request”-klasse. Een form request is een aangepaste request-klasse die validatie- en autorisatielogica bundelt in één klasse.

Een form request maken

Genereer een form request-klasse met het make:request Artisan-commando.

php artisan make:request StorePostRequest

Het bestand app/Http/Requests/StorePostRequest.php wordt gegenereerd.

<?php

namespace App\Http\Requests;

use Illuminate\Foundation\Http\FormRequest;

class StorePostRequest extends FormRequest
{
    /**
     * Bepaal of de gebruiker gemachtigd is dit request uit te voeren
     */
    public function authorize(): bool
    {
        return true;
    }

    /**
     * Geef de validatieregels terug die op dit request van toepassing zijn
     *
     * @return array<string, \Illuminate\Contracts\Validation\ValidationRule|array<mixed>|string>
     */
    public function rules(): array
    {
        return [
            'title' => 'required|string|max:255',
            'body'  => 'required|string',
            'email' => 'required|email|unique:posts',
        ];
    }
}

De `rules()` methode

Geeft de validatieregels terug als array. Dit is hetzelfde formaat als de array die je doorgeeft aan de validate methode in de controller.

De `authorize()` methode

Bepaalt of de gebruiker gemachtigd is om dit request uit te voeren. Geef je true terug, dan is de autorisatie in orde; geef je false terug, dan wordt automatisch een 403-response teruggegeven. Wil je alleen geauthenticeerde gebruikers toestaan, dan kun je dat controleren met auth()->check(). In een tutorial volstaat het om true terug te geven.

Als de authorize methode false teruggeeft, wordt de controllermethode niet uitgevoerd en wordt er een 403 Forbidden-response teruggegeven.

Injecteren in de controller

Een form request gebruik je door hem simpelweg als type hint op te geven in de controllermethode. De validatie wordt uitgevoerd voordat de controller wordt aangeroepen, dus je hoeft geen validatiecode in de methode te schrijven.

use App\Http\Requests\StorePostRequest;

class PostController extends Controller
{
    public function store(StorePostRequest $request): RedirectResponse
    {
        // Op dit punt is de data al gevalideerd

        $validated = $request->validated();

        Post::create($validated);

        return redirect('/posts');
    }
}

Met $request->validated() haal je alleen de gevalideerde data op.

Complexiteit en lengte van wachtwoorden instellen

Met het Password rule-object kun je de complexiteit en de minimale en maximale lengte van wachtwoorden in één keer opgeven.

use Illuminate\Validation\Rules\Password;

Password::min(16)
    ->max(256)
    ->letters()
    ->mixedCase()
    ->numbers()
    ->symbols();

min() bepaalt het minimale aantal tekens, max() het maximale. Door max() op te geven kun je complexe wachtwoorden toestaan en tegelijk expliciet een bovengrens stellen voor opslag of integratie met externe diensten.

Praktijkvoorbeeld: een postformulier maken en opslaan

Dit is de complete flow van het weergeven van het formulier tot het versturen, valideren en opslaan.

Routes definiëren

use App\Http\Controllers\PostController;

Route::get('/posts/create', [PostController::class, 'create']);
Route::post('/posts', [PostController::class, 'store']);

Een form request maken

php artisan make:request StorePostRequest

public function rules(): array
{
    return [
        'title' => 'required|string|max:255',
        'body'  => 'required|string',
    ];
}

public function authorize(): bool
{
    return true;
}

De controller implementeren

use App\Http\Requests\StorePostRequest;
use App\Models\Post;

class PostController extends Controller
{
    public function create(): View
    {
        return view('posts.create');
    }

    public function store(StorePostRequest $request): RedirectResponse
    {
        Post::create($request->validated());

        return redirect('/posts');
    }
}

Een Blade-template maken

{{-- resources/views/posts/create.blade.php --}}

<h1>Nieuwe post</h1>

@if ($errors->any())
    <ul>
        @foreach ($errors->all() as $error)
            <li>{{ $error }}</li>
        @endforeach
    </ul>
@endif

<form method="POST" action="/posts">
    @csrf

    <div>
        <label for="title">Titel</label>
        <input
            id="title"
            type="text"
            name="title"
            value="{{ old('title') }}"
        />
        @error('title')
            <span>{{ $message }}</span>
        @enderror
    </div>

    <div>
        <label for="body">Inhoud</label>
        <textarea id="body" name="body">{{ old('body') }}</textarea>
        @error('body')
            <span>{{ $message }}</span>
        @enderror
    </div>

    <button type="submit">Posten</button>
</form>

Neem in Blade-formulieren altijd de @csrf directive op. Zonder CSRF-token geeft Laravel een 419-fout terug.

Volgende stap

HTTP-requests

Blik terug op hoe je data ophaalt met het request-object.

Aan de slag

Basis

Request-verwerking

Database

Authenticatie

Helpers en externe communicatie

Testen en deployment

AI-ontwikkelondersteuning

Wat is validatie

Validatie in de controller

`$request->validate()` gebruiken

Belangrijke validatieregels

Uitgebreide validatie van e-mailadressen

Arraysleutels valideren

Gevalideerde data gebruiken

Fouten weergeven in Blade-templates

Alle fouten in een lijst weergeven

Fouten per veld weergeven

Form requests

Wat is een form request

Een form request maken

De `rules()` methode

De `authorize()` methode

Injecteren in de controller

Complexiteit en lengte van wachtwoorden instellen

Praktijkvoorbeeld: een postformulier maken en opslaan

Volgende stap

HTTP-requests

​Wat is validatie

​Validatie in de controller

​$request->validate() gebruiken

​Belangrijke validatieregels

​Uitgebreide validatie van e-mailadressen

​Arraysleutels valideren

​Gevalideerde data gebruiken

​Fouten weergeven in Blade-templates

​Alle fouten in een lijst weergeven

​Fouten per veld weergeven

​Form requests

​Wat is een form request

​Een form request maken

​De rules() methode

​De authorize() methode

​Injecteren in de controller

​Complexiteit en lengte van wachtwoorden instellen

​Praktijkvoorbeeld: een postformulier maken en opslaan

​Volgende stap

HTTP-requests

Wat is validatie

Validatie in de controller

`$request->validate()` gebruiken

Belangrijke validatieregels

Uitgebreide validatie van e-mailadressen

Arraysleutels valideren

Gevalideerde data gebruiken

Fouten weergeven in Blade-templates

Alle fouten in een lijst weergeven

Fouten per veld weergeven

Form requests

Wat is een form request

Een form request maken

De `rules()` methode

De `authorize()` methode

Injecteren in de controller

Complexiteit en lengte van wachtwoorden instellen

Praktijkvoorbeeld: een postformulier maken en opslaan

Volgende stap