Introduction à PEAR : utilisez PEAR pour écrire votre prochain programme PHP

Introduction à pear : utilisez pear pour écrire votre prochain programme php

Contenu :

Qu'est-ce qu'une poire
Pourquoi utiliser de la poire ?
Quels bienfaits la poire peut-elle m'apporter ?
Les règles d'encodage Pear commencent à utiliser Pear
Résumé des ressources pertinentes et introduction de l’auteur

Pan Fan (voilier de nuit) ( [email protected] )
Pékin Saidi.com Information Technology Co., Ltd.
En juin 2001, vous étiez probablement déjà un vétéran de PHP et aviez écrit beaucoup de code génial. Mais si vous souhaitez les ajouter maintenant à votre projet actuel, est-ce un peu difficile ? Votre ami souhaite utiliser votre code comme module dans son projet, mais vous constatez que vous utilisez des styles de codage complètement différents. Laissez-le l'adapter, voire le réécrire !
Veuillez me suivre et écrire votre programme PHP en utilisant le standard pear. Votre programme et votre code seront facilement intégrés aux codes d'autres experts. Comme cpan pour Perl, cela permettra à PHP de générer une puissance plus élevée.
Qu'est-ce qu'une paire
Pear est l'abréviation de l'extension php et du référentiel d'applications. 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 de la 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 pour ces sites Web. Pour les développeurs qui doivent être capables de développer rapidement et efficacement des applications pour petites et moyennes entreprises, PHP est le langage de choix. 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 la capacité de partager du code et des applications comme 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 la classification appropriée. répertoire sous cpan, et d'autres personnes peuvent très facilement 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 est né et, à partir de la version 4.04, il a été distribué avec le noyau PHP.
Quels bienfaits la poire peut-elle 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 crée un framework pour vous en fournissant 2 classes pour implémenter des fonctions telles que les destructeurs et la détection d'erreurs. Vous pouvez utiliser ces fonctions via l'héritage.
Règles de codage pour la poire
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 contenant, des balises PHP, des blocs de commentaires dans les en-têtes de fichiers, des balises cvs, des échantillons d'URL et la dénomination des constantes. Voici une brève introduction :
Règles d'indentation :
Vous devez utiliser 4 espaces en poire pour indenter le code et ne pas utiliser de tabulations. Si vous utilisez vim, mettez les paramètres suivants dans votre ~/.vimrc :
définir l'onglet Développer
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 le mode php, de sorte que lorsque vous écrivez du code poire, il ajustera automatiquement votre style d'indentation. Bien sûr, le mode php l'a. bien d'autres Fonctionnalité très intéressante, vous pouvez télécharger la dernière version du mode php à partir de 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 :
si ((condition 1) && (condition 2)) {
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 Vous trouverez ci-dessous 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 ceci :
$result1 = $foo($param1, $param2, $param3);
$var2 = $foo($param3);
$var3 = $foo($param4, $param5);

Définition de la fonction :
Les définitions de fonctions suivent la convention « une seule véritable accolade » :
fonction connecter(&$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 poire. 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 la forme des 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 d'utiliser simplement <?> 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 pear core, vous devez ajouter l'instruction de commentaire suivante au début du fichier :
/* vim : set expandtab tabstop=4 shiftwidth=4 : */
// +-------------------------------------------------------------- --- -----------------------+
// |phpversion 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 la licence de fichier 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] 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 pear core, 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. Dans le même temps, la ligne de mode de vim est également ajoutée à la première ligne, afin que le style de code de pear puisse être conservé dans vim.
Balise CV :
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 vous référer à la RFC 2606 et utiliser « http://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_standard dans pear. Afin de mieux comprendre ces règles de codage, vous pouvez également vous référer au code du module pear core existant.
Commencez à utiliser la poire
poire
Utiliser pear est simple, il vous suffit de définir votre propre programme pear comme ceci :
require_once "poire.php";
la classe your_class_name étend la poire {
La définition de votre classe...
}

Bien sûr, vous devez respecter les règles de codage poire mentionnées précédemment, et vous pourrez ensuite implémenter ce que vous voulez faire dans votre classe. Parlons-en ensuite. En fait, pear nous propose 2 classes prédéfinies :
poire : il s'agit de la classe de base de poire, et toutes les extensions poire doivent en hériter et en dériver.
pear_error : La classe de base de la 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 poire, 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 regarder la source de pear. code:
<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 poire 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 = array();
}
}
....
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 y a 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 De cette façon, lorsque le script sera exécuté, PHP rappellera 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. Non seulement vous renvoyez 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 format XML, 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)) {
return new 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 l'erreur de pear pour détecter s'il y a une erreur, et vous pouvez utiliser le getmessage de pear_error pour obtenir le dernier message d'erreur. Remarque : assurez-vous d'utiliser pear::iserror aux endroits clés.
Utiliser raiseerror
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. .
poire_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 en :
$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 : affiche l'erreur et quitte, 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. Ces méthodes 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.
En résumé, l’introduction à la poire est terminée. En résumé, si vous souhaitez faire une application d'extension de poire, vous devez faire ceci :
require_once "poire.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 :
fonction 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.
Ressources connexes
poirePage d'accueil
page d'accueil php
Page d'accueil phpdoc, qui peut générer des documents API similaires à javadoc à partir du code source de votre application pear
Le mode php pour xemacs/emacs, fournit un support de la syntaxe PHP pour emacs/xemacs et peut bien prendre en charge le style de code poire.
la page d'accueil de vim, un très bon éditeur, prend également en charge php