Répertoire du trésor de PHP PEAR

Cet article vous présente le répertoire des trésors PEAR de PHP. Je le partage avec vous ici. Les amis dans le besoin peuvent s'y référer

.

                                                                 Vous êtes peut-être déjà un vétéran de PHP et avez é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 aura une plus grande vitalité. Votre programme et votre code seront facilement intégrés aux codes d'autres experts. Comme CPAN pour PERL, cela entraînera PHP. générer une énergie plus élevée.

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 PEAR ?
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. , PHP est le langage préféré, en particulier pour les développeurs de sites Web qui doivent être capables de développer rapidement et efficacement des applications commerciales de petite et moyenne taille. Cependant, à mesure que le nombre d'applications PHP continue d'augmenter, il existe un manque de normes unifiées et de gestion efficace de ces applications. Il est donc difficile pour la communauté PHP de partager le code et les applications des autres 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 facilement. Bien sûr, vous devez également suivre les directives lors de l'écriture des modules d'application )

Pour cette raison, PEAR a été créé et a été distribué avec le noyau PHP. à partir du 4.04.

Quels bénéfices PEAR peut-il m'apporter ?
1. Comme mentionné ci-dessus, PEAR gère la bibliothèque de codes d'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 la probabilité 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 PEAR
Les règles de codage PEAR incluent des règles d'indentation, des structures de contrôle, des appels de fonction, des définitions de fonction, 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. Par exemple, ces 11 aspects de la dénomination constante. 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
set shiftwidth=4
set tabstop=4


Si vous utilisez Emacs/ XEmacs, vous devez définir le mode indent-tabs 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. PHP-MODE possède également de nombreuses excellentes fonctionnalités. Vous pouvez télécharger la dernière version de PHP-MODE à 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 :
if ((condition 1) && (condition 2)) {
Instruction 1
}esleif ((condition 3)
(condition 4)) {
Instruction 2;
}else {
Instruction 3
}




Appel de fonction :
Pour l'appel de fonction, le nom de la fonction et le crochet gauche. ( Il ne doit y avoir aucun espace entre eux. Pour les paramètres de fonction, il doit y avoir la même séparation d'espace entre la virgule de délimitation et le paramètre suivant. Il ne doit y avoir aucun espace entre le dernier paramètre et le crochet fermant. Ce qui suit est un appel de fonction standard ;
$result = foo($param1, $param2, $param3);
Écriture irrégulière :
$result=foo ($param1,$param2,$param3); ( $ param1,$param2, $param3 );




De plus, si vous souhaitez attribuer une valeur au résultat de retour de la fonction, il doit y avoir un espace entre le signe égal et la variable affectée. De plus, s'il s'agit d'une série d'instructions d'affectation liées, vous ajoutez des espaces appropriés pour les aligner, comme ceci :
$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) 
{ 
if (is_array($dsn)) { 
$dsninfo = &&dsn; 
} else { 
$dsninfo = DB::parseDSN($dsn); 
} 

if (!$dsninfo 
!$dsninfo['phptype']) { 
return $this->raiseError(); 
} 
return true; 
}

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 cours, 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, mais n'utilisez pas la méthode de commentaire # de Perl ou du shell.

Inclure le code :
Chaque fois que vous devez l'inclure de manière inconditionnelle dans un fichier de classe, vous devez utiliser require_once ; lorsque vous devez l'inclure de manière conditionnelle dans un fichier de classe, vous devez utiliser include_once ; Le fichier à inclure ne sera inclus qu'une seule fois, et ces deux instructions partagent la même liste de fichiers, vous n'avez donc pas à vous soucier de la confusion une fois que require_once inclut un fichier, include_once n'inclura plus le même fichier, et vice versa.

Balise de code PHP :
Utilisez toujours pour définir votre code php au lieu d'utiliser simplement , cela garantira la compatibilité PEAR, ce qui est également propice au cross -portage plateforme.

Instruction 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,

// | est fourni avec ce package dans le fichier LICENSE et est |

// disponible sur le Web à l'adresse

// | net/license/2_02.txt.

// | Si vous n'avez pas reçu de copie de la licence PHP et ne parvenez pas | -web, veuillez envoyer une note à |

// | licence@php.net 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 pour indiquer le droit d'auteur, la licence, 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.

Balise CVS :
Comme indiqué ci-dessus, ajoutez la balise ID CVS à chaque fichier. Si le fichier que vous éditez ou modifiez n'a pas cette balise, veuillez l'ajouter ou remplacer le fichier similaire d'origine. (comme "Dernière modification", etc.)

Exemples d'URL :
Vous pouvez vous référer à la RFC 2606 et utiliser "www.example.com" comme tous les exemples d'URL.

Nom des constantes :
Les constantes doivent être autant que possible en lettres majuscules. 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 à utiliser PEAR extends PEAR{
Définition de votre classe...
}




Bien sûr, vous devez respecter le codage règles de PEAR mentionnées précédemment, et vous pourrez alors Votre classe implémente en interne ce que vous voulez faire. 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.

De 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 le destructeur et la gestion des erreurs

Destructeur
PHP支持构造函数，但是并不支持析构函数，不过，PHP提供register_shutdown_function()这个函数，从而能够在脚本终止前回调注册的函数，因此PEAR利用这个特性，提供了析构函数的仿真。假如你有一个PEAR的子类，叫做mypear,那么在mypear类中，你可以定义一个函数，函数名是下划线加上你的类名，_mypear(),这个函数就是这个类的析构函数。不过这个析构函数和C++中的析构函数不太一样，它不会在对象被删除的时候执行，而是在脚本结束的时候，毕竟这只是一个仿真。由于是使用了register_shutdown_function()，所以在你的析构函数里，打印的信息将不会返回浏览器中。此外，在你的构造函数中，需要调用一下它的父类的构造函数，因为PHP不会自动调用父类的构造函数，而析构函数需要在PEAR的构造函数中注册，我们可以看看PEAR的源代码：

<code> 
function PEAR() { 
if (method_exists($this, "_".get_class($this))) { 
global $_PEAR_destructor_object_list; 
$_PEAR_destructor_object_list[] = &&this; 
} 
if ($this->_debug) { 
printf("PEAR constructor called, class=%s\n", 
get_class($this)); 
} 
..... 
function _PEAR_call_destructors() { 
global $_PEAR_destructor_object_list; 
if (is_array($_PEAR_destructor_object_list) && sizeof($_PEAR_destructor_object_list)) { 
reset($_PEAR_destructor_object_list); 
while (list($k, $objref) = each($_PEAR_destructor_object_list)) { 
$destructor = "_".get_class($objref); 
if (method_exists($objref, $destructor)) { 
$objref->$destructor(); 
} 
} 
//清空已注册的对象列表， 

//防止重复调用 

$_PEAR_destructor_object_list = array(); 

} 

} 

.... 
register_shutdown_function("_PEAR_call_destructors"); 
</code>

上面这段代码展示了PEAR是如何实现析构函数的,在构件函数中，将检查当前类中是否有析构函数，如果有，那么将把当前类的引用放入一个全局列表中，在_PEAR_call_destructors中，则检查这个全局列表中的每个元素是否存在相应的析构函数，如果有，则调用它，最后将全局列表清空。

在PEAR.php的最后一行代码，则调用register_shutdown_function("_PEAR_call_destructors")，注册_PEAR_call_destructors，这样，当脚本执行完毕的时候，PHP会回调这个函数。使用析构函数，你可以在处理完用户的请求，退出之前做一些必要的"善后"工作，典型的例子是，你可以关闭打开的文件，断开数据库的连接，将某些数据存入磁盘等等。

错误处理
PEAR中可以让你有很多的方式来处理错误，你不仅仅是简单地返回一个错误代码，或者错误的信息，而是可以返回一个PEAR_Error对象，或者是由PEAR_Error派生出来的新的错误对象。

PEAR中的错误对象的并没有限定具体的输出形式，它可以仅仅是捕获错误，不给用户返回太多的信息，也可以是去回调一个特殊错误处理函数，同时，即使输出错误信息，它也强迫你必须要是HTML形式，你可以输出XML，CSV形式，或者是其他你自己定义的形式，你只需要从PEAR_Error派生一个新的类，然后在适当的时候创建并"抛出"这个新类的对象就可以了。

简单的错误处理：
在PEAR中，最简单的错误处理是"抛出"这个错误，你只要简单地创建并返回一个PEAR_Error的对象就可以了。下面是一个简单的例子：

<code> 
function myconnect($host = "localhost", $port = 1080) 
{ 
$fp = fsockopen($host, $port, $errno, $errstr); 
if (!is_resource($fp)) { 
return new PEAR_Error($errstr, $errno); 
} 
return $fp; 
} 

$sock = myconnect(); 
if (PEAR::isError($sock)) { 
print "connect error: ".$sock->getMessage()."<BR>\n" 
} 
</code>

如上面代码所展示的，在执行一段可能产生错误的代码后，你需要使用PEAR的isError来检测是否存在错误，并且可以使用PEAR_Error的getMessage来取得最近一次的错误信息。注意：一定要在关键的地方使用使用PEAR::isError

使用raiseError

PHP4.0.5以后，PEAR多了2个函数：
setErrorHandling($mode, $options = null)
raiseError($message = null, $code = null, $mode = null,$options = null, $userinfo = null)


前者可以设置PEAR缺省的错误处理模式，后者是一个包装函数，返回一个PEAR_Error的对象，和直接创建并返回PEAR_Error的对象略有不同的是，如果省略$mode,$options等参数，它会使用缺省值来创建这个PEAR_Error的对象，这些缺省值你可以使用setErrorHandling()来定制。

PEAR_Error
PEAR_Error是PEAR的错误对象的一个基类，和PEAR不同，一般来说，你可以直接创建PEAR_Error的实例，创建方式：
$error = new PEAR_Error($message, $code, $mode, $options, $userinfo);

$message是你的错误信息，$code是该错误的错误号，后3个参数是紧密联系的：
$mode:是这个错误的处理模式，可以下列常量：
PEAR_ERROR_RETURN：仅仅返回该错误对象（缺省方式）
PEAR_ERROR_PRINT：在构建函数中打印这个错误信息，但是当前程序会继续运行。
PEAR_ERROR_TRIGGER：使用PHP的trigger_error() 触发一个错误，如果你已经设置了错误处理函数，或者你把PHP的错误处理级别设置为E_USER_ERROR，那么当前程序将会被终止。
PEAR_ERROR_DIE：打印错误并退出，程序终止。
PEAR_ERROR_CALLBACK：使用一个回调函数或者方法来处理当前错误，程序终止。
$options：这个参数只有在$mode是PEAR_ERROR_TRIGGER和PEAR_ERROR_CALLBACK的时候才起作用，如果是PEAR_ERROR_TRIGGER，$options必须是E_USER_NOTICE, E_USER_WARNING 或 E_USER_ERROR这3个常量的一个，同PHP中trigger_error的值一致。如果$mode是PEAR_ERROR_CALLBACK，$options可以是一个字符串，内容是要回调的函数名，也可以是一个2元素的数组，分别是一个对象变量，和一个字符串（标明要调用的方法）。
$userinfo:存放附加的用户信息，你可以把相关的调试信息放在这里。

PEAR_Error中有一些常用的方法，这些方法在PHP文挡没有描述，这里一一列出：

int getMode：返回当前的错误处理模式,整型。
string getMessage：返回当前完整的错误信息，字符串。
mixed getCallback：返回当前的回调信息，可能是所回调的函数名，或者是（对象，方法）的数组。
int getCode：返回整型的错误代码。
string getType：返回错误的类型，也就是当前的类名，字符串。
string getUserInfo：返回附加的用户信息，字符串。
string getDebugInfo：内容同上。
string toString：返回当前对象的详细字符串描述，内容包括错误处理的模式，级别，错误信息，错误代码，相关回调函数等等。

总结
至此，对于PEAR的介绍就结束了。概括地说，如果你要做一个PEAR的扩展应用，需要这么做：

require_once "PEAR.php"
使用class your_pear_extend extends PEAR{}定义你的新类。
在你的类的构造函数中，调用父类PEAR的构造函数：
function your_pear_extend{

$this->PEAR();

...
}



如果需要，定义你的析构函数 _your_pear_extend
如果需要，从PEAR_Error派生出你自己的错误处理类
设置你的错误处理模式，并在适当的时候触发错误。
在执行可能产生错误的代码后，用PEAR::isError($obj)捕获相应的错误。
实现你自己的功能。
在最新的PHP4.05的PEAR核心发布里，已经有不少优秀的应用模块了，比如：PHPDoc，Cache,HTML...当然，相对于CPAN来说，PEAR只是刚刚起步，需要PHP社区的人们的共同努力，来完善它，增强它,PHP才会越来越强大。

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!