Wie bereits erwähnt, verwaltet PEAR die Codebasis der PEAR-Anwendung nach bestimmten Kategorien. Ihr PEAR-Code kann in entsprechenden Verzeichnissen organisiert werden, und andere Personen können Ihre Ergebnisse problemlos abrufen und teilen. PEAR ist nicht nur ein Code-Repository, es ist auch ein Standard. Wenn Sie diesen Standard zum Schreiben Ihres PHP-Codes verwenden, verbessern Sie die Lesbarkeit und Wiederverwendbarkeit Ihres Programms und verringern das Fehlerrisiko. PEAR erstellt für Sie ein Framework, indem es zwei Klassen bereitstellt, die Funktionen wie Destruktoren und Fehlererkennung implementieren. Sie können diese Funktionen durch Vererbung verwenden.
Zu den Codierungsregeln von PEAR gehören Einrückungsregeln, Kontrollstrukturen, Funktionsaufrufe, Funktionsdefinitionen, Kommentare, eingebundener Code, PHP-Tags, Datei-Header-Kommentarblöcke, CVS-Tags, URL-Beispiele und die Benennung von Konstanten. Hier 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, nehmen Sie die folgenden Einstellungen in Ihre ~/.vimrc auf: set expandtab
setze Shiftwidth=4
setze tabstop=4
Wenn Sie Emacs/XEmacs verwenden, müssen Sie 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. Natürlich gibt es viele PHP-. MODE Sehr gute Funktion, Sie können die neueste Version von PHP-MODE aus der Ressourcenliste herunterladen.
Kontrollstruktur:
Zu den hier erwähnten Kontrollstrukturen gehören: 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 ((condition1) && (condition2)) {
Aussage 1;
}esleif ((Bedingung 3) || (Bedingung 4)) {
Aussage 2;
}anders {
Aussage 3;
}
Funktionsaufruf:
Bei Funktionsaufrufen sollte zwischen dem Funktionsnamen und der öffnenden Klammer (()) kein Leerzeichen stehen, bei Funktionsparametern sollte zwischen dem begrenzenden Komma und dem nächsten Parameter die gleiche Leerzeichentrennung stehen und zwischen dem letzten kein Leerzeichen stehen Parameter und die schließende Klammer. Unten ist ein Standardfunktionsaufruf;
Unregelmäßiges Schreiben:
$result=foo ($param1,$param2,$param3);
$result=foo( $param1,$param2, $param3 );
Wenn Sie außerdem das Rückgabeergebnis der Funktion zuweisen möchten, muss zwischen dem Gleichheitszeichen und der zugewiesenen Variablen ein Leerzeichen stehen. Wenn es sich gleichzeitig um eine Reihe verwandter Zuweisungsanweisungen handelt, fügen Sie zur Ausrichtung entsprechende Leerzeichen hinzu sie, so: $result1 = $foo($param1, $param2, $param3);
$var2 = $foo($param3);
$var3 = $foo($param4, $param5);
Funktionsdefinition:
Die Funktionsdefinition folgt der Konvention „eine wahre Klammer“: function connect(&$dsn, $persistent = false){
if (is_array($dsn)) {
$dsninfo = &&dsn;
} anders {
$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 von 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 besser einen einfachen Kommentar, damit Sie nicht vergessen, wie er funktioniert. Für Kommentarformulare eignen sich Cs /* */ und C++s //. Verwenden Sie jedoch nicht die #-Kommentarmethode von Perl oder Shell.
Enthält Code:
Wenn Sie eine Klassendatei bedingungslos einschließen müssen, müssen Sie require_once verwenden. Wenn Sie eine Klassendatei bedingt einschließen müssen, müssen Sie include_once verwenden. Dadurch wird sichergestellt, dass die Datei, die Sie einschließen möchten, nur einmal und diese beiden Anweisungen enthalten sind Geben Sie dieselbe Dateiliste frei, sodass Sie sich keine Sorgen machen müssen, dass die beiden verwechselt werden. Sobald require_once eine Datei einschließt, schließt include_once dieselbe Datei nicht erneut ein und umgekehrt.
PHP-Code-Markup:
Definieren Sie jederzeit Ihren PHP-Code, anstatt ihn einfach zu verwenden. Dies gewährleistet die PEAR-Kompatibilität und erleichtert die plattformübergreifende Portierung.
Kommentardeklaration 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 mit diesem Paket in der Datei LICENSE gebündelt ist und |
// |. verfügbar im World-Wide-Web unter |
// |. http://www.php.net/license/2_02.txt |
// |. Wenn Sie keine Kopie der PHP-Lizenz erhalten haben und nicht |
// |. Wenn Sie es über das World Wide Web beziehen möchten, senden Sie bitte eine Nachricht an |
// |. [email protected] , damit wir Ihnen sofort eine Kopie zusenden können
// +-------------------------------- --- --------+
// |. Autoren: Originalautor |
// |. Dein Name |
// +-------------------------------- --- --------+
//
// $Id$
Für Dateien, die nicht zur PEAR-Kerncodebasis gehören, wird empfohlen, am Anfang der Datei auch einen ähnlichen Kommentarblock wie diesen zu verwenden, der Urheberrecht, Lizenz, Autor usw. angibt. Fügen Sie gleichzeitig VIMs MODELINE in der ersten Zeile hinzu, damit der PEAR-Codestil in VIM beibehalten werden kann.
CVS-Markup:
Fügen Sie wie oben gezeigt das CVS-ID-Tag zu jeder Datei hinzu. Wenn die Datei, die Sie bearbeiten oder ändern, dieses Tag nicht hat, fügen Sie es bitte hinzu oder ersetzen Sie es durch einen ähnlichen Ausdruck in der Originaldatei (z. B. „Zuletzt geändert“ usw.). )
URL-Beispiel:
Sie können RFC 2606 befolgen und „ www.example.com “ als alle URL-Beispiele verwenden.
Konstante Benennung:
Konstanten sollten nach Möglichkeit in Großbuchstaben geschrieben werden. Um das Verständnis zu erleichtern, verwenden Sie Unterstriche, um die einzelnen Wörter zu trennen. Gleichzeitig sollten Sie den Paketnamen oder Klassennamen voranstellen, in dem sich die Konstante befindet. Beispielsweise sollten 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 Code des vorhandenen PEAR-Kernmoduls zurückgreifen.
Beginnen Sie mit PEAR
Die Verwendung von PEAR ist sehr einfach, Sie müssen lediglich Ihr eigenes PEAR-Programm wie folgt definieren: require_once "PEAR.php";
Klasse your_class_name erweitert PEAR{
Ihre Klassendefinition...
}
Natürlich müssen Sie sich an die oben genannten PEAR-Codierungsregeln halten und können dann in Ihrer Klasse 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 Basisklasse für die Fehlerbehandlung. 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 Destruktoren und Fehlerbehandlungsdestruktoren
.
PHP unterstützt Konstruktoren, jedoch keine Destruktoren. PHP bietet jedoch die Funktion register_shutdown_function(), die die registrierte Funktion zurückrufen kann, bevor das Skript beendet wird. Daher nutzt PEAR diese Funktion, um eine Simulation des Destruktors bereitzustellen. Wenn Sie eine Unterklasse von PEAR namens mypear haben, können Sie in der Klasse mypear eine Funktion definieren. Der Funktionsname ist ein Unterstrich plus Ihrem Klassennamen, _mypear(). Dieser Destruktor unterscheidet sich jedoch vom Destruktor in C++. Er wird nicht ausgeführt, wenn das Objekt gelöscht wird, sondern wenn das Skript endet. Da register_shutdown_function() verwendet wird, werden die gedruckten Informationen nicht an den Browser in Ihrem Destruktor zurückgegeben. Darüber hinaus müssen Sie in Ihrem Konstruktor den Konstruktor seiner übergeordneten Klasse aufrufen, da PHP nicht automatisch den Konstruktor der übergeordneten Klasse aufruft und der Destruktor im Konstruktor von PEAR registriert werden muss PEAR Quellcode: Funktion PEAR() {
if (method_exists($this, "_".get_class($this))) {
global $_PEAR_destructor_object_list;
$_PEAR_destructor_object_list[] = &this;
}
if ($this->_debug) {
printf("PEAR-Konstruktor aufgerufen, Klasse=%sn",
get_class($this));
}
.....
Funktion _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) = every($_PEAR_destructor_object_list)) {
$destructor = "_".get_class($objref);
if (method_exists($objref, $destructor)) {
$objref->$destructor();
}
}
//Löschen Sie die Liste der registrierten Objekte,
//Wiederholte Anrufe verhindern
$_PEAR_destructor_object_list = array();
}}
....
register_shutdown_function("_PEAR_call_destructors");
Der obige Code zeigt, wie PEAR den Destruktor in der Komponentenfunktion implementiert. Wenn dies der Fall ist, wird die Referenz der aktuellen Klasse in eine globale Liste eingefügt Überprüfen Sie, ob für jedes Element in der globalen Liste ein entsprechender Destruktor vorhanden ist. Wenn ja, rufen Sie ihn auf und löschen Sie schließlich die globale Liste.
Rufen Sie in der letzten Codezeile in PEAR.php register_shutdown_function("_PEAR_call_destructors") auf, um _PEAR_call_destructors zu registrieren, sodass PHP diese Funktion bei der Ausführung des Skripts zurückruft. Mit dem Destruktor können Sie einige notwendige „Nachsorge“-Arbeiten durchführen, bevor Sie nach der Verarbeitung der Benutzeranforderung beenden. Typische Beispiele sind das Schließen geöffneter Dateien, das Trennen der Verbindung zur Datenbank und das Speichern bestimmter Daten auf der Festplatte usw.
Fehlerbehandlung
Mit PEAR können Sie Fehler auf viele Arten behandeln. Sie können nicht nur einfach einen Fehlercode oder Fehlerinformationen zurückgeben, sondern auch ein PEAR_Error-Objekt oder ein neues, von PEAR_Error abgeleitetes Fehlerobjekt zurückgeben.
Das Fehlerobjekt in PEAR schränkt die spezifische Ausgabeform nicht ein. Es kann einfach den Fehler erfassen, ohne zu viele Informationen an den Benutzer zurückzugeben, oder es kann gleichzeitig eine spezielle Fehlerbehandlungsfunktion aufrufen, selbst wenn es Fehlerinformationen ausgibt , es kann auch sein, dass Sie das HTML-Format verwenden müssen. Sie können XML, CSV-Format oder andere von Ihnen definierte Formate ausgeben. Sie müssen nur eine neue Klasse von PEAR_Error ableiten und diese neue Klasse dann erstellen und „werfen“. entsprechenden Zeitpunkt darauf.
Einfache Fehlerbehandlung:
In PEAR besteht die einfachste Fehlerbehandlung darin, den Fehler auszulösen. Sie erstellen einfach ein PEAR_Error-Objekt und geben es zurück. Hier ist ein einfaches Beispiel: 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 „Verbindungsfehler: „.$sock->getMessage().“n“
}
Wie im obigen Code gezeigt, müssen Sie nach der Ausführung eines Codeabschnitts, der möglicherweise einen Fehler erzeugt, isError von PEAR verwenden, um zu erkennen, ob ein Fehler vorliegt, und getMessage von PEAR_Error verwenden, um die neueste Fehlermeldung abzurufen.
und raiseError
verwenden.
Nach PHP4.0.5 verfügt PEAR über zwei weitere Funktionen:
setErrorHandling($mode, $options = null)
raiseError($message = null, $code = null, $mode = null, $options = null, $userinfo = null)
Ersteres kann den Standard-Fehlerbehandlungsmodus von PEAR festlegen, und letzteres ist eine Wrapper-Funktion, die ein PEAR_Error-Objekt zurückgibt. Dies unterscheidet sich geringfügig vom direkten Erstellen und Zurückgeben eines PEAR_Error-Objekts, wenn Parameter wie $mode und $options weggelassen werden Erstellen Sie dieses PEAR_Error-Objekt mit Standardwerten, die Sie mit setErrorHandling() anpassen können.
PEAR_Fehler
PEAR_Error ist eine Basisklasse des PEAR-Fehlerobjekts. Im Allgemeinen können Sie eine Instanz von PEAR_Error direkt erstellen: $error = new PEAR_Error($message, $code, $mode, $options, $ userinfo );
$message ist Ihre Fehlermeldung, $code ist die Fehlernummer des Fehlers und die letzten drei Parameter hängen eng zusammen:
$mode: ist der Fehlerbehandlungsmodus, der die folgenden Konstanten sein kann:
PEAR_ERROR_RETURN: Nur das Fehlerobjekt zurückgeben (Standardmodus)
PEAR_ERROR_PRINT: Gibt diese Fehlermeldung in der Build-Funktion aus, aber das aktuelle Programm wird weiterhin ausgeführt.
PEAR_ERROR_TRIGGER: Verwenden Sie PHPs trigger_error(), um einen Fehler auszulösen. Wenn Sie eine Fehlerbehandlungsfunktion eingerichtet haben oder die Fehlerbehandlungsebene von PHP auf E_USER_ERROR setzen, wird das aktuelle Programm beendet.
PEAR_ERROR_DIE: Fehler ausdrucken und beenden, das Programm wird beendet.
PEAR_ERROR_CALLBACK: Verwenden Sie eine Rückruffunktion oder -methode, um den aktuellen Fehler zu behandeln und das Programm zu beenden.
$options: Dieser Parameter funktioniert nur, wenn $mode PEAR_ERROR_TRIGGER und PEAR_ERROR_CALLBACK ist. Wenn es PEAR_ERROR_TRIGGER ist, muss $options eine der drei Konstanten E_USER_NOTICE, E_USER_WARNING oder E_USER_ERROR sein, was mit dem Wert von trigger_error in PHP übereinstimmt. Wenn $mode PEAR_ERROR_CALLBACK ist, kann $options eine Zeichenfolge sein, die den Namen der zurückzurufenden Funktion enthält, oder ein Array aus zwei Elementen, jeweils einer Objektvariablen und einer Zeichenfolge (die die aufzurufende Methode angibt).
$userinfo: Speichert zusätzliche Benutzerinformationen. Hier können Sie relevante Debugging-Informationen eingeben.
Es gibt einige häufig verwendete Methoden in PEAR_Error, die nicht in der PHP-Dokumentation beschrieben sind. Sie sind hier aufgeführt:
int getMode: Gibt den aktuellen Fehlerbehandlungsmodus zurück, Ganzzahl.
string getMessage: Gibt die aktuelle vollständige Fehlermeldung zurück, string.
gemischter getCallback: Gibt die aktuellen Rückrufinformationen zurück, bei denen es sich um den Namen der Funktion handeln kann, die zurückgerufen wird, oder um ein Array von (Objekten, Methoden).
int getCode: Gibt einen ganzzahligen Fehlercode zurück.
string getType: Gibt den falschen Typ zurück, nämlich den aktuellen Klassennamen string.
string getUserInfo: Gibt zusätzliche Benutzerinformationen zurück, string.
string getDebugInfo: Der Inhalt ist derselbe wie oben.
string toString: Gibt eine detaillierte String-Beschreibung des aktuellen Objekts zurück, einschließlich Fehlerbehandlungsmodus, Ebene, Fehlerinformationen, Fehlercode, zugehörige Rückruffunktionen usw.
Zusammenfassend
ist die Einführung in PEAR beendet. Zusammenfassend lässt sich sagen, dass Sie Folgendes tun müssen, wenn Sie eine PEAR-Erweiterungsanwendung erstellen möchten:
require_once „PEAR.php“
Verwenden Sie die Klasse your_pear_extend erweitert PEAR{}, um Ihre neue Klasse zu definieren.
Rufen Sie im Konstruktor Ihrer Klasse den Konstruktor der übergeordneten Klasse PEAR auf: function your_pear_extend{
$this->PEAR();
...
}
Definieren Sie bei Bedarf Ihren Destruktor _your_pear_extend
Leiten Sie bei Bedarf Ihre eigene Fehlerbehandlungsklasse von PEAR_Error ab, um Ihren Fehlerbehandlungsmodus festzulegen und gegebenenfalls Fehler auszulösen.
Nachdem Sie Code ausgeführt haben, der möglicherweise Fehler generiert, verwenden Sie PEAR::isError($obj), um die entsprechenden Fehler zu erfassen.
Implementieren Sie Ihre eigene Funktionalität.
In der PEAR-Kernversion gibt es bereits viele hervorragende Anwendungsmodule, wie zum Beispiel: PHPDoc, Cache und HTML.