Je trouve dommage que l'auteur du site n'indique ni à quelle date ont été réalisés les tests ni même la version de PHP utilisée. N'y a-t-il pas des cas qui s'améliorent avec le temps, surtout depuis que PHP a changé de compilateur ? Cela dit, ça reste informatif.

echo 'hello';

number of ops:  3
compiled vars:  none
line     # *  op                           fetch          ext  return  operands
---------------------------------------------------------------------------------
   2     0  >   EXT_STMT                                                 
         1      ECHO                                                     'hello'
         2    > RETURN                                                   1

branch: #  0; line:     2-    2; sop:     0; eop:     2

echo "hello";

number of ops:  3
compiled vars:  none
line     # *  op                           fetch          ext  return  operands
---------------------------------------------------------------------------------
   2     0  >   EXT_STMT                                                 
         1      ECHO                                                     'hello'
         2    > RETURN                                                   1

branch: #  0; line:     2-    2; sop:     0; eop:     2

$text = 'hello';
echo "$text";

number of ops:  6
compiled vars:  !0 = $text
line     # *  op                           fetch          ext  return  operands
---------------------------------------------------------------------------------
   2     0  >   EXT_STMT                                                 
         1      ASSIGN                                                   !0, 'hello'
   3     2      EXT_STMT                                                 
         3      ADD_VAR                                          ~1      !0
         4      ECHO                                                     ~1
         5    > RETURN                                                   1

branch: #  0; line:     2-    3; sop:     0; eop:     5

$text = 'hello';
echo $text;

number of ops:  5
compiled vars:  !0 = $text
line     # *  op                           fetch          ext  return  operands
---------------------------------------------------------------------------------
   2     0  >   EXT_STMT                                                 
         1      ASSIGN                                                   !0, 'hello'
   3     2      EXT_STMT                                                 
         3      ECHO                                                     !0
         4    > RETURN                                                   1

branch: #  0; line:     2-    3; sop:     0; eop:     4

[quote="liens_geeks"]stealth35, ça veut dire quoi ta phrase concernant "l'opcode", que ce n'est pas complètement fiable ce genre de tests?
Merci d'avance[/quote]

pour exécuter un fichier PHP y'a plusieurs étape, dont une de compilation, de code est converti en opcode (voir l'extension VLD) après un phase de tokenization, l'opcode ressemble a de l'assembleur, c'est ce code qui est exécuté

donc : tokenization -> compilation -> exécution
tout ce qui est compté en terme de temps (avec microtome et compagnie) débute uniquement a partir de l'exécution, tout ce qui avant n'est pas pris en compte,
Un extension comme APC permet de ne faire qu'une seule fois les deux première étape, puisque pour un mémé script l'opcode reste le même, ça fait du travaille en moins donc l'appli est plus rapide

et le fameux débat entre les double quote et single avec bench a l'appuie est ridicule puisque cette déférence est subite au moment de la tokenization donc incalculable au moment de l'exécution

[b]Exemple :[/b]
[b]echo 'hello'; [/b]VS[b] echo "hello";[/b]

[php]echo 'hello';[/php][php]number of ops: 3
compiled vars: none
line # * op fetch ext return operands
---------------------------------------------------------------------------------
2 0 > EXT_STMT
1 ECHO 'hello'
2 > RETURN 1

branch: # 0; line: 2- 2; sop: 0; eop: 2
[/php]
[php]echo "hello";[/php][php]number of ops: 3
compiled vars: none
line # * op fetch ext return operands
---------------------------------------------------------------------------------
2 0 > EXT_STMT
1 ECHO 'hello'
2 > RETURN 1

branch: # 0; line: 2- 2; sop: 0; eop: 2
[/php]

c'est pareil

par contre, faire ça c'est pas top

[php]$text = 'hello';
echo "$text";[/php][php]number of ops: 6
compiled vars: !0 = $text
line # * op fetch ext return operands
---------------------------------------------------------------------------------
2 0 > EXT_STMT
1 ASSIGN !0, 'hello'
3 2 EXT_STMT
3 ADD_VAR ~1 !0
4 ECHO ~1
5 > RETURN 1

branch: # 0; line: 2- 3; sop: 0; eop: 5
[/php]

[php]$text = 'hello';
echo $text;[/php][php]number of ops: 5
compiled vars: !0 = $text
line # * op fetch ext return operands
---------------------------------------------------------------------------------
2 0 > EXT_STMT
1 ASSIGN !0, 'hello'
3 2 EXT_STMT
3 ECHO !0
4 > RETURN 1

branch: # 0; line: 2- 3; sop: 0; eop: 4[/php]

[quote="stealth35"]Donc l'indication que tu donne stealth35 déplace le comptage [b]dans la première partie qui n'est exécutée qu'une seule fois[/b] au lieu de la laisser dans la seconde où elle sera exécutée à chaque tour. [b]Ainsi, un count va ou non être exécuté plusieurs fois...[/b] pour retourner toujours le même résultat, répétition qui, tu en conviendras, est totalement sans intérêt[/quote]

je pense que le Ainsi donne un sens bizarre à ton explication (que j'ai déjà donnée)

[quote="xTG"]En effet, mais c'est assez tordu tout de même comme écriture...
Jamais je n'aurai pu imaginer qu'on puisse écrire plusieurs lignes de code (et non des expressions) dedans. :shock:[/quote]
Ce n'est pas si tordu que ça : un « for » attend trois expressions en paramètres :
[list=1]
[*]Une ou plusieurs expressions séparées par des virgules définissant une situation au lancement de la boucle : ces expressions ne seront exécutées qu'une unique fois avant le premier tour;
[*]Une expression retournant un booléen indiquant si on doit ou non continuer à boucler;
[*]Une ou plusieurs expressions séparées par des virgules indiquant des actions à effectuer à la fin de chaque tour;[/list]
Donc l'indication que te donne [b]stealth35[/b] déplace le comptage dans la première partie qui n'est exécutée qu'une seule fois au lieu de la laisser dans la seconde où elle sera exécutée à chaque tour. Ainsi, un count va ou non être exécuté plusieurs fois... pour retourner toujours le même résultat, répétition qui, tu en conviendras, est totalement sans intérêt ;)

stealth35, ça veut dire quoi ta phrase concernant "l'opcode", que ce n'est pas complètement fiable ce genre de tests?
Merci d'avance

En effet, mais c'est assez tordu tout de même comme écriture...
Jamais je n'aurai pu imaginer qu'on puisse écrire plusieurs lignes de code (et non des expressions) dedans. :shock:

for ($i = 0, $size = count($x); $i < $size; $i++) 

for ($i = 0; $i < count($x); $i++)

faut faire gaffe avec ce genre de tests puisque c'est uniquement l'exécution de l'opcode, pour le count c'est normale il est exécuter a chaque tour de boucle, il faut le mettre dans la première expression

[php]for ($i = 0, $size = count($x); $i < $size; $i++) [/php]
et non pas
[php]for ($i = 0; $i < count($x); $i++)[/php]

beaucoup oublie qu'on peux mettre ce qu'on veux comme expression dans un [url=http://php.net/manual/fr/control-structures.for.php]for[/url]

Je suis par hasard tombé sur http://www.phpbench.com/ qui propose une liste de benchmark de différentes écritures.
Assez intéressant à parcourir, on y voit par exemple qu'un count() d'un tableau dans une boucle for prend bizarrement un temps monstrueux par rapport à une constante calculée.