Laravel
Validierung

Parameter

Basisbeispiel

Sie können Anfragedaten mit der validate Methode validate (verfügbar im Basis-Controller, bereitgestellt von der Eigenschaft ValidatesRequests ).

Wenn die Regeln erfüllt sind, wird Ihr Code normal ausgeführt. Schlägt die Validierung fehl, wird automatisch eine Fehlerantwort mit den Validierungsfehlern zurückgesendet:

• Bei typischen HTML-Formularanfragen wird der Benutzer zur vorherigen Seite weitergeleitet, wobei das Formular die übergebenen Werte enthält
• Für Anforderungen, die eine JSON-Antwort erwarten, wird eine HTTP-Antwort mit Code 422 generiert

In Ihrem UserController speichern Sie beispielsweise einen neuen Benutzer in der store Methode, für den vor dem Speichern eine Überprüfung erforderlich ist.

/**
 * @param  Request  $request
 * @return Response
 */
public function store(Request $request) {
    $this->validate($request, [
        'name' => 'required',
        'email' => 'email|unique:users|max:255'
    ],
    // second array of validation messages can be passed here
    [
        'name.required' => 'Please provide a valid name!',
        'email.required' => 'Please provide a valid email!',
    ]);

    // The validation passed
}

In dem obigen Beispiel bestätigen wir , dass der name Feld mit nicht leeren Wert vorhanden ist . Zweitens prüfen wir, ob das email Feld ein gültiges E-Mail-Format hat, in der Datenbanktabelle "Benutzer" eindeutig ist und eine maximale Länge von 255 Zeichen hat.

Die | Das Zeichen (Pipe) kombiniert verschiedene Validierungsregeln für ein Feld.

Manchmal möchten Sie vielleicht nach dem ersten Validierungsfehler die Ausführung von Validierungsregeln für ein Attribut beenden. bail dem Attribut die bail Regel zu:

$this->validate($request, [
    'name' => 'bail|required',
    'email' => 'email|unique:users|max:255'
]);

Die vollständige Liste der verfügbaren Validierungsregeln finden Sie im Abschnitt Parameter unten .

Array-Überprüfung

Die Überprüfung der Eingabefelder für Array-Formulare ist sehr einfach.

Angenommen, Sie müssen jeden Namen, jede E-Mail-Adresse und den Namen jedes Vaters in einem bestimmten Array überprüfen. Sie könnten folgendes tun:

$validator = \Validator::make($request->all(), [
    'name.*'       => 'required', 
    'email.*'      => 'email|unique:users',
    'fatherName.*' => 'required'
]);

if ($validator->fails()) {
    return back()->withInput()->withErrors($validator->errors());
}

Laravel zeigt Standardmeldungen zur Überprüfung an. Wenn Sie jedoch benutzerdefinierte Meldungen für Array-basierte Felder wünschen, können Sie den folgenden Code hinzufügen:

[
    'name.*' => [
        'required' => 'Name field is required',
    ],
    'email.*' => [
        'unique'   => 'Unique Email is required',
    ],
    'fatherName.*' => [
        'required' => 'Father Name required',
    ]
]

Ihr endgültiger Code wird folgendermaßen aussehen:

$validator = \Validator::make($request->all(), [
    'name.*'       => 'required', 
    'email.*'      => 'email|unique:users',
    'fatherName.*' => 'required',
], [
    'name.*'       => 'Name Required',
    'email.*'      => 'Unique Email is required',
    'fatherName.*' => 'Father Name required',
]);

if ($validator->fails()) {
    return back()->withInput()->withErrors($validator->errors());
}

Andere Validierungsansätze

1) Formularanforderungsbestätigung

Sie können eine "Formularanforderung" erstellen, die die Berechtigungslogik, Validierungsregeln und Fehlernachrichten für eine bestimmte Anforderung in Ihrer Anwendung enthalten kann.

Der CLI-Befehl make:request Artisan generiert die Klasse und platziert sie im Verzeichnis app/Http/Requests :

php artisan make:request StoreBlogPostRequest

Die authorize kann mit der Berechtigungslogik für diese Anforderung überschrieben werden:

public function authorize()
{        
    return $this->user()->can('post');
}

Die rules Methode kann mit den spezifischen Regeln für diese Anforderung überschrieben werden:

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

Die messages kann mit den spezifischen Nachrichten für diese Anforderung überschrieben werden:

public function messages()
{
    return [
        'title.required' => 'A title is required',
        'title.unique' => 'There is another post with the same title',
        'title.max' => 'The title may not exceed :max characters',
        'body.required' => 'A message is required',
    ];
}

Um die Anfrage zu validieren, geben Sie einfach die spezifische Request-Klasse der entsprechenden Controller-Methode an. Wenn die Überprüfung fehlschlägt, wird eine Fehlerantwort zurückgesendet.

public function store(StoreBlogPostRequest $request)
{
    // validation passed
}

2) Validatoren manuell erstellen

Für mehr Flexibilität möchten Sie möglicherweise einen Validator manuell erstellen und die fehlgeschlagene Validierung direkt abwickeln:

<?php    
namespace App\Http\Controllers;

use Validator;
use Illuminate\Http\Request;
use App\Http\Controllers\Controller;

class PostController extends Controller
{
    public function store(Request $request)
    {
        $validator = Validator::make($request->all(), [
            'title' => 'required|unique:posts|max:255',
            'body' => 'required',
        ]);

        if ($validator->fails()) {
            return redirect('post/create')
                    ->withErrors($validator)
                    ->withInput();
        }

        // Store the blog post...
    }
}

2) Regeln fließend erstellen

Gelegentlich müssen Sie gelegentlich eindeutige Regeln erstellen. Das Arbeiten mit der boot() -Methode innerhalb eines Service Providers ist möglicherweise zu hoch. Ab Laravel 5.4 können Sie mithilfe der Rule Klasse neue Regeln problemlos erstellen.

Als Beispiel arbeiten wir mit der UserRequest wenn Sie einen Benutzer einfügen oder aktualisieren möchten. Im Moment möchten wir einen Namen benötigen und die E-Mail-Adresse muss eindeutig sein. Das Problem bei der Verwendung der unique Regel besteht darin, dass beim Bearbeiten eines Benutzers dieselbe E-Mail-Adresse beibehalten werden kann. Daher müssen Sie den aktuellen Benutzer von der Regel ausschließen. Das folgende Beispiel zeigt, wie Sie dies mit der neuen Rule problemlos tun können.

<?php
namespace App\Http\Requests;
use Illuminate\Foundation\Http\FormRequest;
use Illuminate\Http\Request;
use Illuminate\Validation\Rule;

class UserRequest extends FormRequest
{
    /**
     * Determine if the user is authorized to make this request.
     *
     * @return bool
     */
    public function authorize()
    {
        return true;
    }

    /**
     * Get the validation rules that apply to the request.
     *
     * @return array
     */
    public function rules(Request $request)
    {
        $id = $request->route()->getParameter('user');

        return [
            'name'           =>  'required',
            
            // Notice the value is an array and not a string like usual
            'email'         =>  [
                'required',
                Rule::unique('users')->ignore($id)
            ]
        ];
    }
}

Einzelformular-Anforderungsklasse für POST, PUT, PATCH

Nach dem Beispiel 'Form Request Validation' kann dieselbe Request-Klasse für POST , PUT , PATCH sodass Sie keine weitere Klasse erstellen müssen, die dieselben / ähnliche Validierungen verwendet. Dies ist praktisch, wenn Sie in Ihrer Tabelle eindeutige Attribute haben.

/**
 * Get the validation rules that apply to the request.
 *
 * @return array
 */
public function rules() {
    switch($this->method()) {
        case 'GET':
        case 'DELETE':
            return [];
        case 'POST':
            return [
                'name'     => 'required|max:75|unique',
                'category' => 'required',
                'price'    => 'required|between:0,1000',
            ];
        case 'PUT':
        case 'PATCH':
            return [
                'name'     => 'required|max:75|unique:product,name,' . $this->product,
                'category' => 'required',
                'price'    => 'required|between:0,1000',
            ];
        default:break;
    }
}

In der switch-Anweisung wird der Methodentyp der Anforderung ( GET , DELETE , POST , PUT , PATCH ) von oben betrachtet.

Abhängig von der Methode wird das definierte Array von Regeln zurückgegeben. Wenn Sie ein Feld haben , die einzigartig, wie das ist name im Beispiel Feld, müssen Sie eine bestimmte ID für die Validierung festlegen zu ignorieren.

'field_name' => 'unique:table_name,column_name,' . $idToIgnore`

Wenn Sie einen Primärschlüssel mit einer anderen Bezeichnung als id , geben Sie die Primärschlüsselspalte als vierten Parameter an.

'field_name' => 'unique:table_name,column_name,' . $idToIgnore . ',primary_key_column'

In diesem Beispiel verwenden wir PUT und übergeben den Wert der Produkt-ID an die Route ( admin/products/{product} ). $this->product entspricht also der zu ignorierenden id .

Jetzt müssen Ihre PUT|PATCH und POST Überprüfungsregeln nicht die gleichen sein. Definieren Sie Ihre Logik, die Ihren Anforderungen entspricht. Mit dieser Technik können Sie die benutzerdefinierten Nachrichten wiederverwenden, die Sie möglicherweise in der benutzerdefinierten Formularanforderungsklasse definiert haben.

Fehlermeldungen

Anpassen von Fehlermeldungen

Die Dateien /resources/lang/[lang]/validation.php enthalten die /resources/lang/[lang]/validation.php , die vom /resources/lang/[lang]/validation.php verwendet werden sollen. Sie können sie nach Bedarf bearbeiten.

Die meisten von ihnen haben Platzhalter, die beim Generieren der Fehlermeldung automatisch ersetzt werden.

Zum Beispiel in 'required' => 'The :attribute field is required.' , Der Platzhalter für das :attribute wird durch den Feldnamen ersetzt (alternativ können Sie auch den Anzeigewert jedes Felds im attributes Array in derselben Datei anpassen).

Beispiel

Nachrichtenkonfiguration:

'required' => 'Please inform your :attribute.',
//...
'attributes => [
    'email' => 'E-Mail address'
]

Regeln:

`email' => `required`

resultierende Fehlermeldung:

"Bitte informieren Sie Ihre E-Mail-Adresse."

Anpassen von Fehlermeldungen innerhalb einer Request-Klasse

Die Request-Klasse hat Zugriff auf eine messages() -Methode, die ein Array zurückgeben soll. Dies kann zum Überschreiben von Nachrichten verwendet werden, ohne in die lang-Dateien gehen zu müssen. Wenn wir beispielsweise über eine benutzerdefinierte file_exists , können Sie die unten stehenden Meldungen verwenden.

class SampleRequest extends Request {

    /**
     * Get the validation rules that apply to the request.
     *
     * @return array
     */
    public function rules()
    {
        return [
            'image' =>  'required|file_exists'
        ];
    }

    /**
     * Determine if the user is authorized to make this request.
     *
     * @return bool
     */
    public function authorize()
    {
        return true;
    }

    public function messages()
    {
        return [
            'image.file_exists' =>  'That file no longer exists or is invalid'
        ];
    }

}

Fehlermeldungen anzeigen

Die Validierungsfehler werden in die Sitzung geflasht und sind auch in der Variablen $errors verfügbar, die automatisch für alle Ansichten freigegeben wird.

Beispiel für die Anzeige der Fehler in einer Blade-Ansicht:

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

Benutzerdefinierte Validierungsregeln

Wenn Sie eine benutzerdefinierte Validierungsregel erstellen möchten, können Sie dies beispielsweise in der boot Methode eines Service Providers über die Validator-Fassade tun.

<?php
namespace App\Providers;

use Illuminate\Support\ServiceProvider;
use Validator;

class AppServiceProvider extends ServiceProvider
{
    public function boot()
    {
        Validator::extend('starts_with', function($attribute, $value, $parameters, $validator) {
            return \Illuminate\Support\Str::startsWith($value, $parameters[0]);
        });

        Validator::replacer('starts_with', function($message, $attribute, $rule, $parameters) {
            return str_replace(':needle', $parameters[0], $message);
        });
    }
}

Die extend Methode nimmt eine Zeichenfolge, die der Name der Regel ist, und eine Funktion, der wiederum der Name des Attributs, der zu überprüfende Wert, ein Array der Regelparameter und die Validierungsinstanz übergeben werden die Validierung ist bestanden. In diesem Beispiel überprüfen wir, ob die Wertzeichenfolge mit einer bestimmten Teilzeichenfolge beginnt.

Die Fehlermeldung für diese benutzerdefinierte Regel kann wie üblich in der Datei /resources/lang/[lang]/validation.php werden und Platzhalter enthalten, z. B. für Parameterwerte:

'starts_with' => 'The :attribute must start with :needle.'

Die replacer nimmt eine Zeichenfolge an, die den Namen der Regel darstellt, und eine Funktion, der (vor dem Ersetzen) die ursprüngliche Nachricht übergeben wird, der Name des Attributs, der Name der Regel und ein Array der Regelparameter und sollte die Nachricht nach dem Ersetzen der Platzhalter nach Bedarf zurückgeben.

Verwenden Sie diese Regel wie jede andere:

$this->validate($request, [
    'phone_number' => 'required|starts_with:+'
]);