Previous Next

Zend_Http_Cookie und Zend_Http_CookieJar

Einführung

Wie erwartet ist Zend_Http_Cookie eine Klasse, die einen HTTP-Cookie darstellt. Sie stellt Methoden zum Verarbeiten von HTTP-Antwort-Strings, Sammeln von Cookies und dem einfachen Zugriff auf deren Eigenschaften zur Verfügung. So ist es auch möglich verschiedene Zustände eines Cookies zu überprüfen, z.B. den Anfrage-URL, die Ablaufzeit, das Vorliegen einer sicheren Verbindung, etc.

Zend_Http_CookieJar ist ein Objekt, das normalerweise von der Klasse Zend_Http_Client genutzt wird und einen Satz von Zend_Http_Cookie Objekten beinhaltet. Wenn die Klassen miteinander verbunden sind, werden alle ein- und ausgehenden Cookies der HTTP-Anfragen und -Antworten im CookieJar Objekt gespeichert. Bei einer neuen Anfrage seitens des Clients wird nach allen Cookies, die auf diese Anfrage zutreffen, gesucht. Diese werden automatisch zum Anfrage-Header hinzugefügt, was besonders nützlich ist, wenn man eine Benutzersession über aufeinanderfolgende HTTP-Anfragen beibehalten muss; die Session-ID wird automatisch gesendet, wenn es notwendig ist. Ferner ist es möglich, Zend_Http_CookieJar Objekte zu serialisieren und, wenn nötig, in $_SESSION zu speichern.

Instanzieren von Zend_Http_Cookie Objekten

Es gibt zwei Möglichkeiten ein Cookie Objekt zu erstellen:

  • Mithilfe des Konstruktors und der folgenden Syntax: new Zend_Http_Cookie(string $name, string $value, string $domain, [int $expires, [string $path, [boolean $secure]]]);

    • $name: Name des Cookies (notwendig)

    • $value: Inhalt des Cookies (notwendig)

    • $domain: Die Domain des Cookies (z.B. '.example.com') (notwendig)

    • $expires: Ablaufzeit des Cookies als UNIX Zeitstempel (optional, standardmäßig null). Ein Nichtsetzen führt zu einer Behandlung als 'Session-Cookie', das keine Ablaufzeit enthält.

    • $path: Pfad des Cookies, z.B. '/foo/bar/' (optional, standardmäßig '/')

    • $secure: Boolean, ob der Cookie nur über sichere Verbindungen (HTTPS) gesendet werden darf (optional, standardmäßig boolean FALSE)

  • Durch das Aufrufen der statischen fromString()-Methode mit einem Cookie-String, wie er unter 'Set-Cookie' in einer HTTP-Antwort und 'Cookie' in einer -Anfrage zu finden ist. In diesem Fall muss der Cookie-Inhalt bereits kodiert sein. Falls der Cookie-String keinen 'domain'-Teil enthält, muss man selbst einen Referenz-URI angeben, aus dem die Domain und der Pfad des Cookies bestimmt wird.

Example #1 Instanzieren eines Zend_Http_Cookie-Objekts

// Zuerst nutzen wir den Konstruktor. Der Cookie wird in zwei Stunden ablaufen
$cookie = new Zend_Http_Cookie('foo',
                               'bar',
                               '.example.com',
                               time() + 7200,
                               '/path');

// Man kann auch den HTTP-Antwort 'Set-Cookie'-header dafür nutzen.
// Dieser Cookie ist ähnlich zum vorangegangenen, allerdings wird
// er nicht ablaufen und nur über sichere Verbindungen gesendet.
$cookie = Zend_Http_Cookie::fromString('foo=bar; domain=.example.com; ' .
                                       'path=/path; secure');

// Wenn die Domain des Cookies nicht gesetzt ist, muss man ihn selbst angeben.
$cookie = Zend_Http_Cookie::fromString('foo=bar; secure;',
                                       'http://www.example.com/path');

Note:

Beim Instanzieren eines Cookie Objekts mit der Zend_Http_Cookie::fromString()-Methode wird erwartet, dass der Cookie-Inhalt URL-kodiert ist, wie es bei Cookie-Strings sein sollte. Allerdings wird angenommen, dass der Inhalt bei Verwendung des Konstruktors in seiner eigentlichen Form, d.h. nicht URL-kodiert, übergeben wird.

Ein Cookie Objekt kann durch die magische __toString()-Methode zurück in einen String umgewandelt werden. Diese Methode erstellt einen HTTP-Anfrage "Cookie"-Header String, der den Namen sowie den Inhalt des Cookies enthält und durch ein Semikolon (';') abgeschlossen ist. Der Inhalt wird URL-kodiert, wie es für einen Cookie-Header vorgeschrieben ist:

Example #2 Transformation eines Zend_Http_Cookie-Objekts zu einem String

// Erstellt einen neuen Cookie
$cookie = new Zend_Http_Cookie('foo',
                               'two words',
                               '.example.com',
                               time() + 7200,
                               '/path');

// Gibt 'foo=two+words;' aus
echo $cookie->__toString();

// Bezweckt dasselbe
echo (string) $cookie;

// Ab PHP 5.2 funktioniert auch diese Variante
echo $cookie;

Zend_Http_Cookie getter-Methoden

Sobald ein Zend_Http_Cookie instanziert wurde, stellt es diverse getter-Methoden zur Verfügung, die es einem ermöglichen, auf die verschiedenen Eigenschaften des HTTP-Cookies zuzugreifen:

  • string getName(): Gibt den Namen des Cookies zurück

  • string getValue(): Gibt den wirklichen, also nicht kodierten, Inhalt zurück

  • string getDomain(): Gibt die Domain des Cookies zurück

  • string getPath(): Gibt den Pfad des Cookies zurück; dessen Standardwert ist '/'

  • int getExpiryTime(): Gibt die Ablaufzeit des Cookies als UNIX-Timestamp zurück. Falls der Cookie keine Ablaufzeit besitzt, wird NULL zurückgegeben.

Zusätzlich gibt es einige boolesche tester-Methoden:

  • boolean isSecure(): Gibt zurück, ob der Cookie nur über sichere Verbindungen gesendet werden kann. Wenn true zurückgegeben wird, wird der Cookie also nur über HTTPS versendet.

  • boolean isExpired(int $time = null): Überprüft, ob der Cookie bereits abgelaufen ist. Wenn der Cookie keine Ablaufzeit besitzt, wird diese Methode immer true zurückgegeben. Wenn $time übergeben wurde, wird der aktuelle Zeitstempel überschrieben und der übergebene Zeitstempel zur Überprüfung genutzt.

  • boolean isSessionCookie(): Überprüft, ob der Cookie ein "Session-Cookie" ist, der keine Ablaufzeit besitzt und erst abläuft, wenn die Session beendet wird.

Example #3 Nutzen der getter-Methoden von Zend_Http_Cookie

// Zuerst wird der Cookie erstellt
$cookie = Zend_Http_Cookie::fromString('foo=two+words; ' +
                                       'domain=.example.com; ' +
                                       'path=/somedir; ' +
                                       'secure; ' +
                                       'expires=Wednesday, 28-Feb-05 20:41:22 UTC');

echo $cookie->getName();   // Gibt 'foo' aus
echo $cookie->getValue();  // Gibt 'two words' aus
echo $cookie->getDomain(); // Gibt '.example.com' aus
echo $cookie->getPath();   // Gibt '/' aus

echo date('Y-m-d', $cookie->getExpiryTime());
// Gibt '2005-02-28' aus

echo ($cookie->isExpired() ? 'Ja' : 'Nein');
// Gibt 'Ja' aus

echo ($cookie->isExpired(strtotime('2005-01-01') ? 'Ja' : 'Nein');
// Gibt 'Nein' aus

echo ($cookie->isSessionCookie() ? 'Ja' : 'Nein');
// Gibt 'Nein' aus

Zend_Http_Cookie: Überprüfen von Szenarien

Die einzige wirkliche Logik in einem Zend_Http_Cookie-Objekt befindet sich in der match()-Methode. Sie wird genutzt um zu Überprüfen, ob ein Cookie auf eine HTTP-Anfrage zutrifft, um zu entscheiden, ob der Cookie in der Anfrage gesendet werden soll. Die Methode hat folgende Syntax und Parameter: boolean Zend_Http_Cookie->match(mixed $uri, [boolean $matchSessionCookies, [int $now]]);

  • mixed $uri: Ein zu überprüfendes Zend_Uri_Http-Objekt mit einer Domain und einem Pfad. Wahlweise kann stattdessen jedoch auch ein String, der einen validen HTTP-URL darstellt, übergeben werden. Der Cookie ist zutreffend, wenn das URL-Schema (HTTP oder HTTPS), die Domain sowie der Pfad passen.

  • boolean $matchSessionCookies: Gibt an, ob Session-Cookies zutreffen sollen. Standardmäßig ist dieser Parameter true. Wenn false stattdessen übergeben wird, werden Cookies ohne Ablaufzeit nie zutreffen.

  • int $now: Ablaufzeit (in Form eines UNIX-Zeitstempels) auf welche der Cookie überprüft wird. Wenn sie nicht angegeben wird, wird die gegenwärtige Zeit genutzt.

Example #4 Zutreffen von Cookies

// Erstellen eines Cookie Objekts - zuerst ein sicherer Cookie ohne Ablaufzeit
$cookie = Zend_Http_Cookie::fromString('foo=two+words; ' +
                                       'domain=.example.com; ' +
                                       'path=/somedir; ' +
                                       'secure;');

$cookie->match('https://www.example.com/somedir/foo.php');
// Gibt true zurück

$cookie->match('http://www.example.com/somedir/foo.php');
// Gibt false zurück, da die Verbindung nicht sicher ist

$cookie->match('https://otherexample.com/somedir/foo.php');
// Gibt false zurück, da die Domain falsch ist

$cookie->match('https://example.com/foo.php');
// Gibt false zurück, da der Pfad falsch ist

$cookie->match('https://www.example.com/somedir/foo.php', false);
// Gibt false zurück, da keine Session-Cookies akzeptiert werden

$cookie->match('https://sub.domain.example.com/somedir/otherdir/foo.php');
// Gibt true zurück

// Erstellen eines anderen Cookie-Objekts - diesmal unsicher und
// einer Ablaufzeit die zwei Stunden in der Zukunft liegt
$cookie = Zend_Http_Cookie::fromString('foo=two+words; ' +
                                       'domain=www.example.com; ' +
                                       'expires='
                                       . date(DATE_COOKIE, time() + 7200));

$cookie->match('http://www.example.com/');
// Gibt true zurück

$cookie->match('https://www.example.com/');
// Gibt true zurück, da unsichere Cookies genauso gut über sichere
// Verbindungen übertragen werden können

$cookie->match('http://subdomain.example.com/');
// Gibt false zurück, da die Domain unzutreffend ist

$cookie->match('http://www.example.com/', true, time() + (3 * 3600));
// Gibt false zurück, da die Ablaufzeit drei Stunden in der Zukunft
// liegt

Die Zend_Http_CookieJar Klasse: Instanzierung

In den meisten Fällen ist es nicht notwendig, ein Zend_Http_CookieJar Objekt direkt zu erstellen. Wenn man ein neues CookieJar zum Zend_Http_Client Objekts hinzufügen will, muss man lediglich die Methode Zend_Http_Client->setCookieJar( aufrufen, die ein neues und leeres CookieJar zum Client hinzufügt. Später kann man dieses CookieJar via Zend_Http_Client->getCookieJar() holen.

Wenn dennoch ein CookieJar Objekt manuell erstellen werden soll, kann man dies direkt durch "new Zend_Http_CookieJar()" erreichen - der Konstruktor benötigt keine Parameter. Ein anderer Weg zum Instanzieren eines CookieJar Objekts ist es, die statische Methode Zend_Http_CookieJar::fromResponse() zu nutzen. Diese Methode benötigt zwei Parameter: ein Zend_Http_Response Objekt und einen Referenz_URI, entweder in Form eines Strings oder eines Zend_Uri_Http Objekts. Es wird ein Zend_Http_CookieJar Objekt zurückgegeben, das bereits die Cookies, die durch die HTTP-Antwort gesetzt wurden, enthält. Der Referenz-URI wird genutzt um die Domain und den Pfad des Cookies zu setzen, sofern sie nicht in den Set-Cookie-Headern definiert wurden.

Hinzufügen von Cookies zu einem Zend_Http_CookieJar Objekt

Normalerweise werden die, durch HTTP-Antworten gesetzen, Cookies vom Zend_Http_Client Objekt automatisch zu dessen CookieJar hinzugefügt. Wenn man es wünscht, kann man Cookies auch manuell zum CookieJar hinzufügen, was durch Nutzen zweier Methoden erreicht werden kann:

  • Zend_Http_CookieJar->addCookie($cookie[, $ref_uri]): Hinzufügen eines einzelnen Cookies zum CookieJar. $cookie kann entweder ein Zend_Http_Cookie-Objekt oder ein String, der automatisch zu einem Cookie Objekt transformiert wird, sein. Wenn ein String übergeben wird, sollte man jedoch zusätzlich immer $ref_uri übergeben, da dieser einen Referenz-URI darstellt - in Form eines Strings oder eines Zend_Uri_Http Objekts - dessen Werte als Standard für die Domain und den Pfad des Cookies genutzt werden.

  • Zend_Http_CookieJar->addCookiesFromResponse($response, $ref_uri): Fügt alle Cookies zum CookieJar hinzu, die in einer einzelnen HTTP-Antwort gesetzt wurden. Es wird erwartet, dass $response ein Zend_Http_Response Objekt mit Set-Cookie-Headern ist. $ref_uri ist ein Anfrage-URI in Form eines Strings oder eines Zend_Uri_Http-Objekts dessen Inhalt die Standarddomain und den -pfad des Cookies bestimmt.

Abrufen der Cookies von einem Zend_Http_CookieJar-Objekts

Wie beim Hinzufügen von Cookies ist es normalerweise nicht notwendig, die Cookies manuell von einem CookieJar Objekt zu holen. Das Zend_Http_Client Objekt holt automatisch alle benötigten Cookies für eine HTTP-Anfrage. Allerdings gibt es drei Methoden die Cookies aus einem CookieJar zu holen: getCookie(), getAllCookies(), and getMatchingCookies().

Es ist wichtig anzumerken, dass jede dieser Methoden einen speziellen Parameter verlangt, der den Rückgabetyp der Methode festlegt. Dieser Parameter kann drei verschiedene Werte annehmen:

  • Zend_Http_CookieJar::COOKIE_OBJECT: Gibt ein Zend_Http_Cookie Objekt zurück. Wenn diese Methode mehr als einen Cookie zurückgeben sollte, wird stattdessen ein Array aus Objekten zurückgegeben.

  • Zend_Http_CookieJar::COOKIE_STRING_ARRAY: Gibt Cookies als Strings - im Format "foo=bar" - zurück, welche passend für das Senden im "Cookie"-Header einer HTTP-Anfrage sind. Wenn mehr als ein Cookie zurückgegeben werden sollte, wird stattdessen ein Array solcher Strings zurückgegeben.

  • Zend_Http_CookieJar::COOKIE_STRING_CONCAT: Ähnlich zu COOKIE_STRING_ARRAY; allerdings gibt diese Methode, falls mehr als ein Cookie zurückgegeben wird, einen einzelnen, langen String zurück, der die Cookies anhand eines Semikolons (;) trennt. Dieses Prozedere ist besonders hilfreich, wenn man alle zutreffenden Cookies in einem einzelnen "Cookie"-Header einer HTTP-Anfrage zurückgeben will.

Die Struktur der unterschiedlichen Cookie-Abrufmethoden wird unterhalb beschrieben:

  • Zend_Http_CookieJar->getCookie($uri, $cookie_name[, $ret_as]): Gibt einen einzelnen Cookie von dem CookieJar zurück, dessen URI (Domain und Pfad) und Name zu den Parametern passen. $uri ist entweder ein String oder ein Zend_Http_Uri Objekt, die den URI darstellen. $cookie_name ist ein String zum Identifizieren des Cookie-Namens. $ret_as ist ein optionaler Parameter, der angibt, von welchem Typ der zurückgegebene Wert ist. Der Standardwert ist COOKIE_OBJECT.

  • Zend_Http_CookieJar->getAllCookies($ret_as): Holt alle Cookies aus dem CookieJar. $ret_as gibt den Rückgabetyp - wie oben bereits beschrieben - an. Wenn er nicht angegeben wird, nimmt er COOKIE_OBJECT an.

  • Zend_Http_CookieJar->getMatchingCookies($uri[, $matchSessionCookies[, $ret_as[, $now]]]): Gibt alle Cookies vom CookieJar zurück, die mit der Ablaufzeit und dem URI übereinstimmen.

    • $uri ist entweder ein Zend_Uri_Http Objekt oder ein String, der den Verbindungstyp (sicher oder unsicher), die Domain und den Pfad angibt. Nach diesen Informationen wird im CookieJar gesucht.

    • $matchSessionCookies ist ein boolescher Ausdruck, der festlegt, ob nach Session-Cookies gesucht werden soll. Session-Cookies sind Cookies, die keine Ablaufzeit enthalten. Standardmäßig ist dieser Wert true.

    • $ret_as gibt den Rückgabetyp - wie oben beschrieben - an. Wenn keiner angegeben wird, wird COOKIE_OBJECT angenommen.

    • $now ist ein Integer der einen UNIX-Zeitstempel darstellt. Cookies, die vor der angegeben Zeit ablaufen, werden nicht zurückgegeben. Wenn dieser Parameter nicht angegeben wird, wird stattdessen die aktuelle Zeit gewählt.

    Mehr über das Zutreffen von Cookies gibt es hier: Zend_Http_Cookie: Überprüfen von Szenarien.

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_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_Config
Einleitung
Theory of Operation
Zend_Config_Ini
Zend_Config_Xml
Zend_Config_Writer
Zend_Config_Writer
Zend_Console_Getopt
Einführung in Getopt
Definieren von Getopt Regeln
Holen von Optionen und Argumenten
Konfigurieren von Zend_Console_Getopt
Zend_Controller
Zend_Controller Schnellstart
Zend_Controller Grundlagen
Der Front Controller
Das Request Objekt
Der Standard Router
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
Dojo Form Elemente und Dekoratore
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 Form Dekoratore die mit dem Zend Framework ausgeliefert werden
Internationalisierung von Zend_Form
Fortgeschrittene Verwendung von Zend_Form
Zend_Gdata
Einführung zu Gdata
Authentifizierung mit AuthSub
Die Buchsuche Daten API verwenden
Authentifizieren mit ClientLogin
Google Kalender verwenden
Verwenden der Google Dokumente Listen Daten API
Using 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
Zend_Http_Client - Einführung
Zend_Http_Client - Fortgeschrittende Nutzung
Zend_Http_Client - Verbindungsadapter
Zend_Http_Cookie und Zend_Http_CookieJar
Zend_Http_Response
Zend_InfoCard
Einführung
Zend_Json
Einführung
Grundlegende Verwendung
JSON Objects
XML zu JSON Konvertierung
Zend_Json_Server - JSON-RPC server
Zend_Layout
Einführung
Zend_Layout Schnellstart
Zend_Layout Konfigurations Optionen
Erweiterte Verwendung von Zend_Layout
Zend_Ldap
Einleitung
Zend_Loader
Dynamisches Laden von Dateien und Klassen
Plugins laden
Zend_Locale
Einführung
Zend_Locale verwenden
Normalisierung und Lokalisierung
Arbeiten mit Daten und Zeiten
Unterstützte 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_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 von PDF Dokumenten speichern
Dokument Seiten
Zeichnen
Dokument Informationen und Metadaten
Anwendungsbeispiel für die Zend_Pdf Komponente
Zend_ProgressBar
Zend_ProgressBar
Zend_Registry
Die Registry verwenden
Zend_Rest
Einführung
Zend_Rest_Client
Zend_Rest_Server
Zend_Search_Lucene
Überblick
Indexerstellung
Einen Index durchsuchen
Abfragesprache
Abfrage Erzeugungs API
Zeichensätze
Erweiterbarkeit
Zusammenarbeit Mit Java Lucene
Erweitert
Die besten Anwendungen
Zend_Server
Einführung
Zend_Server_Reflection
Zend_Service
Einführung
Zend_Service_Akismet
Zend_Service_Amazon
Zend_Service_Audioscrobbler
Zend_Service_Delicious
Zend_Service_Flickr
Zend_Service_Nirvanix
Zend_Service_ReCaptcha
Zend_Service_Simpy
Einführung
Zend_Service_StrikeIron
Zend_Service_StrikeIron: Mitgelieferte Services
Zend_Service_StrikeIron: Erweiterte Verwendung
Zend_Service_Technorati
Zend_Service_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_Test
Einführung
Zend_Test_PHPUnit
Zend_Text
Zend_Text_Figlet
Zend_Text_Table
Zend_TimeSync
Einführung
Arbeiten mit Zend_TimeSync
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
Zend_Version
Auslesen der Version des Zend Frameworks
Zend_View
Einführung
Controller Skripte
View Scripte
View Helfer
Zend_View_Abstract
Zend_Wildfire
Zend_Wildfire
Zend_XmlRpc
Einführung
Zend_XmlRpc_Client
Zend_XmlRpc_Server
Zend Framework Voraussetzungen
PHP Version
PHP Erweiterungen
Zend Framework Komponenten
Zend Framework Abhängigkeiten
Zend Framework Coding Standard für PHP
Übersicht
PHP Dateiformatierung
Namens Konventionen
Code Stil
Zend Framework Performance Guide
Einführung
Laden von Klassen
Internationalisierung (I18n) und Lokalisierung (L10n)
Darstellen der View
Urheberrecht Informationen