Previous Next

Seiten

Zend_Navigation wird mit zwei Seiten Typen ausgeliefert:

  • MVC Seiten – diese Verwenden die Klasse Zend_Navigation_Page_Mvc

  • URI Seiten – diese Verwenden die Klasse Zend_Navigation_Page_Uri

MVC Seiten werden auf On-Site Webseiten verlinkt, und definiert indem MVC Parameter verwendet werden (action, controller, module, route, params). URI Seiten werden durch eine einzelne Eigenschaft uri definiert, welche die komplette Funktionalität bietet auf Off-Site Seiten zu verlinken, oder andere Dinge mit erstellten Linkt durchzuführen (z.B. eine URI die zu <a href="#">foo<a> wird).

Übliche Seiten Features

Alle Seiten Klassen müssen Zend_Navigation_Page erweitern, und teilen deshalb ein übliches Set von Features und Eigenschaften. Am ehesten zu beachten ist, das Sie die Optionen in der anbei zu sehenden Tabelle und den gleichen Initialisierungs Prozess teilen.

Options Schlüssel werden zu set Methoden gemappt. Das bedeutet das die Option order auf die Methode setOrder() gemappt wird, und reset_params auf die Methode setResetParams(). Wenn es keine Setter Methode für die Option gibt, wird diese als eigene Eigenschaft der Seite gesetzt.

Lesen Sie mehr über das erweitern von Zend_Navigation_Page in Erstellung eigener Seiten Typen.

Übliche Seiten Optionen
Schlüssel Typ Standardwert Beschreibung
label String NULL Ein Seitenlabel, wie 'Home' oder 'Blog'.
id String | int NULL Ein Id Tag/Attribut das verwendet werden kann wenn die Seite dargestellt wird, typischerweise in einem Anker Element.
class String NULL Eine CSS Klasse die verwendet werden kann wenn die Seite dargestellt wird, typischerweise ein Anker Element.
title String NULL Eine kurze Seitenbeschreibung, typischerweise für die Verwendung als title Attribut in einem Anker.
target String NULL Spezifiziert ein Ziel das für die Seite verwendet werden kann, typischerweise ein Anker Element.
rel Array array() Spezifiziert die Weiterleitungs-Relation für die Seite. Jedes Element im Array ist ein Schlüssel-Wert Paar, wobei der Schlüssel den Relation/Link Typ bestimmt, und der Wert ist ein Pointer zu der verlinkten Seite. Ein Beispiel eines Schlüssel-Wert Paares ist 'alternate' => 'format/plain.html'. Um die volle Flexibilität zu erlauben, gibt es keine Einschränkungen an den Relationswerten. Der Wert muß kein String sein. Lesen Sie über rel und rev im Kapitel der Link Helfer.
rev Array array() Spezifiziert die Rückwärts Relation für die Seite. Arbeitet genauso wie rel.
order String | int | NULL NULL Arbeitet die order für Elemente in Works like order for elements in Zend_Form. Wenn spezifiziert, dann wird die Seite in einer speziellen Reihenfolge durchlaufen, was bedeutet das man eine Seite dazu zwingen kann das eine Seite vor anderen durchlaufen wird indem das order Attribut auf eine kleinere Nummer gesetzt wird, z.B. -100. Wenn ein String angegeben wird, muß dieser in einen gültigen int aufgelöst werden können. Wenn NULL angegeben wird, wird er resetiert, was bedeutet das die Reihenfolge verwendet wird mit der die Seite in den Container hinzugefügt wurde.
resource String | Zend_Acl_Resource_Interface | NULL NULL ACL Ressource die mit der Seite verknüpft werden soll. Lesen Sie mehr im Kapitel ACL Integration in View Helfern.
privilege String | NULL NULL ACL Privileg das mit der Seite assoziiert werden soll. Lesen Sie mehr im Kapitel über ACL Integration in View Helfern.
active bool FALSE Ob die Seite für die aktuelle Anfrage als aktiv betrachtet werden soll. Wenn active FALSE ist oder nicht angegeben wird, werden MVC Seiten Ihr Eigenschaften gegen das Anfrage Objekt prüfen wenn $page->isActive() aufgerufen wird.
visible bool TRUE Ob die Seite für den Benutzer sichtbar sein soll, oder nur ein Teil einer Struktur ist. Unsichtbare Seiten werden von View Helfern übersprungen.
pages Array | Zend_Config | NULL NULL Kind Seiten der Seite. Das sollte ein Array oder Zend_Config Objekt sein das entweder Seiten Optionen enthält die in die factory() Methode übergeben werden können, oder die aktuelle Zend_Navigation_Page Instanz, oder einen Mix von beiden.

Note: Eigene Eigenschaften

Alle Seiten unterstützen das Setzen und Empfangen von eigenen Eigenschaften durch Verwendung der magischen Methoden __set($name, $value), __get($name), __isset($name) und __unset($name). Eigene Eigenschaften können jeden Wert haben, und sind im Array enthalten das von $page->toArray() zurückgegeben wird, was bedeutet das Seiten erfolgreich serialisiert/de-serialisiert werden können, selbst wenn die Seiten Eigenschaften enthalten die nicht nativ in der Seitenklasse sind.

Sowohl native als auch eigene Eigenschaften können gesetzt werden indem $page->set($name, $value) verwendet und empfangen indem $page->get($name) verwendet wird, oder durch die Verwendung der magischen Methoden.

Example #1 Eigene Seiten Eigenschaften

Dieses Beispiel zeigt wie eigene Eigenschaften verwendet werden können.

$page = new Zend_Navigation_Page_Mvc();
$page->foo = 'bar';
$page->meaning = 42;

echo $page->foo;

if ($page->meaning != 42) {
    // Eine Aktion sollte durchgeführt werden
}

Zend_Navigation_Page_Mvc

MVC Seiten werden definiert indem MVC Parameter verwendet werden wie von der Zend_Controller Komponent bekannt. Eine MVC Seite wird intern in der getHref() Methode Zend_Controller_Action_Helper_Url verwenden um hrefs zu erstellen, und die isActive() Methode wird die Parameter von Zend_Controller_Request_Abstract mit den Seiten Parametern verknüpfen um zu erkennen ob die Seite aktiv ist.

MVC Seiten Optionen
Schlüssel Typ Standardwert Beschreibung
action String NULL Name der Aktion die verwendet wird wenn eine href zur Seite erstellt wird.
controller String NULL Name des Controllers der verwendet wird wenn eine href zur Seite erstellt wird.
module String NULL Name des Moduls das verwendet wird wenn eine href zur Seite erstellt wird.
params Array array() Benutzer Parameter die verwendet werden wenn eine href zur Seite erstellt wird.
route String NULL Name der Route die verwendet wird wenn eine href zur Seite erstellt wird.
reset_params bool TRUE Ob Benutzer Parameter resetiert werden sollen wenn eine href zur Seite erstellt wird.

Note:

Die drei Beispiele anbei nehmen ein Standard MVC Setup an mit der default Route an.

Die zurückgegebene URI ist relativ zur baseUrl in Zend_Controller_Front. Im Beispiel ist die baseUrl der Einfachheit halber '/'.

Example #2 getHref() erstellt die Seiten URI

Dieses Beispiel zeigt das MVC Seiten intern Zend_Controller_Action_Helper_Url verwenden um URIs zu erstellen wenn $page->getHref() aufgerufen wird.

// getHref() gibt / zurück
$page = new Zend_Navigation_Page_Mvc(array(
    'action'     => 'index',
    'controller' => 'index'
));

// getHref() gibt /blog/post/view zurück
$page = new Zend_Navigation_Page_Mvc(array(
    'action'     => 'view',
    'controller' => 'post',
    'module'     => 'blog'
));

// getHref() gibt /blog/post/view/id/1337 zurück
$page = new Zend_Navigation_Page_Mvc(array(
    'action'     => 'view',
    'controller' => 'post',
    'module'     => 'blog',
    'params'     => array('id' => 1337)
));

Example #3 isActive() erkennt ob eine Seite aktiv ist

Dieses Beispiel zeigt das MVC Seiten erkennen ob sie aktiv sind indem die Parameter verwendet werden die im Anfrage Objekt gefunden werden.

/*
 * Ausgeführte Anfrage:
 * - module:     default
 * - controller: index
 * - action:     index
 */
$page1 = new Zend_Navigation_Page_Mvc(array(
    'action'     => 'index',
    'controller' => 'index'
));

$page2 = new Zend_Navigation_Page_Mvc(array(
    'action'     => 'bar',
    'controller' => 'index'
));

$page1->isActive(); // returns true
$page2->isActive(); // returns false

/*
 * Ausgeführte Anfrage:
 * - module:     blog
 * - controller: post
 * - action:     view
 * - id:         1337
 */
$page = new Zend_Navigation_Page_Mvc(array(
    'action'     => 'view',
    'controller' => 'post',
    'module'     => 'blog'
));

// Gibt true zurück, weil die Anfrage die gleichen Module, Controller
// und Aktion hat
$page->isActive();

/*
 * Ausgefürte Anfrage:
 * - module:     blog
 * - controller: post
 * - action:     view
 */
$page = new Zend_Navigation_Page_Mvc(array(
    'action'     => 'view',
    'controller' => 'post',
    'module'     => 'blog',
    'params'     => array('id' => null)
));

// Gibt false zurück weil die Seite den id Parameter in der
// Anfrage gesetzt haben muß
$page->isActive(); // gibt false zurück

Example #4 Routen verwenden

Routen können mit MVC Seite verwendet werden. Wenn eine Seite eine Route hat, wird diese Route in getHref() verwendet um die URL für die Seite zu erstellen.

Note:

Beachte, das wenn die route Eigenschaft in einer Seite verwendet wird, man auch die Standard Parameter spezifizieren sollte die diese Route definieren (module, controller, action, usw.), andernfalls ist die isActive() Methode nicht dazu in der Lage zu erkennen ob die Seite aktiv ist oder nicht. Der Grund hierfür ist, das es aktuell keinen Weg gibt die Standardparameter von einem Zend_Controller_Router_Route_Interface Objekt zu erhalten, oder die aktuelle Route von einem Zend_Controller_Router_Interface Objekt.

// Die folgende Route wird den ZF Router hinzugefügt
Zend_Controller_Front::getInstance()->getRouter()->addRoute(
    'article_view', // route name
    new Zend_Controller_Router_Route(
        'a/:id',
        array(
            'module'     => 'news',
            'controller' => 'article',
            'action'     => 'view',
            'id'         => null
        )
    )
);

// Eine Seite wird mit der 'route' Option erstellt
$page = new Zend_Navigation_Page_Mvc(array(
    'label'      => 'A news article',
    'route'      => 'article_view',
    'module'     => 'news',    // wird für isActive() benötigt, siehe oben
    'controller' => 'article', // wird für isActive() benötigt, siehe oben
    'action'     => 'view',    // wird für isActive() benötigt, siehe oben
    'params'     => array('id' => 42)
));

// Gibt /a/42 zurück
$page->getHref();

Zend_Navigation_Page_Uri

Seiten des Typs Zend_Navigation_Page_Uri können verwendet werden um auf Seiten von anderen Domains oder Sites zu verweisen, oder um eigene Logik für die Seite zu implementieren. URI Seiten sind einfach; zusätzlich zu den normalen Seitenoptionen nimmt eine URI Seite nur eine Option - uri. uri wird zurückgegeben wenn $page->getHref() aufgerufen wird, und kann ein String oder NULL sein.

Note:

Zend_Navigation_Page_Uri versucht nicht zu erkennen ob es aktiv ist wenn $page->isActive() aufgerufen wird. Es gibt zurück, was aktuell gesetzt ist. Um also eine URI Seite aktiv zu machen muß man händisch $page->setActive() aufrufen oder active als eine Option der Seite bei der Erstellung spezifizieren.

URI Seiten Optionen
Schlüssel Typ Standard Beschreibung
uri String NULL URI zur Seite. Das kann ein String oder Null sein.

Erstellung eigener Seiten Typen

Wenn Zend_Navigation_Page erweiter wird, besteht normalerweise keine Notwendigkeit den Constructor oder die Methoden setOptions() oder setConfig() zu überladen. Der Constructor der Seite nimmt einen einzelnen Parameter, ein Array oder ein Zend_Config Objekt, welches an setOptions() oder an setConfig() übergeben wird. Diese Methoden rufen dann die set() Methode auf, welche Optionen in native oder eigene Eigenschaften mappt. Wenn die Option internal_id angegeben wird, dann wird zuerst nach einer Methode geschaut die setInternalId() heißt und die Option wird an diese Methode übergeben wenn Sie existiert. Wenn die Methode nicht existiert, wird die Option als eigene Eigenschaft der Seite gesetzt, und ist über $internalId = $page->internal_id; oder $internalId = $page->get('internal_id'); erreichbar.

Example #5 Die einfachste eigene Seite

Das einzige Ding das eine eigene Seite implementieren muß ist die getHref() Methode.

class My_Simple_Page extends Zend_Navigation_Page
{
    public function getHref()
    {
        return 'something-completely-different';
    }
}

Example #6 Eine eigene Seite mit Eigenschaften

Wenn Eigenschaften an eine erweiterte Seite angefügt werden, gibt es keine Notwendigkeit setOptions() oder setConfig() zu Überladen/Modifizieren.

class My_Navigation_Page extends Zend_Navigation_Page
{
    private $_foo;
    private $_fooBar;

    public function setFoo($foo)
    {
        $this->_foo = $foo;
    }

    public function getFoo()
    {
        return $this->_foo;
    }

    public function setFooBar($fooBar)
    {
        $this->_fooBar = $fooBar;
    }

    public function getFooBar()
    {
        return $this->_fooBar;
    }

    public function getHref()
    {
        return $this->foo . '/' . $this->fooBar;
    }
}

// Kann jetzt Erstellt werden mit
$page = new My_Navigation_Page(array(
    'label'   => 'Namen von Eigenschaften werden auf Setter gemappt',
    'foo'     => 'bar',
    'foo_bar' => 'baz'
));

// ...oder
$page = Zend_Navigation_Page::factory(array(
    'type'    => 'My_Navigation_Page',
    'label'   => 'Namen von Eigenschaften werden auf Setter gemappt',
    'foo'     => 'bar',
    'foo_bar' => 'baz'
));

Erstellen von Seiten durch Verwendung der Page Factory

Alle Seiten (also auch eigene Klassen), können durch Verwendung der Page Factory Zend_Navigation_Page::factory() erstellt werden. Die Factory kann ein Array mit Optionen oder ein Zend_Config Objekt annehmen. Jeder Schlüssel im Array/Config entspricht einer Seiten Option, wie im Kapitel Seiten gezeigt. Wenn die Option uri angegeben wird und keine MVC Optionen angegeben werden (action, controller, module, route) wird eine URI Seite erstellt. Wenn eine der MVC Optionen angegeben wird, dann wird eine MVC Seite erstellt.

Wenn type angegeben wird, nimmt die Factory an das der Wert der Name der Klasse ist die erstellt werden soll. Wenn der Wert mvc oder uri ist wird eine MVC/URI Seite erstellt.

Example #7 Erstellen einer MVC Seite durch Verwenden der Page Factory

$page = Zend_Navigation_Page::factory(array(
    'label'  => 'My MVC page',
    'action' => 'index'
));

$page = Zend_Navigation_Page::factory(array(
    'label'      => 'Search blog',
    'action'     => 'index',
    'controller' => 'search',
    'module'     => 'blog'
));

$page = Zend_Navigation_Page::factory(array(
    'label'      => 'Home',
    'action'     => 'index',
    'controller' => 'index',
    'module'     => 'index',
    'route'      => 'home'
));

$page = Zend_Navigation_Page::factory(array(
    'type'   => 'mvc',
    'label'  => 'My MVC page'
));

Example #8 Erstellen einer URI Seite durch Verwendung der Page Factory

$page = Zend_Navigation_Page::factory(array(
    'label' => 'My URI page',
    'uri'   => 'http://www.example.com/'
));

$page = Zend_Navigation_Page::factory(array(
    'label'  => 'Search',
    'uri'    => 'http://www.example.com/search',
    'active' => true
));

$page = Zend_Navigation_Page::factory(array(
    'label' => 'My URI page',
    'uri'   => '#'
));

$page = Zend_Navigation_Page::factory(array(
    'type'   => 'uri',
    'label'  => 'My URI page'
));

Example #9 Erstellung eines eigenen Seiten Typs durch Verwendung der Page Factory

Um einen eigenen Seitentyp zu erstellen mit Hilfe der Verwendung der Factory, muß die Option type verwendet werden um den Klassennamen zu spezifizieren der instanziiert werden muß.

class My_Navigation_Page extends Zend_Navigation_Page
{
    protected $_fooBar = 'ok';

    public function setFooBar($fooBar)
    {
        $this->_fooBar = $fooBar;
    }
}

$page = Zend_Navigation_Page::factory(array(
    'type'    => 'My_Navigation_Page',
    'label'   => 'My custom page',
    'foo_bar' => 'foo bar'
));
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 Controller
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_Db_Table_Definition
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_Dojo build layer support
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_Feed_Reader
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
Migration von vorhergehenden Versionen
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
Migration von vorhergehenden Versionen
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
Einführung
API Übersicht
Usage Scenarios
Tools
Objektorientierter Zugriff auf den LDAP Baum durch Verwendung von Zend_Ldap_Node
Informationen vom LDAP Server erhalten
Serialisieren von LDAP Daten von und zu LDIF
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
Migration von vorhergehenden Versionen
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
Interactive Features
Dokument Informationen und Metadaten
Anwendungsbeispiel für die Zend_Pdf Komponente
Zend_ProgressBar
Zend_ProgressBar
Zend_Queue
Einführung
Beispiel der Verwendung
Framework
Adapter
Anpassen von Zend_Queue
Stomp
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 Instanzen
Zend_Service_Amazon_Ec2: Reservierte Instanzen
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_Amazon_Sqs
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_Test_PHPUnit_Db
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
Architektur
Erstellen von Providern für die Verwendung mit Zend_Tool_Framework
Mitgelieferte System Provider
Extending and Configuring Zend_Tool_Framework
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
Erstellen von Quelldateien
Zusätzliche Features für Übersetzungen
Plurale Schreibweisen für Übersetzungen
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 Dokumentations Standard
Übersicht
Formatierung von Dokumentationsdateien
Empfehlungen
Recommended Project Structure for Zend Framework MVC Applications
Overview
Recommended Project Directory Structure
Module Structure
Rewrite Configuration Guide
Zend Framework Performance Guide
Einführung
Laden von Klassen
Zend_Db Performance
Internationalisierung (I18n) und Lokalisierung (L10n)
Darstellen der View
Urheberrecht Informationen