Previous Next

Classes de validation standard

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

Alnum

Retourne true si et seulement si $value contient seulement des caractères alphabétiques et numériques. Ce validateur inclue une option permettant la validation possible des caractères espace.

Alpha

Retourne true si et seulement si $value contient seulement des caractères alphabétiques. Ce validateur inclue une option permettant la validation possible des caractères espace.

Note:

Les caractères alphabétiques comprennent les caractères destinés à constituer des mots dans chaque langue. Cependant l'alphabet anglais est aussi utilisé pour les langues suivantes : chinois, japonais et coréen. La langue est spécifiée par Zend_Locale.

Barcode

Ce validateur est instancié avec le type de code-barres suivant lequel vous souhaitez valider une valeur. Il supporte actuellement les types de code-barres "UPC-A" (Universal Product Code) et "EAN-13" (European Article Number), et la méthode isValid() retourne true si et seulement si la valeur fournie est validée par l'algorithme de validation du code-barres. Vous devez retirer tous les caractères exceptés les nombres compris entre zéro et neuf (0-9) de la valeur à tester avant de la fournir au validateur.

Between

Retourne true si et seulement si $value est compris entre les valeurs minimum et maximum définies. La comparaison inclue par défaut les bornes ($value peut égaler le minimum ou le maximum), bien que ceci puisse être surchargé pour avoir une comparaison stricte, où $value doit être strictement supérieur au minimum et strictement inférieur au maximum.

Ccnum

Retourne true si et seulement si $value respecte » l'algorithme de Luhn ("module 10") pour les numéros de cartes de crédits.

Date

Retourne true si $value est une date valide au format YYYY-MM-DD. Si l'option locale est fournie alors la date sera validé suivant le paramètre local. Enfin si l'option format est fournie ce format est utilisé pour la validation. Pour plus de détails concernant les paramètres optionnel, referez vous à Zend_Date::isDate().

Db_RecordExists and Db_NoRecordExists

Zend_Validate_Db_RecordExists and Zend_Validate_Db_NoRecordExists provide a means to test whether a record exists in a given table of a database, with a given value.

Basic usage

An example of basic usage of the validators:

//Check that the email address exists in the database
$validator = new Zend_Validate_Db_RecordExists('users', 'emailaddress');
if ($validator->isValid($emailaddress)) {
    // email address appears to be valid
} else {
    // email address is invalid; print the reasons
    foreach ($validator->getMessages() as $message) {
        echo "$message\n";
    }
}

The above will test that a given email address is in the database table. If no record is found containing the value of $emailaddress in the specified column, then an error message is displayed.

//Check that the username is not present in the database
$validator = new Zend_Validate_Db_NoRecordExists('users', 'username');
if ($validator->isValid($username)) {
    // username appears to be valid
} else {
    // username is invalid; print the reason
    $messages = $validator->getMessages();
    foreach ($messages as $message) {
        echo "$message\n";
    }
}

The above will test that a given username is not in the database table. If a record is found containing the value of $username in the specified column, then an error message is displayed.

Excluding records

Zend_Validate_Db_RecordExists and Zend_Validate_Db_NoRecordExists also provide a means to test the database, excluding a part of the table, either by providing a where clause as a string, or an array with the keys "field" and "value".

When providing an array for the exclude clause, the != operator is used, so you can check the rest of a table for a value before altering a record (for example on a user profile form)

//Check no other users have the username
$user_id   = $user->getId();
$validator = new Zend_Validate_Db_NoRecordExists(
    'users',
    'username',
    array(
        'field' => 'id',
        'value' => $user_id
    )
);

if ($validator->isValid($username)) {
    // username appears to be valid
} else {
    // username is invalid; print the reason
    $messages = $validator->getMessages();
    foreach ($messages as $message) {
        echo "$message\n";
    }
}

The above example will check the table to ensure no records other than the one where id = $user_id contains the value $username.

You can also provide a string to the exclude clause so you can use an operator other than !=. This can be useful for testing against composite keys.

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

if ($validator->isValid($username)) {
    // username appears to be valid
} else {
    // username is invalid; print the reason
    $messages = $validator->getMessages();
    foreach ($messages as $message) {
        echo "$message\n";
    }
}

The above example will check the posts_categories table to ensure that a record with the post_id has a value matching $category_id

Database Adapters

You can also specify an adapter, as the fourth parameter when instantiating your validator, this will allow you to work with applications using multiple database adapters, or where you have not set a default adapter. As in the example below:

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

Digits

Retourne true si et seulement si $value contient seulement des caractères numériques.

EmailAddress

Zend_Validate_EmailAddress permet de valider une adresse émail. Ce validateur éclate d'abord l'adresse émail entre partie locale et domaine et essaie de valider ces deux parties conformément aux spécifications des adresses émail et des noms de domaine.

Utilisation de base

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

Parties locales complexes

Zend_Validate_EmailAddress validera toute adresse émail conforme à la RFC2822. Comme par exemple bob@domaine.com, bob+jones@domaine.fr, "bob@jones"@domaine.com et "bob jones"@domaine.com. Quelques formats d'émail obsolètes ne seront pas validés (comme tout émail contenant un retour chariot ou un caractère "\").

Validation de différents types de noms de domaine

La partie domaine d'une adresse émail est validée via Zend_Validate_Hostname. Par défaut, seules les domaines qualifiés sous la forme domaine.com sont acceptés, même si, il vous est possible d'accepter les adresses IP et les domaines locaux également.

Afin de réaliser cette opération, il vous faut instancier Zend_Validate_EmailAddress en lui passant un paramètre indiquant le type de nom de domaine à accepter. Les détails sont disponibles dans Zend_Validate_EmailAddress mais vous trouverez ci-dessous un exemple illustrant comment accepter les noms de domaines qualifiés et les hôtes locaux :

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

Vérification que le nom de domaine accepte réellement l'émail

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

Valider les noms de domaines internationaux

Zend_Validate_EmailAddress peut aussi vérifier les caractères internationaux qui existent dans quelques domaines. Ceci est connu comme le support de Nom de Domaine International (IDN). Celui-ci est activé par défaut, quoique vous puissiez le mettre hors service en changeant le paramètre via l'objet interne Zend_Validate_Hostname qui existe dans Zend_Validate_EmailAddress.

$validator->hostnameValidator->setValidateIdn(false);
De plus amples informations concernant l'utilisation de setValidateIdn() sont présentes dans la documentation de Zend_Validate_Hostname.

Notez cependant que les IDNs sont seulement validés si vous autorisez la validation des nom de domaines.

Validation des "Top Level Domains"

Par défaut un nom de domaine sera vérifié grâce à une liste de TLDs connus. Ceci est activé par défaut, quoique vous puissiez le mettre hors service en changeant le paramètre via l'objet Zend_Validate_Hostname interne qui existe dans Zend_Validate_EmailAddress.

$validator->hostnameValidator->setValidateTld(false);
De plus amples informations concernant l'utilisation de setValidateTld() sont présentes dans la documentation de Zend_Validate_Hostname.

Notez cependant que les TLDs sont seulement validés si vous autorisez la validation des nom de domaines.

Float

Retourne true si et seulement si $value est une valeur en virgule flottante. A partir de Zend Framework 1.8 ce validateur prend en considération la locale courante issue du navigateur, de l'environnement ou de l'application. Vous pouvez bien sûr utiliser les accesseurs get/setLocale pour changer ou la fournir au moment de la création de l'instance de ce validateur.

GreaterThan

Retourne true si et seulement si $value est supérieure à une valeur minimum fournie.

Hex

Retourne true si et seulement si $value contient seulement des caractères numériques hexadécimaux.

Hostname

Zend_Validate_Hostname vous permet de valider un nom de domaine sur la base d'un ensemble de spécifications connues. Il est ainsi possible de valider trois types différents de noms de domaine : un nom de domaine qualifié (ex : domaine.com), une adresse IP (ex : 1.2.3.4) ou un nom de domaine local (ex : localhost). Par défaut, seul les noms de domaine qualifiés sont acceptés.

Utilisation basique

Exemple simple :

$validateur = new Zend_Validate_Hostname();
if ($validateur->isValid($domaine)) {
    // le nom de domaine est valide
} else {
    // le nom de domaine est invalide ; afficher pourquoi
    foreach ($validateur->getMessages() as $message) {
        echo "$message\n";
    }
}
Ceci validera le domaine $domaine et, en cas d'échec, fournira des messages d'erreur informatifs via $validator->getMessages().

Validation de différents types de noms de domaine

Il peut se trouver que vous souhaitez valider des adresses IP, des noms de domaine locaux ou toute combinaison de tous les types disponibles. Cette opération peut être effectuée en passant un paramètre à Zend_Validate_Hostname au moment de l'instanciation. Le paramètre doit être un entier qui détermine quels types de noms de domaine sont admis. Il est recommandé d'utiliser les constantes de la classe Zend_Validate_Hostname.

Les constantes de Zend_Validate_Hostname sont : ALLOW_DNS qui autorise uniquement les noms de domaine qualifiés, ALLOW_IP qui autorise les adresses IP, ALLOW_LOCAL qui autorise les domaines locaux et ALLOW_ALL qui autorise les trois types précédents. Pour vérifier uniquement les adresses IP, vous pouvez utiliser l'exemple suivant :

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

Vous pouvez utiliser ALLOW_ALL pour accepter tous les types de domaines. De même, vous pouvez créer des configurations combinant ces différents types. Par exemple, pour accepter les domaines qualifiés et les domaines locaux, instanciez votre objet Zend_Validate_Hostname de la manière suivante :

$validateur = new Zend_Validate_Hostname(Zend_Validate_Hostname::ALLOW_DNS |
                                         Zend_Validate_Hostname::ALLOW_IP);

Validation de Nom de Domaine International (IDN)

Certains noms de domaines nationaux (Country Code Top Level Domains ou ccTLD), comme .de (Allemagne), supporte les caractères internationaux dans leurs noms de domaine. Ceci est connu sous le nom de Nom de Domaine International (IDN). Ces domaines peuvent être vérifiés par Zend_Validate_Hostname grâce aux caractères étendus qui sont utilisés dans le processus de validation.

Pour l'instant, la liste des ccTLD supportés inclus :

  • at (Autriche)

  • ch (Suisse)

  • li (Liechtenstein)

  • de (Allemagne)

  • fi (Finlande)

  • hu (Hongrie)

  • no (Norvège)

  • se (Suède)

Pour vérifier un domaine IDN c'est aussi simple que d'utiliser le validateur standard de nom de domaine puisque la validation IDN est activé par défaut. Si vous voulez mettre hors service la validation IDN, cela peut être fait par le passage d'un paramètre au constructeur Zend_Validate_Hostname ou via la méthode $validator->setValidateIdn().

Vous pouvez aussi désactiver la validation IDN en passant un second paramètre au constructeur du Zend_Validate_Hostname comme ceci :

$validator = new Zend_Validate_Hostname(Zend_Validate_Hostname::ALLOW_DNS,
                                        false);
Alternativement vous pouvez passer soit true soit false à $validator->setValidateIdn() pour activer ou désactiver la validation IDN. Si vous essayez de vérifier un nom de domaine IDN qui n'est pas actuellement soutenu il est probable qu'il retournera une erreur s'il y a des caractères internationaux. Quand un fichier de ccTLD spécifiant les caractères supplémentaires n'existe pas dans "Zend/Validate/Hostname",une validation de nom de domaine normale est réalisée.

Notez cependant que les IDNs sont seulement validés si vous autorisez la validation des noms de domaine.

Validation des "Top Level Domains"

Par défaut un nom de domaine sera vérifié grâce à une liste de TLDs connus. Si cette fonctionnalité n'est pas nécessaire, elle peut être désactivée de la même façon que la désactivation du support des IDNs. Vous pouvez désactiver la validation TLD en passant un troisième paramètre au constructeur de Zend_Validate_Hostname. Dans l'exemple ci-dessous, la validation IDN est supportée via le second paramètre.

$validator = new Zend_Validate_Hostname(Zend_Validate_Hostname::ALLOW_DNS,
                                        true,
                                        false);
Alternativement vous pouvez passer soit true soit false à $validator->setValidateTld() pour activer ou désactiver la validation TLD.

Notez cependant que les TLDs sont seulement validés si vous autorisez la validation des noms de domaine.

Iban

Retourne true si et seulement si $value contient un IBAN valide (International Bank Account Number = Numéro de compte bancaire international). Les numéros IBAN sont validés suivant le pays dans lequel ils sont utilisés et par un somme de contrôle.

Il existe deux manières de valider les numéros IBAN. En premier lieu, vous pouvez fournir une locale qui représente un pays. Tout numéro IBAN fourni sera donc validé suivant ce pays.

$validator = new Zend_Validate_Iban('de_AT');
$iban = 'AT611904300234573201';
if ($validator->isValid($iban)) {
    // IBAN paraît être valide
} else {
    // IBAN est invalide
    foreach ($validator->getMessages() as $message) {
        echo "$message\n";
    }
}

Vous pouvez aussi vouloir valider les numéros IBAN pour des pays uniques. La manière la plus simple est donc de ne pas fournir de locale comme dans l'exemple suivant.

$validator = new Zend_Validate_Iban();
$iban = 'AT611904300234573201';
if ($validator->isValid($iban)) {
    // IBAN paraît être valide
} else {
    // IBAN est invalide
}

Mais ceci montre un gros problème : si vous ne devez accepter que les numéros IBAN que pour un pays en particulier, par exemple l'Allemagne, alors les numéros IBAN des autres pays seront aussi valides. Dans ce cas, souvenez vous d'une chose : quand vous devez valider un numéro IBAN pour un pays donné, vous avez juste à fournir la locale correspondante. Et quand vous acceptez tous les numéros IBAN sans restriction de pays, enlevez simplement cette locale.

InArray

Retourne true si et seulement si $value est contenue dans un tableau. Si l'option stricte est à true, alors le type de $value est aussi vérifié.

Int

Retourne true si et seulement si $value est une valeur entière. A partir de Zend Framework 1.8 ce validateur prend en considération la locale courante issue du navigateur, de l'environnement ou de l'application. Vous pouvez bien sûr utiliser les accesseurs get/setLocale pour changer ou la fournir au moment de la création de l'instance de ce validateur.

Ip

Retourne true si et seulement si $value est une adresse IP valide.

LessThan

Retourne true si et seulement si $value est inférieure à une valeur maximum fournie.

NotEmpty

Retourne true si et seulement si $value est une valeur non vide.

Regex

Retourne true si et seulement si $value respecte une expression régulière fournie.

Sitemap Validators

The following validators conform to the » Sitemap XML protocol.

Sitemap_Changefreq

Validates whether a string is valid for using as a 'changefreq' element in a Sitemap XML document. Valid values are: 'always', 'hourly', 'daily', 'weekly', 'monthly', 'yearly', or 'never'.

Returns true if and only if the value is a string and is equal to one of the frequencies specified above.

Sitemap_Lastmod

Validates whether a string is valid for using as a 'lastmod' element in a Sitemap XML document. The lastmod element should contain a W3C date string, optionally discarding information about time.

Returns true if and only if the given value is a string and is valid according to the protocol.

Example #1 Sitemap Lastmod Validator

$validator = new Zend_Validate_Sitemap_Lastmod();

$validator->isValid('1999-11-11T22:23:52-02:00'); // true
$validator->isValid('2008-05-12T00:42:52+02:00'); // true
$validator->isValid('1999-11-11'); // true
$validator->isValid('2008-05-12'); // true

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

Sitemap_Loc

Validates whether a string is valid for using as a 'loc' element in a Sitemap XML document. This uses Zend_Form::check() internally. Read more at URI Validation.

Sitemap_Priority

Validates whether a value is valid for using as a 'priority' element in a Sitemap XML document. The value should be be a decimal between 0.0 and 1.0. This validator accepts both numeric values and string values.

Example #2 Sitemap Priority Validator

$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

StringLength

Retourne true si et seulement si la longueur de la chaîne $value est supérieure à une valeur minimum et inférieure à une valeur maximum (quand l'option max n'est pas à null). La méthode setMin() lève une exception si la valeur fournie pour la longueur minimum est supérieure à celle fournie pour la longueur maximum, et la méthode setMax() lève une exception si la valeur fournie pour la longueur maximum est supérieure à celle fournie pour la longueur minimum. Cette classe supporte l'UTF-8 et les autres encodages, en se basant sur la valeur courante de »  iconv.internal_encoding . Si vous avez besoin de régler un autre encodage, vous pouvez le faire avec les accesseurs getEncoding() et setEncoding().

Previous Next
Introduction to Zend Framework
Présentation
Installation
Zend_Acl
Introduction
Affiner les Contrôles d'Accès
Utilisation avancée
Zend_Amf
Introduction
Zend_Amf_Server
Zend_Application
Introduction
Zend_Application Quick Start
Théorie générale
Exemples
Core Functionality
Available Resource Plugins
Zend_Auth
Introduction
Authentification avec une table de base de données
Authentification "Digest"
Adaptateur d'authentification HTTP
LDAP Authentication
Authentification OpenID
Zend_Cache
Introduction
Aspect théorique
Les frontends Zend_Cache
Les backends Zend_Cache
Zend_Captcha
Introduction
Opération Captcha
Adaptateurs CAPTCHA
Zend_CodeGenerator
Introduction
Exemples Zend_CodeGenerator
Zend_CodeGenerator Réference
Zend_Config
Introduction
Aspect théorique
Zend_Config_Ini
Zend_Config_Xml
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
Migrer depuis des versions précédentes
Zend_Currency
Introduction à Zend_Currency
How to Work with Currencies
Migrer depuis des versions antérieures
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_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_Dom
Introduction
Zend_Dom_Query
Zend_Exception
Utiliser les exceptions
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_File
Zend_File_Transfer
Validateurs pour Zend_File_Transfer
Filtres pour Zend_File_Transfer
Migrer à partir des versions précédentes
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
Standard Form Elements Shipped With 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_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
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
Migrer à partir des versions précédentes
Zend_Log
Présentation
Rédacteurs (Writers)
Formateurs (mise en forme)
Filtres
Zend_Mail
Introduction
Envoyer des émail en utilisant SMTP
Envoyer plusieurs émail par connexion SMTP
Utiliser différents transports
Émail 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 émail
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_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
Informations du document et métadonnées
Exemple d'utilisation du module Zend_Pdf
Zend_ProgressBar
Zend_ProgressBar
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
Searching an Index
Query Language
Query Construction API
Jeu de caractères
Extensibility
Agir avec Lucene Java
Avancé
Bonnes pratiques
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 Stroage (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_Audioscrobbler
Zend_Service_Delicious
Zend_Service_Flickr
Zend_Service_Nirvanix
Zend_Service_ReCaptcha
Zend_Service_Simpy
Introduction
Zend_Service_StrikeIron
Zend_Service_StrikeIron: Bundled Services
Zend_Service_StrikeIron: Advanced Uses
Zend_Service_Technorati
Zend_Service_Twitter
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_Text
Zend_Text_Figlet
Zend_Text_Table
Zend_TimeSync
Introduction
Utiliser Zend_TimeSync
Zend_Tool_Framework
Introduction
Using the CLI Tool
Architecture
Creating Providers to use with Zend_Tool_Framework
Shipped System Providers
Zend_Tool_Project
Zend_Tool_Project Introduction
Create A Project
Zend Tool Project Providers
Zend_Translate
Introduction
Adaptateurs pour Zend_Translate
Utiliser les adaptateurs de traduction
Migrer à partir des versions précédentes
Zend_Uri
Zend_Uri
Zend_Validate
Introduction
Classes de validation standard
Chaînes de validation
Écrire des validateurs
Validation Messages
Zend_Version
Lire la version de Zend Framework
Zend_View
Introduction
Scripts de contrôleur
Scripts de vue
Aides de vue
Zend_View_Abstract
Migration depuis les versions précédentes
Zend_Wildfire
Zend_Wildfire
Zend_XmlRpc
Introduction
Zend_XmlRpc_Client
Zend_XmlRpc_Server
Configuration système requise par Zend Framework
Introduction
Convention de codage PHP de Zend Framework
Vue d'ensemble
Formatage des fichiers PHP
Conventions de nommage
Style de codage
Zend Framework Performance Guide
Introduction
Chargement des classes
Zend_Db Performance
Internationalisation (i18n) and Localisation (l10n)
View Rendering
Informations de copyright