Previous Next

Les éléments standards fournis avec Zend Framework

Zend Framework est fournis avec des classes d'éléments couvrant la plupart des éléments de formulaire HTML. La plupart spécifie un helper de vue en particulier à utiliser pour décorer un élément, mais plusieurs d'entre elles offrent des fonctionnalités supplémentaires. Ce qui suit est une liste de toutes ces classes, ainsi que des descriptions des fonctionnalités offertes.

Zend_Form_Element_Button

Utilisé pour créer des éléments boutons, Zend_Form_Element_Button étend Zend_Form_Element_Submit, spécifie quelques fonctionnalités personnalisées. Il spécifie le helper de vue 'formButton' pour la décoration.

Comme l'élément submit, il utilise le label de l'élément en tant que valeur de l'élément lors de l'affichage ; autrement dit, pour définir le text du bouton, définissez la valeur de l'élément. Le label sera traduit si l'adapteur de traduction est présent.

Comme le label est utilisé comme faisant partie de l'élément, l'élément bouton utilise seulement ViewHelper et les décorateurs DtDdWrapper.

Après avoir rempli ou validé un formulaire, vous pouvez vérifier si le bouton donné a été cliqué en utilisant la méthode isChecked().

Zend_Form_Element_Captcha

Les CAPTCHAs sont utilisé pour empêcher la soumission automatique des formulaires par des bots et autre processus automatisés.

L'élément de formulaire Captcha permet de spécifier quel Adapteur Zend_Captcha vous désirez utiliser. Il définit ensuite cet adapteur comme validateur à l'objet, et utilise le décorateur du Captcha pour l'affichage (ce qui fait office de proxy vers l'adapteur CAPTCHA).

Les adapteurs peuvent être n'importe quel adapteur de Zend_Captcha, ou n'importe quel adapteur que vous avez défini par ailleurs. Pour permettre ceci, vous devrez passer une clé supplémentaire de plugin loader, 'CAPTCHA' ou 'captcha', lorsque vous spécifiez un prefixe de chemin de plugin loader :

$element->addPrefixPath('My_Captcha', 'My/Captcha/', 'captcha');

Le Captcha peut ensuite être enregistré en utilisant la méthode setCaptcha(), qui prend en paramètre soit une instance concrête de CAPTCHA soit le nom court d'un adapteur CAPTCHA :

// Instance concrête:
$element->setCaptcha(new Zend_Captcha_Figlet());
// Utilisation d'un nom court :
$element->setCaptcha('Dumb');

Si vous souhaitez charger votre élément via la configuration, spécifiez soit la clé 'captcha' avec un tableau contenant la clé 'captcha', soit les clés 'captcha' et 'captchaOptions' :

// Utilisation d'une clé captcha :
$element = new Zend_Form_Element_Captcha('foo', array(
    'label' => "Merci de confirmer que vous êtes humain",
    'captcha' => array(
        'captcha' => 'Figlet',
        'wordLen' => 6,
        'timeout' => 300,
    ),
));
// Utilisation simultanée des clés captcha et captchaOption :
$element = new Zend_Form_Element_Captcha('foo', array(
    'label' => "Merci de confirmer que vous êtes humain",
    'captcha' => 'Figlet',
    'captchaOptions' => array(
        'captcha' => 'Figlet',
        'wordLen' => 6,
        'timeout' => 300,
    ),
));

Le décorateur utilisé est déterminé lors de la récupération de l'adapteur du captcha. Par défaut, le décorateur du captcha est utilisé, mais un adapteur peut spécifier un décorateur différent via sa méthode getDecorator().

Comme noté, l'adapteur de captcha lui même agit comme un validateur pour l'élément. De plus, le validateur NotEmpty n'est pas utilisé, et l'élément est marqué comme requis. Dans la plupart des cas, vous n'aurez besoin de rien d'autre pour que le captcha soit présent dans votre formulaire.

Zend_Form_Element_Checkbox

Les cases à cocher HTML vous permettent de retourner une valeur spécifique, mais elles fonctionnent essentiellement comme des booléens. Lorsque elle est cochée, la valeur de la case à cocher est soumise. Lorsque la case à cocher n'est pas cochée, rien n'est soumis. En interne, Zend_Form_Element_Checkbox applique cet état.

Par défaut, la valeur cochée est '1', et la valeur non cochée est '0'. Vous pouvez spécifier les valeurs en utilisant respectivement les accesseurs setCheckedValue() et setUncheckedValue(). En interne, à chaque fois que vous définissez une valeur, si la valeur fournie correspond à la valeur cochée, alors elle sera définie, mais toutes autres valeurs aura pour effet que la valeur non cochée sera sélectionnée.

En sus, définir la valeur définit la propriété checked de la case à cocher. Vous pouvez la récupérer en utilisant isChecked() ou simplement en accédant à la propriété. Utiliser la méthode setChecked($flag) l'état du flag ainsi que la valeur cochée ou non cochée de l'élément. Veillez à utiliser cette méthode lorsque vous définissez l'état coché d'un élément case à cocher afin d'être sûr que la valeur est correctement définie.

Zend_Form_Element_Checkbox utilise le helper de vue 'formCheckbox'. La valeur cochée est toujours utilisé pour le remplir.

Zend_Form_Element_File

L'élément de formulaire File fournit un mécanisme pour fournir des champs d'upload de fichier à votre formulaire. Il utilise Zend_File_Transfer en interne pour fournir cette fonctionnalité et le helper de vue FormFile ainsi que le décorateur File pour afficher l'élément de formulaire.

Par défaut, il utilise l'adapteur de transfertHttp qui inspecte le tableau $_FILES et vous permet d'attacher des validateurs et des filtres. Les validateurs et les filtres attachés au formulaire sont à leur tour attachés à l'adapteur de transfert.

Exemple #1 Utilisation de l'élément de formulaire File

L'explication d'utilisation de l'élément de formulaire File ci-dessous peut sembler ésotérique, mais l'usage est en fait relativement trivial :

$element = new Zend_Form_Element_File('foo');
$element->setLabel('Upload une image:')
        ->setDestination('/var/www/upload');
// Fait en sorte qu'il y ait un seul fichier
$element->addValidator('Count', false, 1);
// limite à 100K
$element->addValidator('Size', false, 102400);
// seulement des JPEG, PNG, et GIFs
$element->addValidator('Extension', false, 'jpg,png,gif');
$form->addElement($element, 'foo');

Vous devez aussi vous assurer que le type d'encodage correct est fourni au formulaire ; vous devez utiliser 'multipart/form-data'. Vous pouvez faire cela en définissant l'attribut 'enctype' du formulaire:

$form->setAttrib('enctype', 'multipart/form-data');

Après que le formulaire soit validé avec succès, vous devriez recevoir le fichier afin de le stocker dans sa destination finale en utilisant receive(). De plus, vous pouvez déterminer son emplacement finale en utilisant getFileName():

if (!$form->isValid()) {
    print "Uh oh... erreur de validation";
}
if (!$form->foo->receive()) {
    print "Erreur de réception de fichier";
}
$location = $form->foo->getFileName();

Note: Emplacement d'upload par défaut

Par défaut, les fichiers sont uploadés dans le répertoire temp du système.

Note: Valeur de fichier

Au sein du HTTP un élément fichier n'a aucune valeur. Pour cette raison et pour des raisons de sécurité getValue() retourne seulement le nom du fichier uploadé et non le chemin complet. Si vous avez besoin du chemin du fichier, appellez getFileName(), qui retourne à la fois le chemin et le nom du fichier.

Par défaut, le fichier sera automatiquement reçu quand vous appellerez getValues() sur le formulaire. La raison derrière ce comportement est que le fichier lui même est la valeur de l'élément fichier.

$form->getValues();

Note:

Ainsi, un appel supplémentaire de receive() après avoir appellé getValues() n'aura aucun effet. De même, créer une instance de Zend_File_Transfer n'aura aucun effet non plus puisqu'il n'y aura plus de fichier à recevoir.

Cela dit, parfois vous aurez besoin d'appeller getValues() sans recevoir le fichier. Vous pouvez l'archiver en appellant setValueDisabled(true). Afin de recevoir la véritable valeur de ce flag vous pouvez appeller isValueDisabled().

Exemple #2 Récupération explicite de fichier

Tout d'abord appellez setValueDisabled(true).

$element = new Zend_Form_Element_File('foo');
$element->setLabel('Uploadez une image:')
        ->setDestination('/var/www/upload')
        ->setValueDisabled(true);

Désormais le fichier sera reçu lorsque vous appellerez getValues(). Donc vous devez appeller vous même receive() sur l'élément fichier, ou une instance de Zend_File_Transfer .

$values = $form->getValues();
if ($form->isValid($form->getPost())) {
    if (!$form->foo->receive()) {
        print "Erreur d'upload";
    }
}

Il ya plusieurs étapes du fichier uploadés qui peuvent être vérifiées avec les méthodes suivantes :

  • isUploaded() : Vérifie si l'élément fichier a été uploadé ou non.

  • isReceived() : Vérifie si l'élément fichier a déjà été reçu.

  • isFiltered() : Vérifie si les filtres ont déjà été appliqué ou non sur l'élément fichier.

Exemple #3 Vérifier si un fichier optionnel a été uploadé

$element = new Zend_Form_Element_File('foo');
$element->setLabel('Uploader une image:')
        ->setDestination('/var/www/upload')
        ->setRequired(false);
$element->addValidator('Size', false, 102400);
$form->addElement($element, 'foo');
// L'élément fichier foo est optionnel mais quand il est renseigné va là
if ($form->foo->isUploaded()) {
    // fichier foo donné, faire quelque chose
}

Zend_Form_Element_File supporte aussi les fichiers multiples. En appellant la méthode setMultiFile($count) vous pouvez définir, le nombre d'éléments fichier à créer. Ceci vous évite de définir les mêmes réglages plusieurs fois.

Exemple #4 Définir plusieurs fichiers

Créer un élément multifichier est identique à la création d'un élément unique. Appellez simplement setMultiFile() après que l'élément soit créé:

$element = new Zend_Form_Element_File('foo');
$element->setLabel('Uploadez une image:')
        ->setDestination('/var/www/upload');
// s'assure qu'il y a un fichier au minimum, 3 au maximum
$element->addValidator('Count', false, array('min' => 1, 'max' => 3));
// Limite à 100K
$element->addValidator('Size', false, 102400);
// seulement des JPEG, PNG, et des GIF
$element->addValidator('Extension', false, 'jpg,png,gif');
// définit 3 éléments fichiers identiques
$element->setMultiFile(3);
$form->addElement($element, 'foo');

Vous avez maintenant 3 éléments d'upload de fichier identiques avec les mêmes paramètres. Pour obtenir le nombre de fichiers multiples défini, appellez simplement getMultiFile().

Note: Eléments de fichier dans un sous formulaire

Quand vous l'utilisez dans des sous formulaires, vous devez définir des noms uniques. Par exemple, si vous nommez un élément fichier "file" dans le subform1, vous devez un nom différent à tout autre élément fichier dans subform2.

Si il y a deux éléments fichier portant le même nom, le second élément n'est pas affiché ou soumis.

De plus, les éléments fichiers ne sont pas affichés au sein du sous formulaire. Donc lorsque vous ajouter un élément fichier dans un sous formulaire, l'élément sera affiché dans le formulaire principal.

Afin de limiter, vous pouvez spécifier la taille maximum d'un fichier en définissant l'option MAX_FILE_SIZE sur le formulaire. Quand vous définissez cette valeur en utilisant la méthode setMaxFileSize($size), elle sera affiché avec l'élément fichier.

$element = new Zend_Form_Element_File('foo');
$element->setLabel('Uploadez une image:')
        ->setDestination('/var/www/upload')
        ->addValidator('Size', false, 102400) // limit to 100K
        ->setMaxFileSize(102400); // limite la taille de fichier coté client
$form->addElement($element, 'foo');

Note: MaxFileSize et Eléments fichier multiple

Quand vous utilisez des éléments fichiers multiples dans votre formulaire vous devez définir MAX_FILE_SIZE seulement une fois. La redéfinir écrasera la valeur précédente.

Notez que c'est aussi le cas lorsque vous utilisez des formulaires multiples.

Zend_Form_Element_Hidden

Les éléments cachés injectent des données qui doivent être soumises, mais pas manipulées par l'utilisateur. Zend_Form_Element_Hidden remplit cette tâche avec le helper de vue 'formHidden'.

Zend_Form_Element_Hash

Cette élément fournit une proctection contre les attaques CSRF sur les formulaires, en s'assurant que les données sont soumises par la session utilisateur qui a générée le formulaire et non par un script malveillant. La protection est réalisée en ajouté un élément de hachage au formulaire et en le vérifiant lors de la soumission du formulaire.

Le nom de l'élément de hachage doit être unique. Nous recommandons d'utiliser l'option salt pour l'élément - deux hachages ayant le même nom mais des salt différent ne causeront pas de collision :

$form->addElement('hash', 'no_csrf_foo', array('salt' => 'unique'));

Vous pouvez définir le salt ultérieurement en utilisant la méthode setSalt($salt).

En interne, l'élément stocke un identifiant unique en utilisant Zend_Session_Namespace, et le vérifie lors de la soumission (en vérifiant que le TTL n'a pas expiré). Le validateur 'Identical' est ensuite utilisé pour s'assurer que le hachage soumis correspond au hachage stocké.

Le helper de vue 'formHidden' est utilisé pour rendre l'élément dans le formulaire.

Zend_Form_Element_Image

Des images peuvent être utilisées comme éléments de formulaires, et vous pouvez utiliser ces images en tant qu'éléments graphiques sur les boutons de formulaires.

Les images ont besoin d'une image source. Zend_Form_Element_Image permet de la spécifier en utilisant l'accesseur setImage() (ou la clé de configuration 'imageValue'). Quant la valeur définie pour l'élément corresponde à imageValue, alors l'accesseur isChecked() retournera TRUE.

Les éléments image utilise le décorateur Image pour le rendu, en plus des décorateur standard Errors, HtmlTag et Label. Vous pouvez spécifier une balise en option au décorateur Image qui entourera l'élément image.

Zend_Form_Element_MultiCheckbox

Souvent, vous pouvez avoir un ensemble de case à cocher apparenté, et vous souhaitez grouper ces résultat. Cela ressemble beaucoup à Multiselect, mais au lieu que ce soit une liste déroulant, vous avez besoin d'afficher des paires case à cocher/valeur.

Zend_Form_Element_MultiCheckbox rend cela simple comme bonjour. Comme tous les éléments qui étendent l'élément de base Multi, vous pouvez spécifier une liste d'options et les valider simplement à l'aide de cette même liste. Le helper de vue 'formMultiCheckbox' s'assure qu'elles seront retournées dans un tableau lors la soumission du formulaire.

Par défaut, cet élément enregistre un validateur InArray qui effectue la validation à l'aide des clés du tableau d'options enregistrées. Vous pouvez désactiver ce comportement, soit en appellant setRegisterInArrayValidator(false), soit en passant une valeur FALSE à la clé de configuration registerInArrayValidator.

Vous pouvez manipuler les diverses options de case à cocher en utilisant les méthodes suivantes :

  • addMultiOption($option, $value)

  • addMultiOptions(array $options)

  • setMultiOptions(array $options) (écrase les options existantes)

  • getMultiOption($option)

  • getMultiOptions()

  • removeMultiOption($option)

  • clearMultiOptions()

Pour marquer les éléments cochés, vous devez passer un tableau de valeur à setValue(). Ce qui suit cochera les valeur "bar" et "bat":

$element = new Zend_Form_Element_MultiCheckbox('foo', array(
    'multiOptions' => array(
        'foo' => 'Foo Option',
        'bar' => 'Bar Option',
        'baz' => 'Baz Option',
        'bat' => 'Bat Option',
    );
));
$element->setValue(array('bar', 'bat'));

Notez que même en définissant une valeur unique vous devrez passer un tableau.

Zend_Form_Element_Multiselect

Les éléments select XHTML autorisent un attribut 'multiple', indiquant que plusieurs options peuvent être sélectionné pour la soumission du formulaire, au lieu d'une seule habituellement. Zend_Form_Element_Multiselect étend Zend_Form_Element_Select, et définit l'attribut multiple à 'multiple'. Comme les autres classes qui hétite la classe de base Zend_Form_Element_Multi, vous pouvez manipuler les options du select en utilisant :

  • addMultiOption($option, $value)

  • addMultiOptions(array $options)

  • setMultiOptions(array $options) (écrase les options existantes)

  • getMultiOption($option)

  • getMultiOptions()

  • removeMultiOption($option)

  • clearMultiOptions()

Si un adapteur de traduction est enregistré au niveau du formulaire et/ou de l'élément, les valeurs des options seront traduites dans le cadre de l'affichage.

Par défaut, cette élément utilise un validateur InArray qui effectue sa validation à partir des clés de tableau des options enregistrées. Vous pouvez désactiver ce comportement, soit en appellant setRegisterInArrayValidator(false), ou en passant une valeur FALSE à la clé de configuration registerInArrayValidator.

Zend_Form_Element_Password

Les éléments mot de passe sont fondamentalement des éléments texte normaux -- à l'exception du fait que vous ne voulez pas que le mot de passe soumis soit affiché dans les messages d'erreurs ou lorsque le formulaire est affiché à nouveau.

Zend_Form_Element_Password effectue cela en appellant setObscureValue(true) sur chaque validateur (s'assurant ainsi que le mot de passe est dissimulé dans les messages d'erreur de validation), et utilise le helper de vue 'formPassword' qui n'affiche pas la valeur qui lui est passé).

Zend_Form_Element_Radio

Les éléments radio vous permettend de spécifier plusieurs options, parmi lesquelles vous n'avez besoin que d'une seule. Zend_Form_Element_Radio étend la classe de base Zend_Form_Element_Multi, vous permettant ainsi de spécifier un nombre indéfini d'options, et utilise ensuite le helper de vue formRadio pour les afficher.

Par défaut, cette élément utilise un validateur InArray qui effectue sa validation à partir des clés de tableau des options enregistrées. Vous pouvez désactiver ce comportement, soit en appellant setRegisterInArrayValidator(false), ou en passant une valeur FALSE à la clé de configuration registerInArrayValidator.

Comme tous les éléments étendant la classe de base Multi element, les méthodes suivantes peuvent être utilisé pour manipuler les options radio affichées :

  • addMultiOption($option, $value)

  • addMultiOptions(array $options)

  • setMultiOptions(array $options) (écrase les options existantes)

  • getMultiOption($option)

  • getMultiOptions()

  • removeMultiOption($option)

  • clearMultiOptions()

Zend_Form_Element_Reset

Les boutons de mise à zéro sont typiquement utilisé pour vider un formulaire, et ne font pas partie des données soumises. Cela dit, comme ils remplissent un rôle dans l'affichage, ils sont inclus dans les éléments standards.

Zend_Form_Element_Reset étend Zend_Form_Element_Submit. Ainsi, le label est utilisé pour l'affichage du bouton et sera traduit, si un adapteur de traduction est présent. Il utilise seulement les décorateurs 'ViewHelper' et 'DtDdWrapper', puisqu'il ne devrait jamais y avoir de messages d'erreur pour ces éléments, le label ne sera pas non plus nécessaire.

Zend_Form_Element_Select

Les listes d'options sont une manière habituelle de limiter des choix spécifiques. Zend_Form_Element_Select vous permet de les générer rapidement et facilement.

Par défaut, cette élément utilise un validateur InArray qui effectue sa validation à partir des clés de tableau des options enregistrées. Vous pouvez désactiver ce comportement, soit en appellant setRegisterInArrayValidator(false), ou en passant une valeur FALSE à la clé de configuration registerInArrayValidator.

Comme il étend l'élément de base Multi, les méthodes suivantes peuvent être utilisées pour manipuler les options du select :

  • addMultiOption($option, $value)

  • addMultiOptions(array $options)

  • setMultiOptions(array $options) (écrase les options existantes)

  • getMultiOption($option)

  • getMultiOptions()

  • removeMultiOption($option)

  • clearMultiOptions()

Zend_Form_Element_Select utilise le helper de vue 'formSelect pour la décoration.

Zend_Form_Element_Submit

Les boutons Submit sont utilisé pour soumettre un formulaire. Vous pouvez utiliser plusieurs boutons submit ; vous pouvez utiliser le bouton utilisé pour soumettre le formulaire afin de décider quelle action effectuer avec les données soumises. Zend_Form_Element_Submit rend cette décisions simple, en ajoutant une méthode isChecked() method ; puisqu'un seul élément bouton sera soumis par le formulaire, après avoir rempli ou validé le formulaire, vous pourrez appeller cette méthode sur chacun des boutons submit afin de déterminer lequel a été utilisé.

Zend_Form_Element_Submit utilise le label comme "value" du bouton submit, il sera traduit si un adapeur de traduction est présent. isChecked() vérifie la valeur soumises avec le label pour déterminer si le bouton a été utilisé.

Les décorateurs ViewHelper et DtDdWrapper sont utilisé pour rendre cet élément. Aucun décorateur de label n'est utilisé, puisque le label du bouton est utilisé lors du rendu de l'élément ; de plus, vous n'associerez aucune erreurs avec l'élément submit.

Zend_Form_Element_Text

De loin le type d'élément de formulaire le plus répandu est l'élément text, celui ci autorise des saisies de texte limité ; c'est un élément idéal pour la plupart des saisies de données. Zend_Form_Element_Text utilise simplement le helper de vue 'formText' pour afficher l'élément.

Zend_Form_Element_Textarea

Les Textareas sont utilisé lorsque de grandes quantités de texte sont attendues, et ne limite pas la quantité de texte soumise (si ce n'est la taille limite fixée par votre serveur ou PHP). Zend_Form_Element_Textarea utilise le helper de vue 'textArea' pour afficher ces éléments, et place la valeur comme contenu de l'élément.

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