Als Beispiel, könnte man einen CommentController mit einer listAction() Methode haben die man in Reihenfolge ausführen will, um eine Liste von Kommentaren für die aktuelle Anfrage herauszuholen:

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

Um eine registrierte Instanz zu verwenden muss einfach eine Instanz von Zend_Currency erstellt und in Zend_Registry registriert werden, wobei der Schlüssel Zend_Currency zu verwenden ist.

// Unsere Beispielwährung
$currency = new Zend_Currency('de_AT');
Zend_Registry::set('Zend_Currency', $currency);

// In der View
echo $this->currency(1234.56);
// Gibt '€ 1.234,56' zurück

Um das Fluent Interface zu verwenden muss eine Instanz von Zend_Currency erstellt, der Helfer ohne Parameter aufgerufen, und dann die Methode setCurrency() aufgerufen werden.

// In der View
$currency = new Zend_Currency('de_AT');
$this->currency()->setCurrency($currency)->currency(1234.56);
// Gibt '€ 1.234,56' zurück

// Unsere Beispielwährung
$currency = new Zend_Currency('de_AT');

// Den Helfer initiieren
$helper = new Zend_View_Helper_Currency($currency);
echo $helper->currency(1234.56); // Gibt '€ 1.234,56' zurück

// Unsere Beispielwährung
$currency = new Zend_Currency('de_AT');

// Den Helfer initiieren
$helper = new Zend_View_Helper_Currency($currency);
echo $helper->currency(1234.56); // Gibt '€ 1.234,56' zurück
echo $helper->currency(1234.56, array('precision' => 1));
// Gibt '€ 1.234,6' zurück

Um Elemente hinzuzufügen die man durchlaufen will müssen diese im Constructor spezifiziert oder die assign(array $data) Funktion verwendet werden.

<?php foreach ($this->books as $book):?>
  <tr style="background-color:<?php echo $this->cycle(array("#F0F0F0",
                                                            "#FFFFFF"))
                                              ->next()?>">
  <td><?php echo $this->escape($book['author']) ?></td>
</tr>
<?php endforeach;?>

// Rückwärts bewegen und die assign Funktion verwenden
$this->cycle()->assign(array("#F0F0F0","#FFFFFF"));
$this->cycle()->prev();
?>

Die Ausgabe

<tr style="background-color:'#F0F0F0'">
   <td>Erstes</td>
</tr>
<tr style="background-color:'#FFFFFF'">
   <td>Zweites</td>
</tr>

Um zwei Zyklen zu verwenden muß man den Namen des Zyklus verwenden. Einfach zwei Parameter in der cycle Methode setzen. $this->cycle(array("#F0F0F0","#FFFFFF"),'cycle2'). Man kann auch die setName($name) Funktion verwenden.

Die grundsätzliche Verwendung von Partials ist die Ausgabe von Templatefragmenten im eigenen Viewbereich. Es wird das folgende teilweise Skript angenommen:

<?php // partial.phtml ?>
<ul>
    <li>Von: <?php echo $this->escape($this->from) ?></li>
    <li>Subjekt: <?php echo $this->escape($this->subject) ?></li>
</ul>

Dieses würde dann vom View Skript aufgerufen indem das folgende verwendet wird:

<?php echo $this->partial('partial.phtml', array(
    'from' => 'Team Framework',
    'subject' => 'Teil der View')); ?>

Was dann das folgende ausgibt:

<ul>
    <li>From: Team Framework</li>
    <li>Subject: Teil der View</li>
</ul>

Typischerweise, wird man Partials in einer Schleife verwenden um das selbe Inhaltsfragment, viele Male, darzustellen; auf diesem Weg können große Blöcke von wiederholenden Inhalten oder komplexe Anzeigelogik auf einen einzelnen Platz gegeben werden. Trotzdem hat das einen Geschwindigkeitsnachteil, da der partielle Helfer einmal für jede Iteration aufgerufen werden muß.

Der PartialLoop View Helfer hilft bei der Lösung dieses Problems. Er erlaubt es einen wiederholenden Teil (Array oder Objekt das einen Iterator implementiert) als Modell zu übergeben. Er iteriert dann darüber, und übergibt dessen Teile dem Partial Skript als Modell. Teil in diesem Iterator kann jedes Modell sein das der Partial View Helfer erlaubt.

Es wird das folgende teilweise View Skript angenommen:

<?php // partialLoop.phtml ?>
    <dt><?php echo $this->key ?></dt>
    <dd><?php echo $this->value ?></dd>

Und das folgende "Modell":

$model = array(
    array('key' => 'Säugetier', 'value' => 'Kamel'),
    array('key' => 'Vogel', 'value' => 'Pinguin'),
    array('key' => 'Reptil', 'value' => 'Viper'),
    array('key' => 'Fisch', 'value' => 'Flunder'),
);

Im View Skript wird dann der PartialLoop Helfer aufgerufen:

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

<dl>
    <dt>Säugetier</dt>
    <dd>Kamel</dd>

    <dt>Vogel</dt>
    <dd>Pinguin</dd>

    <dt>Reptil</dt>
    <dd>Viper</dd>

    <dt>Fisch</dt>
    <dd>Flunder</dd>
</dl>

Zeitweise existiert ein Parial in einem anderen Modul. Wenn der Name des Moduls bekannt ist, kann dieses als zweites Argument entweder partial() oder partialLoop() übergeben werden, indem das $model Argument an dritte Stelle verschoben wird.

Wenn zum Beispiel, eine Teilseite existiert im 'list' Modul existiert die verwendet werden soll, kann diese wie folgt genommen werden:

<?php echo $this->partial('pager.phtml', 'list', $pagerData) ?>

Auf diesem Weg, können Teile wiederverwendet werden die speziell für andere Module erstellt wurden. Deshalb ist es besser, wiederverwendbare Teile in einen Pfad für geteilt View Skripte zu geben.

Die grundsätzliche Verwendung von Platzhaltern ist die persistenz von View Daten. Jeder Aufruf des Placeholder Helfers erwartet einen Platzhalter Namen; der Helfer gibt dann ein Platzhalter Container Objekt zurück das entweder manipuliert oder einfach ausgegeben werden kann.

<?php $this->placeholder('foo')->set("Ein Text für später") ?>

<?php
    echo $this->placeholder('foo');
    // Ausgabe "Ein Text für später"
?>

Inhalt über Platzhalter zu vereinigen kann zeitweise auch sehr nützlich sein. Zum Beispiel kann ein View Skript ein variables Array besitzen von dem Nachrichten empfangen werden sollen um diese später darzustellen; ein späteres View Skript kann diese dann eruieren wie diese dargestellt werden sollen.

Der Placeholder View Helfer verwendet Container die ArrayObject erweitern, und ein reichhaltiges Set von Features für die Manipulation von Arrays bieten. Zusätzlich bietet es eine Anzahl von Methoden für die Formatierung des Inhalts der im Container gespeichert ist:

<!-- Erstes View Skript -->
<?php $this->placeholder('foo')->exchangeArray($this->data) ?>

<!-- Späteres View Skript -->
<?php
$this->placeholder('foo')->setPrefix("<ul>\n    <li>")
                         ->setSeparator("</li><li>\n")
                         ->setIndent(4)
                         ->setPostfix("</li></ul>\n");
?>

<?php
    echo $this->placeholder('foo');
    // Ausgabe als unsortierte Liste mit schöner Einrückung
?>

Weil die Placeholder Container Objekte ArrayObject erweitern, können Inhalte einem speziellen Schlüssel im Container sehr einfach zugeordnet werden, statt diese einfach an den Container anzufügen. Auf Schlüssel kann entweder als Objekt Eigenschaften oder als Array Schlüssel zugegriffen werden.

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

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

Gelegentlich will man Inhalte für einen Platzhalter in einem View Skript haben die einfachst als Vorlage zu verwenden sind; der Placeholder View Helfer erlaubt es willkürliche Inhalte zu erfassen um diese später durch Verwendung der folgenden API darstellen zu können.

<!-- Standarderfassung: anhängen -->
<?php $this->placeholder('foo')->captureStart();
foreach ($this->data as $datum): ?>
<div class="foo">
    <h2><?php echo $datum->title ?></h2>
    <p><?php echo $datum->content ?></p>
</div>
<?php endforeach; ?>
<?php $this->placeholder('foo')->captureEnd() ?>

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

<!-- Erfassung zum Schlüssel -->
<?php $this->placeholder('foo')->captureStart('SET', 'data');
foreach ($this->data as $datum): ?>
<div class="foo">
    <h2><?php echo $datum->title ?></h2>
    <p><?php echo $datum->content ?></p>
</div>
<?php endforeach; ?>
<?php $this->placeholder('foo')->captureEnd() ?>

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

Der Doctype kann jederzeit spezifiziert werden. Trotzdem werden Helfer die vom Doctype abhängen, diesen erst erkennen wenn er gesetzt wurde, sodas der einfachste Weg darin besteht Ihn in der Bootstrap zu spezifizieren:

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

Und Ihn dann am Beginn des Layout Scripts ausgeben:

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

Wenn man den Doctype wissen will, kann einfach getDoctype() auf dem Objekt aufgerufen werden, welches vom aufgerufenen Helfer zurückgegeben wird.

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

Typischerweise wird man einfach wissen wollen, ob der Doctype XHTML ist oder nicht; hierfür ist die isXhtml() Methode ausreichend:

if ($view->doctype()->isXhtml()) {
    // etwas anderes machen
}

Man kann auch prüfen ob der Doctype ein HTML5 Dokument repräsentiert

if ($view->doctype()->isHtml5()) {
    // etwas anderes machen
}

Um das Open Graph Protokoll zu implementieren, muss XHTML1_RDFA als Dokumenttypdeklaration gesetzt werden. Diese Dokumenttypdeklaration erlaubt es Entwicklern, das Resource Description Framework innerhalb von XHTML-Dokumenten zu verwenden.

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

Der RDFa-Dokumenttyp erlaubt eine erfolgreiche Validierung von XHTML-Dokumenten, wenn das Meta-Tag-Attribute 'property' aus dem Open Graph-Protokoll verwendet wird. Beispielanwendung innerhalb eines View-Skripts:

<?php echo $this->doctype('XHTML1_RDFA'); ?>
<html xmlns="http://www.w3.org/1999/xhtml"
      xmlns:og="http://opengraphprotocol.org/schema/">
<head>
   <meta property="og:type" content="musician" />

Im vorangegangenen Beispiel wurde das Attribut 'property' auf den Wert 'og:type' gesetzt. 'og' bezieht sich dabei auf den Open Graph-Namensraum, welcher im HTML-Element definiert wurde. Die obige Angabe weist den Inhalt des Dokumentes als Seite über einen Musiker aus. Je nach Inhalt einer Seite, muss der HeadMeta-Helfer, - innerhalb einer Applikation - gesondert aufgerufen werden. Weitere mögliche Angaben sind in der Open Graph Protokoll-Dokumentation aufgeführt.

Nachfolgend ein Beispiel, wie man prüfen kann, ob die Dokumenttypdeklaration XHTML1_RDFA entspricht:

<?php echo $this->doctype() ?>
<html xmlns="http://www.w3.org/1999/xhtml"
      <?php if ($view->doctype()->isRdfa()): ?>
      xmlns:og="http://opengraphprotocol.org/schema/"
      xmlns:fb="http://www.facebook.com/2008/fbml"
      <?php endif; ?>
>

headLink kann jederzeit spezifiziert werden. Typischerweise wird ein globaler Link im eigenen Layout Skript spezifiziert, und anwendungsspezifische Links in den View Skripten der Anwendung. Im Layoutskript, in der <head> Sektion, muß das der Helfer ausgegeben werden.

<?php // Links in einem View Skript setzen:
$this->headLink()->appendStylesheet('/styles/basic.css')
                 ->headLink(array('rel' => 'favicon',
                                  'href' => '/img/favicon.ico'),
                                  'PREPEND')
                 ->prependStylesheet('/styles/moz.css',
                                     'screen',
                                     true,
                                     array('id' => 'my_stylesheet'));
?>
<?php // Darstellen der Links: ?>
<?php echo $this->headLink() ?>

Neue Meta Tags können jederzeit spezifiziert werden. Typischerweise werden Clientseitige Cacheregeln oder SEO Schlüsselwörter spezifiziert.

Wenn zum Beispiel ein spezielles SEO Schlüsselwort spezifiziert werden soll, kann das durch die Erstellung eines Meta Nametags, mit dem Namen 'keywords' und dem Inhalt des Schlüsselworts das mit der Seite assoziiert werden soll, geschehen:

// Meta Schlüsselwörter setzen
$this->headMeta()->appendName('keywords', 'framework, PHP, productivity');

Wenn Clientseitige Cacheregeln gesetzt werden sollen, können http-equiv Tags mit den Regeln die erzwungen werden sollen, gesetzt werden:

// Clientseitiges cachen verhindern
$this->headMeta()->appendHttpEquiv('expires',
                                   'Wed, 26 Feb 1997 08:21:57 GMT')
                 ->appendHttpEquiv('pragma', 'no-cache')
                 ->appendHttpEquiv('Cache-Control', 'no-cache');

Ein anderer populärer Verwendungszweck für Meta Tags ist das Setzen des Inhalt-Typs, Zeichensatzes, und der Sprache:

// Setzen des Inhalttyps und des Zeichensatzes
$this->headMeta()->appendHttpEquiv('Content-Type',
                                   'text/html; charset=UTF-8')
                 ->appendHttpEquiv('Content-Language', 'en-US');

Wenn man ein HTML5 Dokument serviert, sollte man das Character Set wie folgt angeben:

// Das Character Set im HTML5 setzen
$this->headMeta()->setCharset('UTF-8'); // Sieht aus wie <meta charset="UTF-8">

Als letztes Beispiel, ein einfacher Weg um eine kurze Nachricht anzuzeigen bevor mit Hilfe eines "Meta Refreshes" weitergeleitet wird:

// Einen Meta Refresh mit 3 Sekunden zu einer neuen URL setzen:
$this->headMeta()->appendHttpEquiv('Refresh',
                                   '3;URL=http://www.some.org/some.html');

Wenn man bereit ist die Meta Tags im Layout zu platzieren, muß einfach der Helfer ausgegeben werden:

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

Neue Skript Tags können jederzeit spezifiziert werden. Wie vorher beschrieben können diese Links auf externe Ressourcen Dateien oder Skripte sein.

// Skripte hinzufügen
$this->headScript()->appendFile('/js/prototype.js')
                   ->appendScript($onloadScript);

Die Reihenfolge ist oft wichtig beim Clientseitigen Skripting; es kann notwendig sein sicherzustellen das Bibliotheken in einer speziellen Reihenfolge geladen werden da Sie Abhängigkeiten zueinander haben; die verschiedenen append, prepend und offsetSet Direktiven können hierbei helfen:

// Skripte in eine Reihenfolge bringen

// An einem bestimmten Offset Platzieren um Sicherzustellen
// das es als letztes geladen wird
$this->headScript()->offsetSetFile(100, '/js/myfuncs.js');

// Scriptige Effekte verwenden (append verwendet den nächsten Index, 101)
$this->headScript()->appendFile('/js/scriptaculous.js');

// Aber Basis Prototype Skripte müssen immer als erstes geladen werden
$this->headScript()->prependFile('/js/prototype.js');

Wenn man letztendlich damit fertig ist am alle Skripte im Layoutskript darzustellen, muß der Helfer einfach ausgegeben werden:

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

Manchmal mit ein Clientseitiges Skript programmtechnisch erstellt werden. Wärend man Strings zusammenhängen, Heredocs und ähnliches verwenden könnte, ist es oft einfacher nur das Skript zu erstellen und in PHP Tags einzubetten. HeadScript lässt das zu, und erfasst es in den Stack:

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

Die folgenden Annahmen werden gemacht:

Ein neues Style Tag kann jederzeit spezifiziert werden:

// Stile hinzufügen
$this->headStyle()->appendStyle($styles);

Die Reihenfolge ist in CSS sehr wichtig; es könnte sein das man sichergestellen muß das Deklarationen in einer speziellen Reihenfolge geladen werden wegen der Reihenfolge der Kaskade; die verschiedenen append, prepend und offsetSet Direktiven können für diesen Zweck verwendet werden:

// Styles in Reihenfolge bringen

// Ein spezielles Offset platzieren:
$this->headStyle()->offsetSetStyle(100, $customStyles);

// Am Ende platzieren:
$this->headStyle()->appendStyle($finalStyles);

// Am Anfang platzieren:
$this->headStyle()->prependStyle($firstStyles);

Wenn man damit fertig ist und alle Style Deklarationen im Layout Skript ausgegeben werden können kann der Helfer einfach wiederholt werden:

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

Hier und da müssen CSS Style Deklarationen programmtechnisch erstellt werden. Wärend String Kopplungen, HereDocs und ähnliches verwendet werden könnte, ist es oft einfacher das durch erstellen der Styles und deren Einfügung in PHP Tags zu machen. HeadStyle lässt das zu indem es in den Stack erfasst wird:

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

Die folgenden Annahmen werden gemacht:

Es kann jederzeit ein Titel Tag spezifiziert werden. Die typische Verwendung besteht darin das Titel Segment bei jedem Level an Tiefe in der Anwendung: Site, Controller, Aktion und potentiell Ressourcen.

// Setzen des Controller und Aktion Namens als Titel Segment:
$request = Zend_Controller_Front::getInstance()->getRequest();
$this->headTitle($request->getActionName())
     ->headTitle($request->getControllerName());

// Setzen der Site im Titel; möglicherweise das Layout Skript:
$this->headTitle('Zend Framework');

// Setzen eines Separator Strings für Segmente:
$this->headTitle()->setSeparator(' / ');

Wenn man letztendlich damit fertig ist den Titel im Layoutskript darzustellen, muß dieser einfach ausgegeben werden:

<!-- Darstellung <action> / <controller> / Zend Framework -->
<?php echo $this->headTitle() ?>

Die Einbettung von Flash in die eigene Seite mit Hilfe des Helfers ist recht direkt. Das einzige benötigte Argument ist die Ressource URI.

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

Das gibt das folgende HTML aus:

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

Das erste Argument des Objekt Helfers wird immer benötigt. Es ist die URI zu der Ressource die man einbetten will. Das zweite Argument wird nur im htmlObject() Helfer benötigt. Die anderen Helfer enthalten bereits den wichtigen Wert für dieses Argument. Der dritte Parameter wird für die Übergabe von Argumenten an das Objekt Element verwendet. Es akzeptiert nur ein Array mit Schlüssel-Wert Paaren. Die classid und codebase sind Beispiel für solche Attribute. Das vierte Argument nimmt auch Schlüssel-Wert Paare und verwendet diese für die Erstellung von <param> Elementen. Sie sehen in Kürze ein Beispiel hierfür. Letztendlich, gibt es eine Option für das zur Verfügungstellen von zusätzlichen Inhalten beim Objekt. Jetzt folgt ein Beispiel welches alle Argumente verwendet.

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

/*
Das würde folgendes ausgeben:

<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>
*/

Navigations View Helfer verwenden die magisch __call() Methode um Methodenaufrufe an den Navigationscontainer weiterzuleiten der im View Helfer registriert ist.

$this->navigation()->addPage(array(
    'type' => 'uri',
    'label' => 'New page'));

Der obige Aufruf fügt eine Seite zum Container im Navigation Helfer hinzu.

Um eine registrierte Instanz zu verwenden muß einfach eine Instanz von Zend_Translate oder Zend_Translate_Adapter erstellt werden und in Zend_Registry durch Verwendung des Schlüssels Zend_Translate registriert werden.

// unser Beispieladapter
$adapter = new Zend_Translate(
    array(
        'adapter' => 'array',
        'content' => array('simple' => 'einfach'),
        'locale'  => 'de'
    )
);
Zend_Registry::set('Zend_Translate', $adapter);

// In der View
echo $this->translate('simple');
// gibt 'einfach' zurück

Um das Fluid Interface zu verwenden muß eine Instanz von Zend_Translate oder Zend_Translate_Adapter erstellt werden, der Helfer ohne Parameter und anschließend die setTranslator() Methode aufgerufen werden.

// in der View
$adapter = new Zend_Translate(
    array(
        'adapter' => 'array',
        'content' => array('simple' => 'einfach'),
        'locale'  => 'de'
    )
);
$this->translate()->setTranslator($adapter)->translate('simple');
// das gibt 'einfach' zurück

// unser Beispieladapter
$adapter = new Zend_Translate(
    array(
        'adapter' => 'array',
        'content' => array('simple' => 'einfach'),
        'locale'  => 'de'
    )
);

// den Helfer initiieren
$translate = new Zend_View_Helper_Translate($adapter);
print $translate->translate('simple'); // das gibt 'einfach' zurück

Dieser Weg kann verwendet werden wenn man nicht mit Zend_View arbeitet und übersetzte Ausgaben erzeugen muß.

Um einen einzelnen Parameter zu verwenden muss dieser einfach der Methode angefügt werden.

// innerhalb der View
$date = "Montag";
$this->translate("Today is %1\$s", $date);
// könnte 'Heute ist Montag' zurückgeben

Oder eine Liste von Parametern verwenden und diese der Methode hinzufügen.

// innerhalb der 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);
// könnte 'Heute ist Monday in April. Aktuelle Zeit: 11:20:55' zurückgeben

Oder ein Array von Parametern verwenden und dieses der Methode hinzufügen.

// innerhalb der View
$date = array("Monday", "April", "11:20:55");
$this->translate("Today is %1\$s in %2\$s. Actual time: %3\$s", $date);
// könnte 'Heute ist Monday in April. Aktuelle Zeit: 11:20:55' zurückgeben

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

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

// innerhalb der View
$date = array("Monday", "April", "11:20:55");

// gibt 'de' als standardmäßig gesetztes Gebietsschema
// vom obigen Beispiel zurück
$this->translate()->getLocale();

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

// gibt 'it' als neues standardmäßig gesetztes Gebietsschema zurück
$this->translate()->getLocale();