Page d'accueil>Code source PHP>Autres catégories
Télécharger

mighty

La dernière bibliothèque de validation dont vous aurez besoin !


Table des matières

Installation
À propos mighty
Démarrage rapide
mVEL
Exemples
Contraintes
Validations
Documentation
Spécification
Journal des modifications


Si vous aimez ce projet et souhaitez soutenir son développement, lui donner un serait apprécié !


Principales fonctionnalités

  1. Zéro dépendance.
  2. Indépendant du framework, peut être intégré dans n’importe quelle base de code.
  3. Expressif, intuitif et facile à utiliser avec plus de 250 règles de validation intégrées.

<classe de durée= puissante démo" style="max-width: 100%;">

Installation 

composer require marwanalsoltany/ mighty

À propos mighty

La validation est une tâche courante dans toute application Web. Les données transmises à l'application via des formulaires (ou tout autre type de saisie) doivent toujours être validées par rapport à un ensemble de règles. mighty peut gérer d'une manière simple et expressive.

mighty est une bibliothèque de validation rapide, puissante, robuste et facile à utiliser, avec laquelle il est tout simplement amusant de travailler, elle facilite la validation de toutes les données. Grâce à la puissance du mighty langage d'expression de validation (mVEL), cela ne ressemble à rien de ce que vous avez vu auparavant. Avec son approche de validation et plus de 250 règles intégrées, il n'y a pratiquement rien que vous ne puissiez valider, de manière très expressive et compacte. En termes simples, la validation sous stéroïdes est mighty ! C'est en effet la dernière bibliothèque de validation dont vous aurez besoin.

mighty propose plusieurs approches différentes pour valider les données. Le cas d'utilisation le plus courant consiste à valider les données entrantes via des requêtes HTTP, mais cela ne se limite bien sûr pas à cela ; mighty fournit également des attributs sous forme de contraintes pour valider facilement des modèles et/ou tout type d'objets.

mighty comprend une grande variété de règles de validation pratiques que vous pouvez appliquer comme une seule règle ou les combiner les unes avec les autres à l'aide d'opérateurs pour créer des validations encore plus complexes.

Démarrage rapide

Pour en savoir plus sur les puissantes fonctionnalités de validation de mighty , allons droit au but et examinons quelques exemples :

Validation générale des données

Validation des données du formulaire à l'aide de Validator::class :

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

Validation des objets

Validation de l'état d'un objet à l'aide des attributs Constraint::class :

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

Un exemple de résultat de la validation d'un objet validable ressemblerait à ceci : 

 // 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.

Vérifiez également ValidatableObject et ValidatableObjectChild .

■ Astuce : D’autres exemples peuvent être trouvés dans la section Exemples.

langage d'expression de validation mighty

mighty a le concept d'expression de validation. L'expression de validation dans ses formes les plus simples n'est qu'une chaîne qui décrit la mighty laquelle les données données doivent être validées. Ces chaînes sont basées sur la mighty spécification du langage d'expression de validation (mVEL). mVEL est assez simple, lisible par l'homme et facile à gérer. Il s'agit d'une combinaison de concepts et/ou de spécifications bien établis comme l'algèbre booléenne, les opérateurs bit à bit, JSON et CSV.

Par conséquent, l'expression de validation peut être définie comme une chaîne contenant des règles séparées par des opérateurs au niveau du bit qui construiront une expression qui, une fois évaluée à l'aide de la logique de l'algèbre booléenne , aboutira au résultat final de la validation. Les règles peuvent avoir des arguments, les types de ces arguments peuvent être désignés en utilisant les mêmes règles de types JSON . Une règle peut également avoir plusieurs arguments et les arguments sont séparés par des virgules ( CSV ).

Par exemple, required&string&between:2,255|null est une expression de validation valide, cette expression peut être comprise comme suit :

  1. L'expression a quatre règles.
  2. L'expression contient les règles :
    1. required Affirme que l'entrée est présente.
    2. string Affirme que l'entrée est une chaîne.
    3. between:2,255 Affirme que l'entrée est une chaîne d'une longueur comprise entre 2 et 255.
    4. null Affirme que l'entrée est nulle.
  3. Le résultat final est le résultat de l'évaluation de l'expression résultant du résultat de chaque règle collée à l'aide d'opérateurs au niveau du bit.

L'expression required&string&between:2,255|null signifie que l'entrée doit être présente ; AND de type chaîne ; ET entre 2 et 255 de longueur ; OU nul. Il s'agit donc d'une chaîne nullable qui, lorsqu'elle n'est pas nulle, doit comporter entre 2 et 255 caractères.

Disons que l'entrée était " mighty is Awesome!" , le résultat de l'expression required&string&between:2,255|null par rapport à cette entrée serait 1&1&1|0 ce qui donnera 1 qui est true , si l'entrée était null , le résultat serait 0&0&0|1 = 1 , si l'entrée était X le résultat serait 0&0&0|0 = 0 , etc...

Contrairement à d'autres implémentations de validations, le concept d' algèbre booléenne utilisant des opérateurs au niveau du bit , donne la possibilité de construire des validations complexes très lisibles et compactes tout en gardant les règles à un nombre minimum, en réutilisant la logique existante de manière inversée ou composée, et enfin en gardant le base de code aussi SÈCHE que possible. Les avantages peuvent être résumés dans les points suivants :

  1. Une règle ne peut PAS être modifiée (en utilisant ~ ) pour faire exactement le contraire de ce qu'elle fait normalement.
  2. Une règle complexe peut être le résultat d'une opération AND (en utilisant & ), d'une opération OR (en utilisant | ) ou d'une opération XOR (en utilisant ^ ), de deux règles simples ou plus.
  3. Les règles peuvent être regroupées et/ou avoir une priorité plus élevée en utilisant des parenthèses, à savoir OPEN (en utilisant ( ) et CLOSE (en utilisant ) ).
  4. Une expression de validation peut également avoir un comportement, qui est un caractère préfixant la chaîne de l'expression de validation qui affectera toutes les règles. Les comportements disponibles sont :
    1. NORMAL : exécute toutes les règles, comportement par défaut (pas de préfixe).
    2. OPTIMISTIQUE : arrête l'exécution des règles après le premier succès (préfixe ? ).
    3. PESSIMISTE : arrête l'exécution des règles après le premier échec (préfixe ! ).
  5. La lisibilité peut être améliorée en aliasant certaines règles ou en ajoutant des ensembles de règles sous forme de macros et en les exécutant à l'aide de la syntaxe [macro] .

De plus, le concept JSON garantit la sécurité des types de données des arguments, et le concept CSV garantit que la liste des arguments a des règles d'analyse claires.

Le plus sympa, c'est que vous n'avez pas besoin de mémoriser toutes les règles ni la syntaxe du Validation Expression Language. La classe Validation est une interface fluide qui peut être utilisée pour créer une expression de validation. Il connaît toutes mighty règles disponibles et prend entièrement en charge IDE-Intellisense pour le rendre aussi simple que possible. Par exemple:

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 ();

■ Fait : Il faut généralement plus de mots pour décrire ce que fait une expression de validation que l'expression de validation elle-même !

Exemples

Voici quelques exemples de scénarios du monde réel :

Validation d'une valeur unique

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);

Validation des données structurées

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);

■ Astuce : lorsque vous fournissez des remplacements de message au Validator::class , il est conseillé d'utiliser le RuleValidation::class pour définir les clés du tableau. Cette classe contient tous mighty noms de règles intégrées sous forme de constantes de classe.

Extension du validateur

Le validateur peut être étendu de trois manières :

  • En ajoutant une règle.
  • En ajoutant un alias.
  • En ajoutant une macro.
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) ' ,
        ],
    ],
];

■ Astuce : consultez les rules , aliases et macros par défaut du Validator pour voir plus d'exemples.

Contraintes

mighty se compose de plus de 250 règles/attributs qui peuvent être utilisés pour valider n'importe quelle donnée ou valeur de classe, constante de classe, propriété et méthode.

Les attributs sont divisés en trois groupes principaux :

  1. Attributs de contrainte générique
  2. Attributs de contrainte spéciale
  3. Attributs de contrainte de règle

Groupe d'attributs de contrainte générique

Les attributs de contrainte générique sont situés sous l'espace de noms MAKS mighty Validation .

Ce groupe se compose actuellement d'un seul attribut ; c'est l'attribut Constraint . Cet attribut prend une expression de validation pour valider les données auxquelles il est appliqué. C'est également la classe de base pour tous les autres attributs.

Groupe d'attributs de contrainte spéciale

Les attributs de contrainte spéciale sont situés sous l'espace de noms MAKS mighty ValidationConstraint .

Ce groupe contient des attributs qui effectuent une tâche spécifique disponible uniquement dans le contexte des attributs. Il se compose des attributs suivants :

  • Rule : Cet attribut est utilisé pour valider n'importe quelle donnée à l'aide d'une seule règle de validation. Il s'agit également de la classe de base pour tous les attributs du groupe d'attributs de contrainte de règle.
  • Callback : Cet attribut est utilisé pour valider n'importe quelle donnée à l'aide d'une fonction de rappel.
  • Valid : Cet attribut est utilisé pour valider la validité d'un objet validable.
  • Shape : Cet attribut est utilisé pour valider la forme d'un tableau ou d'un objet. Notez qu'il s'agit du seul attribut qui valide un ensemble de valeurs (données structurées) plutôt qu'une valeur unique.
  • Compound : cet attribut est utilisé pour combiner un ensemble de contraintes pour créer une expression de validation. Les contraintes peuvent être combinées à l'aide de n'importe quel opérateur, et peuvent également avoir un comportement. Il sert de moyen orienté objet pour créer une expression de validation.

■ Remarque : Notez que les contraintes dont l'utilisation est autorisée avec les attributs Shape::class et Compound::class doivent être des instances réelles de Constraint::class , Rule::class ou Compound::class . Les Callback::class , Valid::class ou Shape::class du groupe d'attributs de contraintes spéciales ne sont PAS autorisés. Si vous avez besoin de cette fonctionnalité, ouvrez un ticket et nous discuterons de sa mise en œuvre

Groupe d'attributs de contrainte de règle

Les attributs de contrainte de règle sont situés sous l'espace de noms MAKS mighty ValidationConstraintRule .

Ce groupe contient des attributs basés sur une seule règle de validation. Il comprend la plupart des attributs mighty . Reportez-vous à la section Validations pour la liste complète.

Ajout d'une contrainte personnalisée

mighty a une énorme liste de contraintes intégrées, il est vraiment rare que vous ayez besoin d'autre chose que ce que mighty fournit. Néanmoins, il est parfois nécessaire d'avoir une contrainte personnalisée. Voici comment y parvenir :

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
    }
}

■ Remarque : Les contraintes personnalisées sont considérées comme faisant partie du groupe d'attributs de contraintes spéciales (c'est-à-dire qu'elles ne peuvent pas être utilisées avec/à l'intérieur des contraintes Shape::class et Compound::class ).

Validations

Le tableau suivant répertorie toutes les règles disponibles, y compris leurs équivalents d'attribut et de méthode :

Règles et alias

  • Validation::class
  • Constraint::class et Constraint/Rule/*
Non. Règle Description Attribut / Méthode
001 Nom : null
Utilisation : null		 Affirme que l'entrée est nulle. Attribut:
NullConstraint::class
Méthode:
Validation::null()
002 Nom : boolean
Utilisation : boolean		 Affirme que l'entrée est un booléen. Attribut:
Boolean::class
Méthode:
Validation::boolean()
003 Nom : integer
Utilisation : integer		 Affirme que l'entrée est un entier. Attribut:
Integer::class
Méthode:
Validation::integer()
004 Nom : float
Utilisation : float		 Affirme que l'entrée est un flottant. Attribut:
FloatConstraint::class
Méthode:
Validation::float()
005 Nom : numeric
Utilisation : numeric		 Affirme que l'entrée est numérique. Attribut:
NumericConstraint::class
Méthode:
Validation::numeric()
006 Nom : string
Utilisation : string		 Affirme que l'entrée est une chaîne. Attribut:
StringConstraint::class
Méthode:
Validation::string()
007 Nom : scalar
Utilisation : scalar		 Affirme que l'entrée est un scalaire. Attribut:
Scalar::class
Méthode:
Validation::scalar()
008 Nom : array
Utilisation : array		 Affirme que l'entrée est un tableau. Attribut:
ArrayConstraint::class
Méthode:
Validation::array()
009 Nom : object
Utilisation : object		 Affirme que l'entrée est un objet. Attribut:
ObjectConstraint::class
Méthode:
Validation::object()
010 Nom : callable
Utilisation : callable		 Affirme que l'entrée est appelable. Attribut:
CallableConstraint::class
Méthode:
Validation::callable()
011 Nom : iterable
Utilisation : iterable		 Affirme que l'entrée est un itérable. Attribut:
IterableConstraint::class
Méthode:
Validation::iterable()
012 Nom : countable
Utilisation : countable		 Affirme que l'entrée est un dénombrable. Attribut:
Countable::class
Méthode:
Validation::countable()
013 Nom : resource
Utilisation : resource		 Affirme que l'entrée est une ressource. Attribut:
ResourceConstraint::class
Méthode:
Validation::resource()
014 Nom : type
Utilisation : type:'["int","float"]'		 Affirme que l'entrée est l'un des types donnés. Attribut:
Type::class
Méthode:
Validation::type(string|array $type)
015 Nom : type.debug
Utilisation : type.debug:string		 Affirme que l'entrée est du type donné à l'aide de get_debug_type(). Attribut:
TypeDebug::class
Méthode:
Validation::typeDebug(string $type)
016 Nom : alpha
Utilisation : alpha		 Affirme que l'entrée est constituée uniquement de caractères alphabétiques. Attribut:
Alpha::class
Méthode:
Validation::alpha()
017 Nom : alnum
Utilisation : alnum		 Affirme que l'entrée est constituée uniquement de caractères alphanumériques. Attribut:
Alnum::class
Méthode:
Validation::alnum()
018 Nom : lower
Utilisation : lower		 Affirme que l'entrée est constituée uniquement de caractères minuscules. Attribut:
Lower::class
Méthode:
Validation::lower()
019 Nom : upper
Utilisation : upper		 Affirme que l'entrée est constituée uniquement de caractères majuscules. Attribut:
Upper::class
Méthode:
Validation::upper()
020 Nom : cntrl
Utilisation : cntrl		 Affirme que l'entrée est constituée uniquement de caractères de contrôle. Attribut:
Cntrl::class
Méthode:
Validation::cntrl()
021 Nom : space
Utilisation : space		 Affirme que l'entrée est constituée uniquement de caractères d'espacement. Attribut:
Space::class
Méthode:
Validation::space()
022 Nom : punct
Utilisation : punct		 Affirme que l'entrée est constituée uniquement de caractères de ponctuation. Attribut:
Punct::class
Méthode:
Validation::punct()
023 Nom : graph
Utilisation : graph		 Affirme que l'entrée est constituée uniquement de caractères graphiques (caractères qui créent une sortie visible). Attribut:
Graph::class
Méthode:
Validation::graph()
024 Nom : print
Utilisation : print		 Affirme que l'entrée est constituée uniquement de caractères imprimables. Attribut:
PrintConstraint::class
Méthode:
Validation::print()
025 Nom : digit
Utilisation : digit		 Affirme que l'entrée est constituée uniquement de chiffres (caractères numériques). Attribut:
Digit::class
Méthode:
Validation::digit()
026 Nom : xdigit
Utilisation : xdigit		 Affirme que l'entrée représente des chiffres hexadécimaux. Attribut:
Xdigit::class
Méthode:
Validation::xdigit()
027 Nom : booleanLike
Utilisation : booleanLike		 Affirme que l'entrée est une valeur qui peut être analysée comme un booléen (TRUE : true, "true", "1", "on", "yes" ; FALSE : false, "false", "0", "off" , "non", "", nul). Attribut:
BooleanLike::class
Méthode:
Validation::booleanLike()
028 Nom : integerLike
Utilisation : integerLike:0,100		 Affirme que l'entrée est une valeur qui peut être analysée comme un entier dans la plage spécifiée. Attribut:
IntegerLike::class
Méthode:
Validation::integerLike(int $min = PHP_INT_MIN, int $max = PHP_INT_MAX)
029 Nom : integerLike.allowOctal
Utilisation : integerLike.allowOctal:0,100		 Affirme que l'entrée est une valeur qui peut être analysée comme un entier dans la plage spécifiée et peut être en notation octale. Attribut:
IntegerLikeAllowOctal::class
Méthode:
Validation::integerLikeAllowOctal(int $min = PHP_INT_MIN, int $max = PHP_INT_MAX)
030 Nom : integerLike.allowHex
Utilisation : integerLike.allowHex:0,100		 Affirme que l'entrée est une valeur qui peut être analysée comme un entier dans la plage spécifiée et peut être en notation hexadécimale. Attribut:
IntegerLikeAllowHex::class
Méthode:
Validation::integerLikeAllowHex(int $min = PHP_INT_MIN, int $max = PHP_INT_MAX)
031 Nom : floatLike
Utilisation : floatLike:1.0,100.0		 Affirme que l'entrée est une valeur qui peut être analysée comme un flottant dans la plage spécifiée. Attribut:
FloatLike::class
Méthode:
Validation::floatLike(float $min = PHP_FLOAT_MIN, float $max = PHP_FLOAT_MAX)
032 Nom : floatLike.allowThousands
Utilisation : floatLike.allowThousands:1.0,100.0		 Affirme que l'entrée est une valeur qui peut être analysée comme un flottant dans la plage spécifiée. Attribut:
FloatLikeAllowThousands::class
Méthode:
Validation::floatLikeAllowThousands(float $min = PHP_FLOAT_MIN, float $max = PHP_FLOAT_MAX)
033 Nom : regexp
Utilisation : regexp:"/[az]/i"		 Affirme que l'entrée correspond à une expression régulière compatible Perl. Attribut:
Regexp::class
Méthode:
Validation::regexp(string $pattern)
034 Nom : ip
Utilisation : ip		 Affirme que l'entrée est une adresse IP. Attribut:
Ip::class
Méthode:
Validation::ip()
035 Nom : ip.v4
Utilisation : ip.v4		 Affirme que l'entrée est une adresse IPv4. Attribut:
IpV4::class
Méthode:
Validation::ipV4()
036 Nom : ip.v6
Utilisation : ip.v6		 Affirme que l'entrée est une adresse IPv6. Attribut:
IpV6::class
Méthode:
Validation::ipV6()
037 Nom : ip.notReserved
Utilisation : ip.notReserved		 Affirme que l’entrée est une adresse IP ne se trouvant pas dans la plage d’adresses IP réservées. Attribut:
IpNotReserved::class
Méthode:
Validation::ipNotReserved()
038 Nom : ip.notPrivate
Utilisation : ip.notPrivate		 Affirme que l'entrée est une adresse IP ne se trouvant pas dans la plage d'adresses IP privées. Attribut:
IpNotPrivate::class
Méthode:
Validation::ipNotPrivate()
039 Nom : mac
Utilisation : mac		 Affirme que l'entrée est une adresse MAC. Attribut:
Mac::class
Méthode:
Validation::mac()
040 Nom : url
Utilisation : url		 Affirme que l'entrée est une URL. Attribut:
Url::class
Méthode:
Validation::url()
041 Nom : url.withPath
Utilisation : url.withPath		 Affirme que l'entrée est une URL qui contient un chemin. Attribut:
UrlWithPath::class
Méthode:
Validation::urlWithPath()
042 Nom : url.withQuery
Utilisation : url.withQuery		 Affirme que l'entrée est une URL qui contient une requête. Attribut:
UrlWithQuery::class
Méthode:
Validation::urlWithQuery()
043 Nom : email
Utilisation : email		 Affirme que l'entrée est une adresse e-mail. Attribut:
Email::class
Méthode:
Validation::email()
044 Nom : email.withUnicode
Utilisation : email.withUnicode		 Affirme que l'entrée est une adresse e-mail (Unicode autorisé). Attribut:
EmailWithUnicode::class
Méthode:
Validation::emailWithUnicode()
045 Nom : domain
Utilisation : domain		 Affirme que l'entrée est un domaine. Attribut:
Domain::class
Méthode:
Validation::domain()
046 Nom : domain.isActive
Utilisation : domain.isActive		 Affirme que l'entrée est un domaine actif. Fonctionne avec les domaines et les e-mails. Attribut:
DomainIsActive::class
Méthode:
Validation::domainIsActive()
047 Nom : file
Utilisation : file		 Affirme que l'entrée est un fichier (peut être un fichier, un lien ou un répertoire). Attribut:
File::class
Méthode:
Validation::file()
048 Nom : file.isFile
Utilisation : file.isFile		 Affirme que l'entrée est un fichier. Attribut:
FileIsFile::class
Méthode:
Validation::fileIsFile()
049 Nom : file.isLink
Utilisation : file.isLink		 Affirme que l'entrée est un lien. Attribut:
FileIsLink::class
Méthode:
Validation::fileIsLink()
050 Nom : file.isDirectory
Utilisation : file.isDirectory		 Affirme que l'entrée est un répertoire. Attribut:
FileIsDirectory::class
Méthode:
Validation::fileIsDirectory()
051 Nom : file.isExecutable
Utilisation : file.isExecutable		 Affirme que l'entrée est un fichier et qu'elle est exécutable. Attribut:
FileIsExecutable::class
Méthode:
Validation::fileIsExecutable()
052 Nom : file.isWritable
Utilisation : file.isWritable		 Affirme que l'entrée est un fichier et qu'elle est accessible en écriture. Attribut:
FileIsWritable::class
Méthode:
Validation::fileIsWritable()
053 Nom : file.isReadable
Utilisation : file.isReadable		 Affirme que l'entrée est un fichier et qu'elle est lisible. Attribut:
FileIsReadable::class
Méthode:
Validation::fileIsReadable()
054 Nom : file.isUploaded
Utilisation : file.isUploaded		 Affirme que l'entrée est un fichier téléchargé via HTTP POST. Attribut:
FileIsUploaded::class
Méthode:
Validation::fileIsUploaded()
055 Nom : file.size
Utilisation : file.size:1024		 Affirme que l'entrée est un fichier et que la taille est égale à la taille donnée en octets. Attribut:
FileSize::class
Méthode:
Validation::fileSize(int $sizeInBytes)
056 Nom : file.size.lte
Utilisation : file.size.lte:1024		 Affirme que l'entrée est un fichier et que sa taille est inférieure ou égale à la taille donnée en octets. Attribut:
FileSizeLte::class
Méthode:
Validation::fileSizeLte(int $sizeInBytes)
057 Nom : file.size.gte
Utilisation : file.size.gte:1024		 Affirme que l'entrée est un fichier et que sa taille est supérieure ou égale à la taille donnée en octets. Attribut:
FileSizeGte::class
Méthode:
Validation::fileSizeGte(int $sizeInBytes)
058 Nom : file.dirname
Utilisation : file.dirname:/path/to/dir		 Affirme que l'entrée est un fichier et que son nom de répertoire est égal au nom de répertoire donné. Attribut:
FileDirname::class
Méthode:
Validation::fileDirname(string $dirname)
059 Nom : file.basename
Utilisation : file.basename:file.ext		 Affirme que l'entrée est un fichier et que son nom de base est égal au nom de base donné. Attribut:
FileBasename::class
Méthode:
Validation::fileBasename(string $basename)
060 Nom : file.filename
Utilisation : file.filename:file		 Affirme que l'entrée est un fichier et que son nom de fichier est égal au nom de fichier donné. Attribut:
FileFilename::class
Méthode:
Validation::fileFilename(string $filename)
061 Nom : file.extension
Utilisation : file.extension:ext		 Affirme que l'entrée est un fichier et que son extension est égale à l'extension donnée. Attribut:
FileExtension::class
Méthode:
Validation::fileExtension(string $extension)
062 Nom : file.mime
Utilisation : file.mime:text/plain		 Affirme que l'entrée est un fichier et que son type MIME est l'un des types MIME donnés. Attribut:
FileMime::class
Méthode:
Validation::fileMime(string|array $mine)
063 Nom : image
Utilisation : image		 Affirme que l'entrée est un fichier image (jpg, jpeg, png, gif, bmp, svg ou webp). Attribut:
Image::class
Méthode:
Validation::image()
064 Nom : image.width
Utilisation : image.width:1920		 Affirme que l'entrée est une image et que sa largeur est égale à la largeur donnée en pixels. Attribut:
ImageWidth::class
Méthode:
Validation::imageWidth(int $width)
065 Nom : image.width.lte
Utilisation : image.width.lte:1920		 Affirme que l'entrée est une image et que sa largeur est inférieure ou égale à la largeur donnée en pixels. Attribut:
ImageWidthLte::class
Méthode:
Validation::imageWidthLte(int $width)
066 Nom : image.width.gte
Utilisation : image.width.gte:1920		 Affirme que l'entrée est une image et que sa largeur est supérieure ou égale à la largeur donnée en pixels. Attribut:
ImageWidthGte::class
Méthode:
Validation::imageWidthGte(int $width)
067 Nom : image.height
Utilisation : image.height:1080		 Affirme que l'entrée est une image et que sa hauteur est égale à la hauteur donnée en pixels. Attribut:
ImageHeight::class
Méthode:
Validation::imageHeight(int $height)
068 Nom : image.height.lte
Utilisation : image.height.lte:1080		 Affirme que l'entrée est une image et que sa hauteur est inférieure ou égale à la hauteur donnée en pixels. Attribut:
ImageHeightLte::class
Méthode:
Validation::imageHeightLte(int $height)
069 Nom : image.height.gte
Utilisation : image.height.gte:1080		 Affirme que l'entrée est une image et que sa hauteur est supérieure ou égale à la hauteur donnée en pixels. Attribut:
ImageHeightGte::class
Méthode:
Validation::imageHeightGte(int $height)
070 Nom : image.dimensions
Utilisation : image.dimensions:1920,1080,==		 Affirme que l'entrée est une image et que ses dimensions sont inférieures, égales ou supérieures à la largeur et à la hauteur données en pixels. Attribut:
ImageDimensions::class
Méthode:
Validation::imageDimensions(int $width, int $height, string $operator = '==')
071 Nom : image.ratio
Utilisation : image.ratio:16:9		 Affirme que l'entrée est une image et que son rapport hauteur/largeur est égal au rapport donné (le rapport doit être spécifié sous forme de fraction comme "16/9"). Attribut:
ImageRatio::class
Méthode:
Validation::imageRatio(string $ratio)
072 Nom : if
Utilisation : if:7,7,==		 Vérifie la condition entre le premier argument et le deuxième argument, l'opérateur de condition peut également être spécifié comme troisième argument. Attribut:
IfConstraint::class
Méthode:
Validation::if(mixed $actual, mixed $expected = true, string $operator = '==')
073 Nom : if.eq
Utilisation : if.eq:3,3		 Vérifie la condition entre le premier argument et le deuxième argument, l'opérateur de condition est "==". Attribut:
IfEq::class
Méthode:
Validation::ifEq(mixed $actual, mixed $expected)
074 Nom : if.neq
Utilisation : if.neq:1,2		 Vérifie la condition entre le premier argument et le deuxième argument, l'opérateur de condition est "!=". Attribut:
IfNeq::class
Méthode:
Validation::ifNeq(mixed $actual, mixed $expected)
075 Nom : if.id
Utilisation : if.id:3,3		 Vérifie la condition entre le premier argument et le deuxième argument, l'opérateur de condition est "===". Attribut:
IfId::class
Méthode:
Validation::ifId(mixed $actual, mixed $expected)
076 Nom : if.nid
Utilisation : if.nid:1,2		 Vérifie la condition entre le premier argument et le deuxième argument, l'opérateur de condition est "!==". Attribut:
IfNid::class
Méthode:
Validation::ifNid(mixed $actual, mixed $expected)
077 Nom : if.gt
Utilisation : if.gt:2,1		 Vérifie la condition entre le premier argument et le deuxième argument, l'opérateur de condition est ">". Attribut:
IfGt::class
Méthode:
Validation::ifGt(mixed $actual, mixed $expected)
078 Nom : if.gte
Utilisation : if.gte:2,2		 Vérifie la condition entre le premier argument et le deuxième argument, l'opérateur de condition est ">=". Attribut:
IfGte::class
Méthode:
Validation::ifGte(mixed $actual, mixed $expected)
079 Nom : if.lt
Utilisation : if.lt:1,2		 Vérifie la condition entre le premier argument et le deuxième argument, l'opérateur de condition est "<". Attribut:
IfLt::class
Méthode:
Validation::ifLt(mixed $actual, mixed $expected)
080 Nom : if.lte
Utilisation : if.lte:1,2		 Vérifie la condition entre le premier argument et le deuxième argument, l'opérateur de condition est "<=". Attribut:
IfLte::class
Méthode:
Validation::ifLte(mixed $actual, mixed $expected)
081 Nom : empty
Utilisation : empty		 Affirme que l'entrée est vide à l'aide de la construction de langage empty() (est vide, c'est-à-dire une chaîne vide, un tableau vide, false, null ou 0). Attribut:
EmptyConstraint::class
Méthode:
Validation::empty()
082 Nom : required
Utilisation : required		 Affirme que l'entrée est requise (n'est pas vide, c'est-à-dire qu'il ne s'agit pas d'une chaîne vide ou nulle). Attribut:
Required::class
Méthode:
Validation::required()
083 Nom : allowed
Utilisation : allowed		 Affirme que l'entrée est autorisée (peut être vide ou avoir n'importe quelle valeur, les chaînes nulles et vides sont considérées comme des valeurs valides). Attribut:
Allowed::class
Méthode:
Validation::allowed()
084 Nom : forbidden
Utilisation : forbidden		 Affirme que l'entrée est interdite (est nulle ou absente). Attribut:
Forbidden::class
Méthode:
Validation::forbidden()
085 Nom : accepted
Utilisation : accepted		 Affirme que l'entrée est acceptée (est égal à : "on", "oui", "ouais", "oui", "yo", "ok", "ok", "oui", 1 ou "1", vrai ou " true"), notez que les chaînes sont traitées sans tenir compte de la casse. Attribut:
Accepted::class
Méthode:
Validation::accepted()
086 Nom : declined
Utilisation : declined		 Affirme que l'entrée est refusée (égal à : "off", "no", "not", "nope", "neh", "nay", 0 ou "0", false ou "false") notez que les chaînes sont traitées sans tenir compte de la casse. Attribut:
Declined::class
Méthode:
Validation::declined()
087 Nom : bit
Utilisation : bit		 Affirme que l'entrée est un bit (est égal à : 1 ou "1", vrai ; 0 ou "0", faux). Attribut:
Bit::class
Méthode:
Validation::bit()
088 Nom : bit.isOn
Utilisation : bit.isOn		 Affirme que l'entrée est un bit activé (égal à : vrai, 1 ou "1"). Attribut:
BitIsOn::class
Méthode:
Validation::bitIsOn()
089 Nom : bit.isOff
Utilisation : bit.isOff		 Affirme que l'entrée est un bit désactivé (égal à : faux, 0 ou "0"). Attribut:
BitIsOff::class
Méthode:
Validation::bitIsOff()
090 Nom : equals
Utilisation : equals:value		 Affirme que l'entrée est égale à la valeur donnée. Fonctionne avec les types scalaires et null. L'opérateur de comparaison est "==". Attribut:
Equals::class
Méthode:
Validation::equals(string|int|float|bool|null $value)
091 Nom : matches
Utilisation : matches:'"/^[a-zA-Z0-9]+$/"'		 Affirme que l'entrée correspond au modèle donné. Fonctionne uniquement avec des chaînes. Attribut:
Matches::class
Méthode:
Validation::matches(string $pattern)
092 Nom : in
Utilisation : in:val1,val2,...		 Affirme que l'entrée se trouve dans les valeurs données. Fonctionne avec les types scalaires et null. Attribut:
In::class
Méthode:
Validation::in(string|int|float|bool|null ...$values)
093 Nom : count
Utilisation : count:3		 Affirme que le nombre d'entrées est égal à la valeur donnée. Fonctionne avec tous les types de données (null : 0 ; booléen : 0 ou 1 ; float/integer : valeur numérique ; chaîne : nombre de caractères ; tableau/dénombrable : nombre d'éléments ; objet : nombre de propriétés accessibles). Attribut:
Count::class
Méthode:
Validation::count(int $count)
094 Nom : min
Utilisation : min:3		 Affirme que le nombre d’entrées est supérieur ou égal à la valeur donnée. Fonctionne avec tous les types de données (null : 0 ; booléen : 0 ou 1 ; float/integer : valeur numérique ; chaîne : nombre de caractères ; tableau/dénombrable : nombre d'éléments ; objet : nombre de propriétés accessibles). Attribut:
Min::class
Méthode:
Validation::min(int|float $count)
095 Nom : max
Utilisation : max:3		 Affirme que le nombre d’entrées est inférieur ou égal à la valeur donnée. Fonctionne avec tous les types de données (null : 0 ; booléen : 0 ou 1 ; float/integer : valeur numérique ; chaîne : nombre de caractères ; tableau/dénombrable : nombre d'éléments ; objet : nombre de propriétés accessibles). Attribut:
Max::class
Méthode:
Validation::max(int|float $count)
096 Nom : between
Utilisation: between:3,7		 Affirme que le nombre d'entrées se situe entre les valeurs données. Fonctionne avec tous les types de données (null : 0 ; booléen : 0 ou 1 ; float/integer : valeur numérique ; chaîne : nombre de caractères ; tableau/dénombrable : nombre d'éléments ; objet : nombre de propriétés accessibles). Attribut:
Between::class
Méthode:
Validation::between(int|float $min, int|float $max)
097 Nom : number.isPositive
Utilisation : number.isPositive		 Affirme que l'entrée est un nombre positif. Attribut:
NumberIsPositive::class
Méthode:
Validation::numberIsPositive()
098 Nom : number.isNegative
Utilisation : number.isNegative		 Affirme que l'entrée est un nombre négatif. Attribut:
NumberIsNegative::class
Méthode:
Validation::numberIsNegative()
099 Nom : number.isEven
Utilisation : number.isEven		 Affirme que l'entrée est un nombre pair. Attribut:
NumberIsEven::class
Méthode:
Validation::numberIsEven()
100 Nom : number.isOdd
Utilisation : number.isOdd		 Affirme que l'entrée est un nombre impair. Attribut:
NumberIsOdd::class
Méthode:
Validation::numberIsOdd()
101 Nom : number.isMultipleOf
Utilisation : number.isMultipleOf:3		 Affirme que l'entrée est un multiple du nombre donné. Attribut:
NumberIsMultipleOf::class
Méthode:
Validation::numberIsMultipleOf(float $number)
102 Nom : number.isFinite
Utilisation : number.isFinite		 Affirme que l'entrée est un nombre fini. Attribut:
NumberIsFinite::class
Méthode:
Validation::numberIsFinite()
103 Nom : number.isInfinite
Utilisation : number.isInfinite		 Affirme que l'entrée est un nombre infini. Attribut:
NumberIsInfinite::class
Méthode:
Validation::numberIsInfinite()
104 Nom : number.isNan
Utilisation : number.isNan		 Affirme que l'entrée n'est pas un nombre. Attribut:
NumberIsNan::class
Méthode:
Validation::numberIsNan()
105 Nom : string.charset
Utilisation : string.charset:UTF-8		 Affirme que l'entrée est codée dans l'un des jeux de caractères donnés (alias inclus). La vérification est effectuée en tenant compte de la casse. Attribut:
StringCharset::class
Méthode:
Validation::stringCharset(string|array $charset)
106 Nom : string.contains
Utilisation : string.contains:substring		 Affirme que l'entrée contient la sous-chaîne donnée. Un deuxième argument booléen peut être spécifié pour activer le mode strict (sensible à la casse). Attribut:
StringContains::class
Méthode:
Validation::stringContains(string $substring, bool $strict = false)
107 Nom : string.startsWith
Utilisation : string.startsWith:substring,1		 Affirme que l'entrée commence par la sous-chaîne donnée. Un deuxième argument booléen peut être spécifié pour activer le mode strict (sensible à la casse). Attribut:
StringStartsWith::class
Méthode:
Validation::stringStartsWith(string $substring, bool $strict = false)
108 Nom : string.endsWith
Utilisation : string.endsWith:substring,0		 Affirme que l'entrée se termine par la sous-chaîne donnée. Un deuxième argument booléen peut être spécifié pour activer le mode strict (sensible à la casse). Attribut:
StringEndsWith::class
Méthode:
Validation::stringEndsWith(string $substring, bool $strict = false)
109 Nom : string.length
Utilisation : string.length:3		 Affirme que l'entrée est une chaîne qui a exactement la longueur donnée. Attribut:
StringLength::class
Méthode:
Validation::stringLength(int $length)
110 Nom : string.wordsCount
Utilisation : string.wordsCount:3		 Affirme que l'entrée est une chaîne contenant exactement le nombre de mots donné. Attribut:
StringWordsCount::class
Méthode:
Validation::stringWordsCount(int $count)
111 Nom : array.hasKey
Utilisation : array.hasKey:key		 Affirme que le tableau d'entrée possède la clé donnée. Attribut:
ArrayHasKey::class
Méthode:
Validation::arrayHasKey(string|int $key)
112 Nom : array.hasValue
Utilisation : array.hasValue:value		 Affirme que le tableau d'entrée contient la valeur donnée. Fonctionne avec des types scalaires. Attribut:
ArrayHasValue::class
Méthode:
Validation::arrayHasValue(mixed $value)
113 Nom : array.hasDistinct
Utilisation : array.hasDistinct:key		 Affirme que l'entrée est un tableau multidimensionnel qui contient des valeurs distinctes de la clé donnée. Attribut:
ArrayHasDistinct::class
Méthode:
Validation::arrayHasDistinct(string|int $key)
114 Nom : array.isAssociative
Utilisation : array.isAssociative		 Affirme que l'entrée est un tableau associatif. Attribut:
ArrayIsAssociative::class
Méthode:
Validation::arrayIsAssociative()
115 Nom : array.isSequential
Utilisation : array.isSequential		 Affirme que l'entrée est un tableau séquentiel. Attribut:
ArrayIsSequential::class
Méthode:
Validation::arrayIsSequential()
116 Nom : array.isUnique
Utilisation : array.isUnique		 Affirme que le tableau d'entrée contient des valeurs uniques. Fonctionne uniquement avec des tableaux unidimensionnels. Attribut:
ArrayIsUnique::class
Méthode:
Validation::arrayIsUnique()
117 Nom : array.subset
Utilisation : array.subset:'{"a":1,"b":2}'		 Affirme que l'entrée est un tableau qui contient le sous-ensemble donné. Notez que cette vérification s'applique uniquement à la première dimension du tableau. Attribut:
ArraySubset::class
Méthode:
Validation::arraySubset(array $subset)
118 Nom : object.hasProperty
Utilisation : object.hasProperty:property		 Affirme que l'entrée a la propriété donnée. Attribut:
ObjectHasProperty::class
Méthode:
Validation::objectHasProperty(string $property)
119 Nom : object.hasMethod
Utilisation : object.hasMethod:method		 Affirme que l'entrée a la méthode donnée. Attribut:
ObjectHasMethod::class
Méthode:
Validation::objectHasMethod(string $method)
120 Nom : object.isStringable
Utilisation : object.isStringable		 Affirme que l'entrée implémente la méthode __toString(). Attribut:
ObjectIsStringable::class
Méthode:
Validation::objectIsStringable()
121 Nom : object.isInstanceOf
Utilisation : object.isInstanceOf:NamespaceClass		 Affirme que l'entrée est une instance de la classe donnée. Attribut:
ObjectIsInstanceOf::class
Méthode:
Validation::objectIsInstanceOf(string $classFQN)
122 Nom : object.isSubclassOf
Utilisation : object.isSubclassOf:NamespaceClass		 Affirme que l'entrée est une sous-classe de la classe donnée. Attribut:
ObjectIsSubclassOf::class
Méthode:
Validation::objectIsSubclassOf(string $classFQN)
123 Nom : serialized
Utilisation : serialized		 Affirme que l'entrée est une donnée sérialisée PHP valide. Attribut:
Serialized::class
Méthode:
Validation::serialized()
124 Nom : json
Utilisation : json		 Affirme que l'entrée est un JSON valide. Attribut:
Json::class
Méthode:
Validation::json()
125 Nom : base64
Utilisation : base64		 Affirme que l’entrée est une chaîne codée en Base64 valide. Attribut:
Base64::class
Méthode:
Validation::base64()
126 Nom : xml
Utilisation : xml		 Affirme que l'entrée est un XML valide. Attribut:
Xml::class
Méthode:
Validation::xml()
127 Nom : locale
Utilisation : locale		 Affirme que l'entrée est un identifiant de paramètres régionaux valide (par défaut : [ISO 639-1] ou [ISO 639-1]_[ISO 3166-1 alpha-2], insensible à la casse, l'entrée est canonique avant la vérification (tirets vers les traits de soulignement, pas de points ni de jeu de caractères) strict : [ISO 639-1] ou [ISO 639-1]_[ISO 3166-1 alpha-2], sensible à la casse sans canonisation. Attribut:
Locale::class
Méthode:
Validation::locale(bool $strict = false)
128 Nom : language
Utilisation : language		 Affirme que l'entrée est un code de langue valide (par défaut : « ISO 639-1 » ; long : « ISO 639-2/T »). Attribut:
Language::class
Méthode:
Validation::language(bool $long = false)
129 Nom : country
Utilisation : country		 Affirme que l'entrée est un code de pays valide (par défaut : « ISO 3166-1 alpha-2 » ; long : « ISO 3166-1 alpha-3 »). Attribut:
Country::class
Méthode:
Validation::country(bool $long = false)
130 Nom : timezone
Utilisation : timezone		 Affirme que l'entrée est un identifiant de fuseau horaire valide (par défaut : insensible à la casse ; strict : sensible à la casse). Attribut:
Timezone::class
Méthode:
Validation::timezone(bool $strict = false)
131 Nom : datetime
Utilisation : datetime		 Affirme que l’entrée est une chaîne/objet datetime valide. Attribut:
Datetime::class
Méthode:
Validation::datetime()
132 Nom : datetime.eq
Utilisation : datetime.eq:"2015-01-01"		 Affirme que l'entrée est égale à la chaîne datetime donnée. Attribut:
DatetimeEq::class
Méthode:
Validation::datetimeEq(string $datetime)
133 Nom : datetime.lt
Utilisation : datetime.lt:tomorrow		 Affirme que l'entrée est une chaîne/un objet datetime inférieur (avant) la chaîne datetime donnée. Attribut:
DatetimeLt::class
Méthode:
Validation::datetimeLt(string $datetime)
134 Nom : datetime.lte
Utilisation : datetime.lte:tomorrow		 Affirme que l'entrée est une chaîne/un objet datetime inférieur (avant) ou égal à la chaîne datetime donnée. Attribut:
DatetimeLte::class
Méthode:
Validation::datetimeLte(string $datetime)
135 Nom : datetime.gt
Utilisation : datetime.gt:today		 Affirme que l'entrée est une chaîne/un objet datetime supérieur (après) la chaîne datetime donnée. Attribut:
DatetimeGt::class
Méthode:
Validation::datetimeGt(string $datetime)
136 Nom : datetime.gte
Utilisation : datetime.gte:today		 Affirme que l'entrée est une chaîne/un objet datetime supérieur (après) ou égal à la chaîne datetime donnée. Attribut:
DatetimeGte::class
Méthode:
Validation::datetimeGte(string $datetime)
137 Nom : datetime.birthday
Utilisation : datetime.birthday		 Affirme que l'entrée est une chaîne/un objet datetime dont l'anniversaire est aujourd'hui. La saisie doit de préférence être au format « AAAA-MM-JJ ». Attribut:
DatetimeBirthday::class
Méthode:
Validation::datetimeBirthday()
138 Nom : datetime.format
Utilisation : datetime.format:"Ymd H:i:s"		 Affirme que l'entrée est une date/heure valide avec le format donné. Attribut:
DatetimeFormat::class
Méthode:
Validation::datetimeFormat(string $format)
139 Nom : datetime.format.global
Utilisation : datetime.format.global		 Affirme que l'entrée ressemble à une chaîne datetime globale valide telle que définie dans la spécification HTML5. Attribut:
DatetimeFormatGlobal::class
Méthode:
Validation::datetimeFormatGlobal()
140 Nom : datetime.format.local
Utilisation : datetime.format.local		 Affirme que l'entrée ressemble à une chaîne datetime locale valide telle que définie dans la spécification HTML5. Attribut:
DatetimeFormatLocal::class
Méthode:
Validation::datetimeFormatLocal()
141 Nom : datestamp
Utilisation : datestamp		 Affirme que l'entrée ressemble à un horodatage humain, au format DMY ou MDY, séparé par un point, un tiret ou une barre oblique. Attribut:
Datestamp::class
Méthode:
Validation::datestamp()
142 Nom : datestamp.ymd
Utilisation : datestamp.ymd		 Affirme que l'entrée ressemble à un horodatage humain au format YMD, séparé par un point, un tiret ou une barre oblique. Attribut:
DatestampYmd::class
Méthode:
Validation::datestampYmd()
143 Nom : datestamp.dmy
Utilisation : datestamp.dmy		 Affirme que l'entrée ressemble à un horodatage humain au format DMY, séparé par un point, un tiret ou une barre oblique. Attribut:
DatestampDmy::class
Méthode:
Validation::datestampDmy()
144 Nom : datestamp.mdy
Utilisation : datestamp.mdy		 Affirme que l'entrée ressemble à un horodatage humain au format MDY, séparé par un point, un tiret ou une barre oblique. Attribut:
DatestampMdy::class
Méthode:
Validation::datestampMdy()
145 Nom : timestamp
Utilisation : timestamp		 Affirme que l'entrée ressemble à un horodatage humain, au format 24 ou 12 heures avec ou sans secondes. Attribut:
Timestamp::class
Méthode:
Validation::timestamp()
146 Nom : timestamp.12
Utilisation : timestamp.12		 Affirme que l'entrée ressemble à un horodatage humain, au format 12 heures avec ou sans secondes et AM/PM en option. Attribut:
Timestamp12::class
Méthode:
Validation::timestamp12()
147 Nom : timestamp.hms
Utilisation : timestamp.hms		 Affirme que l'entrée ressemble à un horodatage humain, au format 24 ou 12 heures avec secondes. Attribut:
TimestampHms::class
Méthode:
Validation::timestampHms()
148 Nom : timestamp.hm
Utilisation : timestamp.hm		 Affirme que l'entrée ressemble à un horodatage humain, au format 24 ou 12 heures sans secondes. Attribut:
TimestampHm::class
Méthode:
Validation::timestampHm()
149 Nom : timestamp.ms
Utilisation : timestamp.ms		 Affirme que l'entrée ressemble à un horodatage humain, contenant uniquement des minutes et des secondes. Attribut:
TimestampMs::class
Méthode:
Validation::timestampMs()
150 Nom : calender.day
Utilisation : calender.day		 Affirme que l'entrée ressemble à un jour du calendrier en plan ou en format long ("Lun" ou "Lundi"). Attribut:
CalenderDay::class
Méthode:
Validation::calenderDay()
151 Nom : calender.month
Utilisation : calender.month		 Affirme que l'entrée ressemble à un mois calendaire au format plan ou long ("Jan" ou "Janvier"). Attribut:
CalenderMonth::class
Méthode:
Validation::calenderMonth()
152 Nom : username
Utilisation : username		 Affirme que l'entrée est un nom d'utilisateur valide (entre 4 et 32 ​​caractères, composé de lettres dans tous les cas, éventuellement de chiffres, éventuellement de l'un des caractères suivants "-_." (non consécutifs), et doit toujours commencer par une lettre et se terminer avec une lettre ou un chiffre). Attribut:
Username::class
Méthode:
Validation::username()
153 Nom : password
Utilisation : password		 Affirme que l'entrée est un mot de passe valide (minimum 8 caractères, composé d'au moins une lettre minuscule et d'une lettre majuscule, d'au moins un chiffre, d'au moins un caractère spécial et éventuellement d'un espace). Attribut:
Password::class
Méthode:
Validation::password()
154 Nom : uuid
Utilisation : uuid		 Affirme que l’entrée est un UUID valide. La version (v1/v2/v3/v4/v5) peut être spécifiée pour affiner le modèle. Attribut:
Uuid::class
Méthode:
Validation::uuid(string|int|null $version = null)
155 Nom : ascii
Utilisation : ascii		 Affirme que l'entrée est une chaîne contenant uniquement des caractères ASCII (chaîne compatible ASCII). Attribut:
Ascii::class
Méthode:
Validation::ascii()
156 Nom : slug
Utilisation : slug		 Affirme que l’entrée est un slug valide. Attribut:
Slug::class
Méthode:
Validation::slug()
157 Nom : meta
Utilisation : meta		 Affirme que l'entrée est une chaîne contenant uniquement des méta-caractères (caractères spéciaux) (c'est-à-dire "@, #, $, ..."). Attribut:
Meta::class
Méthode:
Validation::meta()
158 Nom : text
Utilisation : text		 Affirme que l'entrée est une chaîne contenant des lettres et des signes de ponctuation de n'importe quelle langue. Attribut:
Text::class
Méthode:
Validation::text()
159 Nom : words
Utilisation : words		 Affirme que l'entrée est une chaîne contenant uniquement des mots et des espaces sans aucun autre caractère. Attribut:
Words::class
Méthode:
Validation::words()
160 Nom : spaceless
Utilisation : spaceless		 Affirme que l'entrée est une chaîne ne contenant aucun caractère d'espacement. Attribut:
Spaceless::class
Méthode:
Validation::spaceless()
161 Nom : emoji
Utilisation : emoji		 Affirme que l'entrée contient un emoji. Attribut:
Emoji::class
Méthode:
Validation::emoji()
162 Nom : roman
Utilisation : roman		 Affirme que l'entrée est un nombre romain valide. Attribut:
Roman::class
Méthode:
Validation::roman()
163 Nom : phone
Utilisation : phone		 Affirme que l'entrée est un numéro de téléphone valide (prend en charge : l'Amérique du Nord, l'Europe et la plupart des pays d'Asie et du Moyen-Orient). Attribut:
Phone::class
Méthode:
Validation::phone()
164 Nom : geolocation
Utilisation : geolocation		 Affirme que l’entrée est une géolocalisation valide (combinaison de coordonnées de latitude et de longitude). Attribut:
Geolocation::class
Méthode:
Validation::geolocation()
165 Nom : version
Utilisation : version		 Affirme que l'entrée est un numéro de version sémantique valide. Attribut:
Version::class
Méthode:
Validation::version()
166 Nom : amount
Utilisation : amount		 Affirme que l'entrée contient uniquement des nombres, un point décimal facultatif (virgule ou point) et un moins facultatif (utilisé pour les sommes d'argent par exemple). Attribut:
Amount::class
Méthode:
Validation::amount()
167 Nom : amount.dollar
Utilisation : amount.dollar		 Affirme que l'entrée est un montant en USD correctement formaté, où le point décimal et le séparateur de milliers sont facultatifs. Attribut:
AmountDollar::class
Méthode:
Validation::amountDollar()
168 Nom : amount.euro
Utilisation : amount.euro		 Affirme que l'entrée est un montant d'EUR correctement formaté, où le point décimal et le séparateur de milliers sont facultatifs. Attribut:
AmountEuro::class
Méthode:
Validation::amountEuro()
169 Nom : color
Utilisation : color		 Affirme que l'entrée est une couleur CSS valide (mot-clé « lâche », HEX, HEX-Alpha, RVB, RGBA, RVB « nouvelle syntaxe », HSL, HSLA, HSL « nouvelle syntaxe »). Attribut:
Color::class
Méthode:
Validation::color()
170 Nom : color.hex
Utilisation : color.hex		 Affirme que l'entrée est une couleur CSS HEX valide. Attribut:
ColorHex::class
Méthode:
Validation::colorHex()
171 Nom : color.hexShort
Utilisation : color.hexShort		 Affirme que l'entrée est une couleur CSS 3-Char-HEX valide. Attribut:
ColorHexShort::class
Méthode:
Validation::colorHexShort()
172 Nom : color.hexLong
Utilisation : color.hexLong		 Affirme que l'entrée est une couleur CSS 6-Char-HEX valide. Attribut:
ColorHexLong::class
Méthode:
Validation::colorHexLong()
173 Nom : color.hexAlpha
Utilisation : color.hexAlpha		 Affirme que l'entrée est une couleur CSS HEX-Alpha (4 ou 8 caractères) valide. Attribut:
ColorHexAlpha::class
Méthode:
Validation::colorHexAlpha()
174 Nom : color.rgb
Utilisation : color.rgb		 Affirme que l'entrée est une couleur CSS RVB valide. Attribut:
ColorRgb::class
Méthode:
Validation::colorRgb()
175 Nom : color.rgba
Utilisation : color.rgba		 Affirme que l'entrée est une couleur CSS RGBA valide. Attribut:
ColorRgba::class
Méthode:
Validation::colorRgba()
176 Nom : color.rgb.new
Utilisation : color.rgb.new		 Affirme que l’entrée est une couleur RVB CSS4 valide. Attribut:
ColorRgbNew::class
Méthode:
Validation::colorRgbNew()
177 Nom : color.hsl
Utilisation : color.hsl		 Affirme que l’entrée est une couleur CSS HSL valide. Attribut:
ColorHsl::class
Méthode:
Validation::colorHsl()
178 Nom : color.hsla
Utilisation : color.hsla		 Affirme que l'entrée est une couleur CSS HSLA valide. Attribut:
ColorHsla::class
Méthode:
Validation::colorHsla()
179 Nom: color.hsl.new
Utilisation: color.hsl.new		 Affirme que l'entrée est une couleur HSL CSS4 valide. Attribut:
ColorHslNew::class
Méthode:
Validation::colorHslNew()
180 Nom: color.keyword
Utilisation: color.keyword		 Affirme que l'entrée est une couleur de mot-clé CSS valide (strict, comme dans la spécification CSS). Attribut:
ColorKeyword::class
Méthode:
Validation::colorKeyword()
181 Nom: ssn
Utilisation: ssn		 Affirme que l'entrée est un SSN valide (numéro de sécurité sociale américaine). Attribut:
Ssn::class
Méthode:
Validation::ssn()
182 Nom: sin
Utilisation: sin		 Affirme que l'entrée est un péché valide (numéro d'assurance sociale de l'AC). Attribut:
Sin::class
Méthode:
Validation::sin()
183 Nom: nino
Utilisation: nino		 Affirme que la contribution est un Nino valide (numéro d'assurance national britannique). Attribut:
Nino::class
Méthode:
Validation::nino()
184 Nom: vin
Utilisation: vin		 Affirme que l'entrée est un VIN valide (numéro d'identification du véhicule). Attribut:
Vin::class
Méthode:
Validation::vin()
185 Nom: issn
Utilisation: issn		 Affirme que l'entrée est un ISSN valide (numéro de série international standard). Attribut:
Issn::class
Méthode:
Validation::issn()
186 Nom: isin
Utilisation: isin		 Affirme que l'entrée est un ISIN valide (numéro d'identification international des valeurs mobilières). Attribut:
Isin::class
Méthode:
Validation::isin()
187 Nom: isbn
Utilisation: isbn		 Affirme que l'entrée est un ISBN valide (numéro de livre standard international). Le type (10/13) peut être spécifié pour affiner le motif. Attribut:
Isbn::class
Méthode:
Validation::isbn(string|int|null $type = null)
188 Nom: imei
Utilisation: imei		 Affirme que l'entrée est un IMEI valide (numéro d'identité de l'équipement international de la station mobile). Attribut:
Imei::class
Méthode:
Validation::imei()
189 Nom: imei.sv
Utilisation: imei.sv		 Affirme que l'entrée est un IMEI-SV valide (numéro de version internationale de l'équipement de la station mobile et logiciel). Attribut:
ImeiSv::class
Méthode:
Validation::imeiSv()
190 Nom: meid
Utilisation: meid		 Affirme que l'entrée est un MEID valide (identifiant d'équipement mobile). Attribut:
Meid::class
Méthode:
Validation::meid()
191 Nom: esn
Utilisation: esn		 Affirme que l'entrée est un ESN valide (numéro de série électronique). Attribut:
Esn::class
Méthode:
Validation::esn()
192 Nom: currency
Utilisation: currency		 Affirme que l'entrée est un code de devise valide (par défaut: "ISO 4217 Alpha"; Numérique: "ISO 4217 Numéric"). Attribut:
Currency::class
Méthode:
Validation::currency(bool $numeric = false)
193 Nom: currency.name
Utilisation: currency.name		 Affirme que l'entrée est un nom de devise valide (comme dans ISO 4217). Attribut:
CurrencyName::class
Méthode:
Validation::currencyName()
194 Nom: creditcard
Utilisation : creditcard		 Affirme que l'entrée est un numéro de carte de crédit valide, des espaces équilibrés et / ou des tirets sont autorisés. Attribut:
Creditcard::class
Méthode:
Validation::creditcard()
195 Nom: creditcard.visa
Utilisation: creditcard.visa		 Affirme que l'entrée est un numéro de carte de crédit visa valide, des espaces équilibrés et / ou des tirets sont autorisés. Attribut:
CreditcardVisa::class
Méthode:
Validation::creditcardVisa()
196 Nom: creditcard.mastercard
Utilisation: creditcard.mastercard		 Affirme que l'entrée est un numéro de carte de crédit MasterCard valide, des espaces et / ou des tirets équilibrés sont autorisés. Attribut:
CreditcardMastercard::class
Méthode:
Validation::creditcardMastercard()
197 Nom: creditcard.discover
Utilisation: creditcard.discover		 Affirme que l'entrée est un numéro de carte de crédit Discover valide, des espaces équilibrés et / ou des tirets sont autorisés. Attribut:
CreditcardDiscover::class
Méthode:
Validation::creditcardDiscover()
198 Nom: creditcard.americanExpress
Utilisation: creditcard.americanExpress		 Affirme que l'entrée est un numéro de carte de crédit American Express American Valide, des espaces équilibrés et / ou des tirets sont autorisés. Attribut:
CreditcardAmericanExpress::class
Méthode:
Validation::creditcardAmericanExpress()
199 Nom: creditcard.dinersClub
Utilisation: creditcard.dinersClub		 Affirme que l'entrée est un numéro de carte de crédit Diners Club valide, des espaces équilibrés et / ou des tirets sont autorisés. Attribut:
CreditcardDinersClub::class
Méthode:
Validation::creditcardDinersClub()
200 Nom: creditcard.jcb
Utilisation: creditcard.jcb		 Affirme que l'entrée est un numéro de carte de crédit JCB valide, des espaces équilibrés et / ou des tirets sont autorisés. Attribut:
CreditcardJcb::class
Méthode:
Validation::creditcardJcb()
201 Nom: creditcard.maestro
Utilisation: creditcard.maestro		 Affirme que l'entrée est un numéro de carte de crédit maestro valide, des espaces équilibrés et / ou des tirets sont autorisés. Attribut:
CreditcardMaestro::class
Méthode:
Validation::creditcardMaestro()
202 Nom: creditcard.chinaUnionPay
Utilisation: creditcard.chinaUnionPay		 Affirme que l'entrée est un numéro de carte de crédit de China UnionPay valide, des espaces équilibrés et / ou des tirets sont autorisés. Attribut:
CreditcardChinaUnionPay::class
Méthode:
Validation::creditcardChinaUnionPay()
203 Nom: creditcard.instaPayment
Utilisation: creditcard.instaPayment		 Affirme que l'entrée est un numéro de carte de crédit Instapayment valide, des espaces et / ou des tirets équilibrés sont autorisés. Attribut:
CreditcardInstaPayment::class
Méthode:
Validation::creditcardInstaPayment()
204 Nom: creditcard.laser
Utilisation: creditcard.laser		 Affirme que l'entrée est un numéro de carte de crédit laser valide, des espaces équilibrés et / ou des tirets sont autorisés. Attribut:
CreditcardLaser::class
Méthode:
Validation::creditcardLaser()
205 Nom: creditcard.uatp
Utilisation: creditcard.uatp		 Affirme que l'entrée est un numéro de carte de crédit UATP valide, des espaces équilibrés et / ou des tirets sont autorisés. Attribut:
CreditcardUatp::class
Méthode:
Validation::creditcardUatp()
206 Nom: creditcard.mir
Utilisation: creditcard.mir		 Affirme que l'entrée est un numéro de carte de système de paiement MIR valide, des espaces équilibrés et / ou des tirets sont autorisés. Attribut:
CreditcardMir::class
Méthode:
Validation::creditcardMir()
207 Nom: cvv
Utilisation: cvv		 Affirme que l'entrée est un CVV valide (code de sécurité de la carte). Attribut:
Cvv::class
Méthode:
Validation::cvv()
208 Nom: bic
Utilisation: bic		 Affirme que l'entrée est un BIC valide (code d'identifiant bancaire). Attribut:
Bic::class
Méthode:
Validation::bic()
209 Nom: iban
Utilisation: iban:IQ		 Affirme que l'entrée est un IBAN valide (numéro de compte bancaire international). Le code de pays "ISO 3166-1 Alpha-2" peut être spécifié pour réduire le modèle. Attribut:
Iban::class
Méthode:
Validation::iban(?string $country = null)
210 Nom: luhn
Utilisation: luhn		 Affirme que l'entrée passe la vérification de l'algorithme Luhn. Cette règle est principalement utilisée en conjonction avec d'autres règles telles que les numéros de carte de crédit et les identifiants pour vérifier davantage la validité du sujet. Attribut:
Luhn::class
Méthode:
Validation::luhn()
211 Nom: php.keyword
Utilisation: php.keyword		 Affirme que l'entrée est un mot-clé en langage PHP. Attribut:
PhpKeyword::class
Méthode:
Validation::phpKeyword()
212 Nom: php.reserved
Utilisation: php.reserved		 Affirme que l'entrée est un mot réservé en langage PHP. Attribut:
PhpReserved::class
Méthode:
Validation::phpReserved()
213 Nom: php.reserved.extra
Utilisation: php.reserved.extra		 Affirme que l'entrée est un mot réservé en langage PHP, y compris les mots réservés doux. Attribut:
PhpReservedExtra::class
Méthode:
Validation::phpReservedExtra()
214 Nom: regex
Utilisation: regex		 Affirme que l'entrée est une expression régulière valide. Attribut:
Regex::class
Méthode:
Validation::regex()
215 Nom: bool
Utilisation: voir boolean		 Alias, reportez-vous à boolean pour la description complète. Attribut:
BoolConstraint::class
Méthode:
Validation::bool()
216 Nom: int
Utilisation: voir integer		 Alias, reportez-vous à integer pour la description complète. Attribut:
IntConstraint::class
Méthode:
Validation::int()
217 Nom: long
Utilisation: voir integer		 Alias, reportez-vous à integer pour la description complète. Attribut:
Long::class
Méthode:
Validation::long()
218 Nom: double
Utilisation: voir float		 Alias, reportez-vous à float pour la description complète. Attribut:
Double::class
Méthode:
Validation::double()
219 Nom: real
Utilisation: voir float		 Alias, reportez-vous à float pour la description complète. Attribut:
Real::class
Méthode:
Validation::real()
220 Nom: str
Utilisation: voir string		 Alias, reportez-vous à string pour la description complète. Attribut:
Str::class
Méthode:
Validation::str()
221 Nom: arr
Utilisation: voir array		 Alias, reportez-vous au array pour la description complète. Attribut:
Arr::class
Méthode:
Validation::arr()
222 Nom: obj
Utilisation: voir object		 Alias, reportez-vous à object pour la description complète. Attribut:
Obj::class
Méthode:
Validation::obj()
223 Nom: stream
Utilisation: voir resource		 Alias, reportez-vous à resource pour la description complète. Attribut:
Stream::class
Méthode:
Validation::stream()
224 Nom: assert
Utilisation: voyez if		 Alias, reportez- if à la description complète. Attribut:
Assert::class
Méthode:
Validation::assert(mixed $actual, mixed $expected = true, string $operator = '==')
225 Nom: assert.equals
Utilisation: voir if.eq		 Alias, reportez-vous à if.eq pour la description complète. Attribut:
AssertEquals::class
Méthode:
Validation::assertEquals(mixed $actual, mixed $expected)
226 Nom: assert.notEquals
Utilisation: voir if.neq		 Alias, reportez-vous à if.neq pour la description complète. Attribut:
AssertNotEquals::class
Méthode:
Validation::assertNotEquals(mixed $actual, mixed $expected)
227 Nom: assert.greaterThan
Utilisation: voir if.gt		 Alias, reportez-vous à if.gt pour la description complète. Attribut:
AssertGreaterThan::class
Méthode:
Validation::assertGreaterThan(mixed $actual, mixed $expected)
228 Nom: assert.greaterThanOrEquals
Utilisation: voir if.gte		 Alias, reportez-vous à if.gte pour la description complète. Attribut:
AssertGreaterThanOrEquals::class
Méthode:
Validation::assertGreaterThanOrEquals(mixed $actual, mixed $expected)
229 Nom: assert.lessThan
Utilisation: voir if.lt		 Alias, reportez-vous à if.lt pour la description complète. Attribut:
AssertLessThan::class
Méthode:
Validation::assertLessThan(mixed $actual, mixed $expected)
230 Nom: assert.lessThanOrEquals
Utilisation: voir if.lte		 Alias, reportez-vous à if.lte pour la description complète. Attribut:
AssertLessThanOrEquals::class
Méthode:
Validation::assertLessThanOrEquals(mixed $actual, mixed $expected)
231 Nom: blank
Utilisation: voir empty		 Alias, reportez-vous à empty pour la description complète. Attribut:
Blank::class
Méthode:
Validation::blank()
232 Nom: is
Utilisation: voir equals		 Alias, reportez-vous aux equals pour la description complète. Attribut:
Is::class
Méthode:
Validation::is(mixed $value)
233 Nom: same
Utilisation: voir equals		 Alias, reportez-vous aux equals pour la description complète. Attribut:
Same::class
Méthode:
Validation::same(mixed $value)
234 Nom: pattern
Utilisation: voir matches		 Alias, reportez-vous aux matches pour la description complète. Attribut:
Pattern::class
Méthode:
Validation::pattern(string $pattern)
235 Nom: choice
Utilisation: voir in		 Alias, reportez- in à la description complète. Attribut:
Choice::class
Méthode:
Validation::choice(string|int|float|bool|null ...$values)
236 Nom: size
Utilisation: voir count		 Alias, reportez-vous au count pour la description complète. Attribut:
Size::class
Méthode:
Validation::size(int $size)
237 Nom: length
Utilisation: voir count		 Alias, reportez-vous au count pour la description complète. Attribut:
Length::class
Méthode:
Validation::length(int $count)
238 Nom: range
Utilisation: voir between		 Alias, reportez between à la description complète. Attribut:
Range::class
Méthode:
Validation::range(int|float $min, int|float $max)
239 Nom: minmax
Utilisation: voir between		 Alias, reportez between à la description complète. Attribut:
Minmax::class
Méthode:
Validation::minmax(int|float $min, int|float $max)
240 Nom: filled
Utilisation: voir required		 Alias, reportez-vous à required pour la description complète. Attribut:
Filled::class
Méthode:
Validation::filled()
241 Nom: present
Utilisation: voir required		 Alias, reportez-vous à required pour la description complète. Attribut:
Present::class
Méthode:
Validation::present()
242 Nom: optional
Utilisation: voir allowed		 Alias, reportez-vous à la description complète allowed . Attribut:
Optional::class
Méthode:
Validation::optional()
243 Nom: date
Utilisation: voir datetime		 Alias, reportez-vous à datetime pour la description complète. Attribut:
Date::class
Méthode:
Validation::date()
244 Nom: date.equals
Utilisation: voir datetime.eq		 Alias, reportez-vous à datetime.eq pour la description complète. Attribut:
DateEquals::class
Méthode:
Validation::dateEquals(string $datetime)
245 Nom: date.before
Utilisation: voir datetime.lt		 Alias, reportez-vous à datetime.lt pour la description complète. Attribut:
DateBefore::class
Méthode:
Validation::dateBefore(string $datetime)
246 Nom: date.beforeOrEquals
Utilisation: voir datetime.lte		 Alias, reportez-vous à datetime.lte pour la description complète. Attribut:
DateBeforeOrEquals::class
Méthode:
Validation::dateBeforeOrEquals(string $datetime)
247 Nom: date.after
Utilisation: voir datetime.gt		 Alias, reportez-vous à datetime.gt pour la description complète. Attribut:
DateAfter::class
Méthode:
Validation::dateAfter(string $datetime)
248 Nom: date.afterOrEquals
Utilisation: voir datetime.gte		 Alias, reportez-vous à datetime.gte pour la description complète. Attribut:
DateAfterOrEquals::class
Méthode:
Validation::dateAfterOrEquals(string $datetime)
249 Nom: date.format
Utilisation: voir datetime.format		 Alias, reportez-vous à datetime.format pour la description complète. Attribut:
DateFormat::class
Méthode:
Validation::dateFormat(string $format)
250 Nom: cakeday
Utilisation: voir datetime.birthday		 Alias, reportez-vous à datetime.birthday pour la description complète. Attribut:
Cakeday::class
Méthode:
Validation::cakeday()

Macro

Macro Expression de validation
[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"

Repères

À ce jour, il peut sembler que mighty fait trop et les problèmes de performance commencent à survenir. Eh bien, il n'est pas nécessaire de s'en soucier. mighty est vraiment rapide et est optimisé pour fournir les meilleures performances. Voici quelques repères des performances du validateur:

Pas si scientifique

Les performances de mighty Validator et Laravel Validator dans une application Laravel. Le test a été effectué à l'aide d'un tableau de 50000 éléments, d'entre eux sont des entiers et l'autre moitié sont des cordes numériques. Chaque validateur a été testé 10 fois (consécutivement) et le résultat moyen de ces 10 a été collecté:

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 ' ,
]

Ainsi, mighty est environ 12,5 fois plus rapide que le validateur Laravel avec XDebug désactivé et environ 4x fois plus rapide avec XDebug activé.

Référence scientifique

La référence se fait à l'aide de phpbench. Voici un aperçu rapide:

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

■ FAIT: Le résultat de référence le plus récent peut également être trouvé dans le pipeline CI, qui sera mis à jour avec chaque push / PR vers l'Upstream.

Remarques

  1. mighty génère des messages d'erreur vraiment conviviaux par défaut (actuellement uniquement en anglais). Ces messages peuvent être facilement écrasés sur les bases de validator / contrainte. Vous voudrez peut-être avoir ces messages dans différentes langues, pour cela, la méthode MAKS mighty Rule::setMessageTranslator() peut être utilisée. Cette méthode est un moyen pratique de définir un traducteur de message global, il prend une fermeture qui obtient le message brut (avec les espaces réservés) comme argument et doit renvoyer la version traduite de ce message.
  2. Reportez-vous à la mighty spécification du langage d'expression de validation pour en savoir plus sur la théorie derrière mighty et pour comprendre le fonctionnement du langage.
  3. Reportez-vous à la documentation de l'API mighty pour en savoir plus sur l'API PHP. L'API est bien documentée et il ne devrait y avoir rien qui n'y est pas couvert.
  4. mighty est actuellement une bibliothèque de validation pure, elle ne fait aucune sorte de transformation sur les données. Le moteur et la conception actuelle sont suffisamment flexibles et peuvent être utilisés pour implémenter facilement un désinfectant en plus, il n'est pas prévu de le faire pour le moment, mais il peut s'agir d'une étape future.

Licence

mighty est un projet open-source autorisé en vertu de la licence du MIT .
Copyright (C) 2022 Marwan al-Soltany. Tous droits réservés.

Développer
Informations supplémentaires
Applications connexes
Recommandé pour vous
Actualités connexes Tout