PHP : ‘’ vs “” et interpolation de variable

Vous avez surement déjà remarqué qu’il est possible d’utiliser les guillemets simples ou doubles pour les chaînes de caractères PHP, mais vous êtes-vous déjà demandé ce qui différencie ces deux syntaxes ?

Deux façons d’interpoler les variables

Il est courant d’utiliser les chaînes de caractères en y incorporant une ou plusieurs variable·s. C’est précisément dans ce contexte que nos deux syntaxes diffèrent.

Une chaîne de caractères entourée de guillemets doubles sera analysée par l’interpréteur PHP. Ce qui signifie qu’une variable à l’intérieur de la chaîne sera remplacée par sa valeur. De même pour les séquences d’échappement. Par exemple, « \n » sera remplacé par une nouvelle ligne.

$var = 'variable';

echo "La variable $var est interprétée.\n";
echo 'La variable $var n\'est pas interprétée.\n';

/*
La variable variable est interprétée.
La variable $var n'est pas interprétée.\n
*/

💡 Vous aurez remarqué que pour utiliser un guillemet dans une chaîne de caractères entourée du même type de guillemet, il faut l’échapper avec un antislash.

Puisque les chaînes de caractères avec des guillemets simples n’interprètent pas leur contenu, comment y insérer des variables ?

Il faut utiliser l’opérateur de concaténation comme suit :

$var = 'valeur';
$example = '$var = ' . $var;

Cette dernière syntaxe est plus longue et moins intuitive, pourtant elle est souvent préférée pour deux raisons.

Premièrement, du fait que l’interpréteur PHP n’analyse pas ce type de chaîne, elle est en théorie plus performante. En outre, dans des contextes où aucun élément interprétable n’est présent dans la chaîne de caractères, utiliser la syntaxe avec les guillemets doubles est inutile. Par exemple pour une clé d’un tableau, à moins qu’elle soit dynamique, il est recommandé de l’entourer de guillemets simples.

Le second argument concerne la lisibilité du code. En effet, lorsque la variable est séparée de la chaîne de caractères grâce à l’utilisation de l’opérateur de concaténation, elle ressort mieux visuellement. A l’inverse, il est facile de passer à côté d’une variable cachée dans une chaîne entourée de guillemets doubles.

Encore deux syntaxes

Lorsque l’on utilise les guillemets doubles, il existe deux méthodes pour y injecter des variables. La syntaxe simple, que je vous montre depuis le début de cet article, et la syntaxe complexe où la variable est entourée d’accolades.

$var = 'valeur';

echo "Syntaxe simple : $var";
echo "Syntaxe complexe : {$var}";

La particularité de la syntaxe complexe est que nous délimitons explicitement la variable à interpoler. A l’inverse, avec la syntaxe simple nous laissons PHP trouver par lui-même où commence la variable (là c’est facile, il y a le $) et où elle se termine. C’est évidemment dans le second cas que ça peut mal se passer.

Dans cet exemple, PHP comprend que la variable s’arrête après le crochet fermant.

$tab = ['valeur1'];

echo "Ça fonctionne : $tab[0]";
// Ça fonctionne : valeur1

En revanche, lorsque nous souhaitons utiliser un tableau avec une clé alphabétique, PHP n’arrive pas à délimiter la fin de la variable.

$tab = ['var1' => 'valeur1'];

echo "Ça ne fonctionne pas : $tab['var1']";
// Parse error: syntax error, unexpected string content "", 
// expecting "-" or identifier or variable or number

echo "Avec la syntaxe complexe : {$tab['var1']}";
// Avec la syntaxe complexe : valeur1

De même lors de l’utilisation d’un tableau multidimensionnel.

$tab = [
 ['X', 'O', ''],
 ['', 'X', 'O'],
 ['', '', 'O'],
];

echo "Il y a \"$tab[1][2]\" à la position 2, 3.";
// Warning: Array to string conversion

echo "Il y a \"{$tab[1][2]}\" à la position 2, 3.";
// Il y a "O" à la position 2, 3.

💡 Il est important de noter que la syntaxe complexe ne fonctionne pas pour insérer des expressions dans une chaîne de caractères, ni pour des constantes de classe. C’est uniquement le $ qui indique à PHP qu’une variable est présente et doit être interprétée.

$name = 'John';

echo "Bonjour {strtoupper($name)} !";
// Bonjour {strtoupper(John)} !

Performance

J’ai énoncé plus tôt qu’en théorie la syntaxe avec les guillemets simples est plus performante. Il est temps de passer à la pratique.

J’ai donc réalisé un test assez simple d’interpolation d’une variable dans une chaîne de caractères avec des guillemets simples, puis le même test avec des guillemets doubles. J’ai mis cette chaîne dans une boucle afin que les temps obtenus soient plus parlant.

$start = microtime(true);

for ($i = 0; $i < 10_000_000; $i++) {
    $example = 'Nous sommes au numéro ' . $i;
}

var_dump(microtime(true) - $start);

J’ai d’abord lancé les tests sur la version actuelle de PHP à l’heure où j’écris ces lignes, soit la version 8.2, et j’ai été surpris de découvrir que l’écart est infime. Un premier test a donné l’avantage aux guillemets doubles, avec un temps d’exécution de 1,07 seconde, contre 1,11 seconde. Un autre test m’a donné le résultat inverse, puisque la chaîne avec les guillemets simples s’exécutait en 0,79 seconde contre 0,93 seconde.

Je me suis également amusé à lancer ce test sur la version 5.6 de PHP. Les résultats sont plus proche de ce à quoi je m’attendais. J’ai obtenu 1,9 seconde pour les guillemets simples, contre 2,57 secondes pour les guillemets doubles.

Qu’est-ce que cela démontre ?

Premièrement, nous constatons une belle évolution de performance depuis PHP 5.6, avec un gain d’environ une seconde !

Si vous travaillez sur une version récente de PHP, la différence de performance entre les deux syntaxes est négligeable, ce qui n’en fait plus un critère de choix.

Cependant, les chaînes de caractères entourées de guillemets simples sont plus performantes et seraient donc à privilégier lorsque vous êtes amenés à travailler sur une version plus ancienne de PHP.

L’alternative sprintf

Il existe une autre alternative que j’apprécie pour l’interpolation de variable, celle de la fonction native PHP sprintf.

sprintf(string $format, mixed ...$values): string

Son fonctionnement est à la fois simple et complet. Son premier paramètre est une chaîne de caractères contenant des spécificateurs là où l’on souhaite avoir un contenu dynamique. Il y a ensuite autant de paramètres que de spécificateurs à remplacer.

Documentation PHP : spécificateurs de type

Ces spécificateurs peuvent également formater la valeur avant de l’insérer dans la chaîne, comme dans l’exemple ci-dessous où je spécifie que je souhaite afficher un montant avec deux décimales.

$game = 'Spider-Man';
$price = 49.9;

echo sprintf('Ce jeu %s coûte %01.2f €', $game, $price);
// Ce jeu Spider-Man coûte 49.90 €

Petit bonus, ce formatage gère les arrondis.

$game = 'Spider-Man';
$price = 49.857;

echo sprintf('Ce jeu %s coûte %01.2f €', $game, $price);
// Ce jeu Spider-Man coûte 49.86 €

J’apprécie cette syntaxe, car elle permet, à l’instar des guillemets simples, de séparer visuellement la chaîne à compléter des variables, la rendant particulièrement lisible. Les nombreux spécificateurs disponibles et leurs possibilités de formatage sont également très appréciables.

Quel est le vainqueur ?

L’objectif de cet article n’est pas de statuer sur la bonne syntaxe à adopter, mais plutôt de parcourir les possibilités existantes et d’en détailler quelques subtilités.

Il n’y a donc pas de gagnant, mais maintenant vous avez les cartes pour choisir votre combattant 😉

Pour aller plus loin

Il existe également les syntaxes Heredoc et Nowdoc, que je n’ai pas abordé. Ce sont des équivalents aux syntaxes respectives avec guillemet simple et double, mais pour des chaînes multilignes.

Si vous souhaitez en savoir plus, n’hésitez pas à consulter la documentation officielle, qui est très complète à ce sujet.