Optimiser son code PHP (concaténation)

Le point ’.’ est l’opérateur de concaténation PHP pour une chaîne de caractères.

Lorsque la chaîne est longue, il est de coutûme de tronçonner la chaîne par ligne, plus lisible à l’écran.

Et l’on rencontre deux façons d’opérer :

• en utilisant le point seul
• en répétant le nom de la variable.

Par exemple, dans le premier cas :

Et dans le second :

Qu’elle est la meilleure solution ?

Voici un script de test qui permet peut-être de se faire une idée :

<?php

//
// Vérification optimisation code
//

define('LOOP', 50);

$string = 'Le vif zéphyr jubile sur les kumquats du clown gracieux. ';
$var_string = "    \$test2 .= '" . $string . "';";

// concaténation par l'opérateur .
$concat = '$test1 = \'\'' . PHP_EOL;
for($ii=0; $ii < LOOP; $ii++) {
    $concat .= '    . \'' . $string . '\'' . PHP_EOL;
}
$concat .= '    ;';

// idem, avec duplication de la ligne
$dupstr = " \$test2 = '';" . PHP_EOL;
for($ii=0; $ii < LOOP; $ii++) {
    $dupstr .= $var_string . PHP_EOL;
}

// test via eval pour $concat
echo(PHP_EOL
     . "##############################" . PHP_EOL
     . '### concat' . PHP_EOL);
echo($concat.PHP_EOL);
echo('len1: '.strlen($concat) . PHP_EOL);
$s = microtime(1);
eval('$concat = '.$concat);
$r_concat = microtime(1) - $s;
echo($concat.PHP_EOL);
echo('len2: '.strlen($concat) . PHP_EOL);
echo($r_concat . PHP_EOL);

// test via eval pour $dupstr
echo(PHP_EOL
     . "##############################" . PHP_EOL
     . '### dupstr' . PHP_EOL);
echo($dupstr.PHP_EOL);
echo('len1: '.strlen($dupstr) . PHP_EOL);
$s = microtime(1);
//eval('$dupstr = '.$dupstr);
//eval($dupstr."\$dupstr = \"$test2\";");
eval($dupstr);
$r_dupstr = microtime(1) - $s;
echo($test2.PHP_EOL);
echo('len2: '.strlen($test2) . PHP_EOL);
echo($r_dupstr . PHP_EOL);

echo('Résumé:' . PHP_EOL
     . 'Concaténation par .  :' . $r_concat . PHP_EOL
     . 'par duplication ligne:' . $r_dupstr . PHP_EOL
     );
?>

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

Et le résultat :

Bref, peu significatif !

A noter : si vous définissez LOOP à 10000, donc 10000 lignes par script, le résultat est tout autre :

La gestion de la mémoire y est probablement pour quelque chose.