Weitere Validatoren

Es gibt viele Validatoren, die direkt über Composer verfügbar sind und verwendet werden können, zum Beispiel:

webman/validation (Empfohlen)

top-think/think-validate

respect/validation

Validator webman/validation

Basiert auf illuminate/validation, bietet manuelle Validierung, Annotations-Validierung, parameterbezogene Validierung und wiederverwendbare Regelsätze.

Installation

composer require webman/validation

Grundkonzepte

• Regelsatz-Wiederverwendung: Definieren Sie wiederverwendbare rules, messages, attributes und scenes durch Erweiterung von support\validation\Validator, die sowohl bei manueller als auch bei Annotations-Validierung wiederverwendet werden können.
• Methodenbezogene Annotations-Validierung (Attribute): Verwenden Sie das PHP-8-Attribut #[Validate], um die Validierung an Controller-Methoden zu binden.
• Parameterbezogene Annotations-Validierung (Attribute): Verwenden Sie das PHP-8-Attribut #[Param], um die Validierung an Controller-Methodenparameter zu binden.
• Ausnahmebehandlung: Wirft bei Validierungsfehlern support\validation\ValidationException; die Ausnahmeklasse ist konfigurierbar.
• Datenbankvalidierung: Bei Datenbankvalidierung muss composer require webman/database installiert werden.

Manuelle Validierung

Grundlegende Verwendung

use support\validation\Validator;

$data = ['email' => 'user@example.com'];

Validator::make($data, [
    'email' => 'required|email',
])->validate();

Hinweis
validate() wirft bei Validierungsfehlern support\validation\ValidationException. Wenn Sie keine Ausnahmen werfen möchten, verwenden Sie die unten beschriebene fails()-Methode, um Fehlermeldungen zu erhalten.

Benutzerdefinierte Meldungen und Attribute

use support\validation\Validator;

$data = ['contact' => 'user@example.com'];

Validator::make(
    $data,
    ['contact' => 'required|email'],
    ['contact.email' => 'Invalid email format'],
    ['contact' => 'Email']
)->validate();

Validierung ohne Ausnahme (Fehlermeldungen abrufen)

Wenn Sie keine Ausnahmen werfen möchten, verwenden Sie fails() zur Prüfung und rufen Sie Fehlermeldungen über errors() ab (gibt MessageBag zurück):

use support\validation\Validator;

$data = ['email' => 'bad-email'];

$validator = Validator::make($data, [
    'email' => 'required|email',
]);

if ($validator->fails()) {
    $firstError = $validator->errors()->first();      // string
    $allErrors = $validator->errors()->all();         // array
    $errorsByField = $validator->errors()->toArray(); // array
    // Fehler behandeln...
}

Regelsatz-Wiederverwendung (Benutzerdefinierter Validator)

namespace app\validation;

use support\validation\Validator;

class UserValidator extends Validator
{
    protected array $rules = [
        'id' => 'required|integer|min:1',
        'name' => 'required|string|min:2|max:20',
        'email' => 'required|email',
    ];

    protected array $messages = [
        'name.required' => 'Name is required',
        'email.required' => 'Email is required',
        'email.email' => 'Invalid email format',
    ];

    protected array $attributes = [
        'name' => 'Name',
        'email' => 'Email',
    ];
}

Wiederverwendung bei manueller Validierung

use app\validation\UserValidator;

UserValidator::make($data)->validate();

Szenen verwenden (Optional)

scenes ist eine optionale Funktion; sie validiert nur eine Teilmenge der Felder, wenn Sie withScene(...) aufrufen.

namespace app\validation;

use support\validation\Validator;

class UserValidator extends Validator
{
    protected array $rules = [
        'id' => 'required|integer|min:1',
        'name' => 'required|string|min:2|max:20',
        'email' => 'required|email',
    ];

    protected array $scenes = [
        'create' => ['name', 'email'],
        'update' => ['id', 'name', 'email'],
    ];
}

use app\validation\UserValidator;

// Keine Szene angegeben -> alle Regeln validieren
UserValidator::make($data)->validate();

// Szene angegeben -> nur Felder dieser Szene validieren
UserValidator::make($data)->withScene('create')->validate();

Annotations-Validierung (Methodenebene)

Direkte Regeln

use support\Request;
use support\validation\annotation\Validate;

class AuthController
{
    #[Validate(
        rules: [
            'email' => 'required|email',
            'password' => 'required|string|min:6',
        ],
        messages: [
            'email.required' => 'Email is required',
            'password.required' => 'Password is required',
        ],
        attributes: [
            'email' => 'Email',
            'password' => 'Password',
        ]
    )]
    public function login(Request $request)
    {
        return json(['code' => 0, 'msg' => 'ok']);
    }
}

Regelsätze wiederverwenden

use app\validation\UserValidator;
use support\Request;
use support\validation\annotation\Validate;

class UserController
{
    #[Validate(validator: UserValidator::class, scene: 'create')]
    public function create(Request $request)
    {
        return json(['code' => 0, 'msg' => 'ok']);
    }
}

Mehrfache Validierungsüberlagerungen

use support\validation\annotation\Validate;

class UserController
{
    #[Validate(rules: ['email' => 'required|email'])]
    #[Validate(rules: ['token' => 'required|string'])]
    public function send()
    {
        return json(['code' => 0, 'msg' => 'ok']);
    }
}

Validierungsdatenquelle

use support\validation\annotation\Validate;

class UserController
{
    #[Validate(
        rules: ['email' => 'required|email'],
        in: ['query', 'body', 'path']
    )]
    public function send()
    {
        return json(['code' => 0, 'msg' => 'ok']);
    }
}

Mit dem Parameter in wird die Datenquelle angegeben:

• query HTTP-Abfrageparameter, aus $request->get()
• body HTTP-Anfragekörper, aus $request->post()
• path HTTP-Pfadparameter, aus $request->route->param()

in kann ein String oder Array sein; bei einem Array werden die Werte der Reihe nach zusammengeführt, wobei spätere Werte frühere überschreiben. Wenn in nicht übergeben wird, ist der Standardwert ['query', 'body', 'path'].

Parameterbezogene Validierung (Param)

Grundlegende Verwendung

use support\validation\annotation\Param;

class MailController
{
    public function send(
        #[Param(rules: 'required|email')] string $from,
        #[Param(rules: 'required|email')] string $to,
        #[Param(rules: 'required|string|min:1|max:500')] string $content
    ) {
        return json(['code' => 0, 'msg' => 'ok']);
    }
}

Validierungsdatenquelle

Auch die parameterbezogene Validierung unterstützt den Parameter in zur Angabe der Quelle:

use support\validation\annotation\Param;

class MailController
{
    public function send(
        #[Param(rules: 'required|email', in: ['body'])] string $from
    ) {
        return json(['code' => 0, 'msg' => 'ok']);
    }
}

rules unterstützt String oder Array

use support\validation\annotation\Param;

class MailController
{
    public function send(
        #[Param(rules: ['required', 'email'])] string $from
    ) {
        return json(['code' => 0, 'msg' => 'ok']);
    }
}

Benutzerdefinierte Meldungen / Attribut

use support\validation\annotation\Param;

class UserController
{
    public function updateEmail(
        #[Param(
            rules: 'required|email',
            messages: ['email.email' => 'Invalid email format'],
            attribute: 'Email'
        )]
        string $email
    ) {
        return json(['code' => 0, 'msg' => 'ok']);
    }
}

Regel-Konstanten-Wiederverwendung

final class ParamRules
{
    public const EMAIL = ['required', 'email'];
}

class UserController
{
    public function send(
        #[Param(rules: ParamRules::EMAIL)] string $email
    ) {
        return json(['code' => 0, 'msg' => 'ok']);
    }
}

Methodenebene + Parameterebene kombiniert

use support\Request;
use support\validation\annotation\Param;
use support\validation\annotation\Validate;

class UserController
{
    #[Validate(rules: ['token' => 'required|string'])]
    public function send(
        Request $request,
        #[Param(rules: 'required|email')] string $from,
        #[Param(rules: 'required|integer')] int $id
    ) {
        return json(['code' => 0, 'msg' => 'ok']);
    }
}

Automatische Regelableitung (basierend auf Parametersignatur)

Wenn #[Validate] für eine Methode verwendet wird oder ein beliebiger Parameter dieser Methode #[Param] nutzt, leitet diese Komponente automatisch grundlegende Validierungsregeln aus der Methodenparametersignatur ab und ergänzt sie, bevor sie mit bestehenden Regeln zusammengeführt und validiert werden.

Beispiel: Äquivalente Erweiterung von #[Validate]

1) Nur #[Validate] aktivieren ohne manuelle Regeln:

use support\validation\annotation\Validate;

class DemoController
{
    #[Validate]
    public function create(string $content, int $uid)
    {
    }
}

Entspricht:

use support\validation\annotation\Validate;

class DemoController
{
    #[Validate(rules: [
        'content' => 'required|string',
        'uid' => 'required|integer',
    ])]
    public function create(string $content, int $uid)
    {
    }
}

2) Nur teilweise Regeln geschrieben, Rest durch Parametersignatur ergänzt:

use support\validation\annotation\Validate;

class DemoController
{
    #[Validate(rules: [
        'content' => 'min:2',
    ])]
    public function create(string $content, int $uid)
    {
    }
}

Entspricht:

use support\validation\annotation\Validate;

class DemoController
{
    #[Validate(rules: [
        'content' => 'required|string|min:2',
        'uid' => 'required|integer',
    ])]
    public function create(string $content, int $uid)
    {
    }
}

3) Standardwert / nullable-Typ:

use support\validation\annotation\Validate;

class DemoController
{
    #[Validate]
    public function create(string $content = 'default', ?int $uid = null)
    {
    }
}

Entspricht:

use support\validation\annotation\Validate;

class DemoController
{
    #[Validate(rules: [
        'content' => 'string',
        'uid' => 'integer|nullable',
    ])]
    public function create(string $content = 'default', ?int $uid = null)
    {
    }
}

Ausnahmebehandlung

Standardausnahme

Bei Validierungsfehlern wird standardmäßig support\validation\ValidationException geworfen, die von Webman\Exception\BusinessException erbt und keine Fehler protokolliert.

Das Standard-Antwortverhalten wird von BusinessException::render() behandelt:

• Normale Anfragen: gibt String-Nachricht zurück, z. B. token is required.
• JSON-Anfragen: gibt JSON-Antwort zurück, z. B. {"code": 422, "msg": "token is required.", "data":....}

Anpassung über benutzerdefinierte Ausnahme

• Globale Konfiguration: exception in config/plugin/webman/validation/app.php

Mehrsprachige Unterstützung

Die Komponente enthält eingebaute chinesische und englische Sprachpakete und unterstützt Projektüberschreibungen. Lade-Reihenfolge:

1. Projekt-Sprachpaket resource/translations/{locale}/validation.php
2. Komponenten-eingebaut vendor/webman/validation/resources/lang/{locale}/validation.php
3. Illuminate eingebaut Englisch (Fallback)

Hinweis
Die Webman-Standardsprache wird in config/translation.php konfiguriert oder kann über locale('en'); geändert werden.

Beispiel für lokale Überschreibung

resource/translations/zh_CN/validation.php

return [
    'email' => ':attribute is not a valid email format.',
];

Middleware-Autoload

Nach der Installation lädt die Komponente die Validierungs-Middleware automatisch über config/plugin/webman/validation/middleware.php; keine manuelle Registrierung erforderlich.

Befehlszeilen-Generierung

Verwenden Sie den Befehl make:validator, um Validator-Klassen zu erzeugen (Standardausgabe in das Verzeichnis app/validation).

Hinweis
Erfordert composer require webman/console

Grundlegende Verwendung

• Leeres Template erzeugen

php webman make:validator UserValidator

• Vorhandene Datei überschreiben

php webman make:validator UserValidator --force
php webman make:validator UserValidator -f

Regeln aus Tabellenstruktur erzeugen

• Tabellennamen angeben, um Basisregeln zu erzeugen (leitet $rules aus Feldtyp/nullable/Länge etc. ab; schließt ORM-bezogene Felder standardmäßig aus: Laravel verwendet created_at/updated_at/deleted_at, ThinkORM verwendet create_time/update_time/delete_time)

php webman make:validator UserValidator --table=wa_users
php webman make:validator UserValidator -t wa_users

• Datenbankverbindung angeben (Mehrfachverbindungs-Szenarien)

php webman make:validator UserValidator --table=wa_users --database=mysql
php webman make:validator UserValidator -t wa_users -d mysql

Szenen

• CRUD-Szenen erzeugen: create/update/delete/detail

php webman make:validator UserValidator --table=wa_users --scenes=crud
php webman make:validator UserValidator -t wa_users -s crud

Die Szene update enthält das Primärschlüsselfeld (zur Datensatzsuche) plus weitere Felder; delete/detail enthalten standardmäßig nur den Primärschlüssel.

ORM-Auswahl (laravel (illuminate/database) vs think-orm)

• Automatische Auswahl (Standard): Verwendet das installierte/konfigurierte ORM; bei beiden vorhanden wird standardmäßig Illuminate verwendet
• Erzwingen

php webman make:validator UserValidator --table=wa_users --orm=laravel
php webman make:validator UserValidator --table=wa_users --orm=thinkorm
php webman make:validator UserValidator -t wa_users -o thinkorm

Vollständiges Beispiel

php webman make:validator UserValidator -t wa_users -d mysql -s crud -o laravel -f

Unit-Tests

Im Stammverzeichnis von webman/validation ausführen:

composer install
vendor\bin\phpunit -c phpunit.xml

Validierungsregeln-Referenz

Verfügbare Validierungsregeln

[!IMPORTANT]

• Webman Validation basiert auf illuminate/validation; Regelnamen entsprechen Laravel und es gibt keine Webman-spezifischen Regeln.
• Die Middleware validiert standardmäßig Daten aus $request->all() (GET+POST) zusammengeführt mit Routenparametern, ohne hochgeladene Dateien; für Dateiregeln müssen Sie $request->file() manuell in die Daten mergen oder Validator::make aufrufen.
• current_password hängt vom Auth-Guard ab; exists/unique hängen von Datenbankverbindung und Query Builder ab; diese Regeln sind nicht verfügbar, wenn die entsprechenden Komponenten nicht integriert sind.

Die folgende Liste enthält alle verfügbaren Validierungsregeln und deren Zweck:

Boolean

String

Numeric

Array

Date

File

Database

Utility

accepted

Das Feld muss "yes", "on", 1, "1", true oder "true" sein. Wird häufig für Szenarien wie die Bestätigung der Nutzungsbedingungen verwendet.

accepted_if:anotherfield,value,...

Wenn ein anderes Feld dem angegebenen Wert entspricht, muss das Feld "yes", "on", 1, "1", true oder "true" sein. Wird häufig für bedingte Zustimmungsszenarien verwendet.

active_url

Das Feld muss einen gültigen A- oder AAAA-Datensatz haben. Diese Regel verwendet zuerst parse_url, um den URL-Hostnamen zu extrahieren, und validiert dann mit dns_get_record.

after:date

Das Feld muss einen Wert nach dem angegebenen Datum haben. Das Datum wird an strtotime übergeben, um es in ein gültiges DateTime zu konvertieren:

use support\validation\Validator;

Validator::make($data, [
    'start_date' => 'required|date|after:tomorrow',
])->validate();

Sie können auch einen anderen Feldnamen zum Vergleich übergeben:

Validator::make($data, [
    'finish_date' => 'required|date|after:start_date',
])->validate();

Sie können den fließenden date-Regel-Builder verwenden:

use support\validation\Rule;
use support\validation\Validator;

Validator::make($data, [
    'start_date' => [
        'required',
        Rule::date()->after(\Carbon\Carbon::today()->addDays(7)),
    ],
])->validate();

afterToday und todayOrAfter drücken bequem „muss nach heute sein“ bzw. „muss heute oder später sein“ aus:

Validator::make($data, [
    'start_date' => [
        'required',
        Rule::date()->afterToday(),
    ],
])->validate();

after_or_equal:date

Das Feld muss am oder nach dem angegebenen Datum liegen. Siehe after für weitere Details.

Sie können den fließenden date-Regel-Builder verwenden:

use support\validation\Rule;
use support\validation\Validator;

Validator::make($data, [
    'start_date' => [
        'required',
        Rule::date()->afterOrEqual(\Carbon\Carbon::today()->addDays(7)),
    ],
])->validate();

anyOf

Rule::anyOf erlaubt die Angabe „mindestens eine Regelsatz-Bedingung erfüllen“. Die folgende Regel bedeutet z. B., dass username entweder eine E-Mail-Adresse oder eine alphanumerische/Unterstrich/Bindestrich-Zeichenkette von mindestens 6 Zeichen sein muss:

use support\validation\Rule;
use support\validation\Validator;

Validator::make($data, [
    'username' => [
        'required',
        Rule::anyOf([
            ['string', 'email'],
            ['string', 'alpha_dash', 'min:6'],
        ]),
    ],
])->validate();

alpha

Das Feld muss Unicode-Buchstaben enthalten (\p{L} und \p{M}).

Um nur ASCII (a-z, A-Z) zu erlauben, fügen Sie die Option ascii hinzu:

Validator::make($data, [
    'username' => 'alpha:ascii',
])->validate();

alpha_dash

Das Feld darf nur Unicode-Buchstaben und -Zahlen enthalten (\p{L}, \p{M}, \p{N}), plus ASCII-Bindestrich (-) und Unterstrich (_).

Um nur ASCII (a-z, A-Z, 0-9) zu erlauben, fügen Sie die Option ascii hinzu:

Validator::make($data, [
    'username' => 'alpha_dash:ascii',
])->validate();

alpha_num

Das Feld darf nur Unicode-Buchstaben und -Zahlen enthalten (\p{L}, \p{M}, \p{N}).

Um nur ASCII (a-z, A-Z, 0-9) zu erlauben, fügen Sie die Option ascii hinzu:

Validator::make($data, [
    'username' => 'alpha_num:ascii',
])->validate();

array

Das Feld muss ein PHP-array sein.

Wenn die array-Regel zusätzliche Parameter hat, müssen die Eingabe-Array-Schlüssel in der Parameterliste stehen. Im Beispiel ist der Schlüssel admin nicht in der erlaubten Liste, daher ist er ungültig:

use support\validation\Validator;

$input = [
    'user' => [
        'name' => 'Taylor Otwell',
        'username' => 'taylorotwell',
        'admin' => true,
    ],
];

Validator::make($input, [
    'user' => 'array:name,username',
])->validate();

Es wird empfohlen, in realen Projekten erlaubte Array-Schlüssel explizit zu definieren.

ascii

Das Feld darf nur 7-Bit-ASCII-Zeichen enthalten.

bail

Die weitere Validierung von Regeln für das Feld stoppen, wenn die erste Regel fehlschlägt.

Diese Regel betrifft nur das aktuelle Feld. Für „bei erstem Fehler global stoppen“ verwenden Sie den Illuminate-Validator direkt und rufen Sie stopOnFirstFailure() auf.

before:date

Das Feld muss vor dem angegebenen Datum liegen. Das Datum wird an strtotime übergeben, um es in ein gültiges DateTime zu konvertieren. Wie bei after können Sie einen anderen Feldnamen zum Vergleich übergeben.

Sie können den fließenden date-Regel-Builder verwenden:

use support\validation\Rule;
use support\validation\Validator;

Validator::make($data, [
    'start_date' => [
        'required',
        Rule::date()->before(\Carbon\Carbon::today()->subDays(7)),
    ],
])->validate();

beforeToday und todayOrBefore drücken bequem „muss vor heute sein“ bzw. „muss heute oder früher sein“ aus:

Validator::make($data, [
    'start_date' => [
        'required',
        Rule::date()->beforeToday(),
    ],
])->validate();

before_or_equal:date

Das Feld muss am oder vor dem angegebenen Datum liegen. Das Datum wird an strtotime übergeben, um es in ein gültiges DateTime zu konvertieren. Wie bei after können Sie einen anderen Feldnamen zum Vergleich übergeben.

Sie können den fließenden date-Regel-Builder verwenden:

use support\validation\Rule;
use support\validation\Validator;

Validator::make($data, [
    'start_date' => [
        'required',
        Rule::date()->beforeOrEqual(\Carbon\Carbon::today()->subDays(7)),
    ],
])->validate();

between:min,max

Die Feldgröße muss zwischen min und max (inklusive) liegen. Die Auswertung für Strings, Zahlen, Arrays und Dateien entspricht size.

boolean

Das Feld muss in einen Boolean konvertierbar sein. Akzeptable Eingaben sind true, false, 1, 0, "1", "0".

Verwenden Sie den Parameter strict, um nur true oder false zu erlauben:

Validator::make($data, [
    'foo' => 'boolean:strict',
])->validate();

confirmed

Das Feld muss ein übereinstimmendes {field}_confirmation-Feld haben. Wenn das Feld z. B. password ist, ist password_confirmation erforderlich.

Sie können auch einen benutzerdefinierten Bestätigungsfeldnamen angeben, z. B. erfordert confirmed:repeat_username, dass repeat_username dem aktuellen Feld entspricht.

contains:foo,bar,...

Das Feld muss ein Array sein und alle angegebenen Parameterwerte enthalten. Diese Regel wird häufig für Array-Validierung verwendet; Sie können Rule::contains zur Konstruktion verwenden:

use support\validation\Rule;
use support\validation\Validator;

Validator::make($data, [
    'roles' => [
        'required',
        'array',
        Rule::contains(['admin', 'editor']),
    ],
])->validate();

doesnt_contain:foo,bar,...

Das Feld muss ein Array sein und darf keinen der angegebenen Parameterwerte enthalten. Sie können Rule::doesntContain zur Konstruktion verwenden:

use support\validation\Rule;
use support\validation\Validator;

Validator::make($data, [
    'roles' => [
        'required',
        'array',
        Rule::doesntContain(['admin', 'editor']),
    ],
])->validate();

current_password

Das Feld muss dem Passwort des aktuell authentifizierten Benutzers entsprechen. Sie können den Auth-Guard als ersten Parameter angeben:

Validator::make($data, [
    'password' => 'current_password:api',
])->validate();

[!WARNING]
Diese Regel hängt von der Auth-Komponente und Guard-Konfiguration ab; nicht verwenden, wenn Auth nicht integriert ist.

date

Das Feld muss ein gültiges (nicht-relatives) Datum sein, das von strtotime erkannt wird.

date_equals:date

Das Feld muss dem angegebenen Datum entsprechen. Das Datum wird an strtotime übergeben, um es in ein gültiges DateTime zu konvertieren.

date_format:format,...

Das Feld muss einem der angegebenen Formate entsprechen. Verwenden Sie entweder date oder date_format. Diese Regel unterstützt alle PHP-DateTime-Formate.

Sie können den fließenden date-Regel-Builder verwenden:

use support\validation\Rule;
use support\validation\Validator;

Validator::make($data, [
    'start_date' => [
        'required',
        Rule::date()->format('Y-m-d'),
    ],
])->validate();

decimal:min,max

Das Feld muss numerisch sein mit der erforderlichen Anzahl Dezimalstellen:

Validator::make($data, [
    'price' => 'decimal:2',
])->validate();

Validator::make($data, [
    'price' => 'decimal:2,4',
])->validate();

declined

Das Feld muss "no", "off", 0, "0", false oder "false" sein.

declined_if:anotherfield,value,...

Wenn ein anderes Feld dem angegebenen Wert entspricht, muss das Feld "no", "off", 0, "0", false oder "false" sein.

different:field

Das Feld muss sich von field unterscheiden.

digits:value

Das Feld muss eine ganze Zahl mit der Länge value sein.

digits_between:min,max

Das Feld muss eine ganze Zahl mit einer Länge zwischen min und max sein.

dimensions

Das Feld muss ein Bild sein und Dimensionsbeschränkungen erfüllen:

Validator::make($data, [
    'avatar' => 'dimensions:min_width=100,min_height=200',
])->validate();

Verfügbare Beschränkungen: min_width, max_width, min_height, max_height, width, height, ratio.

ratio ist das Seitenverhältnis; es kann als Bruch oder Float angegeben werden:

Validator::make($data, [
    'avatar' => 'dimensions:ratio=3/2',
])->validate();

Diese Regel hat viele Parameter; es wird empfohlen, Rule::dimensions zur Konstruktion zu verwenden:

use support\validation\Rule;
use support\validation\Validator;

Validator::make($data, [
    'avatar' => [
        'required',
        Rule::dimensions()
            ->maxWidth(1000)
            ->maxHeight(500)
            ->ratio(3 / 2),
    ],
])->validate();

distinct

Bei der Validierung von Arrays dürfen Feldwerte nicht doppelt vorkommen:

Validator::make($data, [
    'foo.*.id' => 'distinct',
])->validate();

Verwendet standardmäßig lockeren Vergleich. Fügen Sie strict für strikten Vergleich hinzu:

Validator::make($data, [
    'foo.*.id' => 'distinct:strict',
])->validate();

Fügen Sie ignore_case hinzu, um Groß-/Kleinschreibung zu ignorieren:

Validator::make($data, [
    'foo.*.id' => 'distinct:ignore_case',
])->validate();

doesnt_start_with:foo,bar,...

Das Feld darf nicht mit einem der angegebenen Werte beginnen.

doesnt_end_with:foo,bar,...

Das Feld darf nicht mit einem der angegebenen Werte enden.

email

Das Feld muss eine gültige E-Mail-Adresse sein. Diese Regel hängt von egulias/email-validator ab, verwendet standardmäßig RFCValidation und kann andere Validierungsmethoden verwenden:

Validator::make($data, [
    'email' => 'email:rfc,dns',
])->validate();

Verfügbare Validierungsmethoden:

Sie können den fließenden Regel-Builder verwenden:

use support\validation\Rule;
use support\validation\Validator;

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

[!WARNING]
dns und spoof erfordern die PHP-Erweiterung intl.

encoding:encoding_type

Das Feld muss der angegebenen Zeichenkodierung entsprechen. Diese Regel verwendet mb_check_encoding, um die Datei- oder String-Kodierung zu erkennen. Kann mit dem File-Regel-Builder verwendet werden:

use Illuminate\Validation\Rules\File;
use support\validation\Validator;

Validator::make($data, [
    'attachment' => [
        'required',
        File::types(['csv'])->encoding('utf-8'),
    ],
])->validate();

ends_with:foo,bar,...

Das Feld muss mit einem der angegebenen Werte enden.

enum

Enum ist eine klassenbasierte Regel zur Validierung, dass der Feldwert ein gültiger Enum-Wert ist. Übergeben Sie den Enum-Klassennamen bei der Konstruktion. Für primitive Werte verwenden Sie Backed Enum:

use app\enums\ServerStatus;
use support\validation\Rule;
use support\validation\Validator;

Validator::make($data, [
    'status' => [Rule::enum(ServerStatus::class)],
])->validate();

Verwenden Sie only/except, um Enum-Werte einzuschränken:

use app\enums\ServerStatus;
use support\validation\Rule;
use support\validation\Validator;

Validator::make($data, [
    'status' => [
        Rule::enum(ServerStatus::class)
            ->only([ServerStatus::Pending, ServerStatus::Active]),
    ],
])->validate();

Validator::make($data, [
    'status' => [
        Rule::enum(ServerStatus::class)
            ->except([ServerStatus::Pending, ServerStatus::Active]),
    ],
])->validate();

Verwenden Sie when für bedingte Einschränkungen:

use app\Enums\ServerStatus;
use support\validation\Rule;
use support\validation\Validator;

Validator::make($data, [
    'status' => [
        Rule::enum(ServerStatus::class)->when(
            $isAdmin,
            fn ($rule) => $rule->only(ServerStatus::Active),
            fn ($rule) => $rule->only(ServerStatus::Pending),
        ),
    ],
])->validate();

exclude

Das Feld wird aus den von validate/validated zurückgegebenen Daten ausgeschlossen.

exclude_if:anotherfield,value

Wenn anotherfield value entspricht, wird das Feld aus den von validate/validated zurückgegebenen Daten ausgeschlossen.

Für komplexe Bedingungen verwenden Sie Rule::excludeIf:

use support\validation\Rule;
use support\validation\Validator;

Validator::make($data, [
    'role_id' => Rule::excludeIf($isAdmin),
])->validate();

Validator::make($data, [
    'role_id' => Rule::excludeIf(fn () => $isAdmin),
])->validate();

exclude_unless:anotherfield,value

Außer wenn anotherfield value entspricht, wird das Feld aus den von validate/validated zurückgegebenen Daten ausgeschlossen. Wenn value null ist (z. B. exclude_unless:name,null), wird das Feld nur behalten, wenn das Vergleichsfeld null oder nicht vorhanden ist.

exclude_with:anotherfield

Wenn anotherfield existiert, wird das Feld aus den von validate/validated zurückgegebenen Daten ausgeschlossen.

exclude_without:anotherfield

Wenn anotherfield nicht existiert, wird das Feld aus den von validate/validated zurückgegebenen Daten ausgeschlossen.

exists:table,column

Das Feld muss in der angegebenen Datenbanktabelle existieren.

Grundlegende Verwendung der Exists-Regel

Validator::make($data, [
    'state' => 'exists:states',
])->validate();

Wenn column nicht angegeben ist, wird standardmäßig der Feldname verwendet. Dieses Beispiel validiert also, ob die Spalte state in der Tabelle states existiert.

Benutzerdefinierten Spaltennamen angeben

Fügen Sie den Spaltennamen nach dem Tabellennamen an:

Validator::make($data, [
    'state' => 'exists:states,abbreviation',
])->validate();

Um eine Datenbankverbindung anzugeben, stellen Sie dem Tabellennamen den Verbindungsnamen voran:

Validator::make($data, [
    'email' => 'exists:connection.staff,email',
])->validate();

Sie können auch einen Modellklassennamen übergeben; das Framework löst den Tabellennamen auf:

Validator::make($data, [
    'user_id' => 'exists:app\model\User,id',
])->validate();

Für benutzerdefinierte Abfragebedingungen verwenden Sie den Rule-Builder:

use Illuminate\Database\Query\Builder;
use support\validation\Rule;
use support\validation\Validator;

Validator::make($data, [
    'email' => [
        'required',
        Rule::exists('staff')->where(function (Builder $query) {
            $query->where('account_id', 1);
        }),
    ],
])->validate();

Sie können den Spaltennamen auch direkt in Rule::exists angeben:

use support\validation\Rule;
use support\validation\Validator;

Validator::make($data, [
    'state' => [Rule::exists('states', 'abbreviation')],
])->validate();

Um zu validieren, dass eine Menge von Werten existiert, kombinieren Sie mit der array-Regel:

Validator::make($data, [
    'states' => ['array', Rule::exists('states', 'abbreviation')],
])->validate();

Wenn sowohl array als auch exists vorhanden sind, validiert eine einzelne Abfrage alle Werte.

extensions:foo,bar,...

Validiert, dass die Dateierweiterung der hochgeladenen Datei in der erlaubten Liste steht:

Validator::make($data, [
    'photo' => ['required', 'extensions:jpg,png'],
])->validate();

[!WARNING]
Verlassen Sie sich nicht allein auf die Erweiterung für die Dateityp-Validierung; verwenden Sie sie zusammen mit mimes oder mimetypes.

file

Das Feld muss eine erfolgreich hochgeladene Datei sein.

filled

Wenn das Feld existiert, darf sein Wert nicht leer sein.

gt:field

Das Feld muss größer als das angegebene field oder value sein. Beide Felder müssen denselben Typ haben. Die Auswertung für Strings, Zahlen, Arrays und Dateien entspricht size.

gte:field

Das Feld muss größer oder gleich dem angegebenen field oder value sein. Beide Felder müssen denselben Typ haben. Die Auswertung für Strings, Zahlen, Arrays und Dateien entspricht size.

hex_color

Das Feld muss ein gültiger Hex-Farbwert sein.

image

Das Feld muss ein Bild sein (jpg, jpeg, png, bmp, gif oder webp).

[!WARNING]
SVG ist standardmäßig wegen XSS-Risiko nicht erlaubt. Zum Erlauben fügen Sie allow_svg hinzu: image:allow_svg.

in:foo,bar,...

Das Feld muss in der angegebenen Werteliste stehen. Sie können Rule::in zur Konstruktion verwenden:

use support\validation\Rule;
use support\validation\Validator;

Validator::make($data, [
    'zones' => [
        'required',
        Rule::in(['first-zone', 'second-zone']),
    ],
])->validate();

In Kombination mit der array-Regel muss jeder Wert im Eingabe-Array in der in-Liste stehen:

use support\validation\Rule;
use support\validation\Validator;

$input = [
    'airports' => ['NYC', 'LAS'],
];

Validator::make($input, [
    'airports' => [
        'required',
        'array',
    ],
    'airports.*' => Rule::in(['NYC', 'LIT']),
])->validate();

in_array:anotherfield.*

Das Feld muss in der Werteliste von anotherfield existieren.

in_array_keys:value.*

Das Feld muss ein Array sein und mindestens einen der angegebenen Werte als Schlüssel enthalten:

Validator::make($data, [
    'config' => 'array|in_array_keys:timezone',
])->validate();

integer

Das Feld muss eine ganze Zahl sein.

Verwenden Sie den Parameter strict, um zu verlangen, dass der Feldtyp integer ist; String-Ganzzahlen sind dann ungültig:

Validator::make($data, [
    'age' => 'integer:strict',
])->validate();

[!WARNING]
Diese Regel validiert nur, ob sie PHPs FILTER_VALIDATE_INT besteht; für strikte numerische Typen verwenden Sie sie zusammen mit numeric.

ip

Das Feld muss eine gültige IP-Adresse sein.

ipv4

Das Feld muss eine gültige IPv4-Adresse sein.

ipv6

Das Feld muss eine gültige IPv6-Adresse sein.

json

Das Feld muss eine gültige JSON-Zeichenkette sein.

lt:field

Das Feld muss kleiner als das angegebene field sein. Beide Felder müssen denselben Typ haben. Die Auswertung für Strings, Zahlen, Arrays und Dateien entspricht size.

lte:field

Das Feld muss kleiner oder gleich dem angegebenen field sein. Beide Felder müssen denselben Typ haben. Die Auswertung für Strings, Zahlen, Arrays und Dateien entspricht size.

lowercase

Das Feld muss in Kleinbuchstaben sein.

list

Das Feld muss ein Listen-Array sein. Listen-Array-Schlüssel müssen aufeinanderfolgende Zahlen von 0 bis count($array) - 1 sein.

mac_address

Das Feld muss eine gültige MAC-Adresse sein.

max:value

Das Feld muss kleiner oder gleich value sein. Die Auswertung für Strings, Zahlen, Arrays und Dateien entspricht size.

max_digits:value

Das Feld muss eine ganze Zahl mit einer Länge von höchstens value sein.

mimetypes:text/plain,...

Validiert, dass der MIME-Typ der Datei in der Liste steht:

Validator::make($data, [
    'video' => 'mimetypes:video/avi,video/mpeg,video/quicktime',
])->validate();

Der MIME-Typ wird durch Lesen des Dateiinhalts ermittelt und kann vom clientseitig bereitgestellten MIME abweichen.

mimes:foo,bar,...

Validiert, dass der MIME-Typ der Datei der angegebenen Erweiterung entspricht:

Validator::make($data, [
    'photo' => 'mimes:jpg,bmp,png',
])->validate();

Obwohl die Parameter Erweiterungen sind, liest diese Regel den Dateiinhalt, um den MIME-Typ zu ermitteln. Erweiterungs-zu-MIME-Zuordnung:

https://svn.apache.org/repos/asf/httpd/httpd/trunk/docs/conf/mime.types

MIME-Typen und Erweiterungen

Diese Regel validiert nicht, dass „Dateierweiterung“ mit „tatsächlichem MIME“ übereinstimmt. Zum Beispiel behandelt mimes:png photo.txt mit PNG-Inhalt als gültig. Zur Validierung der Erweiterung verwenden Sie extensions.

min:value

Das Feld muss größer oder gleich value sein. Die Auswertung für Strings, Zahlen, Arrays und Dateien entspricht size.

min_digits:value

Das Feld muss eine ganze Zahl mit einer Länge von mindestens value sein.

multiple_of:value

Das Feld muss ein Vielfaches von value sein.

missing

Das Feld darf nicht in den Eingabedaten existieren.

missing_if:anotherfield,value,...

Wenn anotherfield einem der value-Werte entspricht, darf das Feld nicht existieren.

missing_unless:anotherfield,value

Außer wenn anotherfield einem der value-Werte entspricht, darf das Feld nicht existieren.

missing_with:foo,bar,...

Wenn eines der angegebenen Felder existiert, darf das Feld nicht existieren.

missing_with_all:foo,bar,...

Wenn alle angegebenen Felder existieren, darf das Feld nicht existieren.

not_in:foo,bar,...

Das Feld darf nicht in der angegebenen Werteliste stehen. Sie können Rule::notIn zur Konstruktion verwenden:

use support\validation\Rule;
use support\validation\Validator;

Validator::make($data, [
    'toppings' => [
        'required',
        Rule::notIn(['sprinkles', 'cherries']),
    ],
])->validate();

not_regex:pattern

Das Feld darf nicht dem angegebenen regulären Ausdruck entsprechen.

Diese Regel verwendet PHP preg_match. Der Regex muss Trennzeichen haben, z. B. 'email' => 'not_regex:/^.+$/i'.

[!WARNING]
Bei Verwendung von regex/not_regex: Wenn der Regex | enthält, verwenden Sie die Array-Form, um Konflikte mit dem |-Separator zu vermeiden.

nullable

Das Feld darf null sein.

numeric

Das Feld muss numerisch sein.

Verwenden Sie den Parameter strict, um nur Integer- oder Float-Typen zu erlauben; numerische Strings sind dann ungültig:

Validator::make($data, [
    'amount' => 'numeric:strict',
])->validate();

present

Das Feld muss in den Eingabedaten existieren.

present_if:anotherfield,value,...

Wenn anotherfield einem der value-Werte entspricht, muss das Feld existieren.

present_unless:anotherfield,value

Außer wenn anotherfield einem der value-Werte entspricht, muss das Feld existieren.

present_with:foo,bar,...

Wenn eines der angegebenen Felder existiert, muss das Feld existieren.

present_with_all:foo,bar,...

Wenn alle angegebenen Felder existieren, muss das Feld existieren.

prohibited

Das Feld muss fehlen oder leer sein. „Leer“ bedeutet:

prohibited_if:anotherfield,value,...

Wenn anotherfield einem der value-Werte entspricht, muss das Feld fehlen oder leer sein. „Leer“ bedeutet:

Für komplexe Bedingungen verwenden Sie Rule::prohibitedIf:

use support\validation\Rule;
use support\validation\Validator;

Validator::make($data, [
    'role_id' => Rule::prohibitedIf($isAdmin),
])->validate();

Validator::make($data, [
    'role_id' => Rule::prohibitedIf(fn () => $isAdmin),
])->validate();

prohibited_if_accepted:anotherfield,...

Wenn anotherfield "yes", "on", 1, "1", true oder "true" ist, muss das Feld fehlen oder leer sein.

prohibited_if_declined:anotherfield,...

Wenn anotherfield "no", "off", 0, "0", false oder "false" ist, muss das Feld fehlen oder leer sein.

prohibited_unless:anotherfield,value,...

Außer wenn anotherfield einem der value-Werte entspricht, muss das Feld fehlen oder leer sein. „Leer“ bedeutet:

prohibits:anotherfield,...

Wenn das Feld existiert und nicht leer ist, müssen alle Felder in anotherfield fehlen oder leer sein. „Leer“ bedeutet:

regex:pattern

Das Feld muss dem angegebenen regulären Ausdruck entsprechen.

Diese Regel verwendet PHP preg_match. Der Regex muss Trennzeichen haben, z. B. 'email' => 'regex:/^.+@.+$/i'.

[!WARNING]
Bei Verwendung von regex/not_regex: Wenn der Regex | enthält, verwenden Sie die Array-Form, um Konflikte mit dem |-Separator zu vermeiden.

required

Das Feld muss existieren und darf nicht leer sein. „Leer“ bedeutet:

required_if:anotherfield,value,...

Wenn anotherfield einem der value-Werte entspricht, muss das Feld existieren und darf nicht leer sein.

Für komplexe Bedingungen verwenden Sie Rule::requiredIf:

use support\validation\Rule;
use support\validation\Validator;

Validator::make($data, [
    'role_id' => Rule::requiredIf($isAdmin),
])->validate();

Validator::make($data, [
    'role_id' => Rule::requiredIf(fn () => $isAdmin),
])->validate();

required_if_accepted:anotherfield,...

Wenn anotherfield "yes", "on", 1, "1", true oder "true" ist, muss das Feld existieren und darf nicht leer sein.

required_if_declined:anotherfield,...

Wenn anotherfield "no", "off", 0, "0", false oder "false" ist, muss das Feld existieren und darf nicht leer sein.

required_unless:anotherfield,value,...

Außer wenn anotherfield einem der value-Werte entspricht, muss das Feld existieren und darf nicht leer sein. Wenn value null ist (z. B. required_unless:name,null), darf das Feld nur leer sein, wenn das Vergleichsfeld null oder nicht vorhanden ist.

required_with:foo,bar,...

Wenn eines der angegebenen Felder existiert und nicht leer ist, muss das Feld existieren und darf nicht leer sein.

required_with_all:foo,bar,...

Wenn alle angegebenen Felder existieren und nicht leer sind, muss das Feld existieren und darf nicht leer sein.

required_without:foo,bar,...

Wenn eines der angegebenen Felder leer oder nicht vorhanden ist, muss das Feld existieren und darf nicht leer sein.

required_without_all:foo,bar,...

Wenn alle angegebenen Felder leer oder nicht vorhanden sind, muss das Feld existieren und darf nicht leer sein.

required_array_keys:foo,bar,...

Das Feld muss ein Array sein und mindestens die angegebenen Schlüssel enthalten.

sometimes

Wenden Sie nachfolgende Validierungsregeln nur an, wenn das Feld existiert. Wird häufig für „optional, aber bei Vorhandensein gültig“-Felder verwendet:

Validator::make($data, [
    'nickname' => 'sometimes|string|max:20',
])->validate();

same:field

Das Feld muss mit field übereinstimmen.

size:value

Die Feldgröße muss dem angegebenen value entsprechen. Für Strings: Zeichenanzahl; für Zahlen: angegebene Ganzzahl (mit numeric oder integer verwenden); für Arrays: Elementanzahl; für Dateien: Größe in KB. Beispiel:

Validator::make($data, [
    'title' => 'size:12',
    'seats' => 'integer|size:10',
    'tags' => 'array|size:5',
    'image' => 'file|size:512',
])->validate();

starts_with:foo,bar,...

Das Feld muss mit einem der angegebenen Werte beginnen.

string

Das Feld muss eine Zeichenkette sein. Um null zu erlauben, verwenden Sie es zusammen mit nullable.

timezone

Das Feld muss eine gültige Zeitzonenkennung sein (aus DateTimeZone::listIdentifiers). Sie können Parameter übergeben, die von dieser Methode unterstützt werden:

Validator::make($data, [
    'timezone' => 'required|timezone:all',
])->validate();

Validator::make($data, [
    'timezone' => 'required|timezone:Africa',
])->validate();

Validator::make($data, [
    'timezone' => 'required|timezone:per_country,US',
])->validate();

unique:table,column

Das Feld muss in der angegebenen Tabelle eindeutig sein.

Benutzerdefinierten Tabellen-/Spaltennamen angeben:

Sie können den Modellklassennamen direkt angeben:

Validator::make($data, [
    'email' => 'unique:app\model\User,email_address',
])->validate();

Sie können den Spaltennamen angeben (Standard ist der Feldname, wenn nicht angegeben):

Validator::make($data, [
    'email' => 'unique:users,email_address',
])->validate();

Datenbankverbindung angeben:

Validator::make($data, [
    'email' => 'unique:connection.users,email_address',
])->validate();

Bestimmte ID ignorieren:

use support\validation\Rule;
use support\validation\Validator;

Validator::make($data, [
    'email' => [
        'required',
        Rule::unique('users')->ignore($user->id),
    ],
])->validate();

[!WARNING]
ignore sollte keine Benutzereingabe erhalten; verwenden Sie nur systemgenerierte eindeutige IDs (Auto-Increment-ID oder Modell-UUID), sonst kann SQL-Injection-Risiko bestehen.

Sie können auch eine Modellinstanz übergeben:

use support\validation\Rule;
use support\validation\Validator;

Validator::make($data, [
    'email' => [
        Rule::unique('users')->ignore($user),
    ],
])->validate();

Wenn der Primärschlüssel nicht id ist, geben Sie den Primärschlüsselnamen an:

use support\validation\Rule;
use support\validation\Validator;

Validator::make($data, [
    'email' => [
        Rule::unique('users')->ignore($user->id, 'user_id'),
    ],
])->validate();

Standardmäßig wird der Feldname als eindeutige Spalte verwendet; Sie können auch den Spaltennamen angeben:

use support\validation\Rule;
use support\validation\Validator;

Validator::make($data, [
    'email' => [
        Rule::unique('users', 'email_address')->ignore($user->id),
    ],
])->validate();

Zusätzliche Bedingungen hinzufügen:

use Illuminate\Database\Query\Builder;
use support\validation\Rule;
use support\validation\Validator;

Validator::make($data, [
    'email' => [
        Rule::unique('users')->where(
            fn (Builder $query) => $query->where('account_id', 1)
        ),
    ],
])->validate();

Soft-Deleted-Datensätze ignorieren:

use support\validation\Rule;
use support\validation\Validator;

Validator::make($data, [
    'email' => [Rule::unique('users')->withoutTrashed()],
])->validate();

Wenn die Soft-Delete-Spalte nicht deleted_at ist:

use support\validation\Rule;
use support\validation\Validator;

Validator::make($data, [
    'email' => [Rule::unique('users')->withoutTrashed('was_deleted_at')],
])->validate();

uppercase

Das Feld muss in Großbuchstaben sein.

url

Das Feld muss eine gültige URL sein.

Sie können erlaubte Protokolle angeben:

Validator::make($data, [
    'url' => 'url:http,https',
    'game' => 'url:minecraft,steam',
])->validate();

ulid

Das Feld muss eine gültige ULID sein.

uuid

Das Feld muss eine gültige RFC-9562-UUID sein (Version 1, 3, 4, 5, 6, 7 oder 8).

Sie können die Version angeben:

Validator::make($data, [
    'uuid' => 'uuid:4',
])->validate();

Validator top-think/think-validate

Beschreibung

Offizieller ThinkPHP-Validator

Projekt-URL

https://github.com/top-think/think-validate

Installation

composer require topthink/think-validate

Schnellstart

Erstellen Sie app/index/validate/User.php

<?php
namespace app\index\validate;

use think\Validate;

class User extends Validate
{
    protected $rule =   [
        'name'  => 'require|max:25',
        'age'   => 'number|between:1,120',
        'email' => 'email',    
    ];

    protected $message  =   [
        'name.require' => 'Name is required',
        'name.max'     => 'Name cannot exceed 25 characters',
        'age.number'   => 'Age must be a number',
        'age.between'  => 'Age must be between 1 and 120',
        'email'        => 'Invalid email format',    
    ];

}

Verwendung

$data = [
    'name'  => 'thinkphp',
    'email' => 'thinkphp@qq.com',
];

$validate = new \app\index\validate\User;

if (!$validate->check($data)) {
    var_dump($validate->getError());
}

Hinweis
webman unterstützt die Methode Validate::rule() von think-validate nicht

Validator workerman/validation

Beschreibung

Dieses Projekt ist eine lokalisierte Version von https://github.com/Respect/Validation

Projekt-URL

https://github.com/walkor/validation

Installation

composer require workerman/validation

Schnellstart

<?php
namespace app\controller;

use support\Request;
use Respect\Validation\Validator as v;
use support\Db;

class IndexController
{
    public function index(Request $request)
    {
        $data = v::input($request->post(), [
            'nickname' => v::length(1, 64)->setName('Nickname'),
            'username' => v::alnum()->length(5, 64)->setName('Username'),
            'password' => v::length(5, 64)->setName('Password')
        ]);
        Db::table('user')->insert($data);
        return json(['code' => 0, 'msg' => 'ok']);
    }
}  

Zugriff über jQuery

  $.ajax({
      url : 'http://127.0.0.1:8787',
      type : "post",
      dataType:'json',
      data : {nickname:'Tom', username:'tom cat', password: '123456'}
  });

Ergebnis:

{"code":500,"msg":"Username may only contain letters (a-z) and numbers (0-9)"}

Erklärung:

v::input(array $input, array $rules) validiert und sammelt Daten. Bei Validierungsfehlern wird Respect\Validation\Exceptions\ValidationException geworfen; bei Erfolg werden die validierten Daten (Array) zurückgegeben.

Wenn der Geschäftscode die Validierungsausnahme nicht abfängt, fängt das Webman-Framework sie ab und gibt JSON (z. B. {"code":500, "msg":"xxx"}) oder eine normale Ausnahmeseite basierend auf den HTTP-Headern zurück. Wenn das Antwortformat Ihren Anforderungen nicht entspricht, können Sie ValidationException abfangen und benutzerdefinierte Daten zurückgeben, wie im folgenden Beispiel:

<?php
namespace app\controller;

use support\Request;
use Respect\Validation\Validator as v;
use Respect\Validation\Exceptions\ValidationException;

class IndexController
{
    public function index(Request $request)
    {
        try {
            $data = v::input($request->post(), [
                'username' => v::alnum()->length(5, 64)->setName('Username'),
                'password' => v::length(5, 64)->setName('Password')
            ]);
        } catch (ValidationException $e) {
            return json(['code' => 500, 'msg' => $e->getMessage()]);
        }
        return json(['code' => 0, 'msg' => 'ok', 'data' => $data]);
    }
}

Validator-Anleitung

use Respect\Validation\Validator as v;

// Einzelne Regelvalidierung
$number = 123;
v::numericVal()->validate($number); // true

// Verkettete Validierung
$usernameValidator = v::alnum()->noWhitespace()->length(1, 15);
$usernameValidator->validate('alganet'); // true

// Ersten Validierungsfehlergrund abrufen
try {
    $usernameValidator->setName('Username')->check('alg  anet');
} catch (ValidationException $exception) {
    echo $exception->getMessage(); // Username may only contain letters (a-z) and numbers (0-9)
}

// Alle Validierungsfehlergründe abrufen
try {
    $usernameValidator->setName('Username')->assert('alg  anet');
} catch (ValidationException $exception) {
    echo $exception->getFullMessage();
    // Gibt aus
    // -  Username must satisfy the following rules
    //     - Username may only contain letters (a-z) and numbers (0-9)
    //     - Username must not contain whitespace

    var_export($exception->getMessages());
    // Gibt aus
    // array (
    //   'alnum' => 'Username may only contain letters (a-z) and numbers (0-9)',
    //   'noWhitespace' => 'Username must not contain whitespace',
    // )
}

// Benutzerdefinierte Fehlermeldungen
try {
    $usernameValidator->setName('Username')->assert('alg  anet');
} catch (ValidationException $exception) {
    var_export($exception->getMessages([
        'alnum' => 'Username may only contain letters and numbers',
        'noWhitespace' => 'Username must not contain spaces',
        'length' => 'length satisfies the rule, so this will not be shown'
    ]));
    // Gibt aus 
    // array(
    //    'alnum' => 'Username may only contain letters and numbers',
    //    'noWhitespace' => 'Username must not contain spaces'
    // )
}

// Objekt validieren
$user = new stdClass;
$user->name = 'Alexandre';
$user->birthdate = '1987-07-01';
$userValidator = v::attribute('name', v::stringType()->length(1, 32))
                ->attribute('birthdate', v::date()->minAge(18));
$userValidator->validate($user); // true

// Array validieren
$data = [
    'parentKey' => [
        'field1' => 'value1',
        'field2' => 'value2'
        'field3' => true,
    ]
];
v::key(
    'parentKey',
    v::key('field1', v::stringType())
        ->key('field2', v::stringType())
        ->key('field3', v::boolType())
    )
    ->assert($data); // Kann auch check() oder validate() verwenden

// Optionale Validierung
v::alpha()->validate(''); // false 
v::alpha()->validate(null); // false 
v::optional(v::alpha())->validate(''); // true
v::optional(v::alpha())->validate(null); // true

// Negationsregel
v::not(v::intVal())->validate(10); // false

Unterschied zwischen den Validator-Methoden validate() check() assert()

validate() gibt einen Boolean zurück, wirft keine Ausnahme

check() wirft bei Validierungsfehlern eine Ausnahme; ersten Fehlergrund über $exception->getMessage() abrufen

assert() wirft bei Validierungsfehlern eine Ausnahme; alle Fehlergründe über $exception->getFullMessage() abrufen

Häufig verwendete Validierungsregeln

Alnum() Nur Buchstaben und Zahlen

Alpha() Nur Buchstaben

ArrayType() Array-Typ

Between(mixed $minimum, mixed $maximum) Validiert, dass die Eingabe zwischen zwei Werten liegt.

BoolType() Validiert Boolean-Typ

Contains(mixed $expectedValue) Validiert, dass die Eingabe einen bestimmten Wert enthält

ContainsAny(array $needles) Validiert, dass die Eingabe mindestens einen definierten Wert enthält

Digit() Validiert, dass die Eingabe nur Ziffern enthält

Domain() Validiert gültigen Domänennamen

Email() Validiert gültige E-Mail-Adresse

Extension(string $extension) Validiert Dateierweiterung

FloatType() Validiert Float-Typ

IntType() Validiert Integer-Typ

Ip() Validiert IP-Adresse

Json() Validiert JSON-Daten

Length(int $min, int $max) Validiert, dass die Länge im Bereich liegt

LessThan(mixed $compareTo) Validiert, dass die Länge kleiner als der angegebene Wert ist

Lowercase() Validiert Kleinbuchstaben

MacAddress() Validiert MAC-Adresse

NotEmpty() Validiert nicht leer

NullType() Validiert null

Number() Validiert Zahl

ObjectType() Validiert Objekttyp

StringType() Validiert String-Typ

Url() Validiert URL

Weitere Validierungsregeln unter https://respect-validation.readthedocs.io/en/2.0/list-of-rules/

Mehr

Besuchen Sie https://respect-validation.readthedocs.io/en/2.0/