Les options suivantes sont supportées par Zend_Validate_Alnum :

Voici un exemple :

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

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
}

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.

Les options suivantes sont supportées par Zend_Validate_Alpha:

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
}

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
}

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.

Les options suivantes sont supportées par Zend_Validate_Barcode:

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
}

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
}

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.

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
}

Les options suivantes sont reconnues par 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.

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.

Les options suivantes sont supportées par Zend_Validate_Callback :

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
}

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
}

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
}

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

Les options suivantes sont supportées par Zend_Validate_CreditCard :

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.

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

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

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.

Les options suivantes sont supportées par Zend_Validate_Date:

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

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

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

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

Voici un exemple basique:

//Vérifie que l'email existe bien dans la base de données
$validator = new Zend_Validate_Db_RecordExists(
    array(
        'table' => 'users',
        'field' => '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(
    array(
        'table' => 'users',
        'field' => '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.

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(
    array(
        'table' => 'users',
        'field' => 'username',
        'exclude' => 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 dans la table qu'aucun autre enregistrement que celui pour lequel id = $user_id ne contient la valeur $username.

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

$email     = 'user@example.com';
$clause    = $db->quoteInto('email = ?', $email);
$validator = new Zend_Validate_Db_RecordExists(
    array(
        'table'   => 'users',
        'field'   => 'username',
        'exclude' => $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 'users' pour s'assurer qu'un seul enregistrement avec un nom $username et un email $email est valide.

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(
    array(
        'table' => 'users',
        'field' => 'id',
        'adapter' => $dbAdapter
    )
);

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',
        'field'  => 'id'
    )
);

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

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

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

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:

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

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

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

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

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

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

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.

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.

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.

Les options suivantes sont supportées par Zend_Validate_Float:

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

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

Les options suivantes sont supportées par Zend_Validate_GreaterThan:

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.

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

Les options suivantes sont supportées par Zend_Validate_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.

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

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

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

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

Les options suivantes sont supportées par Zend_Validate_Identical :

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.

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
}

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
}

Les options suivantes sont supportées par Zend_Validate_InArray :

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

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
}

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.

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
}

Les options suivantes sont supportées par Zend_Validate_Int:

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

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

Les options suivantes sont supportées par Zend_Validate_Ip :

Voici un exemple banal:

$validator = new Zend_Validate_Ip();
if ($validator->isValid($ip)) {
    // ip semble valide
} else {
    // ip n'est pas valide
}

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
}

Les options suivantes sont supportées par Zend_Validate_Isbn :

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.

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 :

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
}

Séparateurs valides :

Les options suivantes sont supportées par Zend_Validate_LessThan:

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.

Les options suivantes sont supportées par 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

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 :

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.

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

Les options suivantes sont supportées par Zend_Validate_PostCode :

Les options suivantes sont supportées par 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.

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

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.

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.

$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

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.

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.

$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

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

Les options suivantes sont reconnues par 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.

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

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

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

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.