PHP est un langage de programmation réseau efficace En raison de ses avantages d’écriture flexible et d’exécution rapide, il est rapidement devenu le langage préféré des programmeurs Web. Une enquête faisant autorité a récemment montré que 31,6 % des sites Web utilisent désormais PHP comme principal langage de programmation côté serveur.
Cependant, il n’est pas facile de devenir un maître en programmation PHP. Ce n'est pas comme beaucoup de gens l'imaginent, tant que vous pouvez écrire rapidement quelques codes simples pour résoudre un problème complexe, vous êtes un maître en programmation PHP. Un vrai maître PHP doit également prendre en compte de nombreux autres problèmes. Les trois directives suivantes sont les directives qu'un programmeur PHP mature doit d'abord suivre en programmation.
1. La paresse est d'or
2. Écrivez du beau code
3. Recherchez la vitesse de programmation, pas la vitesse de programmation
1. La paresse est d'or
Êtes-vous un programmeur paresseux ? Cette idée est tellement étrange ! Parce que les personnes les plus occupées au monde sont probablement les programmeurs informatiques. Mais c’est précisément parce que les programmeurs sont trop occupés qu’ils devraient apprendre à être paresseux lorsqu’ils programment.
Pour un programmeur, il existe deux manières paresseuses : premièrement, utiliser avec audace les codes de programme prêts à l'emploi d'autres personnes et intégrer ces codes dans vos propres programmes ou projets. La seconde consiste à écrire des codes utiles pour créer une bibliothèque de fonctions, qui peut être facilement utilisée lors de l'écriture de programmes à l'avenir. Cela vous évite beaucoup de travail répétitif et vous rend naturellement moins paresseux.
Ces deux méthodes paresseuses conviennent très bien aux programmeurs PHP.
Tout d’abord, PHP est un langage né et développé dans un environnement libre et ouvert. Il existe des milliers de programmeurs dans le monde qui s'efforcent constamment de perfectionner PHP et sont également prêts à partager leur ingéniosité et le code qu'ils écrivent avec d'autres. Vous pouvez trouver chaque jour de nombreux excellents codes de programme sur certains sites Web PHP, listes de diffusion et groupes de discussion. En disant cela, je ne vous encourage pas à attendre toute la journée que d'autres écrivent du code pour vous, mais vous pouvez « vous tenir sur les épaules de grands hommes » et promouvoir pleinement la « doctrine d'utilisation ». vous fait gagner beaucoup de temps. Deuxièmement, en PHP, vous pouvez facilement créer votre propre bibliothèque de fonctions, ce qui peut vous éviter bien des problèmes lors de l'écriture de programmes à l'avenir.
L'auteur ci-dessous vous présente plusieurs fonctions courantes. Certaines de ces fonctions proviennent de projets open source sur Internet, et certaines sont sélectionnées dans la liste de diffusion. Si vous pouvez les ajouter à votre propre bibliothèque, tôt ou tard, vous en profiterez.
1. Fonctions générales de traitement de base de données
Par rapport aux autres fonctions CGI, l'un des avantages de PHP est qu'il dispose de capacités de traitement de base de données très puissantes. Cependant, en PHP, certaines fonctions spécifiques sont utilisées pour gérer différentes bases de données, et il existe un manque de fonctions générales de traitement des bases de données. Cela réduit considérablement la portabilité du code du programme, ce qui apporte également beaucoup d'inconvénients aux amis programmeurs débutants.
Sur Internet, de nombreux programmeurs ont résolu ce problème en encapsulant des classes. Ils ont écrit des fonctions unifiées pour gérer n'importe quelle base de données populaire, qu'il s'agisse de Mysql, populaire dans le monde Linux, ou de SqlServer, très populaire sur les plates-formes Windows. Personnellement, j'aime beaucoup utiliser ces fonctions, car vous pouvez utiliser directement certaines fonctions simples telles que "query" et "next_record" sans avoir à considérer des choses compliquées telles que les connexions à la base de données et les descripteurs de base de données, sans parler de la base de données que vous utilisez .
Si vous avez besoin de ces fonctions, vous pouvez les obtenir en visitant les URL suivantes :
http://phplib.netuse.de/
http://phpclasses.UpperDesign.com/browse.html/package/20
http://phpdb.linuxbox.com/
http://www.phpchina.com
2. Fonction de débogage variable
Le débogage des programmes PHP a toujours été un casse-tête Il n'a pas d'environnement de compilation et de débogage intégré comme les langages de haut niveau tels que VB, et il n'en a pas non plus. possibilité d'être utilisé dans des programmes PHP comme Perl Exécuter directement sous environnement Linux ou DOS. En fait, nous pouvons terminer le débogage de PHP en utilisant de manière flexible l'instruction echo.
Les fonctions suivantes vous permettent de vérifier à tout moment le type et la valeur de n'importe quelle variable du programme.
fonction ss_array_as_string ($array, $column = 0) {
$str = "Tableau( n";
while(list($var, $val) = each($array)){
pour (＄i = 0 ; $i < $colonne＋1 ; $i＋＋){
$str .= " ";
}
＄str .= ＄var. ==> ;
$str .= ss_as_string($val, $column+1)." n";
}
pour (＄i = 0 ; $i < $colonne ; $i＋＋){
$str .= " ";
}
retourner $str.);
}
fonction ss_object_as_string ($objet, $colonne = 0) {
if (empty(＄object－>classname)) {
renvoie "$objet" ;
} autre {
$str = $object->classname."( n";
while (list(,$var) = each($object->persistent_slots)) {
pour (＄i = 0 ; $i < $colonne ; $i＋＋){
$str .= " ";
}
global$$var;
＄str .= ＄var. ==> ;
$str .= ss_as_string($$var, colonne+1)." n";
}
pour (＄i = 0 ; $i < $colonne ; $i＋＋){
$str .= " ";
}
retourner $str.);
}
}
fonction ss_as_string ($thing, $column = 0) {
si (is_object($chose)) {
return ss_object_as_string(＄thing, ＄column);
}
elseif (is_array($chose)) {
return ss_array_as_string(＄thing, $column);
}
elseif (is_double(＄chose)) {
return "Double(".$thing."");
}
elseif (is_long(＄chose)) {
return "Long(".＄chose."");
}
elseif (is_string(＄thing)) {
return "String(".$thing."");
}
autre {
return "Inconnu(".$thing."");
}
}
Si nécessaire, ajoutez simplement le code suivant au programme pour afficher les types et les valeurs des variables (y compris les tableaux et les objets) utilisées dans le programme :
echo ss_as_string(＄my_variable);
En utilisant l'instruction suivante, nous pouvons visualiser directement les valeurs de toutes les variables du programme :
echo ss_as_string($GLOBALS);
3. Fonctions qui contrôlent les informations du journal
Une autre manière importante de déboguer les programmes PHP consiste à afficher les informations du journal. Si vous pouvez facilement contrôler le niveau des informations du journal et le contenu d'affichage des informations du journal, cela apportera plus de commodité au débogage du programme. Les fonctions suivantes peuvent facilement implémenter cette fonction.
$ss_log_level = 0 ;
$ss_log_filename = /tmp/ss-log;
$ss_log_levels = tableau(
AUCUN => 0,
ERREUR => 1,
INFOS => 2,
DÉBOGAGE => 3);
fonction ss_log_set_level ($level = ERREUR) {
global $ss_log_level ;
$ss_log_level = $niveau ;
}
fonction ss_log (＄niveau, $message) {
global $ss_log_level, $ss-log-filename ;
si ($ss_log_levels[$ss_log_level] < $ss_log_levels[$level]) {
//Ne pas afficher les informations du journal
renvoie faux ;
}
$fd = fopen($ss_log_filename, "a+");
fputs(＄fd, $level. - [.ss_timestamp_pretty().] - .$message."n");
fclose(＄fd);
renvoie vrai ;
}
fonction ss_log_reset () {
global $ss_log_filename ;
@unlink($ss_log_filename);
}
Dans la fonction ci-dessus, il existe quatre variables de niveau journal. Lors de l'exécution d'un programme PHP, les informations du journal peuvent être enregistrées et affichées uniquement lorsque le niveau du journal est inférieur à la valeur de niveau prédéfinie. Par exemple, ajoutez l'instruction suivante au programme :
ss_log_set_level(INFO);
Ensuite, lors de l'exécution d'un programme PHP, seules les informations de niveau ERREUR et INFO LOG peuvent être enregistrées et affichées, et les informations de niveau DEBUG sont ignorées. De plus, nous pouvons également définir le contenu des informations affichées avec les déclarations suivantes :
ss_log(ERREUR, "ERREUR de niveau de test");
ss_log(INFO, "niveau de test INFO");
ss_log(DEBUG, "testing level DEBUG");
Vous pouvez également utiliser l'instruction suivante pour effacer les informations du LOG à tout moment :
ss_log_reset();
4. Fonction de test de vitesse
Afin d'optimiser le code, nous avons besoin d'une méthode capable de tester le temps d'exécution du code pour sélectionner le code optimal. La fonction suivante peut tester le temps nécessaire à l'exécution du code :
function ss_timing_start (＄name = default) {
global $ss_timing_start_times ;
$ss_timing_start_times[$name] = explosion( , microtime());
}
fonction ss_timing_stop ($nom = défaut) {
global $ss_timing_stop_times ;
$ss_timing_stop_times[$name] = exploser(, microtime());
}
fonction ss_timing_current ($nom = défaut) {
global $ss_timing_start_times, $ss_timing_stop_times ;
if (!isset($ss_timing_start_times[$name])) {
renvoie 0 ;
}
if (!isset($ss_timing_stop_times[$name])) {
$stop_time = exploser(, microtime());
}
autre {
$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];
retourner $courant ;
}
Maintenant, nous pouvons facilement vérifier le temps d'exécution de n'importe quel morceau de code. Nous pouvons même utiliser plusieurs timers en même temps. Il nous suffit de définir différents paramètres comme nom du timer lors de l'utilisation des fonctions ci-dessus.
5. Débogage et optimisation des opérations de base de données
Pour les bases de données, la vitesse d'exécution est cruciale. Bien que de nombreux livres et articles enseignent des méthodes permettant d’exécuter rapidement des bases de données, toutes les méthodes doivent être testées dans la pratique. Ensuite, nous combinerons la fonction query() dans la bibliothèque de fonctions PHPLib et les fonctions introduites ci-dessus pour écrire une nouvelle fonction query(). Par rapport à la fonction originale, cette fonction ajoute une fonction de surveillance du temps d'exécution.
fonction requête ($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->Rangée = 0 ;
$this->Errno =mysql_errno();
$this->Erreur =mysql_error();
if (＄halt_on_error && !＄this－>Query_ID) {
$this->halt("SQL invalide : ".$Query_String);
}
return $this－>Query_ID ;
}
2. Écrivez un beau code
1. Séparez le programme back-end du programme front-end
Lors de l'écriture d'un programme PHP, certains codes sont utilisés pour traiter certaines transactions, telles que le fonctionnement de bases de données, l'exécution d'opérations mathématiques, etc., tandis que d'autres sont utilisés. les codes sont uniquement destinés au traitement des transactions. Les résultats sont affichés, comme certains codes PHP qui utilisent l'instruction echo pour afficher les résultats au format HTML sur le navigateur Web et les codes HTML directement intégrés dans le programme PHP. Tout d’abord, nous devons clairement distinguer ces deux types de code, en appelant le premier un programme d’arrière-plan et le second un programme frontal.
Parce que PHP est un langage de programmation intégré, c'est-à-dire que tout le code PHP peut être intégré dans du code HTML, ce qui apporte de nombreuses commodités à l'écriture de programmes. Cependant, si les choses vont à l'extrême, elles doivent être inversées. Si vous mélangez du code PHP et du code HTML dans un programme long, cela rendra le programme désordonné et défavorable à la maintenance et à la lecture du programme. Par conséquent, nous devons autant que possible transplanter le code PHP mélangé au code HTML dans ces programmes, encapsuler ces codes dans des fonctions dans des fichiers spéciaux, puis utiliser l'instruction include dans le code HTML pour inclure ces fichiers à l'emplacement approprié. Appelez simplement ces fonctions.
D'une part, cette approche rend le code HTML et le code PHP simples et faciles à lire. D'autre part, comme le code HTML doit être constamment mis à jour, cette méthode de séparation peut garantir que le programme en arrière-plan ne sera pas détruit. .
Contrairement aux programmes front-end, les programmes back-end recherchent la stabilité, la structure et changent rarement, ils doivent donc être soigneusement conçus et gérés. En fait, cela vaut la peine d'investir beaucoup de temps lors de la conception de programmes de bureau : « Plantez des arbres maintenant et profitez de l'ombre plus tard. » Vous pourrez facilement utiliser les programmes d'arrière-plan que vous écrivez maintenant dans vos futurs travaux de conception.
2. Utilisation flexible des fichiers d'inclusion
Comme mentionné précédemment, les programmes d'arrière-plan doivent être organisés dans une série de fichiers d'inclusion. Les fichiers inclus peuvent être chargés dynamiquement en cas de besoin via l'instruction include, ou ils peuvent être automatiquement chargés à l'avance en utilisant la directive auto_prepend_file dans le fichier php.ini.
Si vous utilisez cette dernière méthode, même si vous en bénéficierez une fois pour toutes, il existe également certaines lacunes qui méritent notre attention. Le morceau de code suivant nous montre combien de temps il faut pour analyser un gros fichier d'inclusion :
require(timing.inc);
ss_timing_start();
include(test.inc);
ss_timing_stop();
écho
.ss_timing_current().
?>
Dans le code ci-dessus, test.inc est un fichier d'inclusion de 1000 lignes. Les résultats d'exécution montrent qu'il faut 0,6 seconde pour analyser ce fichier d'inclusion. Pour un grand site Web, cette vitesse n'est pas négligeable.
Un autre inconvénient de l'utilisation des fichiers d'inclusion est que si une erreur se produit dans une instruction d'un fichier, le programme PHP de l'ensemble du site Web ne pourra pas s'exécuter. Utilisez-le donc avec beaucoup de prudence.
En fait, avec un peu de traitement du fichier d'inclusion, celui-ci ne peut être analysé qu'en cas de besoin. Le code suivant provoque l'analyse du fichier abc.inc uniquement lorsque le programme en a besoin :
if (défini(__LIBA_INC)) return;
définir(__LIBA_INC, 1);
/*
*Coder...
*/
?>
3. Utiliser la méthode de programmation orientée objet
PHP est également un langage orienté objet. La méthode de programmation orientée objet est une méthode de conception de logiciels très respectée par les excellents programmeurs. Dans la programmation PHP, les avantages du langage orienté objet peuvent être pleinement utilisés. . L'avantage est d'encapsuler les objets en programmation. Dans le code précédent, nous avons utilisé une méthode orientée objet. Par exemple, lors de la gestion de la base de données, nous avons encapsulé la fonction query() dans la classe de base de données, ce qui a grandement facilité la gestion du code et augmenté la lisibilité du programme.
3. Recherchez la vitesse du programme plutôt que la vitesse de programmation.
Dans la construction de sites Web, la vitesse d'exécution du programme et la vitesse de téléchargement des pages Web sont des facteurs importants qui déterminent le succès ou l'échec. En tant que programmeur Web, vous devez accorder plus d’attention à la vitesse d’exécution de votre code. Plusieurs méthodes présentées ci-dessous améliorent toutes la vitesse d’exécution du code à des degrés divers.
1. Utilisez du code HTML intégré au lieu de l'instruction echo de PHP.
PHP étant un langage de programmation Web intégré, le code HTML et le code PHP peuvent être intégrés l'un dans l'autre. Cependant, de nombreux programmeurs craignent qu'une utilisation excessive de "" pour intégrer du code PHP dans du code HTML appelle l'interpréteur PHP plusieurs fois, réduisant ainsi la vitesse d'exécution du code PHP. Ils préfèrent donc utiliser l'instruction echo de PHP pour générer du code HTML. Utilisez directement le code HTML. Mais la vérité est exactement le contraire. Chaque page PHP n'appelle l'interpréteur PHP qu'une seule fois pour interpréter tous les codes PHP. Par conséquent, l'intégration de codes PHP uniquement lorsque cela est nécessaire, et la plupart du temps en utilisant directement des codes HTML pour saisir les résultats, non seulement ne réduira pas la vitesse d'exécution du programme, mais également. De plus, étant donné que l'analyse des instructions echo est réduite, la vitesse d'exécution du code peut souvent être améliorée.
Le morceau de code suivant démontre notre conclusion. Dans ce code, nous utilisons la fonction de test temporel introduite précédemment.
Utilisez str-replace au lieu de ereg-replace
Les programmeurs habitués à programmer en Perl sont plus disposés à utiliser ereg_replace pour effectuer le travail de remplacement de chaînes, car l'utilisation de ereg_replace en PHP est similaire à l'utilisation de la correspondance de modèles en Perl. Cependant, le code suivant prouve que l'utilisation de str_replace au lieu de ereg_replace améliorera considérablement la vitesse d'exécution du code.
Testez la vitesse d'exécution de str_replace et ereg_replace
//Ce code teste la vitesse d'exécution de str_replace
accentuation ?>
pour (＄i=0; ＄i<1000; ＄i＋＋) {
str_replace(i>, b>, $string).
}
?>
//Ce code teste la vitesse d'exécution de ereg_replace
pour (＄i=0; ＄i<1000; ＄i＋＋) {
ereg_replace(<([/]＊)i>, <1b>, $string).
}
?>
// Imprimer
la conclusion
du résultaten utilisant le temps str_replace -
Il est temps d'utiliser ereg_pattern -
en exécutant le code ci-dessus, le résultat est :
il est temps d'utiliser str_replace - 0,089757
Il est temps d'utiliser ereg_pattern - 0,248881
D'après les résultats d'exécution, nous pouvons voir que l'utilisation de str_replace au lieu de ereg_replace comme fonction de remplacement de chaîne améliore considérablement la vitesse d'exécution du code.
3. Faites attention aux guillemets de chaîne.
PHP, comme beaucoup d'autres langages de programmation, peut utiliser des guillemets doubles ("") pour citer des chaînes, ou des guillemets simples (). Mais en PHP, si vous utilisez des guillemets doubles pour citer une chaîne, l'analyseur PHP analysera d'abord s'il y a une référence à une variable dans la chaîne. S'il y a une variable, il remplacera la variable. S'il s'agit de guillemets simples, ce n'est pas si compliqué : toutes les chaînes entourées de guillemets simples sont directement affichées. Évidemment, en programmation PHP, il est plus rapide d'utiliser des guillemets simples pour citer des variables de chaîne que des guillemets doubles.
4. Évitez d'utiliser des opérations conjointes dans la base de données.
Comparée à d'autres langages de programmation Web, la fonction de base de données de PHP est très puissante. Cependant, l'exécution de la base de données en PHP reste une tâche très longue et laborieuse. Par conséquent, en tant que programmeur Web, vous devez minimiser les opérations de requête de base de données et établir des index appropriés pour la base de données. Une autre chose à noter est que lorsque vous utilisez PHP pour exploiter une base de données, essayez de ne pas utiliser d'opérations conjointes sur plusieurs tables de données. Bien que les opérations conjointes puissent améliorer la fonction de requête de la base de données, elles augmentent considérablement la charge sur le serveur.
Pour illustrer ce problème, nous pouvons regarder l’exemple simple ci-dessous.
Nous avons créé deux tables de données foo et big_foo dans la base de données. Dans la table de données foo, il n'y a qu'un seul champ contenant tous les nombres naturels de 1 à 1000. La table de données big_foo n'a également qu'un seul champ, mais contient tous les nombres naturels de 1 à 1 000 000. Ainsi, en termes de taille, big_foo est égal à foo combiné avec lui-même.
$db->query("select * from foo");
0,032273 secondes
$db->next_record();
0,00048999999999999 secondes
$db->query("insérer dans les valeurs foo (NULL)");
0,019506 secondes
$db->query("select * from foo as a, foo as b");
17,280596 secondes
$db－>query("select ＊ from foo as a, foo as b où a.id > b.id");
14,645251 secondes
$db－>query("select ＊ from foo as a, foo as b où a.id = b.id");
0,041269 secondes
$db－>query("select * from big_foo");
25,393672 secondes
D'après les résultats de l'opération ci-dessus, nous pouvons constater que la vitesse de jointure de deux tables de données contenant 1 000 enregistrements n'est pas beaucoup plus rapide que l'opération séparée d'une grande table de données comportant 1 000 000 d'enregistrements.
5. Faites attention à la différence entre include et require.
Dans la programmation PHP, include() et require() ont les mêmes fonctions, mais il existe quelques différences d'utilisation. include() est une fonction d'inclusion conditionnelle, tandis que require() l'est. un inconditionnel. Contient des fonctions. Par exemple, dans l'exemple suivant, si la variable $somgthing est vraie, le fichier somefile sera inclus :
if($something){
include("un fichier");
}
Mais quelle que soit la valeur prise par $something, le code suivant inclura le fichier somefile dans le fichier :
if($something){
require("un fichier");
}
L'exemple intéressant suivant illustre la différence entre ces deux fonctions.
$je = 1 ;
tandis que (＄i < 3) {
require("unfichier.$i");
$i++;
}
Dans ce code, le programme inclura le même fichier à chaque boucle. Ce n'est évidemment pas l'intention initiale du programmeur. D'après le code, nous pouvons voir que ce code espère inclure des fichiers différents dans chaque boucle. Si vous souhaitez compléter cette fonction, vous devez vous tourner vers la fonction include() :
$i = 1;
tandis que (＄i < 3) {
include("unfichier.＄i");
$i++;
}
6. Faites attention à la différence entre echo et print
Les fonctions d'echo et d'impression en PHP sont fondamentalement les mêmes, mais il existe des différences subtiles entre les deux. Vous pouvez utiliser print comme une fonction ordinaire dans le code PHP. Par exemple, après avoir exécuté le code suivant, la valeur de la variable $res sera 1.
$ret = print "Hello World";
Cela signifie que print peut être utilisé dans certaines expressions complexes, mais echo ne le peut pas. De même, l'instruction echo s'exécute légèrement plus rapidement que l'instruction print dans le code car l'instruction echo ne nécessite le renvoi d'aucune valeur.