Nu är det viktigare än någonsin att data i dina applikationer är giltiga, korrekta och uppfyller alla systemkrav. Det handlar exempelvis om behovet av att upprätthålla data-konsistens och undvika säkerhetsbrister.

Laravel gör datavalidering enkelt och intuitivt. Den följer en MVC-arkitektur (model view controller) och kräver endast allmänna kunskaper i PHP och koncept för objektorienterad programmering (OOP). Dessutom erbjuder Laravel flera metoder för validering av inkommande data.

Utforska några av dessa metoder och hur du tillämpar valideringsregler på din datamängd.

Enkel datavalidering i Laravel

Laravel tillhandahåller flera färdiga validerings-regler för när användarna i din applikation skickar in data via formulär. Du kan markera inmatningsfält som obligatoriska samt ange en minsta eller största längd. Det går dessutom att kräva unika (ej dubbla) poster och giltiga e-postadresser. Laravel-valideraren kontrollerar sedan om inmatningen uppfyller dessa regler eller andra regler som du anger.

Dessa Laravel-valideringsregler omfattar följande:

  • required – Fältdata får inte vara noll eller tomt.
  • array – Den måste vara en PHP-array.
  • bail – Valideringsregeln slutar att köras när den stöter på sitt första valideringsfel.
  • email – Fältdata måste vara en giltig e-postadress.
  • unique – Den får inte ha dubbletter i databastabellen.

Alla validerings-metoder har för- och nackdelar, men deras mångfald gör att du kan välja det bästa tillvägagångssättet för dina behov. Beroende på den valda metoden kan Laravel-validering ske på flera olika sätt, exempelvis med manuella eller automatiska felmeddelanden.

Den vanligaste metoden är code>validate, som används för inkommande HTTP-förfrågningar. Den här metoden är kedjad till förfrågningsdata och utför valideringsreglerna. Du kan dessutom separera reglerna för varje fält med kommatecken, som i exemplet nedan.

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

}

Här är email ett obligatoriskt fält, vilket innebär att det inte kan vara noll. Dessutom måste det vara unikt i databastabellen users så att samma e-postadress inte registreras två gånger. Enligt den sista regeln måste även e-postadressen vara giltig. I annat fall upphör valideringen. Fältet name är obligatoriskt men har inga andra regler.

Om någon valideringsregel i Laravel misslyckas genereras ett svar automatiskt.

Grunderna för validering

För att bättre förstå valideringsmetoderna kan du titta på följande exempel. Du definierar en route för slutpunkten och skapar en kontrollant för att validera och bearbeta förfrågnings-data.

Skapa först en enkel slutpunkt där användare kan lagra sina e-postmeddelanden och lösenord.

Definiera routen

Laravel-router definieras exempelvis i filen routes/web.php för en webbapplikation eller routes/api.php för ett API. I det här exemplet använder du api.php:

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

Skapa styrenheten

Kör det här Artisan-kommandot för att skapa kontrollanten:

php artisan make:controller

UserController

Det här kommandot skapar en fil UserController.php i katalogen app/Http/Controllers.

Definiera sedan en store-metod för att validera data som kommer in i slutpunkten för lagring innan de lagras.

I det här exemplet valideras följande fält med hjälp av dessa regler:

  • email – Ska vara en unik, giltig e-postadress och måste vara obligatorisk
  • password – Bör ha en minsta längd, bekräftelse av lösenordet och måste vara obligatoriskt
  • age – Måste vara ett nummer och måste vara ett krav
<?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
    }

}

Med regeln confirmed kan du kräva ett visst fält två gånger för att kontrollera att uppgifterna är korrekta. Detta görs exempelvis när användare anger sitt lösenord på nytt vid registrering. Den här regeln kräver ett fält som heter password_confirmation, vars data sedan måste matcha lösenordsfältet.

Visa felmeddelanden

Om valideringskriterierna uppfylls fortsätter koden att köras normalt. Ifall valideringen misslyckas skapas istället undantaget IlluminateValidationValidationException och lämpligt felsvar returneras.

Exemplet bygger på ett API som returnerar ett 422 Unprocessable Entity HTTP-svar i JSON-format. För webbapplikationer skulle det omdirigera till den tidigare webbadressen för att visa felmeddelandet.  Förfrågningsuppgifterna skulle därefter blixtsnabbt överföras till sessionen.

Du kan exempelvis använda variabeln $errors i dina vyer för att visa returnerade fel:

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

Du kan dessutom välja att bara visa det första felet eller att gå i en loop för att visa dem alla.

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

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

Återuppdatera formulär

Genom att fylla igen formulär slipper användarna skriva om information. Som ett resultat kan de fokusera på att åtgärda felet. I exemplet med en felande e-postadress kan du fylla på resten av formuläret genom att kalla det gamla värdet för fältet name.

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

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

Denna regel skulle därefter returnera null om det inte fanns någon tidigare inmatning.

Avancerad validering

Laravel tillhandahåller en annan metod för att skriva valideringar som kallas formulärförfrågningar. En formulärförfrågan är en anpassad förfrågningsklass som organiserar valideringar och gör din kontrollant mer lätthanterlig.

De har exempelvis sin egen validerings- och auktoriserings-logik som är lämplig för stora inmatnings-volymer och som kan användas för att definiera validerings-regler och anpassa felmeddelanden.

Om du vill skapa en formulär-begäran kör du det här Artisan-kommandot:

php artisan make:request StoreUserRequest

Det här kommandot skapar sedan filen StoreUserRequest.php i katalogen app/Http/Requests och inkluderar två standardmetoder:

  • rules returnerar valideringsregler för begärsdata.
  • authorize returnerar en boolean som anger om användaren har behörighet att utföra den begärda åtgärden.

Konvertera det föregående exemplet till att använda en formulärförfrågan.

<?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'
        ];
    }

}

Om du vill anpassa felmeddelandena för dessa regler kan du exempelvis åsidosätta metoden messages i klassen 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'
        ];

    }

Observera: Datanamnet och valideringsregeln separeras med en punkt (.) före meddelandeuppgifterna.

Anpassad validering

För att skapa en anpassad validering kan du exempelvis använda en Validator-instans i stället för validate. Validerings-instansen inkluderar två argument: de data som ska valideras och en matris med valideringsregler. Dessa två argument skickas till ::make-metoden på validerings-instansen, vilket genererar en ny validerings-instans.

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

    }

Om du vill lägga till en automatisk direkt kan du utföra metoden validate på en redan befintlig validerings-instans. Vid de tillfällen när valideringen misslyckas så producerar en XHR-förfrågan ett JSON-svar med 422 Unprocessable Entity som statuskod, annars omdirigeras användaren omedelbart.

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

Du kan dessutom anpassa dina felmeddelanden genom att skicka ett tredje argument kallat messages till 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.',
]);

Observera: :attribute ersätts med namnet på det fält som ska valideras.

Sammanfattning

Det är viktigt att validera data för att hålla data-setet rent, korrekt och komplett. Med hjälp av data-validering kan du exempelvis eliminera fel i dina data. De kan annars förstöra eller på annat sätt påverka ditt projekt. Validering blir allt viktigare när man arbetar i stor skala och med stora datamängder.

Laravel möjliggör många flexibla tillvägagångssätt för att säkerställa integriteten och riktigheten hos de data som passerar genom din applikation. Du kan uppnå komplicerad valideringslogik med standardmetoder och anpassningsbara metoder. Som ett resultat blir din kodbas välstrukturerad och lättare återanvändbar.

Skicka dina Laravel-appar snabbare med Kinsta’s tjänster för Applikationshosting.

Jeremy Holcombe Kinsta

Innehålls- och marknadsföringsredaktör på Kinsta, WordPress webbutvecklare och innehållsskribent. Utöver WordPress tycker jag om stranden, golf och filmer. Jag har även problem med långa människor ;).