Heute ist es wichtiger denn je, dass die Daten in deinen Anwendungen gültig und genau sind und alle Systemanforderungen erfüllen. Es geht darum, die Datenkonsistenz zu wahren und Sicherheitsschwachstellen zu vermeiden.
Laravel macht die Datenvalidierung einfach und intuitiv. Es folgt einer Model-View-Controller-Architektur (MVC) und erfordert nur allgemeine Kenntnisse in PHP und objektorientierten Programmierkonzepten (OOP). Außerdem bietet Laravel mehrere Methoden zur Validierung eingehender Daten.
Erkunde einige dieser Ansätze und erfahre, wie du Validierungsregeln auf deinen Datensatz anwenden kannst.
Datenvalidierung in Laravel leicht gemacht
Laravel bietet mehrere gebrauchsfertige Validierungsregeln für die Übermittlung von Daten durch die Nutzer deiner Anwendung über Formulare. Du kannst Eingabefelder als erforderlich markieren, eine Mindest- oder Höchstlänge festlegen und eindeutige (nicht doppelte) Einträge sowie gültige E-Mail-Adressen verlangen. Der Laravel-Validator prüft, ob die Eingabe diese oder andere von dir festgelegte Regeln erfüllt.
Zu diesen Laravel-Validierungsregeln gehören:
required– Die Felddaten dürfen nicht null oder leer sein.array– Die Felddaten müssen ein PHP-Array sein.bail– Die Validierungsregeln wird nicht mehr ausgeführt, wenn sie den ersten Validierungsfehler feststellt.email– Die Felddaten müssen eine gültige E-Mail-Adresse sein.unique– Die Felddaten dürfen keine Duplikate in der Datenbanktabelle haben.
Alle Validierungsmethoden haben Vor- und Nachteile, aber ihre Vielfalt ermöglicht es dir, den besten Ansatz für deine Bedürfnisse zu wählen. Je nachdem, welche Methode du wählst, kann die Validierung in Laravel auf verschiedene Arten erfolgen, mit manuellen oder automatischen Fehlermeldungen.
Die häufigste Methode ist code>validate, die für eingehende HTTP-Anfragen verwendet wird. Diese Methode ist mit den Anfragedaten verkettet und führt die Validierungsregeln aus. Du kannst die Regeln für jedes Feld mit Kommas trennen, wie im folgenden Beispiel zu sehen.
use IlluminateHttpRequest;
public function store (Request $request){
$validated = $request->validate([
'email' => ['required, unique:users, email, bail'],
'name' => ['required'],
]);
}Hier ist email eine Pflichteingabe, d.h. sie darf nicht Null sein. Außerdem muss sie in der Datenbanktabelle users eindeutig sein, damit dieselbe E-Mail-Adresse nicht zweimal eingetragen wird. Die letzte Regel besagt, dass die E-Mail-Adresse auch gültig sein muss. Andernfalls wird der Überprüfungsprozess abgebrochen. Das Feld Name ist erforderlich, hat aber keine weiteren Regeln.
Wenn eine Laravel-Validierungsregel fehlschlägt, wird automatisch eine Antwort erstellt.
Grundlagen der Validierung
Um die Validierungsmethoden besser zu verstehen, schau dir das folgende Beispiel an. Du definierst eine Route für den Endpunkt und erstellst einen Controller, der die Anfragedaten validiert und verarbeitet.
Erstelle zunächst einen einfachen Endpunkt, an dem die Nutzer ihre E-Mails und Passwörter speichern können.
Definiere die Route
Laravel-Routen werden in der Datei routes/web.php für eine Webanwendung oder routes/api.php für eine API definiert. Für dieses Beispiel verwendest du api.php:
use AppHttpControllersUserController;
Route::post('/store', [UserController::class]);Den Controller erstellen
Führe diesen Artisan-Befehl aus, um den Controller zu erstellen:
php artisan make:controller
UserControllerDieser Befehl erstellt eine Datei UserController.php im Verzeichnis app/Http/Controllers.
Definiere nun eine store Methode, um die Daten, die am Endpunkt des Stores eingehen, zu überprüfen, bevor sie gespeichert werden.
In diesem Beispiel werden die folgenden Felder anhand dieser Regeln überprüft:
- Email – Sollte eindeutig sein, eine gültige E-Mail und muss erforderlich sein
- Passwort – Sollte eine Mindestlänge haben, eine Passwortbestätigung und muss erforderlich sein
- Alter – Muss eine Zahl sein und ist ein Pflichtfeld
<?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
}
}Mit der Regel confirmed kannst du ein bestimmtes Feld zweimal abfragen, um zu überprüfen, ob die Daten korrekt sind, z. B. wenn Benutzer ihr Passwort bei der Registrierung erneut eingeben. Diese Regel erfordert ein Feld namens password_confirmation, dessen Daten mit dem Passwortfeld übereinstimmen müssen.
Fehlermeldungen anzeigen
Wenn die Überprüfungskriterien erfüllt sind, wird dein Code normal weiterlaufen. Wenn die Überprüfung fehlschlägt, wird eine IlluminateValidationValidationException Ausnahme ausgelöst und die entsprechende Fehlerantwort zurückgegeben.
Das Beispiel basiert auf einer API, die eine 422 Unprocessable Entity HTTP-Antwort im JSON-Format zurückgibt. Bei Webanwendungen würde es zur vorherigen URL weiterleiten, um die Fehlermeldung anzuzeigen, und die Anfragedaten würden an die Sitzung übertragen.
Du kannst die Variable $errors in deinen Ansichten verwenden, um zurückgegebene Fehler anzuzeigen:
@if ($errors->any())
<div class="alert alert-danger">
<ul>
@foreach ($errors->all() as $error)
<li>{{ $error }}</li>
@endforeach
</ul>
</div>
@endifDu kannst dir auch nur den ersten Fehler anzeigen lassen oder eine Schleife durchlaufen, um alle Fehler zu sehen.
// Fetch all errors
$errors->all()
// Fetch only the first error
$errors->first()Formulare neu ausfüllen
Das Wiederauffüllen von Formularen erspart den Nutzern die erneute Eingabe von Informationen, sodass sie sich auf die Behebung des Fehlers konzentrieren können. In dem Beispiel mit der fehlerhaften E-Mail-Adresse kannst du den Rest des Formulars neu auffüllen, indem du den alten Wert für das Feld name aufrufst.
$name = $request-> old('name')
//Blade helper
<input type="text" name="name" value="{{ old('name') }}">
Diese Regel würde null zurückgeben, wenn es keine vorherige Eingabe gab.
Erweiterte Validierung
Laravel bietet eine weitere Methode zum Schreiben von Validierungen, die sogenannten Formularanfragen. Eine Formularanfrage ist eine benutzerdefinierte Anfrageklasse, die Validierungen organisiert und deinen Controller entschlackt.
Sie verfügen über eine eigene Validierungs- und Autorisierungslogik, die für große Eingabevolumen geeignet ist, und können verwendet werden, um Validierungsregeln zu definieren und Fehlermeldungen anzupassen.
Um eine Formularabfrage zu erstellen, führst du diesen Artisan-Befehl aus:
php artisan make:request StoreUserRequestDieser Befehl erstellt eine Datei StoreUserRequest.php im Verzeichnis app/Http/Requests und enthält zwei Standardmethoden:
rulesgibt die Validierungsregeln für die Anfragedaten zurück.authorizegibt einen booleschen Wert zurück, der angibt, ob der Benutzer die Erlaubnis hat, die angeforderte Aktion durchzuführen.
Konvertiere das vorherige Beispiel, um eine Formularanfrage zu verwenden.
<?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'
];
}
}Um die Fehlermeldungen dieser Regeln anzupassen, kannst du die Methode Messages in der Klasse FormRequest außer Kraft setzen.
/**
* 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'
];
}Hinweis: Der Datenname und die Prüfregel werden durch einen Punkt (.) vor den Nachrichtendaten getrennt.
Benutzerdefinierte Validierung
Um eine benutzerdefinierte Validierung zu erstellen, kannst du anstelle von validate eine Validator -Fassade verwenden. Die Validator-Instanz enthält zwei Argumente: die zu validierenden Daten und eine Reihe von Validierungsregeln. Diese beiden Argumente werden an die Methode ::make der Validator-Fassade übergeben, die eine neue Validator-Instanz erzeugt.
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
}Wenn du eine automatische Direktprüfung hinzufügen möchtest, kannst du die Methode validate auf einer bereits vorhandenen Validatorinstanz ausführen. Wenn die Validierung fehlschlägt, erzeugt eine XHR-Anfrage eine JSON-Antwort mit 422 Unprocessable Entity als Statuscode, oder der Benutzer wird sofort weitergeleitet.
$validator = Validator::make($request->all(),[
'email' => 'required|unique:users|email',
'password' => 'required|min:7|confirmed'
])->validate();Du kannst deine Fehlermeldungen auch anpassen, indem du ein drittes Argument namens messages an Validate::make method übergibst:
$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.',
]);Hinweis: :attribute wird durch den Namen des zu überprüfenden Feldes ersetzt.
Zusammenfassung
Die Datenüberprüfung ist wichtig, damit dein Datensatz sauber, korrekt und vollständig bleibt. Mit der Datenvalidierung kannst du Fehler in deinen Daten ausschließen, die dein Projekt beschädigen oder anderweitig beeinträchtigen könnten. Die Validierung wird immer wichtiger, wenn du in großem Maßstab und mit großen Datenmengen arbeitest.
Laravel ermöglicht zahlreiche flexible Ansätze, um die Integrität und Genauigkeit der Daten zu gewährleisten, die deine Anwendung durchlaufen. Du kannst komplizierte Validierungslogik mit Standard- und anpassbaren Methoden erreichen, wodurch deine Codebasis gut strukturiert und leichter wiederverwendbar ist.
Mit den Anwendungs-Hosting-Diensten von Kinsta kannst du deine Laravel-Anwendungen schneller bereit stellen.
Schreibe einen Kommentar