Previous Next

View Helfer

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.

Ein Helfer ist einfach eine Klasse. Nehmen wir an wir wollen einen Helfer der 'fooBar' heißt. Standardmäßig wird der Klasse 'Zend_View_Helper_' vorangestellt (Es kann ein eigener Prefix definiert werden wenn ein Pfad für die Helfer definiert wird), und das letzte Segment des Klassennamens ist der Name des Helfers; Dieses Segment sollte TitelGroßgeschrieben sein; der volle Klassenname ist dann: Zend_View_Helper_FooBar. Diese Klasse sollte mindestens eine einzelne Methode enthalten, die nach dem Helfer benannt und camelCased ist: fooBar().

Note: Betrachte den Fall

Namen von Helfern sind immer camelCased, bzw. beginnen Sie nie mit einem großgeschriebenen Zeichen. Der Klassenname selbst ist MixedCased, aber die Methode die aktuell ausgeführt wird ist camelCased.

Note: Standard Helfer Pfad

Der Standard Helfer Pfad zeigt immer zu den View Helfern des Zend Frameworks, normalerweise 'Zend/View/Helper/'. Selbst wenn setHelperPath() ausgerufen wird um den existierenden Pfad zu überschreiben, wird dieser Pfad gesetzt um sicherzustellen das die Standard Helfer arbeiten.

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.

Vorhandene Helfer

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(): Primär benutzt mit strictVars(), kann dieser Helfer verwendet werden um template Variablen zu deklarieren welche bereits, oder noch nicht, im View Objekt bereits gesetzt sind, sowie auch Standard Werte. Arrays welche als Argument dieser Methode übergeben werden, werden verwendet um Standard Werte zu setzen; Andernfalls, wenn die Variable nicht existiert, wird diese mit einem leeren String gesetzt.

  • fieldset($name, $content, $attribs): Erstellt ein XHTML Fieldset. Wenn $attribs einen 'legend' Schlüssel enthält, wird der Wert für die Fieldset Beschriftung verwendet. Das Fieldset wird $content umfassen wie vom Helfer angeboten.

  • form($name, $attribs, $content): Erzeugt eine XHTML Form. Alle $attribs werden als XHTML Attribute des Form Tags escaped und dargestellt. Wenn $content vorhanden und kein boolsches false ist, dann wird dieser Inhalt innerhalb der Start und End Form Tags dargestellt werden; wenn $content ein boolsches false ist (der Standard), wird nur das beginnende Formtag erzeugt.

  • formButton($name, $value, $attribs): Erstellt ein <button /> Element.

  • formCheckbox($name, $value, $attribs, $options): Erstellt ein <input type="checkbox" /> Element.

    Standardmäßig, wenn kein $value angegeben und keine $options vorhanden sind, wird '0' als ungecheckter Wert, und '1' als gecheckter Wert angenommen. Wenn ein $value übergeben wird, aber keine $options vorhanden sind, wird der gecheckte Wert and der übergebene Wert angenommen.

    $options sollte ein Array sein. Wenn das Array indiziert ist, ist der erste Wert der gecheckte Wert, und der zweite der ungecheckte Wert; alle anderen Werte werden ignoriert. Es kann auch ein assoziatives Array mit den Schlüsseln 'checked' und 'unChecked' übergeben werden.

    Wenn $options übergeben wurden und $value mit dem gecheckten Wert übereinstimmt, dann wird das Element als gecheckt markiert. Das Element kann auch als gecheckt oder ungecheckt markiert werden indem ein boolscher Wert für das Attribut 'checked' übergeben wird.

    Das obige wird möglicherweise am besten mit einigen Beispielen zusammengefasst:

    formCheckbox('foo');
    
    // '1' und '0' als gecheckte/ungecheckte Optionen; gecheckt
    echo $this->formCheckbox('foo', null, array('checked' => true));
    
    // 'bar' und '0' als gecheckte/ungecheckte Optionen; nicht gecheckt 
    echo $this->formCheckbox('foo', 'bar');
    
    // 'bar' und '0' als gecheckte/ungecheckte Optionen; gecheckt 
    echo $this->formCheckbox('foo', 'bar', array('checked' => true));
    
    // 'bar' und 'baz' als gecheckte/ungecheckte Optionen; nicht gecheckt 
    echo $this->formCheckbox('foo', null, null, array('bar', 'baz');
    
    // 'bar' und 'baz' als gecheckte/ungecheckte Optionen; nicht gecheckt 
    echo $this->formCheckbox('foo', null, null, array(
        'checked' => 'bar', 
        'unChecked' => 'baz'
    ));
    
    // 'bar' und 'baz' als gecheckte/ungecheckte Optionen; gecheckt 
    echo $this->formCheckbox('foo', 'bar', null, array('bar', 'baz');
    echo $this->formCheckbox('foo', null, array('checked' => true), array('bar', 'baz');
    
    // 'bar' und 'baz' als gecheckte/ungecheckte Optionen; nicht gecheckt 
    echo $this->formCheckbox('foo', 'baz', null, array('bar', 'baz');
    echo $this->formCheckbox('foo', null, array('checked' => false), array('bar', 'baz');

    In allen Fällen, wird das Markup einem versteckten Element mit dem nicht gecheckten Wert vorangestellt; auf diesem Weg erhält man trotzdem einen gültigen Wert von der Form selbst wenn der Wert nicht gecheckt wird.

  • formErrors($errors, $options): Erzeugt eine ungeordnete XHTML Liste und zeigt Fehler an. $errors sollte ein String oder ein Array von Strings sein; $options sollte irgendein Attribut sein das im beginnenden List Tag platziert werden soll.

    Es kann alternativer beginnender, schließender und seperierter Inhalt spezifiziert werden wenn Fehler dargestellt werden durch aufruf von verschiedenen Methoden auf dem Helfer:

    • setElementStart($string); Standard ist '<ul class="errors"%s"><li>', wobei %s mit den in $options spezifizierten Attributen ersetzt wird.

    • setElementSeparator($string); Standard ist '</li><li>'.

    • setElementEnd($string); Standard ist '</li></ul>'.

  • formFile($name, $value, $attribs): Erstellt ein <input type="file" /> Element.

  • formHidden($name, $value, $attribs): Erstellt ein <input type="hidden" /> Element.

  • formMultiCheckbox($name, $value, $attribs, $options, $listsep): Erstellt eine Liste von Checkboxen. $options sollte ein assoziatives Array sein und kann beliebig tief werden. $value kann ein einzelner Wert oder ein Array von ausgewählten Werten sein die Schlüsseln im $options Array entsprechen. $listsep ist standardmäßig ein HTML Break ("<br />"). Standardmäßig wird dieses Element als Array behandelt; alle Checkboxen teilen den gleichen Namen, und werden als Array übertragen.

  • 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): Erstelle einen URL String basierend auf dem Namen der Route. $urlOptions sollte ein assoziatives Array von Schlüßel/Werte Paaren sein, welche bon der speziellen Route verwendet wird.

  • htmlList($items, $ordered, $attribs, $escape): erzeugt ungeordnete und geordnete Listen welche auf den $items basieren die übergeben wurden. Wenn $items ein multidimensionales Array ist, wird eine verschachtelte Liste gebaut. Wenn das $escape Flag true ist (standard), werden individuelle Abschnitte escaped durch Verwendung des Escaping Mechanismus der im View Objekt registriert wurde; ein false Wert wird übergeben wenn Markups in den Listen gewünscht werden.

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.

 'United States', 'il' => 'Israel', 'de' => 'Germany')
?>

Die Ausgabe des View Skriptes wird in etwa so aussehen:

Action View Helfer

Der Action View Helfer ermöglicht es View Skripten eine gegebene Kontroller Aktion auszuführen; das Ergebnis des Antwortsobjektes das der Ausführung folgt wird dann zurückgegeben. Dieses kann verwendet werden wenn eine bestimmte Aktion wiederverwendbare Inhalte oder "helfende" Inhalte erstellt.

Aktionen die zu einem _forward() oder einer Umleitung führen werden als ungültig angenommen, und als leerer String zurückgegeben.

Die API für den Action View Helfer folgt dem der meisten MVC Komponenten die Kontroller Aktionen aufrufen: action($action, $controller, $module = null, array $params = array()). $action und $controller werden benötigt; wenn kein Modul angegeben wird, dann wird das Standardmodul angenommen.

Example #1 Grundsätzliche Verwendung von Action View Helfern

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:

Partielle Helfer

Der Partial (Partielle) View Helfer wird verwendet um ein spezielles Template innerhalb seines eigenen variablen Bereichs zu rendern. Primär wird er für wiederverwendbare Templatefragmente verwendet bei denen man keine Vorsorge wegen variablen Namenskonflikten aufpassen muß. Zusätzlich erlauben Sie es Teile von View Skripten von speziellen Modulen zu spezifizieren.

Ein Geschwisterteil zum Partial ist der PartialLoop View Helfer der es erlaubt Daten zu übergeben die durchlaufen werden können, und einen Abschnitt für jedes Teil auszugeben.

Example #2 Grundsätzliche Verwendung von Partials

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


  • Von: escape($this->from) >?
  • Subjekt: escape($this->subject) >?

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

partial('partial.phtml', array(
    'from' => 'Team Framework', 
    'subject' => 'Teil der View')); ?>

Was dann das folgende ausgibt:

  • From: Team Framework
  • Subject: Teil der View

Note: Was ist ein Modell?

Ein Modell das mit dem Partial View Helfer verwendet wird kann eines der folgenden sein:

  • Array. Wenn ein Array übergeben wird, sollte es assoziativ sein, und seine Schlüssel/Werte Paare werden der View mit dem Schlüssel als View Variable zugeordnet.

  • Objekt das die toArray() Methode implementiert. Wenn ein Objekt übergeben wird das eine toArray() Methode besitzt, wird das Ergebnis von toArray() dem View Objekt als View Variablen zugeordnet.

  • Standard Objekt. Jedes andere Objekt wird die Ergebnisse von object_get_vars() (essentiell alle öffentlichen Eigenschaften des Objektes) dem View Objekt zuordnen.

Example #3 Verwendung von PartialLoop um iterierbare Modelle darzustellen

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:


    
key ?>
value ?>

Und das folgende "Modell":

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

partialLoop('partialLoop.phtml', $model) ?>
Säugetier
Kamel
Vogel
Pinguin
Reptil
Viper
Fisch
Flunder

Example #4 Partials in anderen Modulen darstellen

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:

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.

Platzhalter (PlaceHolder) Helfer

Der Placeholder View Helfer wird verwendet um Inhalte zwischen View Skripten und View Instanzen persistent zu machen. Er bietet auch einige nützliche Features wie Inhalte zu vereinigen, Inhalte von View Skripten zu erfassen und Vor- sowie Nach-Texte zu Inhalten hinzuzufügen (und eigene Seperatoren für vereinigte Inhalte).

Example #5 Grundsätzliche Verwendung von Platzhaltern

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.

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

placeholder('foo'); 
    // Ausgabe "Ein Text für später"
?>

Example #6 Platzhalter verwenden um Inhalt zu vereinigen

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:

  • setPrefix($prefix) setzt Text der dem Inhalt vorgesetzt wird. getPrefix() kann verwendet werden um jederzeit festzustellen wie die aktuellen Einstellungen sind.

  • setPostfix($prefix) setzt Text der dem Inhalt angehängt wird. getPostfix() kann verwendet werden um jederzeit festzustellen wie die aktuellen Einstellungen sind.

  • setSeparator($prefix) setzt Text mit dem zusammengefügte Inhalte seperiert werden. getSeparator() kann verwendet werden um jederzeit festzustellen wie die aktuellen Einstellungen sind.

  • setIndent($prefix) kann verwendet werden um einen Markierungswert für den Inhalt zu setzen. Wenn ein Integer übergeben wird, wird diese Anzahl an Leerzeichen verwendet; wenn ein String übergeben wird, wird dieser String verwendet. getIndent() kann verwendet werden um jederzeit festzustellen wie die aktuellen Einstellungen sind.


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

placeholder('foo')->setPrefix("
    \n
  • ") ->setSeparator("
  • \n") ->setIndent(4) ->setPostfix("
\n"); ?> 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.

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

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

Example #7 Verwenden von Platzhaltern um Inhalt zu erfassen

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.

  • captureStart($type, $key) beginnt die Erfassung der Inhalte.

    $type sollte eine der Placeholder Konstanten APPEND oder SET sein. APPEND fügt erfasste Inhalte der Liste der aktuellen Inhalte im Placeholder an; SET verwendet erfasste Inhalte als einzigen Wert für den Platzhalter (überschreibt potentiell alle vorherigen Inhalte). Standardmäßig ist $type APPEND.

    $key kann verwendet werden um einen speziellen Schlüssel im Placeholder Container zu spezifizieren an dem der Inhalt erfasst werden soll.

    captureStart() sperrt die Erfassung bis captureEnd() aufgerufen wurde; Erfassungen können nicht mit dem selben Placeholder Container verschachtelt werden. Das führt zu einer Ausnahme.

  • captureEnd() stoppt die Erfassung von Inhalten, und platziert Ihn im Container Objekt anhängig davon wie captureStart() aufgerufen wurde.


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

Konkrete Platzhalter Implementationen

Zend Framework kommt mit einer Anzahl an "konkreten" Platzhalter Implementationen. Diese sind für üblich verwendete Platzhalter: Doctype, Seitentitel, und verschiedene <head> Elemente. In allen Fällen gibt der Aufruf des Platzhalters ohne Argumente das Element selbst zurück.

Die Dokumentation für jedes Element wird seperat behandelt, wie anbei beschrieben:

Doctype Helfer

Gültige HTML und XHTML Dokumente sollten eine DOCTYPE Deklaration enthalten. Neben der Schwierigkeit sich diese zu merken, können Sie auch beeinflussen wie bestimmte Elemente im Dokument dargestellt werden sollen (zum Beispiel, CDATA Kommentierung in <script> und <style> Elementen.

Der Doctype Helfer erlaubt die Spezifikation von einem der folgenden Typen:

  • XHTML11

  • XHTML1_STRICT

  • XHTML1_TRANSITIONAL

  • XHTML_BASIC1

  • XHTML1_FRAMESET

  • HTML4_STRICT

  • HTML4_LOOSE

  • HTML4_FRAMESET

Es kann auch ein eigener DocType spezifiziert werden solange dieser richtig formatiert ist.

Der Doctype Helfer ist eine konkrete Implementation des Platzhalter Helfers.

Example #8 Grundsätzliche Verwendung des Doctype Helfers

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:

doctype() ?>

Example #9 Empfangen des Doctypes

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

doctype()->getDoctype();
?>

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

doctype()->isXhtml()) {
    // etwas anderes machen
}
?>

HeadMeta Helfer

Das HTML Element <meta> wird verwendet um Meta Informationen über das HTML Dokument anzubieten -- typischerweise Schlüsselwörter. Dokument Zeichensätze, Cache Pragmas, usw. Meta Tags können entweder 'http-equiv' oder 'name' Typen sein, müssen ein 'content' Attribut enthalten, und können auch eines der 'lang' oder 'scheme' Modifikator Attributen enthalten.

Der HeadMeta Helfer unterstützt die folgenden Methoden für das Setzen und Hinzufügen von Meta Tags:

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

Das $keyValue Element wird verwendet um einen Wert für den 'name' oder 'http-equiv' Schlüssel zu definieren; $content ist der Wert für den 'content' Schlüssel, und $modifiers ist ein optionales assoziatives Array das Schlüssel für 'land und/oder 'scheme' enthalten kann.

Meta Tags können auch gesetzt werden indem die headMeta() Helfermethode verwendet wird, welche die folgende Signatur hat: headMeta($content, $keyValue, $keyType = 'name', $modifiers = array(), $placement = 'APPEND'). $keyValue ist der Intalt für den Schlüssel der in $keyType spezifiziert ist, und welche entweder 'name' oder 'http-equiv' sein sollte. $placement kann entweder 'SET' (überschreibt alle vorher gespeicherten Werte), 'APPEND' (fügt an das Ende des Stacks hinzu), oder 'PREPEND' (fügt an den Beginn des Stacks hinzu) sein.

HeadMeta überschreibt append(), offsetSet(), prepend(), und set() um die Verwendung der speziellen Methoden wie oben gelistet zu erzwingen. Intern wird jedes Element als stdClass Token gespeichert, welches später durch Verwendung der itemToString() Methode serialisiert wird. Das erlaubt es Prüfungen an den Elementen im Stack durchzuführen, und diese Elemente optional zu verändern indem einfach das zurückgegebene Objekt verändert wird.

Der HeadMeta Helfer ist eine konkrete Implementation des Platzhalter Helfers.

Example #11 Grundsätzliche Verwendung des HeadMeta Helfers

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:

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:

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:

headMeta()->appendHttpEquiv('Content-Type', 'text/html; charset=UTF-8')
                 ->appendHttpEquiv('Content-Language', 'en-US');
?>

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

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:

headMeta() ?>

HeadScript Helfer

Das HTML <script> Element wird verwendet um entweder Clientseitige Skriptelemente Inline zu ermöglichen oder um eine entfernte Ressource zu verlinken die Clientseitigen Skriptcode enthält. Der HeadScript Helfer erlaubt es beides zu managen.

Der HeadScript Helfer unterstützt die folgenden Methoden für das Setzen und Hinzufügen von Skripten:

  • 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())

Im Falle der *File() Methoden ist $src der entfernte Ort des Skriptes das geladen werden soll; das ist üblicherweise in der Form einer URL oder eines Pfades. Für die *Script() Methoden sind $script die clientseitigen Skript Direktiven die in diesem Element verwendet werden sollen.

HeadScript erlaubt auch das Erfassen von Skripten; das kann nützlich sein wenn man ein Clientseitiges Skript programmtechnisch erstellen und es dann woanders platzieren will. Seine Verwendung wird in einem Beispiel anbei gezeigt.

Letztendlich kann die headScript() Methode verwendet werden um Skript Elemente schnell hinzuzufügen; die Signatur hierfür ist headScript($mode = 'FILE', $spec, $placement = 'APPEND'). Der $mode ist entweder 'FILE' oder 'SCRIPT', anhängig davon ob das Skript verlinkt oder definiert wird. $spec ist entweder die Skriptdatei die verlinkt wird, oder der Skriptcode selbst. $placement sollte entweder 'APPEND', 'PREPEND' oder 'SET' sein.

HeadScript überschreibt append(), offsetSet(), prepend(), und set() um um die Verwendung der speziellen Methoden wie vorher gezeigt zu erzwingen. Intern wird jedes Element als stdClass Token gespeichert, welches später mit Hilfe der itemToString() Methode serialisiert wird. Das erlaubt es Prüfungen an den Elementen im Stack vorzunehmen, und diese Elemente optional zu ändern, einfach durch das Modifizieren des zurückgegebenen Objektes.

Der HeadScript Helfer ist eine konkrete Implementation des Platzhalter Helfers.

Note: InlineScript für HTML Body Skripte verwenden

HeadScript's Schwester Helfer, InlineScript, sollte verwendet werden wenn man Inline Skripte im HTML body inkludieren will. Die Platzierung von Skripten am Ende des Dokuments ist eine gängige Praxis für die schnellere Auslieferung von Seiten, speziell wenn 3rd Party Analyse Skripte verwendet werden.

Note: Andere Attribute werden stanadrdmäßig ausgeschaltet

Standardmäßig wird HeadScript nur <script> Attribute darstellen die von W3C abgesegnet sind. Diese beinhalten 'type', 'charset', 'defer', 'language', und 'src'. Trotzdem, verwenden einige Javascript Frameworks, vorallem » Dojo, eigene Attribute um Verhalten zu ändern. Um solche Attribute zu erlauben, können diese über die setAllowArbitraryAttributes() Methode eingeschaltet werden:

headScript()->setAllowArbitraryAttributes(true);
?>

Example #12 Grundsätzliche Verwendung des HeadScript Helfers

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

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:

headScript()->offsetSetScript(100, '/js/myfuncs.js');

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

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

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

headScript() ?>

Example #13 Skripte einfachen mit Hilfe des HeadScript Helfers

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:

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

Die folgenden Annahmen werden gemacht:

  • Das Skript wird an den Stack angefügt. Wenn es den Stack ersetzen soll oder an den Anfang hinzugefügt werden soll, muß 'SET' oder 'PREPEND' als erstes Argument an captureStart() übergeben werden.

  • Der MIME Typ des Skripts wird mit 'text/javascript' angenommen; wenn ein anderer Typ spezifiziert werden soll muß dieser als zweites Argument an captureStart() übergeben werden.

  • Wenn irgendwelche zusätzlichen Attribute für das <script> Tag spezifiziert werden sollen, müssen diese in einem Array als drittes Argument an captureStart() übergeben werden.

HeadStyle Helfer

Das HTML Element <style> wird verwendet um CSS Stylesheets im HTML Element <head> zu inkludieren.

Note: HeadLink verwenden um CSS Dateien zu verlinken

HeadLink sollte verwendet werden um <link> Elemente zu Erstellen die externe Stylesheets enthalten. HeadScript wird verwendet wenn man Stylesheets inline definieren will.

Der HeadStyle Helfer unterstützt die folgenden Methoden für das Setzen und Hinzufügen von Stylesheet Deklarationen:

  • appendStyle($content, $attributes = array())

  • offsetSetStyle($index, $content, $attributes = array())

  • prependStyle($content, $attributes = array())

  • setStyle($content, $attributes = array())

In allen Fällen ist $content die aktuelle CSS Deklaration. $attributes sind alle zusätzlichen Attribute die das style Tag erhalten soll: lang, title, media, oder dir sind alle möglich.

HeadStyle erlaubt auch das Erfassen von Style Deklarationen; das kann nützlich sein wenn eine Deklaration programmtechnisch erstellt werden soll und Sie dann woanders platziert wird. Die Verwendung hierfür wird in einem unten angeführten Beispiel gezeigt.

Letztendlich kann auch die headStyle() Methode verwendet werden um schnellstens Deklarationselemente hinzuzufügen; die Signatur dafür ist headStyle($content$placement = 'APPEND', $attributes = array()). $placement sollte entweder 'APPEND', 'PREPEND', oder 'SET' sein.

HeadStyle überschreibt jedes append(), offsetSet(), prepend(), und set() um die Verwendung der oben gelisteten speziellen Methoden zu forcieren. Intern wird jeder Teil als stdClass Token gespeichert, welches später serialisiert wird durch Verwendung der itemToString() Methode. Das erlaubt es die Teile im Stack zu Prüfen, und optional auch zu Ändern durch einfaches Modifizieren des zurückgegebenen Objektes.

Der HeadStyle Helfer ist eine konkrete Implementation des Platzhalter Helfers.

Example #14 Grundsätzliche Verwendung des HeadStyle Helfers

Ein neues Style Tag kann jederzeit spezifiziert werden:

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:

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:

headStyle() ?>

Example #15 Den HeadStyle Helfer verwenden um Style Deklarationen zu Erfassen

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:

headStyle()->captureStart() ?>
body {
    background-color: bgColor ?>;
}
headStyle()->captureEnd() ?>

Die folgenden Annahmen werden gemacht:

  • Die Style Deklarationen werden dem Stack angefügt. Wenn Sie den Stack ersetzen sollen oder an den Anfang hinzugefügt werden sollten muß 'SET' oder 'PREPEND' als erstes Argument an captureStart() übergeben werden

  • Wenn zusätzliche Attribute für das <style> Tag spezifiziert werden sollen, dann müssen diese in einem Array als zweites Argument an captureStart() übergeben werden.

HeadTitle Helfer

Das HTML <title> Element wird verwendet um einen Titel für ein HTML Dokument anzubieten. Der HeadTitle Helfer erlaubt es Titel für späteren Empfang und Ausgabe programmtechnisch zu Erstellen und zu Speichern.

Der HeadTitle Helfer ist eine konkrete Implementation des Plaltzhalter Helfer. Er überschreibt die toString() Methode um die erstellung des <title> Elements zu erzwingen, und fgt eine headTitle() Methode für das schnelle und einfache Einstellen und Ändern von Titel Elementen hinzu. Die Signatur dieser Methode ist headTitle($title, $setType = 'APPEND'); standardmäßig, wird der Wert dem Stack angefügt (Anhäufen von Title Segmenten), aber es kann auch 'PREPEND' (Platzierung am Anfang des Stacks) oder 'SET' (Stack überschreiben) spezifiziert werden.

Example #16 Grundsätzliche Verwendung des HeadTitle Helfers

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, Kontroller, Aktion und potentiell Ressourcen.

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:


headTitle() ?>

HTML Object Helpers

The HTML <object> element is used for embedding media like Flash or QuickTime in web pages. The object view helpers take care of embedding media with minimum effort.

There are four initial Object helpers:

  • formFlash Generates markup for embedding Flash files.

  • formObject Generates markup for embedding a custom Object.

  • formPage Generates markup for embedding other (X)HTML pages.

  • formQuicktime Generates markup for embedding QuickTime files.

All of these helpers share a similar interface. For this reason, this documentation will only contain examples of two of these helpers.

Example #17 Flash helper

Embedding Flash in your page using the helper is pretty straight-forward. The only required argument is the resource URI.

htmlFlash('/path/to/flash.swf'); ?>

This outputs the following HTML:


Additionally you can specify attributes, parameters and content that can be rendered along with the <object>. This will be demonstrated using the htmlObject helper.

Example #18 Customizing the object by passing additional arguments

The first argument in the object helpers is always required. It is the URI to the resource you want to embed. The second argument is only required in the htmlObject helper. The other helpers already contain the correct value for this argument. The third argument is used for passing along attributes to the object element. It only accepts an array with key-value pairs. The classid and codebase are examples of such attributes. The fourth argument also only takes a key-value array and uses them to create <param> elements. You will see an example of this shortly. Lastly, there is the option of providing additional content to the object. Now for an example which utilizes all arguments.

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

/*
This would output:


    
    
    some content

*/

InlineScript Helfer

Das HTML <script> Element wird verwendet um entweder Clientseitige Skriptelemente Inline zu ermöglichen oder um eine entfernte Ressource zu verlinken die Clientseitigen Skriptcode enthält. Der InlineScript Helfer erlaubt es beides zu managen. Er ist von HeadScript abgeleitet und jede Methode dieses Helfers ist vorhanden; trotzdem, sollte die inlineScript() Methode statt headScript() verwendet werden.

Note: InlineScript für HTML Body Skripte verwenden

InlineScript, sollte verwendet werden wenn man Skripte im HTML body inkludieren will. Skripte am Ende des Dokuments zu platzieren ist eine gute Praxis um das Versenden von Seiten schneller zu machen, speziell wen 3rd Party Analyse Skripte verwendet werden.

Einige JS Bibliotheken müssen im HTML head; für diese Skripte sollte HeadScript verwendet werden.

JSON Helfer

Wenn Views erstellt werden die JSON zurückgeben ist es wichtig auch den entsprechenden Antwort-Header zu setzen. Der JSON View Helfer macht exakt das. Zusätzlich schaltet er, standardmäßig, Layouts aus (wenn diese aktuell eingeschaltet sind), weil Layouts generell nicht mit JSON Antworten verwendet werden.

Der JSON Helfer setzt die folgenden Header:

Content-Type: application/json

Die meisten AJAX Bibliotheken sehen nach diesem Header wenn die Antworten geparst werden um festzustellen wie der Inhalt handzuhaben ist.

Die Verwendung des JSON Helfers ist sehr geradlienig:

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

Übersetzungs Helfer

Oft sind Webseiten in verschiedenen Sprachen vorhanden. Um den Inhalt einer Site zu übersetzen sollte ganz einfach Zend Translate verwendet werden, und um Zend Translate in der eigenen View zu integrieren sollte der Translate View Helfer verwendet werden.

In allen folgenden Beispielen verwenden wir den einfachen Array Übersetzungs Adapter. Natürlich kann jede Instanz von Zend_Translate und genauso jede Subklasse von Zend_Translate_Adapter verwendet werden. Es gibt verschiedene Wege den Translate View Helfer zu initiieren:

  • Registriert, durch eine vorher in Zend_Registry registrierte Instanz

  • Danach, durch das Fluent Interface

  • Direkt, durch Instanzierung der Klasse

Eine registrierte Instanz von Zend_Translate ist die bevorzugte Verwendung für diesen Helfer. Bevor der Adapter der Registry hinzugefügt wird, kann das zu verwendende Gebietsschema einfach ausgewählt werden.

Note:

Wir sprechen hier von Gebietsschemata (Locale) statt von Sprachen weil eine Sprache auch in verschiedenen Regionen vorhanden sein kann. Zum Beispiel wird Englisch in verschiedenen Dialekten gesprochen. Es könnte eine Übersetzung für Britisch und eine für Amerikanisches Englisch geben. Deswegen sagen wir Gebietsschema "locale" statt Sprache.

Example #19 Registrierte Instanz

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.

 'einfach'), 'de');
Zend_Registry::set('Zend_Translate', $adapter);

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

Wenn man mit dem Fluent Interface besser zurecht kommt, kann eine Instanz auch in der View erstellt werden und der Helfer im Nachhinein initiiert werden.

Example #20 In der View

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.

 'einfach'), 'de');
$this->translate()->setTranslator($adapter)->translate('simple');
// das gibt 'einfach' zurück
?>

Wenn der Helfer ohne Zend_View verwendet werden soll kann er auch direkt angesprochen werden.

Example #21 Direkte Verwendung

 'einfach'), '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ß.

Wie man bereits sehen konnte, wird die translate() Methode verwendet um die Übersetzung zurückzugeben. Sie muss nur mit der benötigten messageid des Übersetzungsadapters aufgerufen werden. Aber sie kann auch Parameter im Übersetzungsstring ersetzen. Deswegen akzeptiert Sie variable Parameter in zwei Wegen: entweder als Liste von Parametern, oder als Array von Parametern. Als Beispiel:

Example #22 Einzelne Parameter

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

translate("Today is %1\$s", $date);
// könnte 'Heute ist Montag' zurückgeben
?>

Note:

Wenn man Parameter verwendet die auch Text sind ist zu beachten das es auch nötig sein kann diese Parameter zu übersetzen.

Example #23 Liste von Parametern

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

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

Example #24 Array von Parametern

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

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

Manchmal ist es notwendig das Gebietsschema der Übersetzung zu Ändern. Das kann entweder dynamisch pro Übersetzung oder statisch für alle folgenden Übersetzungen durchgeführt werden. Dies kann mit beidem, einer Liste von Paramtern oder einem Array von Parametern, verwendet werden. In beiden Fällen muss das als letzter einzelner Parameter angegeben werden.

Example #25 Das Gebietsschema dynamisch wechseln

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

Dieses Beispiel gibt die italienische Übersetzung für die messageid zurück. Aber Sie wird nur einmal verwendet. Die nächste Übersetzung verwendet wieder das Gebietsschema des Adapters. Normalerweise wird das gewünschte Gebietsschema im Übersetzungsadapter gesetzt bevor dieser der Registry hinzugefügt wird. Das Gebietsschema kann aber auch im Helfer gesetzt werden:

Example #26 Das Gebietsschema statisch wechseln

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

Das obige Beispiel setzt 'it' als neues standardmäßiges Gebietsschema welches für alle weiteren Übersetzungen verwendet wird.

Natürlich gibt es auch eine getLocale() Methode um das aktuell gesetzte Gebietsschema zu erhalten.

Example #27 Das aktuell gesetzte Gebietsschema erhalten

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

Helfer Pfade

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.

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.

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 nun $this->helperName() aufgerufen wird, wird Zend_View zuerst nach
// "/path/to/some/helpers/HelperName" mit dem Klassennamen "Your_View_Helper_HelperName",
// dann nach "/other/path/to/helpers/HelperName.php" mit dem Klassennamen "My_View_Helper_HelperName",
// und zuletzt nach "Zend/View/Helpers/HelperName.php" mit dem Klassennamen "Zend_View_Helper_HelperName"
// schauen.

Eigene Helfer schreiben

Eigene Helfer zu schreiben ist einfach; du mußt nur diese Regeln befolgen:

  • Der Klassenname muss mindestens auf den Helfernamen unter Verwendung der MixedCaps 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:

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

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.

Hier und da ist es notwendig das aufrufende Zend_View Objekt aufzurufen -- zum Beispiel, wenn es notwendig ist die registrierte Verschöüsselung zu verwenden, oder wenn ein anderes View Skript gerendert werden soll, als Teil des eigenen Helfers. Um Zugriff zum View Objekt zu erhalten, sollte die eigene Helfer Klasse eine setView($view) Methode wie folgt besitzen:

view = $view;
    }

    public function scriptPath($script)
    {
        return $this->view->getScriptPath($script);
    }
}

Wenn die Helfer Klasse eine setView() Methode hat, wird diese aufgerufen wenn die Helfer Klasse das erste Mal instanziert wird, und das aktuelle View Objekt übergeben wird. Es liegt an einem selbst das Objekt in der Klasse zu fixieren, genau so wie herauszufinden wie auf dieses zugegriffen werden sollte.

Previous Next
Introduction to Zend Framework
Übersicht
Installation
Zend_Acl
Einführung
Verfeinern der Zugriffskontrolle
Fortgeschrittene Verwendung
Zend_Auth
Einführung
Datenbanktabellen Authentifizierung
Digest Authentication
HTTP Authentication Adapter
LDAP Authentifizierung
Open ID Authentifikation
Zend_Cache
Einführung
Die Theorie des Cachens
Zend_Cache Frontends
Zend_Cache Backends
Zend_Captcha
Introduction
Captcha Operation
Captcha Adapters
Zend_Config
Einleitung
Theory of Operation
Zend_Config_Ini
Zend_Config_Xml
Zend_Console_Getopt
Einführung in Getopt
Definieren von Getopt Regeln
Holen von Optionen und Argumenten
Konfigurieren von Zend_Console_Getopt
Zend_Controller
Zend_Controller Schnellstart
Zend_Controller Grundlagen
Der Front Controller
Das Request Objekt
Der Standard Router: Zend_Controller_Router_Rewrite
Der Dispatcher
Action Kontroller
Action Helfer
Das Response Objekt
Plugins
Eine konventionelle modulare Verzeichnis Struktur verwenden
MVC Ausnahmen
Migration von vorhergehenden Versionen
Zend_Currency
Einführung in Zend_Currency
Arbeiten mit Währungen
Migration von vorhergehenden Versionen
Zend_Date
Einführung
Theorie der Arbeitsweise
Basis Methoden
Zend_Date API Übersicht
Erstellen von Datumswerten
Konstanten für generelle Datums Funktionen
Funktionierende Beispiele
Zend_Db
Zend_Db_Adapter
Zend_Db_Statement
Zend_Db_Profiler
Zend_Db_Select
Zend_Db_Table
Zend_Db_Table_Row
Zend_Db_Table_Rowset
Zend_Db_Table Relationships
Zend_Debug
Variablen ausgeben
Zend_Dojo
Introduction
Zend_Dojo_Data: dojo.data Envelopes
Dojo View Helpers
Dojo Form Elements and Decorators
Zend_Dom
Introduction
Zend_Dom_Query
Zend_Exception
Verwenden von Ausnahmen
Zend_Feed
Einführung
Feeds importieren
Feeds von Websites abrufen
Einen RSS Feed konsumieren
Einen Atom Feed konsumieren
Einen einzelnen Atom Eintrag konsumieren
Verändern der Feed- und Eintragsstruktur
Eigene Klassen für Feeds und Einträge
Zend_File
Zend_File_Transfer
Validators for Zend_File_Transfer
Zend_Filter
Einführung
Standard Filter Klassen
Filter Ketten
Filter schreiben
Zend_Filter_Input
Zend_Filter_Inflector
Zend_Form
Zend_Form
Schnellstart mit Zend_Form
Erstellen von Form Elementen mit Hilfe von Zend_Form_Element
Erstellen von Form durch Verwendung von Zend_Form
Erstellen von eigenem Form Markup durch Zend_Form_Decorator
Standard Form Elemente die mit dem With Zend Framework ausgeliefert werden
Standard Form Dekoratore die mit dem Zend Framework ausgeliefert werden
Internationalisierung von Zend_Form
Fortgeschrittene Verwendung von Zend_Form
Zend_Gdata
Einführung zu Gdata
Authentifizierung mit AuthSub
Authentifizieren mit ClientLogin
Google Kalender verwenden
Verwenden der Google Dokumente Listen Daten API
Google Tabellenkalkulation verwenden
Google Apps Provisionierung verwenden
Google Base verwenden
Verwenden der YouTube Daten API
Picasa Web Alben verwenden
Gdata Ausnahmen auffangen
Zend_Http
Zend_Http_Client - Einführung
Zend_Http_Client - Fortgeschrittende Nutzung
Zend_Http_Client - Verbindungsadapter
Zend_Http_Cookie und Zend_Http_CookieJar
Zend_Http_Response
Zend_InfoCard
Einführung
Zend_Json
Einführung
Grundlegende Verwendung
JSON Objects
XML zu JSON Konvertierung
Zend_Json_Server - JSON-RPC server
Zend_Layout
Einführung
Zend_Layout Schnellstart
Zend_Layout Konfigurations Optionen
Erweiterte Verwendung von Zend_Layout
Zend_Ldap
Einleitung
Zend_Loader
Dynamisches Laden von Dateien und Klassen
Plugins laden
Zend_Locale
Einführung
Zend_Locale verwenden
Normalisierung und Lokalisierung
Arbeiten mit Daten und Zeiten
Unterstützte Sprachen für Gebietsschemata
Unterstützte Regionen für Gebietsschemata
Zend_Log
Übersicht
Writer
Formatter
Filter
Zend_Mail
Einführung
Versand über SMTP
Versand von mehreren E-Mails über eine SMTP Verbindung
Verwendung von unterschiedlichen Versandwegen
HTML E-Mail
Anhänge
Empfänger hinzufügen
Die MIME Abgrenzung kontrollieren
Zusätzliche Kopfzeilen
Zeichensätze
Kodierung
SMTP Authentifizierung
SMTP Übertragungen sichern
Lesen von Mail Nachrichten
Zend_Measure
Einführung
Erstellung einer Maßeinheit
Ausgabe von Maßeinheiten
Manipulation von Maßeinheiten
Arten von Maßeinheiten
Zend_Memory
Übersicht
Memory Manager
Memory Objekte
Zend_Mime
Zend_Mime
Zend_Mime_Message
Zend_Mime_Part
Zend_OpenId
Einführung
Zend_OpenId_Consumer Grundlagen
Zend_OpenId_Provider
Zend_Paginator
Introduction
Usage
Configuration
Advanced usage
Zend_Pdf
Einführung
Erstellen und Laden von PDF Dokumenten
Änderungen von PDF Dokumenten speichern
Dokument Seiten
Zeichnen
Dokument Informationen und Metadaten
Anwendungsbeispiel für die Zend_Pdf Komponente
Zend_Registry
Die Registry verwenden
Zend_Rest
Einführung
Zend_Rest_Client
Zend_Rest_Server
Zend_Search_Lucene
Überblick
Indexerstellung
Einen Index durchsuchen
Abfragesprache
Abfrage Erzeugungs API
Zeichensätze
Erweiterbarkeit
Zusammenarbeit Mit Java Lucene
Erweitert
Die besten Anwendungen
Zend_Server
Einführung
Zend_Server_Reflection
Zend_Service
Einführung
Zend_Service_Akismet
Zend_Service_Amazon
Zend_Service_Audioscrobbler
Zend_Service_Delicious
Zend_Service_Flickr
Zend_Service_Nirvanix
Zend_Service_ReCaptcha
Zend_Service_Simpy
Einführung
Zend_Service_StrikeIron
Zend_Service_StrikeIron: Mitgelieferte Services
Zend_Service_StrikeIron: Erweiterte Verwendung
Zend_Service_Technorati
Zend_Service_Yahoo
Zend_Session
Einführung
Grundsätzliche Verwendung
Fortgeschrittene Benutzung
Globales Session Management
Zend_Session_SaveHandler_DbTable
Zend_Soap
Zend_Soap_Server
Zend_Soap_Client
WSDL Zugriffsmethoden
AutoDiscovery. Einführung
Automatische Erkennung von Klassen.
Funktionen für Autodiscovery.
Automatische Erkennung. Datentypen.
Zend_Test
Introduction
Zend_Test_PHPUnit
Zend_Text
Zend_Text_Figlet
Zend_TimeSync
Einführung
Arbeiten mit Zend_TimeSync
Zend_Translate
Einführung
Adapter für Zend_Translate
Benutzen von Übersetzungs Adaptoren
Zend_Uri
Zend_Uri
Zend_Validate
Einführung
Standard Prüfklassen
Kettenprüfungen
Schreiben von Prüfern
Zend_Version
Auslesen der Version des Zend Frameworks
Zend_View
Einführung
Controller Skripte
View Scripte
View Helfer
Zend_View_Abstract
Zend_Wildfire
Zend_Wildfire
Zend_XmlRpc
Einführung
Zend_XmlRpc_Client
Zend_XmlRpc_Server
Zend Framework Voraussetzungen
PHP Version
PHP Erweiterungen
Zend Framework Komponenten
Zend Framework Abhängigkeiten
Zend Framework Coding Standard für PHP
Übersicht
PHP Dateiformatierung
Namens Konventionen
Code Stil
Urheberrecht Informationen