Introduction au Zend Framework

 Apprendre Zend Framework

appendix

 Guide de référence Zend Framework


  •  Zend_Gdata
  •  Zend_Http
  •  Zend_InfoCard
  •  Zend_Json
  •  Zend_Layout
  •  Zend_Ldap
  •  Zend_Loader
  •  Zend_Locale
  •  Zend_Log
  •  Zend_Mail
  •  Zend_Markup
  •  Zend_Measure
  •  Zend_Memory
  •  Zend_Mime
  •  Zend_Navigation
  •  Zend_Oauth
  •  Zend_OpenId
  •  Zend_Paginator
  •  Zend_Pdf
  •  Zend_ProgressBar
  •  Zend_Queue
  •  Zend_Reflection
  •  Zend_Registry
  •  Zend_Rest

  •  Zend_Search_Lucene
  •  Zend_Serializer
  •  Zend_Server
  •  Zend_Service
  •  Zend_Session
  •  Zend_Soap
  •  Zend_Tag
  •  Zend_Test
  •  Zend_Text
  •  Zend_TimeSync
  •  Zend_Tool
  •  Zend_Tool_Framework
  •  Zend_Tool_Project
  •  Zend_Translate
  •  Zend_Uri
  •  Zend_Validate
  •  Zend_Version
  •  Zend_View
  •  Zend_Wildfire
  •  Zend_XmlRpc
  • ZendX_Console_Process_Unix
  • ZendX_JQuery
  • Translation 61.2% Update 2010-11-28 - Revision 23149 - Version ZF 1.11.x

    75.2. Classes de validation standard

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

    75.2.1. Alnum

    Zend_Validate_Alnum permet de valider des données contenant des caractères alphabétiques et des chiffres. Il n'y a pas de limite de taille.

    75.2.1.1. Options supportées par Zend_Validate_Alnum

    Les options suivantes sont supportées par Zend_Validate_Alnum :

    • allowWhiteSpace : Si le caractère d'espace doit être accepté ou non. Par défaut FALSE.

    75.2.1.2. Utilisation de base

    Voici un exemple :

    $validator = new Zend_Validate_Alnum();
    if (
    $validator->isValid('Abcd12')) {
        
    // value ne contient que des caractères autorisés
    } else {
        
    // false
    }

    75.2.1.3. Utiliser les espaces

    Par défaut les caractères espaces ne sont pas acceptés car il ne font pas partie de l'alphabet. Cependant il existe un moyen de les accepter en entrée, ceci permet de valider des phrases complètes.

    Pour autoriser les espaces blancs vous devez passer l'option allowWhiteSpace. Ceci peut se faire à la création de l'objet ou ensuite au moyen des méthodes setAllowWhiteSpace() et getAllowWhiteSpace().

    $validator = new Zend_Validate_Alnum(array('allowWhiteSpace' => true));
    if (
    $validator->isValid('Abcd and 12')) {
        
    // value ne contient que des caractères autorisés
    } else {
        
    // false
    }

    75.2.1.4. Utiliser des langues différentes

    En utilisant Zend_Validate_Alnum, la langue que l'utilisateur précise dans son navigateur sera utilisée pour autoriser ou non certains caractères. Ainsi si l'utilisateur règle son navigateur sur de pour de l'allemand, alors les caractères comme ä, ö et ü seront eux aussi autorisés.

    Les caractères autorisés dépendent donc complètement de la langue utilisée.

    Il existe actuellement 3 langues qui ne sont pas supportées pour ce validateur. Il s'agit du coréen, du japonais et du chinois car ces langues utilisent un alphabet dans lequel un seul caractère est fabriqué à base de multiples caractères.

    Dans le cas où vous utilisez ces langues, seule l'alphabet anglais sera utilisé pour la validation.

    75.2.2. Alpha

    Zend_Validate_Alpha permet de valider qu'une donnée ne contient que des caractères alphabétiques. Il n'y a pas de limite de taille. Ce validateur fonctionne comme le validateur Zend_Validate_Alnum à l'exception qu'il n'accepte pas les chiffres.

    75.2.2.1. Options suportées par Zend_Validate_Alpha

    Les options suivantes sont supportées par Zend_Validate_Alpha:

    • allowWhiteSpace: Si les caractères d'espace sont autorisés ou pas. Par défaut FALSE

    75.2.2.2. Utilisation de base

    Voici un exemple de base:

    $validator = new Zend_Validate_Alpha();
    if (
    $validator->isValid('Abcd')) {
        
    // value ne contient que des caractères autorisés
    } else {
        
    // false
    }

    75.2.2.3. Utiliser les espaces

    Par défaut les caractères espaces ne sont pas acceptés car il ne font pas partie de l'alphabet. Cependant il existe un moyen de les accepter en entrée, ceci permet de valider des phrases complètes.

    Pour autoriser les espaces blancs vous devez passer l'option allowWhiteSpace. Ceci peut se faire à la création de l'objet ou après au moyen des méthodes setAllowWhiteSpace() et getAllowWhiteSpace().

    $validator = new Zend_Validate_Alpha(array('allowWhiteSpace' => true));
    if (
    $validator->isValid('Abcd and efg')) {
        
    // value ne contient que des caractères autorisés
    } else {
        
    // false
    }

    75.2.2.4. Utiliser des langues différentes

    En utilisant Zend_Validate_Alpha, la langue que l'utilisateur précise dans son navigateur sera utilisée pour autoriser ou non certains caractères. Ainsi si l'utilisateur règle son navigateur sur de pour de l'allemand, alors les caractères comme ä, ö et ü seront eux aussi autorisés.

    Les caractères autorisés dépendent donc complètement de la langue utilisée.

    Il existe actuellement 3 langues qui ne sont pas supportées pour ce validateur. Il s'agit de coréen, japonais et chinois car ces langues utilisent un alphabet dans lequel un seul caractère est fabriqué à base de multiples caractères.

    Dans le cas où vous utilisez ces langues, seule l'alphabet anglais sera utilisé pour la validation.

    75.2.3. Barcode

    Zend_Validate_Barcode permet de vérifier si une donnée représente un code barres.

    Zend_Validate_Barcode supporte de multiples standards de codes à barres et peut être étendu pour les codes barres propriétaires. Les formats suivants sont supportés:

    • CODE25: Aussi appelé "two of five" ou "Code25 Industrial".

      Ce code n'a pas de limite de taille. Il supporte les chiffres et le dernier chiffre peut être une somme de contrôle optionnelle calculée sur un modulo 10. Ce standard est très vieux et plus trop utilisé. Les cas d'utilisations classiques sont l'industrie

    • CODE25INTERLEAVED: Aussi appelé "Code 2 of 5 Interleaved".

      C'est une variante de CODE25. Il n'a pas de limite de taille mais il doit contenir un nombre de caractères pair. Il supporte uniquement les chiffres et le dernier chiffre peut être une somme de contrôle optionnelle calculée sur un modulo 10. Il est utilisé au travers le monde et typiquement dans l'industrie / la distribution.

    • CODE39: CODE39 est un des codes les plus vieux.

      Ce code a une taille variable. Il supporte les chiffres, les lettres majuscules, et 7 caractères spéciaux comme l'espace, le point ou le signe dollar. Il peut posséder optionnellement une somme de contrôle calculée sur un modulo 43. Il est utilisé dans le monde, dans l'industrie.

    • CODE39EXT: CODE39EXT est une extension de CODE39.

      Ce code à barres a les mêmes propriétés que CODE39. Aussi, il autorise l'utilisation de tous les caractères ASCII (128). Ce standard est très utilisé dans l'industrie, dans le monde.

    • CODE93: CODE93 est le successeur de CODE39.

      Ce code a une taille variable. Il supporte les chiffres, les lettres de l'alphabet et 7 caractères spéciaux. Il possède optionnellement une somme de contrôle à 2 caractères calculée sur un modulo 47. Ce standard produit un code plus dense que CODE39 et est plus sécurisé.

    • CODE93EXT: CODE93EXT est une extension de CODE93.

      Ce type de code à barres a les mêmes propriétés que CODE93. Aussi, il permet l'utilisation des 128 caractères du jeu ASCII. Ce standard est utilisé dans le monde et principalement dans l'industrie.

    • EAN2: EAN est un raccourci de "European Article Number".

      Ces codes ont deux caractères. Seuls les chiffres sont supportés et ils n'ont pas de somme de contrôle. Ce standard est utilisé principalement en plus de EAN13 (ISBN) sur les livres imprimés.

    • EAN5: EAN est un raccourci pour "European Article Number".

      Ce code barres doit comporter 5 caractères. Il ne supporte que les chiffres et ne possède pas de somme de contrôle. Ce standard est principalement utilisé en plus de EAN13 (ISBN) pour l'impression de livres.

    • EAN8: EAN est un raccourci pour "European Article Number".

      Ce code barres se compose de 7 ou 8 caractères. Il supporte les chiffres uniquement. Lorsqu'il est à 8 caractères, il inclut une somme de contrôle. Ce standard est utilisé dans le monde mais pour des besoins limités. On le trouve pour les petits articles où un code barres plus long n'aurait pas pu être imprimé.

    • EAN12: EAN est un raccourci pour "European Article Number".

      Ce code doit faire 12 caractères de long. Il ne supporte que les chiffres et le dernier chiffre est une somme de contrôle calculée sur un modulo 10. C'est un code utilisé aux Etats-Unis et courant sur le marché. Il a été dépassé par EAN13.

    • EAN13: EAN est un raccourci pour "European Article Number".

      Ce code doit faire 13 caractères de long, il ne supporte que les chiffres et le dernier chiffre est une somme de contrôle calculée sur un modulo 10. Ce standard est utilisé dans le monde et est très commun sur le marché.

    • EAN14: EAN est un raccourci pour "European Article Number".

      Ce code fait 14 caractères de longueur et ne supporte que les chiffres. Le dernier chiffre représente la somme de contrôle calculée sur un modulo 10. Ce code barres est utilisé dans le monde pour la distribution. C'est le successeur de EAN13.

    • EAN18: EAN est un raccourci pour "European Article Number".

      Ce code fait 18 caractères de longueur et ne supporte que les chiffres. Le dernier chiffre représente la somme de contrôle calculée sur un modulo 10. Ce code barres est utilisé pour identifier les conteneur d'envoi dans le transport.

    • GTIN12: GTIN est le raccourci de "Global Trade Item Number".

      Ce code utilise le même standard que EAN12 et est son successeur. Il est utilisé paticulièrement aux Etats-Unis.

    • GTIN13: GTIN est le raccourci de "Global Trade Item Number".

      Ce code utilise le même standard que EAN13 et est son successeur. Il est utilisé dans le monde entier par l'industrie.

    • GTIN14: GTIN est le raccourci de "Global Trade Item Number".

      Ce code utilise le même standard que EAN14 et est son successeur. Il est utilisé dans le monde entier par l'industrie.

    • IDENTCODE: Identcode est utilisé par Deutsche Post et DHL. C'est un cas particulier de Code25.

      Ce code fait 12 caractères de longueur et ne supporte que les chiffres. Le dernier chiffre représente la comme de contrôle calculée modulo 10. Ce code barres est utilisé principalement par les entreprises DP et DHL.

    • INTELLIGENTMAIL: Intelligent Mail est utilisé par les services postaux.

      Ce code fait 20, 25, 29 ou 31 caractères de longueur. Il ne support que les chiffres et ne contient pas de somme de contrôle. Il est le successeur de PLANET et POSTNET. Il est utilisé principalement dans les services postaux aux Etats-Unis.

    • ISSN: ISSN est l'abréviation de International Standard Serial Number.

      Ce code a une longueur de 8 ou 13 caractères. Il ne supporte que les chiffres et le dernier chiffre représente la somme de contrôle calculée sur un modulo 11. Il est utilisé dans le print à travers le monde.

    • ITF14: ITF14 est l'implémentation GS1 de Interleaved Two of Five bar code.

      Ce code est une implémentation particulière de Interleaved 2 of 5. Il doit mesurer 14 caractères de long et est basé sur GTIN14. Il ne contient que des chiffres et le dernier chiffre est une somme de contrôle calculée sur un modulo 10. Il est utilisé dans le monde dans la distribution.

    • LEITCODE: Leitcode est utilisé par Deutsche Post et DHL. C'est un cas particulier de Code25.

      Ce code mesure 14 caractères de longueur et ne supporte que les chiffres. Le dernier chiffre est une somme de contrôle calculée sur un modulo 10. Il est principalement utilisé par les entreprises DP et DHL.

    • PLANET: Planet est l'abréviation de Postal Alpha Numeric Encoding Technique.

      Ce code fait 12 ou 14 caractères de long. Il ne supporte que les chiffres et le dernier chiffre est une somme de contrôle. Ce code barres est utilisé principalement dans les services postaux des Etats-Unis.

    • POSTNET: Postnet est utilisé par le service des Postes des Etats-Unis.

      Ce code fait 6, 7, 10 ou 12 caractères. Il ne supporte que les chiffres et le dernier chiffre est une somme de contrôle. Ce code barres est utilisé dans les services postaux aux Etats-Unis principalement.

    • ROYALMAIL: Royalmail est utilisé par Royal Mail.

      Ce code n'a pas de taille précise. Il supporte les chiffres, les lettres majuscules et le dernier caractère est une somme de contrôle. Ce standard est utilisé par Royal Mail pour le service Cleanmail. Il est aussi appelé RM4SCC.

    • SSCC: SSCC est un raccourci pour "Serial Shipping Container Code".

      Ce code est une variante de EAN, il doit faire 18 caractères de long et ne supporte que les chiffres. Le dernier chiffre doit être la somme de contrôle qui est calculée sur un modulo 10. Ce code est utilisé principalement dans le transport.

    • UPCA: UPC est le raccourci de "Univeral Product Code".

      Ce code a précédé EAN13. Il doit faire 12 caractères et ne supporte que les chiffres. Le dernier chiffre est une somme de contrôle calculée sur un modulo 10. Ce code barres est utilisé aux Etats-Unis.

    • UPCE: UPCE est une variante simplifié et plus courte de UPCA.

      Il peut faire 6, 7 ou 8 caractères et ne supporte que les chiffres. Lorsqu'il fait 8 caractères, il inclut une somme de contrôle calculée sur un modulo 10. Ce code barres est utilisé sur de petits produits sur lesquels UPCA ne pourrait pas tenir.

    75.2.3.1. Options supportées par Zend_Validate_Barcode

    Les options suivantes sont supportées par Zend_Validate_Barcode:

    • adapter: Affecte l'adaptateur de code barres à utiliser. La liste des adaptateurs est donnée ci-dessus. Si vous voulez préciser un adaptateur personnalisé, le nom complet de la classe est requis.

    • checksum: TRUE si oui ou non utiliser une somme de contrôle. Notez que certains adaptateurs ne supportent pas un telle option.

    • options: Affecte des options personnalisées pour un adaptateur personnalisé.

    75.2.3.2. Utilisation classique

    Pour valider si une chaine est un code barres, vous devez juste connaitre son type. Voyez l'exemple suivant pour un EAN13:

    $valid = new Zend_Validate_Barcode('EAN13');
    if (
    $valid->isValid($input)) {
        
    // input semble être valide
    } else {
        
    // input est invalide
    }

    75.2.3.3. Somme de contrôle optionnelle

    Certains codes barres proposent une somme de contrôle. Ils peuvent être valides sans cette somme mais si vous préciser celle-la alors elle devra être validée. Par défaut la somme de contrôle n'est pas activée. En utilisant l'option checksum vous pouvez indiquer si oui ou non la somme de contrôle doit être vérifiée.

    $valid = new Zend_Validate_Barcode(array(
        
    'adapter'  => 'EAN13',
        
    'checksum' => false,
    ));
    if (
    $valid->isValid($input)) {
        
    // input semble être valide
    } else {
        
    // input est invalide
    }
    [Note] Sécurité moindre en désactivant la validation de la somme de contrôle

    En désactivant la validation de la somme de contrôle vous réduirez la sécurité du code à barres. Aussi veuillez noter que si vous désactiver ce contrôle pour des codes l'utilisant vous risqueriez de considérer comme valides des codes barres qui ne le sont pas en réalité.

    75.2.3.4. Ecrire des validateurs personnalisés

    Vous pouvez créer vos propres validateurs pour Zend_Validate_Barcode; ce qui est nécessaire si vous traitez des codes barres propriétaires. Vous aurez alors besoin des informations suivantes.

    • Length: La taille du code barres. Peut être une des valeur suivantes:

      • Integer: Une valeur plus grande que zéro qui définit exactement le nombre de caractères du code barres.

      • -1: Aucune limite de taille pour ce code barres.

      • "even": La taille du code barres doit être un nombre de caractères pair.

      • "odd": La taille du code barres doit être un nombre de caractères impair.

      • array: Un tableau de valeurs entières. La taille du code barres doit être exactement égale à une des valeurs dans le tableau.

    • Characters: Une chaine qui contient tous les caractères autorisés pour ce code barres. La valeur entière spéciale 128 est autorisée ici, elle signifie "les 128 premiers caractères du jeu ASCII".

    • Checksum: Une chaine utilisée comme callback pour valideer la somme de contrôle.

    Votre validateur de code à barres personnalisé doit étendre Zend_Validate_Barcode_AdapterAbstract ou implémenter Zend_Validate_Barcode_AdapterInterface.

    Comme exemple, créons un validateur qui utilise un nombre pair de caractères pouvant être des chiffres et les lettres 'ABCDE'. Une somme de contrôle sera aussi calculée.

    class My_Barcode_MyBar extends Zend_Validate_Barcode_AdapterAbstract
    {
        protected 
    $_length     'even';
        protected 
    $_characters '0123456789ABCDE';
        protected 
    $_checksum   '_mod66';

        protected function 
    _mod66($barcode)
        {
            
    // effectuer de la validation et retourner un booléen
        
    }
    }

    $valid = new Zend_Validate_Barcode('My_Barcode_MyBar');
    if (
    $valid->isValid($input)) {
        
    // input semble valide
    } else {
        
    // input est invalide
    }

    75.2.4. Between

    Zend_Validate_Between permet de valider qu'une valeur soit bien comprise entre deux bornes.

    [Note] Zend_Validate_Between ne supporte que les nombres

    Zend_Validate_Between ne supporte pas les chaines ou les dates.

    75.2.4.1. Options gérées par Zend_Validate_Between

    Les options suivantes sont reconnues par Zend_Validate_Between:

    • inclusive: Défini si les bornes sont inclusives dans la validation (min et max). Par défaut, TRUE.

    • min: Affecte la borne inférieure.

    • max: Affecte la borne supérieure.

    75.2.4.2. Comportement par défaut de Zend_Validate_Between

    Par défaut ce validateur vérifie sur la valeur est entre min et max inclusivement pour les deux bornes.

    $valid  = new Zend_Validate_Between(array('min' => 0'max' => 10));
    $value  10;
    $result $valid->isValid($value);
    // retourne true

    Dans l'exemple ci-dessus, TRUE est retourné car par défaut les bornes supérieures et inférieures sont inclusives. Toute valeur depuis '0' à '10' sont donc autorisées et reconnues. '-1' et '11' auraient retourné FALSE.

    75.2.4.3. Validation exclusive sur les bornes

    Il peut être nécessaire d'exclure les bornes dans la validation. Voyez l'exemple qui suit:

    $valid  = new Zend_Validate_Between(
        array(
            
    'min' => 0,
            
    'max' => 10,
            
    'inclusive' => false
        
    )
    );
    $value  10;
    $result $valid->isValid($value);
    // retourne false

    L'exemple ci-dessus fait en sorte que '0' et '10' retournent FALSE.

    75.2.5. Callback (fonction de rappel)

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

    75.2.5.1. Options supportées par Zend_Validate_Callback

    Les options suivantes sont supportées par Zend_Validate_Callback :

    • callback : spécifie la fonction de rappel qui sera utilisée pour la validation.

    • options : spécifie les options additionnelles qui seront fournies à la fonction de rappel.

    75.2.5.2. 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 :

    function myMethod($value)
    {
        
    // ici de la validation à effectuer
        
    return true;
    }

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

    $valid = new Zend_Validate_Callback('myMethod');
    if (
    $valid->isValid($input)) {
        
    // input semble valide
    } else {
        
    // input est invalide
    }

    75.2.5.3. 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:

    $valid = new Zend_Validate_Callback(function($value){
        
    // Validation ici
        
    return true;
    });

    if (
    $valid->isValid($input)) {
        
    // input semble valide
    } else {
        
    // input est invalide
    }

    75.2.5.4. Utilisation avec les méthodes de rappel

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

    class MyClass
    {
        public function 
    myMethod($value)
        {
            
    // Validation ici
            
    return true;
        }
    }

    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:

    $object = new MyClass;
    $valid = new Zend_Validate_Callback(array($object'myMethod'));
    if (
    $valid->isValid($input)) {
        
    // input semble valide
    } else {
        
    // input est invalide
    }

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

    class MyClass
    {
        public static function 
    test($value)
        {
            
    // Validation ici
            
    return true;
        }
    }

    $valid = new Zend_Validate_Callback(array('MyClass''test'));
    if (
    $valid->isValid($input)) {
        
    // input semble valide
    } else {
        
    // input est invalide
    }

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

    class MyClass
    {
        public function 
    __invoke($value)
        {
            
    // Validation ici
            
    return true;
        }
    }

    $object = new MyClass();
    $valid = new Zend_Validate_Callback($object);
    if (
    $valid->isValid($input)) {
        
    // input semble valide
    } else {
        
    // input est invalide
    }

    75.2.5.5. 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:

    class MyClass
    {
        function 
    myMethod($value$option)
        {
            
    // De la validation ici
            
    return true;
        }
    }

    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":

    $valid = new Zend_Validate_Callback(array(
        
    'callback' => array('MyClass''myMethod'),
        
    'options'  => $option,
    ));

    if (
    $valid->isValid($input)) {
        
    // input semble valide
    } else {
        
    // input est invalide
    }

    Sinon, vous pouvez passer les options après:

    $valid = new Zend_Validate_Callback(array('MyClass''myMethod'));
    $valid->setOptions($option);

    if (
    $valid->isValid($input)) {
        
    // input semble valide
    } else {
        
    // input est invalide
    }

    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.

    $valid = new Zend_Validate_Callback(array('MyClass''myMethod'));
    $valid->setOptions($option);

    if (
    $valid->isValid($input$additional)) {
        
    // input semble valide
    } else {
        
    // input est invalide
    }

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

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

    75.2.6.1. Options supportées par Zend_Validate_CreditCard

    Les options suivantes sont supportées par Zend_Validate_CreditCard :

    • service : une fonction de rappel vers un service en ligne qui sera utilisé en plus pour la validation.

    • type : le type de carte crédit qui sera validée. Voir ci-dessous la liste des institutions pour de plus amples détails.

    75.2.6.2. 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:

    $valid = new Zend_Validate_CreditCard();
    if (
    $valid->isValid($input)) {
        
    // input semble valide
    } else {
        
    // input est invalide
    }

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

    75.2.6.3. 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:

    $valid = new Zend_Validate_CreditCard(
        
    Zend_Validate_CreditCard::AMERICAN_EXPRESS
    );

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

    $valid = new Zend_Validate_CreditCard(array(
        
    Zend_Validate_CreditCard::AMERICAN_EXPRESS,
        
    Zend_Validate_CreditCard::VISA
    ));

    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:

    $valid = new Zend_Validate_CreditCard(array(
        
    'type' => array(Zend_Validate_CreditCard::AMERICAN_EXPRESS)
    ));

    Tableau 75.1. 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().

    $valid = new Zend_Validate_CreditCard();
    $valid->setType(array(
        
    Zend_Validate_CreditCard::AMERICAN_EXPRESS,
        
    Zend_Validate_CreditCard::VISA
    ));
    [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.

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

    // Votre classe de service
    class CcService
    {
        public function 
    checkOnline($cardnumber$types)
        {
            
    // Processus de validation ici
        
    }
    }

    // La validation
    $service = new CcService();
    $valid   = new Zend_Validate_CreditCard(Zend_Validate_CreditCard::VISA);
    $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.

    75.2.7. Ccnum

    [Note] 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.

    75.2.8. Date

    Zend_Validate_Date permet de valider qu'une donnée est bien une date. Le validateur gère la localisation.

    75.2.8.1. Options supportées par Zend_Validate_Date

    Les options suivantes sont supportées par Zend_Validate_Date:

    • format: affecte le format utilisé pour écrire la date.

    • locale: affecte la locale utilisée lors de la validation.

    75.2.8.2. Validation de dates par défaut

    La manière la plus simple de valider une date est d'utiliser le format par défaut du système. Ce format est utilisé lorsqu'aucune locale et aucun format particulier n'est précisé. Voyez l'exemple ci-après:

    $validator = new Zend_Validate_Date();

    $validator->isValid('2000-10-10');   // retourne true
    $validator->isValid('10.10.2000'); // retourne false

    Le format par défaut de Zend_Validate_Date est 'yyyy-MM-dd'.

    75.2.8.3. Validation de dates localisées

    Zend_Validate_Date peut aussi valider les dates dans un format localisé donné. En utilisant l'option locale vous pouvez définir la locale utilisée pour valider le format de la date.

    $validator = new Zend_Validate_Date(array('locale' => 'de'));

    $validator->isValid('10.Feb.2010'); // retourne true
    $validator->isValid('10.May.2010'); // retourne false

    L'option locale affecte le format par défaut de la date. Dans l'exemple ci-dessus il s'agit de 'dd.MM.yyyy' qui est le format pour une locale 'de'.

    75.2.8.4. Formats de dates personnalisés

    Zend_Validate_Date supporte des formats de date personnalisés. Utilisez l'option format pour cela.

    $validator = new Zend_Validate_Date(array('format' => 'yyyy'));

    $validator->isValid('2010'); // retourne true
    $validator->isValid('May');  // retourne false

    Vous pouvez combiner format et locale. Dans ce cas vous pouvez utiliser des noms de mois ou de jours localisés.

    $validator = new Zend_Validate_Date(array('format' => 'yyyy MMMM''locale' => 'de));

    $validator->isValid('
    2010 Dezember'); // retourne true
    $validator->isValid('
    2010 June');     // retourne false

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

    75.2.9.1. Options supportées par Zend_Validate_Db_*

    Les options suivantes sont supportées par Zend_Validate_Db_NoRecordExists et Zend_Validate_Db_RecordExists :

    • adapter : l'adaptateur de base de données qui sera utilisé pour la recherche.

    • exclude : jeu d'enregistrements qui seront exclus de la recherche.

    • field : le champs dans la table de la base de données dans lequel sera effectué la recherche.

    • schema : le schéma utilisé pour la recherche.

    • table : la table qui sera utilisée pour la recherche.

    75.2.9.2. Utilisation de base

    Voici un exemple basique:

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

    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.

    //Vérifie que le nom d'utilisateur n'est pas présent dans la table
    $validator = new Zend_Validate_Db_NoRecordExists('users''username');
    if (
    $validator->isValid($username)) {
        
    // Le nom d'utilisateur semble absent de la table
    } else {
        
    // invalide : l'utilisateur est probablement présent dans la table
        
    $messages $validator->getMessages();
        foreach (
    $messages as $message) {
            echo 
    "$message\n";
        }
    }

    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.

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

    //Vérifie qu'aucun autre utilisateur que celui dont l'id est spécifié, ne possède ce nom
    $user_id   $user->getId();
    $validator = new Zend_Validate_Db_NoRecordExists(
        
    'users',
        
    'username',
        array(
            
    'field' => 'id',
            
    'value' => $user_id
        
    )
    );

    if (
    $validator->isValid($username)) {
        
    // OK
    } else {
        
    // KO
        
    $messages $validator->getMessages();
        foreach (
    $messages as $message) {
            echo 
    "$message\n";
        }
    }

    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 !=.

    $post_id   $post->getId();
    $clause    $db->quoteInto('post_id = ?'$category_id);
    $validator = new Zend_Validate_Db_RecordExists(
        
    'posts_categories',
        
    'post_id',
        
    $clause
    );

    if (
    $validator->isValid($username)) {
        
    // OK
    } else {
        
    // KO
        
    $messages $validator->getMessages();
        foreach (
    $messages as $message) {
            echo 
    "$message\n";
        }
    }

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

    75.2.9.4. 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:

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

    75.2.9.5. 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:

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

    75.2.10. Digits

    Zend_Validate_Digit valide si une donnée contient des chiffres.

    75.2.10.1. Options supportées par Zend_Validate_Digits

    Aucun option n'est gérée par Zend_Validate_Digits

    75.2.10.2. Valider des chiffres

    Pour valider si une donnée ne contient que des chiffres et pas d'autre caractère, appelez simplement le validateur comme montré dans l'exemple suivant:

    $validator = new Zend_Validate_Digits();

    $validator->isValid("1234567890"); // retourne true
    $validator->isValid(1234);         // retourne true
    $validator->isValid('1a234');      // retourne false
    [Note] Valider des nombres

    Si vous voulez valider des nombres ou des valeurs numériques, faites attention car ce validateur ne valide que les chiffres. Ceci signifie que les signes comme les séparateurs des milliers ou les virgules ne seront pas pris en compte et le validateur échouera. Voyez pour ces cas Zend_Validate_Int ou Zend_Validate_Float.

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

    75.2.11.1. Utilisation de base

    Vous trouverez ci-dessous un exemple d'utilisation basique 

    $validateur = new Zend_Validate_EmailAddress();
    if (
    $validateur->isValid($email)) {
        
    // l'email est valide
    } else {
        
    // l'email est invalide ; afficher pourquoi
        
    foreach ($validateur->getMessages() as $message) {
            echo 
    "$message\n";
        }
    }

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

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

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

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

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

    75.2.11.3. 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 de mail obsolètes ne seront pas validés (comme toute adresse mail contenant un retour chariot ou un caractère "\").

    75.2.11.4. Validation uniquement de la partie locale

    Si vous avez besoin de Zend_Validate_EmailAddress uniquement pour vérifier la partie locale d'une adresse mail, et que vous souhaitez désactiver la validation du nom d'hôte, vous pouvez spécifier le paramètre domain à la valeur false. Cela force Zend_Validate_EmailAddress à ne pas valider le nom d'hôte de l'adresse mail.

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

    75.2.11.5. 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 :

    $validator = new Zend_Validate_EmailAddress(
                        
    Zend_Validate_Hostname::ALLOW_DNS |
                        
    Zend_Validate_Hostname::ALLOW_LOCAL);
    if (
    $validator->isValid($email)) {
        
    // l'email est valide
    } else {
        
    // l'email est invalide ; afficher pourquoi
        
    foreach ($validateur->getMessages() as $message) {
            echo 
    "$message\n";
        }
    }

    75.2.11.6. Vérification que le nom de domaine accepte réellement le courriel

    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 (le courriel) existe dans le l'enregistrement du DNS pour le nom de domaine du courriel. Cela vous dit que le nom de domaine accepte le courriel, 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.

    $validator = new Zend_Validate_EmailAddress(
        array(
            
    'allow' => Zend_Validate_Hostname::ALLOW_DNS,
            
    'mx'    => true
        
    )
    );
    [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().

    $validator = new Zend_Validate_EmailAddress(
        array(
            
    'allow' => Zend_Validate_Hostname::ALLOW_DNS,
            
    'mx'    => true,
            
    'deep'  => true
        
    )
    );
    [Avertissement] 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.

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

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

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

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

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

    $validator = new Zend_Validate_EmailAddress();
    $validator->setMessages(
        array(
            
    Zend_Validate_Hostname::UNKNOWN_TLD => 'I don't know the TLD you gave'
        )
    );

    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.

    75.2.12. Float

    Zend_Validate_Float permet de valider si une donnée contient une valeur flottante. Les entrées localisées sont supportées.

    75.2.12.1. Options supportées par Zend_Validate_Float

    Les options suivantes sont supportées par Zend_Validate_Float:

    • locale: Affecte la locale utilisée lors de la validation.

    75.2.12.2. Validation float simple

    Au plus simple, vous utiliserez les paramètres systèmes, c'est à dire la locale correspondant à l'environnement:

    $validator = new Zend_Validate_Float();

    $validator->isValid(1234.5);   // retourne true
    $validator->isValid('10a01'); // retourne false
    $validator->isValid('1,234.5'); // retourne true

    Dans l'exemple ci-dessus, nous supposons un environnement à locale "en".

    75.2.12.3. Validation float localisée

    Il peut être parfois nécessire de prendre en compte la locale pour valider une valeur flottante. Les flottants sont souvent écrits de manière différente en fonction de la locale/région. Par exemple en anglais on écrirait "1.5", mais en allemand "1,5" et dans d'autres langues le regroupement de chiffres pourrait être utilisé.

    Zend_Validate_Float peut valider de telles notations. Il est alors limité à la locale utilisée. Voyez les exemples ci-après:

    $validator = new Zend_Validate_Float(array('locale' => 'de'));

    $validator->isValid(1234.5); // retourne true
    $validator->isValid("1 234,5"); // retourne false
    $validator->isValid("1.234"); // retourne true

    Comme vous le voyez, en utilisant une locale, l'entrée est validée en fonction de celle-ci. Avec une locale différente vous auriez obtenu des résultats éventuellement différents.

    La locale peut être affectée/récupérée après la création de l'objet de validation au moyen des méthodes setLocale() et getLocale().

    75.2.13. GreaterThan

    Zend_Validate_GreaterThan permet de valider qu'une valeur est plus grande qu'une autre (la borne).

    [Note] Zend_Validate_GreaterThan ne supporte que les nombres

    Zend_Validate_GreaterThan ne fonctionnera pas avec les chaines ou les dates.

    75.2.13.1. Options supportées par Zend_Validate_GreaterThan

    Les options suivantes sont supportées par Zend_Validate_GreaterThan:

    • min: Affecte la borne inférieure.

    75.2.13.2. Utilisation de base

    Voyez l'exemple ci-après.

    $valid  = new Zend_Validate_GreaterThan(array('min' => 10));
    $value  10;
    $return $valid->isValid($value);
    // retourne true

    L'exemple ci-dessus retourne TRUE pour toutes les valeurs égales ou supérieures à 10.

    75.2.14. Hex

    Zend_Validate_Hex permet de valider qu'un nombre ne contienne bien que des caractères hexadécimaux. Ce sont les caractères de 0 à 9 et de A à F insensibles à la casse. Il n'existe pas de limite de longueur de la chaine à valider.

    $validator = new Zend_Validate_Hex();
    if (
    $validator->isValid('123ABC')) {
        
    // value ne contient que des caractères hex
    } else {
        
    // false
    }
    [Note] Caractères invalides

    Tous les autres caractères retourneront false, même l'espace et le point. Les zéros unicode ou les chiffres d'autres encodages que latin seront considérés comme invalides.

    75.2.14.1. Options supportées par Zend_Validate_Hex

    Il n'y a pas d'options additionnelles supportées par Zend_Validate_Hex:

    75.2.15. 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 :

    $validateur = new Zend_Validate_Hostname();
    if (
    $validateur->isValid($domaine)) {
        
    // le nom de domaine est valide
    } else {
        
    // le nom de domaine est invalide ; afficher pourquoi
        
    foreach ($validateur->getMessages() as $message) {
            echo 
    "$message\n";
        }
    }

    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 :

    $validateur = new Zend_Validate_Hostname(Zend_Validate_Hostname::ALLOW_IP);
    if (
    $validateur->isValid($hostname)) {
        
    // le nom de domaine est valide
    } else {
        
    // le nom de domaine est invalide ; afficher pourquoi
        
    foreach ($validateur->getMessages() as $message) {
            echo 
    "$message\n";
        }
    }

    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.

    $validator =
        new 
    Zend_Validate_Hostname(
            array(
                
    'allow' => Zend_Validate_Hostname::ALLOW_DNS,
                
    'idn'   => true,
                
    'tld'   => false
            
    )
        );

    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.

    75.2.16. Iban

    Zend_Validate_Iban valide si un nombre donnée est un numéro IBAN number. IBAN est l'abréviation de "International Bank Account Number".

    75.2.16.1. Options supportées par Zend_Validate_Iban

    Les options suivantes sont supportées par Zend_Validate_Iban:

    • locale: Affecte la locale à utiliser pour la validation du format du numéro IBAN.

    75.2.16.2. Validation IBAN

    Les numéros IBAN sont toujours relatifs à un pays. Ceci signifie que différents pays utilisent des formats différents de numéros IBAN. C'est la raison pour laquelle les numéros IBAN ont toujours besoin d'une locale. Sachant cela, nous savons déja utiliser Zend_Validate_Iban.

    75.2.16.2.1. Locale globale à l'application

    Nous pourrions utiliser la locale globale à l'application. Ainsi si on ne passe aucune option à l'initialisation de Zend_Validate_Iban, celui-ci va chercher la locale globale. Voyez le code qui suit:

    // dans le bootstrap
    Zend_Registry::set('Zend_Locale', new Zend_Locale('de_AT'));

    // dans le module
    $validator = new Zend_Validate_Iban();

    if (
    $validator->isValid('AT611904300234573201')) {
        
    // IBAN est valide
    } else {
        
    // IBAN n'est pas valide
    }
    [Note] Locale globale à l'application

    Bien sûr cela ne fonctionne que lorsqu'une locale globale a été spécifiée et enregistrée dans le registre. Sinon, Zend_Locale va essayer d'utiliser la locale que le client envoie, si aucune n'a été envoyée, la locale de l'environnement sera utilisée. Méfiez-vous cela peut mener à des comportements non voulus lors de la validation.

    75.2.16.2.2. Validation IBAN simplifiée

    Il peut arriver parfois que vous ayiez juste besoin de vérifier le format du numéro et s'il est un numéro IBAN. Vous ne voudriez pas utiliser un pays particulier pour valider. Ceci peut être réalisé en passant FALSE en tant que locale.

    $validator = new Zend_Validate_Iban(array('locale' => false));
    // Note: Vous pouvez aussi passer FALSE comme paramètre unique (sans tableau)

    if ($validator->isValid('AT611904300234573201')) {
        
    // IBAN est valide
    } else {
        
    // IBAN n'est pas valide
    }

    Ainsi tout numéro IBAN sera valide. Notez que ceci ne devrait pas être utilisé si vous ne supportez qu'un seul pays.

    75.2.16.2.3. Validation IBAN en fonction d'un pays

    Pour valider par rapport à un pays/région, passez simplement la locale désirée. L'option locale peut alors être utilisée ou la méthode setLocale().

    $validator = new Zend_Validate_Iban(array('locale' => 'de_AT'));

    if (
    $validator->isValid('AT611904300234573201')) {
        
    // IBAN est valide
    } else {
        
    // IBAN n'est pas valide
    }
    [Note] Utilisez des locales pleinement qualifiées

    Vous devez passer une locale pleinement qualifiée sinon le nom de la région ne pourra être trouvé et utilisé.

    75.2.17. Identical

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

    75.2.17.1. Options supportées par Zend_Validate_Identical

    Les options suivantes sont supportées par Zend_Validate_Identical :

    • token : spécifie la valeur qui servira à la validation de l'entrée.

    75.2.17.2. 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 :

    $valid = new Zend_Validate_Identical('origin');
    if (
    $valid->isValid($value) {
        return 
    true;
    }

    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.

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

    $valid = new Zend_Validate_Identical(123);
    if (
    $valid->isValid($input)) {
        
    // l'entrée est valide
    } else {
        
    // l'entrée est incorrecte
    }
    [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.

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

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

    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 :

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

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

    75.2.18.1. Options supportées par Zend_Validate_InArray

    Les options suivantes sont supportées par Zend_Validate_InArray :

    • haystack : spécifie le tableau pour la validation.

    • recursive : définit si la validation doit être recursive. Cette option vaut FALSE par défaut.

    • strict : définit si la validation doit être strict (même type). Cette option vaut FALSE par défaut.

    75.2.18.2. Validation tableau simple

    Passez simplement un tableau dans lequel rechercher une valeur:

    $validator = new Zend_Validate_InArray(array('key' => 'value',
                                                 
    'otherkey' => 'othervalue'));
    if (
    $validator->isValid('value')) {
        
    // value trouvée
    } else {
        
    // value non trouvée
    }

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

    [Note] 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.

    $validator = new Zend_Validate_InArray();
    $validator->setHaystack(array('key' => 'value''otherkey' => 'othervalue'));

    if (
    $validator->isValid('value')) {
        
    // valeur trouvée
    } else {
        
    // valeur non trouvée
    }

    75.2.18.3. 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 :

    $validator = new Zend_Validate_InArray(
        array(
            
    'haystack' => array('key' => 'value''otherkey' => 'othervalue'),
            
    'strict'   => true
        
    )
    );

    if (
    $validator->isValid('value')) {
        
    // valeur trouvée
    } else {
        
    // valeur non trouvée
    }

    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] Note

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

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

    $validator = new Zend_Validate_InArray(
        array(
            
    'haystack' => array(
                
    'firstDimension' => array('key' => 'value',
                                          
    'otherkey' => 'othervalue'),
                
    'secondDimension' => array('some' => 'real',
                                           
    'different' => 'key')),
            
    'recursive' => true
        
    )
    );

    if (
    $validator->isValid('value')) {
        
    // value trouvée
    } else {
        
    // value non trouvée
    }

    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.

    $validator = new Zend_Validate_InArray(
        array(
            
    'firstDimension' => array('key' => 'value',
                                      
    'otherkey' => 'othervalue'),
            
    'secondDimension' => array('some' => 'real',
                                       
    'different' => 'key')
        )
    );
    $validator->setRecursive(true);

    if (
    $validator->isValid('value')) {
        
    // valeur trouvée
    } else {
        
    // valeur non trouvée
    }
    [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.

    75.2.19. Int

    Zend_Validate_Int valide une valeur envers un entier. Les entiers localisés sont aussi gérés.

    75.2.19.1. Options supportées par Zend_Validate_Int

    Les options suivantes sont supportées par Zend_Validate_Int:

    • locale: Affecte la locale à utiliser lors de la validation.

    75.2.19.2. Validation simple d'entiers

    La manière la plus simple de valider un entier est d'utiliser les paramètres systèmes. Lorsqu'aucune option n'est passée, la locale de l'environnement sera utilisée:

    $validator = new Zend_Validate_Int();

    $validator->isValid(1234);   // retourne true
    $validator->isValid(1234.5); // retourne false
    $validator->isValid('1,234'); // retourne true

    Dans l'exemple ci-dessus l'environnement est supposé réglé sur la locale "en". Comme vous le voyez, le regroupement de chiffres est supporté (troisième exemple).

    75.2.19.3. Validation d'entiers localisés

    Il est parfois nécessaire de valider des entiers localisés. Les entiers sont souvent écrits de manière différente en fonction des pays/régions. Par exemple en anglais vous pouvez écrire "1234" ou "1,234", ce sont tous les deux des entiers mais le regroupement des chiffres est optionnel. En allemand, vous écririez "1.234" et en français "1 234".

    Zend_Validate_Int peut valider de telles notations. Il est limité à la locale utilisée et valide le séparateur utilisé en fonction de la locale. Voyez le code ci-après:

    $validator = new Zend_Validate_Int(array('locale' => 'de'));

    $validator->isValid(1234); // retourne true
    $validator->isValid("1,234"); // retourne false
    $validator->isValid("1.234"); // retourne true

    Comme vous le voyez, avec une locale, l'entrée est validée en fonction de la locale. En utilisant l'anglais, vous récupérez FALSE lorsque la locale force une notation différente.

    La locale peut être affectée/récupérée après la création du validateur au moyen des méthodes setLocale() et getLocale().

    75.2.20. Ip

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

    75.2.20.1. Options supportées par Zend_Validate_Ip

    Les options suivantes sont supportées par Zend_Validate_Ip :

    • allowipv4 : définit si la validation autorise les adresses IPv4. Cette option vaut TRUE par défaut.

    • allowipv6 : définit si la validation autorise les adresses IPv6. Cette option vaut TRUE par défaut.

    75.2.20.2. Utilisation classique

    Voici un exemple banal:

    $validator = new Zend_Validate_Ip();
    if (
    $validator->isValid($ip)) {
        
    // ip semble valide
    } else {
        
    // ip n'est pas valide
    }
    [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 la RFC. Beaucoup d'autres classes disponibles font de même.

    75.2.20.3. 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().

    $validator = new Zend_Validate_Ip(array('allowipv6' => false);
    if (
    $validator->isValid($ip)) {
        
    // ip semble être une IPv4 valide
    } else {
        
    // ip n'est pas une adresse IPv4
    }
    [Note] Comportement par défaut

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

    75.2.21. Isbn

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

    75.2.21.1. Options supportées par Zend_Validate_Isbn

    Les options suivantes sont supportées par Zend_Validate_Isbn :

    • separator : définit le séparateur autorisé pour la valeur ISBN. Par défaut, il s'agit d'une chaîne vide.

    • type : définit le type des valeurs ISBN autorisées. Par défaut, il s'agit de Zend_Validate_Isbn::AUTO. Pour plus de détails reportez vous à cette section.

    75.2.21.2. Utilisation classique

    Voici un exemple banal :

    $validator = new Zend_Validate_Isbn();
    if (
    $validator->isValid($isbn)) {
        
    // isbn valide
    } else {
        
    // isbn non valide
    }

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

    75.2.21.3. Configurer un type de validation ISBN explicite

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

    $validator = new Zend_Validate_Isbn();
    $validator->setType(Zend_Validate_Isbn::ISBN13);
    // OU
    $validator = new Zend_Validate_Isbn(array(
        
    'type' => Zend_Validate_Isbn::ISBN13,
    ));

    if (
    $validator->isValid($isbn)) {
        
    // ISBN-13 valide
    } else {
        
    // ISBN-13 invalide
    }

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

    Les types valides sont :

    • Zend_Validate_Isbn::AUTO (défaut)

    • Zend_Validate_Isbn::ISBN10

    • Zend_Validate_Isbn::ISBN13

    75.2.21.4. Spécifier une restriction de séparateur

    Voici un exemple de restriction de séparateur :

    $validator = new Zend_Validate_Isbn();
    $validator->setSeparator('-');
    // OU
    $validator = new Zend_Validate_Isbn(array(
        
    'separator' => '-',
    ));

    if (
    $validator->isValid($isbn)) {
        
    // ISBN valide avec séparateur
    } else {
        
    // ISBN invalide avec séparateur
    }
    [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)

    75.2.22. LessThan

    Zend_Validate_LessThan permet de valider qu'une donnée est bien inférieure à une borne. C'est l'opposé de Zend_Validate_GreaterThan.

    [Note] Zend_Validate_LessThan ne supporte que les chiffres

    Zend_Validate_LessThan ne fonctionnera pas avec les chaines et les dates.

    75.2.22.1. Options gérées par Zend_Validate_LessThan

    Les options suivantes sont supportées par Zend_Validate_LessThan:

    • max: Affecte la borne supérieure.

    75.2.22.2. Utilisation de base

    Voyez l'exemple ci-après.

    $valid  = new Zend_Validate_LessThan(array('max' => 10));
    $value  10;
    $return $valid->isValid($value);
    // retourne true

    L'exemple ci-dessus retourne TRUE pour toutes les valeurs égales ou inférieures à 10.

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

    75.2.23.1. Options supportées par Zend_Validate_NotEmpty

    Les options suivantes sont supportées par Zend_Validate_NotEmpty :

    • type : paramètre le type de validation qui sera réalisée. Pour plus de détails, reportez vous à cette section.

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

    $valid = new Zend_Validate_NotEmpty();
    $value  '';
    $result $valid->isValid($value);
    // retourne false
    [Note] Le comportement par défaut diffère de PHP

    Sans configuration ajoutée, Zend_Validate_NotEmpty diffère de PHP.

    75.2.23.3. 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 :

    // Retourne false pour 0
    $validator = new Zend_Validate_NotEmpty(Zend_Validate_NotEmpty::INTEGER);

    // Retourne false pour 0 ou '0'
    $validator = new Zend_Validate_NotEmpty(
        
    Zend_Validate_NotEmpty::INTEGER Zend_NotEmpty::ZERO
    );

    // Retourne false pour 0 ou '0'
    $validator = new Zend_Validate_NotEmpty(array(
        
    Zend_Validate_NotEmpty::INTEGER,
        
    Zend_Validate_NotEmpty::ZERO
    ));

    // Retourne false pour 0 ou '0'
    $validator = new Zend_Validate_NotEmpty(array(
        
    'integer',
        
    'zero',
    ));

    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.

    75.2.24. 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).

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

    // locale de l'application définie dans le bootstrap
    $locale = new Zend_Locale('fr_FR');
    Zend_Registry::set('Zend_Locale'$locale);
    $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().

    $validator = new Zend_Validate_PostCode('fr_FR');
    $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().

    $validator = new Zend_Validate_PostCode('fr_FR');
    $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.

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

    $validator = new Zend_Validate_PostCode('fr_FR');
    $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.

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

    75.2.24.2. Options supportées par Zend_Validate_PostCode

    Les options suivantes sont supportées par Zend_Validate_PostCode :

    • format : spécifie le format de code postal qui sera utilisé pour la validation.

    • locale : spécifie la locale à partir de laquelle le code postal sera récupéré.

    75.2.25. Regex

    Ce validateur valide si une chaine correspond à un motif d'expression régulière.

    75.2.25.1. Options supportées par Zend_Validate_Regex

    Les options suivantes sont supportées par Zend_Validate_Regex :

    • pattern : le motif d'expression régulière.

    75.2.25.2. Validation avec Zend_Validate_Regex

    La validation au travers d'expressions régulières est pratique, très utilisée et simple dans la mesure où elle vous évite la plupart du temps d'écrire votre propre validateur. Voyons quelques exemples :

    $validator = new Zend_Validate_Regex(array('pattern' => '/^Test/');

    $validator->isValid("Test"); // retourne true
    $validator->isValid("Testing"); // retourne true
    $validator->isValid("Pest"); // retourne false

    Comme vous le voyez, le motif doit être passé avec la même forme que pour preg_match(). Pour plus de détails sur les expressions régulières, voyez le manuel de PHP sur la syntaxe des motifs d'expressions PCRE.

    75.2.25.3. Gestion des motifs

    Vous pouvez affecter / récupérer le motif après avoir crée le validateur en utilisant les méthodes setPattern() et getPattern().

    $validator = new Zend_Validate_Regex(array('pattern' => '/^Test/');
    $validator->setPattern('ing$/');

    $validator->isValid("Test"); // retourne false
    $validator->isValid("Testing"); // retourne true
    $validator->isValid("Pest"); // retourne false

    75.2.26. Validateurs de Sitemap

    Les validateurs suivant sont conformes au protocole XML Sitemap.

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

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

    Exemple 75.1. Validateur de "lastmod" Sitemap

    $validator = new Zend_Validate_Sitemap_Lastmod();
    $validator->isValid('1999-11-11T22:23:52-02:00'); // true
    $validator->isValid('2008-05-12T00:42:52+02:00'); // true
    $validator->isValid('1999-11-11'); // true
    $validator->isValid('2008-05-12'); // true
    $validator->isValid('1999-11-11t22:23:52-02:00'); // false
    $validator->isValid('2008-05-12T00:42:60+02:00'); // false
    $validator->isValid('1999-13-11'); // false
    $validator->isValid('2008-05-32'); // false
    $validator->isValid('yesterday'); // false

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

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

    Exemple 75.2. Validateur de "priority" Sitemap

    $validator = new Zend_Validate_Sitemap_Priority();
    $validator->isValid('0.1'); // true
    $validator->isValid('0.789'); // true
    $validator->isValid(0.8); // true
    $validator->isValid(1.0); // true
    $validator->isValid('1.1'); // false
    $validator->isValid('-0.4'); // false
    $validator->isValid(1.00001); // false
    $validator->isValid(0xFF); // false
    $validator->isValid('foo'); // false

    75.2.26.5. Options supportées par Zend_Validate_Sitemap_*

    Il n'y a pas d'options supportées par ce validateur.

    75.2.27. StringLength

    Ce validateur vérifie la longueur d'une chaine de caractères.

    [Note] Zend_Validate_StringLength ne supporte que les chaines

    Zend_Validate_StringLength ne fonctionnera pas avec les entiers, flottants, les dates ou encore les objets.

    75.2.27.1. Options gérées par Zend_Validate_StringLength

    Les options suivantes sont reconnues par Zend_Validate_StringLength:

    • encoding: Définit l'encodage ICONV à utiliser avec la chaine.

    • min: Définit le nombre de caractères minimum requis.

    • max: Définit le nombre de caractères maximum requis.

    75.2.27.2. Comportement par défaut de Zend_Validate_StringLength

    Par défaut, ce validateur vérifie qu'une valeur de chaine est bien entre min et max caractères. Pour min, la valeur par défaut est 0 et pour max c'est NULL ce qui signifie illimité.

    Ainsi par défaut, sans aucune option, ce validateur vérifie que la donnée traitée est bien une chaine.

    75.2.27.3. Limiter sur la borne supérieure

    La borne supérieure se règle au moyen de l'option max. Ce doit être un entier.

    $validator = new Zend_Validate_StringLength(array('max' => 6));

    $validator->isValid("Test"); // retourne true
    $validator->isValid("Testing"); // retourne false

    Il est possible de préciser cette option plus tard, au moyen de la méthode setMax(). getMax() existe aussi.

    $validator = new Zend_Validate_StringLength();
    $validator->setMax(6);

    $validator->isValid("Test"); // retourne true
    $validator->isValid("Testing"); // retourne false

    75.2.27.4. Limiter sur la borne inférieure

    La borne inférieure se règle au moyen de l'option min. Ce doit être un entier.

    $validator = new Zend_Validate_StringLength(array('min' => 5));

    $validator->isValid("Test"); // retourne false
    $validator->isValid("Testing"); // retourne true

    Il est possible de préciser cette option plus tard, au moyen de la méthode setMin(). getMin() existe aussi.

    $validator = new Zend_Validate_StringLength();
    $validator->setMin(5);

    $validator->isValid("Test"); // retourne false
    $validator->isValid("Testing"); // retourne true

    75.2.27.5. Limiter via les deux bornes

    Quelques fois, il est nécessaire de s'assurer que la chaine comprenne bien un nombre de caractères entre deux bornes min et max. Par exemple depuis un champ de formulaire représentant un nom, vous voudriez que l'utilisateur ne puisse saisir plus de 30 caractères mais au moins 3. Voyez l'exemple qui suit:

    $validator = new Zend_Validate_StringLength(array('min' => 3'max' => 30));

    $validator->isValid("."); // retourne false
    $validator->isValid("Test"); // retourne true
    $validator->isValid("Testing"); // retourne true
    [Note] Comportement illogique, borne inférieure supérieure à la borne supérieure

    Si vous tentez de préciser un min supérieur au max, ou inversement, une exception sera levée.

    75.2.27.6. Encodage des valeurs

    Les chaines se représentent toujours en considérant un encodage. Même si vous ne le précisez pas explicitement, PHP en utilise un. Si votre application utilise un encodage différent de celui de PHP, vous devrez alors le préciser.

    Vous pouvez passer votre propre encodage à l'initialisation grâce à l'option encoding, ou en utilisant la méthode setEncoding() . Nous supposons que votre installation utilise ISO ainsi que votre application. Dans ce cas, vous verrez le comportement suivant:

    $validator = new Zend_Validate_StringLength(
        array(
    'min' => 6)
    );
    $validator->isValid("Ärger"); // retourne false

    $validator->setEncoding("UTF-8");
    $validator->isValid("Ärger"); // retourne true

    $validator2 = new Zend_Validate_StringLength(
        array(
    'min' => 6'encoding' => 'UTF-8')
    );
    $validator2->isValid("Ärger"); // retourne true

    Si votre installation et votre application utilisent des encodages différents, vous deviez toujours préciser l'encodage vous-même.

    digg delicious meneame google twitter technorati facebook

    Comments

    Loading...