Previous Next

Classes de filtre standards

Zend Framework est fourni avec un jeu de filtres standards, qui sont directement utilisables.

Alnum

Zend_Filter_Alnum est un filtre qui ne retourne que des caractères alphabétiques et des chiffres. Tout autre caractère est supprimé.

Options supportées par Zend_Filter_Alnum

Les options suivantes sont supportées par Zend_Filter_Alnum:

  • allowwhitespace: Si activée, les espaces seront autorisés, autrement ils sont supprimés. Par défaut, les espaces ne sont pas autorisés et supprimés.

Utilisation de base

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.

Note:

Zend_Filter_Alnum fonctionne sur presque tous les langages. Les exceptions sont le chinois, le japonnais et le coréen. Ces langues utiliseront l'alphabet anglais plutot que le leur. Le langage est détecté par Zend_Locale.

Autoriser les espaces

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

Alpha

Zend_Filter_Alpha est un filtre qui va retourner $value en enlevant tout caractère non alphabétique. Ce filtre propose une option pour autoriser le caractère espace.

Options supportées par Zend_Filter_Alpha

Les options suivantes sont supportées par Zend_Filter_Alpha:

  • allowwhitespace: Si activée, les espaces seront autorisés. Par défaut, ils sont supprimés.

Utilisation de base

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.

Note:

Zend_Filter_Alpha fonctionne sur presque tous les langages. Les exceptions sont le chinois, le japonnais et le coréen. Ces langues utiliseront l'alphabet anglais plutot que le leur. Le langage est détecté par Zend_Locale.

Autoriser les espaces

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

BaseName

Zend_Filter_BaseName permet de retourner le nom d'un fichier dans une chaine représentant un chemin vers ce fichier.

Options supportées par Zend_Filter_BaseName

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

Utilisation de base

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

Boolean

Ce filtre transforme toute donnée en valeur BOOLEENNE. Ce peut être utile en travaillant avec des bases de données ou des formulaires.

Comportement par défaut de Zend_Filter_Boolean

Par défaut, ce filtre caste (transtype) sa valeur vers un BOOLEEN ; en d'autres termes, il fonctionne comme un appel PHP (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 cast PHP vers le BOOLEEN.

Changer le comportement de Zend_Filter_Boolean

Quelques fois, le cast vers 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 :

  • booléen : retourne la valeur booléenne telle quelle.

  • entier : convertit l'entier 0 en FALSE.

  • flottant : convertit le flottant 0.0 en FALSE.

  • chaine : convertit la chaîne vide '' en FALSE.

  • zero : convertit la chaîne contenant zéro ('0') en FALSE.

  • empty_array : convertit le tableau vide array() en FALSE.

  • null : convertit une valeur NULL en FALSE.

  • php : convertit une valeur, comme PHP le ferait, en BOOLEEN.

  • false_string : convertit une chaine contenant le mot "false" en booléen FALSE.

  • yes : convertit une chaîne localisée contenant le mot "no" en FALSE.

  • all: Convertit tous les types ci-dessus vers un BOOLEEN.

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

Booléens localisés

Comme déja précisé, Zend_Filter_Boolean reconnait 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');

Désactiver le cast (transtypage)

Il peut arriver de ne vouloir que reconnaitre 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.

Utilisation sans transtypage
Type True False
Zend_Filter_Boolean::BOOLEAN TRUE FALSE
Zend_Filter_Boolean::INTEGER 0 1
Zend_Filter_Boolean::FLOAT 0.0 1.0
Zend_Filter_Boolean::STRING ""  
Zend_Filter_Boolean::ZERO "0" "1"
Zend_Filter_Boolean::EMPTY_ARRAY array()  
Zend_Filter_Boolean::NULL NULL  
Zend_Filter_Boolean::FALSE_STRING "false" (non sensible à la casse) "true" (non sensible à la casse)
Zend_Filter_Boolean::YES "oui" localisé (non sensible à la casse) "non" localisé (non sensible à la casse)

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

Callback

Ce filtre vous permet d'utiliser votre propre fonction en tant que filtre de Zend_Filter. Nul besoin de créer un filtre si une fonction ou méthode fait déja le travail.

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

Note:

Notez que passer une fonction qui ne peut être appelée mènera à une exception.

Compression et décompression

Ces deux filtres sont capables de compresser et décompresser des chaines, des fichiers ou des dossiers. Ils utilisent des adaptateurs dans ce but et supportent les formats suivants:

  • Bz2

  • Gz

  • Lzf

  • Rar

  • Tar

  • Zip

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)

Les bases

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

Note: Adaptateur de compression par défaut

Lorsque vous ne précisez aucun adaptateur, Gz sera utilisé par défaut.

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

Note: Note sur la compression de chaines

Tous les adaptateurs ne supportent pas la compression de chaines. Les formats tels que Rar ne savent que traiter des fichiers ou des répertoires. Pour les détails, consultez la documentation relative à l'adaptateur en question.

Créer une archive

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.

Note: Les archives existantes seront écrasées

Si l'archive existe déja, elle sera écrasée.

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

Note: Ne compressez pas un dossier trop gros ou trop profond

Vous ne devriez jamais tenter de compresser un dossier trop gros ou trop profond, comme par exemple une partition complète. Une telle opération s'avère très longue et très couteuse en ressources ce qui peut provoquer des problèmes sur votre serveur.

Décompresser une 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é

Note: Les dossiers de cible doivent exister

Lorsque vous souhaitez décompresser une archive dans un dossier cible, vérifiez bien que celui-ci existe déja.

Adaptateur Bz2

L'adaptateur Bz2 peut compresser et décompresser:

  • Chaines

  • Fichiers

  • Dossiers

Cet adaptateur utilise l'extension PHP Bz2.

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

  • Archive: Précise l'archive à utiliser ou à créer.

  • Blocksize: Précise la taille des blocs. Des valeurs de '0' à '9' sont permises. La valeur par défaut est '4'.

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

Adaptateur Gz

L'adaptateur Bz2 peut compresser et décompresser:

  • Chaines

  • Fichiers

  • Dossiers

Cet adaptateur utilise l'extension PHP Zlib.

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

  • Archive: L'archive à créer ou à utiliser.

  • Level: Niveau de compression. Des valeurs de '0' à '9' sont utilisables, par défaut : '9'.

  • Mode: Il existe deux modes supportés : 'compress' et 'deflate'. La valeur par défaut est 'compress'.

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.

Adaptateur Lzf

L'adaptateur Lzf peut compresser et décompresser:

  • Chaines

Note: Lzf ne supporte que les chaines de caractères

Lzf ne supporte pas les fichiers et les dossiers.

Cet adaptateur utilise l'extension PHPLzf.

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

Adaptateur Rar

L'adaptateur Rar peut compresser et décompresser:

  • Fichiers

  • Dossiers

Note: Rar ne supporte pas les chaines de caractères

L'adaptateur Rar ne supporte pas les chaines de caractères

Cet adaptateur utilise l'extension PHP Rar.

Note: Compression Rar non supportée

Des restrictions du format Rar ne permettent pas la compression gratuite. Si vous souhaitez compresser avec cet adaptateur, vous devrez passer une fonction de callback qui utilisera un algorithme ou fera appel à un programme externe.

Cet adaptateur accepte les options suivantes:

  • Archive: Précise l'archive à créer ou à utiliser.

  • Callback: Une fonction de callback fournissant des services de compression à l'adaptateur.

  • Password: Le mot de passe à utiliser éventuellement en cas de décompression.

  • Target: La cible vers laquelle les fichiers décompressés seront écrits.

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.

Tar Adapter

L'adaptateur Tar peut compresser et décompresser:

  • Fichiers

  • Dossiers

Note: Tar ne supporte pas les chaines de caractères

L'adaptateur Tar ne supporte pas les chaines de caractères

Cet adaptateur utilise le paquet PEAR Archive_Tar.

Cet adaptateur accepte les options suivantes:

  • Archive: Précise l'archive à utiliser ou à créer.

  • Mode: Mode de compression. Les modes supportés sont 'null' qui signifie pas de compression, 'Gz' qui utilisera l'extension PHP Zlib et 'Bz2' qui utilisera l'extension PHPBz2. La valeur par défaut est 'null'.

  • Target: La cible vers laquelle les fichier décompressés seront écrits.

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.

Note: Utilisation avec des dossiers

La compression des dossiers avec Tar utilise le chemin complet comme nom de fichier.

Adaptateur Zip

L'adaptateur Zip peut compresser et décompresser:

  • Chaines

  • Fichiers

  • Dossiers

Note: Zip ne supporte pas la décompression vers des chaines

L'adaptateur Zip ne supporte pas la décompression vers des chaines. Un fichier sera systématiquement crée.

Cet adaptateur utilise l'extension PHP Zip.

Les options suivantes sont supportées :

  • Archive: Précise l'archive qui sera utilisée ou créee.

  • Target: La cible vers laquelle décompresser.

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.

Decrypt

Ce filtre va décrypter toute chaine grâce aux paramètres utilisés. Des adaptateurs sont utilisés. Actuellement des aptateurs existent pour les extensions Mcrypt et OpenSSL de php.

Pour plus de détails sur l'encryptage de contenu, voyez le filtre Encrypt. La documentation de celui-ci couvre les bases en matière de cryptage, nous n'aborderons ici que les méthodes utilisées pour le décryptage.

Décryptage avec Mcrypt

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;

Note:

Si l'extension mcrypt n'est pas présente dans votre environement, une exception sera levée.

Note:

Vos paramètres sont vérifiés à la création de l'instance ou à l'appel de setEncryption(). Si mcrypt détecte des problèmes avec ces paramètres, une exception sera levée.

Decryptage avec OpenSSL

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:

  • private: votre clé privée. Ce peut être un nom de fichier ou juste le contenu de ce fichier : la clé.

  • envelope: la clé enveloppe cryptée de l'utilisateur qui a crypté le document. Un chemin de fichier ou une chaine peuvent être utilisés. Lorsque l'option package est paramétrée, vous pouvez omettre ce paramètre.

  • package: si la clé enveloppe a été empaqueté avec la valeur encryptée. Par défaut vaut FALSE.

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

Note:

L'adaptateur OpenSSL ne fonctionnera pas avec des clés non valides.

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;

Digits

Retourne la chaine $value, mais uniquement les chiffres la composant.

Options supportées par Zend_Filter_Digits

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

Utilisation de base

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

Dir

Ce filtre retournera le dossier dans une chaine représentant le chemin vers un fichier.

Options supportées par Zend_Filter_Dir

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

Utilisation de base

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

Encrypt

Ce filtre va crypter toute chaine avec les paramètres spécifiés. Des adaptateurs sont utilisés. Actuellement, il existe des adaptateurs pour les extensions PHP Mcrypt et OpenSSL.

Comme ces deux méthodes d'encryptage sont très différentes, l'utilisation de leurs adaptateurs l'est aussi.

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

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

Les méthodes setAdapter() et getAdapter() existent aussi.

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

Note:

Si vous ne précisez pas d'adaptateur, Mcrypt est utilisé par défaut.

Cryptage avec Mcrypt

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

  • key: La clé d'encryptage. Cette même clé sera nécessaire pour le décryptage.

  • algorithm: L'algorithme à utiliser pour le cryptage. Voyez » PHP's mcrypt ciphers. Si non précisé, blowfish sera utilisé par défaut.

  • algorithm_directory: Le dossier dans lequel se trouve l'algorithme. Si non précisé, le dossier spécifié par l'extension mcrypt est alors utilisé.

  • mode: Le mode de cryptage à utiliser. Un des » modes mcrypt doit être utilisé. Par défaut, cbc est utilisé.

  • mode_directory: Le dossier dans lequel se trouve le mode. Si non précisé, le dossier spécifié par l'extension mcrypt est alors utilisé.

  • vector: Le vecteur d'initialisation à utiliser. Un vecteur aléatoire est utilisé si non précisé.

  • salt: Si la clé doit être utilisé comme grain de sel. Dans ce cas la clé utilisée pour le cryptage sera elle même cryptée. Par défaut false : ce n'est pas le cas.

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.

Note:

Une exception sera levée si l'extension PHP mcrypt n'est pas disponible.

Note:

Notez aussi que tous vos paramètres utilisés à la création de l'instance ou avec setEncryption() vont être vérifiés. Si mcrypt détecte un problème, une exception sera levée.

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.

Note:

Notez que si vous n'utilisez pas un vecteur spécifique, alors vous devrez le récupérer et le stocker. En effet, celui-ci est indispensable pour décoder la valeur dans le futur.

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

Cryptage avec OpenSSL

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

  • public: La clé publique de l'utilisateur auquel vous voulez proposer du contenu crypté. Plusieurs clés peuvent être spécifiées via un tableau. Il est possible de préciser le contenu de la clé, ou alors un chemin vers une clé.

  • private: Votre clé privée utilisée pour crypter le contenu. La encore la clé peut être précisée sous forme textuelle, ou alors un chemin vers un fichier contenant la clé.

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

Note:

Attention l'adaptateur OpenSSL ne fonctionnera pas si vous ne passez pas des clés valides.

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

HtmlEntities

Retourne la chaine $value en convertissant les caractères en leur entité HTML équivalente si elle existe.

Options gérées par Zend_Filter_HtmlEntities

Les options suivantes sont supportées par Zend_Filter_HtmlEntities:

  • quotestyle: Equivalent au paramètre quote_style de la fonction PHP htmlentities. Ceci permet de définir ce qui sera fait avec les 'simples' et "doubles" quotes. Les constantes suivantes sont acceptées: ENT_COMPAT, ENT_QUOTES ENT_NOQUOTES, par défaut il s'agira de ENT_COMPAT.

  • charset: Equivalent au paramètre charset de la fonction PHP htmlentities. Ceci indique le jeu de caractères à utiliser pour le filtre. Contrairement à la fonction PHP native, la valeur par défaut est 'UTF-8'. Voyez "http://php.net/htmlentities" pour la liste des jeux de caractères supportés.

    Note:

    Cette option peut être passées via le paramètre $options comme un tableau ou objet Zend_Config. L'encodage ou le jeu de caractères seront reconnus.

  • doublequote: Equivalent au paramètre double_encode de la fonction PHP htmlentities. Si passé à false, les entités html existantes ne seront pas encodées. Par défaut sur true (conversion totale).

    Note:

    Cette option peut être passée via le paramètre $options ou la méthode setDoubleEncode().

Utilisation de base

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

$filter = new Zend_Filter_HtmlEntities();

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

Styles de quote

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.

Méthodes d'aide

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

Int

Zend_Filter_Int permet de transformer une valeur scalaire contenant un chiffre en entier.

Options supportées par Zend_Filter_Int

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

Utilisation de base

Voici un exemple de base:

$filter = new Zend_Filter_Int();

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

Ceci affichera '-4'.

LocalizedToNormalized

Ce filtre va transformer toute entrée localisée en sa représentation normalisée. La transformation est effectuée grâce à Zend_Locale en interne.

Ceci permet à l'utilisateur de saisir des information dans sa propre locale, et du coté serveur de stocker les informations normalisées relatives.

Note:

Attention la normalisation n'est pas de la traduction. Ce filtre ne sait pas traduire des chaines d'un langage à un autre.

Les types suivants peuvent être normalisés:

  • entiers: Nombres entiers localisés. Ils seront normalisés dans la notation anglaise internationnale.

  • float: Nombres flottants. Ils seront normalisés dans la notation anglaise internationnale.

  • nombres: Nombres réels. Ils seront normalisés dans la notation anglaise internationnale.

  • time: Valeurs de temps. Normalisées sous forme de tableaux.

  • date: Valeurs de date. Normalisées sous forme de tableaux.

Tout autre type d'entrée sera retourné tel quel, sans tranformation, par ce filtre.

Note:

Notez bien que toute sortie normalisée de ce filtre est de type chaine de caractères.

Normaliser des nombres

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:

  • date_format

  • locale

  • precision

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'

Normaliser des dates et des temps

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

NormalizedToLocalized

Ce filtre est l'inverse de Zend_Filter_LocalizedToNormalized et convertira toute entrée normalisée en entrée localisée. Il utilise Zend_Locale pour celà.

Ceci permet de représenter une valeur normalisée dans la locale de l'utilisateur, qu'il reconnaitra donc sans problème.

Note:

Notez bien que la localisation n'est pas de la traduction, ce filtre ne sait pas traduire des chaines d'une langue à l'autre (comme des noms de jours ou de mois).

Les types suivants peuvent être localisés:

  • entiers: Nombres entiers.

  • float: Nombres flottants.

  • nombres: Autres nombres, comme les réels.

  • temps: Valeurs de temps, localisées sous forme de chaines.

  • date: Valeurs de dates, localisées sour forme de chaines.

Tout autre type d'entrée sera retourné tel quel, sans transformation.

Localisation des nombres

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:

  • date_format

  • locale

  • precision

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'

Localiser des dates et des temps

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'

Null

Ce filtre retournera la valeur NULL si des critères précis sont rencontrés. C'est souvent nécessaire lorsqu'on travaille avec des bases de données et que l'on souhaite une valeur NULL plutôt qu'un booléen ou tout autre type.

Comportement par défaut de Zend_Filter_Null

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.

Changer le comportement de Zend_Filter_Null

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:

  • booleen: Convertit le booléen FALSE en NULL.

  • entier: Convertit l'entier 0 en NULL.

  • tableau_vide: Convertit le tableau vide en NULL.

  • chaine: Convertit la chaine vide '' en NULL.

  • zero: Convertit la chaine zéro ('0') en NULL.

  • tout: Convertit tous les types cités en NULL. (comportement par défaut).

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.

PregReplace

Zend_Filter_PregReplace performs a search using regular expressions and replaces all found elements.

The option match has to be given to set the pattern which will be searched for. It can be a string for a single pattern, or an array of strings for multiple pattern.

To set the pattern which will be used as replacement the option replace has to be used. It can be a string for a single pattern, or an array of strings for multiple pattern.

$filter = new Zend_Filter_PregReplace(array('match' => '/bob/',
                                            'replace' => 'john'));
$input  = 'Hy bob!';

$filter->filter($input);
// returns 'Hy john!'

You can use getMatchPattern() and setMatchPattern() to set the matching pattern afterwards. To set the replacement pattern you can use getReplacement() and setReplacement().

$filter = new Zend_Filter_PregReplace();
$filter->setMatchPattern(array('bob', 'Hy'))
       ->setReplacement(array('john', 'Bye'));
$input  = 'Hy bob!";

$filter->filter($input);
// returns 'Bye john!'

For a more complex usage take a look into PHP's » PCRE Pattern Chapter.

RealPath

Ce filtre va résoudre un lien ou un chemin en chemin absolu canonique. Toutes références à '/./', '/../' et tout ajout supplémentaire de '/' sera résolu ou supprimé. Aucun caractère de lien symbolique ne sera présent dans le résultat ('/./' ou '/../')

Zend_Filter_RealPath retourne FALSE en cas d'echec par exemple si le fichier n'existe pas. Sur les systems BSD, Zend_Filter_RealPath n'échoue pas si seule la dernière partie du chemin n'existe pas, les autres systèmes retourneront FALSE.

$filter = new Zend_Filter_RealPath();
$path   = '/www/var/path/../../mypath';
$filtered = $filter->filter($path);

// retourne '/www/mypath'

Il peut être nécessaire quelques fois de vouloir utiliser ce filtre sur des chemins inexistants. Par exemple récupérer le realpath d'un chemin à créer. Dans ce cas vous pouvez passer FALSE au constructeur, ou utiliser setExists().

$filter = new Zend_Filter_RealPath(false);
$path   = '/www/var/path/../../non/existing/path';
$filtered = $filter->filter($path);

// retourne '/www/non/existing/path' même si file_exists ou realpath retourneraient false

StringToLower

Ce filtre convertit toute entrée vers des caractères minuscules.

$filter = new Zend_Filter_StringToLower();

print $filter->filter('SAMPLE');
// retourne "sample"

Par défaut, seul le jeu de caractères de la locale en cours sera utilisé. Les caractères provenant d'autres jeux seront ignorés. Cela reste possible de les passer en minuscules si l'extension mbstring est présente dans votre environnement PHP. Indiquez l'encodage voulu à la création du filtre StringToLower ou utilisez sa méthode setEncoding().

// utiliser UTF-8
$filter = new Zend_Filter_StringToLower('UTF-8');

// ou passer un tableau
$filter = new Zend_Filter_StringToLower(array('encoding' => 'UTF-8'));

// ou encore faire cela après coup
$filter->setEncoding('ISO-8859-1');

Note: Préciser des mauvais encodages

Attention une exception sera levée si vous précisez un encodage alors que l'extension mbstring est absente.

Une exception sera de même levée si l'encodage que vous précisez n'est pas pris en compte par mbstring.

StringToUpper

Ce filtre convertit toute entrée vers une casse majuscule.

$filter = new Zend_Filter_StringToUpper();

print $filter->filter('Sample');
// retourne "SAMPLE"

Tout comme le filtre StringToLower, seul le jeu de caractères de la locale en cours sera utilisé. Son fonctionnement est le même que celui de StringToLower.

$filter = new Zend_Filter_StringToUpper(array('encoding' => 'UTF-8'));

// ou encore
$filter->setEncoding('ISO-8859-1');

StringTrim

Ce filtre modifie la chaine pour que certains caractères soient supprimés du début et de la fin de la chaine.

Options supportées par Zend_Filter_StringTrim

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

  • charlist: Liste de caractères à supprimer du début et de la fin de la chaine. Si non précisé, le comportement par défaut sera de supprimer les espaces du début et de la fin de la chaine.

Utilisation de base

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.

Comportement par défaut de Zend_Filter_StringTrim

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

Int

Retourne la valeur $value en enlevant les caractères représentant une nouvelle ligne.

StripTags

Ce filtre retourne une chaîne, où toutes les balises HTML et PHP sont supprimées, exceptées celles qui sont explicitement autorisées. En plus de pouvoir spécifier quelles balises sont autorisées, les développeurs peuvent spécifier quels attributs sont autorisés soit pour toutes les balises autorisées soit pour des balises spécifiques seulement.

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