PHP ist eine effiziente Netzwerkprogrammiersprache. Aufgrund seiner Vorteile des flexiblen Schreibens und der schnellen Ausführung hat es sich schnell zur bevorzugten Sprache für Webprogrammierer entwickelt. Eine maßgebliche Umfrage vor nicht allzu langer Zeit ergab, dass 31,6 % der Websites mittlerweile PHP als wichtigste serverseitige Programmiersprache verwenden.
Es ist jedoch nicht einfach, ein PHP-Programmiermeister zu werden. Es ist nicht so, wie viele Leute es sich vorstellen: Solange Sie schnell ein paar einfache Codes schreiben können, um ein komplexes Problem zu lösen, müssen Sie als echter PHP-Meister auch viele andere Probleme berücksichtigen. Die folgenden drei Richtlinien sind die Richtlinien, die ein ausgereifter PHP-Programmierer bei der Programmierung zunächst befolgen sollte.
1. Faulheit ist Gold wert
2. Schreiben Sie schönen Code
3. Verfolgen Sie die Geschwindigkeit des Programmierens, nicht die Geschwindigkeit des Programmierens
1. Faulheit ist Gold
Sind Sie ein fauler Programmierer? Diese Idee ist so seltsam! Denn die wahrscheinlich beschäftigtsten Menschen der Welt sind Computerprogrammierer. Aber gerade weil Programmierer zu beschäftigt sind, sollten sie lernen, beim Programmieren faul zu sein.
Für einen Programmierer gibt es zwei faule Wege: Erstens mutig die vorgefertigten Programmcodes anderer Leute nutzen und diese Codes in eigene Programme oder Projekte integrieren. Die zweite besteht darin, einige nützliche Codes zu schreiben, um eine Funktionsbibliothek zu erstellen, die beim Schreiben zukünftiger Programme problemlos verwendet werden kann. Dies erspart Ihnen viel repetitive Arbeit und macht Sie natürlich weniger faul.
Diese beiden Lazy-Methoden eignen sich sehr gut für PHP-Programmierer.
Erstens ist PHP eine Sprache, die in einer freien und offenen Umgebung geboren und gewachsen ist. Es gibt Tausende von Programmierern auf der ganzen Welt, die ständig nach der Perfektion von PHP streben und auch bereit sind, ihren Einfallsreichtum und den Code, den sie schreiben, mit anderen zu teilen. Auf einigen PHP-Websites, Mailinglisten und Newsgroups finden Sie täglich jede Menge hervorragenden Programmcode. Damit ermutige ich Sie nicht, den ganzen Tag darauf zu warten, dass andere Code für Sie schreiben, sondern Sie können „auf den Schultern großer Männer stehen“ und die „Doktrin der intelligenten Anwendung der Programmcodes anderer Leute“ voll und ganz fördern sparen Sie viel Zeit. Zweitens können Sie in PHP ganz einfach Ihre eigene Funktionsbibliothek erstellen, was Ihnen beim zukünftigen Schreiben von Programmen viel Ärger ersparen kann.
Der folgende Autor stellt Ihnen einige gängige Funktionen vor. Einige dieser Funktionen stammen aus einigen Open-Source-Projekten im Internet, andere wurden aus der Mailingliste ausgewählt. Wenn Sie sie Ihrer eigenen Bibliothek hinzufügen können, werden Sie früher oder später davon profitieren.
1. Allgemeine Datenbankverarbeitungsfunktionen
Im Vergleich zu anderen CGI-Funktionen besteht einer der Vorteile von PHP darin, dass es über sehr leistungsstarke Datenbankverarbeitungsfunktionen verfügt. Allerdings werden in PHP einige spezifische Funktionen zur Handhabung unterschiedlicher Datenbanken verwendet und es mangelt an allgemeinen Datenbankverarbeitungsfunktionen. Dies verringert die Portabilität des Programmcodes erheblich, was auch für Programmieranfänger viele Unannehmlichkeiten mit sich bringt.
Im Internet haben viele Programmierer dieses Problem durch die Kapselung von Klassen gelöst. Sie haben einheitliche Funktionen geschrieben, um jede gängige Datenbank zu verwalten – sei es MySQL, das in der Linux-Welt beliebt ist, oder SqlServer, das auf Windows-Plattformen weit verbreitet ist. Persönlich verwende ich diese Funktionen sehr gerne, da Sie einige einfache Funktionen wie „query“ und „next_record“ direkt verwenden können, ohne komplizierte Dinge wie Datenbankverbindungen und Datenbankhandles berücksichtigen zu müssen, geschweige denn, welche Datenbank Sie verwenden .
Wenn Sie diese Funktionen benötigen, können Sie sie über die folgenden URLs erhalten:
http://phplib.netuse.de/
http://phpclasses.UpperDesign.com/browse.html/package/20
http://phpdb.linuxbox.com/
http://www.phpchina.com
2. Variable Debugging-Funktion
Das Debuggen von PHP-Programmen war schon immer ein Problem. Es gibt keine integrierte Kompilierungs- und Debugging-Umgebung wie Hochsprachen wie VB, und auch nicht Möglichkeit zur direkten Verwendung in PHP-Programmen wie Perl unter Linux oder DOS. Tatsächlich können wir das Debuggen von PHP durch die flexible Verwendung der Echo-Anweisung abschließen.
Mit den folgenden Funktionen können Sie jederzeit den Typ und Wert jeder Variablen im Programm überprüfen.
Funktion ss_array_as_string (&$array, $column = 0) {
$str = "Array( n";
while(list($var, $val) = every($array)){
für (＄i = 0; $i < $column＋1; $i＋＋){
$str .= " ";
}
＄str .= ＄var ==> ;
$str .= ss_as_string($val, $column+1)." n";
}
für (＄i = 0; $i < $column; $i＋＋){
$str .= " ";
}
return $str.);
}
Funktion ss_object_as_string (&$object, $column = 0) {
if (empty(＄object－>classname)) {
return „$object“;
} anders {
$str = $object->classname."( n";
while (list(,$var) = every($object->persistent_slots)) {
für (＄i = 0; $i < $column; $i＋＋){
$str .= " ";
}
global$$var;
＄str .= ＄var ==> ;
$str .= ss_as_string($$var, Spalte+1)." n";
}
für (＄i = 0; $i < $column; $i＋＋){
$str .= " ";
}
return $str.);
}
}
Funktion ss_as_string (&$thing, $column = 0) {
if (is_object($thing)) {
return ss_object_as_string(＄thing, ＄column);
}
elseif (is_array($thing)) {
return ss_array_as_string(＄thing, $column);
}
elseif (is_double(＄thing)) {
return "Double(".$thing.")";
}
elseif (is_long(＄thing)) {
return "Long(".＄thing.")";
}
elseif (is_string(＄thing)) {
return "String(".$thing.")";
}
anders {
return „Unknown(“.$thing.“)“;
}
}
Fügen Sie bei Bedarf einfach den folgenden Code zum Programm hinzu, um die Typen und Werte der im Programm verwendeten Variablen (einschließlich Arrays und Objekte) anzuzeigen:
echo ss_as_string(＄my_variable);
Mit der folgenden Anweisung können wir die Werte aller Variablen im Programm direkt anzeigen:
echo ss_as_string($GLOBALS);
3. Funktionen, die Protokollinformationen steuern
Eine weitere wichtige Möglichkeit, PHP-Programme zu debuggen, ist das Anzeigen von Protokollinformationen. Wenn Sie die Ebene der Protokollinformationen und den Anzeigeinhalt der Protokollinformationen einfach steuern können, wird das Programm-Debuggen komfortabler. Die folgenden Funktionen können diese Funktion problemlos implementieren.
$ss_log_level = 0;
$ss_log_filename = /tmp/ss-log;
$ss_log_levels = array(
KEINE => 0,
FEHLER => 1,
INFO => 2,
DEBUG => 3);
Funktion ss_log_set_level ($level = ERROR) {
global $ss_log_level;
$ss_log_level = $level;
}
Funktion ss_log (＄level, $message) {
global $ss_log_level, $ss-log-filename;
if ($ss_log_levels[$ss_log_level] < $ss_log_levels[$level]) {
//Protokollinformationen nicht anzeigen
return false;
}
$fd = fopen($ss_log_filename, "a+");
fputs(＄fd, $level. - [.ss_timestamp_pretty().] - .$message."n");
fclose(＄fd);
return true;
}
Funktion ss_log_reset () {
global $ss_log_filename;
@unlink($ss_log_filename);
}
In der obigen Funktion gibt es vier Variablen auf Protokollebene. Beim Ausführen eines PHP-Programms können Protokollinformationen nur dann aufgezeichnet und angezeigt werden, wenn die Protokollebene niedriger als der voreingestellte Ebenenwert ist. Fügen Sie dem Programm beispielsweise die folgende Anweisung hinzu:
ss_log_set_level(INFO);
Beim Ausführen eines PHP-Programms können dann nur LOG-Informationen auf ERROR- und INFO-Ebene aufgezeichnet und angezeigt werden, während Informationen auf DEBUG-Ebene ignoriert werden. Darüber hinaus können wir den angezeigten Informationsinhalt auch mit folgenden Anweisungen festlegen:
ss_log(ERROR, „testing level ERROR“);
ss_log(INFO, „Teststufe INFO“);
ss_log(DEBUG, „testing level DEBUG“);
Sie können die LOG-Informationen auch jederzeit mit der folgenden Anweisung löschen:
ss_log_reset();
4. Geschwindigkeitstestfunktion
Um den Code zu optimieren, benötigen wir eine Methode, die die Laufzeit des Codes testen kann, um den optimalen Code auszuwählen. Die folgende Funktion kann die zum Ausführen des Codes erforderliche Zeit testen:
function ss_timing_start (＄name = default) {
global $ss_timing_start_times;
$ss_timing_start_times[$name] = explosion( , microtime());
}
Funktion ss_timing_stop ($name = default) {
global $ss_timing_stop_times;
$ss_timing_stop_times[$name] = explosion(, microtime());
}
Funktion ss_timing_current ($name = default) {
global $ss_timing_start_times, $ss_timing_stop_times;
if (!isset($ss_timing_start_times[$name])) {
0 zurückgeben;
}
if (!isset($ss_timing_stop_times[$name])) {
$stop_time = explosion(, microtime());
}
anders {
$stop_time = $ss_timing_stop_times[$name];
}
$current = $stop_time[1] - $ss_timing_start_times[$name][1];
$current += $stop_time[0] - $ss_timing_start_times[$name][0];
return $current;
}
Jetzt können wir die Ausführungszeit eines beliebigen Codeabschnitts problemlos überprüfen. Wir können sogar mehrere Timer gleichzeitig verwenden. Bei Verwendung der oben genannten Funktionen müssen wir lediglich unterschiedliche Parameter als Namen des Timers festlegen.
5. Debuggen und Optimieren von Datenbankoperationen
Bei Datenbanken ist die Laufgeschwindigkeit entscheidend. Obwohl viele Bücher und Artikel Methoden zum schnellen Ausführen von Datenbanken vermitteln, müssen alle Methoden in der Praxis getestet werden. Als nächstes kombinieren wir die Funktion query() in der PHPLib-Funktionsbibliothek und die oben eingeführten Funktionen, um eine neue Funktion query() zu schreiben. Im Vergleich zur ursprünglichen Funktion fügt diese Funktion eine Laufzeitüberwachungsfunktion hinzu.
Funktion query($Query_String, $halt_on_error = 1) {
$this->connect();
ss_timing_start();
$this->Query_ID = @mysql_query($Query_String,$this->Link_ID);
ss_timing_stop();
ss_log(INFO, ss_timing_current().Secs - .$Query_String);
$this->Row = 0;
$this->Errno =mysql_errno();
$this->Error =mysql_error();
if (＄halt_on_error && !＄this－>Query_ID) {
$this->halt("Ungültiges SQL: ".$Query_String);
}
return $this－>Query_ID;
}
2. Schönen Code schreiben
1. Trennen Sie das Back-End-Programm vom Front-End-Programm.
Beim Schreiben eines PHP-Programms werden einige Codes zum Verarbeiten einiger Transaktionen verwendet, z. B. zum Betreiben von Datenbanken, zum Durchführen mathematischer Operationen usw Codes dienen nur zur Transaktionsverarbeitung, z. B. einige PHP-Codes, die die Echo-Anweisung verwenden, um die Ergebnisse im HTML-Format im Webbrowser anzuzeigen, und solche HTML-Codes, die direkt in das PHP-Programm eingebettet sind. Zunächst sollten wir klar zwischen diesen beiden Arten von Code unterscheiden und ersteres als Hintergrundprogramm und letzteres als Frontend-Programm bezeichnen.
Da es sich bei PHP um eine eingebettete Programmiersprache handelt, kann der gesamte PHP-Code in HTML-Code eingebettet werden, was viele Vorteile beim Schreiben von Programmen mit sich bringt. Wenn die Dinge jedoch ins Extreme gehen, müssen sie umgekehrt werden. Wenn Sie PHP-Code und HTML-Code in einem langen Programm mischen, wird das Programm unübersichtlich und für die Wartung und das Lesen des Programms ungünstig. Daher müssen wir den in diesen Programmen in den HTML-Code eingemischten PHP-Code so weit wie möglich verpflanzen, diese Codes in Funktionen in speziellen Dateien kapseln und dann die Include-Anweisung im HTML-Code verwenden, um diese Dateien an der entsprechenden Stelle einzuschließen. Rufen Sie einfach diese Funktionen auf.
Einerseits macht dieser Ansatz sowohl den HTML-Code als auch den PHP-Code einfach und leicht lesbar. Andererseits kann diese Trennungsmethode sicherstellen, dass das Hintergrundprogramm nicht zerstört wird, da der HTML-Code ständig aktualisiert werden muss .
Im Gegensatz zu Front-End-Programmen streben Back-End-Programme nach Stabilität und Struktur und ändern sich selten. Daher sollten sie sorgfältig entworfen und verwaltet werden. Tatsächlich lohnt es sich, beim Entwerfen von Desktop-Programmen viel Zeit zu investieren: „Jetzt Bäume pflanzen und später den Schatten genießen.“
2. Flexible Nutzung von Include-Dateien
Wie bereits erwähnt, sollten Hintergrundprogramme in einer Reihe von Include-Dateien angeordnet sein. Eingebundene Dateien können bei Bedarf dynamisch über die include-Anweisung geladen werden, oder sie können automatisch im Voraus geladen werden, indem die auto_prepend_file-Direktive in der php.ini-Datei verwendet wird.
Wenn Sie die letztere Methode verwenden, profitieren Sie zwar ein für alle Mal von den Vorteilen, es gibt jedoch auch einige Mängel, die unsere Aufmerksamkeit verdienen. Der folgende Code zeigt uns, wie lange es dauert, eine große Include-Datei zu analysieren:
require(timing.inc);
ss_timing_start();
include(test.inc);
ss_timing_stop();
Echo
.ss_timing_current().
?>
Im obigen Code ist test.inc eine 1000-Zeilen-Include-Datei. Die laufenden Ergebnisse zeigen, dass das Parsen dieser Include-Datei für eine große Website nicht vernachlässigbar ist.
Ein weiterer Nachteil der Verwendung von Include-Dateien besteht darin, dass bei einem Fehler in einer Anweisung in einer Datei das PHP-Programm der gesamten Website nicht ausgeführt werden kann. Gehen Sie daher sehr vorsichtig damit um.
Tatsächlich kann die Include-Datei mit ein wenig Verarbeitung der Include-Datei nur bei Bedarf analysiert werden. Der folgende Code bewirkt, dass die Datei abc.inc nur dann analysiert wird, wenn das Programm sie benötigt:
if (definiert(__LIBA_INC)) return;
define(__LIBA_INC, 1);
/*
* Code...
*/
?>
3. Verwenden Sie die objektorientierte Programmiermethode
. PHP ist auch eine objektorientierte Programmiermethode, die von hervorragenden Programmierern hoch geschätzt wird. Bei der PHP-Programmierung können die Vorteile der objektorientierten Sprache voll ausgenutzt werden Der Vorteil besteht darin, Objekte in der Programmierung zu kapseln. Im vorherigen Code haben wir eine objektorientierte Methode verwendet. Bei der Verwaltung der Datenbank haben wir beispielsweise die Funktion query() in die Datenbankklasse gekapselt, was die Codeverwaltung erheblich erleichtert und die Lesbarkeit des Programms erhöht.
3. Achten Sie eher auf Programmgeschwindigkeit als auf Programmiergeschwindigkeit.
Bei der Website-Erstellung sind die Programmausführungsgeschwindigkeit und die Geschwindigkeit beim Herunterladen von Webseiten wichtige Faktoren, die über Erfolg oder Misserfolg entscheiden. Als Webprogrammierer sollten Sie mehr auf die Ausführungsgeschwindigkeit Ihres Codes achten. Mehrere im Folgenden vorgestellte Methoden verbessern alle die Ausführungsgeschwindigkeit des Codes in unterschiedlichem Maße.
1. Verwenden Sie eingebetteten HTML-Code anstelle der Echo-Anweisung von PHP.
Da PHP eine eingebettete Web-Programmiersprache ist, können HTML-Code und PHP-Code ineinander eingebettet werden. Viele Programmierer befürchten jedoch, dass die übermäßige Verwendung von „“ zum Einbetten von PHP-Code in HTML-Code den PHP-Interpreter mehrmals aufruft und dadurch die Ausführungsgeschwindigkeit von PHP-Code verringert. Daher verwenden sie lieber die Echo-Anweisung von PHP, um HTML-Code auszugeben Direkt HTML-Code verwenden. Aber die Wahrheit ist genau das Gegenteil. Jede PHP-Seite ruft den PHP-Interpreter nur einmal auf, um alle PHP-Codes zu interpretieren. Wenn Sie PHP-Codes nur bei Bedarf einbetten und in den meisten Fällen direkt HTML-Codes zur Eingabe von Ergebnissen verwenden, wird dies nicht nur die Ausführungsgeschwindigkeit des Programms verringern, sondern auch Da auch das Parsen von Echo-Anweisungen reduziert wird, kann die Ausführungsgeschwindigkeit des Codes häufig verbessert werden.
Der folgende Codeabschnitt demonstriert unsere Schlussfolgerung. In diesem Code verwenden wir die zuvor eingeführte Zeittestfunktion.
Verwenden Sie str-replace anstelle von ereg-replace
Programmierer, die mit dem Programmieren in Perl vertraut sind, sind eher bereit, ereg_replace zu verwenden, um String-Ersetzungsarbeiten abzuschließen, da die Verwendung von ereg_replace in PHP der Verwendung des Mustervergleichs in Perl ähnelt. Der folgende Code beweist jedoch, dass die Verwendung von str_replace anstelle von ereg_replace die Ausführungsgeschwindigkeit des Codes erheblich verbessert.
Testen Sie die Laufgeschwindigkeit von str_replace und ereg_replace
// Dieser Code testet die Laufgeschwindigkeit von str_replace
Betonung; ?>
für (＄i=0; ＄i<1000; ＄i＋＋) {
str_replace(i>, b>, $string).
}
?>
//Dieser Code testet die Laufgeschwindigkeit von ereg_replace
für (＄i=0; ＄i<1000; ＄i＋＋) {
ereg_replace(<([/]＊)i>, <1b>, $string).
}
?>
Ergebnisschluss
mit str_replace time
Zeit für die Verwendung von ereg_pattern –
Wenn Sie den obigen Code ausführen, ist das Ergebnis:
Zeit für die Verwendung von str_replace – 0,089757
Zeit für die Verwendung von ereg_pattern - 0,248881
Anhand der Ausführungsergebnisse können wir erkennen, dass die Verwendung von str_replace anstelle von ereg_replace als String-Ersetzungsfunktion die Ausführungsgeschwindigkeit des Codes erheblich verbessert.
3. Achten Sie auf String-Anführungszeichen.
PHP kann, wie viele andere Programmiersprachen auch, doppelte Anführungszeichen ("") verwenden, um Strings in Anführungszeichen zu setzen, oder einfache Anführungszeichen (). Wenn Sie jedoch in PHP doppelte Anführungszeichen verwenden, um eine Zeichenfolge in Anführungszeichen zu setzen, analysiert der PHP-Parser zunächst, ob in der Zeichenfolge ein Verweis auf eine Variable vorhanden ist, und ersetzt die Variable. Wenn es sich um einfache Anführungszeichen handelt, ist es nicht so kompliziert – alle in einfache Anführungszeichen eingeschlossenen Zeichenfolgen werden direkt angezeigt. Offensichtlich ist es bei der PHP-Programmierung schneller, einfache Anführungszeichen als Anführungszeichen für String-Variablen zu verwenden als doppelte Anführungszeichen.
4. Vermeiden Sie die Verwendung gemeinsamer Operationen in der Datenbank.
Im Vergleich zu anderen Web-Programmiersprachen ist die Datenbankfunktion von PHP sehr leistungsfähig. Der Betrieb der Datenbank in PHP ist jedoch immer noch eine sehr zeitaufwändige und arbeitsintensive Angelegenheit. Daher müssen Sie als Webprogrammierer Datenbankabfragevorgänge minimieren und geeignete Indizes für die Datenbank erstellen. Beachten Sie außerdem, dass Sie bei der Verwendung von PHP zum Betreiben einer Datenbank versuchen sollten, keine gemeinsamen Operationen mehrerer Datentabellen zu verwenden. Obwohl gemeinsame Operationen die Abfragefunktion der Datenbank verbessern können, erhöhen sie die Belastung des Servers erheblich.
Um dieses Problem zu veranschaulichen, können wir uns das folgende einfache Beispiel ansehen.
Wir haben zwei Datentabellen foo und big_foo in der Datenbank erstellt. In der Datentabelle foo gibt es nur ein Feld, das alle natürlichen Zahlen von 1 bis 1000 enthält. Die Datentabelle big_foo hat ebenfalls nur ein Feld, enthält aber alle natürlichen Zahlen von 1 bis 1.000.000. Von der Größe her ist big_foo also gleich foo kombiniert mit sich selbst.
$db->query("select * from foo");
0,032273 Sekunden
$db->next_record();
0,00048999999999999 Sek
$db->query("In Foo-Werte einfügen (NULL)");
0,019506 Sekunden
$db->query("select * from foo as a, foo as b");
17,280596 Sek
$db－>query("select ＊ from foo as a, foo as b where a.id > b.id");
14,645251 Sekunden
$db－>query("select ＊ from foo as a, foo as b where a.id = b.id");
0,041269 Sekunden
$db－>query("select * from big_foo");
25,393672 Sekunden
Anhand der obigen Operationsergebnisse können wir feststellen, dass die Geschwindigkeit beim Zusammenführen zweier Datentabellen mit 1.000 Datensätzen nicht viel schneller ist als beim separaten Vorgang einer großen Datentabelle mit 1.000.000 Datensätzen.
5. Beachten Sie den Unterschied zwischen include
() und require () in der PHP-Programmierung, es gibt jedoch einige Unterschiede in der Verwendung. include () ist eine bedingte Einschlussfunktion eine unbedingte Funktion. Wenn beispielsweise im folgenden Beispiel die Variable $somgthing wahr ist, wird die Datei somefile eingefügt:
if($something){
include("somefile");
}
Aber egal welchen Wert $something annimmt, der folgende Code fügt die Datei somefile in die Datei ein:
if($something){
require("somefile");
}
Das folgende interessante Beispiel veranschaulicht den Unterschied zwischen diesen beiden Funktionen.
$i = 1;
while (＄i < 3) {
require("somefile.$i");
$i++;
}
In diesem Code schließt das Programm bei jeder Schleife dieselbe Datei ein. Offensichtlich ist dies nicht die ursprüngliche Absicht des Programmierers. Aus dem Code können wir ersehen, dass dieser Code hofft, in jede Schleife unterschiedliche Dateien aufzunehmen. Wenn Sie diese Funktion vervollständigen möchten, müssen Sie sich der Funktion include() zuwenden:
$i = 1;
while (＄i < 3) {
include("somefile.＄i");
$i++;
}
6. Achten Sie auf den Unterschied zwischen Echo und Print.
Die Funktionen von Echo und Print in PHP sind grundsätzlich gleich, es gibt jedoch subtile Unterschiede zwischen den beiden. Sie können print als normale Funktion im PHP-Code verwenden. Nach der Ausführung des folgenden Codes ist der Wert der Variablen $res beispielsweise 1.
$ret = print "Hello World";
Dies bedeutet, dass print in einigen komplexen Ausdrücken verwendet werden kann, echo jedoch nicht. Ebenso läuft die Echo-Anweisung etwas schneller als die Print-Anweisung im Code, da für die Echo-Anweisung kein Rückgabewert erforderlich ist.