Introduction
Zend_Validate
Programmer's Reference Guide

Classes de validation standard

Zend Framework est fourni avec un jeu de classes de validation standard, qui sont directement utilisables par votre application.

Alnum

Retourne TRUE si et seulement si $value contient seulement des caractères alphabétiques et numériques. Ce validateur inclue une option permettant la validation possible des caractères espace.

Alpha

Retourne TRUE si et seulement si $value contient seulement des caractères alphabétiques. Ce validateur inclue une option permettant la validation possible des caractères espace.

Note: Les caractères alphabétiques comprennent les caractères destinés à constituer des mots dans chaque langue. Cependant l'alphabet anglais est aussi utilisé pour les langues suivantes : chinois, japonais et coréen. La langue est spécifiée par Zend_Locale.

Barcode

Zend_Validate_Barcode allows you to check if a given value can be represented as barcode.

Zend_Validate_Barcode supports multiple barcode standards and can be extended with proprietary barcode implementations very easily. The following barcode standards are supported:

  • CODE25: Often called "two of five" or "Code25 Industrial".

    This barcode has no length limitation. It supports only digits, and the last digit can be an optional checksum which is calculated with modulo 10. This standard is very old and nowadays not often used. Common usecases are within the industry.

  • CODE25INTERLEAVED: Often called "Code 2 of 5 Interleaved".

    This standard is a variant of CODE25. It has no length limitation, but it must contain an even amount of characters. It supports only digits, and the last digit can be an optional checksum which is calculated with modulo 10. It is used worldwide and common on the market.

  • CODE39: CODE39 is one of the oldest available codes.

    This barcode has a variable length. It supports digits, upper cased alphabetical characters and 7 special characters like whitespace, point and dollar sign. It can have an optional checksum which is calculated with modulo 43. This standard is used worldwide and common within the industry.

  • CODE39EXT: CODE39EXT is an extension of CODE39.

    This barcode has the same properties as CODE39. Additionally it allows the usage of all 128 ASCII characters. This standard is used worldwide and common within the industry.

  • CODE93: CODE93 is the successor of CODE39.

    This barcode has a variable length. It supports digits, alphabetical characters and 7 special characters. It has an optional checksum which is calculated with modulo 47 and contains 2 characters. This standard produces a denser code than CODE39 and is more secure.

  • CODE93EXT: CODE93EXT is an extension of CODE93.

    This barcode has the same properties as CODE93. Additionally it allows the usage of all 128 ASCII characters. This standard is used worldwide and common within the industry.

  • EAN2: EAN is the shortcut for "European Article Number".

    These barcode must have 2 characters. It supports only digits and does not have a checksum. This standard is mainly used as addition to EAN13 (ISBN) when printed on books.

  • EAN5: EAN is the shortcut for "European Article Number".

    These barcode must have 5 characters. It supports only digits and does not have a checksum. This standard is mainly used as addition to EAN13 (ISBN) when printed on books.

  • EAN8: EAN is the shortcut for "European Article Number".

    These barcode can have 7 or 8 characters. It supports only digits. When it has a length of 8 characters it includes a checksum. This standard is used worldwide but has a very limited range. It can be found on small articles where a longer barcode could not be printed.

  • EAN12: EAN is the shortcut for "European Article Number".

    This barcode must have a length of 12 characters. It supports only digits, and the last digit is always a checksum which is calculated with modulo 10. This standard is used within the USA and common on the market. It has been superceded by EAN13.

  • EAN13: EAN is the shortcut for "European Article Number".

    This barcode must have a length of 13 characters. It supports only digits, and the last digit is always a checksum which is calculated with modulo 10. This standard is used worldwide and common on the market.

  • EAN14: EAN is the shortcut for "European Article Number".

    This barcode must have a length of 14 characters. It supports only digits, and the last digit is always a checksum which is calculated with modulo 10. This standard is used worldwide and common on the market. It is the successor for EAN13.

  • EAN18: EAN is the shortcut for "European Article Number".

    This barcode must have a length of 18 characters. It support only digits. The last digit is always a checksum digit which is calculated with modulo 10. This code is often used for the identification of shipping containers.

  • GTIN12: GTIN is the shortcut for "Global Trade Item Number".

    This barcode uses the same standard as EAN12 and is its successor. It's commonly used within the USA.

  • GTIN13: GTIN is the shortcut for "Global Trade Item Number".

    This barcode uses the same standard as EAN13 and is its successor. It is used worldwide by industry.

  • GTIN14: GTIN is the shortcut for "Global Trade Item Number".

    This barcode uses the same standard as EAN14 and is its successor. It is used worldwide and common on the market.

  • IDENTCODE: Identcode is used by Deutsche Post and DHL. It's an specialized implementation of Code25.

    This barcode must have a length of 12 characters. It supports only digits, and the last digit is always a checksum which is calculated with modulo 10. This standard is mainly used by the companies DP and DHL.

  • INTELLIGENTMAIL: Intelligent Mail is a postal barcode.

    This barcode can have a length of 20, 25, 29 or 31 characters. It supports only digits, and contains no checksum. This standard is the successor of PLANET and POSTNET. It is mainly used by the United States Postal Services.

  • ISSN: ISSN is the abbreviation for International Standard Serial Number.

    This barcode can have a length of 8 or 13 characters. It supports only digits, and the last digit must be a checksum digit which is calculated with modulo 11. It is used worldwide for printed publications.

  • ITF14: ITF14 is the GS1 implementation of an Interleaved Two of Five bar code.

    This barcode is a special variant of Interleaved 2 of 5. It must have a length of 14 characters and is based on GTIN14. It supports only digits, and the last digit must be a checksum digit which is calculated with modulo 10. It is used worldwide and common within the market.

  • LEITCODE: Leitcode is used by Deutsche Post and DHL. It's an specialized implementation of Code25.

    This barcode must have a length of 14 characters. It supports only digits, and the last digit is always a checksum which is calculated with modulo 10. This standard is mainly used by the companies DP and DHL.

  • PLANET: Planet is the abbreviation for Postal Alpha Numeric Encoding Technique.

    This barcode can have a length of 12 or 14 characters. It supports only digits, and the last digit is always a checksum. This standard is mainly used by the United States Postal Services.

  • POSTNET: Postnet is used by the US Postal Service.

    This barcode can have a length of 6, 7, 10 or 12 characters. It supports only digits, and the last digit is always a checksum. This standard is mainly used by the United States Postal Services.

  • ROYALMAIL: Royalmail is used by Royal Mail.

    This barcode has no defined length. It supports digits, uppercased letters, and the last digit is always a checksum. This standard is mainly used by Royal Mail for their Cleanmail Service. It is also called RM4SCC.

  • SSCC: SSCC is the shortcut for "Serial Shipping Container Code".

    This barcode is a variant of EAN barcode. It must have a length of 18 characters and supports only digits. The last digit must be a checksum digit which is calculated with modulo 10. It is commonly used by the transport industry.

  • UPCA: UPC is the shortcut for "Univeral Product Code".

    This barcode preceeded EAN13. It must have a length of 12 characters and supports only digits. The last digit must be a checksum digit which is calculated with modulo 10. It is commonly used within the USA.

  • UPCE: UPCE is the short variant from UPCA.

    This barcode is a smaller variant of UPCA. It can have a length of 6, 7 or 8 characters and supports only digits. When the barcode is 8 chars long it includes a checksum which is calculated with modulo 10. It is commonly used with small products where a UPCA barcode would not fit.

Supported options for Zend_Validate_Barcode

The following options are supported for Zend_Validate_Barcode:

  • adapter: Sets the barcode adapter which will be used. Supported are all above noted adapters. When using a self defined adapter, then you have to set the complete classname.

  • checksum: TRUE when the barcode should contain a checksum. The default value depends on the used adapter. Note that some adapters don't allow to set this option.

  • options: Defines optional options for a self written adapters.

Basic usage

To validate if a given string is a barcode you just need to know its type. See the following example for an EAN13 barcode:

  1. $valid = new Zend_Validate_Barcode('EAN13');
  2. if ($valid->isValid($input)) {
  3.     // input appears to be valid
  4. } else {
  5.     // input is invalid
  6. }

Optional checksum

Some barcodes can be provided with an optional checksum. These barcodes would be valid even without checksum. Still, when you provide a checksum, then you should also validate it. By default, these barcode types perform no checksum validation. By using the checksum option you can define if the checksum will be validated or ignored.

  1. $valid = new Zend_Validate_Barcode(array(
  2.     'adapter'  => 'EAN13',
  3.     'checksum' => false,
  4. ));
  5. if ($valid->isValid($input)) {
  6.     // input appears to be valid
  7. } else {
  8.     // input is invalid
  9. }

Note: Reduced security by disabling checksum validation
 By switching off checksum validation you will also reduce the security of the used barcodes. Additionally you should note that you can also turn off the checksum validation for those barcode types which must contain a checksum value. Barcodes which would not be valid could then be returned as valid even if they are not.

Writing custom adapters

You may write custom barcode validators for usage with Zend_Validate_Barcode; this is often necessary when dealing with proprietary barcode types. To write your own barcode validator, you need the following information.

  • Length: The length your barcode must have. It can have one of the following values:

    • Integer: A value greater 0, which means that the barcode must have this length.

    • -1: There is no limitation for the length of this barcode.

    • "even": The length of this barcode must have a even amount of digits.

    • "odd": The length of this barcode must have a odd amount of digits.

    • array: An array of integer values. The length of this barcode must have one of the set array values.

  • Characters: A string which contains all allowed characters for this barcode. Also the integer value 128 is allowed, which means the first 128 characters of the ASCII table.

  • Checksum: A string which will be used as callback for a method which does the checksum validation.

Your custom barcode validator must extend Zend_Validate_Barcode_AdapterAbstract or implement Zend_Validate_Barcode_AdapterInterface.

As an example, let's create a validator that expects an even number of characters that include all digits and the letters 'ABCDE', and which requires a checksum.

  1. class My_Barcode_MyBar extends Zend_Validate_Barcode_AdapterAbstract
  2. {
  3.     protected $_length     = 'even';
  4.     protected $_characters = '0123456789ABCDE';
  5.     protected $_checksum   = '_mod66';
  6.  
  7.     protected function _mod66($barcode)
  8.     {
  9.         // do some validations and return a boolean
  10.     }
  11. }
  12.  
  13. $valid = new Zend_Validate_Barcode('My_Barcode_MyBar');
  14. if ($valid->isValid($input)) {
  15.     // input appears to be valid
  16. } else {
  17.     // input is invalid
  18. }

Between

Retourne TRUE si et seulement si $value est compris entre les valeurs minimum et maximum définies. La comparaison inclue par défaut les bornes ($value peut égaler le minimum ou le maximum), bien que ceci puisse être surchargé pour avoir une comparaison stricte, où $value doit être strictement supérieur au minimum et strictement inférieur au maximum.

Callback (fonction de rappel)

Zend_Validate_Callback permet de fournir une fonction de rappel utilisée pour valider la valeur.

Utilisation classique

Le plus simple est de posséder une fonction classique, qui sera utilisée pour valider la donnée. Soit la fonction ci-après :

  1. function myMethod($value)
  2. {
  3.     // ici de la validation à effectuer
  4.     return true;
  5. }

Pour l'utiliser avecZend_Validate_Callback vous devez simplement effectuer votre appel comme ceci:

  1. $valid = new Zend_Validate_Callback('myMethod');
  2. if ($valid->isValid($input)) {
  3.     // input semble valide
  4. } else {
  5.     // input est invalide
  6. }

Utilisation avec les fonctions anonymes (closures)

PHP 5.3 introduit les » fonctions anonymes ou fonctions de fermeture. PHP traite les fonctions anonymes comme des fonctions de rappel valides, et il est donc possible d'utiliser celles-ci avec Zend_Validate_Callback. Exemple:

  1. $valid = new Zend_Validate_Callback(function($value){
  2.     // Validation ici
  3.     return true;
  4. });
  5.  
  6. if ($valid->isValid($input)) {
  7.     // input semble valide
  8. } else {
  9.     // input est invalide
  10. }

Utilisation avec les méthodes de rappel

Bien sûr, il est aussi possible d'utiliser des méthodes de rappel:

  1. class MyClass
  2. {
  3.     public function myMethod($value)
  4.     {
  5.         // Validation ici
  6.         return true;
  7.     }
  8. }

La définition de la fonction de rappel se fait alors dans un tableau contenant un objet de la classe et la méthode à appeler:

  1. $object = new MyClass;
  2. $valid = new Zend_Validate_Callback(array($object, 'myMethod'));
  3. if ($valid->isValid($input)) {
  4.     // input semble valide
  5. } else {
  6.     // input est invalide
  7. }

Il est aussi possible d'utiliser une méthode statique comme fonction de rappel:

  1. class MyClass
  2. {
  3.     public static function test($value)
  4.     {
  5.         // Validation ici
  6.         return true;
  7.     }
  8. }
  9.  
  10. $valid = new Zend_Validate_Callback(array('MyClass', 'test'));
  11. if ($valid->isValid($input)) {
  12.     // input semble valide
  13. } else {
  14.     // input est invalide
  15. }

Enfin, PHP 5.3 définit la méthode magique __invoke(). Si vous l'utilisez, alors un simple objet suffira comme fonction de rappel:

  1. class MyClass
  2. {
  3.     public function __invoke($value)
  4.     {
  5.         // Validation ici
  6.         return true;
  7.     }
  8. }
  9.  
  10. $object = new MyClass();
  11. $valid = new Zend_Validate_Callback($object);
  12. if ($valid->isValid($input)) {
  13.     // input semble valide
  14. } else {
  15.     // input est invalide
  16. }

Ajouter des options

Zend_Validate_Callback permet d'utiliser des options, celles-ci seront alors passées comme argument supplémentaires à la fonction de callback.

Soit la définition suivante:

  1. class MyClass
  2. {
  3.     function myMethod($value, $option)
  4.     {
  5.         // De la validation ici
  6.         return true;
  7.     }
  8. }

Il extsite deux manières d'indiquer des options au validateur : via le constructeur ou sa méthode setOptions().

Via le constructeur, passez un tableau contenant les clés "callback" et "options":

  1. $valid = new Zend_Validate_Callback(array(
  2.     'callback' => array('MyClass', 'myMethod'),
  3.     'options'  => $option,
  4. ));
  5.  
  6. if ($valid->isValid($input)) {
  7.     // input semble valide
  8. } else {
  9.     // input est invalide
  10. }

Sinon, vous pouvez passer les options après:

  1. $valid = new Zend_Validate_Callback(array('MyClass', 'myMethod'));
  2. $valid->setOptions($option);
  3.  
  4. if ($valid->isValid($input)) {
  5.     // input semble valide
  6. } else {
  7.     // input est invalide
  8. }

Si des valeurs supplémentaires sont passées à isValid() elles seront utilisées comme arguments supplémentaires lors de l'appel à la fonction de rappel, mais avant les options $options.

  1. $valid = new Zend_Validate_Callback(array('MyClass', 'myMethod'));
  2. $valid->setOptions($option);
  3.  
  4. if ($valid->isValid($input, $additional)) {
  5.     // input semble valide
  6. } else {
  7.     // input est invalide
  8. }

Lors de l'appel à la fonction de rappel, la valeur à valider sera toujours passée comme premier argument à la fonction de rappel suivie de toutes les autres valeurs passées à isValid(); les autres options suivront. Le nombre et le type d'options qui peuvent être utilisées est illimité.

CreditCard

Zend_Validate_CreditCard permet de valider si une valeur est susceptible de représenter un numéro de carte de crédit.

Une carte de crédit contient plein de données, incluant un hologramme, un numéro de compte, un logo, une date d'expiration, un code de sécurité et le nom du détenteur. L'algorithme qui vérifie la combinaison de ces données n'est connu que des entreprises délivrant les cartes et devrait être vérifié lors d'un paiement. Cependant, il est utile de savoir si le numéro de la carte est valable avant d'effectuer de telles vérifications complexes. Zend_Validate_CreditCard vérifie simplement que le numéro est bien formé.

Dans les cas où vous possederiez un service capable d'effectuer des vérifications complètes, Zend_Validate_CreditCard vous permet de passer une fonction de rappel à utiliser si le numéro a été vérifié comme valide. Le retour de la fonction de rappel servira alors de retour général du validateur.

Les institutions suivantes sont acceptées:

  • American Express

    China UnionPay

    Diners Club Card Blanche

    Diners Club International

    Diners Club US & Canada

    Discover Card

    JCB

    Laser

    Maestro

    MasterCard

    Solo

    Visa

    Visa Electron

Note: Institutions non valides
 Bankcard et Diners Club enRoute n'existent plus, elles sont donc considérées non valides.
Switch est rattaché à Visa et est donc considérée comme non valide.

Utilisation classique

Il y a plusieurs institutions qui peuvent être validées par Zend_Validate_CreditCard. Par défaut, toutes les institutions connues sont acceptées:

  1. $valid = new Zend_Validate_CreditCard();
  2. if ($valid->isValid($input)) {
  3.     // input semble valide
  4. } else {
  5.     // input est invalide
  6. }

L'exemple ci-dessus valide le numéro pour toutes les institutions connues.

Accepter seulement certains types de cartes

Il peut arriver que vous ne vouliez valider que certains types de cartes plutôt que toutes les institutions connues. Zend_Validate_CreditCard permet ceci.

Pour utiliser une limite, spécifiez les institutions accéptées à l'initialisation ou après, grâce à setType(). Plusieurs arguments sont utilisables.

Vous pouvez préciser une seule institution:

  1. $valid = new Zend_Validate_CreditCard(
  2.     Zend_Validate_CreditCard::AMERICAN_EXPRESS
  3. );

Plusieurs institutions se précisent au moyen d'un tableau:

  1. $valid = new Zend_Validate_CreditCard(array(
  2.     Zend_Validate_CreditCard::AMERICAN_EXPRESS,
  3.     Zend_Validate_CreditCard::VISA
  4. ));

Et comme pour tout validateur, vous pouvez passer un tableau global ou un objet Zend_Config. Dans ce cas, les institutions se précisent au moyen de la clé type:

  1. $valid = new Zend_Validate_CreditCard(array(
  2.     'type' => array(Zend_Validate_CreditCard::AMERICAN_EXPRESS)
  3. ));
Constante représentant les institutions
Institution Constante
American Express AMERICAN_EXPRESS
China UnionPay UNIONPAY
Diners Club Card Blanche DINERS_CLUB
Diners Club International DINERS_CLUB
Diners Club US & Canada DINERS_CLUB_US
Discover Card DISCOVER
JCB JCB
Laser LASER
Maestro MAESTRO
MasterCard MASTERCARD
Solo SOLO
Visa VISA
Visa Electron VISA

Vous pouvez aussi configurer les institutions valides après la construction, au moyen des méthodes setType(), addType() et getType().

  1. $valid = new Zend_Validate_CreditCard();
  2. $valid->setType(array(
  3.     Zend_Validate_CreditCard::AMERICAN_EXPRESS,
  4.     Zend_Validate_CreditCard::VISA
  5. ));

Note: Institution par défaut
 Si vous ne précisez pas d'institution à la construction, alors ALL sera utilisée, et donc toutes les institutions seront utilisées.
Dans ce cas, utiliser addType() ne sert à rien.

Validation par fonction de rappel

Comme déja dit, Zend_Validate_CreditCard ne valide que le numéro de la carte. Heureusement, certaines institutions proposent des APIs pour valider des numéros de carte de crédit qui ne sont pas publiques. Ces services sont très souvent payants, ainsi cette vérification est par défaut désactivée.

Lorsque vous avez accès à de telles APIs, vous pouvez les utiliser comme fonctions additionnelles à Zend_Validate_CreditCard et ainsi augmenter la sécurité de la validation.

Pour ce faire, vous devez simplement préciser une fonction de rappel qui sera appelée après que la validation "classique" ait réussi. Ceci évite un appel à l' API avec un numéro de toute façon non valide et augmentera ainsi les performances de la validation et donc de l'application.

setService() et getService() sont utilisée pour la fonction de rappel. La clé de configuration à utiliser, si vous le souhaitez, est 'service' (à la construction). Des détails peuvent être trouvés sur la documentation du validateurCallback.

  1. // Votre classe de service
  2. class CcService
  3. {
  4.     public function checkOnline($cardnumber, $types)
  5.     {
  6.         // Processus de validation ici
  7.     }
  8. }
  9.  
  10. // La validation
  11. $service = new CcService();
  12. $valid   = new Zend_Validate_CreditCard(Zend_Validate_CreditCard::VISA);
  13. $valid->setService(array($service, 'checkOnline'));

Ici le service sera appelé avec le numéro de carte comme premier paramètre, et les types accéptés comme second.

Ccnum

Retourne TRUE si et seulement si $value respecte » l'algorithme de Luhn ("module 10") pour les numéros de cartes de crédits.

Note: Le validateur Ccnum a été déprécié en faveur du validateur CreditCard. Pour des raisons de sécurité, vous devriez utiliser CreditCard au lieu de Ccnum.

Date

Retourne TRUE si $value est une date valide au format YYYY-MM-DD. Si l'option locale est fournie alors la date sera validé suivant le paramètre local. Enfin si l'option format est fournie ce format est utilisé pour la validation. Pour plus de détails concernant les paramètres optionnel, referez vous à Zend_Date::isDate().

Db_RecordExists et Db_NoRecordExists

Zend_Validate_Db_RecordExists et Zend_Validate_Db_NoRecordExists permettent de vérifier si un enregistrement existe (ou pas) dans une table de base de données.

Utilisation de base

Voici un exemple basique:

  1. //Vérifie que l'email existe bien dans la base de données
  2. $validator = new Zend_Validate_Db_RecordExists('users', 'emailaddress');
  3. if ($validator->isValid($emailaddress)) {
  4.     // l'adresse email existe
  5. } else {
  6.     // l'adresse email n'existe pas, affichons les messages d'erreur
  7.     foreach ($validator->getMessages() as $message) {
  8.         echo "$message\n";
  9.     }
  10. }

Le code ci-dessus vérifie la présence d'une adresse email $emailaddress vis à vis d'un champ d'une table de base de données.

  1. //Vérifie que le nom d'utilisateur n'est pas présent dans la table
  2. $validator = new Zend_Validate_Db_NoRecordExists('users', 'username');
  3. if ($validator->isValid($username)) {
  4.     // Le nom d'utilisateur semble absent de la table
  5. } else {
  6.     // invalide : l'utilisateur est probablement présent dans la table
  7.     $messages = $validator->getMessages();
  8.     foreach ($messages as $message) {
  9.         echo "$message\n";
  10.     }
  11. }

Le code ci-dessus vérifie l'absence d'un nom d'utilisateur $username vis à vis d'un champ d'une table de base de données.

Exclure des enregistrement

Zend_Validate_Db_RecordExists et Zend_Validate_Db_NoRecordExists proposent aussi un moyen de tester la base de données en excluant certaines parties de table, en passant une clause where ou un tableau de paires "champs" "valeur".

Lorsqu'un tableau est passé, l'opérateur != est utilisé et vous pouvez ainsi tester le reste de la table.

  1. //Vérifie qu'aucun autre utilisateur que celui dont l'id est spécifié, ne possède ce nom
  2. $user_id   = $user->getId();
  3. $validator = new Zend_Validate_Db_NoRecordExists(
  4.     'users',
  5.     'username',
  6.     array(
  7.         'field' => 'id',
  8.         'value' => $user_id
  9.     )
  10. );
  11.  
  12. if ($validator->isValid($username)) {
  13.     // OK
  14. } else {
  15.     // KO
  16.     $messages = $validator->getMessages();
  17.     foreach ($messages as $message) {
  18.         echo "$message\n";
  19.     }
  20. }

L'exemple ci dessus va vérifier qu'aucun utilisateur dont l'id n'est pas celui spécifié, possède ce nom là $username.

La clause d'exclusion peut aussi être renseignée avec une chaine afin de pouvoir utiliser un opérateur autre que !=.

  1. $post_id   = $post->getId();
  2. $clause    = $db->quoteInto('post_id = ?', $category_id);
  3. $validator = new Zend_Validate_Db_RecordExists(
  4.     'posts_categories',
  5.     'post_id',
  6.     $clause
  7. );
  8.  
  9. if ($validator->isValid($username)) {
  10.     // OK
  11. } else {
  12.     // KO
  13.     $messages = $validator->getMessages();
  14.     foreach ($messages as $message) {
  15.         echo "$message\n";
  16.     }
  17. }

L'exemple ci-dessus vérifie la table posts_categories pour s'assurer qu'un enregistrement avec post_id corresponde à $category_id

Adaptateurs de base de données

Un adaptateur spécifique peut être passé au validateur. Dans le cas contraire, il utilisera l'adaptateur déclaré comme étant celui par défaut:

  1. $validator = new Zend_Validate_Db_RecordExists('users', 'id', null, $dbAdapter);

Nom des bases de données

Vous pouvez spécifier un nom de base de données (schéma) pour l'adaptateur PostgreSQL et DB/2 simplement grâce à un tableau possédant les clés table et schema. Voici un exemple:

  1. $validator = new Zend_Validate_Db_RecordExists(array('table' => 'users',
  2.                                                      'schema' => 'my'), 'id');

Digits

Retourne TRUE si et seulement si $value contient seulement des caractères numériques.

EmailAddress

Zend_Validate_EmailAddress permet de valider une adresse émail. Ce validateur éclate d'abord l'adresse émail entre partie locale et domaine et essaie de valider ces deux parties conformément aux spécifications des adresses émail et des noms de domaine.

Utilisation de base

Vous trouverez ci-dessous un exemple d'utilisation basique 

  1. $validateur = new Zend_Validate_EmailAddress();
  2. if ($validateur->isValid($email)) {
  3.     // l'email est valide
  4. } else {
  5.     // l'email est invalide ; afficher pourquoi
  6.     foreach ($validateur->getMessages() as $message) {
  7.         echo "$message\n";
  8.     }
  9. }

Ceci validera l'adresse émail $email et, en cas d'échec, fournira des messages d'erreur informatifs via $validator->getMessages().

Options for validating Email Addresses

Zend_Validate_EmailAddress supports several options which can either be set at initiation, by giving an array with the related options, or afterwards, by using setOptions(). The following options are supported:

  • allow: Defines which type of domain names are accepted. This option is used in conjunction with the hostname option to set the hostname validator. For more informations about possible values of this option, look at Hostname and possible ALLOW* constants. This option defaults to ALLOW_DNS.

  • hostname: Sets the hostname validator with which the domain part of the email address will be validated.

  • mx: Defines if the MX records from the server should be detected. If this option is defined to TRUE then the MX records are used to verify if the server accepts emails. This option defaults to FALSE.

  • deep: Defines if the servers MX records should be verified by a deep check. When this option is set to TRUE then additionally to MX records also the A, A6 and AAAA records are used to verify if the server accepts emails. This option defaults to FALSE.

  • domain: Defines if the domain part should be checked. When this option is set to FALSE, then only the local part of the email address will be checked. In this case the hostname validator will not be called. This option defaults to TRUE.

  1. $validator = new Zend_Validate_EmailAddress();
  2. $validator->setOptions(array('domain' => false));

Parties locales complexes

Zend_Validate_EmailAddress validera toute adresse émail conforme à la RFC2822. Comme par exemple bob@domaine.com, bob+jones@domaine.fr, "bob@jones"@domaine.com et "bob jones"@domaine.com. Quelques formats d'émail obsolètes ne seront pas validés (comme tout émail contenant un retour chariot ou un caractère "\").

Validating only the local part

If you need Zend_Validate_EmailAddress to check only the local part of an email address, and want to disable validation of the hostname, you can set the domain option to FALSE. This forces Zend_Validate_EmailAddress not to validate the hostname part of the email address.

  1. $validator = new Zend_Validate_EmailAddress();
  2. $validator->setOptions(array('domain' => FALSE));

Validation de différents types de noms de domaine

La partie domaine d'une adresse émail est validée via Zend_Validate_Hostname. Par défaut, seules les domaines qualifiés sous la forme domaine.com sont acceptés, même si, il vous est possible d'accepter les adresses IP et les domaines locaux également.

Afin de réaliser cette opération, il vous faut instancier Zend_Validate_EmailAddress en lui passant un paramètre indiquant le type de nom de domaine à accepter. Les détails sont disponibles dans Zend_Validate_EmailAddress mais vous trouverez ci-dessous un exemple illustrant comment accepter les noms de domaines qualifiés et les hôtes locaux :

  1. $validator = new Zend_Validate_EmailAddress(
  2.                     Zend_Validate_Hostname::ALLOW_DNS |
  3.                     Zend_Validate_Hostname::ALLOW_LOCAL);
  4. if ($validator->isValid($email)) {
  5.     // l'email est valide
  6. } else {
  7.     // l'email est invalide ; afficher pourquoi
  8.     foreach ($validateur->getMessages() as $message) {
  9.         echo "$message\n";
  10.     }
  11. }

Vérification que le nom de domaine accepte réellement l'émail

Le fait qu'une adresse électronique est dans un format correct, ne signifie pas nécessairement que l'adresse électronique existe en réalité. Pour aider résoudre ce problème, vous pouvez utiliser la validation MX pour vérifier si une entrée MX (l'émail) existe dans le l'enregistrement du DNS pour le nom de domaine de l'émail. Cela vous dit que le nom de domaine accepte l'émail, mais ne vous dit pas que l'adresse électronique elle-même est valable.

La vérification MX n'est pas active par défaut et est seulement supporté par des plates-formes UNIX pour l'instant. Pour activer la vérification MX vous pouvez passer un deuxième paramètre au constructeur Zend_Validate_EmailAddress.

  1. $validator = new Zend_Validate_EmailAddress(
  2.     array(
  3.         'allow' => Zend_Validate_Hostname::ALLOW_DNS,
  4.         'mx'    => true
  5.     )
  6. );

Note: MX Check under Windows
 Within Windows environments MX checking is only available when PHP 5.3 or above is used. Below PHP 5.3 MX checking will not be used even if it's activated within the options.

Alternativement vous pouvez passer soit TRUE soit FALSE à $validator->setValidateMx() pour activer ou désactiver la validation MX.

En activant ce paramètre, les fonctions de réseau seront utilisés pour vérifier la présence d'un enregistrement MX sur le nom de domaine de l'adresse électronique que vous voulez valider. Faîtes cependant attention, cela ralentira probablement votre scénario.

Sometimes validation for MX records returns FALSE, even if emails are accepted. The reason behind this behaviour is, that servers can accept emails even if they do not provide a MX record. In this case they can provide A, A6 or AAAA records. To allow Zend_Validate_EmailAddress to check also for these other records, you need to set deep MX validation. This can be done at initiation by setting the deep option or by using setOptions().

  1. $validator = new Zend_Validate_EmailAddress(
  2.     array(
  3.         'allow' => Zend_Validate_Hostname::ALLOW_DNS,
  4.         'mx'    => true,
  5.         'deep'  => true
  6.     )
  7. );
Warning

Performance warning

You should be aware that enabling MX check will slow down you script because of the used network functions. Enabling deep check will slow down your script even more as it searches the given server for 3 additional types.

Note: Disallowed IP addresses
 You should note that MX validation is only accepted for external servers. When deep MX validation is enabled, then local IP addresses like 192.168.* or 169.254.* are not accepted.

Valider les noms de domaines internationaux

Zend_Validate_EmailAddress peut aussi vérifier les caractères internationaux qui existent dans quelques domaines. Ceci est connu comme le support de Nom de Domaine International (IDN). Celui-ci est activé par défaut, quoique vous puissiez le mettre hors service en changeant le paramètre via l'objet interne Zend_Validate_Hostname qui existe dans Zend_Validate_EmailAddress.

  1. $validator->hostnameValidator->setValidateIdn(false);

De plus amples informations concernant l'utilisation de setValidateIdn() sont présentes dans la documentation de Zend_Validate_Hostname.

Notez cependant que les IDNs sont seulement validés si vous autorisez la validation des nom de domaines.

Validation des "Top Level Domains"

Par défaut un nom de domaine sera vérifié grâce à une liste de TLDs connus. Ceci est activé par défaut, quoique vous puissiez le mettre hors service en changeant le paramètre via l'objet Zend_Validate_Hostname interne qui existe dans Zend_Validate_EmailAddress.

  1. $validator->hostnameValidator->setValidateTld(false);

De plus amples informations concernant l'utilisation de setValidateTld() sont présentes dans la documentation de Zend_Validate_Hostname.

Notez cependant que les TLDs sont seulement validés si vous autorisez la validation des nom de domaines.

Setting messages

Zend_Validate_EmailAddress makes also use of Zend_Validate_Hostname to check the hostname part of a given email address. As with Zend Framework 1.10 you can simply set messages for Zend_Validate_Hostname from within Zend_Validate_EmailAddress.

  1. $validator = new Zend_Validate_EmailAddress();
  2. $validator->setMessages(
  3.     array(
  4.         Zend_Validate_Hostname::UNKNOWN_TLD => 'I don't know the TLD you gave'
  5.     )
  6. );

Before Zend Framework 1.10 you had to attach the messages to your own Zend_Validate_Hostname, and then set this validator within Zend_Validate_EmailAddress to get your own messages returned.

Float

Retourne TRUE si et seulement si $value est une valeur en virgule flottante. A partir de Zend Framework 1.8 ce validateur prend en considération la locale courante issue du navigateur, de l'environnement ou de l'application. Vous pouvez bien sûr utiliser les accesseurs get/setLocale pour changer ou la fournir au moment de la création de l'instance de ce validateur.

GreaterThan

Retourne TRUE si et seulement si $value est supérieure à une valeur minimum fournie.

Hex

Retourne TRUE si et seulement si $value contient seulement des caractères numériques hexadécimaux.

Hostname

Zend_Validate_Hostname vous permet de valider un nom de domaine sur la base d'un ensemble de spécifications connues. Il est ainsi possible de valider trois types différents de noms de domaine : un nom de domaine qualifié (ex : domaine.com), une adresse IP (ex : 1.2.3.4) ou un nom de domaine local (ex : localhost). Par défaut, seul les noms de domaine qualifiés sont acceptés.

Utilisation basique

Exemple simple :

  1. $validateur = new Zend_Validate_Hostname();
  2. if ($validateur->isValid($domaine)) {
  3.     // le nom de domaine est valide
  4. } else {
  5.     // le nom de domaine est invalide ; afficher pourquoi
  6.     foreach ($validateur->getMessages() as $message) {
  7.         echo "$message\n";
  8.     }
  9. }
Ceci validera le domaine $domaine et, en cas d'échec, fournira des messages d'erreur informatifs via $validator->getMessages().

Validation de différents types de noms de domaine

Il peut se trouver que vous souhaitez valider des adresses IP, des noms de domaine locaux ou toute combinaison de tous les types disponibles. Cette opération peut être effectuée en passant un paramètre à Zend_Validate_Hostname au moment de l'instanciation. Le paramètre doit être un entier qui détermine quels types de noms de domaine sont admis. Il est recommandé d'utiliser les constantes de la classe Zend_Validate_Hostname.

Les constantes de Zend_Validate_Hostname sont : ALLOW_DNS qui autorise uniquement les noms de domaine qualifiés, ALLOW_IP qui autorise les adresses IP, ALLOW_LOCAL qui autorise les domaines locaux et ALLOW_ALL qui autorise les trois types précédents. Pour vérifier uniquement les adresses IP, vous pouvez utiliser l'exemple suivant :

  1. $validateur = new Zend_Validate_Hostname(Zend_Validate_Hostname::ALLOW_IP);
  2. if ($validateur->isValid($hostname)) {
  3.     // le nom de domaine est valide
  4. } else {
  5.     // le nom de domaine est invalide ; afficher pourquoi
  6.     foreach ($validateur->getMessages() as $message) {
  7.         echo "$message\n";
  8.     }
  9. }

Vous pouvez utiliser ALLOW_ALL pour accepter tous les types de domaines. De même, vous pouvez créer des configurations combinant ces différents types. Par exemple, pour accepter les domaines qualifiés et les domaines locaux, instanciez votre objet Zend_Validate_Hostname de la manière suivante : 

$validateur = new Zend_Validate_Hostname(Zend_Validate_Hostname::ALLOW_DNS |
                                         Zend_Validate_Hostname::ALLOW_IP);

Validation de Nom de Domaine International (IDN)

Certains noms de domaines nationaux (Country Code Top Level Domains ou ccTLD), comme .de (Allemagne), supporte les caractères internationaux dans leurs noms de domaine. Ceci est connu sous le nom de Nom de Domaine International (IDN). Ces domaines peuvent être vérifiés par Zend_Validate_Hostname grâce aux caractères étendus qui sont utilisés dans le processus de validation.

Jusqu'à maintenant plus de 50 ccTLDs supportent les domaines IDN.

Pour vérifier un domaine IDN c'est aussi simple que d'utiliser le validateur standard de nom de domaine puisque la validation IDN est activé par défaut. Si vous voulez mettre hors service la validation IDN, cela peut être fait par le passage d'un paramètre au constructeur Zend_Validate_Hostname ou via la méthode $validator->setValidateIdn().

Vous pouvez aussi désactiver la validation IDN en passant un second paramètre au constructeur du Zend_Validate_Hostname comme ceci : 

$validator =
    new Zend_Validate_Hostname(
        array(
            'allow' => Zend_Validate_Hostname::ALLOW_DNS,
            'idn'   => false
        )
    );
Alternativement vous pouvez passer soit TRUE soit FALSE à $validator->setValidateIdn() pour activer ou désactiver la validation IDN. Si vous essayez de vérifier un nom de domaine IDN qui n'est pas actuellement soutenu il est probable qu'il retournera une erreur s'il y a des caractères internationaux. Quand un fichier de ccTLD spécifiant les caractères supplémentaires n'existe pas dans "Zend/Validate/Hostname",une validation de nom de domaine normale est réalisée.

Notez cependant que les IDNs sont seulement validés si vous autorisez la validation des noms de domaine.

Validation des "Top Level Domains"

Par défaut un nom de domaine sera vérifié grâce à une liste de TLDs connus. Si cette fonctionnalité n'est pas nécessaire, elle peut être désactivée de la même façon que la désactivation du support des IDNs. Vous pouvez désactiver la validation TLD en passant un troisième paramètre au constructeur de Zend_Validate_Hostname. Dans l'exemple ci-dessous, la validation IDN est supportée via le second paramètre.

  1. $validator =
  2.     new Zend_Validate_Hostname(
  3.         array(
  4.             'allow' => Zend_Validate_Hostname::ALLOW_DNS,
  5.             'idn'   => true,
  6.             'tld'   => false
  7.         )
  8.     );
Alternativement vous pouvez passer soit TRUE soit FALSE à $validator->setValidateTld() pour activer ou désactiver la validation TLD.

Notez cependant que les TLDs sont seulement validés si vous autorisez la validation des noms de domaine.

Iban

Retourne TRUE si et seulement si $value contient un IBAN valide (International Bank Account Number = Numéro de compte bancaire international). Les numéros IBAN sont validés suivant le pays dans lequel ils sont utilisés et par un somme de contrôle.

Il existe deux manières de valider les numéros IBAN. En premier lieu, vous pouvez fournir une locale qui représente un pays. Tout numéro IBAN fourni sera donc validé suivant ce pays.

  1. $validator = new Zend_Validate_Iban('de_AT');
  2. $iban = 'AT611904300234573201';
  3. if ($validator->isValid($iban)) {
  4.     // IBAN paraît être valide
  5. } else {
  6.     // IBAN est invalide
  7.     foreach ($validator->getMessages() as $message) {
  8.         echo "$message\n";
  9.     }
  10. }

Vous pouvez aussi vouloir valider les numéros IBAN pour des pays uniques. La manière la plus simple est donc de ne pas fournir de locale comme dans l'exemple suivant.

  1. $validator = new Zend_Validate_Iban();
  2. $iban = 'AT611904300234573201';
  3. if ($validator->isValid($iban)) {
  4.     // IBAN paraît être valide
  5. } else {
  6.     // IBAN est invalide
  7. }

Mais ceci montre un gros problème : si vous ne devez accepter que les numéros IBAN que pour un pays en particulier, par exemple l'Allemagne, alors les numéros IBAN des autres pays seront aussi valides. Dans ce cas, souvenez vous d'une chose : quand vous devez valider un numéro IBAN pour un pays donné, vous avez juste à fournir la locale correspondante. Et quand vous acceptez tous les numéros IBAN sans restriction de pays, enlevez simplement cette locale.

Identical

Zend_Validate_Identical vous permet de valider si une valeur donnée est identique à une valeur préalablement fournie.

Utilisation de base

Pour valider si deux valeurs sont identiques, vous devez d'abord fournir la valeur d'origine. L'exemple montre la validation de deux chaînes :

  1. $valid = new Zend_Validate_Identical('origin');
  2. if ($valid->isValid($value) {
  3.     return true;
  4. }

La validation retournera TRUE seulement si les deux valeurs sont rigoureusement identiques. Dans notre exemple, quand $value vaudra "origin".

Vous pouvez aussi fournir la valeur souhaitée plus tard en utilisant la méthode setToken() et getToken() pour récupérer la valeur actuellement paramétrée.

Objets identiques

Bien sûr Zend_Validate_Identical ne se limite pas à la validation de chaînes, mais aussi tout type de variable comme un booléen, un entier, un flottant, un tableau et même les objets. Comme énoncé ci-dessus, les valeurs fournies et à valider doivent être identiques.

  1. $valid = new Zend_Validate_Identical(123);
  2. if ($valid->isValid($input)) {
  3.     // l'entrée est valide
  4. } else {
  5.     // l'entrée est incorrecte
  6. }

Note: Comparaison de type
 Il est important de noter que le type de la variable sert aussi lors de la validation. Ceci veut dire que la chaîne "3" n'est pas identique à l'entier 3.
Ceci est aussi valable pour les éléments de formulaires. Ce sont des objets ou des tableaux. Donc vous ne pouvez pas simplement comparer un champs texte qui contient un mot de passe avec une valeur textuelle provenant d'une autre source. L'élément de formualire lui-même est fourni en tant que tableau qui peut aussi contenir des informations additionnelles.

Configuration

omme tous les autres validateurs Zend_Validate_Identical supporte aussi des paramètres de configuration en tant que paramètre d'entrée. Ceci veut dire que vous pouvez configurer ce validateur avec une objet Zend_Config.

Mais ceci entraîne un changement dont vous devez tenir compte. Quand vous utilisez un tableau en tant qu'entrée du constructeur, vous devez envelopper la valeur d'origine avec la clé token, dans ce cas elle contiendra une valeur unique.

  1. $valid = new Zend_Validate_Identical(array('token' => 123));
  2. if ($valid->isValid($input)) {
  3.     // l'entrée est valide
  4. } else {
  5.     // l'entrée est incorrecte
  6. }

L'exemple ci-dessus valide l'entier 123 car vous avez fourni la valeur en l'associant à la clé token.

Mais, si vous devez valider un tableau qui contient un seul élément et que cet élément est nommé token alors vous devez l'envelopper comme dans l'example ci-dessous :

  1. $valid = new Zend_Validate_Identical(array('token' => array('token' => 123)));
  2. if ($valid->isValid($input)) {
  3.     // l'entrée est valide
  4. } else {
  5.     // l'entrée est incorrecte
  6. }

InArray

Zend_Validate_InArray vous permet de valider qu'une entrée est bien présente dans un tableau. Ceci fonctionne aussi avec des tableaux multidimensionnels.

Validation tableau simple

Passez simplement un tableau dans lequel rechercher une valeur:

  1. $validator = new Zend_Validate_InArray(array('key' => 'value',
  2.                                              'otherkey' => 'othervalue'));
  3. if ($validator->isValid('value')) {
  4.     // value trouvée
  5. } else {
  6.     // value non trouvée
  7. }

C'est le comportement exact de la fonction PHP in_array().

Note: Par défaut la validation est non stricte et ne valide pas les multiples dimensions.

Bien sûr vous pouvez fournir le tableau à valider plus tard en utilisant la méthode setHaystack(). La méthode getHaystack() retourne le tableau actuellement fourni.

  1. $validator = new Zend_Validate_InArray();
  2. $validator->setHaystack(array('key' => 'value', 'otherkey' => 'othervalue'));
  3.  
  4. if ($validator->isValid('value')) {
  5.     // valeur trouvée
  6. } else {
  7.     // valeur non trouvée
  8. }

Validation tableau stricte

Il est possible d'effectuer une validation stricte des données dans le tableau. Par défaut, il n'y aura aucune différence entre l'entier 0 et la chaine "0". La validation stricte fera cette différence.

Pour spécifier une validation stricte à l'instanciation de l'objet, agissez comme suit :

  1. $validator = new Zend_Validate_InArray(
  2.     array(
  3.         'haystack' => array('key' => 'value', 'otherkey' => 'othervalue'),
  4.         'strict'   => true
  5.     )
  6. );
  7.  
  8. if ($validator->isValid('value')) {
  9.     // valeur trouvée
  10. } else {
  11.     // valeur non trouvée
  12. }

La clé haystack contient le tableau dans lequel valider. En mettant la clé strict à TRUE, la validation sera stricte (valeur et type).

Bien sûr vous pouvez la méthode setStrict() pour changer ce réglage et la méthode getStrict() vous retournera le réglage en cours.

Note: Notez que par défaut, strict a la valeur FALSE.

Validation de tableaux récursifs

En plus de la validation type PHP in_array(), ce validateur peut aussi être utilisé pour valider des tableaux à plusieurs dimensions.

Pour cela, utilisez l'option recursive.

  1. $validator = new Zend_Validate_InArray(
  2.     array(
  3.         'haystack' => array(
  4.             'firstDimension' => array('key' => 'value',
  5.                                       'otherkey' => 'othervalue'),
  6.             'secondDimension' => array('some' => 'real',
  7.                                        'different' => 'key')),
  8.         'recursive' => true
  9.     )
  10. );
  11.  
  12. if ($validator->isValid('value')) {
  13.     // value trouvée
  14. } else {
  15.     // value non trouvée
  16. }

Votre tableau sera parcouru récursivement à la recherche de votre valeur. De plus vous pouvez utiliser la méthode setRecursive() pour paramétrer cette option plus tard et la méthode getRecursive() pour la retrouver.

  1. $validator = new Zend_Validate_InArray(
  2.     array(
  3.         'firstDimension' => array('key' => 'value',
  4.                                   'otherkey' => 'othervalue'),
  5.         'secondDimension' => array('some' => 'real',
  6.                                    'different' => 'key')
  7.     )
  8. );
  9. $validator->setRecursive(true);
  10.  
  11. if ($validator->isValid('value')) {
  12.     // valeur trouvée
  13. } else {
  14.     // valeur non trouvée
  15. }

Note: Réglage par défaut pour la récursivité
 Par défaut, la récursivité n'est pas activée.

Note: Options pour la "haystack"
 Lorsque vous utilisez les clés haystack, strict ou recursive à l'intérieur de votre pile, vous devez alors envelopper la clé haystack.

Int

Retourne TRUE si et seulement si $value est une valeur entière. A partir de Zend Framework 1.8 ce validateur prend en considération la locale courante issue du navigateur, de l'environnement ou de l'application. Vous pouvez bien sûr utiliser les accesseurs get/setLocale pour changer ou la fournir au moment de la création de l'instance de ce validateur.

Ip

Zend_Validate_Ip permet de déterminer si une adresse IP donnée est valide. Le composant supporte IPv4 et IPv6.

Utilisation classique

Voici un exemple banal:

  1. $validator = new Zend_Validate_Ip();
  2. if ($validator->isValid($ip)) {
  3.     // ip semble valide
  4. } else {
  5.     // ip n'est pas valide
  6. }

Note: adresses IP invalides
 Zend_Validate_Ip ne valide que des adresses IP. 'mydomain.com' ou '192.168.50.1/index.html' ne sont donc pas des adresses IP valides. Ce sont des noms de domaines ou des URLs mais pas des adresses IP.

Note: Validation IPv6
 Zend_Validate_Ip valides les adresses IPv6 au moyen d'expressions régulières. La raison est que les fonctions fournies par PHP ne suivent pas le RFC. Beaucoup d'autres classes disponibles font de même.

Valider IPv4 ou IPV6 seules

Il peut arriver de ne vouloir valider qu'un seul des deux formats. Par exemple si le réseau ne supporte pas IPv6, il serait idiot de demander une telle validation.

Pour limiter Zend_Validate_Ip sur un seul des deux protocoles, utilisez les options allowipv4 ou allowipv6 et mettez les à FALSE. Il est possible d'effectuer celà au moyen du constructeur ou avec la méthode setOptions().

  1. $validator = new Zend_Validate_Ip(array('allowipv6' => false);
  2. if ($validator->isValid($ip)) {
  3.     // ip semble être une IPv4 valide
  4. } else {
  5.     // ip n'est pas une adresse IPv4
  6. }

Note: Comportement par défaut
 Le comportement par défaut de Zend_Validate_Ip est de valider les deux standards.

Isbn

Zend_Validate_Isbn permet de valider des valeurs ISBN-10 ou ISBN-13.

Utilisation classique

Voici un exemple banal:

  1. $validator = new Zend_Validate_Isbn();
  2. if ($validator->isValid($isbn)) {
  3.     // isbn valide
  4. } else {
  5.     // isbn non valide
  6. }

Ceci valide tout ISBN-10 et ISBN-13 sans séparateur.

Configurer un type de validation ISBN explicite

Voici comment effectuer une restriction de type de l'ISBN :

  1. $validator = new Zend_Validate_Isbn();
  2. $validator->setType(Zend_Validate_Isbn::ISBN13);
  3. // OU
  4. $validator = new Zend_Validate_Isbn(array(
  5.     'type' => Zend_Validate_Isbn::ISBN13,
  6. ));
  7.  
  8. if ($validator->isValid($isbn)) {
  9.     // ISBN-13 valide
  10. } else {
  11.     // ISBN-13 invalide
  12. }

Seules les valeurs de ISBN-13 sont validée ci-dessus.

Les types valides sont:

  • Zend_Validate_Isbn::AUTO (défaut)

  • Zend_Validate_Isbn::ISBN10

  • Zend_Validate_Isbn::ISBN13

Spécifier une restriction de séparateur

Voici un exemple de restriction de séparateur:

  1. $validator = new Zend_Validate_Isbn();
  2. $validator->setSeparator('-');
  3. // OU
  4. $validator = new Zend_Validate_Isbn(array(
  5.     'separator' => '-',
  6. ));
  7.  
  8. if ($validator->isValid($isbn)) {
  9.     // ISBN valide avec séparateur
  10. } else {
  11.     // ISBN invalide avec séparateur
  12. }

Note: Valeurs sans séparateur
 La valeur FALSE est retournée si $isbn ne contient pas de séparateur ou si le séparateur n'est pas valide.

Séparateurs valides:

  • "" (vide) (défaut)

  • "-" (tiret)

  • " " (espace)

LessThan

Retourne TRUE si et seulement si $value est inférieure à une valeur maximum fournie.

NotEmpty

Ce validateur permet de déterminer si une valeur est non vide. C'est utile lorsque vous travaillez avec des formulaires ou des entrées utilisateur, là où vous pouvez l'utiliser pour savoir si des éléments requis ont été saisis.

Comportement par défaut de Zend_Validate_NotEmpty

Par défaut, ce validateur fonctionne différement de la fonction PHP empty(). En particulier, ce validateur va évaluer l'entier 0 et la chaine '0' comme vides.

  1. $valid = new Zend_Validate_NotEmpty();
  2. $value  = '';
  3. $result = $valid->isValid($value);
  4. // retourne false

Note: Le comportement par défaut diffère de PHP
 Sans configuration ajoutée, Zend_Validate_NotEmpty diffère de PHP.

Changer le comportement de Zend_Validate_NotEmpty

Certains projets ont des opinions différentes sur ce qui peut être considéré comme 'vide'. Une chaine seulement composée d'espaces blancs pourrait être considérée comme vide, ou 0 pourrait être considéré comme non-vide (surtout dans les séquences logiques booléennes). Pour correspondre aux différents besoins, Zend_Validate_NotEmpty vous permet de configurer les types que vous considérez comme vides.

Les types suivants sont gérés:

  • booléen: Retourne FALSE lorsque la valeur booléenne est FALSE.

  • entier: Retourne FALSE lorsque l'entier 0 est passé. Par défaut cette validation n'est pas activée et retourne TRUE pour toute valeur d'entier.

  • flottant: Retourne FALSE lorsque le flottant 0.0 est passé. Par défaut cette validation n'est pas activée et retourne TRUE pour toute valeur de flottant.

  • chaine: Retourne FALSE lorsque la chaine vide '' est passée.

  • zero: Retourne FALSE lorsque le seul caractère zéro ('0') est passé.

  • tableau_vide: Retourne FALSE lorsqu'un tableau vide array() est passé.

  • null: Retourne FALSE lorsqu'une valeur NULL est passée.

  • php: Retourne FALSE lorsque la fonction PHP empty() retournerait TRUE.

  • espace: Retourne FALSE lorsqu'une chaine ne contenant que des caractères espace est passée.

  • tout: Retourne FALSE pour tous les types gérés cités ci-dessus.

Toute autre valeur passée retourne TRUE par défaut.

Il existe différentes manières de selectionner les types ci-dessus. Vous pouvez en spécifier un ou plusieurs, sous forme de tableau ou de constantes ou encore de chaines. Voyez les exemples ci-après:

  1. // Retourne false pour 0
  2. $validator = new Zend_Validate_NotEmpty(Zend_Validate_NotEmpty::INTEGER);
  3.  
  4. // Retourne false pour 0 ou '0'
  5. $validator = new Zend_Validate_NotEmpty(
  6.     Zend_Validate_NotEmpty::INTEGER + Zend_NotEmpty::ZERO
  7. );
  8.  
  9. // Retourne false pour 0 ou '0'
  10. $validator = new Zend_Validate_NotEmpty(array(
  11.     Zend_Validate_NotEmpty::INTEGER,
  12.     Zend_Validate_NotEmpty::ZERO
  13. ));
  14.  
  15. // Retourne false pour 0 ou '0'
  16. $validator = new Zend_Validate_NotEmpty(array(
  17.     'integer',
  18.     'zero',
  19. ));

Il est aussi possible de passer un objet Zend_Config afin de préciser les types à utiliser. Après instantiation, setType() peut être utilisée.

PostCode

Zend_Validate_PostCode vous permet de déterminer si une valeur donnée est un code postal valide. Les codes postaux siont spécifiques aux villes et dans quelques cas spéciaux sont nommés des codes ZIP.

Zend_Validate_PostCode reconnait plus de 160 différents formats de codes postaux. Pour sélectionner le format correct, il existe deux manières. Vous pouvez soit utiliser une locale complète, soit paramétrer votre propre format manuellement.

Utiliser la locale est la méthode la plus commode puisque Zend Framework connait les formats des codes postaux assoicés à chaque locale  cependant, vous devez utiliser une locale complète (c'est-à-dire contenant aussi le spécificateur de région) dans ce cas. Par exemple, la locale "fr" est une bien une locale mais ne peut pas être utilisée avec Zend_Validate_PostCode puisqu'elle ne contient pas la région ; "fr_FR" sera, cependant, une locale valide puisqu'elle spécifie une région ("FR", pour France).

  1. $validator = new Zend_Validate_PostCode('fr_FR');

Quand vous ne paramétrez pas de locale vous-même, alors Zend_Validate_PostCode utilisera la locale de l'application, ou, s'il n'y en a pas, la locale retournée par Zend_Locale.

  1. // locale de l'application définie dans le bootstrap
  2. $locale = new Zend_Locale('fr_FR');
  3. Zend_Registry::set('Zend_Locale', $locale);
  4. $validator = new Zend_Validate_PostCode();

Vous pouvez changer la locale plus tard en appelant setLocale(). Et bien sûr vous pouvez récupérer la locale courante avec getLocale().

  1. $validator = new Zend_Validate_PostCode('fr_FR');
  2. $validator->setLocale('en_GB');

Les formats de codes postaux sont simplement des chaînes d'expressions régulières. Quand le format de code postal international, qui est utilisé en paramétrant la locale, ne correspond pas à vos besoins, alors vous pouvez alors paramétrer manuellement un format en appelant setFormat().

  1. $validator = new Zend_Validate_PostCode('fr_FR');
  2. $validator->setFormat('FR-\d{5}');

Note: Conventions pour les formats personnalisés
 Lors de l'utilisation de formats personnalisés, vous devez omettre les balises de début ('/^') et de fin ('$/'). Elles sont ajoutés automatiquement.
Vous devez faire attention au fait que les valeurs de code postal sont toujours validées de manière stricte. Ce qui veut dire qu'ils doivent être écrits seuls sans caractère additionnel qui ne serait pas couvert par le format.

Options du constructeur

Le plus basiquement possible, vous fournissez soit un objet Zend_Locale, soit une chaîne représentant une locale complète au constructeur de Zend_Validate_PostCode.

  1. $validator = new Zend_Validate_PostCode('fr_FR');
  2. $validator = new Zend_Validate_PostCode($locale);

De plus, vous pouve zfournir un tableau ou un objet Zend_Config au constructeur. Quand vous faîtes ceci, vous devez inclure soit la clé "locale" ou "format" ;celles-ci seront utilisées pour paramétrer les valeurs appropriées dans l'objet validateur.

  1. $validator = new Zend_Validate_PostCode(array(
  2.     'locale' => 'fr_FR',
  3.     'format' => 'FR-\d+'
  4. ));

Regex

Retourne TRUE si et seulement si $value respecte une expression régulière fournie.

Validateurs de Sitemap

Les validateurs suivant sont conformes au protocole » XML Sitemap.

Sitemap_Changefreq

Valide si oui ou non une chaîne utilisable en tant qu'élément "changefreq" dans un document XML Sitemap. Les valeurs valides sont : "always", "hourly", "daily", "weekly", "monthly", "yearly", or "never".

Retourne TRUE si et seulement si la valeur est une chaîne et qu'elle vaut une dès fréquences ci-dessus.

Sitemap_Lastmod

Valide si oui ou non une chaîne utilisable en tant qu'élément "lastmod" dans un document XML Sitemap. L'élément "lasmod" doit contenir une date sous la forme W3C, optionnellement en omettant les informations concernant l'heure.

Retourne TRUE si et seulement si la valeur est une chaîne et qu'elle est valide suivant le protocole.

Example #1 Validateur de "lastmod" Sitemap

  1. $validator = new Zend_Validate_Sitemap_Lastmod();
  2. $validator->isValid('1999-11-11T22:23:52-02:00'); // true
  3. $validator->isValid('2008-05-12T00:42:52+02:00'); // true
  4. $validator->isValid('1999-11-11'); // true
  5. $validator->isValid('2008-05-12'); // true
  6. $validator->isValid('1999-11-11t22:23:52-02:00'); // false
  7. $validator->isValid('2008-05-12T00:42:60+02:00'); // false
  8. $validator->isValid('1999-13-11'); // false
  9. $validator->isValid('2008-05-32'); // false
  10. $validator->isValid('yesterday'); // false

Sitemap_Loc

Valide si oui ou non une chaîne utilisable en tant qu'élément "loc" dans un document XML Sitemap. Ceci utilise en interne la méthode Zend_Form::check(). Vous pouvez en lire davantage avec la validation d'URI.

Sitemap_Priority

Valide si oui ou non une valeur est utilisable en tant qu'élément "priority" dans un document XML Sitemap. La valeur doit être un nombre compris entre 0.0 et 1.0. Ce validateur accepte à la fois des valeurs numériques ou textuelles.

Example #2 Validateur de "priority" Sitemap

  1. $validator = new Zend_Validate_Sitemap_Priority();
  2. $validator->isValid('0.1'); // true
  3. $validator->isValid('0.789'); // true
  4. $validator->isValid(0.8); // true
  5. $validator->isValid(1.0); // true
  6. $validator->isValid('1.1'); // false
  7. $validator->isValid('-0.4'); // false
  8. $validator->isValid(1.00001); // false
  9. $validator->isValid(0xFF); // false
  10. $validator->isValid('foo'); // false

StringLength

Retourne TRUE si et seulement si la longueur de la chaîne $value est supérieure à une valeur minimum et inférieure à une valeur maximum (quand l'option max n'est pas à NULL). La méthode setMin() lève une exception si la valeur fournie pour la longueur minimum est supérieure à celle fournie pour la longueur maximum, et la méthode setMax() lève une exception si la valeur fournie pour la longueur maximum est supérieure à celle fournie pour la longueur minimum. Cette classe supporte l'UTF-8 et les autres encodages, en se basant sur la valeur courante de » iconv.internal_encoding . Si vous avez besoin de régler un autre encodage, vous pouvez le faire avec les accesseurs getEncoding() et setEncoding().

Introduction
Zend_Validate
Programmer's Reference Guide