Previous Next

Rédacteurs (Writers)

Un rédacteur est un objet qui hérite de Zend_Log_Writer_Abstract. La responsabilité d'un rédacteur est d'enregistrer des données de log dans un stockage particulier.

Écrire vers un flux (stream)

Zend_Log_Writer_Stream envoie des données de log à un » flux de PHP.

Pour écrire des données de log dans le buffer d'affichage de PHP, il faut utiliser l'URL php://output. Alternativement, vous pouvez préférer envoyer des données de log directement à un flux comme STDERR (php://stderr).

$redacteur = new Zend_Log_Writer_Stream('php://output');
$logger = new Zend_Log($redacteur);

$logger->info("Message d'information");

Pour écrire des données dans un fichier, employer un des » Filesystem URLs:

$redacteur = new Zend_Log_Writer_Stream('/chemin/vers/fichierdelog');
$logger = new Zend_Log($redacteur);

$logger->info("Message d'information");
Par défaut, le flux s'ouvre en mode d'ajout ("a"). Pour l'ouvrir avec un mode différent, le constructeur de Zend_Log_Writer_Stream accepte un deuxième paramètre facultatif pour le mode.

Le constructeur de Zend_Log_Writer_Stream accepte également une ressource existante de flux :

$flux = @fopen('/chemin/vers/fichierdelog', 'a', false);
if (! $flux) {
    throw new Exception('Impossible d\'ouvrir le flux');
}

$redacteur = new Zend_Log_Writer_Stream($flux);
$logger = new Zend_Log($redacteur);

$logger->info("Message d'information");
Vous ne pouvez pas indiquer le mode pour des ressources existantes de flux. Le faire entraînera une Zend_Log_Exception.

Écrire dans des bases de données

Zend_Log_Writer_Db écrit les informations de log dans une table de base de données en utilisant Zend_Db. Le constructeur de Zend_Log_Writer_Db reçoit une instance de Zend_Db_Adapter, un nom de table, et un plan de correspondance entre les colonnes de la base de données et les données élémentaires d'événement :

$parametres = array ('host'     => '127.0.0.1',
                 'username' => 'malory',
                 'password' => '******',
                 'dbname'   => 'camelot');
$db = Zend_Db::factory('PDO_MYSQL', $parametres);

$planDeCorrespondance = array('niveau' => 'priority', 'msg' => 'message');
$redacteur = new Zend_Log_Writer_Db($db,
                                    'nom_de_la_table_de_log',
                                    $planDeCorrespondance);

$logger = new Zend_Log($redacteur);

$logger->info("Message d'information");
L'exemple ci-dessus écrit une ligne unique de données de log dans la table appelée nom_de_la_table_de_log. La colonne de base de données appelée niveau reçoit le niveau de priorité et la colonne appelée msg reçoit le message de log.

Écrire vers Firebug

Zend_Log_Writer_Firebug envoie des données d'historisation vers la » console Firebug.

zend.wildfire.firebug.console.png

Toutes les données sont envoyées via le composant Zend_Wildfire_Channel_HttpHeaders qui utilise les en-têtes HTTP pour s'assurer que le contenu de la page n'est pas perturbé. Déboguer les requêtes AJAX qui requière du JSON "propre" ou un réponse XML est possible avec cette approche.

Éléments requis :

Exemple #1 Journaliser avec Zend_Controller_Front

// Placez ceci dans votre fichier d'amorçage
// avant de distribuer votre contrôleur frontal
$writer = new Zend_Log_Writer_Firebug();
$logger = new Zend_Log($writer);

// Utiliser ceci dans vos fichiers de modèles, vues et contrôleurs
$logger->log('Ceci est un message de log !', Zend_Log::INFO);

Exemple #2 Journaliser sans Zend_Controller_Front

$writer = new Zend_Log_Writer_Firebug();
$logger = new Zend_Log($writer);

$request = new Zend_Controller_Request_Http();
$response = new Zend_Controller_Response_Http();
$channel = Zend_Wildfire_Channel_HttpHeaders::getInstance();
$channel->setRequest($request);
$channel->setResponse($response);

// Démarrer l'output buffering
ob_start();

// Maintenant vous pouvez appeler le logguer
$logger->log('Ceci est un message de log !', Zend_Log::INFO);

// Envoi des données d'historisation vers le navigateur
$channel->flush();
$response->sendHeaders();

Paramétrer les styles pour les priorités

Les priorités incorporées et celles définies par l'utilisateur peuvent être stylisées avec la méthode setPriorityStyle().

$logger->addPriority('FOO', 8);
$writer->setPriorityStyle(8, 'TRACE');
$logger->foo('Foo Message');

Le style par défaut pour les priorités définies par l'utilisateur peut être paramétrer avec la méthode setDefaultPriorityStyle().

$writer->setDefaultPriorityStyle('TRACE');

Les styles supportés sont les suivants :

Styles d'historisation de Firebug
Style Description
LOG Affiche un message d'historisation basique
INFO Affiche un message d'historisation de type information
WARN Affiche un message d'historisation de type avertissement
ERROR Affiche un message d'historisation de type erreur (celui-ci incrémente le compteur d'erreur de Firebug)
TRACE Affiche un message d'historisation avec une trace extensible
EXCEPTION Affiche un message d'historisation de type erreur avec une trace extensible
TABLE Affiche un message d'historisation avec une table extensible

Préparer les données pour l'historisation

Toute variable PHP peut être journalisée avec les priorités incorporées, un formatage spécial est requis si vous utilisez des styles d'historisation un peu plus spécialisé.

Les styles LOG, INFO, WARN, ERROR et TRACE ne requièrent pas de formatage spécial.

Historisation des exceptions

Pour journaliser une Zend_Exception, fournissez simplement l'objet exception au logguer. Il n'y a pas d'importance sur la priorité ou le style que vous avez fourni puisque l'exception est automatiquement reconnue.

$exception = new Zend_Exception('Test d\'exception');
$logger->err($exception);

Historisation sous forme de tableau

Vous pouvez aussi journaliser des données en les formatant comme un tableau. Les colonnes sont automatiquement reconnues et la première ligne de données devient automatiquement la ligne d'en-têtes.

$writer->setPriorityStyle(8, 'TABLE');
$logger->addPriority('TABLE', 8);

$table = array('Ligne de résumé pour la table',
               array(
                   array('Colonne 1', 'Colonne 2'),
                   array('Ligne 1 c 1',' Ligne 1 c 2'),
                   array('Ligne 2 c 1',' Ligne 2 c 2')
               )
              );
$logger->table($table);

Écrire vers un émail

Zend_Log_Writer_Mail va écrire les entrées du log dans un message émail en utilisant Zend_Mail. Le constructeur de Zend_Log_Writer_Mail requière un objet Zend_Mail et optionnellement un objet Zend_Layout.

Le cas d'utilisation principal de Zend_Log_Writer_Mail est la notification les développeurs, les administrateurs ou toute personne concernée, d'une erreur qui peut survenir dans des scripts. Zend_Log_Writer_Mail a été crée avec l'idée que si quelque chose ne tourne pas rond, une intervention humaine est nécessaire.

Voici un exemple d'utilisation basique :

$mail = new Zend_Mail();
$mail->setFrom('errors@example.org')
     ->addTo('project_developers@example.org');

$writer = new Zend_Log_Writer_Mail($mail);

// Ecrit le sujet. Un résumé des erreurs est ajouté à la suite
$writer->setSubjectPrependText('Errors with script foo.php');

// Limite uniquement au niveau Warning ou supérieur
$writer->addFilter(Zend_Log::WARN);

$log = new Zend_Log();
$log->addWriter($writer);

// Essai
$log->error('unable to connect to database');

// A la fermeture, Zend_Mail::send() est inviqué et concernera
// tous les logs passés dans le filtre.

Zend_Log_Writer_Mail utilisera un corps de message en texte plein (plain text) par défaut.

Le filtre est géré. Par exemple si le filtre est réglé sur Warnings, et que 2 évènements warnings et 5 évènements erreurs se produisent, alors 7 évènements seront envoyés.

Utilisation avec Zend_Layout

Une instance de Zend_Layout peut être utilisée pour générer du HTML qui fera partie de l'émail multipart. Si Zend_Layout est utilisé, Zend_Log_Writer_Mail considérera que le corps HTML du message sera la valeur du rendu de Zend_Layout.

En utilisant Zend_Log_Writer_Mail avec un objet Zend_Layout vous pouvez utiliser un formateur personnalisé grâce à setLayoutFormatter(). Si aucun formateur spécifique Zend_Layout n'est indiqué, le formateur en cours d'utilisation sera appelé. Voici un exemple :

$mail = new Zend_Mail();
$mail->setFrom('errors@example.org')
     ->addTo('project_developers@example.org');
// Nous ne spécifions pas le sujet du message dans l'objet Zend_Mail !

// Utilisons un simple objet Zend_Layout
$layout = new Zend_Layout();

// Créons un formateur à base de listes
$layoutFormatter = new Zend_Log_Formatter_Simple(
    '
  • ' . Zend_Log_Formatter_Simple::DEFAULT_FORMAT . '
  • ' ); $writer = new Zend_Log_Writer_Mail($mail, $layout); // Appliquons le formateur sur le rendu de Zend_Layout. $writer->setLayoutFormatter($layoutFormatter); $writer->setSubjectPrependText('Errors with script foo.php'); $writer->addFilter(Zend_Log::WARN); $log = new Zend_Log(); $log->addWriter($writer); // essai $log->error('unable to connect to database'); // A la fermeture, Zend_Mail::send() est inviqué et concernera // tous les logs passés dans le filtre. // l'email contiendra une partie "plain text", et une partie HTML

    Ligne du sujet dynamique

    La méthode setSubjectPrependText() est utilisée à la place de Zend_Mail::setSubject() pour que la ligne de sujet dans l'émail soit générée dynamiquement avant l'envoi de l'émail. Par exemple, si le texte indiqué est "Erreurs depuis ce script", le sujet de l'émail généré par Zend_Log_Writer_Mail avec 2 warnings et 5 errors sera alors "Erreurs depuis ce script (warn = 2; error = 5)". Si le sujet n'est pas indiqué via Zend_Log_Writer_Mail, la ligne de sujet de Zend_Mail, si il y en a une, sera utilisée.

    Attention

    Envoyer des rapports d'erreurs par emails peut être dangereux. Si votre système de surveillance d'erreurs n'est pas correct ou a un problème, vous risquez de vous retrouver inondé de tonnes d'emails en provenance de votre application.

    A l'heure actuelle, il n'existe dans Zend_Log_Writer_Mail aucun système de limitation ou de contrôle du nombre ou de la fréquence d'envoi des emails. Si vous nécessitez un tel système, vous devrez l'implémenter vous-même.

    Encore une fois, l'unique but de Zend_Log_Writer_Mail est la notification d'un humain au sujet d'une erreur. Si ce système est clairement contrôlé, alors il peut devenir un avantage très appréciable.

    Ecrire dans lee journal du système

    Zend_Log_Writer_Syslog écrit les rapports de log dans le journal système (syslog). En interne, il utilise les fonctions PHP openlog(), closelog(), et syslog().

    Un cas d'utilisation intéressant de Zend_Log_Writer_Syslog est le cluster de machines. La fonctionnalité de journal système permet de faire en sorte que chaque machine enregistre dans un fichier de journal centralisé, ce qui simplifie l'administration.

    Par défaut, tous les messages gérés sont préfixés par "Zend_Log". Si vous souhaitez changer ce nom, utilisez le constructeur ou l'accesseur:

    // A l'instanciation
    $writer = new Zend_Log_Writer_Syslog(array('application' => 'FooBar'));
    
    // Plus tard:
    $writer->setApplicationName('BarBaz');

    Le journal système vous aidera aussi à identifier les messages par types d'application ("facility"), les programmes de journalisation système vont générer des fichiers journaux différents en fonction des types d'application, ce qui là encore, peut aider dans l'administration.

    Pour spécifier le type d'application, utilisez le constructeur ou l'accesseur. Cette option peut être l'une des constantes utilisées par openlog(), définies dans la page » du manuel de openlog().

    // A l'instanciation
    $writer = new Zend_Log_Writer_Syslog(array('facility' => LOG_AUTH));
    
    // Plus tard
    $writer->setFacility(LOG_USER);

    En utilisant l'objet de log, continuez d'utiliser les constantes de Zend_Log, elles vont être converties en leurs valeurs par syslog().

    Ecrire vers le moniteur Zend Server

    Zend_Log_Writer_ZendMonitor vous permet de journaliser des évènements via l'API de Zend Server. Vous pouvez alors aggréger des messages de journal pour l'application et tout son environnement, ceci vers un seul endroit. En interne, cet objet utilise simplement la fonction monitor_custom_event() issue de Zend Monitor.

    Une caractéristique particulière de l'API Monitor est que vous pouvez spécifier n'importe quelle information dans le journal. Par exemple, journaliser une exception est possible en journalisant tout l'objet Exception d'un coup et pas juste son message. L'objet sera alors visible et analysable via le moniteur d'évènement de Zend Server.

    Note: Zend Monitor doit être installé et activé

    Pour utiliser cet objet d'écriture, Zend Monitor doit petre installé et activé. Si ce n'est pas le cas, alors l'objet d'écriture agira de manière transparente et ne fera rien du tout.

    Instancier l'objet d'écriture ZendMonitor est très simple:

    $writer = new Zend_Log_Writer_ZendMonitor();
    $log    = new Zend_Log($writer);

    Ensuite, journalisez vos évènements comme d'habitude:

    $log->info('Voici un message');

    Vous pouvez ajouter des informations à journaliser, passez les comme second paramètre:

    $log->info('Exception rencontrée', $e);

    Ce deuxième paramètre peut être de type scalaire, objet, ou tableau; si vous souhaitez passer plusieurs informations d'un seul coup, utilisez un tableau.

    $log->info('Exception rencontrée', array(
        'request'   => $request,
        'exception' => $e,
    ));

    Au sein de Zend Server, votre évènement est enregistré comme un "évènement personnalisé" (custom event). Depuis l'onglet "Monitor", sélectionnez le sous menu "Evènements"(Events), et utilisez ensuite le filtre "Personnalisé"(Custom).

    zend.log.writers.zendmonitor-events.png

    Evènements dans le récapitulatif Zend Server Monitor

    Sur cette image, les deux premiers évènements listés sont des évènements personnalisés enregistré via l'objet d'écriture ZendMonitor. Cliquez alors sur un évènement pour voir toutes ses informations.

    zend.log.writers.zendmonitor-event.png

    Détails de l'évènement dans Zend Server Monitor

    Cliquer sur le sous menu "Personnalisé"(Custom) montre les détails, c'est à dire ce que vous avez passé comme deuxième argument à la méthode de journalisation. Cet information est enregistrée sous la clé info; et vous pouvez voir que l'objet de requête a été enregistré dans cet exemple.

    Note: Intégration avec Zend_Application

    Par défaut, les commandes zf.sh et zf.bat ajoute une configuration pour la ressource 'log' deZend_Application , elle inclut la configuration pour l'objet d'écriture du journal ZendMonitor. Aussi, le ErrorController utilise ce journal pour journaliser les exceptions de l'application.

    Comme dit précedemment, si l'API de Zend Monitor API n'est pas détectée sur votre installation de PHP, alors le journal ne fera rien du tout.

    Déraciner les rédacteurs

    Le Zend_Log_Writer_Null est une souche qui écrit des données de log nulle part. Il est utile pour neutraliser le log ou déraciner le log pendant les essais :

    $redacteur = new Zend_Log_Writer_Null;
    $logger = new Zend_Log($redacteur);
    
    // va nulle part
    $logger->info("Message d'information");

    Tester avec un simulacre

    Le Zend_Log_Writer_Mock est un rédacteur très simple qui enregistre les données brutes qu'il reçoit dans un tableau exposé comme propriété publique.

    $simulacre = new Zend_Log_Writer_Mock;
    $logger = new Zend_Log($simulacre);
    
    $logger->info("Message d'information");
    
    var_dump($mock->events[0]);
    
    // Array
    // (
    //    [timestamp] => 2007-04-06T07:16:37-07:00
    //    [message] => Message d'information
    //    [priority] => 6
    //    [priorityName] => INFO
    // )

    Pour effacer les événements notés dans le simulacre, il faut simplement réaliser $simulacre->events = array().

    Additionner les rédacteurs

    Il n'y a aucun objet composite de rédacteurs. Cependant, une instance d'enregistreur peut écrire vers tout nombre de rédacteurs. Pour faire ceci, employer la méthode addWriter() :

    $redacteur1 =
        new Zend_Log_Writer_Stream('/chemin/vers/premier/fichierdelog');
    $redacteur2 =
        new Zend_Log_Writer_Stream('/chemin/vers/second/fichierdelog');
    
    $logger = new Zend_Log();
    $logger->addWriter($redacteur1);
    $logger->addWriter($redacteur2);
    
    // va dans les 2 rédacteurs
    $logger->info("Message d'information");

    Previous Next
    Introduction au Zend Framework
    Présentation
    Installation
    Apprendre Zend Framework
    Démarrez rapidement avec Zend Framework
    Zend Framework & MVC Introduction
    Create Your Project
    Create A Layout
    Create a Model and Database Table
    Create A Form
    Congratulations!
    Chargement automatique avec Zend Framework
    Introduction
    Architecture et buts
    Utilisation de base de l'autoloader
    Auto-chargement de resources
    Conclusion
    Les plugins dans Zend Framework
    Introduction
    Utiliser des Plugins
    Conclusion
    Bien démarrer avec Zend_Layout
    Introduction
    Utiliser Zend_Layout
    Zend_Layout: Conclusions
    Bien démarrer avec Zend_View
    Introduction
    Basic Placeholder Usage
    Standard Placeholders
    View Placeholders: Conclusion
    Bien comprendre et utiliser les décorateurs Zend Form
    Introduction
    Les bases des décorateurs
    Chainer les décorateurs
    Rendu individuel des décorateurs
    Créer et rendre des éléments composites
    Conclusion
    Bien démarrer avec Zend_Session, Zend_Auth, et Zend_Acl
    Fabrique une application Multi-Utilisateurs avec Zend Framework
    Gérer les sessions dans ZF
    Authentification d'utilisateurs dans Zend Framework
    Fabriquer un système de gestion d'autorisations avec Zend Framework
    Bien démarrer avec Zend_Search_Lucene
    Introduction à Zend_Search_Lucene
    Structure d'index Lucene
    Ouverture et création d'index
    Indexation
    Recherche
    Requêtes supportées
    Pagination de résultat de recherche
    Bien démarrer avec Zend_Paginator
    Introduction
    Exemples simples
    Contrôles de la pagination et styles de défilement
    Assembler le tout
    Guide de référence Zend Framework
    Zend_Acl
    Introduction
    Affiner les Contrôles d'Accès
    Utilisation avancée
    Zend_Amf
    Introduction
    Zend_Amf_Server
    Zend_Application
    Introduction
    Zend_Application démarrage rapide
    Théorie générale
    Exemples
    Fonctionnalités principales
    Plugins de ressources disponibles
    Zend_Auth
    Introduction
    Authentification avec une table de base de données
    Authentification "Digest"
    Adaptateur d'authentification HTTP
    LDAP Authentication
    Authentification OpenID
    Zend_Barcode
    Introduction
    Création de code-barres avec la classe Zend_Barcode
    Zend_Barcode Objects
    Zend_Barcode Renderers
    Zend_Cache
    Introduction
    Aspect théorique
    Les frontends Zend_Cache
    Les backends Zend_Cache
    Le gestionnaire de Cache
    Zend_Captcha
    Introduction
    Opération Captcha
    Adaptateurs CAPTCHA
    Zend_CodeGenerator
    Introduction
    Exemples Zend_CodeGenerator
    Zend_CodeGenerator Réference
    Zend_Config
    Introduction
    Aspect théorique
    Zend_Config_Ini
    Zend_Config_Xml
    Zend_Config_Writer
    Zend_Config_Writer
    Zend_Console_Getopt
    Introduction
    Déclarer les règles Getopt
    Extraire les options et les arguments
    Configurer Zend_Console_Getopt
    Zend_Controller
    Zend_Controller - Démarrage rapide
    Fondations de Zend_Controller
    Le contrôleur frontal (Front Controller)
    L'objet Requête
    Routeur Standard
    Le distributeur
    Contrôleurs d'action
    Aides d'action (Helper)
    Objet de réponse
    Plugins
    Utilisation de conventions de dossiers modulaires
    Exceptions avec MVC
    Zend_Currency
    Introduction à Zend_Currency
    Utiliser Zend_Currency
    Options des monnaies
    Qu'est ce qui définit une monnaie?
    Où est le symbole monnétaire?
    A quoi ressemble une monnaie?
    Travailler avec les valeurs des monnaies (les montants)
    Calculs avec les monnaies
    Echanger (convertir) des monnaies
    Informations complémentaires pour Zend_Currency
    Zend_Date
    Introduction
    Aspect théorique
    Méthodes de base
    Zend_Date API Overview
    Créer des dates
    Constants for General Date Functions
    Exemples concrets
    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
    Relations Zend_Db_Table
    Zend_Db_Table_Definition
    Zend_Debug
    Afficher des informations
    Zend_Dojo
    Introduction
    Zend_Dojo_Data: dojo.data Envelopes
    Les aides de vues Dojo
    Les éléments de formulaire et les décorateurs Dojo
    Zend_Dojo build layer support
    Zend_Dom
    Introduction
    Zend_Dom_Query
    Zend_Exception
    Utiliser les exceptions
    Utilisation classique
    Exceptions précédentes
    Zend_Feed
    Introduction
    Importer des flux
    Obtenir des flux à partir de pages Web
    Consommer un flux RSS
    Consommer un flux Atom
    Consommer une entrée Atom particulière
    Modifier la structure du flux ou des entrées
    Classes personnalisées pour les flux et entrées
    Zend_Feed_Reader
    Zend_Feed_Writer
    Zend_Feed_Pubsubhubbub
    Zend_File
    Zend_File_Transfer
    Validateurs pour Zend_File_Transfer
    Filtres pour Zend_File_Transfer
    Zend_Filter
    Introduction
    Classes de filtre standards
    Chaînes de filtrage
    Écriture de filtres
    Zend_Filter_Input
    Zend_Filter_Inflector
    Zend_Form
    Zend_Form
    Zend_Form démarrage rapide
    Creating Form Elements Using Zend_Form_Element
    Creating Forms Using Zend_Form
    Créer un visuel personnalisé en utilisant Zend_Form_Decorator
    Standard Form Elements Shipped With Zend Framework
    Décorateurs standards fournis avec Zend Framework
    Internationaliser un formulaire Zend_Form
    Advanced Zend_Form Usage
    Zend_Gdata
    Introduction
    Authentification par procédé AuthSub
    Using the Book Search Data API
    Authentification avec ClientLogin
    Using Google Calendar
    Using Google Documents List Data API
    Using Google Health
    Using Google Spreadsheets
    Using Google Apps Provisioning
    Using Google Base
    Utilisation des albums Web Picasa
    Using the YouTube Data API
    Attraper les exceptions Gdata
    Zend_Http
    Introduction
    Zend_Http_Client - Utilisation avancée
    Zend_Http_Client - Adaptateurs de connexion
    Zend_Http_Cookie and Zend_Http_CookieJar
    Zend_Http_Response
    Zend_InfoCard
    Introduction
    Zend_Json
    Introduction
    Utilisation de base
    Utilisation avancée de Zend_Json
    XML to JSON conversion
    Zend_Json_Server - JSON-RPC server
    Zend_Layout
    Introduction
    Zend_Layout - Démarrage rapide
    Zend_Layout options de configuration
    Zend_Layout, utilisation avancée
    Zend_Ldap
    Introduction
    API overview
    Scénarios d'utilisation
    Outils
    Accès à l'arbre LDAP de manière orientée objet avec Zend_Ldap_Node
    Récupérer des informations depuis un serveur LDAP
    Serialiser des données LDAP depuis/vers LDIF
    Zend_Loader
    Charger les fichiers et les classes dynamiquement
    L'autoloader
    Autoloaders de ressources
    Chargeur de Plugins
    Zend_Locale
    Introduction
    Using Zend_Locale
    Normalization and Localization
    Working with Dates and Times
    Supported locales
    Zend_Log
    Présentation
    Rédacteurs (Writers)
    Formateurs (mise en forme)
    Filtres
    Utiliser la fabrique pour créer des logs
    Zend_Mail
    Introduction
    Envoyer des émail en utilisant SMTP
    Envoyer plusieurs émail par connexion SMTP
    Utiliser différents transports
    Émail HTML
    Fichiers joints
    Ajouter des destinataires
    Contrôler les limites MIME
    En-têtes additionnels
    Jeux de caractères
    Encodage
    Authentification SMTP
    Sécuriser les transports SMTP
    Lire des émail
    Zend_Markup
    Introduction
    Guide de démarrage avec Zend_Markup
    Analyseurs Zend_Markup (parsers)
    Moteurs de rendu Zend_Markup
    Zend_Measure
    Introduction
    Création d'une mesure
    Récupérer des mesures
    Manipuler des mesures
    Types de mesures
    Zend_Memory
    Présentation
    Manager de mémoire
    Objet mémoire
    Zend_Mime
    Zend_Mime
    Zend_Mime_Message
    Zend_Mime_Part
    Zend_Navigation
    Introduction
    Pages
    Containers
    Zend_Oauth
    Introduction to OAuth
    Zend_OpenId
    Introduction
    Zend_OpenId_Consumer Basics
    Zend_OpenId_Provider
    Zend_Paginator
    Introduction
    Utilisation
    Configuration
    Utilisation avancée
    Zend_Pdf
    Introduction
    Créer et charger des documents PDF
    Sauvegarder les changement dans un document PDF
    Les pages d'un document
    Dessiner
    Interactive Features
    Informations du document et métadonnées
    Exemple d'utilisation du module Zend_Pdf
    Zend_ProgressBar
    Zend_ProgressBar
    Zend_Queue
    Introduction
    Example usage
    Framework
    Adapters
    Customizing Zend_Queue
    Stomp
    Zend_Reflection
    Introduction
    Zend_Reflection Exemples
    Réference de Zend_Reflection
    Zend_Registry
    Utiliser le registre
    Zend_Rest
    Introduction
    Zend_Rest_Client
    Zend_Rest_Server
    Zend_Search_Lucene
    Vue d'ensemble
    Créer des index
    Chercher dans un index
    Langage de requêtes
    API de construction de requêtes
    Jeu de caractères
    Extensibilité
    Agir avec Lucene Java
    Avancé
    Bonnes pratiques
    Zend_Serializer
    Introduction
    Zend_Serializer_Adapter
    Zend_Server
    Introduction
    Zend_Server_Reflection
    Zend_Service
    Introduction
    Zend_Service_Akismet
    Zend_Service_Amazon
    Zend_Service_Amazon_Ec2
    Zend_Service_Amazon_Ec2: Instances
    Zend_Service_Amazon_Ec2: Windows Instances
    Zend_Service_Amazon_Ec2: Reserved Instances
    Zend_Service_Amazon_Ec2: CloudWatch Monitoring
    Zend_Service_Amazon_Ec2: Amazon Machine Images (AMI)
    Zend_Service_Amazon_Ec2: Elastic Block Storage (EBS)
    Zend_Service_Amazon_Ec2: Elastic IP Addresses
    Zend_Service_Amazon_Ec2: Keypairs
    Zend_Service_Amazon_Ec2: Regions and Availability Zones
    Zend_Service_Amazon_Ec2: Security Groups
    Zend_Service_Amazon_S3
    Zend_Service_Amazon_Sqs
    Zend_Service_Audioscrobbler
    Zend_Service_Delicious
    Zend_Service_DeveloperGarden
    Zend_Service_Flickr
    Zend_Service_LiveDocx
    Zend_Service_Nirvanix
    Zend_Service_ReCaptcha
    Zend_Service_Simpy
    Zend_Service_SlideShare
    Zend_Service_StrikeIron
    Zend_Service_StrikeIron: Bundled Services
    Zend_Service_StrikeIron: Advanced Uses
    Zend_Service_Technorati
    Zend_Service_Twitter
    Zend_Service_WindowsAzure
    Zend_Service_Yahoo
    Zend_Session
    Introduction
    Usage basique
    Utilisation avancée
    Gestion générale de la session
    Zend_Session_SaveHandler_DbTable
    Zend_Soap
    Zend_Soap_Server
    Zend_Soap_Client
    WSDL
    Auto découverte
    Zend_Tag
    Introduction
    Zend_Tag_Cloud
    Zend_Test
    Introduction
    Zend_Test_PHPUnit
    Zend_Test_PHPUnit_Db
    Zend_Text
    Zend_Text_Figlet
    Zend_Text_Table
    Zend_TimeSync
    Introduction
    Utiliser Zend_TimeSync
    Zend_Tool
    Using Zend_Tool On The Command Line
    Extending Zend_Tool
    Zend_Tool_Framework
    Introduction
    Using the CLI Tool
    Architecture
    Creating Providers to use with Zend_Tool_Framework
    Shipped System Providers
    Extending and Configuring Zend_Tool_Framework
    Zend_Tool_Project
    Introduction
    Créer un projet
    Fournisseurs de Zend_Tool_Project
    Rouages internes de Zend_Tool_Project
    Zend_Translate
    Introduction
    Adaptateurs pour Zend_Translate
    Utiliser les adaptateurs de traduction
    Creating source files
    Additional features for translation
    Notation des pluriels pour Translation
    Zend_Uri
    Zend_Uri
    Zend_Validate
    Introduction
    Classes de validation standard
    Chaînes de validation
    Écrire des validateurs
    Messages de validation
    Zend_Version
    Lire la version de Zend Framework
    Zend_View
    Introduction
    Scripts de contrôleur
    Scripts de vue
    Aides de vue
    Zend_View_Abstract
    Zend_Wildfire
    Zend_Wildfire
    Zend_XmlRpc
    Introduction
    Zend_XmlRpc_Client
    Zend_XmlRpc_Server
    ZendX_Console_Process_Unix
    ZendX_Console_Process_Unix
    ZendX_JQuery
    Introduction
    ZendX_JQuery View Helpers
    ZendX_JQuery Form Elements and Decorators
    Configuration système requise par Zend Framework
    Introduction
    Notes de migration de Zend Framework
    Zend Framework 1.10
    Zend Framework 1.9
    Zend Framework 1.8
    Zend Framework 1.7
    Zend Framework 1.6
    Zend Framework 1.5
    Zend Framework 1.0
    Zend Framework 0.9
    Zend Framework 0.8
    Zend Framework 0.6
    Convention de codage PHP de Zend Framework
    Vue d'ensemble
    Formatage des fichiers PHP
    Conventions de nommage
    Style de codage
    Zend Framework Documentation Standard
    Overview
    Documentation File Formatting
    Recommendations
    Recommended Project Structure for Zend Framework MVC Applications
    Overview
    Recommended Project Directory Structure
    Module Structure
    Rewrite Configuration Guide
    Guide de performance Zend Framework
    Introduction
    Chargement des classes
    Performance de Zend_Db
    Internationalisation (i18n) and Localisation (l10n)
    View Rendering
    Informations de copyright