PHPs Schatzhausverzeichnis PEAR

Dieser Artikel stellt Ihnen das PEAR-Schatzverzeichnis von PHP vor, das ich hier mit Ihnen teilen kann. Freunde in Not können darauf verweisen.

                                                                      Möglicherweise sind Sie bereits ein PHP-Veteran und haben eine Menge tollen Code geschrieben. Aber wenn Sie sie jetzt zu Ihrem aktuellen Projekt hinzufügen möchten, ist das dann etwas schwierig? Ihr Freund möchte Ihren Code als Modul in seinem Projekt verwenden, aber Sie stellen fest, dass Sie völlig andere Codierungsstile verwenden. Lassen Sie ihn ihn anpassen oder sogar neu schreiben!
Bitte folgen Sie mir und schreiben Sie Ihr PHP-Programm mit dem PEAR-Standard. Ihr Programm und Ihr Code werden einfacher in die Codes anderer Experten integriert. Dies führt dazu, dass PHP funktioniert höhere Energie erzeugen.

Was ist PEARＲ
PEAR ist die Abkürzung für PHP Extension and Application Repository. Es handelt sich um ein Code-Repository für PHP-Erweiterungen und -Anwendungen. Einfach ausgedrückt ist PEAR das CPAN von PHP.

Warum PEAR verwenden?
PHP ist eine sehr hervorragende Skriptsprache, prägnant und effizient. Mit der Veröffentlichung von 4.0 kann man sagen, dass PHP zu einer der besten INTERNET-Entwicklungssprachen geworden ist PHP ist die bevorzugte Sprache, insbesondere für diejenigen Website-Entwickler, die in der Lage sein müssen, kleine und mittlere kommerzielle Anwendungen schnell und effizient zu entwickeln. Da die Anzahl der PHP-Anwendungen jedoch weiter zunimmt, mangelt es an einheitlichen Standards und einer effektiven Verwaltung für diese Anwendungen. Daher ist es für die PHP-Community schwierig, den Code und die Anwendungen untereinander so bequem zu teilen wie die Leute in der PERL-Community , weil PHP die gleichen Standards wie CPAN fehlen. Eine einheitliche Codebasis zur Klassifizierung und Verwaltung von Anwendungscodemodulen (jeder, der mit PERL vertraut ist, weiß, dass CPAN ein riesiges PERL-Erweiterungsmodullager ist. Die geschriebenen Anwendungsmodule können im entsprechenden Klassifizierungsverzeichnis unter abgelegt werden CPAN und andere Leute können es leicht wiederverwenden. Natürlich müssen Sie auch beim Schreiben von Anwendungsmodulen die Richtlinien befolgen.

Aus diesem Grund wurde PEAR ins Leben gerufen und mit dem PHP-Kern verteilt ab 4.04.

Welche Vorteile kann mir PEAR bringen?
1. Wie oben erwähnt, verwaltet PEAR die PEAR-Anwendungscodebibliothek nach bestimmten Kategorien. Ihr PEAR-Code kann in entsprechenden Verzeichnissen organisiert werden, und andere Personen können Ihre Ergebnisse problemlos abrufen und teilen.

2.PEAR ist nicht nur ein Code-Repository, es ist auch ein Standard. Die Verwendung dieses Standards zum Schreiben Ihres PHP-Codes verbessert die Lesbarkeit und Wiederverwendbarkeit Ihres Programms und verringert die Fehlerwahrscheinlichkeit.

3.PEAR erstellt für Sie ein Framework, indem es zwei Klassen zur Implementierung von Funktionen wie Destruktoren und Fehlererkennung bereitstellt. Sie können diese Funktionen durch Vererbung verwenden.

PEAR-Codierungsregeln
PEAR-Codierungsregeln umfassen Einrückungsregeln, Kontrollstrukturen, Funktionsaufrufe, Funktionsdefinitionen, Kommentare, enthaltenen Code, PHP-Tags, Datei-Header-Kommentarblöcke, CVS-Tags, URL-Beispiele. Zum Beispiel die 11 Aspekte der ständigen Benennung. Hier ist eine kurze Einführung:

Einrückungsregeln:
PEAR benötigt 4 Leerzeichen, um den Code einzurücken, und es wird kein TAB verwendet. Wenn Sie VIM verwenden, fügen Sie die folgenden Einstellungen in Ihre ~/.vimrc ein:
set expandtab
set shiftwidth=4
set tabstop=4


Wenn Sie Emacs/ verwenden XEmacs, Sie müssen den Indent-Tabs-Mode auf Null setzen.

Aber wenn Sie wie ich gerne (X)Emacs zum Bearbeiten von PHP-Dateien verwenden, empfehle ich Ihnen dringend, PHP-MODE zu installieren, damit Ihr Einrückungsstil beim Schreiben von PEAR-Code automatisch angepasst wird PHP-MODE verfügt außerdem über viele hervorragende Funktionen. Sie können die neueste Version von PHP-MODE aus der Ressourcenliste herunterladen.

Kontrollstruktur:
Die hier genannten Kontrollstrukturen umfassen: if for while switch usw. Bei Kontrollstrukturen sollte nach dem Schlüsselwort ein Leerzeichen stehen (z. B. if for ..) und dann die Kontrollklammern, damit es nicht zu Verwechslungen mit Funktionsaufrufen kommt. Darüber hinaus sollten Sie versuchen, geschweifte Klammern {} zu verwenden. so vollständig wie möglich, auch wenn es syntaktisch optional ist. Dies verhindert logische Verwirrung oder Fehler, wenn Sie in Zukunft neue Codezeilen hinzufügen müssen. Hier ist ein Beispiel:
if ((condition 1) && (condition 2)) {
Statement 1)
(condition 4)) {
Statement 2;
}else {
Anweisung 3;




Funktionsaufruf: Der Funktionsname und die linke Klammer ( Dazwischen dürfen keine Leerzeichen stehen. Bei Funktionsparametern sollte zwischen dem begrenzenden Komma und dem nächsten Parameter die gleiche Leerzeichentrennung bestehen. Zwischen dem letzten Parameter und der schließenden Klammer darf kein Leerzeichen stehen. Das Folgende ist ein Standardfunktionsaufruf ;
$result = foo($param1, $param2, $param3);
Unregelmäßiges Schreiben:
$result=foo ($param1,$param2,$param3); ( $ param1, $param2, $param3 );




Außerdem muss ein Leerzeichen dazwischen stehen, wenn Sie dem Rückgabeergebnis der Funktion einen Wert zuweisen möchten Wenn es sich um eine Reihe verwandter Zuweisungsanweisungen handelt, fügen Sie außerdem entsprechende Leerzeichen hinzu, um sie auszurichten, etwa so:
$result1 = $foo($param1, $param2, $param3); 🎜>$var2 = $foo($param3);
$var3 = $foo($param4, $param5);




Funktionsdefinition:
Funktionsdefinition folgt der „One True Brace“-Konvention:

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; 
}

Wie oben gezeigt, sollten optionale Parameter am Ende der Parameterliste stehen und immer versuchen, sinnvolle Funktionswerte zurückzugeben.

Zu den Kommentaren:
Für die Online-Dokumentation von Klassen sollte es wie JavaDoc mit PHPDoc konvertierbar sein. PHPDoc ist ebenfalls eine PEAR-Anwendung. Eine ausführlichere Einführung finden Sie unter http://www.phpdoc.de/. Zusätzlich zur Online-Dokumentation von Klassen wird empfohlen, zur Erläuterung Ihres Codes Kommentare zu verwenden, die nicht zur Dokumentation gehören. Wenn Sie einen Codeabschnitt sehen, denken Sie: Oh, ich glaube nicht, dass Sie ihn in der Dokumentation sorgfältig beschreiben müssen . Dann geben Sie diesem Code am besten einen einfachen Kommentar, damit Sie nicht vergessen, wie er funktioniert. Für Kommentarformulare sind Cs /* */ und C++s // beide gut, verwenden Sie jedoch nicht die #-Kommentarmethode von Perl oder Shell.

Code einbinden:
Immer wenn Sie ihn bedingungslos in eine Klassendatei einbinden müssen, müssen Sie require_once verwenden; wenn Sie ihn bedingt in eine Klassendatei einbinden müssen, müssen Sie include_once verwenden Die einzuschließende Datei wird nur einmal eingebunden, und diese beiden Anweisungen verwenden dieselbe Dateiliste, sodass Sie sich keine Sorgen machen müssen, dass die beiden verwechselt werden. Sobald require_once eine Datei einschließt, wird include_once dieselbe Datei nicht erneut einschließen. und umgekehrt.

PHP-Code-Tag:
Verwenden Sie immer bb9bd6d87db7f8730c53cb084e6b4d2d, um Ihren PHP-Code zu definieren, anstatt einfach b26da186e11666e6dd99f28d6205715c zu verwenden. Dies gewährleistet die PEAR-Kompatibilität, was auch für Cross förderlich ist -Plattformportierung.

Kommentaranweisung im Dateikopf:
Für alle PHP-Codedateien, die in die PEAR-Kernversion aufgenommen werden müssen, müssen Sie die folgende Kommentaranweisung am Anfang der Datei hinzufügen:
/ * vim: set expandtab tabstop=4 shiftwidth=4: */

// +--------------------------- ----- --------------------------------------------- --+

// |. PHP-Version 4.0 |. -------------------- ---------------- ----+

// |. Copyright (c) 1997, 1998, 1999, 2000, 2001 The PHP Group |. ----------------------- ------------- ---+

// | Diese Quelldatei unterliegt der Version 2.0 der PHP-Lizenz, |. |. das ist in der Datei LICENSE enthalten und ist im World Wide Web unter

/ | verfügbar. php.net/license/2_02.txt.

// | -wide-web, bitte senden Sie eine Nachricht an

// |, damit wir Ihnen sofort eine Kopie zusenden können. ------------------------------------------------- ---------------- ---+

// |. Autoren: Originalautor

// | >// +---------------------------------- ------------ --------------------------+

//

// $Id$


Für Dateien, die nicht in der PEAR-Kerncodebasis enthalten sind, wird empfohlen, dass Sie auch einen ähnlichen Kommentarblock wie diesen am Anfang der Datei haben, der das Urheberrecht, die Lizenz und den Autor usw. angibt. Fügen Sie gleichzeitig VIMs MODELINE in der ersten Zeile hinzu, damit der PEAR-Codestil in VIM beibehalten werden kann.

CVS-Tag:
Fügen Sie, wie oben gezeigt, das CVS-ID-Tag zu jeder Datei hinzu. Wenn die von Ihnen bearbeitete oder geänderte Datei dieses Tag nicht hat, fügen Sie es bitte hinzu oder ersetzen Sie die Originaldatei (z. B. „Zuletzt geändert“ usw.)

URL-Beispiele:
Sie können sich auf RFC 2606 beziehen und „www.example.com“ als alle URL-Beispiele verwenden.

Konstante Benennung:
Konstanten sollten so weit wie möglich in Großbuchstaben geschrieben werden, um das Verständnis zu erleichtern, verwenden Sie Unterstriche, um jedes Wort zu trennen. Gleichzeitig sollten Sie den Paketnamen oder Klassennamen voranstellen, in dem sich die Konstante befindet. Beispielsweise sollten die Konstanten in der Bug-Klasse mit Bug_ beginnen. Das Obige sind die Codierungsregeln von PEAR. Detaillierte Codierungsregeln finden Sie in der Beschreibung der CODING_STANDDARD-Datei in PEAR. Um diese Codierungsregeln besser zu verstehen, können Sie auch auf den vorhandenen PEAR-Kernmodulcode zurückgreifen.

Erste Schritte mit PEAR erweitert PEAR{
Ihre Klassendefinition...
}




Natürlich müssen Sie sich an die halten Codierungsregeln von PEAR, die zuvor erwähnt wurden, und dann können Sie Ihre Klasse intern implementieren, was Sie tun möchten. Als nächstes wollen wir es besprechen. Tatsächlich stellt uns PEAR zwei vordefinierte Klassen zur Verfügung:
PEAR: Dies ist die Basisklasse von PEAR, und alle PEAR-Erweiterungen müssen von ihr erben und abgeleitet werden.
PEAR_Error: PEARs Fehlerbehandlungs-Basisklasse. Sie können Ihre eigene Fehlerbehandlungsklasse ableiten.

Im Allgemeinen sollten Sie keine Instanz von PEAR direkt erstellen, sondern selbst eine neue Klasse ableiten und dann eine Instanz dieser neuen Klasse erstellen. Als Basisklasse stellt uns PEAR einige nützliche Funktionen zur Verfügung, die wichtigsten sind Destruktor und Fehlerbehandlung

Destruktor
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才会越来越强大。

Das obige ist der detaillierte Inhalt vonPHPs Schatzhausverzeichnis PEAR. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!