Previous Next

Aides de vue

Dans vos scripts de vue, il est souvent nécessaire d'effectuer certaines actions complexes encore et encore : par exemple, formater une date, générer des éléments de formulaire, afficher des liens d'action. Vous pouvez utiliser des classes d'aide pour effectuer ce genre de tâches.

Une aide est simplement une classe. Par exemple, nous voulons une aide nommée "foobar". Par défaut, la classe est préfixée avec "Zend_View_Helper_" (vous pouvez spécifier un préfixe personnalisé en paramétrant votre chemin d'aide), et le dernier segment du nom de classe est le nom de l'aide ; ce segment peut être avec des CaracteresMajuscules ; le nom complet de la classe est alors : Zend_View_Helper_FooBar. Cette classe doit contenir au moins une méthode, nommée comme l'aide avec la notationCamel : fooBar().

Note: Surveillez la casse

Les noms des aides sont toujours en notationCamel, c'est-à-dire qu'ils ne commencent pas avec un caractère majuscule. Le nom de classe elle-même peut être en casseMélangée, mais la méthode qui est exécutée est en notationCamel.

Pour utiliser une aide dans votre script de vue, appelez la en utilisant $this->nomAide(). Dans les coulisses, Zend_View va charger la classe Zend_View_Helper_NomAide, créer une instance de cet objet, et appeler sa méthode nomAide(). L'instance de l'objet est persistante dans l'instance de Zend_View, et est réutilisée pour tous les appels futurs à $this->nomAide().

Aides initiales

Zend_View fournit avec un jeu initial de classes d'aides, la plupart est liée à la génération d'éléments de formulaire. Chacune affiche et échappe l'élément automatiquement. De plus, il existe des aides pour créer des URLs sur la base de routes et des listes HTML, de la même manière que l'on déclarerait des variables. Les aides actuellement incluses sont :

  • declareVars() : initialement prévu pour être utilisé avec strictVars(), cette aide peut être utilisée pour déclarer les variables de modèle ("template") qui sont (ou pas) déjà déclarées dans l'objet de vue, ou pour gérer des valeurs par défaut. Les tableaux passés comme arguments à la méthode seront utilisés pour paramétrer des valeurs par défaut ; sinon, si la variable n'existe pas, on lui affecte une chaîne vide.

  • fieldset($name, $content, $attribs) : crée un ensemble de champs XHTML. Si $attribs contient une clé "legend", cette valeur sera utilisée comme légende du fieldset. Le fieldset entourera le contenu $content tel qu'il aura été fourni à l'aide.

  • form($name, $attribs, $content) : génère un formulaire XHTML. Tous les éléments $attribs sont échappés et rendus sous la forme d'attributs de la balise "form". Si $content est présent et n'est pas un booléen valant false, alors ce contenu est rendu à l'intérieur des balises "form" ; si $content est un booléen valant false (par défaut), seul la balise ouvrante "form" est générée.

  • formButton($name, $value, $attribs) : crée un élément <button />.

  • formCheckbox($name, $value, $attribs, $options): crée un élément <input type="checkbox" />.

    Par défaut, quand aucune $value n'est fournie et qu'aucune $options n'est présente, alors "0" est considéré comme la valeur non cochée et "1" comme la valeur cochée. Si une $value est fournie, mais qu'aucune $options n'est présente, l'état coché est considéré égal à la $value fournie.

    $options devrait être un tableau. Si ce tableau est indexé, la première valeur est la valeur cochée, la seconde est la valeur non cochée ; et tout autre valeur est ignorée. Vous pouvez aussi passer un tableau associatif avec les clés "checked" et "unChecked".

    Si $options est fourni, et que $value correspond à la valeur cochée, alors l'élément sera marqué comme coché. Vous pouvez aussi marquer l'élément comme coché ou décoché en passant une valeur booléenne à l'attribut "checked".

    Ceci pourra sûrement être plus explicite avec quelques exemples :

    // "1" et "0" en tant qu'options cochée/décochée ; cochée
    echo $this->formCheckbox('foo');
    
    // "1" et "0" en tant qu'options cochée/décochée ; cochée
    echo $this->formCheckbox('foo', null, array('checked' => true));
    
    // "bar" et "0" en tant qu'options cochée/décochée ; décochée 
    echo $this->formCheckbox('foo', 'bar');
    
    // "bar" et "0" en tant qu'options cochée/décochée ; cochée 
    echo $this->formCheckbox('foo', 'bar', array('checked' => true));
    
    // "bar" et "baz" en tant qu'options cochée/décochée ; décochée 
    echo $this->formCheckbox('foo', null, null, array('bar', 'baz');
    
    // "bar" et "baz" en tant qu'options cochée/décochée ; décochée 
    echo $this->formCheckbox('foo', null, null, array(
        'checked' => 'bar', 
        'unChecked' => 'baz'
    ));
    
    // "bar" et "baz" en tant qu'options cochée/décochée ; cochée 
    echo $this->formCheckbox('foo', 'bar', null, array('bar', 'baz');
    echo $this->formCheckbox('foo', null, array('checked' => true), array('bar', 'baz');
    
    // "bar" et "baz" en tant qu'options cochée/décochée ; décochée 
    echo $this->formCheckbox('foo', 'baz', null, array('bar', 'baz');
    echo $this->formCheckbox('foo', null, array('checked' => false), array('bar', 'baz');

    Dans tous les cas, la balise est précédée d'un élément masqué ("hidden") avec la valeur de l'état décoché ; ainsi, si la valeur est décochée, vous aurez toujours une valeur valide retournée par votre formulaire.

  • formErrors($errors, $options) : génère une liste non ordonnée XHTML pour montrer des erreurs. $errors peut être une chaîne de caractères ou un tableau de chaînes ; $options peut être tout attribut que vous pourriez vouloir placer dans la balise ouvrante de la liste.

    Vous pouvez spécifier des éléments ouvrants, fermants et des séparateurs de contenu alternatifs lors du rendu des erreurs en appelant les différentes méthodes suivantes de l'aide :

    • setElementStart($string) ; par défaut vaut "<ul class="errors"%s"><li>", où %s est remplacé avec les attributs spécifiés dans $options.

    • setElementSeparator($string) ; par défaut vaut "</li><li>".

    • setElementEnd($string) ; par défaut vaut "</li></ul>".

  • formFile($name, $value, $attribs): crée un élément <input type="file" />.

  • formHidden($name, $value, $attribs) : crée un élément <input type="hidden" />.

  • formLabel($name, $value, $attribs) : crée un élément <label>, en réglant l'attribut for avec $name, et le texte du label avec $value. Si disable est fourni via attribs, rien n'est retourné.

  • formMultiCheckbox($name, $value, $attribs, $options, $listsep) : crée une liste de cases à cocher. $options devrait être un tableau associatif, avec une profondeur arbitraire. $value peut être une valeur unique ou un tableau de valeurs sélectionnées qui correspondent aux clés du tableau $options. $listsep est un séparateur HTML ("<br />") par défaut. Par défaut, cet élément est traité comme un tableau ; toutes les cases à cocher partagent le même nom, et sont soumises sous la forme d'un tableau.

  • formPassword($name, $value, $attribs) : crée un élément <input type="password" />.

  • formRadio($name, $value, $attribs, $options) : crée une série d'éléments <input type="button" />, un pour chaque élément $options. Dans le tableau $options, la clé de l'élément est la valeur du radio, et la valeur de l'élément est l'étiquette du radio. La radio $value sera précochée pour vous.

  • formReset($name, $value, $attribs) : crée un élément <input type="reset" />.

  • formSelect($name, $value, $attribs, $options) : crée un bloc <select>...</select>, avec une <option> pour chaque élément $options. Dans le tableau $options, la clé de l'élément est la valeur de l'option, et la valeur de l'élément est son étiquette optionnelle. L'option (ou les options) $value sera (ou seront) présélectionnée(s) pour vous.

  • formSubmit($name, $value, $attribs) : crée un élément <input type="submit" />.

  • formText($name, $value, $attribs) : crée un élément <input type="text" />.

  • formTextarea($name, $value, $attribs) : crée un bloc <textarea>...</textarea>.

  • url($urlOptions, $name, $reset) : crée un URL basé sur une route nommée. $urlOptions doit être un tableau associatif avec des paires de clés/valeurs utilisées par une route particulière.

  • htmlList($items, $ordered, $attribs, $escape) : génère des listes ordonnées ou non basées sur les $items qui lui sont fournis. Si $items est un tableau multidimensionnel, une liste imbriquée sera construite. Si le paramètre $escape vaut true (valeur par défaut), chaque élément sera échappé en utilisant le mécanisme d'échappement enregistré dans les objets de vue ; fournissez une valeur false si vous voulez autoriser du balisage dans vos listes.

Les utiliser dans vos script de vue est très simple, voici un exemple. Notez que tout ce dont vous avez besoin, c'est de les appeler; elles vont se charger et s'instancier elle-même si besoin est.


La sortie résultante du script de vue ressemblera à ceci :

L'aide de vue Action

L'aide de vue Action permet à des scripts de vue de dispatcher une action donnée d'un contrôleur ; le résultat de l'objet de réponse suivant le dispatchage est alors retourné. Ceux-ci peuvent être employés quand une action particulière peut produire du contenu réutilisable ou du contenu de type "gadget".

Les actions qui ont comme conséquence un _forward() ou une redirection sont considérées invalide, et renverront une chaîne vide.

L'API pour l'aide de vue Action respecte le même schéma que la plupart les composants MVC qui appellent des actions de contrôleur : action($action, $controller, $module = null, array $params = array()). $action et $controller sont exigés ; si aucun module n'est spécifié, le module par défaut est implicite.

Example #1 Utilisation de base de l'aide de vue Action

Par exemple, vous pouvez avoir un CommentController avec une méthode listAction() que vous souhaitez appeler afin de récupérer une liste de commentaires pour la requête courante :

L'aide de vue Partial

L'aide de vue Partial est utilisée pour effectuer le rendu d'un modèle ("template") spécifique dans sa propre portée de variable. L'utilisation principale est pour les fragments réutilisables de modèle avec lesquels vous n'avez pas besoin de vous inquiéter des conflits de noms de variable. De plus, ils vous permettent de spécifier les scripts de vue partiels dans des modules spécifiques.

Une soeur de l'aide Partial, l'aide de vue de PartialLoop vous permet de passer des données itératives, et effectue un rendu partiel pour chaque élément.

Example #2 Utilisation de base des Partials

L'utilisation de base des Partials est d'effectuer le rendu d'un fragment de modèle dans sa propre portée de vue. Examinez le script partiel suivant :


  • De : escape($this->de) >?
  • Sujet : escape($this->sujet) >?

Vous l'appeleriez alors dans votre script de vue en utilisant ce qui suit :

partial('partiel.phtml', array(
    'de' => 'Equipe Framework',
    'sujet' => 'vues partielles')); ?>

Qui vous retournerait :

  • De : Equipe Framework
  • Sujet : vues partielles

Note: Qu'est qu'un modèle ?

Un modèle utilisé avec l'aide de vue Partial peut être un des suivants :

  • Tableaux ("array") : si un tableau est fourni, il devrait être associatif, car ses paires de clé/valeur sont assignées à la vue avec les clés comme variables de vue.

  • Objet implémentant la méthode toArray() : si un objet est fourni et qu'il possède une méthode toArray(), le résultat de toArray() sera assigné à la vue comme variable de vue.

  • Objet standard : tout autre objet assignera le résultat de object_get_vars() (essentiellement toutes les propriétés publiques de l'objet) à l'objet de vue.

Example #3 Utiliser PartialLoop pour effectuer le rendu d'éléments itératifs

Typiquement, vous voudrez employer des partials dans une boucle, pour rendre le même fragment de contenu plusieurs fois ; de cette façon vous pouvez mettre de grands blocs de contenu répété ou de logique complexe d'affichage dans un endroit unique. Toutefois ceci a un impact d'exécution, car l'aide Partial doit être appelée une fois par itération.

L'aide de vue PartialLoop résout ce problème. Elle vous permet de fournir un élément itérable (tableau ou objet implémentant Iterator) comme modèle. Elle réitère alors au-dessus de celui-ci en fournissant les éléments au script partiel. Les éléments dans l'itérateur peuvent être n'importe quel modèle que l'aide de vue Partial permet (cf. ci-dessus).

Considérons le script partiel suivant :


    
key ?>
value ?>

Et le "modèle" suivant :

 'Mammifère', 'value' => 'Chameau'),
    array('key' => 'Oiseau',    'value' => 'Pingouin'),
    array('key' => 'Reptile',   'value' => 'Asp'),
    array('key' => 'Poisson',   'value' => 'Flounder')
);
?>

Dans votre script de vue, vous pouvez maintenant appeler l'aide PartialLoop :

partialLoop('partialLoop.phtml', $model) ?>
Mammifère
Chameau
Oiseau
Pingouin
Reptile
Asp
Poisson
Flounder

Example #4 Effectuer le rendu partiel dans des modules différents

Parfois un partiel existera dans un module différent. Si vous connaissez le nom du module, vous pouvez le fournir comme deuxième argument à partial() ou à partialLoop(), en déplaçant l'argument $model à la troisième position.

Par exemple, s'il y a un gestionnaire de page partiel que vous souhaitez utiliser et qui est dans le module "liste", vous pourriez le saisir comme suit :

partial('pager.phtml', 'liste', $pagerData) ?>

De cette façon, vous pouvez réutiliser des partiels créés spécifiquement pour d'autre modules. Ceci dit, il est probablement une meilleure pratique de mettre des partiels réutilisables dans des dossiers partagés de script de vue.

Placeholder Helper

The Placeholder view helper is used to persist content between view scripts and view instances. It also offers some useful features such as aggregating content, capturing view script content for later use, and adding pre- and post-text to content (and custom separators for aggregated content).

Example #5 Basic Usage of Placeholders

Basic usage of placeholders is to persist view data. Each invocation of the Placeholder helper expects a placeholder name; the helper then returns a placeholder container object that you can either manipulate or simply echo out.

placeholder('foo')->set("Some text for later") ?>

placeholder('foo'); 
    // outputs "Some text for later"
?>

Example #6 Using Placeholders to Aggregate Content

Aggregating content via placeholders can be useful at times as well. For instance, your view script may have a variable array from which you wish to retrieve messages to display later; a later view script can then determine how those will be rendered.

The Placeholder view helper uses containers that extend ArrayObject, providing a rich featureset for manipulating arrays. In addition, it offers a variety of methods for formatting the content stored in the container:

  • setPrefix($prefix) sets text with which to prefix the content. Use getPrefix() at any time to determine what the current setting is.

  • setPostfix($prefix) sets text with which to append the content. Use getPostfix() at any time to determine what the current setting is.

  • setSeparator($prefix) sets text with which to separate aggregated content. Use getSeparator() at any time to determine what the current setting is.

  • setIndent($prefix) can be used to set an indentation value for content. If an integer is passed, that number of spaces will be used; if a string is passed, the string will be used. Use getIndent() at any time to determine what the current setting is.


placeholder('foo')->exchangeArray($this->data) ?>

placeholder('foo')->setPrefix("
    \n
  • ") ->setSeparator("
  • \n") ->setIndent(4) ->setPostfix("
\n"); ?> placeholder('foo'); // outputs as unordered list with pretty indentation ?>

Because the Placeholder container objects extend ArrayObject, you can also assign content to a specific key in the container easily, instead of simply pushing it into the container. Keys may be accessed either as object properties or as array keys.

placeholder('foo')->bar = $this->data ?>
placeholder('foo')->bar ?>

placeholder('foo');
echo $foo['bar'];
?>

Example #7 Using Placeholders to Capture Content

Occasionally you may have content for a placeholder in a view script that is easiest to template; the Placeholder view helper allows you to capture arbitrary content for later rendering using the following API.

  • captureStart($type, $key) begins capturing content.

    $type should be one of the Placeholder constants APPEND or SET. If APPEND, captured content is appended to the list of current content in the placeholder; if SET, captured content is used as the sole value of the placeholder (potentially replacing any previous content). By default, $type is APPEND.

    $key can be used to specify a specific key in the placeholder container to which you want content captured.

    captureStart() locks capturing until captureEnd() is called; you cannot nest capturing with the same placholder container. Doing so will raise an exception.

  • captureEnd() stops capturing content, and places it in the container object according to how captureStart() was called.


placeholder('foo')->captureStart(); 
foreach ($this->data as $datum): ?>

title ?>

content ?>

placeholder('foo')->captureEnd() ?> placeholder('foo') ?>

placeholder('foo')->captureStart('SET', 'data'); 
foreach ($this->data as $datum): ?>

title ?>

content ?>

placeholder('foo')->captureEnd() ?> placeholder('foo')->data ?>

Concrete Placeholder Implementations

Zend Framework ships with a number of "concrete" placeholder implementations. These are for commonly used placeholders: doctype, page title, and various <head> elements. In all cases, calling the placeholder with no arguments returns the element itself.

Documentation for each element is covered separately, as linked below:

L'aide de vue Doctype

Les documents HTML et XHTML valides doivent inclure une déclaration DOCTYPE. Sans compter qu'ils sont difficiles à garder en mémoire, ceux-ci peuvent aussi affecter la façon dont certains éléments du document peuvent être rendus (par exemple, les échappements CDATA dans <script> et les éléments <style>.

L'aide Doctype vous permet de spécifier un des types suivants :

  • XHTML11

  • XHTML1_STRICT

  • XHTML1_TRANSITIONAL

  • XHTML1_FRAMESET

  • XHTML_BASIC1

  • HTML4_STRICT

  • HTML4_LOOSE

  • HTML4_FRAMESET

Vous pouvez aussi spécifier un doctype personnalisé du moment que celui-ci soit correctement formé.

L'aide Doctype est une implémentation concrète de l'aide Conteneur.

Example #8 Utilisation basique de l'aide Doctype

Vous pouvez spécifier le doctype à n'importe quel moment. Cependant, les aides de vues qui utilisent pour leur affichage ne le reconnaissent qu'une fois qu'il a été paramètré, donc la manière la plus simple est de le spécifier dans votre fichier d'amorçage :

doctype('XHTML1_STRICT');

Ensuite vous l'affichez en début de votre layout :

doctype() ?>

Example #9 Récupérer le Doctype

Si vous avez besoin du doctype, vous pouvez le récupérer par l'appel de getDoctype() sur l'objet.

doctype()->getDoctype();
?>

Typiquement, vous pouvez simplement vouloir savoir si le doctype est XHTML ou non ; pour ceci, la méthode isXhtml() vous suffira :

doctype()->isXhtml()) {
    // faire qqch de différent
}
?>

L'aide de vue HeadMeta

L'élément HTML <meta> est utilisé pour fournir des métadonnées concernant votre document HTML - typiquement, les mots-clés, l'encodage du document, les directives de mise en cache, etc. Les balises de métadonnées peuvent être soit de type "http-equiv" ou "name", doivent contenir un attribut "content" et peuvent avoir aussi un attribut modificateur "lang" ou "scheme".

L'aide de vue HeadMeta supporte les méthodes suivantes pour le paramétrage et l'ajout de métadonnées :

  • appendName($keyValue, $content, $conditionalName)

  • offsetSetName($index, $keyValue, $content, $conditionalName)

  • prependName($keyValue, $content, $conditionalName)

  • setName($keyValue, $content, $modifiers)

  • appendHttpEquiv($keyValue, $content, $conditionalHttpEquiv)

  • offsetSetHttpEquiv($index, $keyValue, $content, $conditionalHttpEquiv)

  • prependHttpEquiv($keyValue, $content, $conditionalHttpEquiv)

  • setHttpEquiv($keyValue, $content, $modifiers)

Le paramètre $keyValue est utilisé pour définir une valeur pour la clé "name" ou "http-equiv" ; $content est la valeur pour la clé "content", et $modifiers est un tableau associatif optionel qui peut contenir les clés "lang" et/ou "scheme".

Vous pouvez aussi spécifier les métadonnées en utilisant la méthode headMeta() qui a la signature suivante : headMeta($content, $keyValue, $keyType = 'name', $modifiers = array(), $placement = 'APPEND'). $keyValue est le contenu de la clé spécifiée dans $keyType, qui peut être "name" ou "http-equiv". $placement peut être soit "SET" (efface toutes les valeurs sauvegardées précédentes), soit "APPEND" (ajout en fin de pile), soit "PREPEND" (ajout en début de pile).

HeadMeta surcharge chacune des méthodes append(), offsetSet(), prepend(), et set(), pour imposer l'utilisation des méthodes spéciales énumérées ci-dessus. En interne, il stocke chaque élément sous la forme d'un stdClass, qui peut ensuite être sérialiser grâce à la méthode itemToString(). Ceci vous permet de réaliser des contrôles sur les éléments de la pile, et optionnellement de modifier ces éléments simplement en modifiant l'objet retourné.

L'aide de vue HeadMeta est une implémentation concrète de l'aide Placeholder.

Example #11 Utilisation basique de l'aide HeadMeta

Vous pouvez spécifier une nouvelle métadonnée à n'importe quel moment. Typiquement, vous pouvez spécifier les règles de mise en cache côté client ou les mots clés SEO (Search Engine Optimization : pour l'optimisation des moteurs de recherche).

Par exemple, si vous souhaitez spécifier des mots clés SEO, vous devez créer une métadonnée de type "name" ayant pour nom "keywords" et pour contenu les mots clés que vous souhaitez associer à votre page :

headMeta()->appendName('keywords', 'framework php productivité');
?>

Si vous souhaitez paramètrer des règles de mise en cache côté client, vous devez créer une métadonnée de type "http-equiv" avec les règles que vous souhaitez imposer :

headMeta()->appendHttpEquiv('expires', 'Wed, 26 Feb 1997 08:21:57 GMT')
                 ->appendHttpEquiv('pragma', 'no-cache')
                 ->appendHttpEquiv('Cache-Control', 'no-cache');
?>

Une autre utilisation habituelle des métadonnées est le réglage du type de contenu ("content type"), de l'encodage, et le langage :

headMeta()->appendHttpEquiv('Content-Type', 'text/html; charset=UTF-8')
                 ->appendHttpEquiv('Content-Language', 'fr-FR');
?>

Et comme exemple final, une manière simple d'afficher un message de transition avant une redirection est d'uitliser une métadonnée "refresh" :

headMeta()->appendHttpEquiv('Refresh', '3;URL=http://www.some.org/some.html');
?>

Quand vous êtes prêts à placer vos métadonnées dans votre script de disposition, réalisez un "echo" de l'aide :

headMeta() ?>

L'aide de vue HeadScript

L'élément HTML <script> est utilisé pour à la fois pour fournir des éléments de scripts côté-client dans le code HTML et aussi pour lier une ressource distante contenant du script côté-client. L'aide de vue HeadScript vous permet de gérer ces deux cas.

L'aide de vue HeadScript supportent les méthodes suivantes pour paramétrer ou ajouter des scripts :

  • appendFile($src, $type = 'text/javascript', $attrs = array())

  • offsetSetFile($index, $src, $type = 'text/javascript', $attrs = array())

  • prependFile($src, $type = 'text/javascript', $attrs = array())

  • setFile($src, $type = 'text/javascript', $attrs = array())

  • appendScript($script, $type = 'text/javascript', $attrs = array())

  • offsetSetScript($index, $script, $type = 'text/javascript', $attrs = array())

  • prependScript($script, $type = 'text/javascript', $attrs = array())

  • setScript($script, $type = 'text/javascript', $attrs = array())

Dans le cas des méthodes de type *File(), $src est l'emplacement distant du script à charger ; c'est généralement sous la forme d'une URL ou d'un chemin de fichier. Pour les méthode de type *Script(), $script sont les directives de script côté-client que vous souhaitez utiliser dans l'élément.

HeadScript vous permet aussi de capturer des scripts ; ceci peut être utile si vous voulez créer du script côté-client par programmation, et ensuite le placer n'importe où. Une utilisation de ceci est montré dans un exemple ci-dessous.

Enfin, vous pouvez aussi utiliser la méthode headScript() pour rapidement ajouter des éléments de script ; le prototype dans ce cas est headScript($mode = 'FILE', $spec, $placement = 'APPEND'). Le $mode est soit "FILE", soit "SCRIPT", suivant si vous liez un script ou que vous en définissiez un. $spec est soit le script à lier ou la source du script elle-même. $placement est "APPEND", "PREPEND", ou "SET".

HeadScript surcharge chacun des append(), offsetSet(), prepend(), et set() pour imposer l'utilisation des méthodes spéciales énumérées ci-dessus. En interne, il stocke chaque élément sous la forme d'un stdClass, qui peut être ensuite sérialisé grâce à la méthode itemToString(). Ceci vous permet de réaliser des vérifications sur les éléments dans la pile, et optionnellement de les modifier en modifiant simplement l'objet retourné.

L'aide HeadScript est une implémentation concrète de l'aide Conteneur.

Note: Utilisez InlineScript pour les scripts dans le corps ("body") du HTML

L'aide de vue, InlineScript, similaire à HeadScript devrait être utilisée quand vous souhaitez inclure des scripts dans le corps ("body") du HTML. Placer ces scripts en fin du document est une bonne pratique pour accélérer l'envoi de votre page, particulièrement pour les scripts tiers d'analyse.

Note: Les attributs arbitraires sont désactivées par défaut

Par défaut, HeadScript affichera seulement les attributs de <script> approuvés par le W3C. Ceux-ci inclus "type", "charset", "defer", "language", et "src". Cependant, certaines bibliothèques javascript, notamment » Dojo, utilise des attributs personnalisés dans le but de modifier le comportement. Pour autoriser ce type d'attribut, vous pouvez les activer grâce à la méthode setAllowArbitraryAttributes() :

headScript()->setAllowArbitraryAttributes(true);
?>

Example #12 Utilisation basique de l'aide HeadScript

Vous devriez ajouter une nouvelle balise de script à chaque fois. Comme noté ci-dessus, ceux-ci peuvent être des liens vers des ressources externes ou vers les scripts eux-mêmes.

headScript()->appendFile('/js/prototype.js')
                   ->appendScript($onloadScript);
?>

L'ordre est souvent important avec les scripts côté-client ; vous devez vous assurer de charger les librairies dans un ordre spécifique en fonction de leurs dépendances ; utilisez à la fois les directives append, prepend, et offsetSet pour vous aider dans cette tâche :

headScript()->offsetSetScript(100, '/js/myfuncs.js');

// utiliser les effets de scriptaculous (append utilises l'index suivant, c-à-d. 101)
$this->headScript()->appendScript('/js/scriptaculous.js');

// mais dans tous les cas, le script de base prototype doit être chargé en premier :
$this->headScript()->prependScript('/js/prototype.js');
?>

Quand vous êtes finalement prêt à affichr tous les scripts dans votre layout, faîtes simplement un echo de l'aide :

headScript() ?>

Example #13 Capturer les scripts en utilisant l'aide HeadScript

Parfois vous devez générer des scripts côté-client par programme.Même si vous pouvez employer la concaténation de chaînes, les "heredocs", ou tout autre équivalent, il est souvent plus facile de faire juste la création des scripts et de les entourer par des balises PHP. HeadScript vous permet de le faire, et capture ainsi l'élément dans la pile :

headScript()->captureStart() ?>
var action = 'baseUrl ?>';
$('foo_form').action = action;
headScript()->captureEnd() ?>

Les suppositions suivantes sont considérées :

  • Les déclarations de scripts sont ajoutées à la pile. Si vous souhaitez qu'elles remplacent la pile ou qu'elles soient ajoutées en début de pile, vous devez fournir "SET" ou "PREPEND", en tant que premier argument de captureStart().

  • Le type MIME est considéré comme étant "text/javascript" ; si vous souhaitez spécifier un type différent, vous devez le fournir en tant que deuxième argument de captureStart().

  • Si vous souhaitez spécifier un quelconque attribut additionnel pour la balise <script>, fournissez-le sous la forme d'un tableau en troisième argument de captureStart().

L'aide de vue HeadStyle

L'élément HTML <style> est utilisé pour inclure des feuilles de styles CSS à l'intérieur de l'élément HTML <head>.

Note: Utilisez HeadLink pour lier des fichiers CSS externes

HeadLink devrait être utilisé pour inclure des feuilles de styles externes. HeadScript ne devrait être utilisé que si vous souhaitez définir des feuilles de styles internes.

L'aide de vue HeadStyle supporte les méthodes suivantes pour l'ajout et le paramétrage des déclarations de feuilles de styles :

  • appendStyle($content, $attributes = array())

  • offsetSetStyle($index, $content, $attributes = array())

  • prependStyle($content, $attributes = array())

  • setStyle($content, $attributes = array())

Dans tous les cas, $content est le contenu des déclarations CSS. $attributes sont les attributs additionnels que vous pouvez fournir à la balise style : "lang", "title", "media", ou "dir" sont autorisés.

HeadStyle permet aussi la capture des déclarations de style ; ceci peut être utile si vous voulez créer des déclarations par programme, et ensuite les placer à un autre endroit. L'utilisation de cette fonctionnalité est montrée dans un exemple ci-dessous.

Enfin, vous pouvez utiliser la méthode headStyle() pour ajouter rapidement des éléments de déclarations ; la signature de la méthode est headStyle($content$placement = 'APPEND', $attributes = array()). $placement peut être "APPEND", "PREPEND", ou "SET".

HeadStyle surcharge chacune des méthodes append(), offsetSet(), prepend(), et set() pour imposer l'utilisation des méthodes spéciales listées ci-dessus. En interne, il stocke chaque élément sous la forme d'un stdClass, qui est ensuite sérialisé en utilisant la méthode itemToString(). Ceci vous permet de réaliser des vérifications sur les éléments de la pile, et optionnellement modifier ces éléments en modifiant simplement l'objet retourné.

L'aide HeadStyle est une implémentation concrète de l'aide Placeholder.

Example #14 Utilisation basique de l'aide HeadStyle

Vous pouvez spécifier une nouvelle balise de style à n'importe quel moment :

headStyle()->appendStyle($styles);

L'ordre est très important avec les CSS ; vous pouvez devoir assurer que les déclarations soient chargées dans un ordre spécifique dû à l'ordre de la cascade ; employez les diverses directives "append", "prepend", et "offsetSet" pour faciliter cette tâche :

headStyle()->offsetSetStyle(100, $stylesPerso);

// - placer à la fin
$this->headStyle()->appendStyle($stylesFinaux);

// - placer au début
$this->headStyle()->prependStyle($stylesInitiaux);

Quand vous êtes finalement prêt à afficher toutes les déclarations de styles dans votre script de layout, faîtes un simple echo de l'aide :

headStyle() ?>

Example #15 Capturer les déclarations de style en utilisant l'aide HeadStyle

Parfois vous devez produire des déclarations de styles CSS par programme. Même si vous pouvez employer la concaténation de chaînes, les "heredocs", ou tout autre équivalent, il est souvent plus facile de faire juste la création des styles et de les entourer par des balises PHP. HeadStyle vous permet de le faire, et capture ainsi l'élément dans la pile :

headStyle()->captureStart() ?>
body {
    background-color: bgColor ?>;
}
headStyle()->captureEnd() ?>

Les suppositions suivantes sont considérées :

  • Les déclarations de styles sont ajoutées à la pile. Si vous souhaitez qu'elles remplacent la pile ou qu'elles soient ajoutées en début de pile, vous devez fournir "SET" ou "PREPEND", en tant que premier argument de captureStart().

  • Si vous souhaitez spécifier un quelconque attribut additionnel pour la balise <style>, fournissez-le sous la forme d'un tableau en deuxième argument de captureStart().

L'aide de vue HeadTitle

L'élément HTML <title> est utilisé pour fournir un titre à un document HTML. L'aide HeadTitle vous permet par programme de créer et de stocker le titre afin de le récupérer plus tard et de l'afficher.

L'aide HeadTitle est une implémentation concrète de l'aide Placeholder. Elle surcharge la méthode toString() pour forcer la génération d'un élément <title>, et ajoute une méthode headTitle() pour des réglages faciles et rapides et pour l'aggrégation des éléments du titre. La signature de la méthode est headTitle($title, $setType = 'APPEND') ; par défaut, la valeur est ajoutée en fin de pile (pour aggréger les segments du titre), mais vous pouvez aussi spécifier "PREPEND" (pour l'ajouter en début de pile) ou "SET" (pour remplacer la pile existante).

Example #16 Utilisation basique de l'aide HeadTitle

Vous pouvez spécifier la balise de titre à n'importe quel moment. Un usage typique serait de paramètrer les différents segments du titre à chaque niveau de profondeur de votre application : site, module, contrôleur, action et ressources potentielles.

getRequest();
$this->headTitle($request->getActionName())
     ->headTitle($request->getControllerName());

// Réglage du nom de site, par exemple dans votre script de disposition :
$this->headTitle('Zend Framework');

// Réglage de la haîne de séparation des segments :
$this->headTitle()->setSeparator(' / ');
?>

Quand vous êtes finalement prêt à afficher le titre dans votre script de disposition, faîtes simplement un echo de l'aide :


headTitle() ?>

L'aide de vue HTML Object

L'élément HTML <object> est utilisé pour inclure un média comme Flash ou QuickTime dans les pages Web. L'aide de vue Object vous aide à réaliser ceci avec un minimum d'effort.

Il existe quatre aides de vue Object initiaux :

  • formFlash : génère le balisage pour l'inclusion de fichiers Flash.

  • formObject : génère le balisage pour l'inclusion d'objets personnalisés.

  • formPage : génère le balisage pour l'inclusion d'autres pages (X)HTML.

  • formQuicktime : génère le balisage pour l'inclusion de fichiers QuickTime.

Toutes ces aides partagent une interface similaire. Pour cette raison, cette documentation ne présentera des exemples que pour deux de ces aides.

Example #17 Aide de vue Flash

Inclure du Flash dans votre page est assez simple. Le seul argument requis est l'URI de la ressource.

htmlFlash('/path/to/flash.swf'); ?>

Ceci affichera le code HTML suivant :


Cependant vous pouvez aussi spécifier des attributs, des paramètres et du contenu qui peuvent être affichés avec la balise <object>. Ceci peut être montré avec l'aide de vue htmlObject.

Example #18 Personnalisation d'un objet en fournissant des arguments additionnels

Le premier argument de l'aide Object est toujours requis. Il s'agit de l'URI de la ressource à inclure. Le second argument est seulement requis par l'aide htmlObject. Les autres aides contiennent déjà la bonne valeur pour cet argument. Le troisième argument est utilisé pour fournir des attributs à l'élément object. Seul un tableau de paires clé/valeur est accepté. classid ou codebase sont des exemples de tels attributs. Le quatrième paramètre ne prend aussi qu'un tableau de paires clé/valeur est les utilise pour créer des éléments <param>. Enfin, vous avez la possibilité de fournir un contenu additionnel à l'objet en cinquième paramètre. Voici donc un exemple qui utilise tous le paramètres :

htmlObject(
    '/path/to/file.ext', 
    'mime/type', 
    array(
        'attr1' => 'aval1', 
        'attr2' => 'aval2'
    ), 
    array(
        'param1' => 'pval1', 
        'param2' => 'pval2'
    ), 
    'some content'
); ?>

Ceci affichera le code HTML suivant :


    
    
    some content

L'aide de vue InlineScript

L'élément HTML <script> est utilisé pour fournir des éléments de script côté client ou pour lier des ressources distantes contenant des scripts s'exécutant côté client. L'aide de vue InlineScript vous permet de gérer ces deux cas. Elle est dérivée de l'aide HeadScript, et chaque méthode de cette aide est donc disponible ; cependant, vous devez utiliser la méthode inlineScript() au lieu de headScript().

Note: Utiliser InlineScript pour des scripts dans le corps ("body") HTML

InlineScript, peut être utilisé quand vous souhaitez inclure des scripts dans votre body HTML. Placer ces scripts en fin de votre document est une bonne pratique pour améliorer la vitesse de distribution de votre page, particulièrement quand vous utilisez des scripts d'analyses fournis par des tiers.

Certaines librairies JS doivent être incluses dans la partie head du HTML ; utilisez l'aide vue HeadScript pour ces scripts.

L'aide de vue JSON

Quand vous créez des vues qui retournent du JSON, il est important de paramètrer aussi les entêtes de réponse appropriés. L'aide vue JSON réalise exactement cela. De plus, par défaut, elle désactive l'éventuel layout (s'il est activé), puisque les layouts sont rarement utilisés dans les réponses JSON.

L'aide de vue JSON ajoute l'entête suivant :

Content-Type: application/json

Beaucoup de librairies AJAX recherche cet entête quand elles analysent les réponses pour déterminer comment le contenu doit être géré.

L'utilisation de l'aide de vue JSON est très simple :

json($this->data) ?>

Translate Helper

Often web sites are available in several languages. To translate the content of a site you should simply use Zend Translate and to integrate Zend Translate within your view you should use the Translate View Helper.

In all following examples we are using the simple Array Translation Adapter. Of course you can also use any instance of Zend_Translate and also any subclasses of Zend_Translate_Adapter. There are several ways to initiate the Translate View Helper:

  • Registered, through a previously registered instance in Zend_Registry

  • Afterwards, through the fluent interface

  • Directly, through initiating the class

A registered instance of Zend_Translate is the preferred usage for this helper. You can also select the locale to be used simply before you add the adapter to the registry.

Note:

We are speaking of locales instead of languages because a language also may contain a region. For example English is spoken in different dialects. There may be a translation for British and one for American English. Therefore, we say "locale" instead of "language."

Example #19 Registered instance

To use a registered instance just create an instance of Zend_Translate or Zend_Translate_Adapter and register it within Zend_Registry using Zend_Translate as its key.

 'einfach'), 'de');
Zend_Registry::set('Zend_Translate', $adapter);

// within your view
echo $this->translate('simple');
// this returns 'einfach'
?>

If you are more familiar with the fluent interface, then you can also create an instace within your view and initiate the helper afterwards.

Example #20 Within the view

To use the fluent interface, create an instance of Zend_Translate or Zend_Translate_Adapter, call the helper without a parameter, and call the setTranslator() method.

 'einfach'), 'de');
$this->translate()->setTranslator($adapter)->translate('simple');
// this returns 'einfach'
?>

If you are using the helper without Zend_View then you can also use it directly.

Example #21 Direct usage

 'einfach'), 'de');

// initiate the adapter
$translate = new Zend_View_Helper_Translate($adapter);
print $translate->translate('simple'); // this returns 'einfach'
?>

You would use this way if you are not working with Zend_View and need to create translated output.

As already seen, the translate() method is used to return the translation. Just call it with the needed messageid of your translation adapter. But it can also replace parameters within the translation string. Therefore, it accepts variable parameters in two ways: either as a list of parameters, or as an array of parameters. As examples:

Example #22 Single parameter

To use a single parameter just add it to the method.

translate("Today is %1\$s", $date);
// could return 'Heute ist Monday'
?>

Note:

Keep in mind that if you are using parameters which are also text, you may also need to translate these parameters.

Example #23 List of parameters

Or use a list of parameters and add it to the method.

translate("Today is %1\$s in %2\$s. Actual time: %3\$s", $date, $month, $time);
// Could return 'Heute ist Monday in April. Aktuelle Zeit: 11:20:55'
?>

Example #24 Array of parameters

Or use an array of parameters and add it to the method.

translate("Today is %1\$s in %2\$s. Actual time: %3\$s", $date);
// Could return 'Heute ist Monday in April. Aktuelle Zeit: 11:20:55'
?>

Sometimes it is necessary to change the locale of the translation. This can be done either dynamically per translation or statically for all following translations. And you can use it with both a parameter list and an array of parameters. In both cases the locale must be given as the last single parameter.

Example #25 Change locale dynamically

translate("Today is %1\$s in %2\$s. Actual time: %3\$s", $date, 'it');
?>

This example returns the Italian translation for the messageid. But it will only be used once. The next translation will use the locale from the adapter. Normally you will set the desired locale within the translation adapter before you add it to the registry. But you can also set the locale from within the helper:

Example #26 Change locale statically

translate()->setLocale('it');
$this->translate("Today is %1\$s in %2\$s. Actual time: %3\$s", $date);
?>

The above example sets 'it' as the new default locale which will be used for all further translations.

Of course there is also a getLocale() method to get the currently set locale.

Example #27 Get the currently set locale

translate()->getLocale();

$this->translate()->setLocale('it');
$this->translate("Today is %1\$s in %2\$s. Actual time: %3\$s", $date);

// returns 'it' as new set default locale
$this->translate()->getLocale();
?>

Chemin des aides

Comme pour les scripts de vue, votre contrôleur peut spécifier une pile de chemins dans lesquels Zend_View cherchera les classes d'aides. Par défaut, Zend_View cherche dans "Zend/View/Helper/*". Vous pouvez dire à Zend_View de regarder dans d'autres chemins en utilisant les méthodes setHelperPath() et addHelperPath(). De plus, vous pouvez indiquer un préfixe de classe pour utiliser les aides dans le répertoire fourni, et permettre de donner des espaces de noms à vos classes d'aide. Par défaut, si aucun préfixe n'est fourni, "Zend_View_Helper_" est utilisé.

$view = new Zend_View();
$view->setHelperPath('/chemin/vers/plus/de/classes/d-aides', 'Ma_View_Helper');

En fait, vous pouvez "empiler" les chemins en utilisant la méthode addHelperPath(). Comme vous ajoutez des chemins dans la pile, Zend_View va regarder dans le chemin le plus récemment ajouté, pour inclure la classe d'aide. Cela vous permet d'ajouter (ou bien de redéfinir) la distribution initiale des aides, avec vos propres aides personnalisées.

$view = new Zend_View();

// Ajoute /chemin/vers/des/aides avec le préfixe de classe 'Ma_View_Helper'
$view->addHelperPath('/chemin/vers/des/aides', 'Ma_View_Helper');
// Ajoute /autre/chemin/vers/des/aides avec le préfixe de classe 'Votre_View_Helper'
$view->addHelperPath('/autre/chemin/vers/des/aides', 'Votre_View_Helper');

// maintenant, lorsque vous appelerez $this->helperName(), Zend_View
// va rechercher en premier /autre/chemin/vers/des/aides/HelperName.php en utilisant la classe "Votre_View_Helper_HelperName",
// et ensuite dans /chemin/vers/des/aides/HelperName.php en utilisant la classe "Ma_View_Helper_HelperName",
// et finalement dans Zend/View/Helpers/HelperName.php en utilisant la classe "Zend_View_Helper_HelperName"

Écrire des aides personnalisées

Écrire des aides personnalisées est facile, vous devez juste suivre ces règles :

  • Le nom de la classe doit, au minimum, se terminer avec le nom de l'aide en utilisant une notation en casseMélangée. Par exemple, si vous écrivez une aide appelée "actionSpeciale", le nom de la classe doit être au minimum "ActionSpeciale". Vous devriez donner au nom de la classe un préfixe, et il est recommandé d'utiliser "Ma_View_Helper" comme partie de ce préfixe : "Ma_View_Helper_ActionSpeciale". (Vous devez alors fournir le préfixe, avec ou sans le tiret bas, à addHelperPath() ou à setHelperPath()).

  • La classe doit avoir une méthode publique dont le nom correspond au nom de l'aide ; c'est la méthode qui sera appelée quand votre template appellera $this->actionSpeciale(). Dans notre exemple $this->actionSpeciale(), la déclaration de méthode requise serait public function actionSpeciale().

  • En général, la classe ne devrait pas afficher directement les données (via echo ou print). Elle devrait retourner les valeurs pour être ensuite affichées. Les valeurs retournées devrait être échappées de façon appropriées.

  • La classe doit être dans un fichier ayant le même nom que la méthode d'aide. Si on utilise la méthode actionSpeciale(), le fichier devra être nommé "ActionSpeciale.php"

Placez le fichier de classe d'aide quelque part dans la pile des chemins d'aide, et Zend_View le chargera, l'instanciera, le rendra persistant, et l'exécutera automatiquement pour vous.

Voici un exemple de fichier "ActionSpeciale.php" :

class Ma_View_Helper_ActionSpeciale
{
    protected $_count = 0;
    public function actionSpeciale()
    {
        $this->_count++;
        $output = "J'ai vu 'The Big Lebowsky' {$this->_count} fois.";
        return htmlspecialchars($output);
    }
}

Ensuite, dans un script de vue, vous pouvez appeler l'aide ActionSpeciale autant de fois que vous le souhaitez ; elle sera instanciée une fois, et rendue persistante pendant toute la vie de l'instance de Zend_View.

// rappelez vous, $this se réfère à l'instance de Zend_View
echo $this->actionSpeciale();
echo $this->actionSpeciale();
echo $this->actionSpeciale();

La sortie pourrait alors ressembler à ceci :

J'ai vu 'The Big Lebowsky' 1 fois.
J'ai vu 'The Big Lebowsky' 2 fois.
J'ai vu 'The Big Lebowsky' 3 fois.

Quelquefois vous devez accéder à l'objet Zend_View appelant - par exemple, si vous devez utiliser l'encodage enregistré ou voulez effectuer le rendu d'un autre script de vue comme une sous partie de votre aide. Pour avoir accès à votre objet de vue, votre classe d'aide doit avoir une méthode setView($view), comme ceci :

class Ma_View_Helper_ScriptPath
{
    public $view;

    public function setView(Zend_View_Interface $view)
    {
        $this->view = $view;
    }

    public function scriptPath($script)
    {
        return $this->view->getScriptPath($script);
    }
}

Si votre classe d'aide a une méthode setView(), elle sera appelée quand votre classe sera instanciée la première fois et fournira l'objet de la vue courante. Il est de votre responsabilité de maintenir la persistance de l'objet dans votre classe, de même que de déterminer la façon dont il peut être accéder.

Previous Next
Introduction to Zend Framework
Présentation
Installation
Zend_Acl
Introduction
Affiner les Contrôles d'Accès
Utilisation avancée
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
La théorie du cache
Les frontends Zend_Cache
Les backends Zend_Cache
Zend_Captcha
Introduction
Captcha Operation
Captcha Adapters
Zend_Config
Introduction
Point de vue théorique
Zend_Config_Ini
Zend_Config_Xml
Zend_Console_Getopt
Introduction à Getopt
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 : Zend_Controller_Router_Rewrite
Le dispatcheur
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
Point de vue 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
Validators for 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 Quick Start
Creating Form Elements Using Zend_Form_Element
Creating Forms Using Zend_Form
Creating Custom Form Markup Using Zend_Form_Decorator
Standard Form Elements Shipped With Zend Framework
Standard Form Decorators Shipped With Zend Framework
Internationalization of Zend_Form
Advanced Zend_Form Usage
Zend_Gdata
Introduction à Gdata
Authentification par procédé AuthSub
Authentification avec ClientLogin
Using Google Calendar
Using Google Documents List Data API
Using Google Spreadsheets
Using Google Apps Provisioning
Using Google Base
Utiliser l'API YouTube
Utilisation des albums Web Picasa
Attraper les exceptions Gdata
Zend_Http
Zend_Http_Client - 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
Objets 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
Chargeur de Plugins
Zend_Locale
Introduction
Using Zend_Locale
Normalization and Localization
Working with Dates and Times
Supported Languages for Locales
Supported Regions for Locales
Zend_Log
Présentation
Rédacteurs (Writers)
Formateurs (mise en forme)
Filtres
Zend_Mail
Introduction
Envoyer des emails en utilisant SMTP
Envoyer plusieurs emails par connexion SMTP
Utiliser différents transports
Email HTML
Fichiers joints
Ajouter des destinataires
Contrôler les limites MIME
Entêtes additionnelles
Jeux de caractères
Encodage
Authentification SMTP
Sécuriser les transports SMTP
Lire des emails
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_OpenId
Introduction
Zend_OpenId_Consumer Basics
Zend_OpenId_Provider
Zend_Paginator
Introduction
Usage
Configuration
Advanced usage
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_Registry
Utiliser le registre
Zend_Rest
Introduction
Zend_Rest_Client
Zend_Rest_Server
Zend_Search_Lucene
Overview
Building Indexes
Searching an Index
Query Language
Query Construction API
Character Set
Extensibility
Interoperating with Java Lucene
Advanced
Best Practices
Zend_Server
Introduction
Zend_Server_Reflection
Zend_Service
Introduction
Zend_Service_Akismet
Zend_Service_Amazon
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_Yahoo
Zend_Session
Introduction
Usage basique
Utilisation avancée
Global Session Management
Zend_Session_SaveHandler_DbTable
Zend_Soap
Zend_Soap_Server
Zend_Soap_Client
WSDL Accessor
AutoDiscovery. Introduction
Class autodiscovering.
Functions autodiscovering.
Autodiscovering. Datatypes.
Zend_Test
Introduction
Zend_Test_PHPUnit
Zend_Text
Zend_Text_Figlet
Zend_TimeSync
Introduction
Utiliser Zend_TimeSync
Zend_Translate
Introduction
Adaptateurs pour Zend_Translate
Utiliser les adaptateurs de traduction
Zend_Uri
Zend_Uri
Zend_Validate
Introduction
Classes de validation standard
Chaînes de validation
Ecrire des validateurs
Zend_Version
Lire la version du 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
Configuration système requise par le Zend Framework
Version de PHP requise
Extensions PHP
Les composants du Zend Framework
Dépendances internes du Zend Framework
Convention de codage PHP du Zend Framework
Vue d'ensemble
Formatage des fichiers PHP
Conventions de nommage
Style de codage
Informations de copyright