Zend Framework 1.10.9 Manual
|
|
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().
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.
La sortie résultante du script de vue ressemblera à ceci :
L'aide de vue Action permet à des scripts de vue de distribuer une action
donnée d'un contrôleur ; le résultat de l'objet de réponse suivant la distribution 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.
Exemple #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 :
La plupart des URLs générées par le framework possèdent l' URL de base préfixée automatiquement. Les développeurs ont besoin de la rajouter à la main à leurs propres URLs afin de garder une correspondance chemins - ressources correcte.
L'utilisation de l'aide de vue BaseUrl est très simple:
/* * Imaginons une URL de base dans page/application de "/mypage". */ /* * affiche: **/ /* * affiche: * */
Note:
Pour plus de simplicité, le fichier PHP (par exemple "index.php") est enelevé de l'URL de base gérée par
Zend_Controller. Cependant, si ceci vous gène, utilisez $this->getHelper('BaseUrl')->setBaseUrl() pour affecter votre propre BaseUrl.
Afficher des informations de monnaie localisées est très courant; l'aide de vue de
Zend_Currency est dédiée à cela. Voyez le chapitre
sur Zend Currency pour les détails sur la
localisation. Dans cette section, nous apprendrons à manipuler l'aide de vue uniquement.
Il existe plusieurs manières d'initialiser l'aide de vue Currency:
Enrigistrée dans une instance de
Zend_Registry.
Grâce à une interface fluide.
En instanciant directement la classe.
L'enregistrement en registre de Zend_Currency est la manière recommandée.
Grâce à cela vous pouvez selectionner la monnaie à utiliser puis ajouter son adaptateur au registre.
Pour séléctionner la valeur de la monnaie à utiliser, passez une chaine ou encore une locale ce qui est recommandé car les informations provenant du client HTTP seront alors utilisées par défaut.
Note:
Nous parlons bien de "locales" et non de "langues" car la langue peut varier en fonction de la position géorgraphique au sein d'un même pays.Par exemple, l'anglais est parlé dans différents dialectes : Anglais ou Américain. Une monnaie est liée directement à une région, vous devrez donc utiliser une locale complète c'est à dire représentant le pays et la région. Nous parlons donc de "locale" plutôt que de "langue."
Exemple #2 Instance en registre
Pour utiliser une instance en registre, créez une instance de
Zend_Currency et enregistrez la dans
Zend_Registry en utilisant la clé
Zend_Currency.
// notre monnaie d'exemple
$currency = new Zend_Currency('de_AT');
Zend_Registry::set('Zend_Currency', $currency);
// Dans votre vue
echo $this->currency(1234.56);
// Ceci affiche '€ 1.234,56'
Si vous préférez utiliser l'interface fluide, vous pouvez alors créer une instance dans votre vue et la configurer après cela.
Exemple #3 Instance dans la vue
Pour utiliser l'interface fluide, créez une instance de Zend_Currency,
appelez l'aide de vue sans paramètre et appelez ensuite la méthode setCurrency().
// Dans votre vue
$currency = new Zend_Currency('de_AT');
$this->currency()->setCurrency($currency)->currency(1234.56);
// Ceci affiche '€ 1.234,56'
Si vous utilisez l'aide sans Zend_View alors vous pouvez aussi
l'utiliser de manière directe, via instanciation manuelle.
Exemple #4 Utilisation directe via instanciation
// Notre monnaie d'exemple
$currency = new Zend_Currency('de_AT');
// Initialisation de l'aide de vue
$helper = new Zend_View_Helper_Currency($currency);
echo $helper->currency(1234.56); // Ceci affiche '€ 1.234,56'
Comme déja vu, la méthode currency() est utilisée pour retourner la chaine représentant la monnaie. Appelez la simplement avec la valeur que vous voulez voir affichée. Des options sont aussi disponibles, elles servent à changer le comportement interne de l'aide.
Exemple #5 Utilisation directe
// Notre monnaie d'exemple
$currency = new Zend_Currency('de_AT');
// Initialisation de l'aide de vue
$helper = new Zend_View_Helper_Currency($currency);
echo $helper->currency(1234.56); // Ceci affiche '€ 1.234,56'
echo $helper->currency(1234.56, array('precision' => 1));
// Ceci affiche '€ 1.234,6'
Concernant les options disponibles, voyez la méthode
toCurrency() de Zend_Currency.
L'aide Cycle est utilisée pour alterner des valeurs.
Exemple #6 Aide Cycle : utilisation de base
Pour ajouter des éléments dans le cycle, spécifiez le simplement dans le constructeur ou utilisez assign(array $data)
books as $book):?>next()?>"> // Mouvement dans le sens inverse $this->cycle()->assign(array("#F0F0F0","#FFFFFF")); $this->cycle()->prev(); ?>escape($book['author']) ?>
La sortie:
First Second
Exemple #7 Travailler avec 2 cycles ou plus
Pour utiliser 2 cycles, il faut renseigner leurs noms. Ca se passe au niveau du second
paramètre de la méthode cycle. $this->cycle(array("#F0F0F0","#FFFFFF"),'cycle2').
setName($name) peut aussi être utilisée.
books as $book):?>next()?>"> cycle(array(1,2,3),'number')->next()?> escape($book['author'])?>
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
PartialLoopassigne une variable à la vue nomméepartialCounterqui 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.
Exemple #8 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
:
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 :
Note: Qu'est qu'un modèle ?
Un modèle utilisé avec l'aide de vue
Partialpeut ê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 objetsRowà l'intérieur de vos scripts de vue, permettant d'appeler des méthodes sur ceux-ci (comme récupérer des valeurs d'unRowparent ou dépendant).
Exemple #9 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 :
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 :
Exemple #10 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.
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).
Exemple #11 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"
?>
Exemple #12 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("
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'];
?>
Exemple #13 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 ?>
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 :
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
HTML5
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.
Exemple #14 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() ?>
Exemple #15 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
}
Vous pouvez aussi vérifier si le doctype représente un document HTML5 :
if ($view->doctype()->isHtml5()) {
// faire qqch de différent
}
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,
$extras)
offsetSetStylesheet($index, $href, $media, $conditionalStylesheet,
$extras)
prependStylesheet($href, $media, $conditionalStylesheet,
$extras)
setStylesheet($href, $media, $conditionalStylesheet,
$extras)
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. $extras est un tableau de valeurs supplémentaires
que vous voulez ajouter à la balise.
De plus, l'aide HeadLink possède des méthodes pour ajouter des liens
alternatifs dans sa pile :
appendAlternate($href, $type, $title, $extras)
offsetSetAlternate($index, $href, $type, $title, $extras)
prependAlternate($href, $type, $title, $extras)
setAlternate($href, $type, $title, $extras)
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.
Exemple #16 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,
array('id' => 'my_stylesheet'));
?>
headLink() ?>
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.
Exemple #17 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');
Si vous proposez un document HTML5, vous pouvez fournir l'encodage de cette manière :
// régler l'encodage en HTML5
$this->headMeta()->setCharset('UTF-8');
// donnera
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'é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.
Note: Paramétrez des commentaires conditionnels
HeadScriptvous permet d'englober vos balises de script avec des commentaires conditionnels, ce qui permet de les masquer pour des navigateurs spécifiques. Pour ajouter les balises conditionnelles, fournissez le paramètreconditionalen tant que partie du paramètre $attrs lors de l'appel de la méthode.Exemple #18 Headscript avec des commentaires conditionnels
// adding scripts $this->headScript()->appendFile('/js/prototype.js', 'text/javascript', array('conditional' => 'lt IE 7');
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 à
HeadScriptdevrait ê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,
HeadScriptaffichera 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);
Exemple #19 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() ?>
Exemple #20 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'é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.
HeadStylene 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.
Note: Paramétrez des commentaires conditionnels
HeadStylevous permet d'englober vos balises de style avec des commentaires conditionnels, ce qui permet de les masquer pour des navigateurs spécifiques. Pour ajouter les balises conditionnelles, fournissez le paramètreconditionalen tant que partie du paramètre $attrs lors de l'appel de la méthode.Exemple #21 HeadStyle avec des commentaires conditionnels
// adding scripts $this->headStyle()->appendStyle($styles, array('conditional' => 'lt IE 7'));
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.
Note: UTF-8 encoding used by default
By default, Zend Framework uses UTF-8 as its default encoding, and, specific to this case,
Zend_Viewdoes as well. Character encoding can be set differently on the view object itself using the setEncoding() method (or the the encoding instantiation parameter). However, sinceZend_View_Interfacedoes not define accessors for encoding, it's possible that if you are using a custom view implementation with this view helper, you will not have a getEncoding() method, which is what the view helper uses internally for determining the character set in which to encode.If you do not want to utilize UTF-8 in such a situation, you will need to implement a getEncoding() method in your custom view implementation.
Exemple #22 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() ?>
Exemple #23 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'é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).
Exemple #24 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'é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 :
htmlFlash : génère le balisage pour l'inclusion de fichiers
Flash.
htmlObject : génère le balisage pour l'inclusion d'objets
personnalisés.
htmlPage : génère le balisage pour l'inclusion d'autres pages
(X)HTML.
htmlQuicktime : 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.
Exemple #25 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.
Exemple #26 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'é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 votrebodyHTML. 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
headdu HTML ; utilisez l'aide vue HeadScript pour ces scripts.
Quand vous créez des vues qui retournent du JSON, il est important de paramétrer aussi les en-tê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'en-tête suivant :
Content-Type: application/json
Beaucoup de librairies AJAX recherche cet en-tê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) ?>
Note: Keeping layouts and enabling encoding using Zend_Json_Expr
Each method in the JSON helper accepts a second, optional argument. This second argument can be a boolean flag to enable or disable layouts, or an array of options that will be passed to Zend_Json::encode() and used internally to encode data.
To keep layouts, the second parameter needs to be boolean TRUE. When the second parameter is an array, keeping layouts can be achieved by including a
keepLayoutskey with a value of a boolean TRUE.// Boolean true as second argument enables layouts: echo $this->json($this->data, true); // Or boolean true as "keepLayouts" key: echo $this->json($this->data, array('keepLayouts' => true));
Zend_Json::encodeallows the encoding of native JSON expressions usingZend_Json_Exprobjects. This option is disabled by default. To enable this option, pass a boolean TRUE to theenableJsonExprFinderkey of the options array:json($this->data, array( 'enableJsonExprFinder' => true, 'keepLayouts' => true, )) ?>
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".
Exemple #46 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.
Exemple #47 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.
Exemple #48 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 :
Exemple #49 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.
Exemple #50 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'
Exemple #51 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.
Exemple #52 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 :
Exemple #53 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.
Exemple #54 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();
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 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.
Sometimes it is convenient to instantiate a view helper, and then register it with the view. As of version 1.10.0, this is now possible using the registerHelper() method, which expects two arguments: the helper object, and the name by which it will be registered.
$helper = new My_Helper_Foo(); // ...do some configuration or dependency injection... $view->registerHelper($helper, 'foo');
If the helper has a setView() method, the view object will call this and inject itself into the helper on registration.
Note: Helper name should match a method
The second argument to registerHelper() is the name of the helper. A corresponding method name should exist in the helper; otherwise,
Zend_Viewwill call a non-existent method when invoking the helper, raising a fatal PHP error.
|
|
|