Optimiser son code PHP, les chaines de caractères

On peut lire sur le net - dans de nombreux billets à propos d’optimisation de code PHP - qu’employer les apostrophes (single quote) au lieu des guillemets (double quote) pour délimiter les chaînes de caractères permet une interprétation plus rapide.

Mais cet avis ne semble pas partagé par tous. D’aucuns n’hésitent pas à classer cette particularité dans la liste des mythes qui ont la peau dure. Ce point mérite bien un test.

Une boucle de tests sur différents types

La boucle ci-dessous permet de tester la rapidité d’exécution pour les différents types de variables.

• définition d’une variable avec une chaine de caractères (string)
• idem en ajoutant une variable de type string
• idem en ajoutant une variable de type int
• idem en ajoutant une variable de type float
• idem en ajoutant une variable de type boolean

Le tout en testant tour à tour par l’emploi des guillemets puis des apostrophes. Sans l’emploi de la boucle foreach() pour les différents types de variable, nous aurions par exemple par type :

<?php

$e = "Test: $variable";
$e = "Test: ".$variable;
$e = 'Test: '.$variable;
$e = 'Test: '.(string)$variable;
$e = 'Test: '.strval($variable);

?>

Voici le script complet :

<?php

//
// Vérification optimisation code
//

define('LOOP', 100000);
$nt = 0;

function str_ratio($r2, $r1) {
    $ratio = $r2 / $r1;
    return(round($ratio * 100, 2));
}

function str_result($r, $nt, $legend = '') {
    
    $res = '____________________' . PHP_EOL 
        . 'Résultats #'.$nt.': ' . $legend . PHP_EOL 
        . '- double quote in : '.$r[0] . PHP_EOL
        ;
        
    if(isset($r[3])) {
        $res .=
              '- double quote out: '.$r[1]
            . PHP_EOL
            . '- single quote    : '.$r[2]
                .' ('.str_ratio($r[2], $r[0]).')'
                . PHP_EOL
            . '- +       cast: '.$r[3]
                .' ('.str_ratio($r[3], $r[0]).')'
                . PHP_EOL
            . '- +   strval(): '.$r[4]
                .' ('.str_ratio($r[4], $r[0]).')'
                . PHP_EOL
            ;
    }
    else {
        $res .= '- single quote    : '.$r[1]
            .' ('.str_ratio($r[1], $r[0]).')'. PHP_EOL
            ;
    }

    $res .= PHP_EOL ;

    return($res);
}

$tests = array(
    '(rien)' => ''
    , 'string' => 'optimiser le code PHP'
    , 'integer' => 5
    , 'float' => 5.32
    , 'boolean' => true
);

foreach($tests as $k => $v) {
    
    $r = array();

    if($v) {
        // double quote
        $s = microtime(1);
        for($ii=0; $ii<LOOP; $ii++) {
            $e = "Test: $v";
        }
        $r[] = microtime(1) - $s;
        
        // double quote
        $s = microtime(1);
        for($ii=0; $ii<LOOP; $ii++) {
            $e = "Test: ".$v;
        }
        $r[] = microtime(1) - $s;

        // single quote
        $s = microtime(1);
        for($ii=0; $ii<LOOP; $ii++) {
            $e = 'Test: '.$v;
        }
        $r[] = microtime(1) - $s;
        
        // single quote + cast
        $s = microtime(1);
        for($ii=0; $ii<LOOP; $ii++) {
            $e = 'Test: '.(string)$v;
        }
        $r[] = microtime(1) - $s;
        
        // single quote +strval
        $s = microtime(1);
        for($ii=0; $ii<LOOP; $ii++) {
            $e = 'Test: '.strval($v);
        }
        $r[] = microtime(1) - $s;
    }
    else {
        // simple test d'assignation
        
        // double quote
        $s = microtime(1);
        for($ii=0; $ii<LOOP; $ii++) {
            $e = "Test: ";
        }
        $r[] = microtime(1) - $s;
        
        // single quote
        $s = microtime(1);
        for($ii=0; $ii<LOOP; $ii++) {
            $e = 'Test: ';
        }
        $r[] = microtime(1) - $s;
        
    }
    echo(str_result($r, ++$nt, $k.' "'.$v.'"'));
}


?>

Si problème de copié/collé, voici ce script compressé :

Le test est effectué sur deux machines différentes, 5 fois. Le résultat donné ci-dessous est un résultat moyen de ces essais.

En résumé, c’est bien un mythe pour la simple attribution.

Mais en ce qui concerne la concaténation ou l’insertion, il y a visiblement un gain qui peut aller jusqu’à 30 %.

Et 30 % de 1.90734863281E-6 (c’est le coût d’un $e=$variable) ne mérite pas forcément la mise en chantier du projet "optimisation de mon application".

Au passage, remarquons que la fonction strval() est bien plus lente qu’un simple cast.