Einführung in Pear: Verwenden Sie Pear, um Ihr nächstes PHP-Programm zu schreiben
Inhalt:
Was ist eine Birne?
Warum Birne verwenden?
Welche Vorteile kann mir Birne bringen?
Die Pear-Kodierungsregeln beginnen mit der Verwendung von Pear
Zusammenfassung relevanter Ressourcen und Vorstellung des Autors
Pan Fan (Nachtsegler) ( [email protected] )
Beijing Saidi.com Information Technology Co., Ltd.
Im Juni 2001 waren Sie wahrscheinlich bereits ein PHP-Veteran und hatten jede 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 lassen sich leicht in die Codes anderer Experten integrieren. Wie bei Perl wird PHP dadurch eine höhere Leistung erzielen.
Was ist ein Paar?
Pear ist die Abkürzung für PHP-Erweiterung und Anwendungs-Repository. Es handelt sich um ein Code-Repository für PHP-Erweiterungen und -Anwendungen. Einfach ausgedrückt ist Pear das CPAN von PHP.
Warum Birne verwenden?
PHP ist eine sehr hervorragende Skriptsprache, prägnant und effizient. Mit der Veröffentlichung von 4.0 verwenden immer mehr Menschen sie zur Entwicklung dynamischer Websites. Man kann sagen, dass PHP zu einer der besten Internet-Entwicklungssprachen geworden ist, insbesondere für diese Websites Entwickler, die in der Lage sein müssen, kleine und mittlere Geschäftsanwendungen schnell und effizient zu entwickeln, ist PHP die Sprache der Wahl. Da es jedoch immer mehr PHP-Anwendungen gibt, mangelt es an einheitlichen Standards und einer effektiven Verwaltung dieser Anwendungen. Daher ist es für die PHP-Community schwierig, ihre Codes und Anwendungen so bequem zu teilen wie die Leute in der Perl-Community PHP fehlt die Möglichkeit, Code und Anwendungen wie Cpan zu teilen. Eine einheitliche Codebasis zur Klassifizierung und Verwaltung von Anwendungscodemodulen (jeder, der mit Perl vertraut ist, weiß, dass es sich bei cpan um ein riesiges Perl-Erweiterungsmodullager handelt. Die geschriebenen Anwendungsmodule können in die entsprechende Klassifizierung eingeordnet werden Verzeichnis unter cpan, und andere Leute können es sehr einfach wiederverwenden, natürlich müssen Sie beim Schreiben von Anwendungsmodulen auch die Richtlinien befolgen.
Aus diesem Grund wurde Pear ins Leben gerufen und ab 4.04 mit dem PHP-Kern verteilt.
Welche Vorteile kann mir Birne bringen?
1. Wie oben 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.
2. Pear ist nicht nur ein Code-Repository, sondern 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.
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.
Kodierungsregeln für Birne
Zu den Codierungsregeln von Pear gehören Einrückungsregeln, Kontrollstrukturen, Funktionsaufrufe, Funktionsdefinitionen, Kommentare, enthaltender Code, PHP-Tags, Kommentarblöcke in Dateikopfzeilen, CVS-Tags, URL-Beispiele und die Benennung von Konstanten. Hier eine kurze Einführung:
Einrückungsregeln:
Sie müssen 4 Leerzeichen in Pear verwenden, um den Code einzurücken, und keine Tabulatoren verwenden. Wenn Sie vim verwenden, nehmen Sie die folgenden Einstellungen in Ihre ~/.vimrc vor:
Erweitern Sie die Registerkarte
setze Shiftwidth=4
set tabstop=4
Wenn Sie emacs/xemacs verwenden, müssen Sie indent-tabs-mode auf nil setzen.
Wenn Sie jedoch wie ich gerne (x)emacs zum Bearbeiten von PHP-Dateien verwenden, empfehle ich Ihnen dringend, den PHP-Modus zu installieren, damit Ihr Einrückungsstil beim Schreiben von Pear-Code automatisch angepasst wird viele weitere Sehr nette 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 ((Bedingung 1) && (Bedingung 2)) {
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 finden Sie einen Standardfunktionsaufruf.
$result = foo($param1, $param2, $param3);
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:
Funktionsdefinitionen folgen der „one true brace“-Konvention:
Funktion 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, genau 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 besser einen einfachen Kommentar, damit Sie nicht vergessen, wie er funktioniert. Für die Form von Kommentaren 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:
Verwenden Sie immer <?php ?>, um Ihren PHP-Code zu definieren, anstatt 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-Core-Version 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 die PHP-Gruppe |
// +-------------------------------- --- --------+
// |. Diese Quelldatei unterliegt der Version 2.0 der PHP-Lizenz, |
// |. das mit diesem Paket in der Dateilizenz 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 in der Lage sind |
// |. Wenn Sie es über das World Wide Web beziehen möchten, senden Sie bitte eine Nachricht an |
// |[email protected] wir Ihnen sofort eine Kopie zusenden können |
// +-------------------------------- --- --------+
// |. Autoren: Originalautor |
// |. Ihr Name |
// +-------------------------------- --- --------+
//
// $id$
Für Dateien, die nicht in der Pear-Core-Codebasis enthalten sind, wird empfohlen, dass Sie am Anfang der Datei auch einen ähnlichen Kommentarblock haben, der das Urheberrecht, die Vereinbarung, den Autor usw. angibt. Gleichzeitig wird der ersten Zeile auch die Modeline von vim hinzugefügt, sodass der Codestil von Pear in vim beibehalten werden kann.
CVS-Tag:
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 sich auf RFC 2606 beziehen und „ http://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 die Konstanten in der Bug-Klasse mit bug_ beginnen. Die oben genannten Codierungsregeln von Pear finden Sie in der Beschreibung der Datei „coding_standard“ in Pear. Um diese Codierungsregeln besser zu verstehen, können Sie auch auf den Code des vorhandenen Pear-Core-Moduls zurückgreifen.
Beginnen Sie mit der Verwendung von Birnen
Birne
Die Verwendung von Pear ist einfach. Sie müssen lediglich Ihr eigenes Pear-Programm wie folgt definieren:
require_once "pear.php";
Klasse your_class_name erweitert Birne{
Ihre Klassendefinition...
}
Natürlich müssen Sie sich an die zuvor erwähnten Pear-Coding-Regeln halten, und dann können Sie das, was Sie tun möchten, in Ihrer Klasse umsetzen. Als nächstes wollen wir es besprechen. Tatsächlich stellt uns Pear zwei vordefinierte Klassen zur Verfügung:
Birne: Dies ist die Basisklasse von Birne, und alle Birnenerweiterungen müssen von ihr erben und abgeleitet sein.
Pear_error: Die Basisklasse der Fehlerbehandlung von Pear. 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 verwendet Pear diese Funktion, um eine Simulation des Destruktors bereitzustellen. Wenn Sie eine Unterklasse von Pear haben, die Mypear heißt, können Sie in der Mypear-Klasse eine Funktion definieren. Der Funktionsname ist ein Unterstrich plus Ihr Klassenname, _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 der übergeordneten Klasse aufrufen, da PHP den Konstruktor der übergeordneten Klasse nicht automatisch aufruft und der Destruktor im Konstruktor von Pear registriert werden muss. Wir können uns die Quelle von Pear ansehen Code:
<Code>
Funktion Birne() {
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");
</code>
Der obige Code zeigt, wie Pear den Destruktor implementiert. In der Komponentenfunktion wird geprüft, ob in der aktuellen Klasse ein Destruktor vorhanden ist. 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. Auf diese Weise ruft PHP diese Funktion zurück, wenn das Skript ausgeführt wird. 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 Sie müssen das HTML-Format verwenden. Sie können das 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:
<Code>
Funktion 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().“<br>n“
}
</code>
Wie im obigen Code gezeigt, müssen Sie nach der Ausführung eines Codeabschnitts, der möglicherweise einen Fehler erzeugt, den iserror von Pear verwenden, um zu erkennen, ob ein Fehler vorliegt, und Sie können die getmessage von Pear_error verwenden, um die neueste Fehlermeldung abzurufen. Hinweis: Stellen Sie sicher, dass Sie an wichtigen Stellen „pear::iserror“ verwenden
Verwenden Sie raiseerror
Nach PHP4.0.5 hat Pear 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 Sie Parameter wie $mode und $options weglassen, werden Standardwerte zum Erstellen des Pear_error-Objekts verwendet. Sie können diese Standardwerte mit seterrorhandling() anpassen. .
Pear_error
Pear_error ist eine Basisklasse des Fehlerobjekts von Pear. Im Allgemeinen können Sie eine Instanz von Pear_error direkt erstellen, indem Sie:
$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: gibt nur das Fehlerobjekt zurück (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 ausgeben 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, die mit dem Wert von „trigger_error“ in PHP übereinstimmt. Wenn $mode „pear_error_callback“ ist, kann „$options“ ein String sein, der den Namen der zurückzurufenden Funktion enthält, oder ein Array aus zwei Elementen, jeweils einer Objektvariablen und einem String (der 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. Diese Methoden werden in der PHP-Dokumentation nicht beschrieben. 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 die Birne beendet. Zusammenfassend lässt sich sagen, dass Sie Folgendes tun müssen, wenn Sie eine Verlängerungsanwendung von Birne durchführen möchten:
require_once „pear.php“
Verwenden Sie die Klasse your_pear_extend extensions pear{}, um Ihre neue Klasse zu definieren.
Rufen Sie im Konstruktor Ihrer Klasse den Konstruktor der übergeordneten Klasse Pear auf:
Funktion 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 neuesten Pear-Core-Version von php4.05 gibt es bereits viele hervorragende Anwendungsmodule, wie zum Beispiel: phpdoc, Cache, HTML ... Im Vergleich zu cpan steht Pear natürlich noch am Anfang und braucht Leute aus der PHP-Community. Durch unsere gemeinsamen Bemühungen, es zu verbessern und zu verbessern, wird PHP immer leistungsfähiger.
Verwandte Ressourcen
BirneHomepage
PHP-Homepage
phpdoc-Homepage, die API-Dokumente ähnlich wie Javadoc aus dem Quellcode Ihrer PEAR-Anwendung generieren kann
PHP-Modus für xemacs/emacs, bietet PHP-Syntaxunterstützung für emacs/xemacs und kann den Pear-Code-Stil gut unterstützen
Die vim-Homepage ist ein sehr guter Editor und bietet auch gute PHP-Unterstützung