Qu'est-ce que PEAR ?
PEAR est l'abréviation de PHP Extension and Application Repository. Il s'agit d'un référentiel de code pour les extensions et applications PHP. En termes simples, PEAR est le CPAN de PHP.
Pourquoi utiliser POIRE ?
PHP est un très excellent langage de script, concis et efficace. Avec la sortie de la version 4.0, de plus en plus de personnes l'utilisent pour développer des sites Web dynamiques. On peut dire que PHP est devenu l'un des meilleurs langages de développement INTERNET, notamment PHP. langage de choix pour les développeurs de sites Web qui doivent être capables de développer rapidement et efficacement des applications pour petites et moyennes entreprises. Cependant, avec le nombre croissant d'applications PHP, il existe un manque de normes unifiées et de gestion efficace de ces applications. Par conséquent, il est difficile pour la communauté PHP de partager ses codes et ses applications aussi facilement que les membres de la communauté PERL, car. PHP n'a pas les mêmes normes que CPAN. Une base de code unifiée pour classer et gérer les modules de code d'application (quiconque connaît PERL sait que CPAN est un énorme entrepôt de modules d'extension PERL. Les modules d'application écrits peuvent être placés dans le répertoire de classification approprié sous CPAN, et d'autres personnes peuvent le réutiliser. Bien sûr, vous devez également suivre les directives lors de l'écriture des modules d'application.)
C'est pour cette raison que PEAR a vu le jour et a été distribué avec le noyau PHP à partir de la version 4.04.
Quels bénéfices PEAR peut-il m'apporter ?
1. Comme mentionné ci-dessus, PEAR gère la base de code de l'application PEAR selon certaines catégories. Votre code PEAR peut être organisé dans des répertoires appropriés, et d'autres personnes peuvent facilement récupérer et partager vos résultats.
2. PEAR n'est pas seulement un référentiel de code, c'est aussi un standard. L'utilisation de ce standard pour écrire votre code PHP améliorera la lisibilité et la réutilisabilité de votre programme et réduira les risques d'erreurs.
3. PEAR construit un framework pour vous en fournissant 2 classes pour implémenter des fonctions telles que les destructeurs et la capture d'erreurs. Vous pouvez utiliser ces fonctions via l'héritage.
Règles de codage de PEAR
Les règles de codage de PEAR incluent des règles d'indentation, des structures de contrôle, des appels de fonctions, des définitions de fonctions, des commentaires, du code inclus, des balises PHP, des blocs de commentaires d'en-tête de fichier, des balises CVS, des exemples d'URL et la dénomination des constantes. Voici une brève introduction :
règles d’indentation :
PEAR nécessite 4 espaces pour indenter le code et aucune TAB n'est utilisée. Si vous utilisez VIM, mettez les paramètres suivants dans votre ~/.vimrc : set expandtab
définir la largeur de décalage = 4
set tabstop=4
Si vous utilisez Emacs/XEmacs, vous devez définir indent-tabs-mode sur nil.
Mais si vous aimez utiliser (X)Emacs pour éditer des fichiers PHP comme moi, je vous recommande fortement d'installer PHP-MODE afin que lorsque vous écrivez du code PEAR, il ajuste automatiquement votre style d'indentation. Bien sûr, il existe de nombreux PHP-. MODE Très bonne fonctionnalité, vous pouvez télécharger la dernière version de PHP-MODE depuis la liste des ressources.
Structure de contrôle :
Les structures de contrôle mentionnées ici incluent : if for while switch, etc. Pour les structures de contrôle, il doit y avoir un espace après le mot-clé (comme if for ..), puis les parenthèses de contrôle, afin qu'il ne soit pas confondu avec les appels de fonction. De plus, vous devez essayer d'utiliser des accolades {}. aussi complètement que possible, même si c'est syntaxiquement facultatif. Cela évitera toute confusion logique ou erreur lorsque vous devrez ajouter de nouvelles lignes de code à l'avenir. Voici un exemple : if ((condition1) && (condition2)) {
Déclaration 1 ;
}esleif ((Condition 3) || (Condition 4)) {
Déclaration 2 ;
}autre {
Déclaration 3 ;
}
Appel de fonction :
Pour les appels de fonction, il ne doit y avoir aucun espace entre le nom de la fonction et le crochet ouvrant ( (), pour les paramètres de fonction, il doit y avoir la même séparation d'espace entre la virgule délimitatrice et le paramètre suivant, et il ne doit y avoir aucun espace entre le dernier paramètre et le crochet fermant. Ci-dessous Est un appel de fonction standard ; $result = foo($param1, $param2, $param3);
Écriture irrégulière :
$result=foo ($param1,$param2,$param3);
$result=foo( $param1,$param2, $param3 );
De plus, si vous souhaitez attribuer le résultat de retour de la fonction, il doit y avoir un espace entre le signe égal et la variable affectée. En même temps, s'il s'agit d'une série d'instructions d'affectation liées, vous ajoutez des espaces appropriés pour aligner. eux, comme ça ：$result1 = $foo($param1, $param2, $param3);
$var2 = $foo($param3);
$var3 = $foo($param4, $param5);
Définition de la fonction :
La définition de la fonction suit la convention « une seule vraie accolade » : function connect(&$dsn, $persistent = false)
{
si (is_array($dsn)) {
$dsninfo = &&dsn;
} autre {
$dsninfo = DB::parseDSN($dsn);
}
si (!$dsninfo || !$dsninfo['phptype']) {
return $this->raiseError();
}
renvoie vrai ;
}
Comme indiqué ci-dessus, les paramètres facultatifs doivent être à la fin de la liste des paramètres et essayer toujours de renvoyer des valeurs de fonction significatives.
Concernant les commentaires :
Pour la documentation en ligne des classes, elle devrait pouvoir être convertie par PHPDoc, tout comme JavaDoc. PHPDoc est également une application PEAR Pour une introduction plus détaillée, vous pouvez aller sur http://www.phpdoc.de/ pour la consulter. En plus de la documentation en ligne des classes, il est recommandé d'utiliser des commentaires non liés à la documentation pour expliquer votre code. Lorsque vous voyez un morceau de code, vous pensez : Oh, je ne pense pas que vous ayez besoin de le décrire soigneusement dans la documentation. . Alors vous feriez mieux de donner un simple commentaire à ce code pour ne pas oublier son fonctionnement. Pour les formulaires de commentaires, les /* */ de C et // de C++ sont tous deux bons. Cependant, n'utilisez pas la méthode de commentaire # de Perl ou du shell.
Contient le code :
Chaque fois que vous devez inclure un fichier de classe de manière inconditionnelle, vous devez utiliser require_once ; lorsque vous devez inclure un fichier de classe de manière conditionnelle, vous devez utiliser include_once ; cela garantit que le fichier que vous souhaitez inclure ne sera inclus qu'une seule fois, et ces deux instructions ; partagez la même liste de fichiers, vous n'avez donc pas à vous soucier de la confusion des deux. Une fois que require_once inclut un fichier, include_once n'inclura plus le même fichier, et vice versa.
Balisage du code PHP :
Utilisez toujours <?php ?> pour définir votre code php au lieu de simplement utiliser <?php ?> Cela garantit la compatibilité PEAR et facilite le portage multiplateforme.
Déclaration de commentaire dans l'en-tête du fichier :
Pour tous les fichiers de code PHP qui doivent être inclus dans la version principale de PEAR, vous devez ajouter l'instruction de commentaire suivante au début du fichier : /* vim : set expandtab tabstop=4 shiftwidth=4 : */
// +-------------------------------------------------------------- --- -----------------------+
// | PHP version 4.0 |
// +-------------------------------------------------------------- --- -----------------------+
// | Copyright (c) 1997, 1998, 1999, 2000, 2001 Le groupe PHP |
// +-------------------------------------------------------------- --- -----------------------+
// | Ce fichier source est soumis à la version 2.0 de la licence PHP, |
// | qui est fourni avec ce package dans le fichier LICENSE, et est |
// | disponible sur le Web à l'adresse |
// | http://www.php.net/license/2_02.txt .
// | Si vous n'avez pas reçu de copie de la licence PHP et que vous ne parvenez pas |
// | l'obtenir via le World Wide Web, veuillez envoyer une note à |
// | [email protected] afin que nous puissions vous en envoyer une copie immédiatement.
// +-------------------------------------------------------------- --- -----------------------+
// | Auteurs : Auteur original |
// | Votre nom |
// +-------------------------------------------------------------- --- -----------------------+
//
// $Id$
Pour les fichiers qui ne sont pas dans la base de code principale de PEAR, il est recommandé d'avoir également un bloc de commentaires similaire au début du fichier, indiquant le droit d'auteur, l'accord, l'auteur, etc. En même temps, ajoutez MODELINE de VIM dans la première ligne, afin que le style de code de PEAR puisse être conservé dans VIM.
Balisage CVS :
Comme indiqué ci-dessus, ajoutez la balise ID CVS à chaque fichier. Si le fichier que vous éditez ou modifiez ne possède pas cette balise, veuillez l'ajouter ou la remplacer par une expression similaire dans le fichier d'origine (telle que "Dernière modification", etc. )
Exemple d'URL :
Vous pouvez suivre la RFC 2606 et utiliser « www.example.com » comme tous les exemples d'URL.
Dénomination constante :
Les constantes doivent être écrites en majuscules lorsque cela est possible, et pour faciliter la compréhension, utilisez des traits de soulignement pour séparer chaque mot. En même temps, vous devez préfixer le nom du package ou le nom de la classe où se trouve la constante. Par exemple, les constantes de la classe Bug doivent commencer par Bug_. Ce qui précède sont les règles de codage de PEAR. Pour les règles de codage détaillées, veuillez vous référer à la description du fichier CODING_STANDDARD dans PEAR. Pour mieux comprendre ces règles de codage, vous pouvez également vous référer au code du module de base PEAR existant.
Commencez avec PEAR
POIRE
Utiliser PEAR est très simple, il vous suffit de définir votre propre programme PEAR comme ceci : require_once "PEAR.php";
la classe your_class_name étend PEAR{
La définition de votre classe...
}
Bien sûr, vous devez respecter les règles de codage PEAR mentionnées ci-dessus, puis vous pourrez implémenter ce que vous voulez faire dans votre classe. Ensuite, parlons-en. En fait, PEAR nous fournit 2 classes prédéfinies : PEAR : Il s'agit de la classe de base de PEAR, et toutes les extensions PEAR doivent en hériter et en dériver. PEAR_Error : classe de base de gestion des erreurs de PEAR, vous pouvez choisir de dériver votre propre classe de gestion des erreurs.
D'une manière générale, vous ne devez pas créer directement une instance de PEAR, mais dériver vous-même une nouvelle classe, puis créer une instance de cette nouvelle classe. En tant que classe de base, PEAR nous fournit quelques fonctions utiles, les plus importantes sont les destructeurs et
les destructeurs de gestion des erreurs.
PHP prend en charge les constructeurs, mais pas les destructeurs. Cependant, PHP fournit la fonction register_shutdown_function(), qui peut rappeler la fonction enregistrée avant la fin du script. Par conséquent, PEAR utilise cette fonctionnalité pour fournir une simulation du destructeur. Si vous avez une sous-classe de PEAR appelée mypear, alors dans la classe mypear, vous pouvez définir une fonction. Le nom de la fonction est un trait de soulignement plus le nom de votre classe, _mypear(). Cependant, ce destructeur est différent du destructeur en C++. Il ne sera pas exécuté lorsque l'objet sera supprimé, mais à la fin du script. Après tout, ce n'est qu'une simulation. Puisque register_shutdown_function() est utilisé, les informations imprimées ne seront pas renvoyées au navigateur dans votre destructeur. De plus, dans votre constructeur, vous devez appeler le constructeur de sa classe parent, car PHP n'appellera pas automatiquement le constructeur de la classe parent, et le destructeur doit être enregistré dans le constructeur de PEAR. Nous pouvons y jeter un œil. POIRE Code source : <code>
fonction POIRE() {
if (method_exists($this, "_".get_class($this))) {
global $_PEAR_destructor_object_list ;
$_PEAR_destructor_object_list[] = &this;
}
si ($this->_debug) {
printf("Constructeur PEAR appelé, classe=%sn",
get_class($this));
}
.....
fonction _PEAR_call_destructors() {
global $_PEAR_destructor_object_list ;
if (is_array($_PEAR_destructor_object_list) && sizeof($_PEAR_destructor_object_list)) {
réinitialiser($_PEAR_destructor_object_list);
while (list($k, $objref) = each($_PEAR_destructor_object_list)) {
$destructeur = "_".get_class($objref);
if (method_exists($objref, $destructor)) {
$objref->$destructeur();
}
}
//Effacer la liste des objets enregistrés,
//Empêcher les appels répétés
$_PEAR_destructor_object_list = tableau();
}
}
....
register_shutdown_function("_PEAR_call_destructors");
</code>
Le code ci-dessus montre comment PEAR implémente le destructeur. Dans la fonction du composant, il vérifiera s'il existe un destructeur dans la classe actuelle. Si tel est le cas, alors la référence de la classe actuelle sera mise dans une liste globale, dans _ In PEAR_call_destructors. , vérifiez si chaque élément de la liste globale a un destructeur correspondant, si c'est le cas, appelez-le et enfin effacez la liste globale.
Dans la dernière ligne de code de PEAR.php, appelez register_shutdown_function("_PEAR_call_destructors") pour enregistrer _PEAR_call_destructors, afin que lorsque le script soit exécuté, PHP rappelle cette fonction. En utilisant le destructeur, vous pouvez effectuer certains travaux de « suivi » nécessaires avant de quitter après avoir traité la demande de l'utilisateur. Des exemples typiques sont que vous pouvez fermer des fichiers ouverts, vous déconnecter de la base de données et stocker certaines données sur le disque, etc.
Gestion des erreurs
PEAR vous permet de gérer les erreurs de plusieurs manières. Vous renvoyez non seulement simplement un code d'erreur ou des informations d'erreur, mais vous pouvez également renvoyer un objet PEAR_Error ou un nouvel objet d'erreur dérivé de PEAR_Error.
L'objet d'erreur dans PEAR ne limite pas le formulaire de sortie spécifique. Il peut simplement capturer l'erreur sans renvoyer trop d'informations à l'utilisateur, ou il peut rappeler une fonction spéciale de gestion des erreurs en même temps, même s'il génère des informations sur l'erreur. , cela peut également Vous êtes obligé d'utiliser le format HTML. Vous pouvez générer du XML, du format CSV ou d'autres formats définis par vous-même. Il vous suffit de dériver une nouvelle classe de PEAR_Error, puis de créer et de "lancer" cette nouvelle classe. moment approprié.
Gestion simple des erreurs :
Dans PEAR, la gestion des erreurs la plus simple consiste à "lancer" l'erreur. Vous créez et renvoyez simplement un objet PEAR_Error. Voici un exemple simple : <code>
fonction myconnect($host = "localhost", $port = 1080)
{
$fp = fsockopen($hôte, $port, $errno, $errstr);
si (!is_resource($fp)) {
renvoie une nouvelle PEAR_Error($errstr, $errno);
}
retourner $fp ;
}
$chaussette = maconnexion();
if (PEAR::isError($sock)) {
print "erreur de connexion : ".$sock->getMessage()."<BR>n"
}
</code>
Comme indiqué dans le code ci-dessus, après avoir exécuté un morceau de code susceptible de produire une erreur, vous devez utiliser isError de PEAR pour détecter s'il y a une erreur, et vous pouvez utiliser getMessage de PEAR_Error pour obtenir le dernier message d'erreur.
Remarque : assurez-vous d'utiliser PEAR::isErroret raiseError
aux endroits clés.
Après PHP4.0.5, PEAR a 2 fonctions supplémentaires :
setErrorHandling($mode, $options = null)
raiseError($message = null, $code = null, $mode = null,$options = null, $userinfo = null)
Le premier peut définir le mode de gestion des erreurs par défaut de PEAR, et le second est une fonction wrapper qui renvoie un objet PEAR_Error, ce qui est légèrement différent de la création et du renvoi direct d'un objet PEAR_Error. Si vous omettez des paramètres tels que $mode et $options, il utilisera les valeurs par défaut pour créer l'objet PEAR_Error. Vous pouvez utiliser setErrorHandling() pour personnaliser ces valeurs par défaut. .
PEAR_Erreur
PEAR_Error est une classe de base de l'objet d'erreur de PEAR. Contrairement à PEAR, d'une manière générale, vous pouvez créer directement une instance de PEAR_Error. La méthode de création est : $error = new PEAR_Error($message, $code, $mode, $options, $userinfo. );
$message est votre message d'erreur, $code est le numéro d'erreur de l'erreur et les trois derniers paramètres sont étroitement liés :
$mode : est le mode de gestion des erreurs, qui peut être les constantes suivantes :
PEAR_ERROR_RETURN : renvoie uniquement l'objet d'erreur (mode par défaut)
PEAR_ERROR_PRINT : imprime ce message d'erreur dans la fonction de construction, mais le programme en cours continuera à s'exécuter.
PEAR_ERROR_TRIGGER : utilisez trigger_error() de PHP pour déclencher une erreur. Si vous avez configuré une fonction de gestion des erreurs ou si vous définissez le niveau de gestion des erreurs de PHP sur E_USER_ERROR, le programme en cours sera terminé.
PEAR_ERROR_DIE : Imprimez l'erreur et quittez, le programme se termine.
PEAR_ERROR_CALLBACK : utilisez une fonction ou une méthode de rappel pour gérer l'erreur actuelle et le programme se termine.
$options : Ce paramètre ne fonctionne que lorsque $mode est PEAR_ERROR_TRIGGER et PEAR_ERROR_CALLBACK. S'il est PEAR_ERROR_TRIGGER, $options doit être l'une des trois constantes E_USER_NOTICE, E_USER_WARNING ou E_USER_ERROR, ce qui est cohérent avec la valeur de trigger_error en PHP. Si $mode vaut PEAR_ERROR_CALLBACK, $options peut être une chaîne contenant le nom de la fonction à rappeler, ou un tableau de 2 éléments, respectivement une variable objet et une chaîne (indiquant la méthode à appeler).
$userinfo : stocke des informations utilisateur supplémentaires. Vous pouvez mettre ici des informations de débogage pertinentes.
Il existe certaines méthodes couramment utilisées dans PEAR_Error, qui ne sont pas décrites dans la documentation PHP. Elles sont répertoriées ici :
int getMode : renvoie le mode de gestion des erreurs actuel, entier.
string getMessage : renvoie le message d'erreur complet actuel, chaîne.
Mixed getCallback : renvoie les informations de rappel actuelles, qui peuvent être le nom de la fonction rappelée ou un tableau de (objets, méthodes).
int getCode : renvoie un code d'erreur entier.
string getType : renvoie le mauvais type, qui est le nom de la classe actuelle, string.
string getUserInfo : renvoie des informations utilisateur supplémentaires, une chaîne.
string getDebugInfo : le contenu est le même que ci-dessus.
string toString : renvoie une description détaillée de la chaîne de l'objet actuel, y compris le mode de gestion des erreurs, le niveau, les informations sur l'erreur, le code d'erreur, les fonctions de rappel associées, etc.
résumé
, l'introduction à PEAR est terminée. En résumé, si vous souhaitez créer une application d'extension PEAR, vous devez faire ceci :
require_once "PEAR.php"
Utilisez la classe your_pear_extend extends PEAR{} pour définir votre nouvelle classe.
Dans le constructeur de votre classe, appelez le constructeur de la classe parent PEAR : function your_pear_extend{
$this->POIRE();
...
}
Si nécessaire, définissez votre destructeur _your_pear_extend
Si nécessaire, dérivez votre propre classe de gestion des erreurs à partir de PEAR_Error pour définir votre mode de gestion des erreurs et déclencher des erreurs le cas échéant.
Après avoir exécuté du code pouvant générer des erreurs, utilisez PEAR::isError($obj) pour capturer les erreurs correspondantes.
Implémentez votre propre fonctionnalité.
Dans la dernière version principale de PEAR de PHP4.05, il existe déjà de nombreux excellents modules d'application, tels que : PHPDoc, Cache, HTML... Bien sûr, comparé à CPAN, PEAR n'en est qu'à ses débuts et a besoin de personnes de la communauté PHP. Grâce à nos efforts conjoints pour l'améliorer et l'améliorer, PHP deviendra de plus en plus puissant.
Documents de référence
Page d'accueil Pear Page
d'accueil PHP
La page d'accueil PHPDoc, qui peut générer des documents API de type JAVADOC à partir du code source de votre application PEAR
PHP-Mode pour XEmacs/Emacs, fournit un support de la syntaxe php pour emacs/xemacs et peut bien prendre en charge
la page d'accueil Vim de style code poire. Un très bon éditeur avec un bon support pour PHP
À propos de l'auteur
Pan Fan (Night Sailer) : Ingénieur chez Beijing Saidi Data Co., Ltd. Principalement engagé dans l'analyse et la conversion de données, ainsi que dans les travaux de développement connexes. Bon à utiliser VB, PERL, PHP pour le développement et le travail en chinois sous Linux. Mes intérêts récents sont l'application de Perl, Php et XML, le modèle de développement MVC de PHP et l'utilisation de PERL-GTK. Vous pouvez le contacter par e-mail : [email protected].