Previous Next

Zend_Db_Table_Row

Einführung

Zend_Db_Table_Row ist eine Klasse, die eine einzelne Zeile eines Zend_Db_Table-Objekts enthält. Wenn eine Abfrage über eine Table-Klasse gestartet wird, wird das Ergebnis als ein Satz von Zend_Db_Table_Row-Objekten zurückgegeben. Dieses Objekt kann auch benutzt werden, um neue Zeilen zu erstellen und sie in die Datenbank einzutragen.

Zend_Db_Table_Row ist eine Implementierung des » Row Data Gateway -Entwurfsmusters.

Eine Zeile lesen

Zend_Db_Table_Abstract enthält die Methoden find() und fetchAll(), die beide ein Zend_Db_Table_Rowset Objekt zurückgeben, und die Methode fetchRow(), die ein Objekt vom Typ Zend_Db_Table_Row zurückgibt.

Example #1 Beispiel des Lesen einer Zeile

$bugs = new Bugs();
$row = $bugs->fetchRow($bugs->select()->where('bug_id = ?', 1));

Ein Zend_Db_Table_Rowset Objekt enthält einen Satz von Zend_Db_Table_Row Objekten. Siehe Zend_Db_Table_Rowset.

Example #2 Beispiel des Lesens einer Zeile aus einem Rowset

$bugs = new Bugs();
$rowset = $bugs->fetchAll($bugs->select()->where('bug_status = ?', 1));
$row = $rowset->current();

Spaltenwerte aus einer Zeile lesen

Zend_Db_Table_Row_Abstract bietet Zugriffsmethoden an, damit die Spalten einer Zeile als Objekteigenschaften angesprochen werden können.

Example #3 Beispiel für das Lesens einer Spalte aus einer Zeile

$bugs = new Bugs();
$row = $bugs->fetchRow($bugs->select()->where('bug_id = ?', 1));

// Wert der Spalte bug_description ausgeben
echo $row->bug_description;

Note:

Frühere Versionen von Zend_Db_Table_Row haben diese Spalten-Zugriffsnamen mithilfe einer Zeichenketten-Transformation namens Inflection auf Spaltennamen umgeleitet.

Die Aktuelle Version von Zend_Db_Table_Row implementiert diese Funktion jedoch nicht mehr. Der Spalten-Zugriffsname muss genau so geschrieben sein, wie die Spalte in der Datenbank heißt.

Zeilendaten als ein Array lesen

Die Tabellenzeile kann mithilfe der toArray() Methode des Zeilenobjekts auch als Array gelesen werden. Diese gibt ein assoziatives Array zurück, mit Spaltennamen als Index und ihren Inhalten als Werten.

Example #4 Beispiel der Benutzung der toArray()-Methode

$bugs = new Bugs();
$row = $bugs->fetchRow($bugs->select()->where('bug_id = ?', 1));

// Das assoziative Array aus dem Zeilenobjekt holen
$rowArray = $row->toArray();

// Jetzt einfach wie ein normales Array verwenden
foreach ($rowArray as $column => $value) {
    echo "Spalte: $column\n";
    echo "Wert:  $value\n";
}

Das Array, das von toArray()zurückgegeben wird, ist nicht update fähig. Die Werte des Arrays können wie in jedem Array modifiziert werden, aber Änderungen an diesem Array werden nicht direkt in der Datenbank gespeichert.

Daten aus verwandten Tabellen lesen

Die Klasse Zend_Db_Table_Row_Abstract bietet Methoden, um Zeilen und Zeilensätze aus verwandten Tabellen auszulesen. Siehe Zend_Db_Table Relationships für weitere Informationen über Tabellenbeziehungen.

Zeilen in die Datenbank schreiben

Spaltenwerte einer Zeile verändern

Individuelle Werte von Spalten können mit Hilfe der Zugriffsvariablen gesetzt werden, so ähnlich wie Spalten in obiegen Beispiel als Objekteigenschaften gelesen werden.

Das Ändern eines Werts über eine Zugriffsvariable ändert den Spaltenwert des Zeilenobjekts in der Anwendung, aber noch wird die Änderung nicht in die Datenbank übernommen. Das wird mit der Methode save() erledigt.

Example #5 Beispiel der Änderung eines Spaltenwertes einer Zeile

$bugs = new Bugs();
$row = $bugs->fetchRow($bugs->select()->where('bug_id = ?', 1));

// Wert einer oder mehrerer Spalten ändern
$row->bug_status = 'FIXED';

// Die Datenbankzeile mit den neuen Werten aktualisieren
$row->save();

Eine neue Zeile einfügen

Eine neue Zeile kann in einer Tabelle mit der createRow() Methode der Tabellenklasse angelegt werden. Auf Felder dieser Zeile können mit dem Objektorientierten Interface zugegriffen werden, aber die Zeile wird nicht in der Datenbank geschrieben, bis die save() Methode aufgerufen wird.

Example #6 Beispiel der Erstellung einer neuen Zeile für eine Tabelle

$bugs = new Bugs();
$newRow = $bugs->createRow();

// Spaltenwerte setzen, wie es in der Anwendung üblich ist
$newRow->bug_description = '...Beschreibung...';
$newRow->bug_status = 'NEW';

// Neue Zeile in die Datenbank einfügen
$newRow->save();

Das optionale Argument der createRow() Methode ist ein assoziatives Array, mit dem Felder der neuen Zeile eingefügt werden können.

Example #7 Beispiel der Bekanntgabe einer neuen Zeile für eine Tabelle

$data = array(
    'bug_description' => '...Beschreibung...',
    'bug_status'      => 'NEW'
);

$bugs = new Bugs();
$newRow = $bugs->createRow($data);

// Neue Zeile in die Datenbank einfugen
$newRow->save();

Note:

Die Methode createRow() wurde in früheren Versionen von Zend_Db_Table fetchNew() genannt. Es wird empfohlen, den neuen Methodennamen zu benutzen, obwohl der alte Name weiterhin funktioniert, um Abwärtskompatibilität zu gewährleisten.

Werte mehrerer Spalten ändern

Zend_Db_Table_Row_Abstract beinhaltet eine Methode namens setFromArray(), die es ermöglicht, mehrere Spalten einer Zeile mithilfe eines assoziativen Arrays mit Spaltenname/Wert-Paaren gleichzeitig zu setzen. Diese Methode ist nützlich, um Werte für neue Zeilen oder Zeilen, die aktualisiert werden müssen, zu setzen.

Example #8 Beispiel der Verwendung von setFromArray() um neue Werte in einer Tabelle zu setzen

$bugs = new Bugs();
$newRow = $bugs->createRow();

// Daten in ein assoziatives Array schreiben
$data = array(
    'bug_description' => '...Beschreibung...',
    'bug_status'      => 'NEW'
);

// Alle Spaltenwerte auf einmal setzen
$newRow->setFromArray($data);

// Neue Zeile in die Datenbank schreiben
$newRow->save();

Eine Zeile löschen

Das Zeilenobjekt hat eine Methode namens delete(). Diese löscht Zeilen in der Datenbank, deren Primärschlüssel dem im Zeilenobjekt entspricht.

Example #9 Beispiel für das Löschen einer Zeile

$bugs = new Bugs();
$row = $bugs->fetchRow('bug_id = 1');

// Zeile löschen
$row->delete();

save() muss nicht aufgerufen werden, um den Löschvorgang abzuschließen; er wird sofort auf der Datenbank ausgeführt.

Serialisieren und Deserialisieren von Zeilen

Es ist oft nützlich, Inhalte einer Datenbankzeile für spätere Benutzung zu speichern. Die Operation, die ein Objekt in eine Form bringt, die einfach in einem Offline Speicher abgelegt werden kann (zum Beispiel eine Textdatei), nennt man Serialisierung. Zend_Db_Table_Row_Abstract Objekte sind serialisierbar.

Eine Zeile Serialisieren

Es kann einfach PHPs serialize() Funktion verwendet werden, um einen String zu erstellen, der einen Byte-Stream enthält welcher das Zeilen-Objekt repräsentiert.

Example #10 Beispiel: Eine Zeile serialisieren.

$bugs = new Bugs();
$row = $bugs->fetchRow('bug_id = 1');

// Objekt serialisieren
$serializedRow = serialize($row);

// Jetzt kann $serializedRow z.B. in einer Datei gespeichert werden

Zeilen deserialisieren

PHPs unserialize() Funktion stellt ein Objekt aus einem Byte-Stream wieder her. Die Funktion gibt das Original Objekt zurück.

Bitte beachten: Das zurückgegebene Zeilen-Objekt ist nicht mit der Datenbank verbunden. Das Zeilenobjekt und seine Eigenschaften können gelesen werden, aber es können keine Zeilenwerte verändert oder andere Operationen ausgeführt werden, die eine Datenbankverbindung benötigen.

Example #11 Beispiel für das deserialisieren eines serialisiertes Zeilenobjektes

$rowClone = unserialize($serializedRow);

// Jetzt können die Objekteigenschaften genutzt werden
// allerdings nur lesend.
echo $rowClone->bug_description;

Note: Warum werden Zeilenobjekte unverbunden deserialisiert?

Ein serialisiertes Objekt ist eine Zeichenkette, die lesbar für jeden ist, dem sie vorliegt. Es könnte ein Sicherheitsrisiko sein, Parameter wie Datenbank-Loginname und -Passwort in simplem, unverschlüsseltem Text abzulegen. Es ist nicht wünschenswert, solche Daten in einer Textdatei abzulegen, die nicht geschützt ist, oder sie in einer E-Mail oder einem anderen Medium zu versenden, das leicht von potentiellen Angreifern lesbar ist. Der Leser des serialisierten Objekts sollte es nicht benutzen können, um Zugriff zur Datenbank zu erhalten, ohne richtige Logindaten zu kennen.

Ein Zeilenobjekt als Live-Daten reaktivieren

Ein nicht verbundenes Zeilenobjekt kann mithilfe der Methode setTable() reaktiviert werden. Das Argument dieser Methode ist ein gültiges Zend_Db_Table_Abstract-Objekt, das vom Benutzer erstellt wird. Für das Erstellen eines Tabellenobjekts wird eine aktive Datenbankverbindung benötigt, also wird, indem die Tabelle wieder mit dem Zeilenobjekt verknüpft wird, auch der Datenbankzugriff wiederhergestellt. Ab diesem Zeitpunkt können Werte im Zeilenobjekt wieder verändert und in der Datenbank gespeichert werden.

Example #12 Ein Zeilenobjekt reaktivieren

$rowClone = unserialize($serializedRow);

$bugs = new Bugs();

// Das Zeilenobjekt wieder mit einer Tabelle
// und damit mit einer aktiven Datenbankverbindung verknüpfen
$rowClone->setTable($bugs);

// Jetzt können wieder Werte geändert und danach gespeichert werden
$rowClone->bug_status = 'FIXED';
$rowClone->save();

Die Zeilenklasse erweitern

Zend_Db_Table_Row ist die standardmäßige Implementierung der abstrakten Klasse Zend_Db_Table_Row_Abstract. Selbstverständlich können auch eigene Klassen geschrieben werden, die Zend_Db_Table_Row_Abstract erweitern. Um die neue Zeilenklasse zum Speichern von Abfrageergebnissen zu benutzen, muss der Name dieser selbstgeschriebene Zeilenklasse entweder in der geschützten $_rowClass-Variable einer Tabellen-KLasse oder als Array-Argument des Konstruktors eines Tabellenobjekts angegeben werden.

Example #13 Eine eigene Zeilenklasse angeben

class MyRow extends Zend_Db_Table_Row_Abstract
{
    // ...Anpassungen
}

// Eine eigene Zeilenklasse angeben, die
// in allen Instanzen einer Tabellenklasse verwendet wird.
class Products extends Zend_Db_Table_Abstract
{
    protected $_name = 'products';
    protected $_rowClass = 'MyRow';
}

// Oder die eigene Zeilenklasse nur für eine bestimmte
// Instanz der Tabellenklasse angeben.
$bugs = new Bugs(array('rowClass' => 'MyRow'));

Initialisierung einer Zeile

Wenn Anwendungs-spezifische Logik benötigt wird die initialisiert werden soll wenn eine Zeile erstellt wird, kann entschieden werden die Aufgaben in die init() Methode zu verschieben, welche aufgerufen wird nachdem alle Metadaten der Zeile bearbeitet wurden. Das wird empfohlen statt der __construct Methode wenn die Metadaten nicht programtechnisch verändert werden müssen.

Example #14 Beispiel der Verwendung der init() Methode

class MyApplicationRow extends Zend_Db_Table_Row_Abstract
{
    protected $_role;

    public function init()
    {
        $this->_role = new MyRoleClass();
    }
}

Eigene Logik für Einfügen, Aktualisieren und Löschen in Zend_Db_Table_Row definieren

Die Zeilenklasse ruft geschützte Methoden namens _insert(), _update(), und _delete() auf, bevor die entsprechenden Operationen in der INSERT, UPDATE, und DELETE ausgeführt werden. In diesen Methoden kann in den eigenen Zeilenklassen auch eigene Logik implementiert werden.

Wenn es nötig ist, eigene Logik in einer bestimmten Tabelle auszuführen, und diese Logik bei jeder Operation ausgeführt werden muss, die auf die Tabelle angewendet wird, hat es vielleicht mehr Sinn, diesen eigenen Code in den insert(), update() und delete()-Methoden der eigenen Tabellenklasse zu implementieren. Trotzdem kann es manchmal nötig sein, eigene Logik in der Zeilenklasse einzubauen.

Unten sind beispielhaft Fälle aufgeführt, in denen es Sinn haben könnte, eigene Logik in der Zeilenklasse anstatt der Tabellenklasse einzubauen:

Example #15 Beispiel einer eigenen Logik in einer Zeilenklasse

Es ist möglich, dass es nicht in allen Fällen nötig ist, diese Logik anzuwenden. Eigene Logik kann auf Abruf angeboten werden, indem sie in einer Zeilenklasse eingebaut und je nach Bedarf ein Tabellenobjekt mit dieser Zeilenklasse erstellt wird. In anderen Fällen benutzt das Tabellenobjekt die Standard Zeilenklasse.

Operationen in einer Tabelle müssen geloggt werden, aber nur, wenn die Anwendung entsprechend konfiguriert ist.

class MyLoggingRow extends Zend_Db_Table_Row_Abstract
{
    protected function _insert()
    {
        $log = Zend_Registry::get('database_log');
        $log->info(Zend_Debug::dump($this->_data,
                                    "INSERT: $this->_tableClass",
                                    false)
                  );
    }
}

// $loggingEnabled sei ein Beispiel
// für eine Konfigurationseinstellung
if ($loggingEnabled) {
    $bugs = new Bugs(array('rowClass' => 'MyLoggingRow'));
} else {
    $bugs = new Bugs();
}

Example #16 Zeilenklasse, die Insert Daten für verschiedene Tabellen loggt.

Es könnte sein, dass eigene Anwendungslogik für mehrere Tabellen angewendet werden muss. Anstatt diese eigene Logik in jeder Tabellenklasse zu implementieren, kann der Code für solche Zwecke auch in einer Zeilenklasse eingebaut und diese Zeilenklasse für jede dieser Tabellenklassen benutzt werden.

In diesem Beispiel ist der Logging-Code für alle Tabellenklassen identisch.

class MyLoggingRow extends Zend_Db_Table_Row_Abstract
{
    protected function _insert()
    {
        $log = Zend_Registry::get('database_log');
        $log->info(Zend_Debug::dump($this->_data,
                                    "INSERT: $this->_tableClass",
                                    false)
                  );
    }
}

class Bugs extends Zend_Db_Table_Abstract
{
    protected $_name = 'bugs';
    protected $_rowClass = 'MyLoggingRow';
}

class Products extends Zend_Db_Table_Abstract
{
    protected $_name = 'products';
    protected $_rowClass = 'MyLoggingRow';
}

Inflection in Zend_Db_Table_Row einbauen

Manche Personen ziehen es vor, dass der Klassenname der Tabelle dem Tabellennamen in der Datenbank direkt entspricht, indem eine String Transformation durchgeführt wird, die auch Inflection genannt wird.

Zend_Db Klassen implementieren Inflection standardmäßig nicht. Inflection (Beugung) in Zend_Db_Table definieren gibt eine Erklärung für diese Richtlinie.

Wenn Inflection genutzt werden soll, dann muss die Manipulation selbst implementiert werden, indem die Methode _transformColumn() in einer eigenen Zeilenklasse überschrieben wird und Objekte dieser Klasse für Abfragen an die Datenbank genutzt werden.

Example #17 Inflection-Methode definieren

Das definieren einer Methode für Inflection erlaubt es, inflection-ierte Versionen der Spaltenname (beispielsweise vollständig in Großbuchstaben) als Zugriffsvariablen eines Zeilenobjekts zu benutzen. Die Zeilenklasse benutzt die Methode _transformColumn(), um den Namen, der als Zugriffsvariable genutzt wurde, wieder in den ursprünglichen Spaltennamen in der Tabelle umzuwandeln.

class MyInflectedRow extends Zend_Db_Table_Row_Abstract
{
    protected function _transformColumn($columnName)
    {
        $nativeColumnName = meineEigeneInflectionFunktion($columnName);
        return $nativeColumnName;
    }
}

class Bugs extends Zend_Db_Table_Abstract
{
    protected $_name = 'bugs';
    protected $_rowClass = 'MyInflectedRow';
}

$bugs = new Bugs();
$row = $bugs->fetchNew();

// Benutzung von Spaltennamen im camelCase.
// _transformColumn() wandelt den Spaltennamen wieder um.
$row->bugDescription = 'New description';

Es liegt in der Verantwortung des Entwicklers, Funktionen für Inflection zu schreiben. Zend Framework bietet solche Funktionen wie bereits erwähnt von Haus aus nicht an.

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