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 Titel Groß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:

    // '1' und '0' als gecheckte/ungecheckte Optionen; nicht gecheckt
    echo $this->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, $attribs): Erstellt ein <input type="file" /> Element.

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

  • formLabel($name, $value, $attribs): Erstellt ein <label> Element, setzt das for Attribut auf $name, und den aktuellen Labeltext auf $value. Wenn disable an attribs übergeben wird, wird nichts zurückgegeben.

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

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

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:

Cycle Helfer

Der Cycle Helfer wird verwendet um ein Set von Werte zu ändern.

Example #2 Grundsätzliche Verwendung des Cycle Helfers

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

books as $book):?>
  next()?>">
  escape($book['author']) ?>



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

Die Ausgabe


   Erstes


   Zweites

Example #3 Mit einem oder mehreren Zyklen arbeiten

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.

books as $book):?>
  next()?>">
  cycle(array(1,2,3),'number')->next()?>
  escape($book['author'])?>

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.

Note: PartialLoop Zähler

Der PartialLoop View Helfer fügt der View eine Variable hinzu die partialCounter heißt und die die aktuelle Position des Arrays zum View Skript übergibt. Das bietet einen einfachen Weg um alternative Farbgebungen zum Bespiel bei Tabellenzeilen zu haben.

Example #4 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.

Wenn das eigene Modell ein Objekt ist, kann es gewünscht sein, es als Objekt an das Partielle Skript zu übergeben, statt es in ein Array von Variablen zu serialisieren. Das kann durch das Setzen der 'objectKey' Eigenschaft des betreffenden Helfers getan werden:

// Dem Partiellen mitteilen das ein Objekt als 'model' Variable übergeben wird
$view->partial()->setObjectKey('model');

// Dem Partiellen mitteilen das ein Objekt von partialLoop als 'model'
// Variable im letzten Partiellen View Skript übergeben wird
$view->partialLoop()->setObjectKey('model');

Diese Technik ist speziell dann sinnvoll wenn Zend_Db_Table_Rowsets an partialLoop() übergeben werden, da man dann kompletten Zugriff auf die Zeilenobjekte im View Skript hat, was es einem erlaubt Ihre Methoden auszurufen (wie das empfangen von Werten bei Eltern- oder abhängigen Zeilen).

Example #5 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":

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

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

Example #6 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 Separatoren für vereinigte Inhalte).

Example #7 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 #8 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 #9 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 separat 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

  • HTML5

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

Der Doctype Helfer ist eine konkrete Implementation des Platzhalter Helfers.

Example #10 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 #11 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 = $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
}

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 #13 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:

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

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:

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.

Note: Abhängige Kommentare setzen

HeadScript erlaubt es ein Script Tag in abhängige Kommentare zu setzen, das es erlaubt es vor speziellen Browsern zu verstecken. Um abhängige Tags zu setzen, muß der abhängige Wert als Teil des $attrs Parameters im Methodenaufruf übergeben werden.

Example #14 Headscript mit abhängigen Kommentaren

// Scripte hinzufügen
$this->headScript()->appendFile(
    '/js/prototype.js',
    'text/javascript',
    array('conditional' => 'lt IE 7')
);

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:

$this->headScript()->setAllowArbitraryAttributes(true);

Example #15 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.

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

headScript() ?>

Example #16 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.

Note: Abhängige Kommentare setzen

HeadStyle erlaubt es ein Script Tag in abhängige Kommentare zu setzen, das es erlaubt es vor speziellen Browsern zu verstecken. Um abhängige Tags zu setzen, muß der abhängige Wert als Teil des $attrs Parameters im Methodenaufruf übergeben werden.

Example #17 Headstyle mit abhängigen Kommentaren

// Skripte hinzufügen
$this->headStyle()->appendStyle($styles, array('conditional' => 'lt IE 7');

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 #18 Grundsätzliche Verwendung des HeadStyle Helfers

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:

headStyle() ?>

Example #19 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 #20 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.

// Setzen des Kontroller 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:


headTitle() ?>

HTML Objekt Helfer

Das HTML <object> Element wird für das Einbetten von Medien wie Flash oder Quicktime in Webseiten verwendet. Der Object View Helfer übernimmt die Einbettung von Medien mit einem minimalen Aufwand.

Es gibt initial view Objekt Helfer:

  • formFlash Erzeugt Markup für die Einbettung von Flash Dateien.

  • formObject Erzeugt Markup für die Einbettung von eigenen Objekten.

  • formPage Erzeugt Markup für die Einbettung anderer (X)HTML Seiten.

  • formQuicktime Erzeugt Markup für die Einbettung von QuickTime Dateien.

Alle diese Helfer teilen sich das gleiche Interface. Aus diesem Grund enthält diese Dokumentation nur Beispiele für zwei dieser Helfer.

Example #21 Flash Helfer

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

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

Das gibt das folgende HTML aus:


Zusätzlich können Attribute, Parameter und Inhalte definiert werden die mit dem <object> dargestellt werden. Das wird durch Verwendung des htmlObject Helfers demonstriert.

Example #22 Anpassen des Objekts durch die Übergabe von zusätzlichen Argumenten

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:


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

Note: Layouts behalten und Encoding einschalten durch Verwendung von Zend_Json_Expr

Jede Methode im JSON Helfer akzwptiert ein zweites, optionales, Argument. Dieses zweite Argument kan ein boolsches Flag sein um Layouts ein- oder auszuschalten, oder ein Array von Optionen die an Zend_Json::encode() übergeben und intern verwendet werden um Daten zu kodieren.

Um Layouts zu behalten muß der zweite Parameter ein boolsches true sein. Wenn der zweite Parameter ein Array ist, können Layouts behalten werden indem ein keepLayouts Schlüssel mit dem boolschen Wert true eingefügt wird.

// Ein boolsches true als zweites Argument aktiviert Layouts:
echo $this->json($this->data, true);

// Oder ein boolsches true als "keepLayouts" Schlüssel:
echo $this->json($this->data, array('keepLayouts' => true));

Zend_Json::encode erlaubt es native JSON Ausdrücke zu kodieren indem Zend_Json_Expr Objekte verwendet werden. Diese Option ist standardmäßig deaktiviert. Um diese Option zu aktivieren, muß ein boolsches true an den enableJsonExprFinder Schlüssel des Options Arrays übergeben werden:

json($this->data, array(
    'enableJsonExprFinder' => true,
    'keepLayouts'          => true,
)) ?>

Navigations Helfer

Die Navigations Helfer werden von Zend_Navigation_Container für die Darstellung von Navigations Elementen verwendet.

Es gibt 2 eingebaute Helfer:

  • Breadcrumbs, wird für die Darstellung des Pfades der aktuell aktiven Seite verwendet.

  • Links, wird für die Darstellung von Navigations Header Links (z.B. <link rel="next" href="..." />) verwendet.

  • Menu, wird für die Darstellung von Menüs verwendet.

  • Sitemap, wird für die Darstellung von Sitemaps verwendet die dem » Sitemaps XML Format entsprechen.

  • Navigation, wird für die Weiterleitung von Aufrufen zu anderen Navigations Helfern verwendet.

Alle eingebauten Helfer erweitern Zend_View_Helper_Navigation_HelperAbstract, welches die Integration von ACL und Übersetzung hinzufügt. Die abstrakte Klasse implementiert das Interface Zend_View_Helper_Navigation_Helper welches die folgenden Methoden definiert:
  • {get|set}Container() empfängt/setzt den Navigations Container mit dem der Helfer standardmäßig arbeiten soll, und hasContainer() prüft ob der Helfer Container registriert hat.

  • {get|set}Translator() empfängt/setzt den Übersetzer der für die Übersetzung von Überschriften und Titelm verwendet wird, und {get|set}UseTranslator() kontrolliert ob der Übersetzer aktiviert werden soll. Die Methode hasTranslator() prüft ob der Helfer einen Übersetzer registriert hat.

  • {get|set}Acl(), {get|set}Role(), empfängt/setzt ACL (Zend_Acl) Instanzen und Rollen (string oder Zend_Acl_Role_Interface) die bei der Darstellung für das Filtern von Seiten verwendet werden, und {get|set}UseAcl() kontrolliert ob ACL aktiviert werden soll. Die Methoden hasAcl() und hasRole() prüfen ob der Helfer eine ACL Instanz oder Rolle registriert hat.

  • __toString(), die magische Methode stellt sicher das der Helfer, durch den direkten Aufruf von echo an der Instanz des Helfers, dargestellt werden kann.

  • render(), muß von konkreten Helfern implementiert werden um die Darstellung durchzuführen.

Zusätzlich zu den Methoden die vom Interface kommen, implementiert die abstrakte Klasse die folgenden Methoden:
  • {get|set}Indent() empfängt/setzt die Einrückung. Der Setzer akzeptiert einen string oder ein int. Im Fall eines int's verwendet der Helfer die angegebene Zahl als Leerzeichen für die Einrückung. Z.B. bedeutet setIndent(4) eine Einrückung von initial 4 Leerzeichen. Die Einrückung kann für alle Helfer außer dem Sitemap Helfer spezifiziert werden.

  • {get|set}MinDepth() empfängt/setzt die minimale Tiefe die eine Seite haben muß um vom Helfer eingefügt zu werden. Das Setzen von null bedeutet keine minimale Tiefe.

  • {get|set}MaxDepth() empfängt/setzt die maximale Tiefe die eine Seite haben muß um vom Helfer eingefügt zu werden. Das Setzen von null bedeutet keine maximale Tiefe.

  • __call() wird verwendet um Aufrufe zum Container, der im Helfer registriert ist, weiterzuleiten, was bedeutet das man Methoden in einem Helfer aufrufen kann wie wenn Sie im Container wären. Siehe das folgende Beispiel.

  • findActive($container, $minDepth, $maxDepth) wird verwendet um die tiefste aktive Seite im angegebenen Container zu finden. Wenn keine Tiefe angegeben wird, verwendet diese Methode die Werte die sie von getMinDepth() und getMaxDepth() erhält. Die tiefste aktive Seite muß zwischen $minDepth und $maxDepth inklusive liegen. Gibt ein Array zurück das Referenzen zu der gefundenen Instanz der Seite enthält, und die Tiefe bei der die Seite gefunden wurde.

  • htmlify() stellt ein a HTML Element von einer Zend_Navigation_Page Instanz dar.

  • accept() wird verwendet um zu erkennen ub eine Seite akzeptiert werden soll wenn durch Container iteriert wird. Diese Methode prüft die Sichtbarkeit der Seite und verifiziert das die Rolle des Helfers auf die Ressource/Privilegien der Seite zugreifen darf.

  • static setDefaultAcl() wird für das Setzen des standardmäßigen ACL Objekts verwendet, das dann von Helfern verwendet wird.

  • static setDefaultRole() wird für das Setzen der standardmäßigen Rolle verwendet, die dann von Helfern verwendet wird.

Wenn ein Navigations Container nicht explizit in einem Helfer durch Verwendung von $helper->setContainer($nav) gesetzt ist, schaut der Helfer in der Registry nach einer Container Instanz mit dem Schlüssel Zend_Navigation. Wenn ein Container nicht explizit gesetzt wurde, oder nicht in der Registry gefunden wird, erstellt der Helfer einen leeren Zend_Navigation Container wenn $helper->getContainer() aufgerufen wird.

Example #23 Aufrufe an den Navigations Container weiterleiten

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.

Übersetzung von Labels und Titeln

Der Navigations Helfer unterstützt die Übersetzung von SeitenLabels und Überschriften. Man kann einen Übersetzer vom Typ Zend_Translate oder Zend_Translate_Adapter im Helfer setzen indem $helper->setTranslator($translator) verwendet wird, oder wie in allen anderen I18n-fähigen Komponenten; durch das Hinzufügen des Übersetzers in die Registry indem der Schlüssel Zend_Translate verwendet wird.

Wenn man die Übersetzung ausschalten will, sollte man $helper->setUseTranslator(false) verwenden.

Der Proxy Helfer injiziert seinen eigenen Übersetzer in den Helfer auf den er weiterleitet wenn der weitergeleitete Helfer nicht bereits einen Übersetzer hat.

Note:

Es gibt keinen Übersetzer im Sitemap Helfer, da keine SeitenLabels oder Überschriften in einer XML Sitemap enthalten sind.

Integration mit ACL

Alle navigatorischen View Helfer unterstützen ACL abgeleitet von der Zend_View_Helper_Navigation_HelperAbstract Klasse. Ein Zend_Acl Objekt kann einer Instanz eines Helfers mit $helper->setAcl($acl) hinzugefügt werden, und eine Rolle mit $helper->setRole('member') oder $helper->setRole(new Zend_Acl_Role('member')). Wenn ACL im Helfer verwendet wird, muß es der Rolle im Helfer vom ACL erlaubt sein auf die Ressourcen zuzugreifen und/oder das die Privilegien für diese Seite bei der Darstellung eingefügt werden dürfen.

Wenn eine Seite vom ACL nicht akzeptiert ist, wird auch jede untergeordnete Seite von der Darstellung ausgenommen sein. If a page is not accepted by ACL, any descendant page will also be excluded from rendering.

Der Proxy Helfer injiziert seine eigene ACL und Rolle in den Helfer zu dem er weiterleitet wenn der weitergeleitete Helfer nicht bereits einen hat.

Das Beispiel von unten zeigt wie ACL die Darstellung beeinflusst.

Setup der Navigation das in Beispielen verwendet wird

Dieses Beispiel zeigt das Setup eines Navigations Container für eine fiktive Software Firma.

Notizen zum Setup:

  • Die Domain der Site ist www.example.com.

  • Interessante Eigenschaften der Seite sind mit einem Kommentar markiert.

  • Solange im Beispiel nicht anders erwähnt, fragt der Benutzer nach der URL http://www.example.com/products/server/faq/, welche auf die Seite mit dem Label FAQ unter Foo Server übersetzt wird.

  • Das angenommene ACL und Route Setup wird unter dem Container Setup gezeigt.

/*
 * Navigations Container (config/array)

 * Jedes Element im Array wird an Zend_Navigation_Page::factory()
 * übergeben wenn der unten angezeigt Navigations Container
 * erstellt wird.
 */
$pages = array(
    array(
        'label'      => 'Home',
        'title'      => 'Geh zu Home',
        'module'     => 'default',
        'controller' => 'index',
        'action'     => 'index',
        'order'      => -100 // Sicherstellen das Home die erste Seite ist
    ),
    array(
        'label'      => 'Spezielles Angebot nur diese Woche!',
        'module'     => 'store',
        'controller' => 'offer',
        'action'     => 'amazing',
        'visible'    => false // nicht sichtbar
    ),
    array(
        'label'      => 'Produkte',
        'module'     => 'products',
        'controller' => 'index',
        'action'     => 'index',
        'pages'      => array(
            array(
                'label'      => 'Foo Server',
                'module'     => 'products',
                'controller' => 'server',
                'action'     => 'index',
                'pages'      => array(
                    array(
                        'label'      => 'FAQ',
                        'module'     => 'products',
                        'controller' => 'server',
                        'action'     => 'faq',
                        'rel'        => array(
                            'canonical' => 'http://www.example.com/?page=faq',
                            'alternate' => array(
                                'module'     => 'products',
                                'controller' => 'server',
                                'action'     => 'faq',
                                'params'     => array('format' => 'xml')
                            )
                        )
                    ),
                    array(
                        'label'      => 'Editionen',
                        'module'     => 'products',
                        'controller' => 'server',
                        'action'     => 'editions'
                    ),
                    array(
                        'label'      => 'System Anforderungen',
                        'module'     => 'products',
                        'controller' => 'server',
                        'action'     => 'requirements'
                    )
                )
            ),
            array(
                'label'      => 'Foo Studio',
                'module'     => 'products',
                'controller' => 'studio',
                'action'     => 'index',
                'pages'      => array(
                    array(
                        'label'      => 'Kunden Stories',
                        'module'     => 'products',
                        'controller' => 'studio',
                        'action'     => 'customers'
                    ),
                    array(
                        'label'      => 'Support',
                        'module'     => 'prodcts',
                        'controller' => 'studio',
                        'action'     => 'support'
                    )
                )
            )
        )
    ),
    array(
        'label'      => 'Firma',
        'title'      => 'Über uns',
        'module'     => 'company',
        'controller' => 'about',
        'action'     => 'index',
        'pages'      => array(
            array(
                'label'      => 'Investor Relations',
                'module'     => 'company',
                'controller' => 'about',
                'action'     => 'investors'
            ),
            array(
                'label'      => 'News',
                'class'      => 'rss', // Klasse
                'module'     => 'company',
                'controller' => 'news',
                'action'     => 'index',
                'pages'      => array(
                    array(
                        'label'      => 'Für die Presse',
                        'module'     => 'company',
                        'controller' => 'news',
                        'action'     => 'press'
                    ),
                    array(
                        'label'      => 'Archiv',
                        'route'      => 'archive', // Route
                        'module'     => 'company',
                        'controller' => 'news',
                        'action'     => 'archive'
                    )
                )
            )
        )
    ),
    array(
        'label'      => 'Community',
        'module'     => 'community',
        'controller' => 'index',
        'action'     => 'index',
        'pages'      => array(
            array(
                'label'      => 'Mein Account',
                'module'     => 'community',
                'controller' => 'account',
                'action'     => 'index',
                'resource'   => 'mvc:community.account' // Ressource
            ),
            array(
                'label' => 'Forum',
                'uri'   => 'http://forums.example.com/',
                'class' => 'external' // Klasse
            )
        )
    ),
    array(
        'label'      => 'Administration',
        'module'     => 'admin',
        'controller' => 'index',
        'action'     => 'index',
        'resource'   => 'mvc:admin', // Ressource
        'pages'      => array(
            array(
                'label'      => 'Neuen Artikel schreiben',
                'module'     => 'admin',
                'controller' => 'post',
                'aciton'     => 'write'
            )
        )
    )
);

// Container von einem Array erstellen
$container = new Zend_Navigation($pages);

// Den Container im Proxy Helfer speichern
$view->getHelper('navigation')->setContainer($container);

// ...oder einfach:
$view->navigation($container);

// ...oder ihn einfach in der Registry speichern:
Zend_Registry::set('Zend_Navigation', $container);

Zusätzlich zum obigen Container, wird das folgende Setup angenommen:

// Router Setup (Standardrouten und 'archive' Route):
$front = Zend_Controller_Front::getInstance();
$router = $front->getRouter();
$router->addDefaultRoutes();
$router->addRoute(
    'archive',
    new Zend_Controller_Router_Route(
        '/archive/:year',
        array(
            'module'     => 'company',
            'controller' => 'news',
            'action'     => 'archive',
            'year'       => (int) date('Y') - 1
        ),
        array('year' => '\d+')
    )
);

// ACL Setup:
$acl = new Zend_Acl();
$acl->addRole(new Zend_Acl_Role('member'));
$acl->addRole(new Zend_Acl_Role('admin'));
$acl->add(new Zend_Acl_Resource('mvc:admin'));
$acl->add(new Zend_Acl_Resource('mvc:community.account'));
$acl->allow('member', 'mvc:community.account');
$acl->allow('admin', null);

// ACL und Rolle im Proxy Helfer speichern:
$view->navigation()->setAcl($acl)->setRole('member');

// ...oder ein standard ACL und Rolle statisch setzen:
Zend_View_Helper_Navigation_HelperAbstract::setDefaultAcl($acl);
Zend_View_Helper_Navigation_HelperAbstract::setDefaultRole('member');

Breadcrumbs Helfer

Breadcrumbs werden verwendet um anzuzeigen wo in einer Sitemap ein Benutzer aktuell browst, und werden typischerweise wie folgt angezeigt: "Du bist hier: Home > Produkte > FantastischesProdukt 1.0". Der BreakCrumbs Helfer folgt den Richtlinien von » Breadcrumbs Pattern - Yahoo! Design Pattern Library, und erlaubt eine einfache Anpassung (Minimale/Maximale Tiefe, Einrückung, Trennzeichen, und ob das letzte Element verlinkt sein soll), oder die Darstellung durch Verwendung eines partiellen View Skripts.

Der Breabcrumbs Helfer funktioniert wie folgt; er findet die tiefste aktive Seite in einem Navigations Container, und stellt den aufwärtsgerichteten Pfad zum Root dar. Für MVC Seiten wird die "Aktivität" einer Seite erkannt indem das Anfrage Objekt angeschaut wird, wie im Kapitel Zend_Navigation_Page_Mvc beschrieben.

Der Helfer setzt die Eigenschaft minDepth standardmäßig auf 1, was bedeutet das Breadcrumbs nicht dargestellt werden wenn die tiefste aktive Seite eine Root Seite ist. Wenn maxDepth spezifiziert ist, beendet der Helfer die Darstellung bei der spezifizierten Tiefe (z.B. stopp bei Level 2 selbst wenn die tiefste aktive Seite auf Level 3 ist).

Methoden im Breakcrumbs Helfer sind:

  • {get|set}Separator() empfängt/setzt das Trennzeichen das zwischen Breakcrumbs verwendet wird. Der Standardwert ist ' &gt; '.

  • {get|set}LinkLast() empfängt/setzt ob der letzte Breabcrumb als Anker dargestellt werden soll oder nicht. Der Standardwert ist false.

  • {get|set}Partial() empfängt/setzt ein partielles View Skript das für die Darstellung von Breadcrumbs verwendet werden soll. Wenn ein partielles View Skript gesetzt ist, verwendet die render() Methode des Helfers die renderPartial() Methode. Wenn kein partielles gesetzt ist, wird die renderStraight() Methode verwendet. Der Helfer erwartet das der partielle ein string oder ein array mit zwei Elementen ist. Wen der Partielle ein string ist, benennt er den Namen des partiellen Skripts das zu verwenden ist. Wenn er ein array ist, wird das erste Element als Name des partiellen View Skripts verwendet, und das zweite Element ist das Modul in dem das Skript zu finden ist.

  • renderStraight() ist die standardmäßige render Methode.

  • renderPartial() wird für die Darstellung verwendet wenn ein partielles View Skript verwendet wird.

Example #24 Darstellung von Breadcrumbs

Dieses Beispiel zeigt wie Breadcrumbs mit Standardsettings dargestellt werden.

In einem View Skript oder Layout:
navigation()->breadcrumbs(); ?>

oder wenn Short-Tags aktiviert sind:
navigation()->breadcrumbs(); ?>

Die zwei obigen Aufrufe verwenden die magische __toString() Methode,
und sind identisch mit:
navigation()->breadcrumbs()->render(); ?>

Ausgabe:
Produkte > Foo Server > FAQ

Example #25 Einrückung spezifizieren

Dieses Beispiel zeigt wie Breadcrumbs mit anfänglicher Einrückung dargestellt werden können.

Darstellung mit 8 Leerzeichen Einrückung:
navigation()->breadcrumbs()->setIndent(8); ?>

Ausgabe:
        Products > Foo Server > FAQ

Example #26 Eigene Ausgabe für Breakcrumbs

Dieses Beispiel zeigt wie man eine eigene Breadcrumbs Ausgabe durch die Spezifizierung diverser Optionen erstellt.

In einem View Skript oder Layout:

navigation()
          ->breadcrumbs()
          ->setLinkLast(true)                   // Letzte Seite verlinken
          ->setMaxDepth(1)                      // Bei Level 1 stoppen
          ->setSeparator(' ▶' . PHP_EOL); // Cooler Seperator mit Umbruch
?>

Output:
ProdukteFoo Server

/////////////////////////////////////////////////////

Minimale notwendige Tiefe für die Darstellung von Breadcrumbs setzen:

navigation()->breadcrumbs()->setMinDepth(10);
echo $this->navigation()->breadcrumbs();
?>

Ausgabe:
Nichts, weil die tiefste aktive Seite nicht auf Level 10 oder tiefer ist.

Example #27 Darstellung von Breadcrumbs mit Verwendung eines partiellen View Skripts

Dieses Beispiel zeigt wir eigene Breakcrumbs durch Verwendung eines partiellen View Skripts dargestellt werden können. Durch den Aufruf von setPartial() kann man ein partielles View Skript spezifizieren das verwendet wird wenn die renderPartial() Methode aufgerufen wird. Diese Methode findest die tiefste aktive Seite und übergibt ein Array von Seiten die zur aktiven Seite des partiellen View Skripts weiterleitet.

Im Layout:

$partial = ;
echo $this->navigation()->breadcrumbs()
                        ->setPartial(array('breadcrumbs.phtml', 'default'));

Inhalt von application/modules/default/views/breadcrumbs.phtml:

echo implode(', ', array_map(
        create_function('$a', 'return $a->getLabel();'),
        $this->pages));

Ausgabe:

Produkte, Foo Server, FAQ

Menu Helfer

Der Menu Helfer wird für die Darstellung von Menüs aus Navigations Containern verwendet. Standardmäßig wird das Menü durch Verwendung der HTML Tags UL und LI dargestellt. Der Helfer erlaubt aber auch die Verwendung eines partiellen View Skripts.

Methoden im Menu Helfer:

  • {get|set}UlClass() empfängt/setzt die CSS Klasse zur Verwendung in renderMenu().

  • {get|set}OnlyActiveBranch() empfängt/setzt ein Flag das spezifiziert ob der aktive Zweig eines Containers dargestellt werden soll.

  • {get|set}RenderParents() empfängt/setzt ein Flag das spezifiziert ob Eltern nur dargestellt werden sollen wenn nur der aktive Zweig eines Containers dargestellt wird. Wenn es auf false gesetzt wird, wird nur das tiefste aktive Menü dargestellt.

  • {get|set}Partial() empfängt/setzt ein partielles View Skript das für die Darstellung des Menüs verwendet werden soll. Wenn ein partielles Skript gesetzt ist, verwendet die render() Methode des Helfers die renderPartial() Methode. Wenn kein Partieller gesetzt ist, wird die renderMenu() Methode verwendet. Der Helfer erwartet das der Partielle ein string, oder ein array mit zwei Elementen, ist. Wenn der Partielle ein string ist bezeichnet er den Namen des partiellen Skripts das zu verwenden ist. Wenn er ein array ist wird das erste Element als Name des partiellen View Skripts verwendet, und das zweite Element ist das Modul indem das Skript gefunden wird.

  • htmlify() überschreibt die Methode der abstrakten Klasse damit span Elemente zurückgegeben werden wenn die Seite kein href hat.

  • renderMenu($container = null, $options = array()) ist eine standardmäßige render Methode, und stellt einen Container als HTML UL Liste dar.

    Wenn $container nicht angegeben wird, wird der Container der im Helfer registriert ist dargestellt.

    $options wird verwendet um temporär spezifizierte Optionen zu überschreiben ohne das die Werte in der Helferinstanz resetiert werden. Es ist ein assoziatives Array wobei jeder Schlüssel mit einer Option im Helfer korrespondiert.

    Erkannte Optionen:

    • indent; Einrückung. Erwartet einen string oder einen int Wert.

    • minDepth; Minimale Tiefe. Erwartet ein int oder null (keine minimale Tiefe).

    • maxDepth; Maximale Tiefe. Erwartet ein int oder null (keine maximale Tiefe).

    • ulClass; CSS Klasse für das ul Element. Erwartet einen string.

    • onlyActiveBranch; Ob nur der aktive Branch dargestellt werden soll. Erwartet einen boolean Wert.

    • renderParents; Ob eltern dargestellt werden sollen wenn nur der aktive Branch dargestellt wird. Erwartet einen boolean Wert.

    Wenn keine Option angegeben wird, werden die Werte die im Helfer gesetzt sind verwendet.

  • renderPartial() wird für die Darstellung des Menüs in einem partiellen View Skript verwendet.

  • renderSubMenu() stellt das tiefste Menü Level des aktiven Branches eines Containers dar.

Example #31 Darstellung eines Menüs

Dieses Beispiel zeigt wie ein Menü von einem registrierten/im View Helfer gefundenen Container, dargestellt wird. Es ist zu beachten das Seiten basierend auf Ihrer Sichtbarkeit und ACL ausgefiltert werden.

In einem View Skript oder Layout:
navigation()->menu()->render() ?>

Oder einfach:
navigation()->menu() ?>

Oder wenn Short Tags aktiviert sind:
navigation()->menu() ?>

Ausgabe:

Example #32 renderMenu() direkt aufrufen

Dieses Beispiel zeigt wie ein Menü dargestellt werden kann das nicht im View Helfer registriert ist, indem renderMenu() direkt aufgerufen wird und ein paar wenige Optionen spezifiziert werden.

navigation()->findOneByLabel('Community');
$options = array(
    'indent'  => 16,
    'ulClass' => 'community'
);
echo $this->navigation()
          ->menu()
          ->renderMenu($community, $options);
?>
Output:
                

Example #33 Das tiefste aktive Menü darstellen

Dieses Beispiel zeigt wie renderSubMenu() das tiefste Untermenü des aktiven Branches dargestellt wird.

Der Aufruf von renderSubMenu($container, $ulClass, $indent) ist identisch mit dem Aufruf von renderMenu($container, $options) mit den folgenden Optionen: array( 'ulClass' => $ulClass, 'indent' => $indent, 'minDepth' => null, 'maxDepth' => null, 'onlyActiveBranch' => true, 'renderParents' => false )

navigation()
          ->menu()
          ->renderSubMenu(null, 'sidebar', 4);
?>

Die Ausgabe ist die gleiche wenn 'FAQ' oder 'Foo Server' aktiv sind:
    

Example #34 Darstellung eines Menüs mit maximaler Tiefe

navigation()
          ->menu()
          ->setMaxDepth(1);
?>

Ausgabe:

Example #35 Darstellung eines Menüs mit minimaler Tiefe

navigation()
          ->menu()
          ->setMinDepth(1);
?>

Ausgabe:

Example #36 Nur den aktiven Branch eines Menüs darstellen

navigation()
          ->menu()
          ->setOnlyActiveBranch(true);
?>

Ausgabe:

Example #37 Nur den aktiven Branch eines Menüs mit minimaler Tiefe darstellen

navigation()
          ->menu()
          ->setOnlyActiveBranch(true)
          ->setMinDepth(1);
?>

Ausgabe:

Example #38 Nur den aktiven Branch eines Menüs mit maximaler Tiefe darstellen

navigation()
          ->menu()
          ->setOnlyActiveBranch(true)
          ->setMaxDepth(1);
?>

Ausgabe:

Example #39 Nur den aktiven Branch eines Menüs mit maximaler Tiefe aber ohne Eltern darstellen

navigation()
          ->menu()
          ->setOnlyActiveBranch(true)
          ->setRenderParents(false)
          ->setMaxDepth(1);
?>

Ausgabe:

Example #40 Darstellen eines eigenen Menüs durch Verwendung eines partiellen View Skripts

Dieses Beispiel zeigt wie ein eigenes Menü, durch Verwendung eines partiellen View Skripts, dargestellt werden kann. Durch Aufruf von setPartial() kann ein partielles View Skript spezifiziert werden das verwendet wird wenn man render() aufruft. Wenn ein Partielles spezifiziert ist, wird die renderPartial() Methode aufgerufen. Diese Methode fügt den Container in die View ein, und verwendet hierbei den Schlüssel container.

In a layout:

$partial = array('menu.phtml', 'default');
$this->navigation()->menu()->setPartial($partial);
echo $this->navigation()->menu()->render();

In application/modules/default/views/menu.phtml:

foreach ($this->container as $page) {
    echo $this->menu()->htmlify($page), PHP_EOL;
}

Ausgabe:

Home
Produkte
Firma
Community

Sitemap Helfer

Der Sitemap Helfer wird für die Erzeugung von XML Sitemaps verwendet wie im » Sitemaps XML Format definiert. Mehr darüber kann unter »  Sitemaps in Wikipedia nachgelesen werden.

Standardmäßig verwendet der Sitemap Helfer Sitemap Prüfungen um jedes Element zu prüfen das dargestellt werden soll. Das kann deaktiviert werden indem man $helper->setUseSitemapValidators(false) aufruft.

Note:

Wenn man die Sitemap Prüfungen deaktiviert, werden die eigenen Eigenschaften (siehe Tabelle) nicht geprüft.

Der Sitemap Helfer unterstützt auch die Pürfung von » Sitemap XSD Schemas der erzeugten Sitemap. Das ist standardmäßig deaktiviert, da es eine Anfrage auf die Schema Datei benötigt. Es kann mit $helper->setUseSchemaValidation(true) aktiviert werden.

Sitemap XML Elemente
Element Beschreibung
loc Absolute UTL zur Seite. Eine absolute URL wird vom Helfer erzeugt.
lastmod

Das Datum der letzten Änderung der Datei, im » W3C Datetime Format. Dieser Zeitabschnitt kann bei Bedarf unterdrückt, und nur YYYY-MM-DD verwendet werden.

Der Helfer versucht den lastmod Wert von der Seiteneigenschaft lastmod zu erhalten wenn diese auf der Seite gesetzt ist. Wenn der Wert kein gültiges Datum ist, wird er ignoriert.

changefreq

Wie oft eine Seite geändert wird. Dieser Wert bietet eine generelle Information für Suchmaschinen und muß nicht exakt mit der Anzahl der Suchen auf der Seite übereinstimmen. Gültige Werte sind:

  • always

  • hourly

  • daily

  • weekly

  • monthly

  • yearly

  • never

Der Helfer versucht den changefreq Wert von der Seiteneigenschaft changefreq zu erhalten, wenn diese auf der Seite gesetzt ist. Wenn der Wert nicht gültig ist, wird er ignoriert.

priority

Die Priorität dieser URL relativ zu anderen URLs auf der eigenen Site. Der gültige Bereich für diesen Wert ist von 0.0 bis 1.0.

Der Helfer versucht den priority Wert von der Seiteneigenschaft priority zu erhalten wenn dieser auf der Seite gesetzt ist. Wenn der Wert nicht gültig ist, wird er ignoriert.

Methoden im Sitemap Helfer:

  • {get|set}FormatOutput() empfängt/setzt ein Flag das anzeigt ob XML Ausgaben formatiert werden sollen. Das entspricht der Eigenschaft formatOutput der nativen DOMDocument Klasse. Mehr kann man unter » PHP: DOMDocument - Handbuch nachlesen. Der Standardwert ist false.

  • {get|set}UseXmlDeclaration() empfängt/setzt ein Flag das anzeigt ob die XML Deklaration bei der Darstellung enthalten sein soll. Der Standardwert ist true.

  • {get|set}UseSitemapValidators() empfängt/setzt ein Flag das anzeigt ob Sitemap Prüfungen verwendet werden sollen wenn die DOM Sitemap dargestellt werden soll. Der Standardwert ist true.

  • {get|set}UseSchemaValidation() empfängt/setzt ein Flag das anzeigt ob der Helfer eine XML Schema Prüfung verwenden soll wenn die DOM Sitemap erzeugt wird. Der Standardwert ist false.

  • {get|set}ServerUrl() empfängt/setzt die Server URL die nicht-absoluten URLs in der url() Methode vorangestellt werden. Wenn keine Server URL spezifiziert ist, wird diese vom Helfer festgestellt.

  • url() wird verwendet um absolute URLs zu Seiten zu erstellen.

  • getDomSitemap() erzeugt ein DOMDocument von einem angegebenen Container.

Example #41 Eine XML Sitemap darstellen

Dieses Beispiel zeigt wie eine XML Sitemap, basierend auf dem Setup das wir vorher angegeben haben, dargestellt wird.

// In einem View Skript oder Layout:

// Ausgabeformat
$this->navigation()
      ->sitemap()
      ->setFormatOutput(true); // Standardwert ist false

// Andere mögliche Methoden:
// ->setUseXmlDeclaration(false); // Standardwert ist true
// ->setServerUrl('http://my.otherhost.com');
// Standard ist die automatische Erkennung

// Sitemap ausdrucken
echo $this->navigation()->sitemap();

Es ist zu beachten wie Seiten die unsichtbar oder Seiten mit ACL Rollen die mit dem View Helfer inkompatibel sin, ausgefiltert werden:



  
    http://www.example.com/
  
  
    http://www.example.com/products
  
  
    http://www.example.com/products/server
  
  
    http://www.example.com/products/server/faq
  
  
    http://www.example.com/products/server/editions
  
  
    http://www.example.com/products/server/requirements
  
  
    http://www.example.com/products/studio
  
  
    http://www.example.com/products/studio/customers
  
  
    http://www.example.com/prodcts/studio/support
  
  
    http://www.example.com/company/about
  
  
    http://www.example.com/company/about/investors
  
  
    http://www.example.com/company/news
  
  
    http://www.example.com/company/news/press
  
  
    http://www.example.com/archive
  
  
    http://www.example.com/community
  
  
    http://www.example.com/community/account
  
  
    http://forums.example.com/
  

Die Sitemap ohne Verwendung einer ACL Rolle darstellen (sollte /community/account ausfiltern):

echo $this->navigation()
          ->sitemap()
          ->setFormatOutput(true)
          ->setRole();


  
    http://www.example.com/
  
  
    http://www.example.com/products
  
  
    http://www.example.com/products/server
  
  
    http://www.example.com/products/server/faq
  
  
    http://www.example.com/products/server/editions
  
  
    http://www.example.com/products/server/requirements
  
  
    http://www.example.com/products/studio
  
  
    http://www.example.com/products/studio/customers
  
  
    http://www.example.com/prodcts/studio/support
  
  
    http://www.example.com/company/about
  
  
    http://www.example.com/company/about/investors
  
  
    http://www.example.com/company/news
  
  
    http://www.example.com/company/news/press
  
  
    http://www.example.com/archive
  
  
    http://www.example.com/community
  
  
    http://forums.example.com/
  

Darstellen der Sitemap mit Verwendung einer maximalen Tiefe von 1.

echo $this->navigation()
          ->sitemap()
          ->setFormatOutput(true)
          ->setMaxDepth(1);


  
    http://www.example.com/
  
  
    http://www.example.com/products
  
  
    http://www.example.com/products/server
  
  
    http://www.example.com/products/studio
  
  
    http://www.example.com/company/about
  
  
    http://www.example.com/company/about/investors
  
  
    http://www.example.com/company/news
  
  
    http://www.example.com/community
  
  
    http://www.example.com/community/account
  
  
    http://forums.example.com/
  

Navigation Helfer

Der Navigation Helfer ist ein Proxy Helfer der Aufrufe zu anderen Navigations Helfern durchführt. Er kann als Einstiegspunkt fpr alle navigations-basierenden View Tasks verwendet werden. Die vorher erwähnten Navigations Helfer sind im Namespace Zend_View_Helper_Navigation und würden es deshalb benötigen, den Pfad Zend/View/Helper/Navigation als Helfer Pfad der View hinzuzufügen. Mit dem Proxy Helfer der im Zend_View_Helper Namespace sitzt, ist er immer vorhanden, ohne das irgendein Helfer Pfad an der View hinzugefügt werden muß.

Der Navigations Helfer findet andere Helfer die das Zend_View_Helper_Navigation_Helper Interface implementieren, was bedeuet das auch auf eigene View Helfer weitergeleitet wird. Das würde trotzdem das Hinzufügen des eigenen Helfer Pfades zur View benötigen.

Wenn auf andere Helfer weitergeleitet wird, kann der Navigations Helfer seinen Container, ACL/Rolle und Übersetzer injizieren. Das bedeutet weder das man diese drei nicht explizit in allen navigatorischen Helfern setzen muß, noch das diese in Zend_Registry oder in statische Methoden injiziert werden muß.

  • findHelper() findet alle angegebenen Helfer, prüft das dieser ein navigatorischer Helfer ist, und injiziiert Container, ACL/Rolle und Übersetzer.

  • {get|set}InjectContainer() empfängt/setzt ein Flag das anzeigt ob der Container an weitergeleitete Helfer injiziiert werden soll. Der Standardwert ist true.

  • {get|set}InjectAcl() empfängt/setzt ein Flag das anzeigt ob die ACL/Rolle an weitergeleitete Helfer injiziiert werden soll. Der Standardwert ist true.

  • {get|set}InjectTranslator() empfängt/setzt ein Flag das anzeigt ob der Übersetzer an weitergeleitete Helfer injiziiert werden soll. Der Standardwert ist true.

  • {get|set}DefaultProxy() empfängt/setzt den Standard Proxy. Der Standardwert ist 'menu'.

  • render() leitet auf die render Methode des Standardproxies weiter.

Ü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 #42 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.

// unser Beispieladapter
$adapter = new Zend_Translate('array', array('simple' => '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 #43 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.

// in der View
$adapter = new Zend_Translate('array', array('simple' => '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 #44 Direkte Verwendung

// unser Beispieladapter
$adapter = new Zend_Translate('array', array('simple' => '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 #45 Einzelne Parameter

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

Note:

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

Example #46 Liste von Parametern

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

Example #47 Array von Parametern

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

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 #48 Das Gebietsschema dynamisch wechseln

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

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 #49 Das Gebietsschema statisch wechseln

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

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 #50 Das aktuell gesetzte Gebietsschema erhalten

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

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.

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

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

  • Wärend das nicht strikt notwendig ist, ist es empfohlen entweder Zend_View_Helper_Interface zu implementieren oder Zend_View_Helper_Abstract zu erweitern wenn eigene Helfer erstellt werden. Eingeführt mit 1.6.0, definieren diese einfach die setView() Methode; trotzdem, in kommenden Releases, ist es geplant ein Strategy Pattern zu implementieren das vieles der Namensschemas einfacher mach wie anbei beschrieben. Wenn darauf aufgebaut wird hilft das, das der eigene Code Zukunftssicher ist.

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

class My_View_Helper_SpecialPurpose extends Zend_View_Helper_Abstract
{
    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.

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

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:

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

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.

Wenn Zend_View_Helper_Abstract erweitert wird, muß diese Methode nicht selbst definiert werden da Sie schon vordefiniert ist.

Previous Next
Introduction to Zend Framework
Übersicht
Installation
Zend_Acl
Einführung
Verfeinern der Zugriffskontrolle
Fortgeschrittene Verwendung
Zend_Amf
Einführung
Zend_Amf_Server
Zend_Application
Einführung
Zend_Application Quick Start
Theorie der Funktionsweise
Beispiele
Kern Funktionalität
Vorhandene Ressource Plugins
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
Einführung
Captcha Anwendung
CAPTCHA Adapter
Zend_CodeGenerator
Einführung
Zend_CodeGenerator Beispiele
Zend_CodeGenerator Referenz
Zend_Config
Einleitung
Theory of Operation
Zend_Config_Ini
Zend_Config_Xml
Zend_Config_Writer
Zend_Config_Writer
Zend_Console_Getopt
Einführung
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
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
Einführung
Zend_Dojo_Data: dojo.data Envelopes
Dojo View Helfer
Formular Elemente und Dekoratore für Dojo
Zend_Dom
Einführung
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
Prüfungen für Zend_File_Transfer
Filter für Zend_File_Transfer
Migration von vorhergehenden Versionen
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 Formular Dekoratoren die mit dem Zend Framework ausgeliefert werden
Internationalisierung von Zend_Form
Fortgeschrittene Verwendung von Zend_Form
Zend_Gdata
Einführung
Authentifizierung mit AuthSub
Die Buchsuche Daten API verwenden
Authentifizieren mit ClientLogin
Google Kalender verwenden
Verwenden der Google Dokumente Listen Daten API
Verwenden von Google Health
Google Tabellenkalkulation verwenden
Google Apps Provisionierung verwenden
Google Base verwenden
Picasa Web Alben verwenden
Verwenden der YouTube Daten API
Gdata Ausnahmen auffangen
Zend_Http
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
Fortgeschrittene Verwendung von Zend_Json
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
Der Autoloader
Ressource Autoloader
Plugins laden
Zend_Locale
Einführung
Zend_Locale verwenden
Normalisierung und Lokalisierung
Arbeiten mit Daten und Zeiten
Unterstützte Gebietsschemata
Migrieren von vorhergehenden Versionen
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_Navigation
Einführung
Seiten
Container
Zend_OpenId
Einführung
Zend_OpenId_Consumer Grundlagen
Zend_OpenId_Provider
Zend_Paginator
Einführung
Verwendung
Konfiguration
Advanced usage
Zend_Pdf
Einführung
Erstellen und Laden von PDF Dokumenten
Änderungen an PDF Dokumenten speichern
Arbeiten mit Seiten
Zeichnen
Dokument Informationen und Metadaten
Anwendungsbeispiel für die Zend_Pdf Komponente
Zend_ProgressBar
Zend_ProgressBar
Zend_Reflection
Einführung
Zend_Reflection Beispiele
Zend_Reflection Referenz
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_Amazon_Ec2
Zend_Service_Amazon_Ec2: Instanzen
Zend_Service_Amazon_Ec2: Windows Instances
Zend_Service_Amazon_Ec2: Reserved Instances
Zend_Service_Amazon_Ec2: CloudWatch Monitoring
Zend_Service_Amazon_Ec2: Amazon Maschinen Images (AMI)
Zend_Service_Amazon_Ec2: Elastischer Block Speicher (EBS)
Zend_Service_Amazon_Ec2: Elastische IP Adressen
Zend_Service_Amazon_Ec2: Schlüsselpaare
Zend_Service_Amazon_Ec2: Regionen und Availability Zones
Zend_Service_Amazon_Ec2: Sicherheitsgruppen
Zend_Service_Amazon_S3
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_Twitter
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
Zend_Tag
Einführung
Zend_Tag_Cloud
Zend_Test
Einführung
Zend_Test_PHPUnit
Zend_Text
Zend_Text_Figlet
Zend_Text_Table
Zend_TimeSync
Einführung
Arbeiten mit Zend_TimeSync
Zend_Tool_Framework
Einführung
Verwenden des CLI Tools
Architecture
Erstellen von Providern für die Verwendung mit Zend_Tool_Framework
Mitgelieferte System Provider
Zend_Tool_Project
Zend_Tool_Project Einführung
Ein Projekt erstellen
Project Provider für Zend Tool
Zend_Translate
Einführung
Adapter für Zend_Translate
Benutzen von Übersetzungs Adaptoren
Migration von vorhergehenden Versionen
Zend_Uri
Zend_Uri
Zend_Validate
Einführung
Standard Prüfklassen
Kettenprüfungen
Schreiben von Prüfern
Prüfungsmeldungen
Zend_Version
Die Version des Zend Frameworks erhalten
Zend_View
Einführung
Controller Skripte
View Scripte
View Helfer
Zend_View_Abstract
Migration von vorhergehenden Versionen
Zend_Wildfire
Zend_Wildfire
Zend_XmlRpc
Einführung
Zend_XmlRpc_Client
Zend_XmlRpc_Server
Zend Framework Voraussetzungen
Einführung
Zend Framework Coding Standard für PHP
Übersicht
PHP Dateiformatierung
Namens Konventionen
Code Stil
Zend Framework Performance Guide
Einführung
Laden von Klassen
Zend_Db Performance
Internationalisierung (I18n) und Lokalisierung (L10n)
Darstellen der View
Urheberrecht Informationen