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.

<div id="sidebar right">
    <div class="item">
        <?= $this->action('list', 'comment', null, array('count' => 10)); ?>
    </div>
</div>

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.

<!--partiel.phtml-->
<ul>
    <li>De : <?= $this->escape($this->de) ?></li>
    <li>Sujet : <?= $this->escape($this->sujet) ?></li>
</ul>

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

<ul>
    <li>De : Equipe Framework</li>
    <li>Sujet : vues partielles</li>
</ul>

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

<!--partialLoop.phtml-->
    <dt><?= $this->key ?></dt>
    <dd><?= $this->value ?></dd>

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

<dl>
<?= $this->partialLoop('partialLoop.phtml', $model) ?>
</dl>

<dl>
    <dt>Mammifère</dt>
    <dd>Chameau</dd>

    <dt>Oiseau</dt>
    <dd>Pingouin</dd>

    <dt>Reptile</dt>
    <dd>Asp</dd>

    <dt>Poisson</dt>
    <dd>Flounder</dd>

</dl>

<?= $this->partial('pager.phtml', 'liste', $pagerData) ?>

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

<?php $this->placeholder('foo')->set("Some text for later") ?>

<?php 
    echo $this->placeholder('foo'); 
    // outputs "Some text for later"
?>

        

<!-- first view script -->
<?php $this->placeholder('foo')->exchangeArray($this->data) ?>

        

<!-- later view script -->
<?php 
$this->placeholder('foo')->setPrefix("<ul>\n    <li>")
                         ->setSeparator("</li><li>\n") 
                         ->setIndent(4)
                         ->setPostfix("</li></ul>\n");
?>

<?php 
    echo $this->placeholder('foo'); 
    // outputs as unordered list with pretty indentation
?>

        

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

<?php
$foo = $this->placeholder('foo');
echo $foo['bar'];
?>

        

<!-- Default capture: append -->
<?php $this->placeholder('foo')->captureStart(); 
foreach ($this->data as $datum): ?>
<div class="foo">
    <h2><?= $datum->title ?></h2>
    <p><?= $datum->content ?></p>
</div>
<?php endforeach; ?>
<?php $this->placeholder('foo')->captureEnd() ?>

<?php echo $this->placeholder('foo') ?>

        

<!-- Capture to key -->
<?php $this->placeholder('foo')->captureStart('SET', 'data'); 
foreach ($this->data as $datum): ?>
<div class="foo">
    <h2><?= $datum->title ?></h2>
    <p><?= $datum->content ?></p>
</div>
 <?php endforeach; ?>
<?php $this->placeholder('foo')->captureEnd() ?>

<?php echo $this->placeholder('foo')->data ?>

        

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.

$doctypeHelper = new Zend_View_Helper_Doctype();
$doctypeHelper->doctype('XHTML1_STRICT');

<?php echo $this->doctype() ?>

$doctype = $view->doctype()->getDoctype();

if ($view->doctype()->isXhtml()) {
    // 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)

• 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 un booléen, 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.

<?php // régler les liens dans votre script de vue :
$this->headLink()->appendStylesheet('/styles/basic.css')
                 ->headLink(array('rel' => 'favicon', 'href' => '/img/favicon.ico'), 'PREPEND')
                 ->prependStylesheet('/styles/moz.css', 'screen', true);
?>

<!-- effectuer le rendu -->
<?= $this->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.

// paramètrage des mots clés
$this->headMeta()->appendName('keywords', 'framework php productivité');

// 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');

// régler le type de contenu et l'encodage
$this->headMeta()->appendHttpEquiv('Content-Type', 'text/html; charset=UTF-8')
                 ->appendHttpEquiv('Content-Language', 'fr-FR');

// 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');

<?php echo $this->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.

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

// ajout de scripts
$this->headScript()->appendFile('/js/prototype.js')
                   ->appendScript($onloadScript);

// mettre les scripts dans l'ordre

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

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

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

<?= $this->headScript() ?>

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

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.

// ajout de styles
$this->headStyle()->appendStyle($styles);

// 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);

<?= $this->headStyle() ?>

<?php $this->headStyle()->captureStart() ?>
body {
    background-color: <?= $this->bgColor ?>;
}
<?php $this->headStyle()->captureEnd() ?>

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

// 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(' / ');

<!-- Affiche <action> / <controller> / Zend Framework -->
<?= $this->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 :

• 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.

<?php echo $this->htmlFlash('/path/to/flash.swf'); ?>

<object data="/path/to/flash.swf" type="application/x-shockwave-flash" 
    classid="clsid:D27CDB6E-AE6D-11cf-96B8-444553540000" 
    codebase="http://download.macromedia.com/pub/shockwave/cabs/flash/swflash.cab">
</object>

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.

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

<object data="/path/to/file.ext" type="mime/type" attr1="aval1" attr2="aval2">
    <param name="param1" value="pval1" />
    <param name="param2" value="pval2" />
    some content
</object>

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.

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 :

<?= $this->json($this->data) ?>

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

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

• Registered, through a previously registered instance in Zend_Registry

• Afterwards, through the fluent interface

• Directly, through initiating the class

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

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

// our example adapter
$adapter = new Zend_Translate('array', array('simple' => 'einfach'), 'de');
Zend_Registry::set('Zend_Translate', $adapter);

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

        

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

// within your view
$adapter = new Zend_Translate('array', array('simple' => 'einfach'), 'de');
$this->translate()->setTranslator($adapter)->translate('simple');
// this returns 'einfach'

        

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

// our example adapter
$adapter = new Zend_Translate('array', array('simple' => 'einfach'), 'de');

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

        

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

// within your view
$date = "Monday";
$this->translate("Today is %1\$s", $date);
// could return 'Heute ist Monday'

        

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

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

        

// within your view
$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'

        

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

// within your view
$date = array("Monday", "April", "11:20:55");
$this->translate("Today is %1\$s in %2\$s. Actual time: %3\$s", $date, 'it');

        

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

// within your view
$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);

        

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

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

// within your view
$date = array("Monday", "April", "11:20:55");

// returns 'de' as set default locale from our above examples
$this->translate()->getLocale();

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

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