Startseite>PHP-Quellcode>Andere Kategorien
Herunterladen

mighty

Die letzte Validierungsbibliothek, die Sie jemals brauchen werden!


Inhaltsverzeichnis

Installation
Ungefähr mighty
Schnellstart
mVEL
Beispiele
Einschränkungen
Validierungen
Dokumentation
Spezifikation
Änderungsprotokoll


Wenn Ihnen dieses Projekt gefällt und Sie seine Entwicklung unterstützen möchten, freuen wir uns über eine Spende!


Hauptmerkmale

  1. Keine Abhängigkeiten.
  2. Framework-unabhängig, kann in jede Codebasis integriert werden.
  3. Ausdrucksstark, intuitiv und einfach zu bedienen mit über 250 integrierten Validierungsregeln.

<span class= mächtige Demo" style="max-width: 100%;">

Installation 

composer require marwanalsoltany/ mighty

Ungefähr mighty

Die Validierung ist eine häufige Aufgabe in jeder Webanwendung. Daten, die über Formulare – oder jede Art von Eingabe – an die Anwendung übergeben werden, müssen immer anhand einer Reihe von Regeln validiert werden. mighty kann auf einfache und ausdrucksstarke Weise damit umgehen.

mighty ist eine schnelle, leistungsstarke, robuste und benutzerfreundliche Validierungsbibliothek, mit der die Arbeit einfach Spaß macht und die Validierung aller Daten zum Kinderspiel macht. Dank der Leistungsfähigkeit der mighty Validation Expression Language (mVEL) ist es mit nichts zu vergleichen, was Sie bisher gesehen haben. Mit seinem Validierungsansatz und über 250 integrierten Regeln gibt es so gut wie nichts, was Sie damit nicht validieren können, und zwar auf eine sehr ausdrucksstarke und kompakte Art und Weise. Einfach ausgedrückt: Die Validierung von Steroiden ist mighty ! Es ist in der Tat die letzte Validierungsbibliothek, die Sie jemals brauchen werden.

mighty bietet verschiedene Ansätze zur Validierung von Daten. Der häufigste Anwendungsfall ist die Validierung eingehender Daten über HTTP-Anfragen, aber er ist natürlich nicht darauf beschränkt; mighty bietet auch Attribute in Form von Einschränkungen, um Modelle und/oder Objekte jeglicher Art einfach zu validieren.

mighty umfasst eine Vielzahl praktischer Validierungsregeln, die Sie als einzelne Regel anwenden oder mithilfe von Operatoren miteinander kombinieren können, um noch komplexere Validierungen zu erstellen.

Schnellstart

Um mehr über die leistungsstarken Validierungsfunktionen von mighty zu erfahren, kommen wir gleich auf den Punkt und schauen uns einige Beispiele an:

Allgemeine Datenvalidierung

Formulardaten mit der Validator::class validieren:

mightyValidator; $validator = new Validator(); $validator ->setData([ 'name' => 'John Doe', 'username' => 'john.doe', 'password' => 'Super@Secret#123', 'email' => '[email protected]', 'hobbies' => ['coding', 'design', 'sports'], ]) ->setValidations([ // required&string&between:3,255 'name' => $validator->validation()->required()->string()->between(3, 255), // required&string&matches:/[a-z0-9._-]/i 'username' => $validator->validation()->required()->string()->matches('/[a-z0-9._-]/i'), // required&string&min:8 'password' => $validator->validation()->required()->string()->min(8), // required&email 'email' => $validator->validation()->required()->email(), // null^(required&array&max:5) 'hobbies' => $validator ->validation() ->null() ->xor() ->group(fn ($validation) => $validation ->array() ->max(5) ), // null|(if:${hobbies.validations.array}&(string&min:3)) // hobby can be null or a string with at least 3 characters if hobbies is an array 'hobbies.*' => $validator ->validation() ->null() ->or() ->group(fn ($validation) => $validation ->if('${hobbies.validations.array}') ->open() ->string() ->min(3) ->close() ), ]) ->validate(); $result = $validator->isOK(); // boolean result of the overall validation result $errors = $validator->getErrors(); // an array of results of validations that failed $results = $validator->getResults(); // an array of results of all validations $validator->check(); // void or throws an exception with a nicely formatted message of what exactly went wrong ">
 use MAKS  mighty  Validator ;

$ validator = new Validator ();

$ validator
    -> setData ([
        ' name '     => ' John Doe ' ,
        ' username ' => ' john.doe ' ,
        ' password ' => ' Super@Secret#123 ' ,
        ' email '    => ' [email protected] ' ,
        ' hobbies '  => [ ' coding ' , ' design ' , ' sports ' ],
    ])
    -> setValidations ([
        // required&string&between:3,255
        ' name '      => $ validator -> validation ()-> required ()-> string ()-> between ( 3 , 255 ),
        // required&string&matches:/[a-z0-9._-]/i
        ' username '  => $ validator -> validation ()-> required ()-> string ()-> matches ( ' /[a-z0-9._-]/i ' ),
        // required&string&min:8
        ' password '  => $ validator -> validation ()-> required ()-> string ()-> min ( 8 ),
        // required&email
        ' email '     => $ validator -> validation ()-> required ()-> email (),
        // null^(required&array&max:5)
        ' hobbies '   => $ validator
            -> validation ()
            -> null ()
            -> xor ()
            -> group ( fn ( $ validation ) => $ validation
                -> array ()
                -> max ( 5 )
            ),
        // null|(if:${hobbies.validations.array}&(string&min:3))
        // hobby can be null or a string with at least 3 characters if hobbies is an array
        ' hobbies.* ' => $ validator
            -> validation ()
            -> null ()
            -> or ()
            -> group ( fn ( $ validation ) => $ validation
                -> if ( ' ${hobbies.validations.array} ' )
                -> open ()
                -> string ()
                -> min ( 3 )
                -> close ()
            ),
    ])
    -> validate ();

$ result = $ validator -> isOK (); // boolean result of the overall validation result

$ errors = $ validator -> getErrors (); // an array of results of validations that failed

$ results = $ validator -> getResults (); // an array of results of all validations

$ validator -> check (); // void or throws an exception with a nicely formatted message of what exactly went wrong

Objektvalidierung

Validieren des Status eines Objekts mithilfe von Constraint::class Attributen:

mightyValidationStrategy; use MAKS mighty ValidationBehavior; use MAKS mighty ValidationOperator; use MAKS mighty ValidationConstraint; use MAKS mighty ValidationConstraint as Assert; use MAKS mighty ValidationConstraintValidatableObjectInterface; use MAKS mighty ValidationConstraintValidatableObjectTrait; class ValidatableObject implements ValidatableObjectInterface { use ValidatableObjectTrait; #[AssertRuleEquals('CONST')] public const CONST = 'CONST'; #[AssertRuleIn(['STATIC', 'VAR'])] public static $static = 'VAR'; #[AssertRuleStringConstraint] #[AssertRuleStringCharset('UTF-8')] #[AssertRuleBetween(3, 99)] public $default = 'DEFAULT'; #[AssertRuleStringConstraint] #[AssertRuleStringContains('<element>')] #[AssertRuleXml] public $xml = '<?xml version="1.0"?><element></element>'; #[AssertRuleArrayConstraint] #[AssertShape([ 'string' => new AssertRuleStr, 'array' => new AssertRuleArr, ])] public $array = [ 'string' => 'value', 'array' => [], ]; #[AssertRuleObjectConstraint] #[AssertRuleObjectIsInstanceOf(ValidatableObjectInterface::class)] #[AssertValid(message: 'Not valid')] public $object; #[AssertCallback('is_scalar', 'Data is not scalar')] #[Constraint('string&min:3', strategy: Strategy::FailLazy, messages: [ 'string' => 'Must be string.', 'min' => 'Must be longer than ${@arguments.0}.', ])] public function getDefault() { return $this->default; } #[AssertCompound([ new AssertRuleStr, new AssertCompound([ new AssertRuleArr, new AssertCompound([ new AssertRuleBlank, ], Operator::Not), ], Operator::And), ], Operator::Xor, Behavior::Pessimistic, Strategy::FailLazy)] public static function getStaticProperty() { return static::$static; } } $object = new ValidatableObject(); $result = $object->isValid(); // boolean result of the overall validation result $results = $object->validate(); // an array of results of all validations $object->check(); // void or throws an exception with a nicely formatted message of what exactly went wrong ">
 use MAKS  mighty  Validation  Strategy ;
use MAKS  mighty  Validation  Behavior ;
use MAKS  mighty  Validation  Operator ;
use MAKS  mighty  Validation  Constraint ;
use MAKS  mighty  Validation  Constraint as Assert ;
use MAKS  mighty  Validation  Constraint  ValidatableObjectInterface ;
use MAKS  mighty  Validation  Constraint  ValidatableObjectTrait ;


class ValidatableObject implements ValidatableObjectInterface
{
    use ValidatableObjectTrait;


    #[ Assert  Rule Equals( ' CONST ' )]
    public const CONST = ' CONST ' ;

    #[ Assert  Rule In([ ' STATIC ' , ' VAR ' ])]
    public static $ static = ' VAR ' ;

    #[ Assert  Rule StringConstraint]
    #[ Assert  Rule StringCharset( ' UTF-8 ' )]
    #[ Assert  Rule Between( 3 , 99 )]
    public $ default = ' DEFAULT ' ;

    #[ Assert  Rule StringConstraint]
    #[ Assert  Rule StringContains( ' <element> ' )]
    #[ Assert  Rule Xml]
    public $ xml = ' <?xml version="1.0"?><element></element> ' ;

    #[ Assert  Rule ArrayConstraint]
    #[ Assert Shape([
        ' string ' => new Assert  Rule  Str ,
        ' array '  => new Assert  Rule  Arr ,
    ])]
    public $ array = [
        ' string ' => ' value ' ,
        ' array '  => [],
    ];

    #[ Assert  Rule ObjectConstraint]
    #[ Assert  Rule ObjectIsInstanceOf(ValidatableObjectInterface::class)]
    #[ Assert Valid(message: ' Not valid ' )]
    public $ object ;

    #[ Assert Callback( ' is_scalar ' , ' Data is not scalar ' )]
    #[Constraint( ' string&min:3 ' , strategy: Strategy::FailLazy, messages: [
        ' string ' => ' Must be string. ' ,
        ' min '    => ' Must be longer than ${@arguments.0}. ' ,
    ])]
    public function getDefault ()
    {
        return $ this -> default ;
    }

    #[ Assert Compound([
        new Assert  Rule  Str ,
        new Assert  Compound ([
            new Assert  Rule  Arr ,
            new Assert  Compound ([
                new Assert  Rule  Blank ,
            ], Operator::Not),
        ], Operator::And),
    ], Operator::Xor, Behavior::Pessimistic, Strategy::FailLazy)]
    public static function getStaticProperty ()
    {
        return static :: $ static ;
    }
}

$ object = new ValidatableObject ();

$ result = $ object -> isValid (); // boolean result of the overall validation result

$ results = $ object -> validate (); // an array of results of all validations

$ object -> check (); // void or throws an exception with a nicely formatted message of what exactly went wrong

Ein Beispiel für die Ausgabe der Validierung eines validierbaren Objekts würde wie folgt aussehen: 

 // check out the previous snippet see the used constraints

$ object = new ValidatableObject ();
$ object -> object = new class implements ValidatableObjectInterface {
    use ValidatableObjectTrait;
    // some properties and their validation constraints ...
};
$ object -> default = null ; // this must be a string

$ object -> check ();

// ValidationFailedException::class
// Data failed to pass the validation.
// (01) The value (null) of the "ValidatableObject->default" property failed to pass the validation [string]. Problem: Value must be a string.
// (02) The value (null) of the "ValidatableObject->default" property failed to pass the validation [string.charset:"UTF-8"]. Problem: Value must be encoded in one of the following charsets: ["UTF-8"].
// (03) The value (null) of the "ValidatableObject->default" property failed to pass the validation [between:3,99]. Problem: Value must be between 3 and 99 or have a value/count/length that is between 3 and 99.
// (04) The return value (null) of the "ValidatableObject->getDefault()" method failed to pass the validation [callback]. Problem: Data is not scalar.
// (05) The return value (null) of the "ValidatableObject->getDefault()" method failed to pass the validation [string&min:3]. Problems: Must be string; Must be longer than 3.

Überprüfen Sie auch ValidatableObject und ValidatableObjectChild .

■ Hinweis: Weitere Beispiele finden Sie im Abschnitt Beispiele.

mighty Validierungsausdruckssprache

mighty hat das Konzept des Validierungsausdrucks. Der Validierungsausdruck in seiner einfachsten Form ist nur eine Zeichenfolge, die beschreibt, wie mighty die angegebenen Daten validiert werden sollen. Diese Zeichenfolgen basieren auf der mighty Validation Expression Language Specification (mVEL). mVEL ist ziemlich einfach, für Menschen lesbar und leicht zu handhaben. Es handelt sich um eine Kombination gut etablierter Konzepte und/oder Spezifikationen wie Boolesche Algebra, bitweise Operatoren, JSON und CSV.

Daher kann der Validierungsausdruck als eine Zeichenfolge definiert werden, die einige durch bitweise Operatoren getrennte Regeln enthält, die einen Ausdruck erstellen, der bei Auswertung mithilfe der Booleschen Algebra- Logik zum Endergebnis der Validierung führt. Die Regeln können Argumente haben, die Typen dieser Argumente können mit denselben Regeln wie JSON- Typen bezeichnet werden. Eine Regel kann auch mehrere Argumente haben und die Argumente werden durch Kommas ( CSV ) getrennt.

Beispielsweise ist required&string&between:2,255|null ein gültiger Validierungsausdruck. Dieser Ausdruck kann wie folgt verstanden werden:

  1. Der Ausdruck hat vier Regeln.
  2. Der Ausdruck enthält die Regeln:
    1. required Bestätigt, dass die Eingabe vorhanden ist.
    2. string Bestätigt, dass die Eingabe eine Zeichenfolge ist.
    3. between:2,255 Bestätigt, dass die Eingabe eine Zeichenfolge mit einer Länge zwischen 2 und 255 ist.
    4. null Bestätigt, dass die Eingabe null ist.
  3. Das Endergebnis ist das Ergebnis der Auswertung des Ausdrucks, der sich aus dem Ergebnis jeder durch bitweisen Operatoren zusammengefügten Regel ergibt.

Der required&string&between:2,255|null -Ausdruck bedeutet, dass die Eingabe vorhanden sein muss; AND vom Typ string; UND zwischen 2 und 255 lang; ODER null. Es handelt sich also um eine nullbare Zeichenfolge, die zwischen 2 und 255 Zeichen lang sein muss, wenn sie nicht null ist.

Nehmen wir an, die Eingabe lautete " mighty is Awesome!" , wäre das Ergebnis des Ausdrucks required&string&between:2,255|null für diese Eingabe 1&1&1|0 was zu 1 führt, was true ist. Wenn die Eingabe null wäre, wäre das Ergebnis 0&0&0|1 = 1 , wenn die Eingabe X das Ergebnis wäre wäre 0&0&0|0 = 0 usw.

Im Gegensatz zu anderen Validierungsimplementierungen bietet das Konzept der Booleschen Algebra mit bitweisen Operatoren die Möglichkeit, komplexe Validierungen zu erstellen, die sehr gut lesbar und kompakt sind und gleichzeitig die Anzahl der Regeln auf ein Minimum beschränken, vorhandene Logik in umgekehrter oder zusammengesetzter Weise wiederverwenden und schließlich die Regeln beibehalten Codebasis so trocken wie möglich. Die Vorteile lassen sich in folgenden Punkten zusammenfassen:

  1. Eine Regel kann NICHT so bearbeitet werden (mit ~ ), dass sie genau das Gegenteil von dem bewirkt, was sie normalerweise tut.
  2. Eine komplexe Regel kann das Ergebnis einer UND -Verknüpfung (mit & ), einer ODER -Verknüpfung (mit | ) oder einer XOR- Verknüpfung (mit ^ ) von zwei oder mehr einfachen Regeln sein.
  3. Regeln können durch die Verwendung von Klammern gruppiert und/oder mit höherer Priorität versehen werden, nämlich OPEN (mithilfe von ( ) und CLOSE (mithilfe von ) ).
  4. Ein Validierungsausdruck kann auch ein Verhalten haben, bei dem es sich um ein Zeichen handelt, das der Zeichenfolge des Validierungsausdrucks vorangestellt wird und sich auf alle Regeln auswirkt. Verfügbare Verhaltensweisen sind:
    1. NORMAL : Alle Regeln ausführen, Standardverhalten (kein Präfix).
    2. OPTIMISTISCH : Stoppen Sie die Ausführung von Regeln nach dem ersten Erfolg (Präfix ? ).
    3. PESSIMISTISCH : Stoppen Sie die Ausführung von Regeln nach dem ersten Fehler (Präfix ! ).
  5. Die Lesbarkeit kann verbessert werden, indem man einige Regeln mit Aliasnamen versehen oder Regelsätze als Makros hinzufügt und diese mit der [macro] -Syntax ausführt.

Außerdem gewährleistet das Konzept von JSON die Sicherheit der Argumentdatentypen, und das Konzept von CSV stellt sicher, dass die Argumentliste über klare Parsing-Regeln verfügt.

Das Beste daran ist, dass Sie sich weder alle Regeln noch die Syntax der Validation Expression Language merken müssen. Die Validation Klasse ist eine fließende Schnittstelle, die zum Erstellen eines Validierungsausdrucks verwendet werden kann. Es kennt alle mighty verfügbaren Regeln und verfügt über vollständige IDE-Intellisense-Unterstützung, um es so einfach wie möglich zu machen. Zum Beispiel:

mightyValidation; // the validation expression: `required&string&between:2,255|null` // can be constructed using the Validation::class as follows: $validation = (new Validation())->required()->string()->between(2, 255)->or()->null(); // AND is the default operator // or statically: $validation = Validation::required()->string()->between(2, 255)->or()->null(); ">
 use MAKS  mighty  Validation ;

// the validation expression: `required&string&between:2,255|null`
// can be constructed using the Validation::class as follows:
$ validation = ( new Validation ())-> required ()-> string ()-> between ( 2 , 255 )-> or ()-> null (); // AND is the default operator
// or statically:
$ validation = Validation:: required ()-> string ()-> between ( 2 , 255 )-> or ()-> null ();

■ Tatsache: Um zu beschreiben, was ein Validierungsausdruck tut, sind normalerweise mehr Worte erforderlich als der Validierungsausdruck selbst!

Beispiele

Hier sind einige Beispiele realer Szenarien:

Validieren eines einzelnen Werts

mightyValidator; $result = ($validator = new Validator()) ->validateOne( '123', $validator ->validation() // can be an integer or float or a string that is numeric // this example is only for demonstration only, // the same result can be achieved using numeric() only ->integer()->or()->float()->or()->group( fn ($validation) => $validation->string()->and()->numeric() ) ) ->toArray(); // $result would look something like this: [ 'value' => '123', 'result' => true, 'validations' => [ 'integer' => false, 'float' => false, 'string' => true, 'numeric' => true, ], 'errors' => [], 'metadata' => [ 'basis' => 'integer|float|(string&numeric)', 'rules' => 'integer|float|(string&numeric)', 'expression' => '0|0|(1&1)', ], ]; // you can also simply use the static helper Validator::validateData($data, $validation);">
 use MAKS  mighty  Validator ;

$ result = ( $ validator = new Validator ())
    -> validateOne (
        ' 123 ' ,
        $ validator
            -> validation ()
            // can be an integer or float or a string that is numeric
            // this example is only for demonstration only,
            // the same result can be achieved using numeric() only
            -> integer ()-> or ()-> float ()-> or ()-> group (
                fn ( $ validation ) => $ validation -> string ()-> and ()-> numeric ()
            )
    )
    -> toArray ();

// $result would look something like this:
[
    ' value ' => ' 123 ' ,
    ' result ' => true ,
    ' validations ' => [
        ' integer ' => false ,
        ' float ' => false ,
        ' string ' => true ,
        ' numeric ' => true ,
    ],
    ' errors ' => [],
    ' metadata ' => [
        ' basis ' => ' integer|float|(string&numeric) ' ,
        ' rules ' => ' integer|float|(string&numeric) ' ,
        ' expression ' => ' 0|0|(1&1) ' ,
    ],
];

// you can also simply use the static helper Validator::validateData($data, $validation);

Validierung strukturierter Daten

mightyValidator; use AppServiceHaveIBeenPwnedService as PasswordService; $validator = new Validator(); $data = [ 'name' => 'John Doe', 'age' => 32, 'email' => '[email protected]', 'username' => 'john.doe', 'password' => 'Secret@123', 'image' => '/path/to/image.png', 'submission' => 'now', 'consent' => 'yes', 'data' => [ 'nickname' => 'JOE', 'number' => 7, 'hobbies' => [ 'coding', 'cooking', 'reading', ] ], ]; $validations = [ 'name' => $validator->validation()->required()->string()->stringCharset(['UTF-8', 'ASCII'])->pessimistic(), // or using mVEL => required&string&string.charset:'["UTF-8","ASCII"]' 'age' => $validator->validation()->required()->integer()->min(18), // or using mVEL => required&integer&min:18 'email' => $validator->validation()->required()->email()->macro('gmail'), // or using mVEL => required&email&[gmail] 'username' => $validator->validation()->required()->username(), // or using mVEL => required&username 'password' => $validator->validation()->required()->password()->callback(fn ($input) => !PasswordService::isPwned($input)), // or using mVEL => required&password (NOTE: callback ist not possible, it requires a Validation::class instance that is bound to the Validator::class instance) 'image' => $validator->validation()->null()->xor()->group(fn () => $this->image()->imageDimensions(1920, 1080, '<=')), // or using mVEL => null^(image&image.dimensions:1920,1080,"<=") 'submission' => $validator->validation()->required()->datetime()->datetimeLt('2022-12-07'), // or using mVEL => required&datetime&datetime.lt:"2022-12-07" 'consent' => $validator->validation()->assert('${age.value}', 18, '>=')->or()->accepted()->or()->assertEquals('${this}', 'granted')->optimistic(), // or using mVEL => ?assert:${age.value},18,">="|accepted|assert.equals:${this},"granted" 'data' => $validator->validation()->required()->array()->arrayHasKey('nickname'), // or using mVEL => required&array&array.hasKey:"nickname" 'data.*' => $validator->validation()->scalar()->or()->array()->optimistic(), // or using mVEL => ?scalar|array 'data.nickname' => $validator->validation()->string()->min(2)->max(32), // or using mVEL => string&min:2&max:32 'data.hobbies.*' => $validator->validation()->ifEq('${data.hobbies.validations.array}', false)->or()->group(fn () => $this->string()->min(3)), // or using mVEL => if.eq:${data.hobbies.validations.array},false|(string&min:3) ]; $labels = [ 'name' => 'Name', 'age' => 'Age', 'email' => 'E-Mail', 'password' => 'Password', 'image' => 'Image', 'data' => 'Data', 'data.*' => 'Value of data', 'consent' => 'Consent', ]; $messages = [ '*' => [ // this will be expanded for all fields 'required' => '${@label} is a required field.', ], 'age' => [ 'min' => '${@label} must be at least ${@arguments.0}.', ], 'username' => [ 'matches' => '${@label} must contain letters, numbers, and the following characters ".-_" only.', ], 'consent' => [ 'assert' => 'You must be at least ${@arguments.1} years old to submit this form.', ] ]; $validator ->setData($data) ->setValidations($validations) ->setMessages($messages) ->setLabels($labels) ->validate(); $results = $validator->getResults(); // $result should look something like this: [ // this will actually be a Result object // array syntax is used here for demonstration purposes 'name' => [ 'key' => 'name', 'value' => 'John Doe', 'result' => true, 'validations' => [ 'required' => true, 'string' => true, 'string.charset' => true, ], 'errors' => [], 'metadata' => [ 'basis' => '!required&string&string.charset:["UTF-8","ASCII"]', 'rules' => 'required&string&string.charset:["UTF-8","ASCII"]', 'expression' => '1&1&1', ], ], // other validations ... ]; // you can also simply use the static helper Validator::validateData($data, $validations);">
 use MAKS  mighty  Validator ;
use App  Service  HaveIBeenPwnedService as PasswordService ;

$ validator = new Validator ();

$ data = [
    ' name '       => ' John Doe ' ,
    ' age '        => 32 ,
    ' email '      => ' [email protected] ' ,
    ' username '   => ' john.doe ' ,
    ' password '   => ' Secret@123 ' ,
    ' image '      => ' /path/to/image.png ' ,
    ' submission ' => ' now ' ,
    ' consent '    => ' yes ' ,
    ' data '       => [
        ' nickname ' => ' JOE ' ,
        ' number '   => 7 ,
        ' hobbies '  => [
            ' coding ' ,
            ' cooking ' ,
            ' reading ' ,
        ]
    ],
];

$ validations = [
    ' name '           => $ validator -> validation ()-> required ()-> string ()-> stringCharset ([ ' UTF-8 ' , ' ASCII ' ])-> pessimistic (),
    // or using mVEL => required&string&string.charset:'["UTF-8","ASCII"]'
    ' age '            => $ validator -> validation ()-> required ()-> integer ()-> min ( 18 ),
    // or using mVEL => required&integer&min:18
    ' email '          => $ validator -> validation ()-> required ()-> email ()-> macro ( ' gmail ' ),
    // or using mVEL => required&email&[gmail]
    ' username '       => $ validator -> validation ()-> required ()-> username (),
    // or using mVEL => required&username
    ' password '       => $ validator -> validation ()-> required ()-> password ()-> callback ( fn ( $ input ) => !PasswordService:: isPwned ( $ input )),
    // or using mVEL => required&password (NOTE: callback ist not possible, it requires a Validation::class instance that is bound to the Validator::class instance)
    ' image '          => $ validator -> validation ()-> null ()-> xor ()-> group ( fn () => $ this -> image ()-> imageDimensions ( 1920 , 1080 , ' <= ' )),
    // or using mVEL => null^(image&image.dimensions:1920,1080,"<=")
    ' submission '     => $ validator -> validation ()-> required ()-> datetime ()-> datetimeLt ( ' 2022-12-07 ' ),
    // or using mVEL => required&datetime&datetime.lt:"2022-12-07"
    ' consent '        => $ validator -> validation ()-> assert ( ' ${age.value} ' , 18 , ' >= ' )-> or ()-> accepted ()-> or ()-> assertEquals ( ' ${this} ' , ' granted ' )-> optimistic (),
    // or using mVEL => ?assert:${age.value},18,">="|accepted|assert.equals:${this},"granted"
    ' data '           => $ validator -> validation ()-> required ()-> array ()-> arrayHasKey ( ' nickname ' ),
    // or using mVEL => required&array&array.hasKey:"nickname"
    ' data.* '         => $ validator -> validation ()-> scalar ()-> or ()-> array ()-> optimistic (),
    // or using mVEL => ?scalar|array
    ' data.nickname '  => $ validator -> validation ()-> string ()-> min ( 2 )-> max ( 32 ),
    // or using mVEL => string&min:2&max:32
    ' data.hobbies.* ' => $ validator -> validation ()-> ifEq ( ' ${data.hobbies.validations.array} ' , false )-> or ()-> group ( fn () => $ this -> string ()-> min ( 3 )),
    // or using mVEL => if.eq:${data.hobbies.validations.array},false|(string&min:3)
];

$ labels = [
    ' name '     => ' Name ' ,
    ' age '      => ' Age ' ,
    ' email '    => ' E-Mail ' ,
    ' password ' => ' Password ' ,
    ' image '    => ' Image ' ,
    ' data '     => ' Data ' ,
    ' data.* '   => ' Value of data ' ,
    ' consent '  => ' Consent ' ,
];

$ messages = [
    ' * ' => [ // this will be expanded for all fields
        ' required ' => ' ${@label} is a required field. ' ,
    ],
    ' age ' => [
        ' min ' => ' ${@label} must be at least ${@arguments.0}. ' ,
    ],
    ' username ' => [
        ' matches ' => ' ${@label} must contain letters, numbers, and the following characters ".-_" only. ' ,
    ],
    ' consent ' => [
        ' assert ' => ' You must be at least ${@arguments.1} years old to submit this form. ' ,
    ]
];

$ validator
    -> setData ( $ data )
    -> setValidations ( $ validations )
    -> setMessages ( $ messages )
    -> setLabels ( $ labels )
    -> validate ();

$ results = $ validator -> getResults ();

// $result should look something like this:
[
    // this will actually be a Result object
    // array syntax is used here for demonstration purposes
    ' name ' => [
        ' key ' => ' name ' ,
        ' value ' => ' John Doe ' ,
        ' result ' => true ,
        ' validations ' => [
            ' required ' => true ,
            ' string ' => true ,
            ' string.charset ' => true ,
        ],
        ' errors ' => [],
        ' metadata ' => [
            ' basis ' => ' !required&string&string.charset:["UTF-8","ASCII"] ' ,
            ' rules ' => ' required&string&string.charset:["UTF-8","ASCII"] ' ,
            ' expression ' => ' 1&1&1 ' ,
        ],
    ],
    // other validations ...
];

// you can also simply use the static helper Validator::validateData($data, $validations);

■ Hinweis: Wenn Sie Nachrichtenüberschreibungen für die Validator::class bereitstellen, wird empfohlen, RuleValidation::class zum Festlegen von Array-Schlüsseln zu verwenden. Diese Klasse enthält alle mighty integrierten Regelnamen als Klassenkonstanten.

Erweiterung des Validators

Der Validator kann auf drei Arten erweitert werden:

  • Durch Hinzufügen einer Regel.
  • Durch Hinzufügen eines Alias.
  • Durch Hinzufügen eines Makros.
mightyValidator; use MAKS mighty Rule; $validator = new Validator(); // adding a new rule $validator->addRule( (new Rule()) ->name('equals') ->arguments(['string']) ->callback(fn (string $input, mixed $expected): bool => $input == $expected) ->parameters(['@input', '@arguments.0']) ->comparison(['@output', '===', true]) ->example('equals:value') ->description('Asserts that the input is equal to the given value.') ); // adding a new rule alias $validator->addRuleAlias('eq', 'equals'); // adding a new rules macro $validator->addRuleMacro('gmail', 'string&email&matches:"/@gmail.com$/i"'); $results = $validator->validateAll( [ 'name' => 'John', 'email' => '[email protected]', ], [ 'name' => 'eq:John', 'email' => 'required&[gmail]', ] ); // $results should look like this: [ // items will actually be a Result object // array syntax is used here for demonstration purposes 'name' => [ 'key' => 'name', 'value' => 'John', 'result' => true, 'validations' => [ 'eq' => true, ], 'errors' => [], 'metadata' => [ 'basis' => 'eq:John', 'rules' => 'eq:John', 'expression' => '1', ], ], 'email' => [ 'key' => 'email', 'value' => '[email protected]', 'result' => false, 'validations' => [ 'required' => true, 'string' => true, 'email' => true, 'matches' => false, ],, 'errors' => [], 'metadata' => [ 'basis' => 'required&[gmail]', 'rules' => 'required&(string&email&matches:"/@gmail.com$/i")', 'expression' => '1&(1&1&0)', ], ], ];">
 use MAKS  mighty  Validator ;
use MAKS  mighty  Rule ;

$ validator = new Validator ();

// adding a new rule
$ validator -> addRule (
    ( new Rule ())
        -> name ( ' equals ' )
        -> arguments ([ ' string ' ])
        -> callback ( fn ( string $ input , mixed $ expected ): bool => $ input == $ expected )
        -> parameters ([ ' @input ' , ' @arguments.0 ' ])
        -> comparison ([ ' @output ' , ' === ' , true ])
        -> example ( ' equals:value ' )
        -> description ( ' Asserts that the input is equal to the given value. ' )
);

// adding a new rule alias
$ validator -> addRuleAlias ( ' eq ' , ' equals ' );

// adding a new rules macro
$ validator -> addRuleMacro ( ' gmail ' , ' string&email&matches:"/@gmail.com$/i" ' );

$ results = $ validator -> validateAll (
    [
        ' name '  => ' John ' ,
        ' email ' => ' [email protected] ' ,
    ],
    [
        ' name '  => ' eq:John ' ,
        ' email ' => ' required&[gmail] ' ,
    ]
);

// $results should look like this:
[
    // items will actually be a Result object
    // array syntax is used here for demonstration purposes
    ' name ' => [
        ' key ' => ' name ' ,
        ' value ' => ' John ' ,
        ' result ' => true ,
        ' validations ' => [
            ' eq ' => true ,
        ],
        ' errors ' => [],
        ' metadata ' => [
            ' basis ' => ' eq:John ' ,
            ' rules ' => ' eq:John ' ,
            ' expression ' => ' 1 ' ,
        ],
    ],
    ' email ' => [
        ' key ' => ' email ' ,
        ' value ' => ' [email protected] ' ,
        ' result ' => false ,
        ' validations ' => [
            ' required ' => true ,
            ' string ' => true ,
            ' email ' => true ,
            ' matches ' => false ,
        ],,
        ' errors ' => [],
        ' metadata ' => [
            ' basis ' => ' required&[gmail] ' ,
            ' rules ' => ' required&(string&email&matches:"/@gmail.com$/i") ' ,
            ' expression ' => ' 1&(1&1&0) ' ,
        ],
    ],
];

■ Hinweis: Schauen Sie sich die rules , aliases und macros des Validator an, um weitere Beispiele zu sehen.

Einschränkungen

mighty besteht aus über 250 Regeln/Attributen, die zur Validierung beliebiger Daten oder der Werte von Klassen, Klassenkonstanten, Eigenschaften und Methoden verwendet werden können.

Die Attribute sind in drei Hauptgruppen unterteilt:

  1. Allgemeine Einschränkungsattribute
  2. Spezielle Einschränkungsattribute
  3. Regeleinschränkungsattribute

Gruppe „Allgemeine Einschränkungsattribute“.

Die generischen Einschränkungsattribute befinden sich im Namensraum MAKS mighty Validation .

Diese Gruppe besteht derzeit nur aus einem Attribut; das ist das Constraint -Attribut. Dieses Attribut benötigt einen Validierungsausdruck, um die Daten zu validieren, auf die es angewendet wird. Sie ist auch die Basisklasse für alle anderen Attribute.

Gruppe „Spezielle Einschränkungsattribute“.

Die speziellen Einschränkungsattribute befinden sich im Namensraum MAKS mighty ValidationConstraint .

Diese Gruppe enthält Attribute, die eine bestimmte Aufgabe ausführen, die nur im Kontext von Attributen verfügbar ist. Es besteht aus folgenden Attributen:

  • Rule : Dieses Attribut wird verwendet, um alle Daten mithilfe einer einzigen Validierungsregel zu validieren. Es ist auch die Basisklasse für alle Attribute in der Regeleinschränkungsattributgruppe.
  • Callback : Dieses Attribut wird verwendet, um alle Daten mithilfe einer Rückruffunktion zu validieren.
  • Valid : Dieses Attribut wird verwendet, um die Gültigkeit eines validierbaren Objekts zu validieren.
  • Shape : Dieses Attribut wird verwendet, um die Form eines Arrays oder Objekts zu validieren. Beachten Sie, dass dies das einzige Attribut ist, das eine Reihe von Werten (strukturierte Daten) und nicht einen einzelnen Wert validiert.
  • Compound : Dieses Attribut wird verwendet, um eine Reihe von Einschränkungen zu kombinieren, um einen Validierungsausdruck zu erstellen. Die Einschränkungen können mit beliebigen Operatoren kombiniert werden und auch ein Verhalten haben. Es dient als objektorientierte Möglichkeit, einen Validierungsausdruck aufzubauen.

■ Hinweis: Beachten Sie, dass die Einschränkungen, die mit den Attributen Shape::class und Compound::class verwendet werden dürfen, tatsächliche Instanzen von Constraint::class , Rule::class oder Compound::class sein müssen. Callback::class , Valid::class oder Shape::class der Special Constraint Attributes Group sind NICHT zulässig. Wenn Sie diese Funktion benötigen, öffnen Sie ein Problem und wir besprechen die Implementierung

Gruppe „Regeleinschränkungsattribute“.

Die Regeleinschränkungsattribute befinden sich im Namensraum MAKS mighty ValidationConstraintRule .

Diese Gruppe enthält Attribute, die auf einer einzelnen Validierungsregel basieren. Es besteht aus den meisten Attributen, mighty bietet. Die vollständige Liste finden Sie im Abschnitt „Validierungen“.

Hinzufügen einer benutzerdefinierten Einschränkung

mighty verfügt über eine riesige Liste integrierter Einschränkungen. Es kommt wirklich selten vor, dass Sie etwas anderes als das benötigen, was mighty bereitstellt. Dennoch besteht manchmal Bedarf an einer benutzerdefinierten Einschränkung. So können Sie dies erreichen:

mightyRule; use MAKS mighty Result; use MAKS mighty ValidationStrategy; use MAKS mighty ValidationConstraint; use MAKS mighty ValidationConstraintValidatesOne; // use the ValidatesMany interface if your Constraint returns a collection of Result objects use MAKS mighty ValidationConstraintValidatesMany; #[Attribute( Attribute::TARGET_PROPERTY | Attribute::TARGET_METHOD )] class MyCustomConstraint extends Constraint implements ValidatesOne { public function __construct( ?string $message = null, Strategy $strategy = Strategy::FailFast, ) { parent::__construct( validation: 'app.myCustomConstraint', messages: ['app.myCustomConstraint' => $message], strategy: $strategy ); } public function validate(mixed $value = null): Result { // it is really up to you, how you handle this // you will just work with a normal mighty Validator // here we're just preparing the data to pass to the Validator $name = ''; $data = [$name => $value]; $validations = [$name => $this->validation]; $messages = [$name => [$this->validation => $this->messages[$this->validation] ?? null]]; $labels = [$name => static::class]; // you can reuse the built-in rules or // add you own Rule that handles your custom logic $result = $this ->getValidator() ->addRule( // see MAKS mighty Rule for more info (new Rule()) ->setName('app.myCustomConstraint') ->setCallback(static fn ($input) => $input /* here comes your logic */) ->setParameters(['@input']) // rule callback dependencies ->setMessage('${@label} must follow my custom constraint validation.') // this is the default message ) ->setData($data) ->setValidations($validations) ->setMessages($messages) ->setLabels($labels) ->validate(); return $result[$name]; // if you implement ValidatesMany, you will just return $result } }">
 <?php

declare (strict_types= 1 );

namespace App  Validation  Constraint ;

use Attribute ;
use MAKS  mighty  Rule ;
use MAKS  mighty  Result ;
use MAKS  mighty  Validation  Strategy ;
use MAKS  mighty  Validation  Constraint ;
use MAKS  mighty  Validation  Constraint  ValidatesOne ;
// use the ValidatesMany interface if your Constraint returns a collection of Result objects
use MAKS  mighty  Validation  Constraint  ValidatesMany ;

#[Attribute(
    Attribute:: TARGET_PROPERTY |
    Attribute:: TARGET_METHOD
)]
class MyCustomConstraint extends Constraint implements ValidatesOne
{
    public function __construct (
        ? string $ message = null ,
        Strategy $ strategy = Strategy::FailFast,
    ) {
        parent :: __construct (
            validation: ' app.myCustomConstraint ' ,
            messages: [ ' app.myCustomConstraint ' => $ message ],
            strategy: $ strategy
        );
    }


    public function validate ( mixed $ value = null ): Result
    {
        // it is really up to you, how you handle this
        // you will just work with a normal mighty Validator
        // here we're just preparing the data to pass to the Validator
        $ name        = '' ;
        $ data        = [ $ name => $ value ];
        $ validations = [ $ name => $ this -> validation ];
        $ messages    = [ $ name => [ $ this -> validation => $ this -> messages [ $ this -> validation ] ?? null ]];
        $ labels      = [ $ name => static ::class];

        // you can reuse the built-in rules or
        // add you own Rule that handles your custom logic
        $ result = $ this
            -> getValidator ()
            -> addRule (
                // see MAKS mighty Rule for more info
                ( new Rule ())
                    -> setName ( ' app.myCustomConstraint ' )
                    -> setCallback ( static fn ( $ input ) => $ input /* here comes your logic */ )
                    -> setParameters ([ ' @input ' ]) // rule callback dependencies
                    -> setMessage ( ' ${@label} must follow my custom constraint validation. ' ) // this is the default message
            )
            -> setData ( $ data )
            -> setValidations ( $ validations )
            -> setMessages ( $ messages )
            -> setLabels ( $ labels )
            -> validate ();

        return $ result [ $ name ]; // if you implement ValidatesMany, you will just return $result
    }
}

■ Hinweis: Benutzerdefinierte Einschränkungen gelten als Teil der Gruppe „Spezielle Einschränkungsattribute“ (d. h. sie dürfen nicht mit/innerhalb der Einschränkungen Shape::class und Compound::class “ verwendet werden).

Validierungen

Die folgende Tabelle listet alle verfügbaren Regeln einschließlich ihrer Attribut- und Methodenäquivalente auf:

Regeln und Aliase

  • Validation::class
  • Constraint::class und Constraint/Rule/*
NEIN. Regel Beschreibung Attribut/Methode
001 Name: null
Verwendung: null		 Bestätigt, dass die Eingabe null ist. Attribut:
NullConstraint::class
Verfahren:
Validation::null()
002 Name: boolean
Verwendung: boolean		 Bestätigt, dass die Eingabe ein boolescher Wert ist. Attribut:
Boolean::class
Verfahren:
Validation::boolean()
003 Name: integer
Verwendung: integer		 Bestätigt, dass die Eingabe eine Ganzzahl ist. Attribut:
Integer::class
Verfahren:
Validation::integer()
004 Name: float
Verwendung: float		 Bestätigt, dass die Eingabe ein Float ist. Attribut:
FloatConstraint::class
Verfahren:
Validation::float()
005 Name: numeric
Verwendung: numeric		 Bestätigt, dass die Eingabe numerisch ist. Attribut:
NumericConstraint::class
Verfahren:
Validation::numeric()
006 Name: string
Verwendung: string		 Bestätigt, dass die Eingabe eine Zeichenfolge ist. Attribut:
StringConstraint::class
Verfahren:
Validation::string()
007 Name: scalar
Verwendung: scalar		 Bestätigt, dass die Eingabe ein Skalar ist. Attribut:
Scalar::class
Verfahren:
Validation::scalar()
008 Name: array
Verwendung: array		 Bestätigt, dass die Eingabe ein Array ist. Attribut:
ArrayConstraint::class
Verfahren:
Validation::array()
009 Name: object
Verwendung: object		 Bestätigt, dass die Eingabe ein Objekt ist. Attribut:
ObjectConstraint::class
Verfahren:
Validation::object()
010 Name: callable
Verwendung: callable		 Bestätigt, dass die Eingabe aufrufbar ist. Attribut:
CallableConstraint::class
Verfahren:
Validation::callable()
011 Name: iterable
Verwendung: iterable		 Bestätigt, dass die Eingabe iterierbar ist. Attribut:
IterableConstraint::class
Verfahren:
Validation::iterable()
012 Name: countable
Verwendung: countable		 Bestätigt, dass die Eingabe zählbar ist. Attribut:
Countable::class
Verfahren:
Validation::countable()
013 Name: resource
Verwendung: resource		 Bestätigt, dass die Eingabe eine Ressource ist. Attribut:
ResourceConstraint::class
Verfahren:
Validation::resource()
014 Name: type
Verwendung: type:'["int","float"]'		 Bestätigt, dass die Eingabe einer der angegebenen Typen ist. Attribut:
Type::class
Verfahren:
Validation::type(string|array $type)
015 Name: type.debug
Verwendung: type.debug:string		 Stellt mithilfe von get_debug_type() sicher, dass die Eingabe vom angegebenen Typ ist. Attribut:
TypeDebug::class
Verfahren:
Validation::typeDebug(string $type)
016 Name: alpha
Verwendung: alpha		 Bestätigt, dass die Eingabe nur aus alphabetischen Zeichen besteht. Attribut:
Alpha::class
Verfahren:
Validation::alpha()
017 Name: alnum
Verwendung: alnum		 Bestätigt, dass die Eingabe nur aus alphanumerischen Zeichen besteht. Attribut:
Alnum::class
Verfahren:
Validation::alnum()
018 Name: lower
Verwendung: lower		 Bestätigt, dass die Eingabe nur aus Kleinbuchstaben besteht. Attribut:
Lower::class
Verfahren:
Validation::lower()
019 Name: upper
Verwendung: upper		 Bestätigt, dass die Eingabe nur aus Großbuchstaben besteht. Attribut:
Upper::class
Verfahren:
Validation::upper()
020 Name: cntrl
Verwendung: cntrl		 Bestätigt, dass die Eingabe nur aus Steuerzeichen besteht. Attribut:
Cntrl::class
Verfahren:
Validation::cntrl()
021 Name: space
Verwendung: space		 Bestätigt, dass die Eingabe nur aus Leerzeichen besteht. Attribut:
Space::class
Verfahren:
Validation::space()
022 Name: punct
Verwendung: punct		 Bestätigt, dass die Eingabe nur aus Satzzeichen besteht. Attribut:
Punct::class
Verfahren:
Validation::punct()
023 Name: graph
Verwendung: graph		 Bestätigt, dass die Eingabe nur aus grafischen Zeichen besteht (Zeichen, die eine sichtbare Ausgabe erzeugen). Attribut:
Graph::class
Verfahren:
Validation::graph()
024 Name: print
Verwendung: print		 Bestätigt, dass die Eingabe nur aus druckbaren Zeichen besteht. Attribut:
PrintConstraint::class
Verfahren:
Validation::print()
025 Name: digit
Verwendung: digit		 Bestätigt, dass die Eingabe nur aus Ziffern (numerischen Zeichen) besteht. Attribut:
Digit::class
Verfahren:
Validation::digit()
026 Name: xdigit
Verwendung: xdigit		 Bestätigt, dass die Eingabe hexadezimale Ziffern darstellt. Attribut:
Xdigit::class
Verfahren:
Validation::xdigit()
027 Name: booleanLike
Verwendung: booleanLike		 Bestätigt, dass die Eingabe ein Wert ist, der als boolescher Wert geparst werden kann (TRUE: wahr, „wahr“, „1“, „ein“, „ja“; FALSCH: falsch, „falsch“, „0“, „aus“ , „nein“, „“, null). Attribut:
BooleanLike::class
Verfahren:
Validation::booleanLike()
028 Name: integerLike
Verwendung: integerLike:0,100		 Bestätigt, dass die Eingabe ein Wert ist, der als Ganzzahl innerhalb des angegebenen Bereichs analysiert werden kann. Attribut:
IntegerLike::class
Verfahren:
Validation::integerLike(int $min = PHP_INT_MIN, int $max = PHP_INT_MAX)
029 Name: integerLike.allowOctal
Verwendung: integerLike.allowOctal:0,100		 Bestätigt, dass die Eingabe ein Wert ist, der als Ganzzahl innerhalb des angegebenen Bereichs analysiert werden kann und in Oktalschreibweise vorliegen kann. Attribut:
IntegerLikeAllowOctal::class
Verfahren:
Validation::integerLikeAllowOctal(int $min = PHP_INT_MIN, int $max = PHP_INT_MAX)
030 Name: integerLike.allowHex
Verwendung: integerLike.allowHex:0,100		 Bestätigt, dass die Eingabe ein Wert ist, der als Ganzzahl innerhalb des angegebenen Bereichs analysiert werden kann und in hexadezimaler Schreibweise vorliegen kann. Attribut:
IntegerLikeAllowHex::class
Verfahren:
Validation::integerLikeAllowHex(int $min = PHP_INT_MIN, int $max = PHP_INT_MAX)
031 Name: floatLike
Verwendung: floatLike:1.0,100.0		 Bestätigt, dass die Eingabe ein Wert ist, der als Float innerhalb des angegebenen Bereichs analysiert werden kann. Attribut:
FloatLike::class
Verfahren:
Validation::floatLike(float $min = PHP_FLOAT_MIN, float $max = PHP_FLOAT_MAX)
032 Name: floatLike.allowThousands
Verwendung: floatLike.allowThousands:1.0,100.0		 Bestätigt, dass die Eingabe ein Wert ist, der als Float innerhalb des angegebenen Bereichs analysiert werden kann. Attribut:
FloatLikeAllowThousands::class
Verfahren:
Validation::floatLikeAllowThousands(float $min = PHP_FLOAT_MIN, float $max = PHP_FLOAT_MAX)
033 Name: regexp
Verwendung: regexp:"/[az]/i"		 Bestätigt, dass die Eingabe mit einem Perl-kompatiblen regulären Ausdruck übereinstimmt. Attribut:
Regexp::class
Verfahren:
Validation::regexp(string $pattern)
034 Name: ip
Verwendung: ip		 Bestätigt, dass es sich bei der Eingabe um eine IP-Adresse handelt. Attribut:
Ip::class
Verfahren:
Validation::ip()
035 Name: ip.v4
Verwendung: ip.v4		 Bestätigt, dass es sich bei der Eingabe um eine IPv4-Adresse handelt. Attribut:
IpV4::class
Verfahren:
Validation::ipV4()
036 Name: ip.v6
Verwendung: ip.v6		 Bestätigt, dass es sich bei der Eingabe um eine IPv6-Adresse handelt. Attribut:
IpV6::class
Verfahren:
Validation::ipV6()
037 Name: ip.notReserved
Verwendung: ip.notReserved		 Bestätigt, dass es sich bei der Eingabe um eine IP-Adresse handelt, die nicht im reservierten IP-Bereich liegt. Attribut:
IpNotReserved::class
Verfahren:
Validation::ipNotReserved()
038 Name: ip.notPrivate
Verwendung: ip.notPrivate		 Bestätigt, dass es sich bei der Eingabe um eine IP-Adresse handelt, die nicht im privaten IP-Bereich liegt. Attribut:
IpNotPrivate::class
Verfahren:
Validation::ipNotPrivate()
039 Name: mac
Verwendung: mac		 Bestätigt, dass es sich bei der Eingabe um eine MAC-Adresse handelt. Attribut:
Mac::class
Verfahren:
Validation::mac()
040 Name: url
Verwendung: url		 Bestätigt, dass die Eingabe eine URL ist. Attribut:
Url::class
Verfahren:
Validation::url()
041 Name: url.withPath
Verwendung: url.withPath		 Bestätigt, dass die Eingabe eine URL ist, die einen Pfad enthält. Attribut:
UrlWithPath::class
Verfahren:
Validation::urlWithPath()
042 Name: url.withQuery
Verwendung: url.withQuery		 Bestätigt, dass die Eingabe eine URL ist, die eine Abfrage enthält. Attribut:
UrlWithQuery::class
Verfahren:
Validation::urlWithQuery()
043 Name: email
Verwendung: email		 Bestätigt, dass es sich bei der Eingabe um eine E-Mail-Adresse handelt. Attribut:
Email::class
Verfahren:
Validation::email()
044 Name: email.withUnicode
Verwendung: email.withUnicode		 Bestätigt, dass es sich bei der Eingabe um eine E-Mail-Adresse handelt (Unicode zulässig). Attribut:
EmailWithUnicode::class
Verfahren:
Validation::emailWithUnicode()
045 Name: domain
Verwendung: domain		 Bestätigt, dass die Eingabe eine Domäne ist. Attribut:
Domain::class
Verfahren:
Validation::domain()
046 Name: domain.isActive
Verwendung: domain.isActive		 Bestätigt, dass die Eingabe eine aktive Domäne ist. Funktioniert mit Domains und E-Mails. Attribut:
DomainIsActive::class
Verfahren:
Validation::domainIsActive()
047 Name: file
Verwendung: file		 Bestätigt, dass es sich bei der Eingabe um eine Datei handelt (kann eine Datei, ein Link oder ein Verzeichnis sein). Attribut:
File::class
Verfahren:
Validation::file()
048 Name: file.isFile
Verwendung: file.isFile		 Bestätigt, dass die Eingabe eine Datei ist. Attribut:
FileIsFile::class
Verfahren:
Validation::fileIsFile()
049 Name: file.isLink
Verwendung: file.isLink		 Bestätigt, dass die Eingabe ein Link ist. Attribut:
FileIsLink::class
Verfahren:
Validation::fileIsLink()
050 Name: file.isDirectory
Verwendung: file.isDirectory		 Bestätigt, dass die Eingabe ein Verzeichnis ist. Attribut:
FileIsDirectory::class
Verfahren:
Validation::fileIsDirectory()
051 Name: file.isExecutable
Verwendung: file.isExecutable		 Bestätigt, dass die Eingabe eine Datei ist und ausführbar ist. Attribut:
FileIsExecutable::class
Verfahren:
Validation::fileIsExecutable()
052 Name: file.isWritable
Verwendung: file.isWritable		 Bestätigt, dass die Eingabe eine Datei ist und beschreibbar ist. Attribut:
FileIsWritable::class
Verfahren:
Validation::fileIsWritable()
053 Name: file.isReadable
Verwendung: file.isReadable		 Bestätigt, dass die Eingabe eine Datei ist und lesbar ist. Attribut:
FileIsReadable::class
Verfahren:
Validation::fileIsReadable()
054 Name: file.isUploaded
Verwendung: file.isUploaded		 Bestätigt, dass es sich bei der Eingabe um eine Datei handelt, die über HTTP POST hochgeladen wird. Attribut:
FileIsUploaded::class
Verfahren:
Validation::fileIsUploaded()
055 Name: file.size
Verwendung: file.size:1024		 Bestätigt, dass es sich bei der Eingabe um eine Datei handelt und die Größe der angegebenen Größe in Bytes entspricht. Attribut:
FileSize::class
Verfahren:
Validation::fileSize(int $sizeInBytes)
056 Name: file.size.lte
Verwendung: file.size.lte:1024		 Bestätigt, dass es sich bei der Eingabe um eine Datei handelt und die Größe kleiner oder gleich der angegebenen Größe in Bytes ist. Attribut:
FileSizeLte::class
Verfahren:
Validation::fileSizeLte(int $sizeInBytes)
057 Name: file.size.gte
Verwendung: file.size.gte:1024		 Bestätigt, dass es sich bei der Eingabe um eine Datei handelt und die Größe größer oder gleich der angegebenen Größe in Bytes ist. Attribut:
FileSizeGte::class
Verfahren:
Validation::fileSizeGte(int $sizeInBytes)
058 Name: file.dirname
Verwendung: file.dirname:/path/to/dir		 Bestätigt, dass die Eingabe eine Datei ist und ihr Verzeichnisname mit dem angegebenen Verzeichnisnamen übereinstimmt. Attribut:
FileDirname::class
Verfahren:
Validation::fileDirname(string $dirname)
059 Name: file.basename
Verwendung: file.basename:file.ext		 Bestätigt, dass die Eingabe eine Datei ist und ihr Basisname dem angegebenen Basisnamen entspricht. Attribut:
FileBasename::class
Verfahren:
Validation::fileBasename(string $basename)
060 Name: file.filename
Verwendung: file.filename:file		 Bestätigt, dass die Eingabe eine Datei ist und ihr Dateiname mit dem angegebenen Dateinamen übereinstimmt. Attribut:
FileFilename::class
Verfahren:
Validation::fileFilename(string $filename)
061 Name: file.extension
Verwendung: file.extension:ext		 Bestätigt, dass es sich bei der Eingabe um eine Datei handelt und ihre Erweiterung mit der angegebenen Erweiterung übereinstimmt. Attribut:
FileExtension::class
Verfahren:
Validation::fileExtension(string $extension)
062 Name: file.mime
Verwendung: file.mime:text/plain		 Bestätigt, dass die Eingabe eine Datei ist und ihr MIME-Typ einer der angegebenen MIME-Typen ist. Attribut:
FileMime::class
Verfahren:
Validation::fileMime(string|array $mine)
063 Name: image
Verwendung: image		 Bestätigt, dass es sich bei der Eingabe um eine Bilddatei handelt (JPG, JPEG, PNG, GIF, BMP, SVG oder WebP). Attribut:
Image::class
Verfahren:
Validation::image()
064 Name: image.width
Verwendung: image.width:1920		 Bestätigt, dass die Eingabe ein Bild ist und seine Breite der angegebenen Breite in Pixeln entspricht. Attribut:
ImageWidth::class
Verfahren:
Validation::imageWidth(int $width)
065 Name: image.width.lte
Verwendung: image.width.lte:1920		 Bestätigt, dass es sich bei der Eingabe um ein Bild handelt und seine Breite kleiner oder gleich der angegebenen Breite in Pixel ist. Attribut:
ImageWidthLte::class
Verfahren:
Validation::imageWidthLte(int $width)
066 Name: image.width.gte
Verwendung: image.width.gte:1920		 Bestätigt, dass es sich bei der Eingabe um ein Bild handelt und seine Breite größer oder gleich der angegebenen Breite in Pixel ist. Attribut:
ImageWidthGte::class
Verfahren:
Validation::imageWidthGte(int $width)
067 Name: image.height
Verwendung: image.height:1080		 Bestätigt, dass es sich bei der Eingabe um ein Bild handelt und seine Höhe der angegebenen Höhe in Pixeln entspricht. Attribut:
ImageHeight::class
Verfahren:
Validation::imageHeight(int $height)
068 Name: image.height.lte
Verwendung: image.height.lte:1080		 Bestätigt, dass es sich bei der Eingabe um ein Bild handelt und seine Höhe kleiner oder gleich der angegebenen Höhe in Pixel ist. Attribut:
ImageHeightLte::class
Verfahren:
Validation::imageHeightLte(int $height)
069 Name: image.height.gte
Verwendung: image.height.gte:1080		 Bestätigt, dass es sich bei der Eingabe um ein Bild handelt und seine Höhe größer oder gleich der angegebenen Höhe in Pixel ist. Attribut:
ImageHeightGte::class
Verfahren:
Validation::imageHeightGte(int $height)
070 Name: image.dimensions
Verwendung: image.dimensions:1920,1080,==		 Bestätigt, dass es sich bei der Eingabe um ein Bild handelt und seine Abmessungen kleiner, gleich oder größer als die angegebene Breite und Höhe in Pixel sind. Attribut:
ImageDimensions::class
Verfahren:
Validation::imageDimensions(int $width, int $height, string $operator = '==')
071 Name: image.ratio
Verwendung: image.ratio:16:9		 Bestätigt, dass es sich bei der Eingabe um ein Bild handelt und sein Seitenverhältnis dem angegebenen Verhältnis entspricht (das Verhältnis muss als Bruch wie „16/9“ angegeben werden). Attribut:
ImageRatio::class
Verfahren:
Validation::imageRatio(string $ratio)
072 Name: if
Verwendung: if:7,7,==		 Überprüft die Bedingung zwischen dem ersten Argument und dem zweiten Argument, der Bedingungsoperator kann auch als drittes Argument angegeben werden. Attribut:
IfConstraint::class
Verfahren:
Validation::if(mixed $actual, mixed $expected = true, string $operator = '==')
073 Name: if.eq
Verwendung: if.eq:3,3		 Überprüft die Bedingung zwischen dem ersten Argument und dem zweiten Argument. Der Bedingungsoperator ist „==". Attribut:
IfEq::class
Verfahren:
Validation::ifEq(mixed $actual, mixed $expected)
074 Name: if.neq
Verwendung: if.neq:1,2		 Überprüft die Bedingung zwischen dem ersten Argument und dem zweiten Argument. Der Bedingungsoperator ist „!=". Attribut:
IfNeq::class
Verfahren:
Validation::ifNeq(mixed $actual, mixed $expected)
075 Name: if.id
Verwendung: if.id:3,3		 Überprüft die Bedingung zwischen dem ersten Argument und dem zweiten Argument. Der Bedingungsoperator ist „===". Attribut:
IfId::class
Verfahren:
Validation::ifId(mixed $actual, mixed $expected)
076 Name: if.nid
Verwendung: if.nid:1,2		 Überprüft die Bedingung zwischen dem ersten Argument und dem zweiten Argument. Der Bedingungsoperator ist „!==". Attribut:
IfNid::class
Verfahren:
Validation::ifNid(mixed $actual, mixed $expected)
077 Name: if.gt
Verwendung: if.gt:2,1		 Überprüft die Bedingung zwischen dem ersten Argument und dem zweiten Argument. Der Bedingungsoperator ist „>“. Attribut:
IfGt::class
Verfahren:
Validation::ifGt(mixed $actual, mixed $expected)
078 Name: if.gte
Verwendung: if.gte:2,2		 Überprüft die Bedingung zwischen dem ersten Argument und dem zweiten Argument. Der Bedingungsoperator ist „>=“. Attribut:
IfGte::class
Verfahren:
Validation::ifGte(mixed $actual, mixed $expected)
079 Name: if.lt
Verwendung: if.lt:1,2		 Überprüft die Bedingung zwischen dem ersten Argument und dem zweiten Argument. Der Bedingungsoperator ist „<“. Attribut:
IfLt::class
Verfahren:
Validation::ifLt(mixed $actual, mixed $expected)
080 Name: if.lte
Verwendung: if.lte:1,2		 Überprüft die Bedingung zwischen dem ersten Argument und dem zweiten Argument. Der Bedingungsoperator ist „<=“. Attribut:
IfLte::class
Verfahren:
Validation::ifLte(mixed $actual, mixed $expected)
081 Name: empty
Verwendung: empty		 Bestätigt mithilfe des Sprachkonstrukts empty(), dass die Eingabe leer ist (ist leer, z. B. leere Zeichenfolge, leeres Array, falsch, null oder 0). Attribut:
EmptyConstraint::class
Verfahren:
Validation::empty()
082 Name: required
Verwendung: required		 Bestätigt, dass die Eingabe erforderlich ist (ist nicht leer, d. h. keine leere Zeichenfolge oder Null). Attribut:
Required::class
Verfahren:
Validation::required()
083 Name: allowed
Verwendung: allowed		 Bestätigt, dass die Eingabe zulässig ist (kann leer sein oder einen beliebigen Wert haben, Null und leere Zeichenfolge gelten als gültige Werte). Attribut:
Allowed::class
Verfahren:
Validation::allowed()
084 Name: forbidden
Verwendung: forbidden		 Bestätigt, dass die Eingabe verboten ist (null ist oder nicht vorhanden ist). Attribut:
Forbidden::class
Verfahren:
Validation::forbidden()
085 Name: accepted
Verwendung: accepted		 Bestätigt, dass die Eingabe akzeptiert wird (entspricht: „on“, „yes“, „yeah“, „yep“, „yo“, „ok“, „okay“, „aye“, 1 oder „1“, true oder „ true") beachten Sie, dass bei der Verarbeitung von Zeichenfolgen die Groß-/Kleinschreibung nicht beachtet wird. Attribut:
Accepted::class
Verfahren:
Validation::accepted()
086 Name: declined
Verwendung: declined		 Bestätigt, dass die Eingabe abgelehnt wird (entspricht: „off“, „no“, „not“, „nope“, „neh“, „nay“, 0 oder „0“, false oder „false“). Beachten Sie, dass Zeichenfolgen behandelt werden ohne Berücksichtigung der Groß- und Kleinschreibung. Attribut:
Declined::class
Verfahren:
Validation::declined()
087 Name: bit
Verwendung: bit		 Bestätigt, dass die Eingabe ein Bit ist (entspricht: 1 oder „1“, wahr; 0 oder „0“, falsch). Attribut:
Bit::class
Verfahren:
Validation::bit()
088 Name: bit.isOn
Verwendung: bit.isOn		 Bestätigt, dass es sich bei der Eingabe um ein eingeschaltetes Bit handelt (entspricht: wahr, 1 oder „1“). Attribut:
BitIsOn::class
Verfahren:
Validation::bitIsOn()
089 Name: bit.isOff
Verwendung: bit.isOff		 Bestätigt, dass es sich bei der Eingabe um ein ausgeschaltetes Bit handelt (entspricht: falsch, 0 oder „0“). Attribut:
BitIsOff::class
Verfahren:
Validation::bitIsOff()
090 Name: equals
Verwendung: equals:value		 Bestätigt, dass die Eingabe dem angegebenen Wert entspricht. Funktioniert mit Skalartypen und Null. Der Vergleichsoperator ist „==“. Attribut:
Equals::class
Verfahren:
Validation::equals(string|int|float|bool|null $value)
091 Name: matches
Verwendung: matches:'"/^[a-zA-Z0-9]+$/"'		 Bestätigt, dass die Eingabe mit dem angegebenen Muster übereinstimmt. Funktioniert nur mit Strings. Attribut:
Matches::class
Verfahren:
Validation::matches(string $pattern)
092 Name: in
Verwendung: in:val1,val2,...		 Bestätigt, dass die Eingabe den angegebenen Werten entspricht. Funktioniert mit Skalartypen und Null. Attribut:
In::class
Verfahren:
Validation::in(string|int|float|bool|null ...$values)
093 Name: count
Verwendung: count:3		 Bestätigt, dass die Eingabeanzahl dem angegebenen Wert entspricht. Funktioniert mit allen Datentypen (null: 0; boolescher Wert: 0 oder 1; Gleitkommazahl/Ganzzahl: Zahlenwert; Zeichenfolge: Anzahl der Zeichen; Array/zählbar: Anzahl der Elemente; Objekt: Anzahl der zugänglichen Eigenschaften). Attribut:
Count::class
Verfahren:
Validation::count(int $count)
094 Name: min
Verbrauch: min:3		 Bestätigt, dass die Eingabeanzahl größer oder gleich dem angegebenen Wert ist. Funktioniert mit allen Datentypen (null: 0; boolescher Wert: 0 oder 1; Gleitkommazahl/Ganzzahl: Zahlenwert; Zeichenfolge: Anzahl der Zeichen; Array/zählbar: Anzahl der Elemente; Objekt: Anzahl der zugänglichen Eigenschaften). Attribut:
Min::class
Verfahren:
Validation::min(int|float $count)
095 Name: max
Verbrauch: max:3		 Bestätigt, dass die Eingabeanzahl kleiner oder gleich dem angegebenen Wert ist. Funktioniert mit allen Datentypen (null: 0; boolescher Wert: 0 oder 1; Gleitkommazahl/Ganzzahl: Zahlenwert; Zeichenfolge: Anzahl der Zeichen; Array/zählbar: Anzahl der Elemente; Objekt: Anzahl der zugänglichen Eigenschaften). Attribut:
Max::class
Verfahren:
Validation::max(int|float $count)
096 Name: between
Verwendung: between:3,7		 Bestätigt, dass die Eingabeanzahl zwischen den angegebenen Werten liegt. Funktioniert mit allen Datentypen (null: 0; boolescher Wert: 0 oder 1; Gleitkommazahl/Ganzzahl: Zahlenwert; Zeichenfolge: Anzahl der Zeichen; Array/zählbar: Anzahl der Elemente; Objekt: Anzahl der zugänglichen Eigenschaften). Attribut:
Between::class
Verfahren:
Validation::between(int|float $min, int|float $max)
097 Name: number.isPositive
Verwendung: number.isPositive		 Bestätigt, dass die Eingabe eine positive Zahl ist. Attribut:
NumberIsPositive::class
Verfahren:
Validation::numberIsPositive()
098 Name: number.isNegative
Verwendung: number.isNegative		 Bestätigt, dass die Eingabe eine negative Zahl ist. Attribut:
NumberIsNegative::class
Verfahren:
Validation::numberIsNegative()
099 Name: number.isEven
Verwendung: number.isEven		 Bestätigt, dass die Eingabe eine gerade Zahl ist. Attribut:
NumberIsEven::class
Verfahren:
Validation::numberIsEven()
100 Name: number.isOdd
Verwendung: number.isOdd		 Bestätigt, dass die Eingabe eine ungerade Zahl ist. Attribut:
NumberIsOdd::class
Verfahren:
Validation::numberIsOdd()
101 Name: number.isMultipleOf
Verwendung: number.isMultipleOf:3		 Bestätigt, dass die Eingabe ein Vielfaches der angegebenen Zahl ist. Attribut:
NumberIsMultipleOf::class
Verfahren:
Validation::numberIsMultipleOf(float $number)
102 Name: number.isFinite
Verwendung: number.isFinite		 Bestätigt, dass die Eingabe eine endliche Zahl ist. Attribut:
NumberIsFinite::class
Verfahren:
Validation::numberIsFinite()
103 Name: number.isInfinite
Verwendung: number.isInfinite		 Bestätigt, dass die Eingabe eine unendliche Zahl ist. Attribut:
NumberIsInfinite::class
Verfahren:
Validation::numberIsInfinite()
104 Name: number.isNan
Verwendung: number.isNan		 Bestätigt, dass die Eingabe keine Zahl ist. Attribut:
NumberIsNan::class
Verfahren:
Validation::numberIsNan()
105 Name: string.charset
Verwendung: string.charset:UTF-8		 Bestätigt, dass die Eingabe in einem der angegebenen Zeichensätze (einschließlich Aliase) codiert ist. Die Prüfung erfolgt unter Berücksichtigung der Groß- und Kleinschreibung. Attribut:
StringCharset::class
Verfahren:
Validation::stringCharset(string|array $charset)
106 Name: string.contains
Verwendung: string.contains:substring		 Bestätigt, dass die Eingabe die angegebene Teilzeichenfolge enthält. Ein zweites boolesches Argument kann angegeben werden, um den strikten Modus zu aktivieren (Groß-/Kleinschreibung beachten). Attribut:
StringContains::class
Verfahren:
Validation::stringContains(string $substring, bool $strict = false)
107 Name: string.startsWith
Verwendung: string.startsWith:substring,1		 Bestätigt, dass die Eingabe mit der angegebenen Teilzeichenfolge beginnt. Ein zweites boolesches Argument kann angegeben werden, um den strikten Modus zu aktivieren (Groß-/Kleinschreibung beachten). Attribut:
StringStartsWith::class
Verfahren:
Validation::stringStartsWith(string $substring, bool $strict = false)
108 Name: string.endsWith
Verwendung: string.endsWith:substring,0		 Bestätigt, dass die Eingabe mit der angegebenen Teilzeichenfolge endet. Ein zweites boolesches Argument kann angegeben werden, um den strikten Modus zu aktivieren (Groß-/Kleinschreibung beachten). Attribut:
StringEndsWith::class
Verfahren:
Validation::stringEndsWith(string $substring, bool $strict = false)
109 Name: string.length
Verwendung: string.length:3		 Bestätigt, dass die Eingabe eine Zeichenfolge ist, die genau die angegebene Länge hat. Attribut:
StringLength::class
Verfahren:
Validation::stringLength(int $length)
110 Name: string.wordsCount
Verwendung: string.wordsCount:3		 Bestätigt, dass die Eingabe eine Zeichenfolge ist, die genau die angegebene Anzahl von Wörtern enthält. Attribut:
StringWordsCount::class
Verfahren:
Validation::stringWordsCount(int $count)
111 Name: array.hasKey
Verwendung: array.hasKey:key		 Bestätigt, dass das Eingabearray den angegebenen Schlüssel hat. Attribut:
ArrayHasKey::class
Verfahren:
Validation::arrayHasKey(string|int $key)
112 Name: array.hasValue
Verwendung: array.hasValue:value		 Bestätigt, dass das Eingabearray den angegebenen Wert enthält. Funktioniert mit Skalartypen. Attribut:
ArrayHasValue::class
Verfahren:
Validation::arrayHasValue(mixed $value)
113 Name: array.hasDistinct
Verwendung: array.hasDistinct:key		 Bestätigt, dass die Eingabe ein mehrdimensionales Array ist, das unterschiedliche Werte des angegebenen Schlüssels enthält. Attribut:
ArrayHasDistinct::class
Verfahren:
Validation::arrayHasDistinct(string|int $key)
114 Name: array.isAssociative
Verwendung: array.isAssociative		 Bestätigt, dass die Eingabe ein assoziatives Array ist. Attribut:
ArrayIsAssociative::class
Verfahren:
Validation::arrayIsAssociative()
115 Name: array.isSequential
Verwendung: array.isSequential		 Bestätigt, dass die Eingabe ein sequentielles Array ist. Attribut:
ArrayIsSequential::class
Verfahren:
Validation::arrayIsSequential()
116 Name: array.isUnique
Verwendung: array.isUnique		 Bestätigt, dass das Eingabearray eindeutige Werte enthält. Funktioniert nur mit eindimensionalen Arrays. Attribut:
ArrayIsUnique::class
Verfahren:
Validation::arrayIsUnique()
117 Name: array.subset
Verwendung: array.subset:'{"a":1,"b":2}'		 Bestätigt, dass die Eingabe ein Array ist, das die angegebene Teilmenge enthält. Beachten Sie, dass diese Prüfung nur für die erste Dimension des Arrays gilt. Attribut:
ArraySubset::class
Verfahren:
Validation::arraySubset(array $subset)
118 Name: object.hasProperty
Verwendung: object.hasProperty:property		 Bestätigt, dass die Eingabe die angegebene Eigenschaft hat. Attribut:
ObjectHasProperty::class
Verfahren:
Validation::objectHasProperty(string $property)
119 Name: object.hasMethod
Verwendung: object.hasMethod:method		 Bestätigt, dass die Eingabe die angegebene Methode hat. Attribut:
ObjectHasMethod::class
Verfahren:
Validation::objectHasMethod(string $method)
120 Name: object.isStringable
Verwendung: object.isStringable		 Bestätigt, dass die Eingabe die Methode __toString() implementiert. Attribut:
ObjectIsStringable::class
Verfahren:
Validation::objectIsStringable()
121 Name: object.isInstanceOf
Verwendung: object.isInstanceOf:NamespaceClass		 Bestätigt, dass die Eingabe eine Instanz der angegebenen Klasse ist. Attribut:
ObjectIsInstanceOf::class
Verfahren:
Validation::objectIsInstanceOf(string $classFQN)
122 Name: object.isSubclassOf
Verwendung: object.isSubclassOf:NamespaceClass		 Bestätigt, dass die Eingabe eine Unterklasse der angegebenen Klasse ist. Attribut:
ObjectIsSubclassOf::class
Verfahren:
Validation::objectIsSubclassOf(string $classFQN)
123 Name: serialized
Verwendung: serialized		 Bestätigt, dass es sich bei der Eingabe um gültige PHP-serialisierte Daten handelt. Attribut:
Serialized::class
Verfahren:
Validation::serialized()
124 Name: json
Verwendung: json		 Bestätigt, dass die Eingabe ein gültiges JSON ist. Attribut:
Json::class
Verfahren:
Validation::json()
125 Name: base64
Verwendung: base64		 Bestätigt, dass die Eingabe eine gültige Base64-codierte Zeichenfolge ist. Attribut:
Base64::class
Verfahren:
Validation::base64()
126 Name: xml
Verwendung: xml		 Bestätigt, dass die Eingabe ein gültiges XML ist. Attribut:
Xml::class
Verfahren:
Validation::xml()
127 Name: locale
Verwendung: locale		 Bestätigt, dass die Eingabe eine gültige Gebietsschemakennung ist (Standard: [ISO 639-1] oder [ISO 639-1]_[ISO 3166-1 alpha-2], Groß-/Kleinschreibung wird nicht beachtet, die Eingabe wird vor der Prüfung kanonisiert (Striche zu Unterstrichen, keine Punkte oder Zeichensatz); streng: [ISO 639-1] oder [ISO 639-1]_[ISO 3166-1 alpha-2], Groß- und Kleinschreibung ohne Kanonisierung. Attribut:
Locale::class
Verfahren:
Validation::locale(bool $strict = false)
128 Name: language
Verwendung: language		 Bestätigt, dass die Eingabe ein gültiger Sprachcode ist (Standard: „ISO 639-1“; lang: „ISO 639-2/T“). Attribut:
Language::class
Verfahren:
Validation::language(bool $long = false)
129 Name: country
Verwendung: country		 Bestätigt, dass es sich bei der Eingabe um einen gültigen Ländercode handelt (Standard: „ISO 3166-1 alpha-2“; lang: „ISO 3166-1 alpha-3“). Attribut:
Country::class
Verfahren:
Validation::country(bool $long = false)
130 Name: timezone
Verwendung: timezone		 Bestätigt, dass die Eingabe eine gültige Zeitzonenkennung ist (Standard: Groß-/Kleinschreibung wird nicht beachtet; streng: Groß-/Kleinschreibung wird beachtet). Attribut:
Timezone::class
Verfahren:
Validation::timezone(bool $strict = false)
131 Name: datetime
Verwendung: datetime		 Bestätigt, dass die Eingabe eine gültige Datums-/Uhrzeitzeichenfolge/ein gültiges Datum/Uhrzeit-Objekt ist. Attribut:
Datetime::class
Verfahren:
Validation::datetime()
132 Name: datetime.eq
Verwendung: datetime.eq:"2015-01-01"		 Bestätigt, dass die Eingabe mit der angegebenen Datums-/Uhrzeitzeichenfolge übereinstimmt. Attribut:
DatetimeEq::class
Verfahren:
Validation::datetimeEq(string $datetime)
133 Name: datetime.lt
Verwendung: datetime.lt:tomorrow		 Bestätigt, dass die Eingabe eine Datum/Uhrzeit-Zeichenfolge/ein Datums-/Uhrzeitzeichenfolge ist, die kleiner als (vor) der angegebenen Datum/Uhrzeit-Zeichenfolge ist. Attribut:
DatetimeLt::class
Verfahren:
Validation::datetimeLt(string $datetime)
134 Name: datetime.lte
Verwendung: datetime.lte:tomorrow		 Bestätigt, dass die Eingabe eine Datum/Uhrzeit-Zeichenfolge/ein Datum/Uhrzeit-Objekt ist, die kleiner (vor) oder gleich der angegebenen Datum/Uhrzeit-Zeichenfolge ist. Attribut:
DatetimeLte::class
Verfahren:
Validation::datetimeLte(string $datetime)
135 Name: datetime.gt
Verwendung: datetime.gt:today		 Bestätigt, dass die Eingabe eine Datum/Uhrzeit-Zeichenfolge/ein Objekt ist, die größer als (nach) der angegebenen Datum/Uhrzeit-Zeichenfolge ist. Attribut:
DatetimeGt::class
Verfahren:
Validation::datetimeGt(string $datetime)
136 Name: datetime.gte
Verwendung: datetime.gte:today		 Bestätigt, dass die Eingabe eine Datum/Uhrzeit-Zeichenfolge/ein Datum/Uhrzeit-Objekt ist, die größer als (nach) oder gleich der angegebenen Datum/Uhrzeit-Zeichenfolge ist. Attribut:
DatetimeGte::class
Verfahren:
Validation::datetimeGte(string $datetime)
137 Name: datetime.birthday
Verwendung: datetime.birthday		 Bestätigt, dass es sich bei der Eingabe um eine Datums-/Uhrzeitzeichenfolge/ein Objekt handelt, das heute Geburtstag hat. Die Eingabe sollte vorzugsweise im Format „JJJJ-MM-TT“ erfolgen. Attribut:
DatetimeBirthday::class
Verfahren:
Validation::datetimeBirthday()
138 Name: datetime.format
Verwendung: datetime.format:"Ymd H:i:s"		 Bestätigt, dass die Eingabe ein gültiges Datum/eine gültige Uhrzeit mit dem angegebenen Format ist. Attribut:
DatetimeFormat::class
Verfahren:
Validation::datetimeFormat(string $format)
139 Name: datetime.format.global
Verwendung: datetime.format.global		 Bestätigt, dass die Eingabe wie eine gültige globale Datums-/Uhrzeitzeichenfolge aussieht, wie in der HTML5-Spezifikation definiert. Attribut:
DatetimeFormatGlobal::class
Verfahren:
Validation::datetimeFormatGlobal()
140 Name: datetime.format.local
Verwendung: datetime.format.local		 Bestätigt, dass die Eingabe wie eine gültige lokale Datums-/Uhrzeitzeichenfolge aussieht, wie in der HTML5-Spezifikation definiert. Attribut:
DatetimeFormatLocal::class
Verfahren:
Validation::datetimeFormatLocal()
141 Name: datestamp
Verwendung: datestamp		 Bestätigt, dass die Eingabe wie ein menschlicher Datumsstempel im DMY- oder MDY-Format aussieht, getrennt durch Punkt, Bindestrich oder Schrägstrich. Attribut:
Datestamp::class
Verfahren:
Validation::datestamp()
142 Name: datestamp.ymd
Verwendung: datestamp.ymd		 Bestätigt, dass die Eingabe wie ein menschlicher Datumsstempel im YMD-Format aussieht, getrennt durch Punkt, Bindestrich oder Schrägstrich. Attribut:
DatestampYmd::class
Verfahren:
Validation::datestampYmd()
143 Name: datestamp.dmy
Verwendung: datestamp.dmy		 Bestätigt, dass die Eingabe wie ein menschlicher Datumsstempel im DMY-Format aussieht, getrennt durch Punkt, Bindestrich oder Schrägstrich. Attribut:
DatestampDmy::class
Verfahren:
Validation::datestampDmy()
144 Name: datestamp.mdy
Verwendung: datestamp.mdy		 Bestätigt, dass die Eingabe wie ein menschlicher Datumsstempel im MDY-Format aussieht, getrennt durch Punkt, Bindestrich oder Schrägstrich. Attribut:
DatestampMdy::class
Verfahren:
Validation::datestampMdy()
145 Name: timestamp
Verwendung: timestamp		 Bestätigt, dass die Eingabe wie ein menschlicher Zeitstempel im 24- oder 12-Stunden-Format mit oder ohne Sekunden aussieht. Attribut:
Timestamp::class
Verfahren:
Validation::timestamp()
146 Name: timestamp.12
Verwendung: timestamp.12		 Bestätigt, dass die Eingabe wie ein menschlicher Zeitstempel aussieht, 12-Stunden-Format mit oder ohne Sekunden und optional AM/PM. Attribut:
Timestamp12::class
Verfahren:
Validation::timestamp12()
147 Name: timestamp.hms
Verwendung: timestamp.hms		 Bestätigt, dass die Eingabe wie ein menschlicher Zeitstempel im 24- oder 12-Stunden-Format mit Sekunden aussieht. Attribut:
TimestampHms::class
Verfahren:
Validation::timestampHms()
148 Name: timestamp.hm
Verwendung: timestamp.hm		 Bestätigt, dass die Eingabe wie ein menschlicher Zeitstempel im 24- oder 12-Stunden-Format ohne Sekunden aussieht. Attribut:
TimestampHm::class
Verfahren:
Validation::timestampHm()
149 Name: timestamp.ms
Verwendung: timestamp.ms		 Bestätigt, dass die Eingabe wie ein menschlicher Zeitstempel aussieht und nur Minuten und Sekunden enthält. Attribut:
TimestampMs::class
Verfahren:
Validation::timestampMs()
150 Name: calender.day
Verwendung: calender.day		 Bestätigt, dass die Eingabe wie ein Kalendertag im Aufnahme- oder Langformat („Mo“ oder „Montag“) aussieht. Attribut:
CalenderDay::class
Verfahren:
Validation::calenderDay()
151 Name: calender.month
Verwendung: calender.month		 Bestätigt, dass die Eingabe wie ein Kalendermonat im Kurz- oder Langformat aussieht („Jan“ oder „Januar“). Attribut:
CalenderMonth::class
Verfahren:
Validation::calenderMonth()
152 Name: username
Verwendung: username		 Bestätigt, dass die Eingabe ein gültiger Benutzername ist (zwischen 4 und 32 Zeichen, besteht auf jeden Fall aus Buchstaben, optional Zahlen, optional einem der folgenden Zeichen „-_.“ (nicht fortlaufend) und muss immer mit einem Buchstaben beginnen und enden mit einem Buchstaben oder einer Zahl). Attribut:
Username::class
Verfahren:
Validation::username()
153 Name: password
Verwendung: password		 Bestätigt, dass es sich bei der Eingabe um ein gültiges Passwort handelt (mindestens 8 Zeichen, bestehend aus mindestens einem Kleinbuchstaben und einem Großbuchstaben, mindestens einer Zahl, mindestens einem Sonderzeichen und optional einem Leerzeichen). Attribut:
Password::class
Verfahren:
Validation::password()
154 Name: uuid
Verwendung: uuid		 Bestätigt, dass die Eingabe eine gültige UUID ist. Die Version (v1/v2/v3/v4/v5) kann angegeben werden, um das Muster einzugrenzen. Attribut:
Uuid::class
Verfahren:
Validation::uuid(string|int|null $version = null)
155 Name: ascii
Verwendung: ascii		 Bestätigt, dass die Eingabe eine Zeichenfolge ist, die nur ASCII-Zeichen enthält (ASCII-kompatible Zeichenfolge). Attribut:
Ascii::class
Verfahren:
Validation::ascii()
156 Name: slug
Verwendung: slug		 Bestätigt, dass die Eingabe ein gültiger Slug ist. Attribut:
Slug::class
Verfahren:
Validation::slug()
157 Name: meta
Verwendung: meta		 Bestätigt, dass die Eingabe eine Zeichenfolge ist, die nur Metazeichen (Sonderzeichen) enthält (z. B. „@, #, $, ...“). Attribut:
Meta::class
Verfahren:
Validation::meta()
158 Name: text
Verwendung: text		 Bestätigt, dass die Eingabe eine Zeichenfolge ist, die Buchstaben und Satzzeichen aus einer beliebigen Sprache enthält. Attribut:
Text::class
Verfahren:
Validation::text()
159 Name: words
Verwendung: words		 Bestätigt, dass die Eingabe eine Zeichenfolge ist, die nur Wörter und Leerzeichen ohne andere Zeichen enthält. Attribut:
Words::class
Verfahren:
Validation::words()
160 Name: spaceless
Verwendung: spaceless		 Bestätigt, dass die Eingabe eine Zeichenfolge ist, die keine Leerzeichen enthält. Attribut:
Spaceless::class
Verfahren:
Validation::spaceless()
161 Name: emoji
Verwendung: emoji		 Bestätigt, dass die Eingabe ein Emoji enthält. Attribut:
Emoji::class
Verfahren:
Validation::emoji()
162 Name: roman
Verwendung: roman		 Bestätigt, dass die Eingabe eine gültige römische Zahl ist. Attribut:
Roman::class
Verfahren:
Validation::roman()
163 Name: phone
Verwendung: phone		 Bestätigt, dass es sich bei der Eingabe um eine gültige Telefonnummer handelt (unterstützt: Nordamerika, Europa und die meisten Länder Asiens und des Nahen Ostens). Attribut:
Phone::class
Verfahren:
Validation::phone()
164 Name: geolocation
Verwendung: geolocation		 Bestätigt, dass es sich bei der Eingabe um eine gültige Geolokalisierung (Kombination aus Breitengrad- und Längengradkoordinaten) handelt. Attribut:
Geolocation::class
Verfahren:
Validation::geolocation()
165 Name: version
Verwendung: version		 Bestätigt, dass die Eingabe eine gültige semantische Versionsnummer ist. Attribut:
Version::class
Verfahren:
Validation::version()
166 Name: amount
Verwendung: amount		 Bestätigt, dass die Eingabe nur Zahlen, einen optionalen Dezimalpunkt (Komma oder Punkt) und ein optionales Minus (wird beispielsweise für Geldbeträge verwendet) enthält. Attribut:
Amount::class
Verfahren:
Validation::amount()
167 Name: amount.dollar
Verwendung: amount.dollar		 Bestätigt, dass es sich bei der Eingabe um einen gültig formatierten USD-Betrag handelt, wobei Dezimalpunkt und Tausendertrennzeichen optional sind. Attribut:
AmountDollar::class
Verfahren:
Validation::amountDollar()
168 Name: amount.euro
Verwendung: amount.euro		 Bestätigt, dass es sich bei der Eingabe um einen gültig formatierten Betrag in EUR handelt, wobei Dezimalpunkt und Tausendertrennzeichen optional sind. Attribut:
AmountEuro::class
Verfahren:
Validation::amountEuro()
169 Name: color
Verwendung: color		 Bestätigt, dass die Eingabe eine gültige CSS-Farbe ist (Schlüsselwort „lose“, HEX, HEX-Alpha, RGB, RGBA, RGB „neue Syntax“, HSL, HSLA, HSL „neue Syntax“). Attribut:
Color::class
Verfahren:
Validation::color()
170 Name: color.hex
Verwendung: color.hex		 Bestätigt, dass die Eingabe eine gültige CSS-HEX-Farbe ist. Attribut:
ColorHex::class
Verfahren:
Validation::colorHex()
171 Name: color.hexShort
Verwendung: color.hexShort		 Bestätigt, dass die Eingabe eine gültige CSS-3-Char-HEX-Farbe ist. Attribut:
ColorHexShort::class
Verfahren:
Validation::colorHexShort()
172 Name: color.hexLong
Verwendung: color.hexLong		 Bestätigt, dass die Eingabe eine gültige CSS-6-Char-HEX-Farbe ist. Attribut:
ColorHexLong::class
Verfahren:
Validation::colorHexLong()
173 Name: color.hexAlpha
Verwendung: color.hexAlpha		 Bestätigt, dass die Eingabe eine gültige CSS-HEX-Alpha-Farbe (4 oder 8 Zeichen) ist. Attribut:
ColorHexAlpha::class
Verfahren:
Validation::colorHexAlpha()
174 Name: color.rgb
Verwendung: color.rgb		 Bestätigt, dass die Eingabe eine gültige CSS-RGB-Farbe ist. Attribut:
ColorRgb::class
Verfahren:
Validation::colorRgb()
175 Name: color.rgba
Verwendung: color.rgba		 Bestätigt, dass die Eingabe eine gültige CSS-RGBA-Farbe ist. Attribut:
ColorRgba::class
Verfahren:
Validation::colorRgba()
176 Name: color.rgb.new
Verwendung: color.rgb.new		 Bestätigt, dass die Eingabe eine gültige CSS4-RGB-Farbe ist. Attribut:
ColorRgbNew::class
Verfahren:
Validation::colorRgbNew()
177 Name: color.hsl
Verwendung: color.hsl		 Bestätigt, dass die Eingabe eine gültige CSS-HSL-Farbe ist. Attribut:
ColorHsl::class
Verfahren:
Validation::colorHsl()
178 Name: color.hsla
Verwendung: color.hsla		 Bestätigt, dass die Eingabe eine gültige CSS-HSLA-Farbe ist. Attribut:
ColorHsla::class
Verfahren:
Validation::colorHsla()
179 Name: color.hsl.new
Verwendung: color.hsl.new		 Behauptet, dass die Eingabe eine gültige CSS4 -HSL -Farbe ist. Attribut:
ColorHslNew::class
Verfahren:
Validation::colorHslNew()
180 Name: color.keyword
Verwendung: color.keyword		 Behauptet, dass die Eingabe eine gültige CSS -Schlüsselwortfarbe ist (streng, wie in der CSS -Spezifikation). Attribut:
ColorKeyword::class
Verfahren:
Validation::colorKeyword()
181 Name: ssn
Verwendung: ssn		 Behauptet, dass die Eingabe eine gültige SSN ist (US -amerikanische Sozialversicherungsnummer). Attribut:
Ssn::class
Verfahren:
Validation::ssn()
182 Name: sin
Verwendung: sin		 Behauptet, dass die Eingabe eine gültige Sünde ist (CA -Sozialversicherungsnummer). Attribut:
Sin::class
Verfahren:
Validation::sin()
183 Name: nino
Verwendung: nino		 Behauptet, dass der Input ein gültiger NINO (UK National Insurance Number) ist. Attribut:
Nino::class
Verfahren:
Validation::nino()
184 Name: vin
Verwendung: vin		 Behauptet, dass die Eingabe eine gültige VIN ist (Fahrzeugidentifikationsnummer). Attribut:
Vin::class
Verfahren:
Validation::vin()
185 Name: issn
Nutzung: issn		 Behauptet, dass die Eingabe eine gültige ISSN ist (internationale Standard -Seriennummer). Attribut:
Issn::class
Verfahren:
Validation::issn()
186 Name: isin
Verwendung: isin		 Behauptet, dass die Eingabe eine gültige ISIN ist (internationale Wertpapier -Identifikationsnummer). Attribut:
Isin::class
Verfahren:
Validation::isin()
187 Name: isbn
Verwendung: isbn		 Behauptet, dass die Eingabe eine gültige ISBN ist (internationale Standardbuchnummer). Der Typ (10/13) kann spezifiziert werden, um das Muster einzugrenzen. Attribut:
Isbn::class
Verfahren:
Validation::isbn(string|int|null $type = null)
188 Name: imei
Verwendung: imei		 Behauptet, dass die Eingabe eine gültige IMEI (International Mobile Station Equipment Identity Number) ist. Attribut:
Imei::class
Verfahren:
Validation::imei()
189 Name: imei.sv
Verwendung: imei.sv		 Behauptet, dass die Eingabe eine gültige IMEI-SV (International Mobile Station Equipment Identity und Software-Versionsnummer) ist. Attribut:
ImeiSv::class
Verfahren:
Validation::imeiSv()
190 Name: meid
Verwendung: meid		 Behauptet, dass die Eingabe eine gültige MEID (mobile Gerätekennung) ist. Attribut:
Meid::class
Verfahren:
Validation::meid()
191 Name: esn
Verwendung: esn		 Behauptet, dass die Eingabe eine gültige ESN ist (elektronische Seriennummer). Attribut:
Esn::class
Verfahren:
Validation::esn()
192 Name: currency
Nutzung: currency		 Behauptet, dass die Eingabe ein gültiger Währungscode ist (Standard: "ISO 4217 Alpha"; numerisch: "ISO 4217 numerisch"). Attribut:
Currency::class
Verfahren:
Validation::currency(bool $numeric = false)
193 Name: currency.name
Nutzung: currency.name		 Behauptet, dass die Eingabe ein gültiger Währungsname ist (wie in ISO 4217). Attribut:
CurrencyName::class
Verfahren:
Validation::currencyName()
194 Name: creditcard
Nutzung: creditcard		 Behauptet, dass die Eingabe eine gültige Kreditkartennummer ist, sind ausgewogene Räume und/oder Striche zulässig. Attribut:
Creditcard::class
Verfahren:
Validation::creditcard()
195 Name: creditcard.visa
Nutzung: creditcard.visa		 Behauptet, dass die Eingabe eine gültige Visa -Kreditkartennummer ist, sind ausgewogene Räume und/oder Striche zulässig. Attribut:
CreditcardVisa::class
Verfahren:
Validation::creditcardVisa()
196 Name: creditcard.mastercard
Nutzung: creditcard.mastercard		 Behauptet, dass die Eingabe eine gültige MasterCard -Kreditkartennummer ist, sind ausgewogene Räume und/oder Striche zulässig. Attribut:
CreditcardMastercard::class
Verfahren:
Validation::creditcardMastercard()
197 Name: creditcard.discover
Nutzung: creditcard.discover		 Behauptet, dass die Eingabe eine gültige Discover -Kreditkartennummer ist, ausgewogene Räume und/oder Striche sind zulässig. Attribut:
CreditcardDiscover::class
Verfahren:
Validation::creditcardDiscover()
198 Name: creditcard.americanExpress
Nutzung: creditcard.americanExpress		 Behauptet, dass die Eingabe eine gültige American Express -Kreditkartennummer ist, ausgewogene Räume und/oder Striche sind zulässig. Attribut:
CreditcardAmericanExpress::class
Verfahren:
Validation::creditcardAmericanExpress()
199 Name: creditcard.dinersClub
Nutzung: creditcard.dinersClub		 Behauptet, dass die Eingabe eine gültige Kreditkartennummer von Diners Club ist, sind ausgewogene Räume und/oder Striche zulässig. Attribut:
CreditcardDinersClub::class
Verfahren:
Validation::creditcardDinersClub()
200 Name: creditcard.jcb
Nutzung: creditcard.jcb		 Behauptet, dass die Eingabe eine gültige JCB -Kreditkartennummer ist, sind ausgewogene Räume und/oder Striche zulässig. Attribut:
CreditcardJcb::class
Verfahren:
Validation::creditcardJcb()
201 Name: creditcard.maestro
Nutzung: creditcard.maestro		 Behauptet, dass die Eingabe eine gültige Maestro -Kreditkartennummer ist, sind ausgewogene Räume und/oder Striche zulässig. Attribut:
CreditcardMaestro::class
Verfahren:
Validation::creditcardMaestro()
202 Name: creditcard.chinaUnionPay
Nutzung: creditcard.chinaUnionPay		 Behauptet, dass es sich bei der Eingabe um eine gültige Kreditkartennummer der China UnionPay handelt, sind ausgewogene Räume und/oder Striche zulässig. Attribut:
CreditcardChinaUnionPay::class
Verfahren:
Validation::creditcardChinaUnionPay()
203 Name: creditcard.instaPayment
Nutzung: creditcard.instaPayment		 Behauptet, dass die Eingabe eine gültige Kreditkartennummer für Instapayment ist, sind ausgewogene Räume und/oder Striche zulässig. Attribut:
CreditcardInstaPayment::class
Verfahren:
Validation::creditcardInstaPayment()
204 Name: creditcard.laser
Nutzung: creditcard.laser		 Behauptet, dass die Eingabe eine gültige Laser -Kreditkartennummer ist, sind ausgewogene Räume und/oder Striche zulässig. Attribut:
CreditcardLaser::class
Verfahren:
Validation::creditcardLaser()
205 Name: creditcard.uatp
Nutzung: creditcard.uatp		 Behauptet, dass die Eingabe eine gültige UATP -Kreditkartennummer ist, sind ausgewogene Räume und/oder Striche zulässig. Attribut:
CreditcardUatp::class
Verfahren:
Validation::creditcardUatp()
206 Name: creditcard.mir
Nutzung: creditcard.mir		 Behauptet, dass die Eingabe eine gültige MIR -Zahlungssystemkartennummer ist, ausgewogene Räume und/oder Striche sind zulässig. Attribut:
CreditcardMir::class
Verfahren:
Validation::creditcardMir()
207 Name: cvv
Verwendung: cvv		 Behauptet, dass die Eingabe ein gültiger CVV (Kartensicherheitscode) ist. Attribut:
Cvv::class
Verfahren:
Validation::cvv()
208 Name: bic
Verwendung: bic		 Behauptet, dass die Eingabe ein gültiger BIC (Bank -Kennercode) ist. Attribut:
Bic::class
Verfahren:
Validation::bic()
209 Name: iban
Nutzung: iban:IQ		 Behauptet, dass die Eingabe eine gültige IBAN (internationale Bankkontonummer) ist. Der Ländercode "ISO 3166-1 Alpha-2" kann so spezifiziert werden, um das Muster einzugrenzen. Attribut:
Iban::class
Verfahren:
Validation::iban(?string $country = null)
210 Name: luhn
Verwendung: luhn		 Behauptet, dass der Eingang den Luhn -Algorithmus -Check überträgt. Diese Regel wird hauptsächlich in Verbindung mit anderen Regeln wie Kreditkartennummern und Identifikatoren verwendet, um die Gültigkeit des Subjekts weiter zu überprüfen. Attribut:
Luhn::class
Verfahren:
Validation::luhn()
211 Name: php.keyword
Verwendung: php.keyword		 Behauptet, dass die Eingabe ein PHP -Sprachschlüsselwort ist. Attribut:
PhpKeyword::class
Verfahren:
Validation::phpKeyword()
212 Name: php.reserved
Verwendung: php.reserved		 Behauptet, dass die Eingabe ein PHP -Sprache ist, das reserviert ist. Attribut:
PhpReserved::class
Verfahren:
Validation::phpReserved()
213 Name: php.reserved.extra
Verwendung: php.reserved.extra		 Behauptet, dass die Eingabe ein PHP -Sprache ist, das reserviert ist, einschließlich weicher reservierter Wörter. Attribut:
PhpReservedExtra::class
Verfahren:
Validation::phpReservedExtra()
214 Name: regex
Verwendung: regex		 Behauptet, dass die Eingabe ein gültiger regulärer Ausdruck ist. Attribut:
Regex::class
Verfahren:
Validation::regex()
215 Name: bool
Verwendung: siehe boolean		 Alias, finden Sie in boolean für die vollständige Beschreibung. Attribut:
BoolConstraint::class
Verfahren:
Validation::bool()
216 Name: int
Verwendung: Siehe integer		 Alias, finden Sie in integer für die vollständige Beschreibung. Attribut:
IntConstraint::class
Verfahren:
Validation::int()
217 Name: long
Verwendung: Siehe integer		 Alias, finden Sie in integer für die vollständige Beschreibung. Attribut:
Long::class
Verfahren:
Validation::long()
218 Name: double
Verwendung: Siehe float		 Alias, finden Sie in float für die vollständige Beschreibung. Attribut:
Double::class
Verfahren:
Validation::double()
219 Name: real
Verwendung: Siehe float		 Alias, finden Sie in float für die vollständige Beschreibung. Attribut:
Real::class
Verfahren:
Validation::real()
220 Name: str
Verwendung: siehe string		 Alias, finden Sie in string für die vollständige Beschreibung. Attribut:
Str::class
Verfahren:
Validation::str()
221 Name: arr
Verwendung: siehe array		 Alias, finden Sie in array für die vollständige Beschreibung. Attribut:
Arr::class
Verfahren:
Validation::arr()
222 Name: obj
Verwendung: Siehe object		 Alias ​​finden Sie auf object für die vollständige Beschreibung. Attribut:
Obj::class
Verfahren:
Validation::obj()
223 Name: stream
Verwendung: Siehe resource		 Alias ​​finden Sie auf resource um die vollständige Beschreibung zu erhalten. Attribut:
Stream::class
Verfahren:
Validation::stream()
224 Name: assert
Verwendung: Sehen Sie if		 Alias, siehe if für die vollständige Beschreibung. Attribut:
Assert::class
Verfahren:
Validation::assert(mixed $actual, mixed $expected = true, string $operator = '==')
225 Name: assert.equals
Nutzung: Sehen Sie if.eq		 Alias ​​finden Sie in if.eq für die vollständige Beschreibung. Attribut:
AssertEquals::class
Verfahren:
Validation::assertEquals(mixed $actual, mixed $expected)
226 Name: assert.notEquals
Nutzung: Sehen Sie, if.neq		 Alias ​​finden Sie in if.neq für die vollständige Beschreibung. Attribut:
AssertNotEquals::class
Verfahren:
Validation::assertNotEquals(mixed $actual, mixed $expected)
227 Name: assert.greaterThan
Verwendung: Sehen Sie if.gt		 Alias ​​finden Sie in if.gt für die vollständige Beschreibung. Attribut:
AssertGreaterThan::class
Verfahren:
Validation::assertGreaterThan(mixed $actual, mixed $expected)
228 Name: assert.greaterThanOrEquals
Verwendung: Sehen Sie if.gte		 Alias ​​finden Sie in if.gte für die vollständige Beschreibung. Attribut:
AssertGreaterThanOrEquals::class
Verfahren:
Validation::assertGreaterThanOrEquals(mixed $actual, mixed $expected)
229 Name: assert.lessThan
Verwendung: Sehen Sie if.lt		 Alias ​​finden Sie in if.lt für die vollständige Beschreibung. Attribut:
AssertLessThan::class
Verfahren:
Validation::assertLessThan(mixed $actual, mixed $expected)
230 Name: assert.lessThanOrEquals
Verwendung: Sehen Sie if.lte		 Alias ​​finden Sie in if.lte für die vollständige Beschreibung. Attribut:
AssertLessThanOrEquals::class
Verfahren:
Validation::assertLessThanOrEquals(mixed $actual, mixed $expected)
231 Name: blank
Verwendung: Siehe empty		 Alias, finden Sie auf empty um die vollständige Beschreibung zu erhalten. Attribut:
Blank::class
Verfahren:
Validation::blank()
232 Name: is
Verwendung: Siehe equals		 Alias, siehe equals Beschreibung. Attribut:
Is::class
Verfahren:
Validation::is(mixed $value)
233 Name: same
Verwendung: Siehe equals		 Alias, siehe equals Beschreibung. Attribut:
Same::class
Verfahren:
Validation::same(mixed $value)
234 Name: pattern
Verwendung: Siehe matches		 Alias, siehe matches für die vollständige Beschreibung. Attribut:
Pattern::class
Verfahren:
Validation::pattern(string $pattern)
235 Name: choice
Verwendung: Siehe in		 Alias, finden Sie in der vollständigen Beschreibung. Attribut:
Choice::class
Verfahren:
Validation::choice(string|int|float|bool|null ...$values)
236 Name: size
Nutzung: Siehe count		 Alias ​​finden Sie in der count der vollständigen Beschreibung. Attribut:
Size::class
Verfahren:
Validation::size(int $size)
237 Name: length
Nutzung: Siehe count		 Alias ​​finden Sie in der count der vollständigen Beschreibung. Attribut:
Length::class
Verfahren:
Validation::length(int $count)
238 Name: range
Verwendung: Siehe between		 Alias, between die vollständige Beschreibung. Attribut:
Range::class
Verfahren:
Validation::range(int|float $min, int|float $max)
239 Name: minmax
Verwendung: Siehe between		 Alias, between die vollständige Beschreibung. Attribut:
Minmax::class
Verfahren:
Validation::minmax(int|float $min, int|float $max)
240 Name: filled
Verwendung: Siehe required		 Alias, beziehen Sie required auf die vollständige Beschreibung. Attribut:
Filled::class
Verfahren:
Validation::filled()
241 Name: present
Verwendung: Siehe required		 Alias, beziehen Sie required auf die vollständige Beschreibung. Attribut:
Present::class
Verfahren:
Validation::present()
242 Name: optional
Verwendung: Siehe allowed		 Alias, beziehen Sie allowed auf die vollständige Beschreibung. Attribut:
Optional::class
Verfahren:
Validation::optional()
243 Name: date
Verwendung: Siehe datetime		 Alias ​​finden Sie in datetime für die vollständige Beschreibung. Attribut:
Date::class
Verfahren:
Validation::date()
244 Name: date.equals
Verwendung: Siehe datetime.eq		 Alias ​​finden Sie in datetime.eq für die vollständige Beschreibung. Attribut:
DateEquals::class
Verfahren:
Validation::dateEquals(string $datetime)
245 Name: date.before
Verwendung: Siehe datetime.lt		 Alias ​​finden Sie in datetime.lt um die vollständige Beschreibung zu erhalten. Attribut:
DateBefore::class
Verfahren:
Validation::dateBefore(string $datetime)
246 Name: date.beforeOrEquals
Verwendung: Siehe datetime.lte		 Alias ​​finden Sie in datetime.lte für die vollständige Beschreibung. Attribut:
DateBeforeOrEquals::class
Verfahren:
Validation::dateBeforeOrEquals(string $datetime)
247 Name: date.after
Verwendung: Siehe datetime.gt		 Alias ​​finden Sie in datetime.gt für die vollständige Beschreibung. Attribut:
DateAfter::class
Verfahren:
Validation::dateAfter(string $datetime)
248 Name: date.afterOrEquals
Verwendung: Siehe datetime.gte		 Alias ​​finden Sie in datetime.gte für die vollständige Beschreibung. Attribut:
DateAfterOrEquals::class
Verfahren:
Validation::dateAfterOrEquals(string $datetime)
249 Name: date.format
Verwendung: Siehe datetime.format		 Alias, finden Sie in datetime.format für die vollständige Beschreibung. Attribut:
DateFormat::class
Verfahren:
Validation::dateFormat(string $format)
250 Name: cakeday
Verwendung: Siehe datetime.birthday		 Alias ​​finden Sie in datetime.birthday für die vollständige Beschreibung. Attribut:
Cakeday::class
Verfahren:
Validation::cakeday()

Makros

Makro Validierungsausdruck
[nullable] null^~empty
[alnumDash] matches:"/[a-zA-Z0-9-_]+/"
[twitterHandle] matches:'"/^[a-zA-Z_]{1}[a-zA-Z0-9_]{0,14}$/"'
[gmail] email&string.contains:"@gmail."
[eduMail] email&string.endsWith:".edu"

Benchmarks

Inzwischen mag es so aussehen, als würde mighty zu viel tun und die Leistungsbedenken beginnen sich zu entstehen. Nun, das ist nicht nötig, darüber zu sorgen. mighty ist sehr schnell und ist optimiert, um die beste Leistung zu erzielen. Hier sind einige Benchmarks der Leistung des Validators:

Nicht so wissenschaftlicher Benchmark

Die Leistung von mighty Validator und Laravel Validator in einer Laravel -Anwendung. Der Test wurde unter Verwendung einer Reihe von 50000 Elementen durchgeführt, die Hälfte von ihnen ist Ganzzahlen und die andere Hälfte sind numerische Saiten. Jeder Validator wurde zehnmal (nacheinander) getestet und das durchschnittliche Ergebnis dieser 10 wurde gesammelt:

mighty Validator with XDebug disabled [ // required&integer 'preparationTime' => '1.32ms', // the time required to build the array 'validationTime' => '1107.29ms', // the time required to validate the array 'totalTime' => '1108.61ms', // the time required for the whole process ] // mighty Validator with XDebug enabled [ // required&integer 'preparationTime' => '9.09ms', 'validationTime' => '6085.04ms', 'totalTime' => '6094.13ms', ] // Laravel Validator with XDebug disabled [ // required|integer 'preparationTime' => '1.33ms', 'validationTime' => '13882.72ms', 'totalTime' => '13884.05ms', ] // Laravel Validator with XDebug enabled [ // required|integer 'preparationTime' => '9.33ms', 'validationTime' => '24010.60ms', 'totalTime' => '24019.93ms', ]">
 $ data = array_merge ( range ( 1 , 25000 ), array_map ( ' strval ' , range ( ' 25001 ' , ' 50000 ' )));
// mighty Validator with XDebug disabled
[ // required&integer
  ' preparationTime ' => ' 1.32ms ' ,    // the time required to build the array
  ' validationTime '  => ' 1107.29ms ' , // the time required to validate the array
  ' totalTime '       => ' 1108.61ms ' , // the time required for the whole process
]
// mighty Validator with XDebug enabled
 [ // required&integer
  ' preparationTime ' => ' 9.09ms ' ,
  ' validationTime '  => ' 6085.04ms ' ,
  ' totalTime '       => ' 6094.13ms ' ,
]
// Laravel Validator with XDebug disabled
[ // required|integer
  ' preparationTime ' => ' 1.33ms ' ,
  ' validationTime '  => ' 13882.72ms ' ,
  ' totalTime '       => ' 13884.05ms ' ,
]
// Laravel Validator with XDebug enabled
[ // required|integer
  ' preparationTime ' => ' 9.33ms ' ,
  ' validationTime '  => ' 24010.60ms ' ,
  ' totalTime '       => ' 24019.93ms ' ,
]

mighty ist also etwa 12,5x -mal schneller als Laravel Validator, wobei XDEBUG mit aktiviertem XDEBUG etwa 4x -mal schneller ist.

Wissenschaftliche Benchmark

Der Benchmark erfolgt mit Phpbench. Hier ist eine kurze Übersicht:

mighty/phpbench.json.dist with PHP version 8.1.9, xdebug , opcache MAKS mighty BenchmarksConstraintBench benchAValidValidatableObject............I4 ✔ Mo305.595074ops/s (±0.75%) benchAnInvalidValidatableObject.........I4 ✔ Mo326.708522ops/s (±1.02%) MAKS mighty BenchmarksValidatorBench benchSingleValidationString.............I4 ✔ Mo0.02212ms (±1.59%) benchSingleValidationObject.............I4 ✔ Mo0.126929ms (±1.63%) benchBulkValidationObject...............I4 ✔ Mo9.345847ms (±0.62%) benchBulkValidationString...............I4 ✔ Mo6.734188ms (±0.40%) Subjects: 6, Assertions: 6, Failures: 0, Errors: 0">
 PHPBench (1.2.6) running benchmarks...
with configuration file: mighty /phpbench.json.dist
with PHP version 8.1.9, xdebug , opcache 

MAKS mighty BenchmarksConstraintBench

    benchAValidValidatableObject............I4 ✔ Mo305.595074ops/s (±0.75%)
    benchAnInvalidValidatableObject.........I4 ✔ Mo326.708522ops/s (±1.02%)

MAKS mighty BenchmarksValidatorBench

    benchSingleValidationString.............I4 ✔ Mo0.02212ms (±1.59%)
    benchSingleValidationObject.............I4 ✔ Mo0.126929ms (±1.63%)
    benchBulkValidationObject...............I4 ✔ Mo9.345847ms (±0.62%)
    benchBulkValidationString...............I4 ✔ Mo6.734188ms (±0.40%)

Subjects: 6, Assertions: 6, Failures: 0, Errors: 0

■ FACT: Das neueste Benchmark -Ergebnis finden Sie auch in der CI -Pipeline, die mit jedem Push/PR bis zum Upsteam aktualisiert wird.

Notizen

  1. mighty generiert standardmäßig wirklich freundliche Fehlermeldungen (derzeit nur in englischer Sprache). Diese Nachrichten können auf Validator-/Beschränkungsbasen leicht überschrieben werden. Möglicherweise möchten Sie diese Nachrichten in verschiedenen Sprachen haben. Dafür kann die Methode MAKS mighty Rule::setMessageTranslator() verwendet werden. Diese Methode ist eine bequeme Möglichkeit, einen globalen Nachrichtenübersetzer festzulegen. Sie dauert eine Schließung, die die rohe Nachricht (mit Platzhaltern) als Argument erhält und die übersetzte Version dieser Nachricht zurückgeben muss.
  2. Siehe Sprachspezifikation der mighty Validation Expression, um mehr über die Theorie hinter mighty zu erfahren und eine Art und Weise zu verstehen, wie die Sprache funktioniert.
  3. Siehe mighty API -Dokumentation, um mehr über die PHP -API zu erfahren. Die API ist gut dokumentiert und es sollte nichts geben, was dort nicht bedeckt ist.
  4. mighty ist derzeit eine reine Validierungsbibliothek, sie führt keine Transformation in den Daten aus. Der Motor und das aktuelle Design sind flexibel genug und können verwendet werden, um einen Desinfektionsmittel einfach darauf zu implementieren. Es gibt im Moment keinen Plan, dies zu erstellen, aber es kann ein zukünftiger Meilenstein sein.

Lizenz

mighty ist ein Open-Source-Projekt, das nach der MIT -Lizenz lizenziert wurde.
Copyright (C) 2022 Marwan al-Soltany. Alle Rechte vorbehalten.

Expandieren
Zusätzliche Informationen
Ähnliche Anwendungen
Empfohlen für Sie
Ähnliche Nachrichten Alle