Zend Framework 1.7.9 - Aides de vue

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



    Votre email :
        formText('email',
                                   'vous@exemple.fr',
                                   array('size' => 32)) ?>
    
    Votre pays :
        formSelect('country',
                                     'us',
                                     null,
                                     $this->pays) ?>
    
    ??? Would you like to opt in ???
        formCheckbox('opt_in',
                                       'oui',
                                       null,
                                       array('oui', 'non')) ?>

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


    Votre email :
        
    
    Votre pays :
        
    
    ??? Would you like to opt in ???

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 retourneront 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 :


    
        action('list', 'comment', null, array('count' => 10)); ?>

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.

Note: Compteur de PartialLoop

L'aide de vue PartialLoop assigne une variable à la vue nommée partialCounter qui fournit la position courante du tableau au script de vue. Ce qui permet simplement d'avoir des couleurs alternatives dans les lignes d'un tableau par exemple.

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

Si votre modèle est un objet, vous pouvez vouloir le fournir en tant qu'objet au script partiel, plutôt que de le sérialiser en un tableau de variables. Vous pouvez faire ceci en paramétrant la propriété "objectKey" de l'aide de vue approprié :
// Tell partial to pass objects as 'model' variable
$view->partial()->setObjectKey('model');

// Tell partial to pass objects from partialLoop as 'model' variable in final
// partial view script:
$view->partialLoop()->setObjectKey('model');
Cette technique est particulièrement utile quand vous fournissez un Zend_Db_Table_Rowsets à partialLoop(), ainsi vous avez un accès complet à vos objets Row à l'intérieur de vos scripts de vue, permettant d'appeler des méthodes sur ceux-ci (comme récupérer des valeurs d'un Row parent ou dépendant).

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 :

$model = array(
    array('key' => '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.

L'aide de vue Placeholder

Note:
NDT. : Le terme "placeholder est conservé car sa signification varie en fonction du contexte : conteneur générique ou emplacement réservé.

L'aide de vue Placeholder est utilisé pour faire persister le contenu entre les scripts de vues et les instances de vues. Il offre aussi des fonctionnalités utiles comme l'agrégation de contenu, la capture de contenu de scripts de vues pour une utilisation ultérieure, et l'ajout de texte pré ou post contenu (et la personnalisation des séparateurs de contenu).

Example #5 Utilisation basique des Placeholders

L'utilisation basique des placeholders est la persistance des données de vue. Chaque appel de l'aide Placeholder attend un nom de placeholder ; l'aide retourne un objet conteneur que vous pouvez soit manipuler ou simplement envoyé à l'affichage.

placeholder('foo')->set("Du texte pour plus tard") ?>

placeholder('foo'); 
    // outputs "Du texte pour plus tard"
?>

Example #6 Utilisation des Placeholders pour agréger du contenu

L'agrégation du contenu via les placeholders peut être aussi utile parfois. Par exemple, votre script de vue peut avoir une variable sous forme de tableau à partir de laquelle vous souhaitez récupérer des messages à afficher plus tard ; un autre script de vue peut ensuite déterminer de la manière suivant laquelle ils seront affichés.

L'aide de vue Placeholder utilise des conteneurs qui étendent ArrayObject, fournissant de riches fonctionnalités de manipulations des tableaux. De plus, il offre une variété de méthodes pour le formatage du contenu stockée dans le conteneur :

setPrefix($prefix) paramètre le texte qui sera placé préalablement à tout le contenu. Utilisez getPrefix() à tout moment pour déterminer le réglage courant.
setPostfix($prefix) paramètre le texte qui sera placé après tout le contenu. Utilisez getPostfix() à tout moment pour déterminer le réglage courant.
setSeparator($prefix) paramètre le texte qui sera placé entre chaque élément de contenu. Utilisez getSeparator() à tout moment pour déterminer le réglage courant.
setIndent($prefix) peut être utilisé pour paramétrer une indentation pour chaque élément du contenu. Si un entier est fourni, il s'agira du nombre d'espaces à utiliser ; si une chaîne est fournie, elle sera utilisée. Utilisez getIndent() à tout moment pour déterminer le réglage courant.


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


placeholder('foo')->setPrefix("\n    ")
                         ->setSeparator("
\n") 
                         ->setIndent(4)
                         ->setPostfix("\n");
?>

placeholder('foo'); 
    // affiche une liste non-ordonnée avec une belle indentation
?>

Puisque l'objet conteneur Placeholder étend ArrayObject, vous pouvez ainsi facilement assigner du contenu à une clé du conteneur en particulier, plutôt que de simplement de les envoyer les unes après les autres ("push"). Les clés peuvent être accédées soit en utilisant les propriétés d'objet ou comme les clés d'un tableau.

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

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

Example #7 Utilisation des Placeholders pour capturer le contenu

Occasionnellement vous pouvez avoir du contenu pour un placeholder dans un script de vue qui est simple à mettre sous forme de modèle ("template") ; l'aide de vue Placeholder vous permet de capturer tout contenu arbitraire pour un rendu ultérieur en utilisant l'API suivante.

captureStart($type, $key) commence la capture de contenu.

$type doit être une des constantes de Placeholder : APPEND ou SET. Si c'est APPEND, le contenu capturé est ajouté à la liste de contenu courant dans le placeholder ; si c'est SET, le contenu capturé remplace toute valeur existante dans le placeholder (potentiellement permet de remplacer tout contenu préalable). Par défaut, $type vaut APPEND.

$key peut être utilisé pour spécifier une clé en particulier dans le conteneur placeholder dans laquelle vous souhaitez capturer le contenu.

captureStart() verrouille la capture jusqu'à l'appel de captureEnd() ; vous ne pouvez pas imbriquer des captures avec le même conteneur placeholder. Le faire entraînera la levée d'une exception.
captureEnd() stoppe la capture de contenu, et le place dans l'objet conteneur suivant la manière utilisée pour appeler captureStart().


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

Implémentation concrète des Placeholder

Le Zend Framework embarque certaines implémentations concrètes de placeholders. Celles-ci sont destinées à des placeholders communément utilisés : doctype, titre de page, et les différents éléments <head>. Dans tous les cas, appeler le placeholder sans arguments retournera l'élément lui-même.

La documentation pour chacun des éléments existe séparément, suivez les liens ci-dessous :

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 :

$doctypeHelper = new Zend_View_Helper_Doctype();
$doctypeHelper->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 = $view->doctype()->getDoctype();

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

if ($view->doctype()->isXhtml()) {
    // faire qqch de différent
}

L'aide de vue HeadLink

L'élément HTML <link> est de plus en plus employé pour lier différents types de ressources à votre site : feuilles de styles, syndication, icônes, trackbacks et d'autres. L'aide HeadLink fournit une interface simple pour créer et agréger ces éléments pour la récupération postérieure et le rendement dans votre script d'affichage.

L'aide HeadLink possède des méthodes pour ajouter des liens de feuilles de style dans sa pile :

appendStylesheet($href, $media, $conditionalStylesheet)
offsetSetStylesheet($index, $href, $media, $conditionalStylesheet)
prependStylesheet($href, $media, $conditionalStylesheet)
setStylesheet($href, $media, $conditionalStylesheet)

La valeur par défaut de $media vaut screen, mais peut être n'importe quelle valeur de média valide. $conditionalStylesheet est une chaîne ou le booléen false, et sera utilisé au moment du rendu pour déterminer si des commentaires spéciaux doivent être inclus pour empêcher le chargement de la feuille de style sur certaines plate-formes.

De plus, l'aide HeadLink possède des méthodes pour ajouter des liens alternatifs dans sa pile :

appendAlternate($href, $type, $title)
offsetSetAlternate($index, $href, $type, $title)
prependAlternate($href, $type, $title)
setAlternate($href, $type, $title)

La méthode headLink() de l'aide permet de spécifier tous les attributs nécessaires à un élément <link>, et vous permet aussi de préciser l'emplacement - le nouvel élément peut remplacer tous les autres, s'ajouter au début ou à la fin de la liste.

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

Example #10 Utilisation basique de l'aide HeadLink

Vous pouvez spécifier un headLink à n'importe quel moment. Typiquement, vous pouvez spécifier des liens globaux dans votre script de disposition, et des liens spécifiques à l'application dans vos scripts de vue. Dans votre script de disposition, dans la section <head>, vous pourrez ensuite afficher le résultat de l'aide.

headLink()->appendStylesheet('/styles/basic.css')
                 ->headLink(array('rel' => 'favicon',
                                  'href' => '/img/favicon.ico'),
                            'PREPEND')
                 ->prependStylesheet('/styles/moz.css',
                                     'screen',
                                     true);
?>


headLink() ?>

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 :

// paramètrage des mots clés
$this->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 :

// désactiver la mise en cache côté client
$this->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 :

// régler le type de contenu et l'encodage
$this->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'utiliser une métadonnée "refresh" :

// paramètrer une métadonnée refresh pour 3 secondes
// avant une nouvel URL :
$this->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() :
$this->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.

// ajout de scripts
$this->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 :

// mettre les scripts dans l'ordre

// placer celui-ci à un offset particulier pour s'assurer
// de le charger en dernier
$this->headScript()->offsetSetFile(100, '/js/myfuncs.js');

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

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

Quand vous êtes finalement prêt à afficher 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 :

// ajout de styles
$this->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 :

// Mettre les styles dans le bon ordre

// - placer à un offset particulier
$this->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.

// Paramétrage des noms de contrôleurs et d'action
// en tant que segment de titre :
$request = Zend_Controller_Front::getInstance()->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 :

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

L'aide de vue Translate

Souvent le sites Web sont disponibles en plusieurs langues. Pour traduire le contenu d'un site, vous pouvez simplement utiliser Zend Translate et pour intégrer Zend Translate à l'intérieur de vos vues, vous devriez utiliser l'aide de vue Translate.

Dans tous les exemples suivants nous allons utiliser l'adaptateur de traduction Array. Bien sûr vous pouvez aussi utiliser toute instance de Zend_Translate ainsi que toutes sous-classes de Zend_Translate_Adapter. Il y a plusieurs manières d'initialiser l'aide de vue Translate :

enregistré préalablement dans Zend_Registry
après, par l'interface fluide
directement en initialisant la classe

Une instance préalablement enregistré de Zend_Translate est l'utilisation préférée pour cette aide. Vous pouvez ainsi sélectionner la locale à utiliser avant d'ajouter l'adaptateur dans le registre.

Note:
Nous parlons de locales et non de langues car une langue peut aussi contenir une région. Par exemple l'anglais est parlé en différents dialectes. Il peut y avoir une traduction pour l'anglais et une pour l'américain. Ainsi, nous disons "locale" plutôt que "langues".

Example #19 Instance enregistrée

Pour utiliser une instance enregistrée, créez une instance de Zend_Translate ou Zend_Translate_Adapter et enregistrez la dans Zend_Registry en utilisant la clé Zend_Translate.

// notre adaptateur d'exemple
$adapter = new Zend_Translate('array', array('simple' => 'einfach'), 'de');
Zend_Registry::set('Zend_Translate', $adapter);

// à l'intérieur de votre vue
echo $this->translate('simple');
// ceci retourne 'einfach'

Si vous êtes plus familier avec l'interface fluide, alors vous pouvez aussi créer une instance à l'intérieur de votre vue et initialiser l'aide ensuite.

Example #20 A l'intérieur de la vue

Pour utiliser l'interface fluide, créez une instance de Zend_Translate ou Zend_Translate_Adapter, appelez l'aide sans paramètres, et appelez la méthode setTranslator().

// à l'intérieur de votre vue
$adapter = new Zend_Translate('array', array('simple' => 'einfach'), 'de');
$this->translate()->setTranslator($adapter)->translate('simple');
// ceci retourne 'einfach'

Si vous utilisez votre aide sans Zend_View, alors vous pouvez aussi l'utiliser directement.

Example #21 Utilisation directe

// notre adaptateur d'exemple
$adapter = new Zend_Translate('array', array('simple' => 'einfach'), 'de');

// initialiser l'adaptateur
$translate = new Zend_View_Helper_Translate($adapter);
print $translate->translate('simple');
// ceci retourne 'einfach'

Vous devriez utiliser cette façon de faire si vous ne travaillez pas avec Zend_View et que vous avez besoin de créer des affichages traduits.

Comme vu auparavant, la méthode translate() est utilisé pour retourner la traduction. Appelez la simplement avec l'identifiant de message de votre adaptateur de traduction. Mais il peut aussi avoir à remplacer des paramètres dans la chaîne de traduction. Donc, il accepte des paramètres de deux manières : soit comme une liste de paramètres, soit comme un tableau de paramètres. Par exemple :

Example #22 Paramètres unique

Pour utiliser un paramètre unique, ajoutez le en fin de méthode :

// à l'intérieur de votre vue
$date = "Monday";
$this->translate("Today is %1\$s", $date);
// ceci retourne 'Heute ist Monday'

Note:
Gardez à l'esprit que si vous utilisez des paramètres qui sont aussi des textes, vous pouvez aussi avoir à traduire ces paramètres.

Example #23 Liste de paramètres

Ou utiliser une liste de paramètres et ajoutez les en fin de méthode :

// à l'intérieur de votre vue
$date = "Monday";
$month = "April";
$time = "11:20:55";
$this->translate("Today is %1\$s in %2\$s. Actual time: %3\$s",
                 $date,
                 $month,
                 $time);
// ceci retourne 'Heute ist Monday in April. Aktuelle Zeit: 11:20:55'

Example #24 Tableau de paramètres

Ou utiliser un tableau de paramètres et ajoutez le en fin de méthode :

// à l'intérieur de votre vue
$date = array("Monday", "April", "11:20:55");
$this->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'

Parfois il est nécessaire de changer la locale pour une traduction. Ceci peut être fait soit dynamiquement par traduction ou statiquement pour toutes les traductions suivantes. Et vous pouvez utiliser ceci avec une liste de paramètres ou un tableau de paramètres. Dans les deux cas la locale doit être fournie comme un paramètre unique final.

Example #25 Changement dynamique de la locale

// à l'intérieur de votre vue
$date = array("Monday", "April", "11:20:55");
$this->translate("Today is %1\$s in %2\$s. Actual time: %3\$s", $date, 'it');

Cet exemple retourne la traduction italienne pour l'identifiant de message. Mais la locale ne sera utilisée qu'une seule fois. La traduction suivante utilisera la locale de l'adaptateur. Normalement vous réglerez la locale au niveau de votre adaptateur avant de le mettre dans le registre. Mais vous pouvez aussi paramétrer la locale avec l'aide de vue :

Example #26 Changement statique de la locale

// à l'intérieur de votre vue
$date = array("Monday", "April", "11:20:55");
$this->translate()->setLocale('it');
$this->translate("Today is %1\$s in %2\$s. Actual time: %3\$s", $date);

L'exemple ci-dessus paramètre 'it' comme nouvelle locale par défaut, elle sera utilisée pour toutes les traductions ultérieures.

Bien sûr il existe aussi la méthode getLocale() pour récupérer le réglage courant de la locale.

Example #27 Récupération de la locale courante

// à l'intérieur de votre vue
$date = array("Monday", "April", "11:20:55");

// retourne 'de' comme réglé dans les exemples précédents
$this->translate()->getLocale();

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

// retourne 'it' comme nouvelle locale par défaut
$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 :

Bien qu'il ne soit pas strictement nécessaire, il est recommandé soit d'implémenter Zend_View_Helper_Interface ou d'étendre Zend_View_Helper_Abstract quand vous créez vos aides. Introduit en 1.6.0, ceux-ci définissent la méthode setView() ; cependant, dans les prochaines releases, nous prévoyons d'implémenter un motif de conception Stratégie qui permettra de simplifier en grande partie le schéma de nomination détaillé ci-dessous. Contruire sur ces bases à partir de maintenant vous aidera pour vos codes futurs.
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.

Zend Framework 1.7.9 Manual