Previous Next

Classes de validation standard

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

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.

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.

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
}

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
}

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.

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.

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

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
}

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
}

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.

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.

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

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
}

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

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
}

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.

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.

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.

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.

Callback (fonction de rappel)

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

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.

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
}

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
}

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
}

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

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.

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.

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.

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

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.

Ccnum

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

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

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.

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

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

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

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.

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.

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.

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

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

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

Digits

Zend_Validate_Digit valide si une donnée contient des chiffres.

Options supportées par Zend_Validate_Digits

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

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.

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 

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

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

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 "\").

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

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

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.

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.

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.

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.

Float

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

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.

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

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

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.

Options supportées par Zend_Validate_GreaterThan

Les options suivantes sont supportées par Zend_Validate_GreaterThan:

  • min: Affecte la borne inférieure.

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.

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.

Options supportées par Zend_Validate_Hex

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

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.

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

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.

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.

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.

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.

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

Identical

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

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.

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.

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.

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
}

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.

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.

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:

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
}

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:

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.

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

Int

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

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.

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

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

Ip

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

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.

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.

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.

Isbn

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

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.

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.

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

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)

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.

Options gérées par Zend_Validate_LessThan

Les options suivantes sont supportées par Zend_Validate_LessThan:

  • max: Affecte la borne supérieure.

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.

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.

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.

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.

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.

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.

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

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

Regex

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

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.

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.

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

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.

Exemple #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

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.

Exemple #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

Options supportées par Zend_Validate_Sitemap_*

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

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.

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.

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.

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

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

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.

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.

Previous Next
Introduction au Zend Framework
Présentation
Installation
Apprendre Zend Framework
Démarrez rapidement avec Zend Framework
Zend Framework & Introduction MVC
Créer votre projet
Créer une layout
Créer un modèle et une table en base de données
Créer un formulaire
Félicitations !
Chargement automatique avec Zend Framework
Introduction
Architecture et buts
Utilisation de base de l'autoloader
Auto-chargement de resources
Conclusion
Les plugins dans Zend Framework
Introduction
Utiliser des Plugins
Conclusion
Bien démarrer avec Zend_Layout
Introduction
Utiliser Zend_Layout
Zend_Layout: Conclusions
Bien démarrer avec Zend_View
Introduction
Utilisation de base des Placeholders
Placeholders standards
View Placeholders: Conclusion
Bien comprendre et utiliser les décorateurs Zend Form
Introduction
Les bases des décorateurs
Chainer les décorateurs
Rendu individuel des décorateurs
Créer et rendre des éléments composites
Conclusion
Bien démarrer avec Zend_Session, Zend_Auth, et Zend_Acl
Fabrique une application Multi-Utilisateurs avec Zend Framework
Gérer les sessions dans ZF
Authentification d'utilisateurs dans Zend Framework
Fabriquer un système de gestion d'autorisations avec Zend Framework
Bien démarrer avec Zend_Search_Lucene
Introduction à Zend_Search_Lucene
Structure d'index Lucene
Ouverture et création d'index
Indexation
Recherche
Requêtes supportées
Pagination de résultat de recherche
Bien démarrer avec Zend_Paginator
Introduction
Exemples simples
Contrôles de la pagination et styles de défilement
Assembler le tout
Guide de référence Zend Framework
Zend_Acl
Introduction
Affiner les Contrôles d'Accès
Utilisation avancée
Zend_Amf
Introduction
Zend_Amf_Server
Zend_Application
Introduction
Zend_Application démarrage rapide
Théorie générale
Exemples
Fonctionnalités principales
Plugins de ressources disponibles
Zend_Auth
Introduction
Authentification avec une table de base de données
Authentification "Digest"
Adaptateur d'authentification HTTP
LDAP Authentication
Authentification OpenID
Zend_Barcode
Introduction
Création de code-barres avec la classe Zend_Barcode
Zend_Barcode Objects
Zend_Barcode Renderers
Zend_Cache
Introduction
Aspect théorique
Les frontends Zend_Cache
Les backends Zend_Cache
Le gestionnaire de Cache
Zend_Captcha
Introduction
Opération Captcha
Adaptateurs CAPTCHA
SimpleCloud API: Zend_Cloud
Document Service Introduction
Queue Service Introduction
StorageService Introduction
Zend_CodeGenerator
Introduction
Exemples Zend_CodeGenerator
Zend_CodeGenerator Réference
Zend_Config
Introduction
Aspect théorique
Zend_Config_Ini
Zend_Config_Json
Zend_Config_Xml
Zend_Config_Yaml
Zend_Config_Writer
Zend_Config_Writer
Zend_Console_Getopt
Introduction
Déclarer les règles Getopt
Extraire les options et les arguments
Configurer Zend_Console_Getopt
Zend_Controller
Zend_Controller - Démarrage rapide
Fondations de Zend_Controller
Le contrôleur frontal (Front Controller)
L'objet Requête
Routeur Standard
Le distributeur
Contrôleurs d'action
Aides d'action (Helper)
Objet de réponse
Plugins
Utilisation de conventions de dossiers modulaires
Exceptions avec MVC
Zend_Currency
Introduction à Zend_Currency
Utiliser Zend_Currency
Options des monnaies
Qu'est ce qui définit une monnaie?
Où est le symbole monnétaire?
A quoi ressemble une monnaie?
Travailler avec les valeurs des monnaies (les montants)
Calculs avec les monnaies
Echanger (convertir) des monnaies
Informations complémentaires pour Zend_Currency
Zend_Date
Introduction
Aspect théorique
Méthodes de base
Zend_Date API Overview
Créer des dates
Constants for General Date Functions
Exemples concrets
Zend_Db
Zend_Db_Adapter
Zend_Db_Statement
Zend_Db_Profiler
Zend_Db_Select
Zend_Db_Table
Zend_Db_Table_Row
Zend_Db_Table_Rowset
Relations Zend_Db_Table
Zend_Db_Table_Definition
Zend_Debug
Afficher des informations
Zend_Dojo
Introduction
Zend_Dojo_Data: dojo.data Envelopes
Les aides de vues Dojo
Les éléments de formulaire et les décorateurs Dojo
Zend_Dojo build layer support
Zend_Dom
Introduction
Zend_Dom_Query
Zend_Exception
Utiliser les exceptions
Utilisation classique
Exceptions précédentes
Zend_Feed
Introduction
Importer des flux
Obtenir des flux à partir de pages Web
Consommer un flux RSS
Consommer un flux Atom
Consommer une entrée Atom particulière
Modifier la structure du flux ou des entrées
Classes personnalisées pour les flux et entrées
Zend_Feed_Reader
Zend_Feed_Writer
Zend_Feed_Pubsubhubbub
Zend_File
Zend_File_Transfer
Validateurs pour Zend_File_Transfer
Filtres pour Zend_File_Transfer
Zend_Filter
Introduction
Classes de filtre standards
Chaînes de filtrage
Écriture de filtres
Zend_Filter_Input
Zend_Filter_Inflector
Zend_Form
Zend_Form
Zend_Form démarrage rapide
Creating Form Elements Using Zend_Form_Element
Creating Forms Using Zend_Form
Créer un visuel personnalisé en utilisant Zend_Form_Decorator
Les éléments standards fournis avec Zend Framework
Décorateurs standards fournis avec Zend Framework
Internationaliser un formulaire Zend_Form
Advanced Zend_Form Usage
Zend_Gdata
Introduction
Authentification par procédé AuthSub
Using the Book Search Data API
Authentification avec ClientLogin
Using Google Calendar
Using Google Documents List Data API
Using Google Health
Using Google Spreadsheets
Using Google Apps Provisioning
Using Google Base
Utilisation des albums Web Picasa
Using the YouTube Data API
Attraper les exceptions Gdata
Zend_Http
Introduction
Zend_Http_Client - Utilisation avancée
Zend_Http_Client - Adaptateurs de connexion
Zend_Http_Cookie and Zend_Http_CookieJar
Zend_Http_Response
Zend_Http_UserAgent
The UserAgent Device Interface
The UserAgent Features Adapter
The WURFL UserAgent Features Adapter
The DeviceAtlas UserAgent Features Adapter
The TeraWurfl UserAgent Features Adapter
The UserAgent Storage Interface
The Session UserAgent Storage Adapter
Zend_InfoCard
Introduction
Zend_Json
Introduction
Utilisation de base
Utilisation avancée de Zend_Json
XML to JSON conversion
Zend_Json_Server - JSON-RPC server
Zend_Layout
Introduction
Zend_Layout - Démarrage rapide
Zend_Layout options de configuration
Zend_Layout, utilisation avancée
Zend_Ldap
Introduction
API overview
Scénarios d'utilisation
Outils
Accès à l'arbre LDAP de manière orientée objet avec Zend_Ldap_Node
Récupérer des informations depuis un serveur LDAP
Serialiser des données LDAP depuis/vers LDIF
Zend_Loader
Charger les fichiers et les classes dynamiquement
L'autoloader
Autoloaders de ressources
Chargeur de Plugins
Zend_Locale
Introduction
Using Zend_Locale
Normalization and Localization
Working with Dates and Times
Supported locales
Zend_Log
Présentation
Rédacteurs (Writers)
Formateurs (mise en forme)
Filtres
Utiliser la fabrique pour créer des logs
Zend_Mail
Introduction
Envoyer des courriels en utilisant SMTP
Envoyer plusieurs courriels par connexion SMTP
Utiliser différents transports
Courriel HTML
Fichiers joints
Ajouter des destinataires
Contrôler les limites MIME
En-têtes additionnels
Jeux de caractères
Encodage
Authentification SMTP
Sécuriser les transports SMTP
Lire des courriels
Zend_Markup
Introduction
Guide de démarrage avec Zend_Markup
Analyseurs Zend_Markup (parsers)
Moteurs de rendu Zend_Markup
Zend_Measure
Introduction
Création d'une mesure
Récupérer des mesures
Manipuler des mesures
Types de mesures
Zend_Memory
Présentation
Manager de mémoire
Objet mémoire
Zend_Mime
Zend_Mime
Zend_Mime_Message
Zend_Mime_Part
Zend_Navigation
Introduction
Pages
Containers
Zend_Oauth
Introduction to OAuth
Zend_OpenId
Introduction
Zend_OpenId_Consumer Basics
Zend_OpenId_Provider
Zend_Paginator
Introduction
Utilisation
Configuration
Utilisation avancée
Zend_Pdf
Introduction
Créer et charger des documents PDF
Sauvegarder les changement dans un document PDF
Les pages d'un document
Dessiner
Interactive Features
Informations du document et métadonnées
Exemple d'utilisation du module Zend_Pdf
Zend_ProgressBar
Zend_ProgressBar
Zend_Queue
Introduction
Example usage
Framework
Adapters
Customizing Zend_Queue
Stomp
Zend_Reflection
Introduction
Zend_Reflection Exemples
Réference de Zend_Reflection
Zend_Registry
Utiliser le registre
Zend_Rest
Introduction
Zend_Rest_Client
Zend_Rest_Server
Zend_Search_Lucene
Vue d'ensemble
Créer des index
Chercher dans un index
Langage de requêtes
API de construction de requêtes
Jeu de caractères
Extensibilité
Agir avec Lucene Java
Avancé
Bonnes pratiques
Zend_Serializer
Introduction
Zend_Serializer_Adapter
Zend_Server
Introduction
Zend_Server_Reflection
Zend_Service
Introduction
Zend_Service_Akismet
Zend_Service_Amazon
Zend_Service_Amazon_Ec2
Zend_Service_Amazon_Ec2: Instances
Zend_Service_Amazon_Ec2: Windows Instances
Zend_Service_Amazon_Ec2: Reserved Instances
Zend_Service_Amazon_Ec2: CloudWatch Monitoring
Zend_Service_Amazon_Ec2: Amazon Machine Images (AMI)
Zend_Service_Amazon_Ec2: Elastic Block Storage (EBS)
Zend_Service_Amazon_Ec2: Elastic IP Addresses
Zend_Service_Amazon_Ec2: Keypairs
Zend_Service_Amazon_Ec2: Regions and Availability Zones
Zend_Service_Amazon_Ec2: Security Groups
Zend_Service_Amazon_S3
Zend_Service_Amazon_Sqs
Zend_Service_Audioscrobbler
Zend_Service_Delicious
Zend_Service_DeveloperGarden
Zend_Service_Ebay
Zend_Service_Ebay_Finding
Zend_Service_Flickr
Zend_Service_LiveDocx
Zend_Service_Nirvanix
Zend_Service_ReCaptcha
Zend_Service_ShortUrl
Zend_Service_Simpy
Zend_Service_SlideShare
Zend_Service_StrikeIron
Zend_Service_StrikeIron: Bundled Services
Zend_Service_StrikeIron: Advanced Uses
Zend_Service_Technorati
Zend_Service_Twitter
Zend_Service_WindowsAzure
Zend_Service_WindowsAzure_Storage_Blob
Zend_Service_WindowsAzure_Diagnostics_Manager
Zend_Service_WindowsAzure_Storage_Queue
Zend_Service_WindowsAzure_Storage_Table
Zend_Service_Yahoo
Zend_Session
Introduction
Usage basique
Utilisation avancée
Gestion générale de la session
Zend_Session_SaveHandler_DbTable
Zend_Soap
Zend_Soap_Server
Zend_Soap_Client
WSDL
Auto découverte
Zend_Tag
Introduction
Zend_Tag_Cloud
Zend_Test
Introduction
Zend_Test_PHPUnit
Zend_Test_PHPUnit_Db
Zend_Text
Zend_Text_Figlet
Zend_Text_Table
Zend_TimeSync
Introduction
Utiliser Zend_TimeSync
Zend_Tool
Using Zend_Tool On The Command Line
Extending Zend_Tool
Zend_Tool_Framework
Introduction
Using the CLI Tool
Architecture
Creating Providers to use with Zend_Tool_Framework
Shipped System Providers
Extending and Configuring Zend_Tool_Framework
Zend_Tool_Project
Introduction
Créer un projet
Fournisseurs de Zend_Tool_Project
Rouages internes de Zend_Tool_Project
Zend_Translate
Introduction
Adaptateurs pour Zend_Translate
Utiliser les adaptateurs de traduction
Creating source files
Additional features for translation
Notation des pluriels pour Translation
Zend_Uri
Zend_Uri
Zend_Validate
Introduction
Classes de validation standard
Chaînes de validation
Écrire des validateurs
Messages de validation
Zend_Version
Lire la version de Zend Framework
Zend_View
Introduction
Scripts de contrôleur
Scripts de vue
Aides de vue
Zend_View_Abstract
Zend_Wildfire
Zend_Wildfire
Zend_XmlRpc
Introduction
Zend_XmlRpc_Client
Zend_XmlRpc_Server
ZendX_Console_Process_Unix
ZendX_Console_Process_Unix
ZendX_JQuery
Introduction
ZendX_JQuery View Helpers
ZendX_JQuery Form Elements and Decorators
Configuration système requise par Zend Framework
Introduction
Notes de migration de Zend Framework
Zend Framework 1.10
Zend Framework 1.9
Zend Framework 1.8
Zend Framework 1.7
Zend Framework 1.6
Zend Framework 1.5
Zend Framework 1.0
Zend Framework 0.9
Zend Framework 0.8
Zend Framework 0.6
Convention de codage PHP de Zend Framework
Vue d'ensemble
Formatage des fichiers PHP
Conventions de nommage
Style de codage
Recommandation sur la documentation de Zend Framework
Présentation
Format des fichiers de documentation
Recommendations
Recommended Project Structure for Zend Framework MVC Applications
Overview
Recommended Project Directory Structure
Module Structure
Rewrite Configuration Guide
Guide de performance Zend Framework
Introduction
Chargement des classes
Performance de Zend_Db
Internationalisation (i18n) and Localisation (l10n)
View Rendering
Informations de copyright