Entourée de 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, vous devrez l'échapper à l'aide d'un antislash (\). Pour spécifier un antislash littéral, doublez-le (\\). Notez que si vous tentez d'échapper n'importe quel autre caractère, l'antislash s'affichera, 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';
?>

Entourée de guillemets doubles

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

De la même façon que pour les chaînes entourées de guillemets simples, l'échappement de tout autre caractère affichera l'antislash. Avant PHP 5.1.1, l'antislash de \{$var} n'était pas affiché.

La fonctionnalité la plus intéressante des chaînes entourées de 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 3è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 en elle-même vient ensuite, suivie du même identifiant pour fermer la notation.

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").

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

Heredoc se comporte exactement comme une chaîne entourée de 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 attentions doivent être prises lorsque vous utilisez des variables complexes dans une syntaxe Heredoc qu'avec les autres types de chaînes.

<?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 foo()
	{
		$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;
?>

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

Depuis PHP 5.3.0, il est possible d'initialiser les variables statiques et les propriétés ou constantes de classes avec la syntaxe Heredoc :

<?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;
}
?>

Depuis PHP 5.3.0, l'identifiant de début de syntaxe Heredoc peut éventuellement être écrit entre guillemets doubles :

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

Nowdoc

Nowdoc est aux chaînes entourées de guillemets simples ce qu'Heredoc est aux chaînes entourées de guillemets doubles. Un Nowdoc est spécifié de manière similaire à un Heredoc, mais aucune analyse n'est effectuée dans une construction 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.

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

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

	function foo()
	{
		$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;
?>

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

Note:

Le support de la syntaxe Nowdoc a été ajouté en PHP 5.3.0.

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 avec un minimum d'effort.

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

<?php
$juice = "pomme";

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

// Invalide. "s" est un caractère valide dans un nom de variable, mais la variable est $juice.
echo "Il a bu du jus constitué de $juices.";
?>

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

<?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 à base de $juice[0]s.".PHP_EOL; // Ne fonctionne pas
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
?>

<?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}";
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.
// En d'autres termes, ceci fonctionnera, mais uniquement parce que PHP cherchera d'abord
// une constante nommée foo ; une erreur de niveau E_NOTICE (constante indéfinie) sera émise.
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()}";
?>

<?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";
?>

I am bar.
I am bar.

<?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) en utilisant la même syntaxe que pour les tableaux, comme pour la variable $str[42]. Il convient dans ce cas de voir une chaîne de caractères comme un tableau. Les fonctions substr() et substr_replace() peuvent être utilisées lorsque vous voulez extraire ou remplacer plus d'un caractère.

Note: On peut également accéder à une chaîne en utilisant des accolades, comme ceci : $str{42}.

<?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';

?>

Depuis PHP 5.4, la position dans une chaîne doit être un entier, ou des chaînes pouvant être converties en entier, sinon, une alerte sera émise. Auparavant, une position comme "foo" était transformée silencieusement en 0.

<?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']));
?>

<?php
$foo = 1 + "10.5";				// $foo est un nombre à virgule flottante (11.5)
$foo = 1 + "-1.3e3";			  // $foo est un nombre à virgule flottante (-1299)
$foo = 1 + "bob-1.3e3";		   // $foo est un entier (1)
$foo = 1 + "bob3";				// $foo est un entier (1)
$foo = 1 + "10 Small Pigs";	   // $foo est un entier (11)
$foo = 4 + "10.2 Little Piggies"; // $foo est un nombre à virgule flottante (14.2)
$foo = "10.0 pigs " + 1;		  // $foo est un nombre à virgule flottante (11)
$foo = "10.0 pigs " + 1.0;		// $foo est un nombre à virgule flottante (11)
?>

Pour plus d'informations à propos de cette conversion, reportez-vous au manuel Unix de la fonction strtod(3).

Pour tester un des exemples de cette section, copiez/collez l'exemple et insérez la ligne suivante pour voir ce qu'il se passe :

<?php
echo "Le type de \$foo==$foo; est " . gettype ($foo) . "<br />\n";
?>

Ne vous attendez pas à récupérer le code d'un caractère en le convertissant en entier, comme cela est fait en C. Utilisez les fonctions ord() et chr() pour convertir entre caractères et codes ASCII.

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

Le type string en PHP est implémenté sous la forme d'un tableau d'octets accompagné d'un entier indiquant la longueur du buffer. 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 (“NUL bytes”) 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 buffers mémoires ; 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 la fonction setlocale()), mais opèrent octets par octets. C'est le cas des fonctions strcasecmp(), strtoupper(), ou ucfirst(). Cela signifie qu'elles ne peuvent être utilisées qu'avec les encodages sur un seul octet, et si l'encodage correspond à la locale. Par exemple, strtoupper("á") peut retourner "Á" si la locale est correctement positionnée et si á est encodé sur un seul octet. Si la chaîne est encodée en UTF-8, le résultat correct ne sera pas retourné, et la chaîne résultante pourra être (ou non) corrompue, suivant la locale courante.
• Enfin, elles peuvent juste supposer que la chaîne utilise un encodage spécifique, comme 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é). Bien que ce soit en raison de leur buts spécifiques, la fonction utf8_decode() assume un encodage UTF-8 et la fonction utf8_encode() pré-suppose un encodage ISO-8859-1.

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.