valitron

Valitron : une validation facile qui ne craint pas

Valitron est une bibliothèque de validation autonome simple, minimale et élégante sans dépendances. Valitron utilise des méthodes de validation simples et directes en mettant l'accent sur une syntaxe lisible et concise. Valitron est la bibliothèque de validation simple et pragmatique que vous recherchiez.

Bénéficiez d'une assistance vlucas/valitron avec l'abonnement Tidelift

Pourquoi Valitron ?

Valitron a été créé par frustration face à d'autres bibliothèques de validation qui dépendent de composants volumineux provenant d'autres frameworks comme HttpFoundation de Symfony, récupérant une tonne de fichiers supplémentaires qui ne sont pas vraiment nécessaires à la validation de base. Il a également une syntaxe volontairement simple utilisée pour exécuter toutes les validations en un seul appel au lieu de valider individuellement chaque valeur en instanciant de nouvelles classes et en validant les valeurs une par une comme l'exigent certaines autres bibliothèques de validation.

En bref, Valitron est tout ce que vous recherchiez dans une bibliothèque de validation mais que vous n'avez pas pu trouver jusqu'à présent : une syntaxe pragmatique simple, un code léger qui a du sens, extensible pour des rappels et des validations personnalisés, bien testé et sans dépendances. . Commençons.

Installation

Valitron utilise Composer pour installer et mettre à jour :

 curl -s http://getcomposer.org/installer | php
php composer.phar require vlucas/valitron

Les exemples ci-dessous utilisent la syntaxe PHP 5.4, mais Valitron fonctionne sur PHP 5.3+.

Usage

L'utilisation est simple et directe. Fournissez simplement un tableau de données que vous souhaitez valider, ajoutez quelques règles, puis appelez validate() . S'il y a des erreurs, vous pouvez appeler errors() pour les obtenir.

 $ v = new Valitron  Validator ( array ( ' name ' => ' Chester Tester ' ));
$ v -> rule ( ' required ' , ' name ' );
if ( $ v -> validate ()) {
    echo " Yay! We're all good! " ;
} else {
    // Errors
    print_r ( $ v -> errors ());
}

En utilisant ce format, vous pouvez valider les données $_POST directement et facilement, et même appliquer une règle comme required à un tableau de champs :

 $ v = new Valitron  Validator ( $ _POST );
$ v -> rule ( ' required ' , [ ' name ' , ' email ' ]);
$ v -> rule ( ' email ' , ' email ' );
if ( $ v -> validate ()) {
    echo " Yay! We're all good! " ;
} else {
    // Errors
    print_r ( $ v -> errors ());
}

Vous pouvez utiliser la syntaxe par points pour accéder aux membres de tableaux multidimensionnels et un astérisque pour valider chaque membre d'un tableau :

 $ v = new Valitron  Validator ( array ( ' settings ' => array (
    array ( ' threshold ' => 50 ),
    array ( ' threshold ' => 90 )
)));
$ v -> rule ( ' max ' , ' settings.*.threshold ' , 100 );
if ( $ v -> validate ()) {
    echo " Yay! We're all good! " ;
} else {
    // Errors
    print_r ( $ v -> errors ());
}

Ou utilisez la syntaxe par points pour valider tous les membres d'un tableau numérique :

 $ v = new Valitron  Validator ( array ( ' values ' => array ( 50 , 90 )));
$ v -> rule ( ' max ' , ' values.* ' , 100 );
if ( $ v -> validate ()) {
    echo " Yay! We're all good! " ;
} else {
    // Errors
    print_r ( $ v -> errors ());
}

Vous pouvez également accéder aux valeurs imbriquées en utilisant la notation par points :

 $ v = new Valitron  Validator ( array ( ' user ' => array ( ' first_name ' => ' Steve ' , ' last_name ' => ' Smith ' , ' username ' => ' Batman123 ' )));
$ v -> rule ( ' alpha ' , ' user.first_name ' )-> rule ( ' alpha ' , ' user.last_name ' )-> rule ( ' alphaNum ' , ' user.username ' );
if ( $ v -> validate ()) {
    echo " Yay! We're all good! " ;
} else {
    // Errors
    print_r ( $ v -> errors ());
}

Définition de la langue et du répertoire de langue globalement :

 // boot or config file

use Valitron  Validator as V ;

V:: langDir ( __DIR__ . ' /validator_lang ' ); // always set langDir before lang.
V:: lang ( ' ar ' );

Désactivation du nom du {champ} dans la sortie du message d'erreur.

 use Valitron  Validator as V ;

$ v = new Valitron  Validator ([ ' name ' => ' John ' ]);
$ v -> rule ( ' required ' , [ ' name ' ]);

// Disable prepending the labels
$ v -> setPrependLabels ( false );

// Error output for the "false" condition
[
    [ " name " ] => [
        " is required "
    ]
]

// Error output for the default (true) condition
[
    [ " name " ] => [
        " name is required "
    ]
]

Vous pouvez exiger des valeurs de manière conditionnelle à l’aide des règles conditionnelles requises. Dans cet exemple, pour l'authentification, nous exigeons soit un jeton lorsque l'e-mail et le mot de passe ne sont pas présents, soit un mot de passe lorsque l'adresse e-mail est présente.

 // this rule set would work for either data set...
$ data = [ ' email ' => ' [email protected] ' , ' password ' => ' mypassword ' ];
// or...
$ data = [ ' token ' => ' jashdjahs83rufh89y38h38h ' ];

$ v = new Valitron  Validator ( $ data );
$ v -> rules ([
    ' requiredWithout ' => [
        [ ' token ' , [ ' email ' , ' password ' ], true ]
    ],
    ' requiredWith ' => [
        [ ' password ' , [ ' email ' ]]
    ],
    ' email ' => [
        [ ' email ' ]
    ]
    ' optional ' => [
        [ ' email ' ]
    ]
]);
$ this -> assertTrue ( $ v -> validate ());

Règles de validation intégrées

• required - Le champ est obligatoire
• requiredWith - Le champ est obligatoire si d'autres champs sont présents
• requiredWithout - Le champ est obligatoire si d'autres champs ne sont PAS présents
• equals - Le champ doit correspondre à un autre champ (confirmation par e-mail/mot de passe)
• different - Le champ doit être différent d'un autre champ
• accepted - La case à cocher ou la radio doit être acceptée (oui, activé, 1, vrai)
• numeric - Doit être numérique
• integer - Doit être un nombre entier
• boolean - Doit être booléen
• array - Doit être un tableau
• length - La chaîne doit avoir une certaine longueur
• lengthBetween - La chaîne doit être comprise entre des longueurs données
• lengthMin - La chaîne doit être supérieure à la longueur donnée
• lengthMax - La chaîne doit être inférieure à la longueur donnée
• min - Minimum
• max - Maximum
• listContains - Effectue une vérification in_array sur les valeurs de tableau données (dans l'autre sens que in )
• in - Effectue une vérification in_array sur les valeurs de tableau données
• notIn - Négation de la règle in (pas dans un tableau de valeurs)
• ip - Adresse IP valide
• ipv4 - Adresse IP v4 valide
• ipv6 - Adresse IP v6 valide
• email - Adresse e-mail valide
• emailDNS - Adresse e-mail valide avec enregistrement DNS actif
• url - URL valide
• urlActive - URL valide avec enregistrement DNS actif
• alpha - Caractères alphabétiques uniquement
• alphaNum - Caractères alphabétiques et numériques uniquement
• ascii - Caractères ASCII uniquement
• slug - Caractères slug de l'URL (az, 0-9, -, _)
• regex - Le champ correspond à un modèle d'expression régulière
• date - Le champ est une date valide
• dateFormat - Le champ est une date valide dans le format donné
• dateBefore - Le champ est une date valide et est antérieur à la date donnée
• dateAfter - Le champ est une date valide et est postérieure à la date indiquée
• contains - Le champ est une chaîne et contient la chaîne donnée
• subset - Le champ est un tableau ou un scalaire et tous les éléments sont contenus dans le tableau donné
• containsUnique - Le champ est un tableau et contient des valeurs uniques
• creditCard - Le champ est un numéro de carte de crédit valide
• instanceOf - Le champ contient une instance de la classe donnée
• optional - La valeur n'a pas besoin d'être incluse dans le tableau de données. Si c’est le cas, il doit passer la validation.
• arrayHasKeys - Field est un tableau et contient toutes les clés spécifiées.

REMARQUE : Si vous comparez des nombres à virgule flottante avec des validateurs min/max, vous devez installer l'extension BCMath pour une plus grande précision et fiabilité. L'extension n'est pas requise pour que Valitron fonctionne, mais Valitron l'utilisera si elle est disponible, et elle est fortement recommandée.

utilisation des champs obligatoires

la règle required vérifie si un champ existe dans le tableau de données et n'est pas nul ou une chaîne vide.

 $ v -> rule ( ' required ' , ' field_name ' );

En utilisant un paramètre supplémentaire, vous pouvez rendre cette règle plus flexible et vérifier uniquement si le champ existe dans le tableau de données.

 $ v -> rule ( ' required ' , ' field_name ' , true );

Syntaxe alternative.

 $ v = new Valitron  Validator ([ ' username ' => ' spiderman ' , ' password ' => ' Gr33nG0Blin ' , ' required_but_null ' => null ]);
$ v -> rules ([
    ' required ' => [
        [ ' username ' ],
        [ ' password ' ],
        [ ' required_but_null ' , true ] // boolean flag allows empty value so long as the field name is set on the data array
    ]
]);
$ v -> validate ();

obligatoireAvec utilisation des champs

La règle requiredWith vérifie que le champ est obligatoire, non nul et non la chaîne vide, si d'autres champs sont présents, non nul et non la chaîne vide.

 // password field will be required when the username field is provided and not empty
$ v -> rule ( ' requiredWith ' , ' password ' , ' username ' );

Syntaxe alternative.

 $ v = new Valitron  Validator ([ ' username ' => ' spiderman ' , ' password ' => ' Gr33nG0Blin ' ]);
$ v -> rules ([
    ' requiredWith ' => [
        [ ' password ' , ' username ' ]
    ]
]);
$ v -> validate ();

Remarque Vous pouvez fournir plusieurs valeurs sous forme de tableau. Dans ce cas, si l'un des champs est présent, le champ sera obligatoire.

 // in this case the password field will be required if the username or email fields are present
$ v -> rule ( ' requiredWith ' , ' password ' , [ ' username ' , ' email ' ]);

Syntaxe alternative.

 $ v = new Valitron  Validator ([ ' username ' => ' spiderman ' , ' password ' => ' Gr33nG0Blin ' ]);
$ v -> rules ([
    ' requiredWith ' => [
        [ ' password ' , [ ' username ' , ' email ' ]]
    ]
]);
$ v -> validate ();

Drapeau strict

L'indicateur strict changera la règle requiredWith en requiredWithAll qui nécessitera le champ uniquement si TOUS les autres champs sont présents, pas null et pas la chaîne vide.

 // in this example the suffix field is required only when both the first_name and last_name are provided
$ v -> rule ( ' requiredWith ' , ' suffix ' , [ ' first_name ' , ' last_name ' ], true );

Syntaxe alternative.

 $ v = new Valitron  Validator ([ ' first_name ' => ' steve ' , ' last_name ' => ' holt ' , ' suffix ' => ' Mr ' ]);
$ v -> rules ([
    ' requiredWith ' => [
        [ ' suffix ' , [ ' first_name ' , ' last_name ' ], true ]
    ]
]);
$ v -> validate ();

De même, dans ce cas, validate() retournerait toujours true, car le champ suffixe ne serait pas requis en mode strict, car tous les champs ne sont pas fournis.

 $ v = new Valitron  Validator ([ ' first_name ' => ' steve ' ]);
$ v -> rules ([
    ' requiredWith ' => [
        [ ' suffix ' , [ ' first_name ' , ' last_name ' ], true ]
    ]
]);
$ v -> validate ();

obligatoireSans utilisation des champs

La règle requiredWithout vérifie que le champ est obligatoire, non nul et non la chaîne vide, si d'autres champs ne sont PAS présents.

 // this rule will require the username field when the first_name is not present
$ v -> rule ( ' requiredWithout ' , ' username ' , ' first_name ' )

Syntaxe alternative.

 // this will return true, as the username is provided when the first_name is not provided
$ v = new Valitron  Validator ([ ' username ' => ' spiderman ' ]);
$ v -> rules ([
    ' requiredWithout ' => [
        [ ' username ' , ' first_name ' ]
    ]
]);
$ v -> validate ();

Remarque Vous pouvez fournir plusieurs valeurs sous forme de tableau. Dans ce cas, si AUCUN des champs n’est présent, le champ sera obligatoire.

 // in this case the username field will be required if either the first_name or last_name fields are not present
$ v -> rule ( ' requiredWithout ' , ' username ' , [ ' first_name ' , ' last_name ' ]);

Syntaxe alternative.

 // this passes validation because although the last_name field is not present, the username is provided
$ v = new Valitron  Validator ([ ' username ' => ' spiderman ' , ' first_name ' => ' Peter ' ]);
$ v -> rules ([
    ' requiredWithout ' => [
        [ ' username ' , [ ' first_name ' , ' last_name ' ]]
    ]
]);
$ v -> validate ();

Drapeau strict

L'indicateur strict modifiera la règle requiredWithout en requiredWithoutAll , ce qui nécessitera le champ uniquement si TOUS les autres champs ne sont pas présents.

 // in this example the username field is required only when both the first_name and last_name are not provided
$ v -> rule ( ' requiredWithout ' , ' username ' , [ ' first_name ' , ' last_name ' ], true );

Syntaxe alternative.

 $ v = new Valitron  Validator ([ ' username ' => ' BatMan ' ]);
$ v -> rules ([
    ' requiredWithout ' => [
        [ ' username ' , [ ' first_name ' , ' last_name ' ], true ]
    ]
]);
$ v -> validate ();

De même, dans ce cas, validate() retournerait toujours true, car le champ du nom d'utilisateur ne serait pas requis en mode strict, puisque tous les champs sont fournis.

 $ v = new Valitron  Validator ([ ' first_name ' => ' steve ' , ' last_name ' => ' holt ' ]);
$ v -> rules ([
    ' requiredWithout ' => [
        [ ' suffix ' , [ ' first_name ' , ' last_name ' ], true ]
    ]
]);
$ v -> validate ();

est égal à l'utilisation des champs

La règle equals vérifie si deux champs sont égaux dans le tableau de données et que le deuxième champ n'est pas nul.

 $ v -> rule ( ' equals ' , ' password ' , ' confirmPassword ' );

Syntaxe alternative.

 $ v = new Valitron  Validator ([ ' password ' => ' youshouldnotseethis ' , ' confirmPassword ' => ' youshouldnotseethis ' ]);
$ v -> rules ([
    ' equals ' => [
        [ ' password ' , ' confirmPassword ' ]
    ]
]);
$ v -> validate ();

utilisation de différents champs

La règle different vérifie si deux champs ne sont pas identiques ou différents dans le tableau de données et que le deuxième champ n'est pas nul.

 $ v -> rule ( ' different ' , ' username ' , ' password ' );

Syntaxe alternative.

 $ v = new Valitron  Validator ([ ' username ' => ' spiderman ' , ' password ' => ' Gr33nG0Blin ' ]);
$ v -> rules ([
    ' different ' => [
        [ ' username ' , ' password ' ]
    ]
]);
$ v -> validate ();

utilisation des champs acceptés

La règle accepted vérifie si le champ est « oui », « activé », 1 ou vrai.

 $ v -> rule ( ' accepted ' , ' remember_me ' );

Syntaxe alternative.

 $ v = new Valitron  Validator ([ ' remember_me ' => true ]);
$ v -> rules ([
    ' accepted ' => [
        [ ' remember_me ' ]
    ]
]);
$ v -> validate ();

utilisation des champs numériques

La règle numeric vérifie si le champ est numérique. Ceci est analogue à la fonction is_numeric() de php.

 $ v -> rule ( ' numeric ' , ' amount ' );

Syntaxe alternative.

 $ v = new Valitron  Validator ([ ' amount ' => 3.14 ]);
$ v -> rules ([
    ' numeric ' => [
        [ ' amount ' ]
    ]
]);
$ v -> validate ();

utilisation des champs entiers

La règle des integer vérifie si le champ est un nombre entier.

 $ v -> rule ( ' integer ' , ' age ' );

Syntaxe alternative.

 $ v = new Valitron  Validator ([ ' age ' => ' 27 ' ]);
$ v -> rules ([
    ' integer ' => [
        [ ' age ' ]
    ]
]);
$ v -> validate ();

Notez que l'indicateur booléen facultatif pour le mode strict garantit que les entiers doivent être fournis sous une forme strictement numérique. La règle suivante serait donc vraie :

 $ v = new Valitron  Validator ([ ' negative ' => ' -27 ' , ' positive ' => ' 27 ' ]);
$ v -> rule ( ' integer ' , ' age ' , true );
$ v -> rule ( ' integer ' , ' height ' , true );
$ v -> validate ();

Alors que ce qui suit sera évalué comme faux, car le + pour le nombre positif dans ce cas est redondant :

 $ v = new Valitron  Validator ([ ' negative ' => ' -27 ' , ' positive ' => ' +27 ' ]);
$ v -> rule ( ' integer ' , ' age ' , true );
$ v -> rule ( ' integer ' , ' height ' , true );
$ v -> validate ();

utilisation des champs booléens

La règle boolean vérifie si le champ est booléen. Ceci est analogue à la fonction is_bool() de php.

 $ v -> rule ( ' boolean ' , ' remember_me ' );

Syntaxe alternative.

 $ v = new Valitron  Validator ([ ' remember_me ' => true ]);
$ v -> rules ([
    ' boolean ' => [
        [ ' remember_me ' ]
    ]
]);
$ v -> validate ();

utilisation des champs du tableau

La règle array vérifie si le champ est un tableau. Ceci est analogue à la fonction is_array() de php.

 $ v -> rule ( ' array ' , ' user_notifications ' );

Syntaxe alternative.

 $ v = new Valitron  Validator ([ ' user_notifications ' => [ ' bulletin_notifications ' => true , ' marketing_notifications ' => false , ' message_notification ' => true ]]);
$ v -> rules ([
    ' array ' => [
        [ ' user_notifications ' ]
    ]
]);
$ v -> validate ();

utilisation des champs de longueur

La règle length vérifie si le champ a exactement une longueur donnée et que le champ est une chaîne valide.

 $ v -> rule ( ' length ' , ' username ' , 10 );

Syntaxe alternative.

 $ v = new Valitron  Validator ([ ' username ' => ' bobburgers ' ]);
$ v -> rules ([
    ' length ' => [
        [ ' username ' , 10 ]
    ]
]);
$ v -> validate ();

utilisation de la longueur entre les champs

La règle lengthBetween vérifie si le champ se situe entre une longueur donnée et que le champ est une chaîne valide.

 $ v -> rule ( ' lengthBetween ' , ' username ' , 1 , 10 );

Syntaxe alternative.

 $ v = new Valitron  Validator ([ ' username ' => ' bobburgers ' ]);
$ v -> rules ([
    ' lengthBetween ' => [
        [ ' username ' , 1 , 10 ]
    ]
]);
$ v -> validate ();

Utilisation des champs lengthMin

La règle lengthMin vérifie si le champ a au moins une longueur donnée et que le champ est une chaîne valide.

 $ v -> rule ( ' lengthMin ' , ' username ' , 5 );

Syntaxe alternative.

 $ v = new Valitron  Validator ([ ' username ' => ' martha ' ]);
$ v -> rules ([
    ' lengthMin ' => [
        [ ' username ' , 5 ]
    ]
]);
$ v -> validate ();

Utilisation des champs lengthMax

La règle lengthMax vérifie si le champ a au plus une longueur donnée et que le champ est une chaîne valide.

 $ v -> rule ( ' lengthMax ' , ' username ' , 10 );

Syntaxe alternative.

 $ v = new Valitron  Validator ([ ' username ' => ' bruins91 ' ]);
$ v -> rules ([
    ' lengthMax ' => [
        [ ' username ' , 10 ]
    ]
]);
$ v -> validate ();

utilisation minimale des champs

La règle min vérifie si le champ contient au moins une valeur donnée et que la valeur fournie est numérique.

 $ v -> rule ( ' min ' , ' age ' , 18 );

Syntaxe alternative.

 $ v = new Valitron  Validator ([ ' age ' => 28 ]);
$ v -> rules ([
    ' min ' => [
        [ ' age ' , 18 ]
    ]
]);
$ v -> validate ();

utilisation maximale des champs

La règle max vérifie si le champ contient au plus une valeur donnée et que la valeur fournie est numérique.

 $ v -> rule ( ' max ' , ' age ' , 12 );

Syntaxe alternative.

 $ v = new Valitron  Validator ([ ' age ' => 10 ]);
$ v -> rules ([
    ' max ' => [
        [ ' age ' , 12 ]
    ]
]);
$ v -> validate ();

utilisation des champs listContains

La règle listContains vérifie que le champ est présent dans un tableau de valeurs donné.

 $ v -> rule ( ' listContains ' , ' color ' , ' yellow ' );

Syntaxe alternative.

 $ v = new Valitron  Validator ([ ' color ' => [ ' blue ' , ' green ' , ' red ' , ' yellow ' ]]);
$ v -> rules ([
    ' listContains ' => [
        [ ' color ' , ' yellow ' ]
    ]
]);
$ v -> validate ();

utilisation dans les champs

La règle in vérifie que le champ est présent dans un tableau de valeurs donné.

 $ v -> rule ( ' in ' , ' color ' , [ ' blue ' , ' green ' , ' red ' , ' purple ' ]);

Syntaxe alternative.

 $ v = new Valitron  Validator ([ ' color ' => ' purple ' ]);
$ v -> rules ([
    ' in ' => [
        [ ' color ' , [ ' blue ' , ' green ' , ' red ' , ' purple ' ]]
    ]
]);
$ v -> validate ();

Utilisation des champs notIn

La règle notIn vérifie que le champ n'est PAS présent dans un tableau de valeurs donné.

 $ v -> rule ( ' notIn ' , ' color ' , [ ' blue ' , ' green ' , ' red ' , ' yellow ' ]);

Syntaxe alternative.

 $ v = new Valitron  Validator ([ ' color ' => ' purple ' ]);
$ v -> rules ([
    ' notIn ' => [
        [ ' color ' , [ ' blue ' , ' green ' , ' red ' , ' yellow ' ]]
    ]
]);
$ v -> validate ();

utilisation des champs IP

La règle ip vérifie que le champ est une adresse IP valide. Cela inclut les plages IPv4, IPv6, privées et réservées.

 $ v -> rule ( ' ip ' , ' user_ip ' );

Syntaxe alternative.

 $ v = new Valitron  Validator ([ ' user_ip ' => ' 127.0.0.1 ' ]);
$ v -> rules ([
    ' ip ' => [
        [ ' user_ip ' ]
    ]
]);
$ v -> validate ();

utilisation des champs ipv4

La règle ipv4 vérifie que le champ est une adresse IPv4 valide.

 $ v -> rule ( ' ipv4 ' , ' user_ip ' );

Syntaxe alternative.

 $ v = new Valitron  Validator ([ ' user_ip ' => ' 127.0.0.1 ' ]);
$ v -> rules ([
    ' ipv4 ' => [
        [ ' user_ip ' ]
    ]
]);
$ v -> validate ();

utilisation des champs ipv6

La règle ipv6 vérifie que le champ est une adresse IPv6 valide.

 $ v -> rule ( ' ipv6 ' , ' user_ip ' );

Syntaxe alternative.

 $ v = new Valitron  Validator ([ ' user_ip ' => ' 0:0:0:0:0:0:0:1 ' ]);
$ v -> rules ([
    ' ipv6 ' => [
        [ ' user_ip ' ]
    ]
]);
$ v -> validate ();

utilisation des champs de courrier électronique

La règle email vérifie que le champ est une adresse email valide.

 $ v -> rule ( ' email ' , ' user_email ' );

Syntaxe alternative.

 $ v = new Valitron  Validator ([ ' user_email ' => ' [email protected] ' ]);
$ v -> rules ([
    ' email ' => [
        [ ' user_email ' ]
    ]
]);
$ v -> validate ();

Utilisation des champs emailDNS

La règle emailDNS valide que le champ est une adresse e-mail valide avec un enregistrement DNS actif ou de tout autre type.

 $ v -> rule ( ' emailDNS ' , ' user_email ' );

Syntaxe alternative.

 $ v = new Valitron  Validator ([ ' user_email ' => ' [email protected] ' ]);
$ v -> rules ([
    ' emailDNS ' => [
        [ ' user_email ' ]
    ]
]);
$ v -> validate ();

utilisation des champs URL

La règle url vérifie que le champ est une URL valide.

 $ v -> rule ( ' url ' , ' website ' );

Syntaxe alternative.

 $ v = new Valitron  Validator ([ ' website ' => ' https://example.com/contact ' ]);
$ v -> rules ([
    ' url ' => [
        [ ' website ' ]
    ]
]);
$ v -> validate ();

Utilisation des champs urlActive

La règle urlActive vérifie que le champ est une URL valide avec un enregistrement A, AAAA ou CNAME actif.

 $ v -> rule ( ' urlActive ' , ' website ' );

Syntaxe alternative.

 $ v = new Valitron  Validator ([ ' website ' => ' https://example.com/contact ' ]);
$ v -> rules ([
    ' urlActive ' => [
        [ ' website ' ]
    ]
]);
$ v -> validate ();

utilisation des champs alpha

La règle alpha vérifie que le champ contient uniquement des caractères alphabétiques.

 $ v -> rule ( ' alpha ' , ' username ' );

Syntaxe alternative.

 $ v = new Valitron  Validator ([ ' username ' => ' batman ' ]);
$ v -> rules ([
    ' alpha ' => [
        [ ' username ' ]
    ]
]);
$ v -> validate ();

Utilisation des champs alphaNum

La règle alphaNum vérifie que le champ contient uniquement des caractères alphabétiques ou numériques.

 $ v -> rule ( ' alphaNum ' , ' username ' );

Syntaxe alternative.

 $ v = new Valitron  Validator ([ ' username ' => ' batman123 ' ]);
$ v -> rules ([
    ' alphaNum ' => [
        [ ' username ' ]
    ]
]);
$ v -> validate ();

utilisation des champs ascii

La règle ascii vérifie que le champ contient uniquement des caractères du jeu de caractères ascii.

 $ v -> rule ( ' ascii ' , ' username ' );

Syntaxe alternative.

 $ v = new Valitron  Validator ([ ' username ' => ' batman123 ' ]);
$ v -> rules ([
    ' ascii ' => [
        [ ' username ' ]
    ]
]);
$ v -> validate ();

utilisation des champs de limaces

La règle slug vérifie que le champ contient uniquement des caractères slug d'URL (az, 0-9, -, _).

 $ v -> rule ( ' slug ' , ' username ' );

Syntaxe alternative.

 $ v = new Valitron  Validator ([ ' username ' => ' L337-H4ckZ0rz_123 ' ]);
$ v -> rules ([
    ' slug ' => [
        [ ' username ' ]
    ]
]);
$ v -> validate ();

utilisation des champs regex

La règle regex garantit que le champ correspond à un modèle regex donné. (Cette expression régulière vérifie que la chaîne est alphanumérique entre 5 et 10 caractères).

 $ v -> rule ( ' regex ' , ' username ' , ' /^[a-zA-Z0-9]{5,10}$/ ' );

Syntaxe alternative.

 $ v = new Valitron  Validator ([ ' username ' => ' Batman123 ' ]);
$ v -> rules ([
    ' regex ' => [
        [ ' username ' , ' /^[a-zA-Z0-9]{5,10}$/ ' ]
    ]
]);
$ v -> validate ();

utilisation des champs de date

La règle date vérifie si le champ fourni est un objet DateTime valide ou si la chaîne peut être convertie en horodatage Unix via strtotime().

 $ v -> rule ( ' date ' , ' created_at ' );

Syntaxe alternative.

 $ v = new Valitron  Validator ([ ' created_at ' => ' 2018-10-13 ' ]);
$ v -> rules ([
    ' date ' => [
        [ ' created_at ' ]
    ]
]);
$ v -> validate ();

Utilisation des champs dateFormat

La règle dateFormat vérifie que le champ fourni est une date valide dans un format de date spécifié.

 $ v -> rule ( ' dateFormat ' , ' created_at ' , ' Y-m-d ' );

Syntaxe alternative.

 $ v = new Valitron  Validator ([ ' created_at ' => ' 2018-10-13 ' ]);
$ v -> rules ([
    ' dateFormat ' => [
        [ ' created_at ' , ' Y-m-d ' ]
    ]
]);
$ v -> validate ();

dateAvant l'utilisation des champs

La règle dateBefore vérifie que le champ fourni est une date valide antérieure à une date spécifiée.

 $ v -> rule ( ' dateBefore ' , ' created_at ' , ' 2018-10-13 ' );

Syntaxe alternative.

 $ v = new Valitron  Validator ([ ' created_at ' => ' 2018-09-01 ' ]);
$ v -> rules ([
    ' dateBefore ' => [
        [ ' created_at ' , ' 2018-10-13 ' ]
    ]
]);
$ v -> validate ();

utilisation des champs dateAfter

La règle dateAfter vérifie que le champ fourni est une date valide après une date spécifiée.

 $ v -> rule ( ' dateAfter ' , ' created_at ' , ' 2018-10-13 ' );

Syntaxe alternative.

 $ v = new Valitron  Validator ([ ' created_at ' => ' 2018-09-01 ' ]);
$ v -> rules ([
    ' dateAfter ' => [
        [ ' created_at ' , ' 2018-01-01 ' ]
    ]
]);
$ v -> validate ();

contient l'utilisation des champs

La règle contains vérifie qu'une chaîne donnée existe dans le champ et vérifie que le champ et la valeur de recherche sont tous deux des chaînes valides.

 $ v -> rule ( ' contains ' , ' username ' , ' man ' );

Syntaxe alternative.

 $ v = new Valitron  Validator ([ ' username ' => ' Batman123 ' ]);
$ v -> rules ([
    ' contains ' => [
        [ ' username ' , ' man ' ]
    ]
]);
$ v -> validate ();

Remarque Vous pouvez utiliser l'indicateur strict facultatif pour garantir une correspondance sensible à la casse. L'exemple suivant renverra vrai :

 $ v = new Valitron  Validator ([ ' username ' => ' Batman123 ' ]);
$ v -> rules ([
    ' contains ' => [
        [ ' username ' , ' man ' ]
    ]
]);
$ v -> validate ();

Alors que cela renverrait false, car le M dans la chaîne de recherche n'est pas en majuscule dans la valeur fournie :

 $ v = new Valitron  Validator ([ ' username ' => ' Batman123 ' ]);
$ v -> rules ([
    ' contains ' => [
        [ ' username ' , ' Man ' , true ]
    ]
]);
$ v -> validate ();

utilisation des champs de sous-ensemble

La règle subset vérifie que le champ est un champ scalaire ou matriciel et que toutes ses valeurs sont contenues dans un ensemble de valeurs donné.

 $ v -> rule ( ' subset ' , ' colors ' , [ ' green ' , ' blue ' , ' orange ' ]);

Syntaxe alternative.

 $ v = new Valitron  Validator ([ ' colors ' => [ ' green ' , ' blue ' ]]);
$ v -> rules ([
    ' subset ' => [
        [ ' colors ' , [ ' orange ' , ' green ' , ' blue ' , ' red ' ]]
    ]
]);
$ v -> validate ();

Cet exemple renverrait false, car la couleur fournie, le violet, n'existe pas dans le tableau de valeurs acceptées que nous fournissons.

 $ v = new Valitron  Validator ([ ' colors ' => [ ' purple ' , ' blue ' ]]);
$ v -> rules ([
    ' subset ' => [
        [ ' colors ' , [ ' orange ' , ' green ' , ' blue ' , ' red ' ]]
    ]
]);
$ v -> validate ();

contientUtilisation des champs uniques

La règle containsUnique vérifie que le champ fourni est un tableau et que toutes les valeurs qu'il contient sont uniques, c'est-à-dire qu'il n'y a pas de valeurs en double dans le tableau.

 $ v -> rule ( ' containsUnique ' , ' colors ' );

Syntaxe alternative.

 $ v = new Valitron  Validator ([ ' colors ' => [ ' purple ' , ' blue ' ]]);
$ v -> rules ([
    ' containsUnique ' => [
        [ ' colors ' ]
    ]
]);
$ v -> validate ();

Cet exemple renverrait false, car les valeurs du tableau fourni sont des doublons.

 $ v = new Valitron  Validator ([ ' colors ' => [ ' purple ' , ' purple ' ]]);
$ v -> rules ([
    ' containsUnique ' => [
        [ ' colors ' ]
    ]
]);
$ v -> validate ();

Utilisation de la validation de carte de crédit

La validation de carte bancaire permet actuellement de valider une Visa visa , Mastercard mastercard , Dinersclub dinersclub , American Express amex ou Discover discover

Cela vérifiera la carte de crédit par rapport à chaque type de carte

 $ v -> rule ( ' creditCard ' , ' credit_card ' );

Pour éventuellement filtrer les types de cartes, ajoutez le slug à un tableau comme paramètre suivant :

 $ v -> rule ( ' creditCard ' , ' credit_card ' , [ ' visa ' , ' mastercard ' ]);

Si vous ne souhaitez valider qu'un seul type de carte, mettez-le sous forme de chaîne :

 $ v -> rule ( ' creditCard ' , ' credit_card ' , ' visa ' );

Si les informations sur le type de carte proviennent du client, vous souhaiterez peut-être également spécifier un tableau de types de cartes valides :

 $ cardType = ' amex ' ;
$ v -> rule ( ' creditCard ' , ' credit_card ' , $ cardType , [ ' visa ' , ' mastercard ' ]);
$ v -> validate (); // false 

Utilisation des champs instanceOf

La règle instanceOf vérifie que le champ est une instance d'une classe donnée.

 $ v -> rule ( ' instanceOf ' , ' date ' , DateTime);

Syntaxe alternative.

 $ v = new Valitron  Validator ([ ' date ' => new  DateTime ()]);
$ v -> rules ([
    ' instanceOf ' => [
        [ ' date ' , ' DateTime ' ]
    ]
]);
$ v -> validate ();

Remarque Vous pouvez également comparer la valeur à un objet donné plutôt qu'au nom de classe de chaîne. Cet exemple retournerait également vrai :

 $ v = new Valitron  Validator ([ ' date ' => new  DateTime ()]);
$ existingDateObject = new  DateTime ();
$ v -> rules ([
    ' instanceOf ' => [
        [ ' date ' , $ existingDateObject ]
    ]
]);
$ v -> validate ();

utilisation des champs facultatifs

La règle optional garantit que si le champ est présent dans l'ensemble de données, il satisfait à toutes les règles de validation.

 $ v -> rule ( ' optional ' , ' username ' );

Syntaxe alternative. Cet exemple renverrait vrai soit lorsque le champ « nom d'utilisateur » n'est pas présent, soit dans le cas où le nom d'utilisateur est uniquement composé de caractères alphabétiques.

 $ v = new Valitron  Validator ([ ' username ' => ' batman ' ]);
$ v -> rules ([
    ' alpha ' => [
        [ ' username ' ]
    ],
    ' optional ' => [
        [ ' username ' ]
    ]
]);
$ v -> validate ();

Cet exemple renverrait false, car bien que le champ soit facultatif, puisqu'il est fourni, il doit passer toutes les règles de validation, ce qui n'est pas le cas dans ce cas.

 $ v = new Valitron  Validator ([ ' username ' => ' batman123 ' ]);
$ v -> rules ([
    ' alpha ' => [
        [ ' username ' ]
    ],
    ' optional ' => [
        [ ' username ' ]
    ]
]);
$ v -> validate ();

Utilisation des champs arrayHasKeys

La règle arrayHasKeys garantit que le champ est un tableau et qu'il contient toutes les clés spécifiées. Renvoie false si le champ n'est pas un tableau ou si aucune clé requise n'est spécifiée ou si une clé est manquante.

 $ v = new Valitron  Validator ([
    ' address ' => [
        ' name ' => ' Jane Doe ' ,
        ' street ' => ' Doe Square ' ,
        ' city ' => ' Doe D.C. '
    ]
]);
$ v -> rule ( ' arrayHasKeys ' , ' address ' , [ ' name ' , ' street ' , ' city ' ]);
$ v -> validate ();

Ajout de règles de validation personnalisées

Pour ajouter votre propre règle de validation, utilisez la méthode addRule avec un nom de règle, un rappel ou une fermeture personnalisée et un message d'erreur à afficher en cas d'erreur. Le rappel fourni doit renvoyer un booléen vrai ou faux.

 Valitron Validator:: addRule ( ' alwaysFail ' , function ( $ field , $ value , array $ params , array $ fields ) {
    return false ;
}, ' Everything you do is wrong. You fail. ' );

Vous pouvez également utiliser des règles ponctuelles valables uniquement pour les champs spécifiés.

 $ v = new Valitron  Validator ( array ( " foo " => " bar " ));
$ v -> rule ( function ( $ field , $ value , $ params , $ fields ) {
    return true ;
}, " foo " )-> message ( " {field} failed... " );

Ceci est utile car ces règles peuvent avoir accès à des variables définies dans la portée où réside le Validator . La signature de Closure est identique à la signature du rappel Validator::addRule .

Si vous souhaitez ajouter vos propres règles qui ne sont pas statiques (c'est-à-dire que votre règle n'est pas statique et disponible pour appeler des instances Validator ), vous devez utiliser Validator::addInstanceRule . Cette règle prendra les mêmes paramètres que Validator::addRule mais elle devra être appelée sur une instance Validator .

Règles de chaînage

Vous pouvez enchaîner plusieurs règles ensemble à l’aide de la syntaxe suivante.

 $ v = new Valitron  Validator ([ ' email_address ' => ' [email protected] ' ]);
$ v -> rule ( ' required ' , ' email_address ' )-> rule ( ' email ' , ' email_address ' );
$ v -> validate ();

Syntaxe alternative pour ajouter des règles

À mesure que le nombre de règles augmente, vous préférerez peut-être la syntaxe alternative pour définir plusieurs règles à la fois.

 $ rules = [
    ' required ' => ' foo ' ,
    ' accepted ' => ' bar ' ,
    ' integer ' =>  ' bar '
];

$ v = new Valitron  Validator ( array ( ' foo ' => ' bar ' , ' bar ' => 1 ));
$ v -> rules ( $ rules );
$ v -> validate ();

Si votre règle nécessite plusieurs paramètres ou un seul paramètre plus complexe qu'une chaîne, vous devez envelopper la règle dans un tableau.

 $ rules = [
    ' required ' => [
        [ ' foo ' ],
        [ ' bar ' ]
    ],
    ' length ' => [
        [ ' foo ' , 3 ]
    ]
];

Vous pouvez également spécifier plusieurs règles pour chaque type de règle.

 $ rules = [
    ' length '   => [
        [ ' foo ' , 5 ],
        [ ' bar ' , 5 ]
    ]
];

En combinant ces techniques, vous pouvez créer une définition de règle complète dans une structure de données relativement compacte.

Vous pouvez continuer à ajouter des règles individuelles avec la méthode rule même après avoir spécifié une définition de règle via un tableau. Ceci est particulièrement utile si vous définissez des règles de validation personnalisées.

 $ rules = [
    ' required ' => ' foo ' ,
    ' accepted ' => ' bar ' ,
    ' integer ' =>  ' bar '
];

$ v = new Valitron  Validator ( array ( ' foo ' => ' bar ' , ' bar ' => 1 ));
$ v -> rules ( $ rules );
$ v -> rule ( ' min ' , ' bar ' , 0 );
$ v -> validate ();

Vous pouvez également ajouter des règles par champ :

 $ rules = [
    ' required ' ,
    [ ' lengthMin ' , 4 ]
];

$ v = new Valitron  Validator ( array ( ' foo ' => ' bar ' ));
$ v -> mapFieldRules ( ' foo ' , $ rules );
$ v -> validate ();

Ou pour plusieurs champs à la fois :

 $ rules = [
    ' foo ' => [ ' required ' , ' integer ' ],
    ' bar ' =>[ ' email ' , [ ' lengthMin ' , 4 ]]
];

$ v = new Valitron Validator(array( ' foo ' => ' bar ' , ' bar ' => '[email protected]));
$v->mapFieldsRules($rules);
$v->validate();

Ajout d'une étiquette de champ aux messages

Vous pouvez procéder de deux manières différentes : vous pouvez ajouter une étiquette individuelle à une règle ou un tableau de toutes les étiquettes pour les règles.

Pour ajouter une étiquette individuelle à une règle, ajoutez simplement la méthode label après la règle.

 $ v = new Valitron  Validator ( array ());
$ v -> rule ( ' required ' , ' name ' )-> message ( ' {field} is required ' )-> label ( ' Name ' );
$ v -> validate ();

Il existe un cas limite dans cette méthode, vous ne pourrez pas utiliser un tableau de noms de champs dans la définition de règle, donc une règle par champ. Donc ça ne marcherait pas :

 $ v = new Valitron  Validator ( array ());
$ v -> rule ( ' required ' , array ( ' name ' , ' email ' ))-> message ( ' {field} is required ' )-> label ( ' Name ' );
$ v -> validate ();

Cependant, nous pouvons utiliser un tableau de labels pour résoudre ce problème en ajoutant simplement la méthode labels à la place :

 $ v = new Valitron  Validator ( array ());
$ v -> rule ( ' required ' , array ( ' name ' , ' email ' ))-> message ( ' {field} is required ' );
$ v -> labels ( array (
    ' name ' => ' Name ' ,
    ' email ' => ' Email address '
));
$ v -> validate ();

Cela introduit un nouvel ensemble de balises dans votre fichier de langue d'erreur qui ressemble à {field} , si vous utilisez une règle comme equals vous pouvez accéder à la deuxième valeur du fichier de langue en incrémentant le champ avec une valeur comme {field1} .

Réutilisation des règles de validation

Vous pouvez réutiliser vos règles de validation pour valider rapidement différentes données avec les mêmes règles en utilisant la méthode withData :

 $ v = new Valitron  Validator ( array ());
$ v -> rule ( ' required ' , ' name ' )-> message ( ' {field} is required ' );
$ v -> validate (); //false

$ v2 = $ v -> withData ( array ( ' name ' => ' example ' ));
$ v2 -> validate (); //true 

Exécution de tests

La suite de tests dépend du chargeur automatique Composer pour charger et exécuter les fichiers Valitron. Veuillez vous assurer d'avoir téléchargé et installé Composer avant d'exécuter les tests :

1. Téléchargez Composer curl -s http://getcomposer.org/installer | php
2. Exécutez 'install' php composer.phar install
3. Exécutez les tests phpunit

Contribuer

1. Fourchette-le
2. Créez votre branche de fonctionnalités ( git checkout -b my-new-feature )
3. Apportez vos modifications
4. Exécutez les tests, en ajoutant de nouveaux pour votre propre code si nécessaire ( phpunit )
5. Validez vos modifications ( git commit -am 'Added some feature' )
6. Pousser vers la branche ( git push origin my-new-feature )
7. Créer une nouvelle demande de tirage
8. Félicitez-vous pour être si génial

Divulgations de sécurité et coordonnées

Pour signaler une vulnérabilité de sécurité, veuillez utiliser le contact de sécurité Tidelift. Tidelift coordonnera le correctif et la divulgation.