Les chaînes de caractères

Une chaîne de caractères est une série de caractères, où un caractère est la même chose qu'un octet. De ce fait, PHP ne supporte que les jeux de caractères comportant 256 caractères différents, et, donc, n'a pas de support natif pour l'Unicode. Reportez-vous aux détails sur le type chaîne de caractères pour plus d'informations.

Note: Sur les systèmes 32-bit une chaîne de caractères peut être d'une taille allant jusqu'au plus 2Go (2147483647 octets maximum).

Syntaxe

Une chaîne de caractères littérale peut être spécifiée de 4 façons différentes :

Guillemets simples

La façon la plus simple de spécifier une chaîne de caractères est de l'entourer de guillemets simples (le caractère ').

Pour spécifier un guillemet simple littéral, il doit être échappé à l'aide d'un antislash (\). Pour spécifier un antislash littéral, doublez-le (\\). Toute les autres instances d'antislash seront traitées comme un antislash littéral : ce qui signifie que les autres séquences auquelles vous êtes éventuellement habitués (comme \r ou \n) s'afficheront telles quelles, sans avoir une quelconque signification particulière.

Note: Contrairement aux syntaxes avec double guillemets et heredoc, les variables et les séquences d'échappement pour les caractères spéciaux ne seront pas interprétées lorsqu'elles figurent dans une chaîne de caractères entourée de guillemets simples.

<?php
echo 'ceci est une chaîne simple';

echo
'Vous pouvez également ajouter des nouvelles lignes
dans vos chaînes
de cette façon'
;

// Affiche : Arnold a dit : "I'll be back"
echo 'Arnold a dit : "I\'ll be back"';

// Affiche : Voulez-vous supprimer C:\*.*?
echo 'Voulez-vous supprimer C:\\*.*?';

// Affiche : Voulez-vous supprimer C:\*.*?
echo 'Voulez-vous supprimer C:\*.*?';

// Affiche : Ceci n'affichera pas \n de nouvelle ligne
echo 'Ceci n\'affichera pas \n de nouvelle ligne';

// Affiche : Les variables ne seront pas $traitees $ici
echo 'Les variables ne seront pas $traitees $ici';
?>

Guillemets doubles

Si la chaîne de caractères est entourée de guillemets doubles ("), PHP interprétera les séquences d'échappement suivantes pour les caractères spéciaux :

Caractères échappés
Séquence Signification
\n Fin de ligne (LF ou 0x0A (10) en ASCII)
\r Retour à la ligne (CR ou 0x0D (13) en ASCII)
\t Tabulation horizontale (HT or 0x09 (9) en ASCII)
\v Tabulation verticale (VT ou 0x0B (11) en ASCII)
\e échappement (ESC or 0x1B (27) en ASCII)
\f Saut de page (FF ou 0x0C (12) en ASCII)
\\ Antislash
\$ Signe dollar
\" Guillemet double
\[0-7]{1,3} Octal: la séquence de caractères correspondant à l'expression rationnelle [0-7]{1,3} est un caractère en notation octale (par example "\101" === "A"), qui débordera silencieusement pour s'adapter à un octet (par example "\400" === "\000")
\x[0-9A-Fa-f]{1,2} Hexadécimal: la séquence de caractères correspondant à l'expression rationnelle [0-9A-Fa-f]{1,2} est un caractère en notation hexadécimale (par example "\x41" === "A")
\u{[0-9A-Fa-f]+} Unicode: la séquence de caractères correspondant à l'expression rationnelle [0-9A-Fa-f]+ est un point de code Unicode, qui sera la sortie de la chaîne de caractères représentant ce point de code UTF-8. Les accolades sont requis dans la séquence. Par example "\u{41}" === "A"

De la même façon que pour les chaîne de caractères entourées de guillemets simples, l'échappement de tout autre caractère affichera l'antislash.

La fonctionnalité la plus intéressante des chaîne de caractères guillemets doubles est que les noms de variables seront interprétés. Voir la documentation sur l'analyse des chaînes de caractères pour plus de détails.

Syntaxe Heredoc

Une troisième façon de délimiter une chaîne de caractères est la syntaxe Heredoc : <<<. Après cet opérateur, un identifiant est fourni, suivi d'une nouvelle ligne. La chaîne de caractères en elle-même vient ensuite, suivie du même identifiant pour fermer la notation.

L'identifiant de fin peut être indenté par des espaces ou tabulations, au quel cas l'indentation sera retirée de toutes les lignes dans la chaîne de caractères doc. Antérieur à PHP 7.3.0, l'identifiant de fin doit commencer à la première colonne de la ligne.

De plus, l'identifiant doit suivre les mêmes règles que n'importe quel autre libellé PHP : il ne doit contenir que des caractères alphanumériques et des soulignés, et doit commencer par un caractère non numérique ou un souligné ("underscore").

Exemple #1 Exemple Heredoc basique à partir de PHP 7.3.0

<?php
// no indentation
echo <<<END
a
b
c
\n
END;

// 4 spaces of indentation
echo <<<END
a
b
c
END;

Résultat de l'exemple ci-dessus en PHP 7.3 :

      a
     b
    c

  a
 b
c

Si l'identifiant de fin est indenté plus que n'importe quelle ligne du texte, alors une ParseError sera lancée :

Exemple #2 Closing identifier must not be indented further than any lines of the body

<?php
echo <<<END
a
b
c
END;

Résultat de l'exemple ci-dessus en PHP 7.3 :

PHP Parse error:  Invalid body indentation level (expecting an indentation level of at least 3) in example.php on line 4

Si l'identifiant de fin est indenté, alors les tabulations peuvent aussi être utilisé, néanmoins, les tabulations et les espaces ne doivent pas être mélangé en ce qui concerne l'indentation de l'identifiant et l'indentation du texte (jusqu'à l'identifiant de fin). Dans quelconque de ces cas, une ParseError sera lancée. Ces contraintes sur les caractères d'espacement blanc ont été incluse car le mélange de tabulations et d'espaces pour l'indentation est nuisible à la lisibilité.

Exemple #3 Indentation différente pour le texte (espace) et identifiant de fin

<?php
// All the following code do not work.
// different indentation for body (spaces) ending marker (tabs)
{
echo <<<END
a
END;
}
// mixing spaces and tabs in body
{
echo <<<END
a
END;
}
// mixing spaces and tabs in ending marker
{
echo <<<END
a
END;
}

Résultat de l'exemple ci-dessus en PHP 7.3 :

PHP Parse error:  Invalid indentation - tabs and spaces cannot be mixed in example.php line 8

L'identifiant de fin du corps du texte n'est pas requis d'être suivi d'une point virgule ou une nouvelle ligne. Par exemple, le code suivant est autorisé à partir de PHP 7.3.0:

Exemple #4 Continuer une expression après un identifiant de fin

<?php
$values
= [<<<END
a
b
c
END, 'd e f'];
var_dump($values);

Résultat de l'exemple ci-dessus en PHP 7.3 :

array(2) {
  [0] =>
  string(11) "a
  b
    c"
  [1] =>
  string(5) "d e f"
}
Avertissement

Si l'identifiant de fin a été trouvé au début d'une ligne, alors peut importe s'il fait partie d'un autre mot, il peut être considéré comme l'identifiant de fin et causer une ParseError.

Exemple #5 Identifiant de fin dans le corps de la chaîne de caractères tend à causer une ParseError

<?php
$values
= [<<<END
a
b
END ING
END
, 'd e f'];

Résultat de l'exemple ci-dessus en PHP 7.3 :

PHP Parse error:  syntax error, unexpected identifier "ING", expecting "]" in example.php on line 6

Pour éviter ce problème, il suffit de suivre cette règle simple : ne pas choisir comme identifiant de fin si ceci apparait dans le corps du texte.

Avertissement

Antérieur à PHP 7.3.0, il est très important de noter que la ligne contenant l'identifiant de fin ne doit contenir aucun autre caractère, mis à part un point-virgule (;). Cela signifie en particulier que l'identifiant ne doit pas être indenté, et qu'il ne doit y avoir aucun espace ou tabulation avant ou après le point-virgule. Il est également important de garder à l'esprit que le premier caractère avant l'identifiant de fermeture doit être une nouvelle ligne telle que définie par le système d'exploitation ; sur les systèmes Unix, incluant macOS, il s'agit du caractère \n. Le délimiteur de fermeture doit aussi être suivi d'une nouvelle ligne.

Si cette règle n'est pas respectée et que l'identifiant de fermeture n'est pas "propre", il ne sera pas considéré comme identifiant de fermeture, et PHP continuera à en chercher un. Si un identifiant de fermeture "propre" n'est pas trouvé avant la fin du fichier courant, une erreur d'analyse sera émise à la dernière ligne.

Exemple #6 Exemple invalide, antérieur à PHP 7.3.0

<?php
class foo {
public
$bar = <<<EOT
bar
EOT;
}
// L'identifiant ne doit pas être indenté
?>

Exemple #7 Exemple valide, même antérieur à PHP 7.3.0

<?php
class foo {
public
$bar = <<<EOT
bar
EOT;
}
?>

Heredoc contenant des variables ne peuvent être utilisé pour initialiser les propriétés d'une classe.

Heredoc se comporte exactement comme une chaîne de caractères guillemets doubles, sans les guillemets doubles. Cela signifie que les guillemets dans une syntaxe Heredoc n'ont pas besoin d'être échappés, mais que les codes d'échappement listés plus haut peuvent toujours être utilisés. Les variables seront interprétées, mais les mêmes précautions doivent être prises lorsque des variables complexes sont exprimées dans une Heredoc comme avec chaîne de caractères.

Exemple #8 Exemple de chaînes Heredoc

<?php
$str
= <<<EOD
Exemple de chaîne
sur plusieurs lignes
en utilisant la syntaxe Heredoc.
EOD;

/* Exemple plus complexe, avec des variables. */
class foo
{
var
$foo;
var
$bar;

function
__construct()
{
$this->foo = 'Foo';
$this->bar = array('Bar1', 'Bar2', 'Bar3');
}
}

$foo = new foo();
$name = 'MyName';

echo <<<EOT
Mon nom est "$name". J'affiche quelques $foo->foo.
Maintenant, j'affiche quelques
{$foo->bar[1]}.
Et ceci devrait afficher un 'A' majuscule : \x41
EOT;
?>

L'exemple ci-dessus va afficher :

Mon nom est "MyName". J'affiche quelques Foo.
Maintenant, j'affiche quelques Bar2.
Et ceci devrait afficher un 'A' majuscule : A

Il est aussi possible d'utiliser la syntaxe Heredoc pour passer des données en paramètre à une fonction :

Exemple #9 Exemple d'utilisation de Heredoc pour passer des arguments

<?php
var_dump
(array(<<<EOD
foobar!
EOD
));

Il est possible d'initialiser les variables statiques et les propriétés ou constantes de classes avec la syntaxe Heredoc :

Exemple #10 Utilisation de Heredoc pour initialiser des valeurs statiques

<?php
// Variables statiques
function foo()
{
static
$bar = <<<LABEL
Nothing in here...
LABEL;
}

// Constantes et propriétés de classe
class foo
{
const
BAR = <<<FOOBAR
Constant example
FOOBAR;

public
$baz = <<<FOOBAR
Property example
FOOBAR;
}
?>

L'identifiant ouvrant Heredoc peut éventuellement être écrit entre guillemets doubles :

Exemple #11 Utilisation des guillemets doubles avec Heredoc

<?php
echo <<<"FOOBAR"
Hello World!
FOOBAR;
?>

Nowdoc

Nowdoc est aux chaînes guillemets simples ce qu'Heredoc est aux chaînes guillemets doubles. Un Nowdoc est spécifié de manière similaire à un Heredoc, mais aucune analyse n'est effectuée à l'intérieur d'une Nowdoc. Cette syntaxe est idéale pour embarquer du code PHP ou d'autres larges blocs de texte, sans avoir besoin d'échapper quoi que ce soit. Elle partage quelques fonctionnalités avec la syntaxe SGML <![CDATA[ ]]>, en ce qu'elle déclare un bloc de texte qui ne doit pas être analysé.

Nowdoc est identifié avec la même séquence <<< utilisée par Heredoc, mais l'identifiant qui suit est entouré de guillemets simples, comme <<<'EOT'. Toutes les règles concernant les identifiants Heredoc s'appliquent également aux identifiants Nowdoc, et, tout particulièrement, celles concernant la forme de l'identifiant de fin.

Exemple #12 Exemple de chaîne Nowdoc

<?php
echo <<<'EOD'
Exemple de chaîne sur plusieurs lignes en utilisant la syntaxe Nowdoc.
Les barre oblique inversée sont toujours traité de façon littérale,
par exemple \\ and \'.
EOD;

L'exemple ci-dessus va afficher :

Exemple de chaîne sur plusieurs lignes en utilisant la syntaxe Nowdoc.
Les barre oblique inversée sont toujours traité de façon littérale,
par exemple \\ and \'.

Exemple #13 Exemple de chaîne Nowdoc avec des variables

<?php
class foo
{
public
$foo;
public
$bar;

function
__construct()
{
$this->foo = 'Foo';
$this->bar = array('Bar1', 'Bar2', 'Bar3');
}
}

$foo = new foo();
$name = 'MyName';

echo <<<'EOT'
Mom nom est "$name". J'affiche quelques $foo->foo.
Maintenant, j'affiche quelques {$foo->bar[1]}.
Ceci ne devrait pas afficher un 'A' : \x41
EOT;
?>

L'exemple ci-dessus va afficher :

Mom nom est "$name". J'affiche quelques $foo->foo.
Maintenant, j'affiche quelques {$foo->bar[1]}.
Ceci ne devrait pas afficher un 'A' : \x41

Exemple #14 Exemple avec des données statiques

<?php
class foo {
public
$bar = <<<'EOT'
bar
EOT;
}
?>

Analyse des variables

Lorsqu'une chaîne de caractères est spécifiée entre guillemets doubles ou en Heredoc, les variables qu'elle contient sont interprétées.

Il existe 2 types de syntaxes : une simple et une complexe. La syntaxe simple est la plus commune et la plus pratique. Elle fournit une façon d'embarquer une variable, une valeur de tableau, ou une propriété d'objet dans une chaîne de caractères avec un minimum d'effort.

La syntaxe complexe se reconnaît à l'utilisation d'accolades autour de l'expression.

Syntaxe simple

Si un signe dollar ($) est rencontré, l'analyseur prendra autant de caractères que possible pour former un nom de variable valide. Entourer le nom de la variable avec des accolades, pour spécifier explicitement la fin de celui-ci.

<?php
$juice
= "pomme";

echo
"Il a bu du jus de $juice." . PHP_EOL;

// Non souhaité. "s" est un caractère valide pour un nom de variable, ainsi ceci fait référence à $juices, et non à $juice.
echo "Il a bu du jus constitué de $juices." . PHP_EOL;
// Spécifiez explicitement la fin du nom de la variable en plaçant la référence entre accolades.
echo "Il a bu du jus constitué de ${juice}s.";

?>

L'exemple ci-dessus va afficher :

Il a bu du jus de pomme.
Il a bu du jus constitué de .
Il a bu du jus constitué de pommes.

De la même façon, un index d'un tableau ou une propriété d'un objet peut être analysé. Avec les indices de tableaux, le crochet fermant (]) marque la fin de l'index. Les mêmes règles sont appliquées aux propriétés d'objets que pour les simples variables.

Exemple #15 Exemple de la syntaxe simple

<?php
$juices
= array("pomme", "poire", "koolaid1" => "raisin");

echo
"Il a bu du jus de $juices[0].".PHP_EOL;
echo
"Il a bu du jus de $juices[1].".PHP_EOL;
echo
"Il a bu du jus de $juices[koolaid1].".PHP_EOL;

class
people {
public
$john = "John Smith";
public
$jane = "Jane Smith";
public
$robert = "Robert Paulsen";

public
$smith = "Smith";
}

$people = new people();

echo
"$people->john a bu du jus de $juices[0].".PHP_EOL;
echo
"$people->john a dit bonjour à $people->jane.".PHP_EOL;
echo
"$people->john's wife greeted $people->robert.".PHP_EOL;
echo
"$people->robert a dit bonjour aux $people->smiths."; // Ne fonctionne pas
?>

L'exemple ci-dessus va afficher :

Il a bu du jus de pomme.
Il a bu du jus de poire.
Il a bu du jus de raisin.
John Smith a bu du jus de pomme.
John Smith a dit bonjour à Jane Smith.
John Smith's wife greeted Robert Paulsen.
Robert Paulsen a dit bonjour aux .

À partir de PHP 7.1.0 les indices numériques négatifs sont aussi supportés.

Exemple #16 Indices numériques négatifs

<?php
$string
= 'string';
echo
"Le personnage à l'index -2 est $string[-2].", PHP_EOL;
$string[-3] = 'o';
echo
"Change le caractère à l'index -3 par o donne $string.", PHP_EOL;
?>

L'exemple ci-dessus va afficher :

Le personnage à l'index -2 est n.
Change le caractère à l'index -3 par o donne strong.

Pour tout ce qui est plus complexe, vous devriez utiliser la syntaxe complexe.

Syntaxe complexe

Cette syntaxe est appelée complexe, non pas parce qu'elle est complexe, mais parce qu'elle permet l'utilisation d'expressions complexes.

Toute variable scalaire, élément de tableau ou attribut d'objet représentable en tant que chaîne de caractères peut être utilisé avec cette syntaxe. L'expression est écrite de la même façon qu'elle apparaitrait à l'extérieur de la chaîne de caractères et est entouré des caractères { et }. Sachant que { ne peut pas être échappé, cette syntaxe ne sera reconnue que lorsque le $ suit immédiatement {. Utiliser {\$ pour afficher littéralement {$. Voici quelques exemples pour éclaircir ceci :

<?php
// Montre toutes les erreurs
error_reporting(E_ALL);

$great = 'fantastic';

// Ne fonctionne pas, affiche : This is { fantastic}
echo "This is { $great}";

// Fonctionne, affiche : This is fantastic
echo "This is {$great}";

// Fonctionne
echo "This square is {$square->width}00 centimeters broad.";

// Fonctionne, les clés entourées de guillemets simples ne fonctionnent qu'avec la syntaxe à accolades
echo "This works: {$arr['key']}";

// Fonctionne
echo "This works: {$arr[4][3]}";

// Ceci est faux pour la même raison pour laquelle $foo[bar] est faux à l'extérieur d'une chaîne.
// PHP recherche d'abord une constante nommée foo et génère une erreur si elle n'est pas trouvée.
// Si la constante est trouvée, sa valeur (et non 'foo' elle-même) serait utilisée
// comme indice de tableau.
echo "This is wrong: {$arr[foo][3]}";

// Fonctionne. Lors de l'utilisation de tableaux multidimensionnels, utilisez toujours
// les accolades autour du tableau lorsqu'il se trouve dans la chaîne
echo "This works: {$arr['foo'][3]}";

// Fonctionne.
echo "This works: " . $arr['foo'][3];

echo
"This works too: {$obj->values[3]->name}";

echo
"This is the value of the var named $name: {${$name}}";

echo
"This is the value of the var named by the return value of getName(): {${getName()}}";

echo
"This is the value of the var named by the return value of \$object->getName(): {${$object->getName()}}";

// Ne fonctionne pas, affiche : This is the return value of getName(): {getName()}
echo "This is the return value of getName(): {getName()}";

// Ne fonctionne pas, affiche : C:\folder\{fantastic}.txt
echo "C:\folder\{$great}.txt"
// fonctionne, affiche : C:\folder\fantastic.txt
echo "C:\\folder\\{$great}.txt"
?>

Il est également possible d'accéder aux propriétés de classes en utilisant des variables contenues dans des chaînes, en utilisant cette syntaxe.

<?php
class foo {
var
$bar = 'I am bar.';
}

$foo = new foo();
$bar = 'bar';
$baz = array('foo', 'bar', 'baz', 'quux');
echo
"{$foo->$bar}\n";
echo
"{$foo->{$baz[1]}}\n";
?>

L'exemple ci-dessus va afficher :

I am bar.
I am bar.

Note:

Les valeurs accédé via les fonctions, méthodes, variables statiques de classes, ainsi que les constantes de classes à l'intérieur de {$} sont interprétée comme le nom d'une variable dans le contexte où la chaîne est définie. L'utilisation de simples accolades ({}) ne fonctionnera pas pour accéder à la valeur retournée par des fonctions, méthodes, ou les valeurs de constantes et de variables statiques de classes.

<?php
// Affichage de toutes les erreurs.
error_reporting(E_ALL);

class
beers {
const
softdrink = 'rootbeer';
public static
$ale = 'ipa';
}

$rootbeer = 'A & W';
$ipa = 'Alexander Keith\'s';

// Ceci fonctionne ; Affiche : I'd like an A & W
echo "I'd like an {${beers::softdrink}}\n";

// Ceci fonctionne également ; Affiche : I'd like an Alexander Keith's
echo "I'd like an {${beers::$ale}}\n";
?>

Accès et modification d'une chaîne, par caractère

On peut accéder à, et modifier un, caractère d'une chaîne de caractères en spécifiant sa position (à partir de 0) après la chaîne de caractères en utilisant les crochets de tableau, tel que $str[42]. Il convient dans ce cas de voir une chaîne de caractères comme un tableau de caractères. Les fonctions substr() et substr_replace() peuvent être utilisées lorsque vous voulez extraire ou remplacer plus d'un caractère.

Note: À partir de PHP 7.1.0, les positions négatives dans les chaînes de caractères sont aussi supportées. Cela spécifie la position en partant de la fin de la chaîne de caractères. Auparavant, les index négatif émettait E_NOTICE pour la lecture (donnant une chaîne vide) et E_WARNING pour l'écriture (laissant la chaîne inchangée).

Note: Antérieur à PHP 8.0.0, les strings pouvait aussi être accédé en utilisant les accolades, comme ceci $str{42}. La syntaxe avec les accolades a été rendue obsolète en PHP 7.4.0 et n'est plus supportée à partir de PHP 8.0.0.

Avertissement

Écrire à une position hors de l'intervalle existant fait que la chaîne est complétée par des espaces jusqu'à cette position. Les positions sont toujours converties en valeur entière. Les types de positions invalides émettent une E_WARNING. Seul le premier caractère d'une chaîne assignée est utilisé. À partir de PHP 7.1.0, assigner une chaîne vide lève une erreur fatale. Auparavant, cela affectait un octet NULL.

Avertissement

En interne, les chaînes PHP sont des tableaux d'octets. Ainsi, l'accès ou la modification d'une chaîne en utilisant les crochets d'un tableau n'est pas multioctets, et ne doit être utilisé qu'avec les chaînes dont l'encodage est sur un seul octet, comme ISO-8859-1.

Note: À partir de PHP 7.1.0, appliquer un index vide sur une chaîne vide lève une erreur fatale. Auparavant, la chaîne était silencieusement convertie en un tableau.

Exemple #17 Quelques exemples de chaînes

<?php
// Récupération du premier caractère d'une chaîne
$str = 'This is a test.';
$first = $str[0];

// Récupération du troisième caractère d'une chaîne
$third = $str[2];

// Récupération du dernier caractère d'une chaîne
$str = 'This is still a test.';
$last = $str[strlen($str)-1];

// Modification du dernier caractère d'une chaîne
$str = 'Look at the sea';
$str[strlen($str)-1] = 'e';

?>

Les positions d'une chaîne doivent être un entier, ou des chaînes pouvant être converties en entier, sinon, une alerte sera émise.

Exemple #18 Exemple de Positions de Chaîne Invalide

<?php
$str
= 'abc';

var_dump($str['1']);
var_dump(isset($str['1']));

var_dump($str['1.0']);
var_dump(isset($str['1.0']));

var_dump($str['x']);
var_dump(isset($str['x']));

var_dump($str['1x']);
var_dump(isset($str['1x']));
?>

L'exemple ci-dessus va afficher :

string(1) "b"
bool(true)

Warning: Illegal string offset '1.0' in /tmp/t.php on line 7
string(1) "b"
bool(false)

Warning: Illegal string offset 'x' in /tmp/t.php on line 9
string(1) "a"
bool(false)
string(1) "b"
bool(false)

Note:

Accéder à des variables d'autres types (pas des tableaux ni des objets implémentant les interfaces appropriées) en utilisant [] ou {} retournera silencieusement null.

Note:

Les caractères dans une chaîne de caractères littérales peuvent être accédé en utilisant la syntaxe [] ou {}.

Note:

Accéder aux caractères dans une chaîne de caractères littérales en utilisant la syntaxe {} a été rendu obsolète en PHP 7.4. Ceci a été supprimée en PHP 8.0.

Fonctions et opérateurs utiles

Les chaîne de caractères peuvent être concaténées en utilisant l'opérateur '.' (point). Il est à noter que l'opérateur '+' (addition) ne fonctionnera pas. Voir opérateurs de chaînes pour plus d'informations.

Il existe de nombreuses fonctions utiles pour la manipulation de chaîne de caractères.

Voir la section sur les fonctions de chaînes de caractères pour des fonctions génériques, et à la section sur les expressions régulières compatibles Perl pour des fonctionnalités de recherches et remplacements avancés.

Il existe également des fonctions pour les URL, et des fonctions pour chiffrer/déchiffrer des chaînes de caractères (Sodium et Hash).

Finalement, voir aussi les fonctions "type de caractères".

Conversion en chaîne de caractères

Une valeur peut être convertie en une chaîne de caractères en utilisant le mot-clé (string) ou la fonction strval(). La conversion en chaîne de caractères est automatiquement effectuée dans le contexte d'une expression où une chaîne de caractères est nécessaire. Ceci survient notamment lors de l'utilisation des fonctions echo ou print, ou lorsqu'une variable est comparée à une chaîne de caractères. Les sections sur les types et sur le transtypage expliquent ce qui suit de manière plus détaillée. Voir aussi la fonction settype().

Une valeur booléen true est convertie en la chaîne de caractères "1". Une valeur booléen false est convertie en "" (une chaîne vide). Ceci permet les conversions vers et depuis les valeurs booléen et chaîne de caractères.

Un entier ou un nombre décimal est converti en une chaîne de caractères représentant le nombre de façon textuelle (y compris l'exposant pour les nombre décimal). Les nombres à virgule flottante peuvent être convertis en utilisant la notation exponentielle (4.1E+6).

Note:

À partir de PHP 8.0.0, le point décimal est toujours un point .. Antérieur à PHP 8.0.0, le point décimal est défini dans la locale du script (catégorie LC_NUMERIC). Voir la fonction setlocale().

Les tableau sont toujours convertis en la chaîne de caractères "Array" ; à cause de cela, echo et print ne peuvent pas afficher par eux-même le contenu d'un tableau. Pour afficher un seul élément, il faut utiliser une syntaxe tel que echo $arr['foo']. Voir ci-dessous pour des astuces permettant d'afficher le contenu complet.

Pour pouvoir convertir un objet en chaîne de caractères la méthode magique __toString doit être utilisée.

Les ressources sont toujours converties en chaîne de caractères sous la forme "Resource id #1", où 1 est l'identifiant assigné à la ressource par PHP lors de l'exécution. Alors qu'il ne faut pas se fier à cette structure, car susceptible d'évoluer, elle sera néanmoins unique pour une ressource donnée durant toute la durée d'exécution du script courant (ie une requête web ou un processus CLI). Pour récupérer le type d'une ressource, utilisez la fonction get_resource_type().

null est toujours converti en une chaîne vide.

Au vu de tout cela, la conversion d'un tableau, d'un objet, ou d'une ressource, en une chaîne de caractères ne fournit aucune information utile sur sa valeur, mis à part son type. Voir les fonctions print_r() et var_dump() pour inspecter plus efficacement les contenus de ces types.

La plupart des valeurs en PHP peuvent également être converties en chaîne de caractères afin de les stocker. Cette méthode est appelée "sérialisation", et est effectuée par serialize().

Détails sur le type "chaîne de caractères"

Le type chaîne de caractères en PHP est implémenté sous la forme d'un tableau d'octets accompagné d'un entier indiquant la longueur de la mémoire tampon. Il n'a aucune information sur la traduction octet/caractère, laissant cette tâche au programmeur. Il n'y a aucune limitation sur les valeurs pouvant être présentes dans une chaîne ; en particulier, les octets dont la valeur est 0 (“octets NUL”) sont autorisés à n'importe quel endroit de la chaîne (cependant, quelques fonctions, indiquées dans ce manuel comme n'étant pas “sécurisées au niveau binaire”, peuvent ignorer tous les octets après un octet nul.)

La nature même du type "chaîne de caractères" explique qu'il n'existe pas de type “byte” en PHP - les chaînes de caractères jouent ce rôle. Les fonctions qui ne retournent pas de données textuelles - par exemple, des données arbitraires lues depuis un socket réseau - continueront de retourner des chaînes de caractères.

PHP ne dictant aucun encodage spécifique pour les chaînes de caractères, on pourrait se demander comment les chaînes littérales sont codés. Par exemple, est-ce que la chaîne "á" équivaut à la chaîne "\xE1" (ISO-8859-1), "\xC3\xA1" (UTF-8, C form), "\x61\xCC\x81" (UTF-8, D form) ou à une autre des représentations possibles ? La réponse est que la chaîne sera encodée suivant l'encodage courant du script. Aussi, si le script est écrit en ISO-8859-1, alors, la chaîne sera encodée en ISO-8859-1 ; et ainsi de suite. Toutefois, ceci n'est pas vrai si Zend Multibyte est activé ; dans ce cas, le script peut être écrit dans n'importe quel encodage (qui sera explicitement déclaré, ou bien détecté), puis sera converti en un encodage interne, qui sera utilisé pour les chaînes littérales. Notez qu'il existe des contraintes sur l'encodage du script (ou sur l'encodage interne, si Zend Multibyte est activé) - cela signifie quasiment toujours que l'encodage utilisé doit être un sur-ensemble compatible d'ASCII, comme UTF-8 ou ISO-8859-1. Notez cependant que les encodages dépendant de l'état, où les mêmes valeurs de l'octet peuvent être utilisées dans des états de décalage initial et non-initial, peuvent être problématiques.

Bien évidemment, pour être utiles, les fonctions qui opèrent sur du texte peuvent devoir faire des hypothèses sur la façon dont est encodé la chaîne de caractères. Malheureusement, ces hypothèses ne sont pas les mêmes suivant les fonctions de PHP :

  • Certaines fonctions supposent que la chaîne est encodée en utilisant un (quelconque) encodage à un seul octet, mais n'ont pas besoin d'interpréter ces octets sous la forme de caractères. C'est actuellement le cas, par exemple, pour les fonctions substr(), strpos(), strlen() et strcmp(). Une autre façon de voir ces fonctions est qu'elles opèrent sur les mémoires tampons ; autrement dit, qu'elles fonctionnent avec les octets et leurs positions.
  • D'autres fonctions reçoivent l'encodage de la chaîne en paramètre, éventuellement en assumant un encodage par défaut si ce n'est pas le cas. C'est le cas de la fonction htmlentities() ainsi que de la majorité des fonctions de l'extension mbstring.
  • D'autres utilisent la locale courante (voir setlocale()), mais opèrent octet par octet.
  • Enfin, elles peuvent juste supposer que la chaîne utilise un encodage spécifique, généralement UTF-8. C'est le cas de la plupart des fonctions de l'extension intl ainsi que de celles de l'extension PCRE (dans ce dernier cas, uniquement lorsque le modificateur u est utilisé).

Pour conclure, le fait d'écrire un programme correct en utilisant Unicode dépend de l'utilisation ou non de fonctions qui ne fonctionnent pas en Unicode, et qui corrompront très certainement les données ; il conviendra donc d'utiliser des fonctions qui fonctionnent correctement, générallement depuis les extensions intl et mbstring. Cependant, l'utilisation de fonctions qui peuvent gérer des encodages Unicode n'est que le commencement. Quelques soient les fonctions fournies par le langage, il est essentiel de connaître les spécifications de l'Unicode. Par exemple, un programme qui assume qu'il n'y a que des caractères en majuscule et en minuscule fait une mauvaise hypothèse.

add a note add a note

User Contributed Notes 26 notes

up
370
John
7 years ago
I've been a PHP programmer for a decade, and I've always been using the "single-quoted literal" and "period-concatenation" method of string creation. But I wanted to answer the performance question once and for all, using sufficient numbers of iterations and a modern PHP version. For my test, I used:

php -v
PHP 7.0.12 (cli) (built: Oct 14 2016 09:56:59) ( NTS )
Copyright (c) 1997-2016 The PHP Group
Zend Engine v3.0.0, Copyright (c) 1998-2016 Zend Technologies

------ Results: -------

* 100 million iterations:

$outstr = 'literal' . $n . $data . $int . $data . $float . $n;
63608ms (34.7% slower)

$outstr = "literal$n$data$int$data$float$n";
47218ms (fastest)

$outstr =<<<EOS
literal$n$data$int$data$float$n
EOS;
47992ms (1.64% slower)

$outstr = sprintf('literal%s%s%d%s%f%s', $n, $data, $int, $data, $float, $n);
76629ms (62.3% slower)

$outstr = sprintf('literal%s%5$s%2$d%3$s%4$f%s', $n, $int, $data, $float, $data, $n);
96260ms (103.9% slower)

* 10 million iterations (test adapted to see which of the two fastest methods were faster at adding a newline; either the PHP_EOL literal, or the \n string expansion):

$outstr = 'literal' . $n . $data . $int . $data . $float . $n;
6228ms (reference for single-quoted without newline)

$outstr = "literal$n$data$int$data$float$n";
4653ms (reference for double-quoted without newline)

$outstr = 'literal' . $n . $data . $int . $data . $float . $n . PHP_EOL;
6630ms (35.3% slower than double-quoted with \n newline)

$outstr = "literal$n$data$int$data$float$n\n";
4899ms (fastest at newlines)

* 100 million iterations (a test intended to see which one of the two ${var} and {$var} double-quote styles is faster):

$outstr = 'literal' . $n . $data . $int . $data . $float . $n;
67048ms (38.2% slower)

$outstr = "literal$n$data$int$data$float$n";
49058ms (1.15% slower)

$outstr = "literal{$n}{$data}{$int}{$data}{$float}{$n}"
49221ms (1.49% slower)

$outstr = "literal${n}${data}${int}${data}${float}${n}"
48500ms (fastest; the differences are small but this held true across multiple runs of the test, and this was always the fastest variable encapsulation style)

* 1 BILLION iterations (testing a completely literal string with nothing to parse in it):

$outstr = 'literal string testing';
23852ms (fastest)

$outstr = "literal string testing";
24222ms (1.55% slower)

It blows my mind. The double-quoted strings "which look so $slow since they have to parse everything for \n backslashes and $dollar signs to do variable expansion", turned out to be the FASTEST string concatenation method in PHP - PERIOD!

Single-quotes are only faster if your string is completely literal (with nothing to parse in it and nothing to concatenate), but the margin is very tiny and doesn't matter.

So the "highest code performance" style rules are:

1. Always use double-quoted strings for concatenation.

2. Put your variables in "This is a {$variable} notation", because it's the fastest method which still allows complex expansions like "This {$var['foo']} is {$obj->awesome()}!". You cannot do that with the "${var}" style.

3. Feel free to use single-quoted strings for TOTALLY literal strings such as array keys/values, variable values, etc, since they are a TINY bit faster when you want literal non-parsed strings. But I had to do 1 billion iterations to find a 1.55% measurable difference. So the only real reason I'd consider using single-quoted strings for my literals is for code cleanliness, to make it super clear that the string is literal.

4. If you think another method such as sprintf() or 'this'.$var.'style' is more readable, and you don't care about maximizing performance, then feel free to use whatever concatenation method you prefer!
up
96
gtisza at gmail dot com
12 years ago
The documentation does not mention, but a closing semicolon at the end of the heredoc is actually interpreted as a real semicolon, and as such, sometimes leads to syntax errors.

This works:

<?php
$foo
= <<<END
abcd
END;
?>

This does not:

<?php
foo
(<<<END
abcd
END;
);
// syntax error, unexpected ';'
?>

Without semicolon, it works fine:

<?php
foo
(<<<END
abcd
END
);
?>
up
22
garbage at iglou dot eu
7 years ago
You can use string like array of char (like C)

$a = "String array test";

var_dump($a);
// Return string(17) "String array test"

var_dump($a[0]);
// Return string(1) "S"

// -- With array cast --
var_dump((array) $a);
// Return array(1) { [0]=> string(17) "String array test"}

var_dump((array) $a[0]);
// Return string(17) "S"

- Norihiori
up
9
Ray.Paseur sometimes uses Gmail
5 years ago
md5('240610708') == md5('QNKCDZO')

This comparison is true because both md5() hashes start '0e' so PHP type juggling understands these strings to be scientific notation.  By definition, zero raised to any power is zero.
up
19
og at gams dot at
16 years ago
easy transparent solution for using constants in the heredoc format:
DEFINE('TEST','TEST STRING');

$const = get_defined_constants();

echo <<<END
{$const['TEST']}
END;

Result:
TEST STRING
up
3
vseokdog at gmail dot com
4 years ago
Don't forget about new E_WARNING and E_NOTICE errors from PHP 7.1.x: they have been introduced when invalid strings are coerced using operators expecting numbers (+ - * / ** % << >> | & ^) or their assignment equivalents. An E_NOTICE is emitted when the string begins with a numeric value but contains trailing non-numeric characters, and an E_WARNING is emitted when the string does not contain a numeric value.

Example:
$foo = 1 + "bob-1.3e3"; 
$foo = "10.2 pigs " + 1.0;
Will produce: Warning: A non-numeric value encountered

Read more: https://www.php.net/manual/en/migration71.other-changes.php
up
17
lelon at lelon dot net
19 years ago
You can use the complex syntax to put the value of both object properties AND object methods inside a string.  For example...
<?php
class Test {
    public
$one = 1;
    public function
two() {
        return
2;
    }
}
$test = new Test();
echo
"foo {$test->one} bar {$test->two()}";
?>
Will output "foo 1 bar 2".

However, you cannot do this for all values in your namespace.  Class constants and static properties/methods will not work because the complex syntax looks for the '$'.
<?php
class Test {
    const
ONE = 1;
}
echo
"foo {Test::ONE} bar";
?>
This will output "foo {Test::one} bar".  Constants and static properties require you to break up the string.
up
4
sideshowAnthony at googlemail dot com
8 years ago
Something I experienced which no doubt will help someone . . .
In my editor, this will syntax highlight HTML and the $comment:

$html = <<<"EOD"
<b>$comment</b>
EOD;

Using this shows all the same colour:

$html = <<<EOD
<b>$comment</b>
EOD;

making it a lot easier to work with
up
10
chAlx at findme dot if dot u dot need
15 years ago
To save Your mind don't read previous comments about dates  ;)

When both strings can be converted to the numerics (in ("$a" > "$b") test) then resulted numerics are used, else FULL strings are compared char-by-char:

<?php
var_dump
('1.22' > '01.23'); // bool(false)
var_dump('1.22.00' > '01.23.00'); // bool(true)
var_dump('1-22-00' > '01-23-00'); // bool(true)
var_dump((float)'1.22.00' > (float)'01.23.00'); // bool(false)
?>
up
8
headden at karelia dot ru
14 years ago
Here is an easy hack to allow double-quoted strings and heredocs to contain arbitrary expressions in curly braces syntax, including constants and other function calls:

<?php

// Hack declaration
function _expr($v) { return $v; }
$_expr = '_expr';

// Our playground
define('qwe', 'asd');
define('zxc', 5);

$a=3;
$b=4;

function
c($a, $b) { return $a+$b; }

// Usage
echo "pre {$_expr(1+2)} post\n"; // outputs 'pre 3 post'
echo "pre {$_expr(qwe)} post\n"; // outputs 'pre asd post'
echo "pre {$_expr(c($a, $b)+zxc*2)} post\n"; // outputs 'pre 17 post'

// General syntax is {$_expr(...)}
?>
up
6
steve at mrclay dot org
15 years ago
Simple function to create human-readably escaped double-quoted strings for use in source code or when debugging strings with newlines/tabs/etc.

<?php
function doubleQuote($str) {
   
$ret = '"';
    for (
$i = 0, $l = strlen($str); $i < $l; ++$i) {
       
$o = ord($str[$i]);
        if (
$o < 31 || $o > 126) {
            switch (
$o) {
                case
9: $ret .= '\t'; break;
                case
10: $ret .= '\n'; break;
                case
11: $ret .= '\v'; break;
                case
12: $ret .= '\f'; break;
                case
13: $ret .= '\r'; break;
                default:
$ret .= '\x' . str_pad(dechex($o), 2, '0', STR_PAD_LEFT);
            }
        } else {
            switch (
$o) {
                case
36: $ret .= '\$'; break;
                case
34: $ret .= '\"'; break;
                case
92: $ret .= '\\\\'; break;
                default:
$ret .= $str[$i];
            }
        }
    }
    return
$ret . '"';
}
?>
up
1
nospam at nospam dot com
7 years ago
Beware that consistent with "String conversion to numbers":

<?php

if ('123abc' == 123) echo '(intstr == int) incorrectly tests as true.';

// Because one side is a number, the string is incorrectly converted from intstr to int, which then matches the test number.

// True for all conditionals such as if and switch statements (probably also while loops)!

// This could be a huge security risk when testing/using/saving user input, while expecting and testing for only an integer.

// It seems the only fix is for 123 to be a string as '123' so no conversion happens.

?>
up
1
mark at manngo dot net
7 years ago
I though that it would be helpful to add this comment so that the information at least appears on the right page on the PHP site.

Note that if you intend to use a double-quoted string with an associative key, you may run into the T_ENCAPSED_AND_WHITESPACE error. Some regard this as one of the less obvious error messages.

An expression such as:

<?php
    $fruit
=array(
       
'a'=>'apple',
       
'b'=>'banana',
       
//    etc
   
);

    print
"This is a $fruit['a']";    //    T_ENCAPSED_AND_WHITESPACE
?>

will definitely fall to pieces.

You can resolve it as follows:

<?php
   
print "This is a $fruit[a]";    //    unquote the key
   
print "This is a ${fruit['a']}";    //    Complex Syntax
   
print "This is a {$fruit['a']}";    //    Complex Syntax variation
?>

I have a personal preference for the last variation as it is more natural and closer to what the expression would be like outside the string.

It’s not clear (to me, at least) why PHP misinterprets the single quote inside the expression but I imagine that it has something to do with the fact quotes are not part of the value string — once the string is already being parsed the quotes just get in the way … ?
up
3
php at richardneill dot org
11 years ago
Leading zeroes in strings are (least-surprise) not treated as octal.
Consider:
  $x = "0123"  + 0;  
  $y = 0123 + 0;
  echo "x is $x, y is $y";    //prints  "x is 123, y is 83"
in other words:
* leading zeros in numeric literals in the source-code are interpreted as "octal", c.f. strtol().
* leading zeros in strings (eg user-submitted data), when cast (implicitly or explicitly) to integer are ignored, and considered as decimal, c.f. strtod().
up
4
Richard Neill
16 years ago
Unlike bash, we can't do
  echo "\a"       #beep!

Of course, that would be rather meaningless for PHP/web, but it's useful for PHP-CLI. The solution is simple:  echo "\x07"
up
0
necrodust44 at gmail dot com
10 years ago
String conversion to numbers.

Unfortunately, the documentation is not correct.

«The value is given by the initial portion of the string. If the string starts with valid numeric data, this will be the value used. Otherwise, the value will be 0 (zero).»

It is not said and is not shown in examples throughout the documentation that, while converting strings to numbers, leading space characters are ignored, like with the strtod function.

<?php
   
echo "     \v\f    \r   1234" + 1;    // 1235
   
var_export ("\v\f    \r   1234" == "1234");    // true
?>

However, PHP's behaviour differs even from the strtod's. The documentation says that if the string contains a "e" or "E" character, it will be parsed as a float, and suggests to see the manual for strtod for more information. The manual says

«A hexadecimal number consists of a "0x" or "0X" followed by a nonempty sequence of hexadecimal digits possibly containing a radix character, optionally followed by a binary exponent.  A binary exponent consists of a 'P' or 'p', followed by an optional plus or minus sign, followed by a nonempty sequence of decimal digits, and indicates multiplication by a power of 2.»

But it seems that PHP does not recognise the exponent or the radix character.

<?php
   
echo "0xEp4" + 1;     // 15
?>

strtod also uses the current locale to choose the radix character, but PHP ignores the locale, and the radix character is always 2E. However, PHP uses the locale while converting numbers to strings.

With strtod, the current locale is also used to choose the space characters, I don't know about PHP.
up
3
atnak at chejz dot com
19 years ago
Here is a possible gotcha related to oddness involved with accessing strings by character past the end of the string:

$string = 'a';

var_dump($string[2]);  // string(0) ""
var_dump($string[7]);  // string(0) ""
$string[7] === '';  // TRUE

It appears that anything past the end of the string gives an empty string..  However, when E_NOTICE is on, the above examples will throw the message:

Notice:  Uninitialized string offset:  N in FILE on line LINE

This message cannot be specifically masked with @$string[7], as is possible when $string itself is unset.

isset($string[7]);  // FALSE
$string[7] === NULL;  // FALSE

Even though it seems like a not-NULL value of type string, it is still considered unset.
up
-3
jonijnm at example dot com
6 years ago
Both should work :(

<?php

class Testing {
    public static
$VAR = 'static';
    public const VAR =
'const';
   
    public function
sayHelloStatic() {
        echo
"hello: {$this::$VAR}";
    }
   
    public function
sayHelloConst() {
        echo
"hello: {$this::VAR}"; //Parse error:  syntax error, unexpected '}', expecting '['
   
}
}

$obj = new Testing();
$obj->sayHelloStatic();
$obj->sayHelloConst();
up
-3
shd at earthling dot net
14 years ago
If you want a parsed variable surrounded by curly braces, just double the curly braces:

<?php
  $foo
= "bar";
  echo
"{{$foo}}";
?>

will just show {bar}. The { is special only if followed by the $ sign and matches one }. In this case, that applies only to the inner braces. The outer ones are not escaped and pass through directly.
up
-3
rkfranklin+php at gmail dot com
16 years ago
If you want to use a variable in an array index within a double quoted string you have to realize that when you put the curly braces around the array, everything inside the curly braces gets evaluated as if it were outside a string.  Here are some examples:

<?php
$i
= 0;
$myArray[Person0] = Bob;
$myArray[Person1] = George;

// prints Bob (the ++ is used to emphasize that the expression inside the {} is really being evaluated.)
echo "{$myArray['Person'.$i++]}<br>";

// these print George
echo "{$myArray['Person'.$i]}<br>";
echo
"{$myArray["Person{$i}"]}<br>";

// These don't work
echo "{$myArray['Person$i']}<br>";
echo
"{$myArray['Person'$i]}<br>";

// These both throw fatal errors
// echo "$myArray[Person$i]<br>";
//echo "$myArray[Person{$i}]<br>";
?>
up
-2
webmaster at rephunter dot net
18 years ago
Use caution when you need white space at the end of a heredoc. Not only is the mandatory final newline before the terminating symbol stripped, but an immediately preceding newline or space character is also stripped.

For example, in the following, the final space character (indicated by \s -- that is, the "\s" is not literally in the text, but is only used to indicate the space character) is stripped:

$string = <<<EOT
this is a string with a terminating space\s
EOT;

In the following, there will only be a single newline at the end of the string, even though two are shown in the text:

$string = <<<EOT
this is a string that must be
followed by a single newline

EOT;
up
-4
bishop
17 years ago
You may use heredoc syntax to comment out large blocks of code, as follows:
<?php
<<<_EOC
    // end-of-line comment will be masked... so will regular PHP:
    echo (
$test == 'foo' ? 'bar' : 'baz');
    /* c-style comment will be masked, as will other heredocs (not using the same marker) */
    echo <<<EOHTML
This is text you'll never see!       
EOHTML;
    function defintion(
$params) {
        echo 'foo';
    }
    class definition extends nothing     {
       function definition(
$param) {
          echo 'do nothing';
       }      
    }

    how about syntax errors?; = gone, I bet.
_EOC;
?>

Useful for debugging when C-style just won't do.  Also useful if you wish to embed Perl-like Plain Old Documentation; extraction between POD markers is left as an exercise for the reader.

Note there is a performance penalty for this method, as PHP must still parse and variable substitute the string.
up
-5
cvolny at gmail dot com
15 years ago
I commented on a php bug feature request for a string expansion function and figured I should post somewhere it might be useful:

using regex, pretty straightforward:
<?php
function stringExpand($subject, array $vars) {
   
// loop over $vars map
   
foreach ($vars as $name => $value) {
       
// use preg_replace to match ${`$name`} or $`$name`
       
$subject = preg_replace(sprintf('/\$\{?%s\}?/', $name), $value,
$subject);
    }
   
// return variable expanded string
   
return $subject;
}
?>

using eval() and not limiting access to only certain variables (entire current symbol table including [super]globals):

<?php
function stringExpandDangerous($subject, array $vars = array(), $random = true) {
   
       
// extract $vars into current symbol table
       
extract($vars);
       
       
$delim;
       
// if requested to be random (default), generate delim, otherwise use predefined (trivially faster)
       
if ($random)
           
$delim = '___' . chr(mt_rand(65,90)) . chr(mt_rand(65,90)) . chr(mt_rand(65,90)) . chr(mt_rand(65,90)) . chr(mt_rand(65,90)) . '___';
        else
           
$delim = '__ASDFZXCV1324ZXCV__'// button mashing...
       
        // built the eval code
       
$statement = "return <<<$delim\n\n" . $subject . "\n$delim;\n";
       
       
// execute statement, saving output to $result variable
       
$result = eval($statement);
       
       
// if eval() returned FALSE, throw a custom exception
       
if ($result === false)
            throw new
EvalException($statement);
       
       
// return variable expanded string
       
return $result;
    }
?>

I hope that helps someone, but I do caution against using the eval() route even if it is tempting.  I don't know if there's ever a truely safe way to use eval() on the web, I'd rather not use it.
up
-7
Hayley Watson
6 years ago
Any single expression, however complex, that starts with $ (i.e., a variable) can be {}-embedded in a double-quoted string:

<?php

echo "The expression {$h->q()["x}"]->p(9 == 0 ? 17 : 42)} gets parsed just as well as " . $h->q()["x}"]->p(9 == 0 ? 17 : 42) . " does.";

?>
up
-20
M. H. S.
4 years ago
<?php

// Its A Example for "Heredoc":

$n = 10;

$var_heredoc = <<<HEREDOC

Its A String For "
$var_heredoc" variable.

heredoc can expanding variables.
(example:
$n)

if you want not expanding, you need print " \ " befor variable.
(example: /
$n)

heredoc can use " /n, /t, /r, ... ".

heredoc = the string of double-qoutation;

        HEREDOC; -> its bad closing of heredoc!

HEREDOC;
// its a good closing of heredoc!

?>
up
-3
greenbluemoonlight at gmail dot com
3 years ago
<?php
\\Example # 10 Simple Syntax - Solution for the last "echo" line.

class people {
    public
$john = "John Smith";
    public
$jane = "Jane Smith";
    public
$robert = "Robert Paulsen";

    public
$smith = "Smith";
}

$people = new people();

echo
"$people->john then said hello to $people->jane.".PHP_EOL;
echo
"$people->john's wife greeted $people->robert.".PHP_EOL;
echo
"$people->robert greeted the two $people->smiths";
\\
Won't work
\\Outputs: Robert Paulsen greeted the two

/**Solution:**\

echo "$people->robert greeted the two $people->smith\x08s";

\\Will work
\\Outputs: Robert Paulsen greeted the two Smiths

?>
To Top