PHP Vs. HTML

**Madfrix** · 10/03/2010, 01h21

Bonjour,

je me suis toujours demandé ce qui était le plus rapide en temps d'affichage de la page :

Ca :

Code php :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
 
<html>
<body>
 
toutes mes autres balises html avec quelques ouvertures php pour affichage des variables
 
</body>
</html>

Ou ca :

Code php :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
 
$html = '<html>';
$html .= '<body>';
 
toutes mes autres balises html affichées dans ma variable PHP
 
$html .= '</body>';
$html .= '</html>';
 
echo $html;

En gros, vaut il mieux ouvrir 36000 <?php ?> dans une page ou alors tout mettre dans une variable (concaténation) et afficher tout à la fin ?

J'aurais tendance à dire la 2ieme méthode (moins d'appels serveur) mais comme je suis feignant

j'ai jamais testé sur de grosses quantités de code alors je demande

Merci

**nsanabi** · 10/03/2010, 01h45

ce qui est sur, est qu'en utilisant la seconde façon de faire on perd toutes les possibilités fournies par un éditeur >WYSIWYG, donc une perte de confort au développement.
s'il y a une différence entre les deux en terme de temps d'exécution, je doute quelle soit significative.
le choix en est vite fait pour ma part

J'aurais tendance à dire la 2ieme méthode (moins d'appels serveur)

je ne pense pas que cela soit vrai, une fois que la requête demande un script php le serveur entre en jeux et il exécute la totalité du script, et je ne me rappel pas trop où (ça remonte à des années) j'ai lu que le html en dehors des <?php ?> sera interprété de façon similaire a du <?php echo "html";?>.

**Fench** · 10/03/2010, 08h43

Salut,

Les deux sont pareil niveau affichage html (je ne parle pas du traitement sur le serveur) car dans un premier cas tu as un fichier avec des codes html et dans le deuxième, tu aura exactement la même page ! (puisque à la fin tu fait un echo de ta variable qui contient tous les codes avant de les envoyer)

**ThomasR** · 10/03/2010, 08h58

Bonjour,

Il est clair qu'utiliser la première solution est plus performante, à tous les niveaux...

Ne pas utiliser PHP permet au système d'éviter d'allouer des espaces en mémoire, il ne fait qu'envoyer au buffer.

**RunCodePhp** · 10/03/2010, 08h58

Salut

De mon coté aussi je n'ai pas de doc officiel sous le coude, mais il me semble avoir lu que du HTML brut serait plus rapide de que de le stocker dans une variable, voir plusieurs variables.

Le raisonnement est simple.
Stocker du contenu dans une variable (html ou pas d'ailleurs) c'est de l'espace mémoire alloué au serveur (pc), mais aussi cela demandera une analyse à supplémentaire l'interpréteur Php.
En somme : Pas de <?php ... ?>, pas d'analyse, donc gain en performance.

De plus, il y aurait aussi une différence de performance sur les 2 syntaxes suivantes (les séparateurs) :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
 
$fois = 'fois';
 
// 1/ Séparateur : simple quote (ou apostrophe)
$html = '<div>Il était une $fois ...</div>';
 
// 2/ Séparateur : double quote (ou guillemets)
$html .= "<div>Il était une $fois ...</div>";

Le cas 1 (simple quote) serait plus rapide car il demande aucune analyse supplémentaire, et le $foie n'aura aucun effet.
Il sera afficher : il était une $fois ...

Par contre, pour le cas 2 (double quote), il serait moins performant car l'interpréteur Php devra d'analyser la chaine entière au cas ou il y aurait des variables à interpréter, dans tel cas cela demandera de générer le contenu des variables stocké en mémoire (si on peu dire).
Il sera affiché : il était une fois ...

Le fait d'utiliser des variables devrait donc avoir une incidence sur les performance, théoriquement.
A coté de ça, les serveurs (ou pc) sont de plus en plus performants, des espaces de stockages/mémoires de plus en plus grands aussi, ce qui fait qu'il sera peut être difficile de le percevoir.
Pour s'en rendre compte, il faudrait faire un comparatif sur du contenu très volumineux à mon sens.

Enfin, c'est ce que j'ai pu lire.

**Madfrix** · 10/03/2010, 10h41

Bonjour,

aie j'ai utiliser la seconde méthode

Par contre j'ai utilisé cette méthode que pour l'affichage dans mon div principal par ajax donc ma variable $html ne contient pas enormement de caractères (22k au max). Pour l'optimisation via les simples quotes etc normalement j'ai bien optimisé

Je me suis aidé de cette page qui même si elle n'apprend rien d'extraordinaire donne un ordre d'idée du temps de telle méthode de prog par rapport à une autre.

Bon je vais réfléchir i je change ou pas ma méthode de prog

Merci

**RunCodePhp** · 10/03/2010, 11h25

aie j'ai utiliser la seconde méthode

Bon je vais réfléchir i je change ou pas ma méthode de prog

Faut pas non plus exagérer.

J'utilise un peu à tour de bras le stockage du html dans des variables, ce n'est pas pour autant que le serveur s'écroule, ou met des heures pour générer le html.

Bon, ça dépend de pleins de paramètres, mais si on généralise un peu, ce n'est pas le stockage du HTML dans des variables qui provoquent le plus de lenteur, c'est tout les traitements qu'il y a autour (à mon avis).
Comme faire une requêtes (voir des dizaines, même une centaine qui sait), des alternatives à en plus finir, des manipulations sur des chaine, des calculs, etc, etc ...

C'est l'analyse de tout ça qui va demander d'optimiser ou non son code, comme avoir recourt à toute sorte de mise en cache par exemple.

Donc, faire attention à ne pas stoker tout et n'importe quoi dans des variables, ok, mais ce sont les traitements Php provoquent vraiment des ralentissements, c'est surtout là qu'il faut faire gaffe.

**Petibidon** · 10/03/2010, 11h26

Des éléments de réponse ici :

http://m-fernandez.developpez.com/ar.../bench/#LIII-B

Avis perso, les rapports gain/cout dans chacun des cas est tellement minime que ça vaut pas vraiment le coup de se prendre le chou avec ça.

**Madfrix** · 10/03/2010, 11h38

Merci Petibidon article intéressant

Envoyé par RunCodePhp

Donc, faire attention à ne pas stoker tout et n'importe quoi dans des variables, ok, mais ce sont les traitements Php provoquent vraiment des ralentissements, c'est surtout là qu'il faut faire gaffe.

Oui c'est sur par contre j'avais remarqué quelque chose de bizarre sur un bout de code (que je n'ai plus) : lors de la manipulation de tableau php de grande capacité > 100k éléments, lors d'une boucle foreach par exemple j'obtenais un out of memory si j'incidais mon tableau moi meme ($tab[$i]=...; $i++) au lieu de le laisser faire automatiquement ($tab[]=...) j'ai jamais compris pourquoi

Sinon, comme le post commence à dévier, qui aurait des idées idées d'optimisation de ce bout de code me servant à simuler un combat entre 2 troupes

Code php :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
 
//On calcule le niveau d'anticipation
if(($attaquant_technologie['anticipation'] - $defenseur_technologie['anticipation']) > 0){
	$rand_attaquant = number_format(50 + ($attaquant_technologie['anticipation'] - $defenseur_technologie['anticipation']) * 5 / 2, 0);
	$rand_defenseur = 100 - $rand_attaquant;
	}else if(($defenseur_technologie['anticipation'] - $attaquant_technologie['anticipation']) > 0){
		$rand_defenseur = number_format(50 + ($defenseur_technologie['anticipation'] - $attaquant_technologie['anticipation']) * 5 / 2, 0);
		$rand_attaquant = 100 - $rand_defenseur;
	}else{
			$rand_attaquant = 50;
			$rand_defenseur = 50;
		}
 
 
if(isset($defenseur)){
 
	$round=1;
 
	while($round<=5 && !empty($attaquant) && !empty($defenseur)){
 
		shuffle($attaquant);
		shuffle($defenseur);
 
		if(count($attaquant) >= count($defenseur)){
			$grand='attaquant';
			$petit='defenseur';
		}else{
			$grand='defenseur';
			$petit='attaquant';
		}
 
		$residu = array_diff_key(${$grand}, ${$petit});
 
		foreach(${$petit} as $cle=>$valeur){	
 
			//l'attaquant attaque le premier sinon c'est le defenseur
			if((mt_rand(1, 100) <= $rand_attaquant)){
				//Calcul du coup critique eventuel (X5)
				(mt_rand(1, 100) <= $unites_desc_attaquant[$attaquant[$cle]['type']]['coup_critique']) ? $coup_critique_attaquant = 5 : $coup_critique_attaquant = 1;
				$degats = $coup_critique_attaquant * $attaquant[$cle]['valeur_attaque'] * (100 - $unites_desc_defenseur[$defenseur[$cle]['type']][$attaquant[$cle]['type_attaque']]) / 100 - $unites_desc_defenseur[$defenseur[$cle]['type']]['armure'];
				if($degats > 0) 		
					$defenseur[$cle]['vie'] -= $degats;
 
				//Si l'unité du defenseur est vivante elle contre attaque si elle ne l'a pas déjà fait auparavant sur une autre unité 
				if($defenseur[$cle]['vie'] <= 0){
					$defenseur_pertes[$defenseur[$cle]['type']][$round]++;
					unset($defenseur[$cle]);
				}else{
					(mt_rand(1, 100) <= $unites_desc_attaquant[$attaquant[$cle]['type']]['coup_critique']) ? $coup_critique_defenseur = 5 : $coup_critique_defenseur = 1;
					$degats = $coup_critique_defenseur * $defenseur[$cle]['valeur_attaque'] * (100 - $unites_desc_attaquant[$attaquant[$cle]['type']][$defenseur[$cle]['type_attaque']]) / 100 - $unites_desc_attaquant[$attaquant[$cle]['type']]['armure'];
 
					if($degats > 0){ 		
						$attaquant[$cle]['vie'] -= $degats;
						if($attaquant[$cle]['vie'] <= 0){
							$attaquant_pertes[$attaquant[$cle]['type']][$round]++;
							unset($attaquant[$cle]);
						}
					}	
				}
 
			}else{
				//Calcul du coup critique eventuel (X5)
				(mt_rand(1, 100) <= $unites_desc_defenseur[$defenseur[$cle]['type']]['coup_critique']) ? $coup_critique_defenseur = 5 : $coup_critique_defenseur = 1;
				$degats = $coup_critique_defenseur * $defenseur[$cle]['valeur_attaque'] * (100 - $unites_desc_attaquant[$attaquant[$cle]['type']][$defenseur[$cle]['type_attaque']]) / 100 - $unites_desc_attaquant[$attaquant[$cle]['type']]['armure'];
				if($degats > 0) 		
					$attaquant[$cle]['vie'] -= $degats;
 
				//Si l'unité du defenseur est vivante elle contre attaque si elle ne l'a pas déjà fait auparavant sur une autre unité 
				if($attaquant[$cle]['vie'] <= 0){
					$attaquant_pertes[$attaquant[$cle]['type']][$round]++;
					unset($attaquant[$cle]);
				}else{
					(mt_rand(1, 100) <= $unites_desc_defenseur[$defenseur[$cle]['type']]['coup_critique']) ? $coup_critique_attaquant = 5 : $coup_critique_attaquant = 1;
					$degats = $coup_critique_attaquant * $attaquant[$cle]['valeur_attaque'] * (100 - $unites_desc_defenseur[$defenseur[$cle]['type']][$attaquant[$cle]['type_attaque']]) / 100 - $unites_desc_defenseur[$defenseur[$cle]['type']]['armure'];
 
					if($degats > 0){ 		
						$defenseur[$cle]['vie'] -= $degats;
						if($defenseur[$cle]['vie'] <= 0){
							$defenseur_pertes[$defenseur[$cle]['type']][$round]++;
							unset($defenseur[$cle]);
						}
 
					}	
				}
 
			}
 
		}
 
		//Remise  à jour du petit tableau
		${$petit} = array_values(${$petit});
		$cle2=0;		
 
		foreach($residu as $cle=>$valeur){
 
			if(!isset(${$petit}[$cle2]) && !empty(${$petit})){
				$cle2=0;
				${$petit} = array_values(${$petit});
			}else if(empty(${$petit})){
				break;
			}
 
			//Calcul du coup critique eventuel (X5)
			(mt_rand(1, 100) <= ${'unites_desc_'.$grand}[${$grand}[$cle]['type']]['coup_critique']) ? $coup_critique_{$grand} = 5 : $coup_critique_{$grand} = 1;
			$degats = $coup_critique_{$grand} * ${$grand}[$cle]['valeur_attaque'] * (100 - ${'unites_desc_'.$petit}[${$petit}[$cle2]['type']][${$grand}[$cle]['type_attaque']]) / 100 - ${'unites_desc_'.$petit}[${$petit}[$cle2]['type']]['armure'];
			if($degats > 0) 		
				${$petit}[$cle2]['vie'] -= $degats;
 
			//Si l'unité du defenseur est vivante elle contre attaque si elle ne l'a pas déjà fait auparavant sur une autre unité 
			if(${$petit}[$cle2]['vie'] <= 0){
				${$petit.'_pertes'}[${$petit}[$cle2]['type']][$round]++;
				unset(${$petit}[$cle2]);
			}
 
			$cle2++;
 
		}
 
		//Remise à jour des tableaux
		$attaquant = array_values($attaquant);
		$defenseur = array_values($defenseur);
 
		$round++;
	}
}

Merci

**nsanabi** · 10/03/2010, 12h06

Envoyé par Madfrix

Sinon, comme le post commence à dévier, qui aurait des idées idées d'optimisation de ce bout de code me servant à simuler un combat entre 2 troupes

n'est ce pas plutôt toi qui fait dévier la discussion? car je ne vois pas le rapport entre ta toute première question et la dernière, et je suppose que pour ta seconde il va falloir créer un autre sujet

**RunCodePhp** · 10/03/2010, 12h10

Effectivement, cet article a l'air intéressant.

Cela permet d'éviter les allers-retours incessants entre le serveur et le navigateur dus à la répétition des echos d'où un gain de temps plus que conséquent.

Je réagi cependant à la remarque de cet article qui me semble véhiculer une idée fausse : que chaque echo feraient un aller/retour entre le serveur et le navigateur.

Il me semble pas, un echo donne l'instruction au serveur de stocker les données qui s'y trouvent dans une mémoire, et une fois la page entièrement analysée/interprétée, tout ce contenu mis en mémoire est renvoyée d'un block, le flux HTML dans son intégralité.
Sauf erreur, les données sont renvoyées qu'une fois.

Je ne sais pas si ce test est fiable pour le démontrer, il me semble que oui :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
 
echo 'Avant la pause<br />';
sleep(10); // Pause de 10 secondes
echo 'Après la pause<br />';

Ici, on pourrait croire voir afficher en 1er "Avant la pause", puis après 10 secondes de pause, voir afficher "Après la pause".
Il en est rien, on reçois les 2 echo au même moment, au bout de 10 secondes.

**nsanabi** · 10/03/2010, 12h35

out ce contenu mis en mémoire est renvoyée d'un block, le flux HTML dans son intégralité.
Sauf erreur, les données sont renvoyées qu'une fois.

alors pourquoi avec ce code

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
 
<?php
echo 'Salut !';
header('Location: page.php');
?>

il y a une erreur

Warning: Cannot modify header information - headers already sent

effectivement il est possible d'utiliser en php un output buffer avec la fonction ob_start().

mais comme toi j'estime que dans tout les cas il n'y a pas des allez-venue du client vers serveur pour chaque echo

j'edite :
je viens de faire quelques tests, et apparemment le warning ne s'affiche plus, j'ai testé aussi avec la fonction session_start() qui générait "normalement" une erreur si elle est appelé après un quelconque envoi vers le client, mais il n y a aucune erreur apparente. tout se déroule normalement.
je suppose que dans les versions précédente de php il faillait gérer le fameux outputbuffer manuellement, et que maintenant (j'ai un php 5.2.8) le buffer est pris en charge automatiquement. ou bien il y a un autre truc

**RunCodePhp** · 10/03/2010, 12h51

alors pourquoi avec ce code

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
 
<?php
echo 'Salut !';
header('Location: page.php');
?>

il y a une erreur

C'est normal et logique.
Ce sont 2 instructions contradictoires, Php estime quelle est suffisamment grave pour en générer une erreur.

D'un coté du dis à Php de vouloir afficher un contenu pour vers une page, et tout de suite après tu change d'avis tu lui dit de faire une redirection sur autre page.
Php perd la boule : C'est contradictoire.

Imagine une tour de contrôle qui donne l'ordre à un A380 de décoller.
Le pilote met les gaz, se lance à toute vitesse sur la piste.
Dans la seconde qui suit, on lui dit d'arrêter.
Il fait comment le pilote, il met le frein à main

**ThomasR** · 10/03/2010, 13h36

Envoyé par RunCodePhp

D'un coté du dis à Php de vouloir afficher un contenu pour vers une page, et tout de suite après tu change d'avis tu lui dit de faire une redirection sur autre page.
Php perd la boule : C'est contradictoire.:

Ce n'est pas du tout çà.

header permet d'envoyer des entêtes au navigateur (PHP ne sait pas ce qu'est une redirection).

Dans l'ordre d'envoi des infos au navigateur c'est :
entêtes
contenu

De plus, si il a activé l'output buffering ou qu'il utilise manuellement un buffer (ob_*) ce code est tout à fait valide. Aussi, header n'arrête pas l'execution du script, donc si je prend ton exemple rien ne dit au pilote de s'arrêter.

**RunCodePhp** · 10/03/2010, 13h50

Il y aurait donc rien d'illogique à faire :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
 
echo 'hello';
header('Location: machin.php');
header('Location: truc.php');
echo 'Wold';

En somme, rien de plus normal que de renvoyer 50 entêtes différentes.

Et puis, qu'en est il de ce qui est écrit dans le tuto :

Cela permet d'éviter les allers-retours incessants entre le serveur et le navigateur dus à la répétition des echos d'où un gain de temps plus que conséquent.

Fait on autant d'aller/retours entre le serveur/navigateur qu'il y a de echo ?

**nsanabi** · 10/03/2010, 13h58

Envoyé par ThomasR

De plus, si il a activé l'output buffering ou qu'il utilise manuellement un buffer (ob_*) ce code est tout à fait valide.

comment l'activer ou le désactiver ?

**ThomasR** · 10/03/2010, 14h06

Envoyé par nsanabi

comment l'activer ou le désactiver ?

Dans php.ini

Envoyé par RunCodePhp

Il y aurait donc rien d'illogique à faire :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
 
echo 'hello';
header('Location: machin.php');
header('Location: truc.php');
echo 'Wold';

En somme, rien de plus normal que de renvoyer 50 entêtes différentes.

Je ne vois pas le rapport avec ce que j'ai dit ? Bien sûr que c'est illogique... soyons sérieux

Et puis, qu'en est il de ce qui est écrit dans le tuto :
Fait on autant d'aller/retours entre le serveur/navigateur qu'il y a de echo ?

Oui, par défaut flush est appelé après chaque envoi au buffer. PHP préfère envoyer un gros paquet plutôt que de multiples petits paquets.

**Petibidon** · 10/03/2010, 15h07

Envoyé par ThomasR

Oui, par défaut flush est appelé après chaque envoi au buffer. PHP préfère envoyer un gros paquet plutôt que de multiples petits paquets.

Tu voulais dire le contraire ?
PHP ne flush pas systématiquement, sinon il enverrait une multitude de petits paquets et l'exemple donné par RunCodePhp n'aurait pas le même comportement. Tu peux forcer PHP à vider le buffer avec la fonction flush() par contre.

**RunCodePhp** · 10/03/2010, 15h13

Envoyé par ThomasR

Oui, par défaut flush est appelé après chaque envoi au buffer. PHP préfère envoyer un gros paquet plutôt que de multiples petits paquets.

Envoyer des paquets, d'accord, mais est ce réellement au navigateur que Php les envoient ?
Ce ne serait pas plutôt à Apache, et que celui ci une fois obtenu tous les paquets, Php et Html, se chargerait de les envoyer, d'un bloc ?
C'est Apache le serveur Web, Php n'est qu'un interpréteur, c'est pas lui qui gère la réception/envoie des données il me semble.

Enfin, c'est la représentation que j'en ais.
Elle est peut être fausse, ceci dit.

Envoyé par RunCodePhp

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
 
echo 'Avant la pause<br />';
sleep(10); // Pause de 10 secondes
echo 'Après la pause<br />';

Ici, on pourrait croire voir afficher en 1er "Avant la pause", puis après 10 secondes de pause, voir afficher "Après la pause".
Il en est rien, on reçois les 2 echo au même moment, au bout de 10 secondes.

Je suis curieux de savoir comment faire, quelle config, je pourrais d'abord voir afficher le 1er echo, et 10 secondes après le 2ème echo dans un navigateur.
Avec uniquement ces 3 lignes de codes.

S'il faut avoir recourt à des config, ou des sur-couche de codes supplémentaires, alors on ne rentre plus dans une généralité mais une spécificité, un cas particulier en somme.
Donc cette phrase dans la doc, bien quelle ne soit pas totalement fausse (encore que), ne ferait que véhiculer une idée fausse.
Enfin, c'est mon avis.

**ThomasR** · 10/03/2010, 16h32

Envoyé par Petibidon

Tu voulais dire le contraire ?
PHP ne flush pas systématiquement, sinon il enverrait une multitude de petits paquets et l'exemple donné par RunCodePhp n'aurait pas le même comportement. Tu peux forcer PHP à vider le buffer avec la fonction flush() par contre.

Exact : http://www.php.net/manual/fr/outcont...implicit-flush

PHP Vs. HTML

Langage PHP

Discussions similaires

Partager

Partager