In deinen View Skripten ist es oft notwendig, bestimmte komplexe Funktionen immer wieder auszuführen, z.B. Datum formatieren, Formularelemente erstellen oder Links für Aktionen anzuzeigen. Du kannst Helferklassen verwenden, um diese Aufgaben für dich durchführen zu lassen.
        A helper is simply a class. Let's say we want a helper named 'fooBar'.
        By default, the class is prefixed with 'Zend_View_Helper_'
        (you can specify a custom prefix when setting a helper path), and the
        last segment of the class name is the helper name; this segment should
        be TitleCapped; the full class name is then:
        Zend_View_Helper_FooBar. This class should contain at the
        minimum a single method, named after the helper, and camelCased:
        fooBar().
    
![]()  | 
Anmerkung | 
|---|---|
Helper names are always camelCased, i.e., they never begin with an uppercase character.  | 
        Um einen Helfer in deinem View Skript zu verwenden, rufe ihn mittels
        $this->helperName() auf. Im Hintergrund wird Zend_View die Klasse
        Zend_View_Helper_HelperName laden, eine Objektinstanz der Klasse erstellen und
        deren Methode helperName() aufrufen. Die Objektinstanz bleibt innerhalb der
        Zend_View Instanz bestehen und wird bei allen weiteren Aufrufen von 
        $this->helperName() wiederverwendet.
    
            Zend_View enthält bereits einige vorhandene Helferklassen, die sich alle 
            auf die Erstellung von Formularelementen beziehen und die notwendige Maskierung der 
            Ausgaben automatisch vornehmen. Zusätzlich gibt es Helfer zum Erstellen Routen-basierter
            URLS and HTML Listen, genauso wie für das Deklarieren von Variablen. Die aktuell 
            gelieferten Helfer beinhalten: 
        
                declareVars(): Primarily for use when using
                strictVars(), this helper can be used to declare
                template variables that may or may not already be set in the
                view object, as well as to set default values.  Arrays passed as
                arguments to the method will be used to set default values;
                otherwise, if the variable does not exist, it is set to an empty
                string.
            
                formButton($name, $value, $attribs): Erstellt ein 
                <input type="button" /> Element.
            
                formCheckbox($name, $value, $attribs, $options): Erstellt ein 
                <input type="checkbox" /> Element. Der $options Parameter ist ein Array, bei
                dem der erste Wert der ausgewählte Wert ("checked") und der zweite Wert der 
                nicht ausgewählte Wert ("unchecked") angibt (die Standardwerte sind '1' und '0').
                Wenn $value mit dem ausgewählten Wert ("checked") übereinstimmt, wird die Checkbox
                für dich ausgewählt sein.
            
                formFile($name, $value, $attribs): Erstellt ein
                <input type="file" /> Element.
            
                formHidden($name, $value, $attribs): Erstellt ein
                <input type="hidden" /> Element.
            
                formPassword($name, $value, $attribs): Erstellt ein
                <input type="password" /> Element.
            
                formRadio($name, $value, $attribs, $options): Erstellt eine Reihe von 
                <input type="radio" /> Elementen, eine für jeden der $options Elemente. 
                Im $options Array ist der Elementschlüssel der Wert und der Elementwert die 
                Bezeichnung des Radio-Buttons. Der $value Radiobutton wird für dich vorgewählt.
            
                formReset($name, $value, $attribs): Erstellt ein 
                <input type="reset" /> Element.
            
                formSelect($name, $value, $attribs, $options): Erstellt einen 
                <select>...</select> block mit einer <option>one für jedes
                $options Element. Im $options Array ist der Elementschlüssel der Optionswert und 
                der Elementwert die Optionsbezeichnung. Die $value Optionen werden für dich 
                vorgewählt.
            
                formSubmit($name, $value, $attribs): Erstellt ein
                <input type="submit" /> Element.
            
                formText($name, $value, $attribs): Erstellt ein
                <input type="text" /> Element.
            
                formTextarea($name, $value, $attribs): Erstellt einen
                <textarea>...</textarea> Block.
            
                url($urlOptions, $name, $reset): Creates a URL
                string based on a named route. $urlOptions should
                be an associative array of key/value pairs used by the
                particular route.
            
                htmlList($items, $ordered, $attribs): generates
                unordered and ordered lists based on the $items
                passed to it. If $items is a multidimensional
                array, a nested list will be built.
            
Die Verwendung dieser Helfer in deinem View Skript ist sehr einfach, hier ist ein Beispiel. Beachte, dass du diese Helfer nur aufzurufen brauchst; sie werden automatisch geladen und instanziiert, sobald sie benötigt werden.
<?php
// Innerhalb deines View Skriptes, verweist $this auf die Zend_View 
// Instanz.
// 
// Sagen wir, dass du bereits eine Serie von Auswahlwerten der Variable
// $countries in Form eines Arrays zugewiesen hast 
// ('us' => 'United States', 'il' => 'Israel', 'de' => 'Germany')
?>
<form action="action.php" method="post">
    <p><label>Deine Email:
        <?php echo $this->formText('email', 'you@example.com', array('size' => 32)) ?>
    </label></p>
    <p><label>Dein Land:
        <?php echo $this->formSelect('country', 'us', null, $this->countries) ?>
    </label></p>
    <p><label>Möchtest Du hinzugefügt werden?
        <?php echo $this->formCheckbox('opt_in', 'yes', null, array('yes', 'no')) ?>
    </label></p>
</form>
        
Die Ausgabe des View Skriptes wird in etwa so aussehen:
<form action="action.php" method="post">
    <p><label>Deine Email:
        <input type="text" name="email" value="you@example.com" size="32" />
    </label></p>
    <p><label>Dein Land:
        <select name="country">
            <option value="us" selected="selected">United States</option>
            <option value="il">Israel</option>
            <option value="de">Germany</option>
        </select>
    </label></p>
    <p><label>Möchtest Du hinzugefügt werden?
        <input type="hidden" name="opt_in" value="no" />
        <input type="checkbox" name="opt_in" value="yes" checked="checked" />
    </label></p>
</form>
        
            Wie bei den View Skripten kann der Controller für Zend_View auch einen
            Stapel an Pfaden festlegen, in dem nach Hilfsklassen gesucht werden soll. Standardmäßig
            sucht Zend_View in "Zend/View/Helper/*" nach Hilfsklassen. Du kannst
            Zend_View mit Hilfe der Methoden setHelperPath() und 
            addHelperPath() mitteilen, auch in anderen Verzeichnissen zu suchen.
            Zusätzlich kann man einen Klassenpräfix angeben, um Helfer in dem bereit gestellten Pfad
            verwenden zu können, um eigene Namensräume für die Helferklassen zu verwenden.
            Standardmäßig wird 'Zend_View_Helper_' angenommen, wenn kein Präfix angegeben wird.
        
<?php
$view = new Zend_View();
// Setze den Pfad auf /path/to/more/helpers, mit dem Präfix 'My_View_Helper'
$view->setHelperPath('/path/to/more/helpers', 'My_View_Helper');
?>
        
            Durch Verwendung der addHelperPath() Methode können die Pfade "gestapelt"
            werden. Wenn du Pfade zu diesem Stapelspeicher hinzufügst, wird Zend_View
            im zuletzt hinzugefügten Pfad nach der angeforderten Hilfsklasse schauen. Dies erlaubt
            dir, zu den vorhandenen Helfern weitere hinzufügen oder diese durch eigene zu ersetzen.
        
<?php
$view = new Zend_View();
// Füge /path/to/some/helpers mit Klassenpräfix 'My_View_Helper' hinzu
$view->addHelperPath('/path/to/some/helpers', 'My_View_Helper);
// Füge /other/path/to/helpers mit Klassenpräfix 'Your_View_Helper' hinzu
$view->addHelperPath('/other/path/to/helpers', 'Your_View_Helper');
// wenn du nun $this->helperName() aufrufst, wird Zend_View zuerst nach
// "/other/path/to/helpers/HelperName.php" mit dem Klassennamen "My_View_Helper_HelperName", 
// dann nach "/path/to/some/helpers/HelperName.php" mit dem Klassennamen "Your_View_Helper_HelperName", 
// und zuletzt nach "Zend/View/Helpers/HelperName.php" mit dem Klassennamen "Zend_View_Helper_HelperName"
// schauen.
?>
        
Eigene Helfer zu schreiben ist einfach; du mußt nur diese Regeln befolgen:
                Der Klassenname muss mindestens auf den Helfernamen unter Verwendung der CamelCaps 
                selber enden. Wenn du z.B. einen Helfer mit Namen "specialPurpose" schreibst, muss
                der Klassenname mindestens "SpecialPurpose" lauten. Man kann, und sollte, dem 
                Klassennamen einen Präfix geben und es wird empfohlen, 'View_Helper' als Teil des
                Präfix zu verwenden: "My_View_Helper_SpecialPurpose" (man muss den Präfix mit oder
                oder abschließenden Unterstrich an addHelperPath() oder 
                setHelperPath() übergeben).
            
Die Klasse muss eine öffentliche Methode mit dem Namen des Helfers haben. Dies ist die Methode, welche vom View Skript durch "$this->specialPurpose()" aufgerufen wird. In unserem "specialPurpose" Beispiel, würde die notwendige Deklaration dieser Methode "public function specialPurpose()" lauten.
Im Allgemeinen sollte die Klasse keine Ausgaben durch echo(), print() oder auf andere Weise erstellen. Stattdessen sollte es die auszugebenen Werte zurückgeben. Die zurückgegebenen Werte sollten entsprechend maskiert werden.
Diese Klasse muss sich in einer Datei befinden, die nach der Helfermethode benannt ist. Bezogen auf unser "specialPurpose" Beispiel, muss der Dateiname "SpecialPurpose.php" lauten.
            Platziere die Hilfsklasse irgendwo in deinem Stapelspeicher für Hilfspfade und
            Zend_View wird den Helfer automatisch für dich laden, instanziieren,
            speichern und ausführen. 
        
            Hier ist ein Beispiel für unseren SpecialPurpose Helfer:
        
<?php
class My_View_Helper_SpecialPurpose
{
    protected $_count = 0;
    public function specialPurpose()
    {
        $this->_count++;
        $output = "Ich habe 'The Jerk' {$this->_count} Mal(e) gesehen.";
        return htmlspecialchars($output);
    }
}
?>
        
            Dann rufst du in einem View Skript den SpecialPurpose Helfer so oft auf,
            wie du möchtest; er wird einmal instanziiert und bleibt für die Lebensdauer der
            Zend_View Instanz bestehen.
        
<?php
// denke daran, dass $this in deinem View Skript auf die 
// Zend_View Instanz verweist.
echo $this->specialPurpose();
echo $this->specialPurpose();
echo $this->specialPurpose();
?>
        
Die Ausgabe wird in etwa so aussehen:
Ich habe 'The Jerk' 1 Mal(e) gesehen.
Ich habe 'The Jerk' 2 Mal(e) gesehen.
Ich habe 'The Jerk' 3 Mal(e) gesehen.
        
            Sometimes you will need access to the calling Zend_View
            object -- for instance, if you need to use the registered encoding,
            or want to render another view script as part of your helper. To get
            access to the view object, your helper class should have a
            setView($view) method, like the following:
        
<?php
class My_View_Helper_ScriptPath
{
    public $view;
    public function setView(Zend_View_Interface $view)
    {
        $this->view = $view;
    }
    public function scriptPath($script)
    {
        return $this->view->getScriptPath($script);
    }
}
?>
            If your helper class has a setView() method, it will be
            called when the helper class is first instantiated, and passed the
            current view object. It is up to you to persist the object in your
            class, as well as determine how it should be accessed.