Les options suivantes sont supportées par Zend_Filter_Alnum:

Voyez l'exemple suivant pour le comportement par défaut de ce filtre.

$filter = new Zend_Filter_Alnum();
$return = $filter->filter('This is (my) content: 123');
// retourne 'Thisismycontent123'

L'exemple ci-dessus retourne 'Thisismycontent123'. Comme vous le voyez, tous les espaces et le double-point sont filtrés.

Zend_Filter_Alnum peut aussi autoriser les espaces. Ca peut être utile, voyez l'exemple suivant:

$filter = new Zend_Filter_Alnum(array('allowwhitespace' => true));
$return = $filter->filter('This is (my) content: 123');
// retourne 'This is my content 123'

L'exemple ci-dessus retourne 'This is my content 123'. Comme vous le voyez, le double-point est filtré ainsi que les parenthèses, mais pas les espaces.

Pour changer allowWhiteSpace après construction de l'objet, utilisez setAllowWhiteSpace() et getAllowWhiteSpace().

Les options suivantes sont supportées par Zend_Filter_Alpha:

Voici un exemple de base:

$filter = new Zend_Filter_Alpha();

print $filter->filter('This is (my) content: 123');

L'exemple ci-dessus affiche 'Thisismycontent'. Remarquez que les espaces et le double-point ont été supprimés.

Zend_Filter_Alpha peut aussi autoriser les espaces. Ca peut être utile, voyez l'exemple suivant:

$filter = new Zend_Filter_Alpha(array('allowwhitespace' => true));

print $filter->filter('This is (my) content: 123');

L'exemple ci-dessus retourne 'This is my content'. Comme vous le voyez, le double-point ainsi que les chiffres et les parenthèses sont filtrés mais pas les espaces.

Pour changer allowWhiteSpace après construction de l'objet, utilisez setAllowWhiteSpace() et getAllowWhiteSpace().

Il n'y a pas d'option supplémentaire gérée par Zend_Filter_BaseName.

Voici un exemple de base:

$filter = new Zend_Filter_BaseName();

print $filter->filter('/vol/tmp/filename');

Ceci va afficher 'filename'.

$filter = new Zend_Filter_BaseName();

print $filter->filter('/vol/tmp/filename.txt');

Ceci affichera 'filename.txt'.

Les options suivantes sont supportées par Zend_Filter_Boolean :

Par défaut, ce filtre transtype sa valeur vers un BOOLEEN ; en d'autres termes, il fonctionne comme un appel PHP de type (boolean) $value.

$filter = new Zend_Filter_Boolean();
$value  = '';
$result = $filter->filter($value);
// retourne false

Ceci signifie que sans paramètre additionnel, Zend_Filter_Boolean prend toute valeur d'entrée et retourne un BOOLEEN comme le transtypage PHP vers le BOOLEEN.

Parfois, le transtypage tel que (boolean) peut ne pas suffire. Zend_Filter_Boolean permet ainsi de configurer les types d'entrée à convertir, et ceux à ignorer.

Les types suivants sont acceptés :

Toute autre valeur fournie retournera TRUE.

Pour préciser les options ci-dessus, plusieurs manières sont données : utilisez des chaînes, des constantes, ajoutez les, utilisez des tableaux... Voyez l'exemple :

// convertit 0 vers false
$filter = new Zend_Filter_Boolean(Zend_Filter_Boolean::INTEGER);

// convertit 0 et '0' vers false
$filter = new Zend_Filter_Boolean(
    Zend_Filter_Boolean::INTEGER + Zend_Filter_Boolean::ZERO
);

// convertit 0 et '0' vers false
$filter = new Zend_Filter_Boolean(array(
    'type' => array(
        Zend_Filter_Boolean::INTEGER,
        Zend_Filter_Boolean::ZERO,
    ),
));

// convertit 0 et '0' vers false
$filter = new Zend_Filter_Boolean(array(
    'type' => array(
        'integer',
        'zero',
    ),
));

Vous pouvez aussi passer une instance de Zend_Config pour préciser les options. Pour préciser ces options après la création de votre objet, utilisez la méthode setType().

Comme déjà précisé, Zend_Filter_Boolean reconnaît les chaînes localisées "yes" et "no". Ceci signifie que vous pouvez demander au client au travers d'un formulaire "oui" ou "non" dans sa propre langue et Zend_Filter_Boolean convertira la valeur vers le booléen approprié.

Préciser la locale s'effectue grâce à la clé de configuration locale ou la méthode setLocale().

$filter = new Zend_Filter_Boolean(array(
    'type'   => Zend_Filter_Boolean::ALL,
    'locale' => 'de',
));

// retourne false
echo $filter->filter('nein');

$filter->setLocale('en');

// retourne true
$filter->filter('yes');

Il peut arriver de ne vouloir que reconnaître TRUE ou FALSE et donc retourner les autres valeurs telles quelles. Zend_Filter_Boolean permet un tel comportement via son option casting lorsque réglée sur FALSE.

Dans un tel cas, Zend_Filter_Boolean fonctionnera comme décrit dans le tableau ci-dessous qui montre quelles valeurs retournent TRUE ou FALSE. Toute autre valeur non présente dans ce tableau sera retournée telle quelle lorsque l'option casting vaut FALSE.

L'exemple qui suit illustre l'utilisation de l'option casting :

$filter = new Zend_Filter_Boolean(array(
    'type'    => Zend_Filter_Boolean::ALL,
    'casting' => false,
));

// retourne false
echo $filter->filter(0);

// retourne true
echo $filter->filter(1);

// retourne la valeur
echo $filter->filter(2);

Les options suivantes sont supportées par Zend_Filter_Callback :

L'utilisation de ce filtre est assez simple. Prenos par exemple un filtre qui inverse une chaine.

$filter = new Zend_Filter_Callback('strrev');

print $filter->filter('Hello!');
// retourne "!olleH"

C'est très simple de passer une fonction à appliquer comme filtre. Dans le cas de méthodes de classes, passez un tableau comme callback.

// Notre classe
class MyClass
{
    public function Reverse($param);
}

// La définition du filtre
$filter = new Zend_Filter_Callback(array('MyClass', 'Reverse'));
print $filter->filter('Hello!');

Pour récupérer la fonction de filtrage actuelle, utilisez getCallback() et pour en affecter une nouvelle, utilisez setCallback().

Il est aussi possible de définir des paramètres par défaut qui sont alors passés à la méthode appelée lorsque le filtre est exécuté.

$filter = new Zend_Filter_Callback(
    array(
        'callback' => 'MyMethod',
        'options'  => array('key' => 'param1', 'key2' => 'param2')
    )
);
$filter->filter(array('value' => 'Hello'));

L'appel manuel à une telle fonction se serait fait comme cela:

$value = MyMethod('Hello', 'param1', 'param2');

Les options suivantes sont supportées par Zend_Filter_Compress et Zend_Filter_Decompress :

Les formats de compression suivants sont supportés par leurs adaptateurs respectifs :

Chaque format de compression possède des caractéristiques propres et ils s'utilisent tous d'une manière commune. Seules leurs options vont différer ainsi que les types de compressions qu'ils offrent (algorithmes, fichiers, chaines et dossiers)

Pour créer un filtre de compression vous devez sélectionner le format que vous désirez. La description suivante utilisera l'adaptateur Bz2. Les détails des autres adaptateurs seront précisés plus tard dans la section suivante.

Les deux filtres (compression et décompression) sont identiques lorsqu'ils utilisent le même adaptateur. Simplement Zend_Filter_Compress est utilisé pour les opérations de compression alors que Zend_Filter_Decompress est utilisé pour la décompression.

Par exemple, si nous voulons compresser une chaine nous devons instancier Zend_Filter_Compress et indiquer un adaptateur.

$filter = new Zend_Filter_Compress('Bz2');

Les adaptateurs se spécifient donc dans le constructeur.

Il est aussi possible de passer des options sous forme de tableau ou d'objet Zend_Config. Si vous souhaitez préciser des options, vous devez alors au minimum indiquer la clé "adapter". Les clés "options" ou "adapterOptions" peuvent ensuite être utilisées et doivent représenter un tableau.

$filter = new Zend_Filter_Compress(array(
    'adapter' => 'Bz2',
    'options' => array(
        'blocksize' => 8,
    ),
));

Concernant la décompression, le principe est exactement identique.

$filter = new Zend_Filter_Decompress('Bz2');

Pour récupérer une chaine compressée, il faut indiquer la chaine originale. La valeur "filtrée" récupérée sera alors la chaine compressée, tout simplement.

$filter     = new Zend_Filter_Compress('Bz2');
$compressed = $filter->filter('Uncompressed string');
// Retourne la chaine compressée

La décompression suit exactement le même principe.

$filter     = new Zend_Filter_Decompress('Bz2');
$compressed = $filter->filter('Compressed string');
// Retourne la chaine décompressée

Créer une archive fonctionne quasiment de la même manière que la compression d'une chaine. Cependant dans ce cas, nous devons préciser une options supplémentaire indiquant le nom de l'archive à créer.

$filter     = new Zend_Filter_Compress(array(
    'adapter' => 'Bz2',
    'options' => array(
        'archive' => 'filename.bz2',
    ),
));
$compressed = $filter->filter('Uncompressed string');
// Retourne true en cas de succès et crée le fichier d'archive

Dans l'exemple ci-dessus, la chaine est compressée puis retournée dans une archive.

Si vous souhaitez compresser un fichier, vous devez fournir son chemin.

$filter     = new Zend_Filter_Compress(array(
    'adapter' => 'Bz2',
    'options' => array(
        'archive' => 'filename.bz2'
    ),
));
$compressed = $filter->filter('C:\temp\compressme.txt');
// Retourne true en cas de succès et crée le fichier d'archive

Il est aussi possible de préciser le nom d'un dossier plutôt que d'un fichier. Dans ce cas, tout le dossier sera compressé, récursivement.

$filter     = new Zend_Filter_Compress(array(
    'adapter' => 'Bz2',
    'options' => array(
        'archive' => 'filename.bz2'
    ),
));
$compressed = $filter->filter('C:\temp\somedir');
// Retourne true en cas de succès et crée le fichier d'archive

Décompresser une archive s'éxecute d'une manière sensiblement identique à la compression. Vous devez passer le paramètre archive ou préciser le nom du fichier.

$filter     = new Zend_Filter_Decompress('Bz2');
$compressed = $filter->filter('filename.bz2');
// Retourne true en cas de succès et décompresse le fichier d'archive

Certains adaptateurs permettent la décompression d'une archive dans un dossier cible, dans ce cas le paramètre target permet de l'indiquer.

$filter     = new Zend_Filter_Decompress(array(
    'adapter' => 'Zip',
    'options' => array(
        'target' => 'C:\temp',
    )
));
$compressed = $filter->filter('filename.zip');
// Retourne true en cas de succès et décompresse le fichier d'archive
// dans le dossier spécifié

L'adaptateur Bz2 peut compresser et décompresser:

Cet adaptateur utilise l'extension PHP Bz2.

Pour personnaliser la compression, cet adaptateur utilise les options suivantes:

Toutes les options peuvent être passées à l'instanciation ou en utilisant des méthodes. Par exemple pour la tailles des blocs, getBlocksize() et setBlocksize(). La méthode setOptions() est aussi présente, elle accepte un tableau

L'adaptateur Bz2 peut compresser et décompresser:

Cet adaptateur utilise l'extension PHP Zlib.

Pour personnaliser la compression, cet adaptateur utilise les options suivantes:

Toutes les options peuvent être passées en constructeur ou en utilisant des méthodes. Par exemple, pour l'option 'Level', getLevel() et setLevel(). La méthode setOptions() est aussi présente et accepte un tableau.

L'adaptateur Lzf peut compresser et décompresser:

Cet adaptateur utilise l'extension PHPLzf.

Il n'existe pas d'options pour personnaliser cet adaptateur.

L'adaptateur Rar peut compresser et décompresser:

Cet adaptateur utilise l'extension PHP Rar.

Cet adaptateur accepte les options suivantes:

Toutes les options peuvent être passées au constructeurs ou via des méthodes. Par exemple, pour l'option 'Target', getTarget() et setTarget().La méthode setOptions() est aussi disponible et accepte un tableau.

L'adaptateur Tar peut compresser et décompresser:

Cet adaptateur utilise le paquet PEAR Archive_Tar.

Cet adaptateur accepte les options suivantes:

Toutes les options peuvent être passées au constructeurs ou via des méthodes. Par exemple, pour l'option 'Target', getTarget() et setTarget().La méthode setOptions() est aussi disponible et accepte un tableau.

L'adaptateur Zip peut compresser et décompresser:

Cet adaptateur utilise l'extension PHP Zip.

Les options suivantes sont supportées :

Toutes les options peuvent être passées au constructeurs ou via des méthodes. Par exemple, pour l'option 'Target', getTarget() et setTarget().La méthode setOptions() est aussi disponible et accepte un tableau.

Pour décrypter une données cryptées avec Mcrypt, vous avez besoin des paramètres utilisés pour encrypter, ainsi que du vecteur.

Si vous n'aviez pas passé de vecteur spécifique à l'encryptage, alors vous devriez récupérer le vecteur utilisé grâce à la méthode getVector(). Sans ce vecteur, aucun décryptage de la données originale n'est possible.

Le décryptage s'effectue aussi simplement que l'encryptage.

// Utilisation des paramètres blowfish par défaut
$filter = new Zend_Filter_Decrypt('myencryptionkey');

// Utilisation du vecteur utilisé lors de l'encryptage
$filter->setVector('myvector');

$decrypted = $filter->filter('texte_encodé_non_lisible');
print $decrypted;

Le décryptage avec OpenSSL est aussi simple que l'encryptage. Mais vous aurez besoin de toutes les données concernant la personne ayant crypté la donnée de référence.

Pour décrypter avec OpenSSL vous devez posséder:

// Utilise OpenSSL avec une clé spécifiée
$filter = new Zend_Filter_Decrypt(array(
    'adapter' => 'openssl',
    'private' => '/path/to/mykey/private.pem'
));

// Passage des clés enveloppe
$filter->setEnvelopeKey(array(
    '/key/from/encoder/first.pem',
    '/key/from/encoder/second.pem'
));

Optionnellement il peut être nécessaire de passer la passphrase pour décrypter les clés elles-mêmes. Utilisez alors setPassphrase().

// Utilise OpenSSL avec une clé spécifiée
$filter = new Zend_Filter_Decrypt(array(
    'adapter' => 'openssl',
    'private' => '/path/to/mykey/private.pem'
));

// Passage des clés enveloppe
$filter->setEnvelopeKey(array(
    '/key/from/encoder/first.pem',
    '/key/from/encoder/second.pem'
));
$filter->setPassphrase('mypassphrase');

Enfin, décryptez le contenu. Voici l'exemple complet:

// Utilise OpenSSL avec une clé spécifiée
$filter = new Zend_Filter_Decrypt(array(
    'adapter' => 'openssl',
    'private' => '/path/to/mykey/private.pem'
));

// Passage des clés enveloppe
$filter->setEnvelopeKey(array(
    '/key/from/encoder/first.pem',
    '/key/from/encoder/second.pem'
));
$filter->setPassphrase('mypassphrase');

$decrypted = $filter->filter('texte_encodé_illisible');
print $decrypted;

Il n'y a pas d'option supplémentaire pour Zend_Filter_Digits.

Voici un exemple de base:

$filter = new Zend_Filter_Digits();

print $filter->filter('October 2009');

Ceci affiche "2009".

$filter = new Zend_Filter_Digits();

print $filter->filter('HTML 5 for Dummies');

Ceci affiche "5".

Il n'y a pas d'options supplémentaire pour Zend_Filter_Dir.

Voici un exemple de base:

$filter = new Zend_Filter_Dir();

print $filter->filter('/etc/passwd');

Ceci affiche "/etc".

$filter = new Zend_Filter_Dir();

print $filter->filter('C:/Temp/x');

Ceci affiche "C:/Temp".

// Utiliser Mcrypt
$filter1 = new Zend_Filter_Encrypt(array('adapter' => 'mcrypt'));

// Utiliser OpenSSL
$filter2 = new Zend_Filter_Encrypt(array('adapter' => 'openssl'));

// Utiliser Mcrypt
$filter = new Zend_Filter_Encrypt();
$filter->setAdapter('openssl');

Cet adaptateur nécessite la présence de l'extension PHP Mcrypt. Voici ses options:

Si vous passez une chaine à la place d'un tableau pour la clé, celle-ci sera utilisée.

Les méthodes getEncryption() et setEncryption() sont aussi présentes.

getVector() et setVector() sont aussi disponibles si besoin. Une chaine passée sera mise à la taille du vecteur pour être utilisée avec l'algorithme en cours.

// Utilise blowfish par défaut
$filter = new Zend_Filter_Encrypt('myencryptionkey');

// Affecte un vecteur précis.
$filter->setVector('myvector');
// $filter->getVector(); est nécessaire sinon, pour décoder la valeur plus tard

$encrypted = $filter->filter('text_to_be_encoded');
print $encrypted;

// Pour le décryptage, voyez le code du filtre Decrypt

Lorsque vous avez installé l'extension PHP OpenSSL, vous pouvez utiliser l'adaptateur du même nom, dont voici les options d'instanciation:

getPublicKey() et setPublicKey() sont aussi présentes, ainsi que getPrivateKey() et setPrivateKey().

// Utiliser openssl
$filter = new Zend_Filter_Encrypt(array(
    'adapter' => 'openssl',
    'private' => '/path/to/mykey/private.pem'
));

// utilisation des méthodes
$filter->setPublicKey(array(
    '/public/key/path/first.pem',
    '/public/key/path/second.pem'
));

Si vous souhaitez encoder aussi les clés, passez alors une passphrase via setPassphrase(). Attention, la passphrase sera nécessaire pour décoder les clés.

// Utilise openssl avec une clé privée
$filter = new Zend_Filter_Encrypt(array(
    'adapter' => 'openssl',
    'private' => '/path/to/mykey/private.pem'
));

// utilisation des méthodes pour specifier la clé publique
$filter->setPublicKey(array(
    '/public/key/path/first.pem',
    '/public/key/path/second.pem'
));
$filter->setPassphrase('mypassphrase');

Pour décrypter le document, la passphrase (si utilisée) et les clés enveloppe sont nécessaires.

Ceci signifie que vous devez appeler la méthode getEnvelopeKey() après le cryptage pour récupérer l'enveloppe.

Voici donc un exemple complet de cryptage de données avec OpenSSL.

// Utilisons openssl avec une clé privée
$filter = new Zend_Filter_Encrypt(array(
    'adapter' => 'openssl',
    'private' => '/path/to/mykey/private.pem'
));

// Voici la clé publique
$filter->setPublicKey(array(
    '/public/key/path/first.pem',
    '/public/key/path/second.pem'
));
$filter->setPassphrase('mypassphrase');

$encrypted = $filter->filter('text_to_be_encoded');
$envelope  = $filter->getEnvelopeKey();
print $encrypted;

// Le décryptage est expliqué dans le filtre Decrypt

Les options suivantes sont supportées par Zend_Filter_HtmlEntities:

Voyez l'exemple qui suit pour le comportement de ce filtre.

$filter = new Zend_Filter_HtmlEntities();

print $filter->filter('<');

Zend_Filter_HtmlEntities permet de changer les styles de quote à filtrer. Ceci est utile si vous voulez laisser intactes les doubles, simples ou les deux types de quotes. Voici un exemple:

$filter = new Zend_Filter_HtmlEntities(array('quotestyle' => ENT_QUOTES));

$input  = "A 'single' and " . '"double"';
print $filter->filter($input);

Ceci affiche A 'single' and "double". Notez que les 'simples' et les "doubles" quotes ont été filtrées.

$filter = new Zend_Filter_HtmlEntities(array('quotestyle' => ENT_COMPAT));

$input  = "A 'single' and " . '"double"';
print $filter->filter($input);

L'exemple ci-dessus affichera A 'single' and "double". Notez que seules les "doubles" quotes ont été filtrées.

$filter = new Zend_Filter_HtmlEntities(array('quotestyle' => ENT_NOQUOTES));

$input  = "A 'single' and " . '"double"';
print $filter->filter($input);

L'exemple ci-dessus affichera A 'single' and "double". Notez qu'ici aucune des "doubles" ou 'simples' quotes n'ont été altérées.

Pour changer ou récupérer la valeur de quotestyle après instantiation, les méthodes setQuoteStyle() et getQuoteStyle() peuvent être utilisées. setQuoteStyle() accepte un paramètre $quoteStyle. Les constantes suivantes sont autorisées: ENT_COMPAT, ENT_QUOTES, ENT_NOQUOTES

$filter = new Zend_Filter_HtmlEntities();

$filter->setQuoteStyle(ENT_QUOTES);
print $filter->getQuoteStyle(ENT_QUOTES);

Pour changer ou récupérer la valeur de charset après instantiation, les méthodes setCharSet() et getCharSet() peuvent être utilisées. setCharSet() accepte un paramètre $charSet. Voyez "http://php.net/htmlentities" pour une liste des valeurs acceptées.

$filter = new Zend_Filter_HtmlEntities();

$filter->setQuoteStyle(ENT_QUOTES);
print $filter->getQuoteStyle(ENT_QUOTES);

Pour changer ou récupérer la valeur de doublequote après instantiation, les méthodes setDoubleQuote() et getDoubleQuote() peuvent être utilisées. setDoubleQuote() accepte un booléen $doubleQuote.

$filter = new Zend_Filter_HtmlEntities();

$filter->setQuoteStyle(ENT_QUOTES);
print $filter->getQuoteStyle(ENT_QUOTES);

Il n'y a pas d'option supplémentaire pour Zend_Filter_Int.

Voici un exemple de base:

$filter = new Zend_Filter_Int();

print $filter->filter('-4 is less than 0');

Ceci affichera '-4'.

Tout type de nombre peut être normalisé, excepté les nombres représentant une notation scientifique.

Voici un exemple:

// Initialise le filtre
$filter = new Zend_Filter_LocalizedToNormalized();
$filter->filter('123.456,78');
// retourne '123456.78'

Imaginons que nous utilisoons la locale 'de' de manière globale sur toute l'application. Zend_Filter_LocalizedToNormalized va utiliser cette locale là pour calculer sa sortie.

Il est possible de contrôler la normalisation des nombres. Toute options accépté par Zend_Locale_Format peut alors être utilisée. Les plus courantes sont:

Pour plus de détails à ce sujet, voyez le chapitre Zend_Locale.

Voici un exemple utilisant la précision:

// Numeric Filter
$filter = new Zend_Filter_LocalizedToNormalized(array('precision' => 2));

$filter->filter('123.456');
// retourne '123456.00'

$filter->filter('123.456,78901');
// retourne '123456.79'

Les dates et temps peuvent être normalisés eux aussi. La sortie du filtre sera alors toujours de type tableau.

// Initialise le filtre
$filter = new Zend_Filter_LocalizedToNormalized();
$filter->filter('12.April.2009');
// retourne array('day' => '12', 'month' => '04', 'year' => '2009')

Imaginons une fois de plus une locale globale 'de'. L'entrée est donc automatiquement reconnue comme date et vous aurez un tableau en sortie.

Vous pouvez contrôler la transformation du filtre grâce aux paramètres date_format et locale.

// Date Filter
$filter = new Zend_Filter_LocalizedToNormalized(
    array('date_format' => 'ss:mm:HH')
);

$filter->filter('11:22:33');
// retourne array('hour' => '33', 'minute' => '22', 'second' => '11')

Tout type de nombre peut être localisé, à l'exception des nombres représentant une notation scientifique.

Comment fonctionne la localisation pour les nombres ?:

// Initialise le filtre
$filter = new Zend_Filter_NormalizedToLocalized();
$filter->filter(123456.78);
// retourne '123.456,78'

Imaginons que vous avez affecté une locale 'de' comme locale de l'application. Zend_Filter_NormalizedToLocalized va utiliser cette locale pour détecter le type de sortie à produire, ceci sous forme de chaine de caractères.

Il est aussi possible de contrôler le look de vos nombres localisés. Pour cela vous pouvez préciser toute option que Zend_Locale_Format reconnait. Les plus courantes sont:

Pour plus de détails sur ces options, voyez le chapitre sur Zend_Locale .

Voici un exemple utilisant ces options:

// Numeric Filter
$filter = new Zend_Filter_NormalizedToLocalized(array('precision' => 2));

$filter->filter(123456);
// retourne '123.456,00'

$filter->filter(123456.78901);
// retourne '123.456,79'

Les dates et les temps peuvent aussi être localisés. Des chaines de caractères sont alors retournées, agissant avec la locale définie.

// Initialise le filtre
$filter = new Zend_Filter_NormalizedToLocalized();
$filter->filter(array('day' => '12', 'month' => '04', 'year' => '2009');
// retoures '12.04.2009'

Imaginons que vous ayiez spécifié la locale 'de' au niveau de l'application, celle-ci est alors automatiquement détectée et utilisée pour localiser la date.

Bien sûr, vous pouvez contrôler le format d'affichage de vos dates, grâce aux paramètres date_format et locale.

// Date Filter
$filter = new Zend_Filter_LocalizedToNormalized(
    array('date_format' => 'ss:mm:HH')
);

$filter->filter(array('hour' => '33', 'minute' => '22', 'second' => '11'));
// retourne '11:22:33'

Par défaut, ce filtre fonctionne comme la fonction PHP empty(). Donc si empty() retourne true sur la valeur, alors NULL sera retourné par ce filtre

$filter = new Zend_Filter_Null();
$value  = '';
$result = $filter->filter($value);
// retourne null plutôt que la chaine vide

Ceci signifie qu'en l'absence d'une configuration spéciale, Zend_Filter_Null accepte tout type en entrée et retourne NULL dans les mêmes cas que empty().

Toute autre valeur sera retournée telle quelle, sans aucune modification.

Quelques fois ça ne suffit pas de filtrer en se basant sur empty(). Ainsi, Zend_Filter_Null permet de déclarer quels types seront convertis.

Les types suivants sont gérés:

Il existe plusieurs manières de spécifier les types à filtrer, des constantes, des types ajoutés à la suite, des chaines de caractères, un tableau... Voyez les exemples suivants:

// convertit false en null
$filter = new Zend_Filter_Null(Zend_Filter_Null::BOOLEAN);

// convertit false et 0 en null
$filter = new Zend_Filter_Null(
    Zend_Filter_Null::BOOLEAN + Zend_Filter_Null::INTEGER
);

// convertit false et 0 en null
$filter = new Zend_Filter_Null( array(
    Zend_Filter_Null::BOOLEAN,
    Zend_Filter_Null::INTEGER
));

// convertit false et 0 en null
$filter = new Zend_Filter_Null(array(
    'boolean',
    'integer',
));

Un objet Zend_Config peut aussi être utilisé pour préciser les types. La méthode setType() existe de même.

Les options suivantes sont gérées par Zend_Filter_StringTrim:

Voici un exemple de base:

$filter = new Zend_Filter_StringTrim();

print $filter->filter(' This is (my) content: ');

Ceci affichera 'This is (my) content:'. Notez que les espaces ont été supprimés.

$filter = new Zend_Filter_StringTrim(':');
// ou new Zend_Filter_StringTrim(array('charlist' => ':'));

print $filter->filter(' This is (my) content:');

Ceci affichera 'This is (my) content'. Notez que les espaces et le double-point ont été supprimés. Vous pouvez aussi passer une instance de Zend_Config ou un tableau avec la clé 'charlist'. Les méthodes setCharList() et getCharList() sont aussi disponibles.