Nombres décimaux
Les tableaux
Les types
PHP Manual

## Les chaînes de caractères

Une chaîne de caractères est une série de caractères. Avant PHP 6, un caractère est la même chose qu'un octet. Ainsi, il y a exactement 256 caractères différents. Ceci impliquait également que PHP n'avait pas de support natif pour l'Unicode. Voir les fonctions utf8_encode() et utf8_decode() pour des fonctionnalités Unicode simples.

> Note: Ce n'est pas un problème pour une chaîne de caractères de devenir très grande. PHP n'impose pas de taille à une chaîne de caractères ; la seule limite est la mémoire disponible sur le système sous lequel PHP s'exécute.

### Syntaxe

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

- Entourée de guillemets simples
- Entourée de guillemets doubles
- syntaxe Heredoc
- syntaxe Nowdoc (depuis PHP 5.3.0)

#### Entourée de simple guillemet

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

Pour spécifier un guillemet simple littéral, vous devrez l'échapper d'un antislash (\). Pour spécifier un antislash littéral avant un guillemet simple, ou à la fin d'une chaîne de caractères, échappez-le deux fois (\\). Notez que si vous tentez d'échapper n'importe quel autre caractère, l'antislash s'affichera.

> Note: Contrairement aux 2 autres syntaxes, les variables et les séquences échappées des caractères spéciaux ne seront pas traitées lorsqu'elles seront dans une chaîne de caractères entourée de simple guillemet.

`<?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 dit : "I'll be back"
echo 'Arnold 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 guillemet double

Si la chaîne de caractères est entourée de guillemet double ("), PHP interprétera plus de séquences échappées 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 or 0x0B (11) en ASCII) (depuis PHP 5.2.5)
\f | Saut de page (FF ou 0x0C (12) en ASCII) (depuis PHP 5.2.5)
\\ | Antislash
\$ | Signe dollars
\" | Guillemet double
\[0-7]{1,3} | La séquence de caractères correspondant à une expression régulière est un caractère, en notation octal
\x[0-9A-Fa-f]{1,2} | La séquence de caractères correspondant à une expression régulière est un caractère, en notation hexadécimale

De la même façon que pour les chaînes entourées de simple guillemet, 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 guillemet double est que les noms de variables sont traité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, puis, une nouvelle ligne. La chaîne elle-même suit, puis, le même identifiant pour fermer la notation.

L'identifiant doit commencer la première colonne de la ligne. De plus, l'identifiant doit suivre les mêmes règles que n'importe quel 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").

Avertissement

Il est très important de noter que la ligne contenant l'identifiant ne doit contenir aucun autre caractère, mise à part, éventuellement, un point-virgule (;). Cela signifie que l'identifiant ne doit pas être indenté, et 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 sur les systèmes Unix, incluant Mac OSX (caractère \n). Le délimiteur de fermeture (pouvant être suivi d'un point-virgule) 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.

Heredoc ne peut être utilisé pour initialiser les membres d'une classe. Depuis PHP 5.3, cette limitation ne s'applique qu'aux Heredoc qui contiennent des variables.

Exemple #1 Exemple invalide

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

Heredoc se comporte exactement comme une chaîne entourée de double guillemet, sans avoir de double guillemet. Cela signifie que les guillemets dans une syntaxe Heredoc n'ont pas besoin d'être échappés, mais les codes d'échappement listés ci-dessus peuvent toujours être utilisés. Les variables seront traitées mais les mêmes attentions doivent être prises lorsque vous utilisez des variables complexes dans une syntaxe Heredoc.

Exemple #2 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 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': \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 arguments à une fonction :

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

`<?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 :

Exemple #4 Utilisation de Heredoc pour initialiser des valerus 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;
}
?>`

PHP 5.3.0 introduit aussi la possibilité pour Heredoc d'utiliser les guillemets doubles dans les déclarations :

Exemple #5 Utilisation des guillemets doubles avec Heredoc

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

> Note: Le support de la syntaxe Heredoc a été ajouté en PHP 4.

#### Nowdoc

Nowdoc est aux chaînes entourées de guillemet simple ce qu'Heredoc est aux chaînes entourées de guillemet double. Nowdoc est spécifié de manière similaire à Heredoc, mut aucune analyse n'est effectuée dans une syntaxe Nowdoc. La construction est idéale pour embarquer du code PHP ou d'autres larges blocs de texte, sans avoir besoin d'échapper quoi que ce soit. Cette syntaxe partage les mêmes fonctionnalités que le constructeur 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 guillemet simple,e.g. <<<'EOT'. Toutes les règles concernant les identifiants Heredoc sont également appliquer aux identifiants Nowdoc, et tout spécialement, celles concernant l'apparence de l'identifiant.

Exemple #6 Exemple de chaînes Nowdoc

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

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

> Note: Contrairement à Heredoc, NowDoc peut être utilisé dans n'importe quel contexte de données statiques. L'exemple typique est l'initialisation de membres ou de constantes de classe :

> Exemple #7 Exemple avec des données statiques

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

> Note: Le support Nowdoc a été ajouté en PHP 5.3.0.

#### Analyse des variables

Lorsqu'une chaîne de caractères est spécifié en guillemet double ou en Heredoc, les variables sont analysées.

Il y a 2 types de syntaxe : 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, un tableau ou un objet dans une chaîne avec un minimum d'effort.

La syntaxe complexe a été introduite en PHP 4, et se reconnaît en l'utilisation d'accolades autour de l'expression.

##### Syntaxe simple

Si un signe dollars ($) est rencontré, l'analyse prendra autant de caractères que possible pour former un nom de variable valide. Si vous entourez un nom de variable par des accolades explicitement, alors le nom de la variable n'aura aucune ambiguïté.

`<?php
$beer = 'Heineken';
echo "$beer's taste is great"; // fonctionne ; "'" est un caractère invalide pour les noms de variable
echo "He drank some $beers"; // ne fonctionne pas ; 's' est un caractère valide dans un nom de variable et la variable est en fait "$beer"
echo "He drank some ${beer}s"; // fonctionne
echo "He drank some {$beer}s"; // fonctionne
?>`

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

`<?php
// Ces exemples sont spécifiques à l'utilisation des tableaux dans des chaînes.
// Lorsqu'ils sont à l'extérieur d'une chaîne, quottez toujours les chaînes représentant
// les clés du tableau et n'utilisez pas d'{accolades}.
// Montre toutes les erreurs
error_reporting(E_ALL);
$fruits = array('strawberry' => 'red', 'banana' => 'yellow');
// Fonctionne, mais notez que cela fonctionne différemment à l'extérieur d'une chaîne
echo "A banana is $fruits[banana].";
// Fonctionne
echo "A banana is {$fruits['banana']}.";
// Fonctionne, mais PHP cherche une constante nommée banana en premier, tel que décrit ci-dessous
echo "A banana is {$fruits[banana]}.";
// Ne fonctionne pas, utilisez des accolades. Ceci produira une erreur d'analyse.
echo "A banana is $fruits['banana'].";
// Fonctionne
echo "A banana is " . $fruits['banana'] . ".";
// Fonctionne
echo "This square is $square->width meters broad.";
// Ne fonctionne pas. Pour une solution, reportez-vous à la syntaxe complexe.
echo "This square is $square->width00 centimeters broad.";
?>`

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

##### Syntaxe complexe

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

En fait, n'importe quelle valeur d'un espace de nom peut être inclue dans une chaîne de caractères avec cette syntaxe. Écrivez simple l'expression de la même façon qu'elle devrait l'être à l'extérieur de la chaîne et ensuite, entourez-là des caractères { et }. Sachant que le caractère { ne peut pas être échappé, cette syntaxe ne sera reconnue que lorsque le caractère $ suit immédiatement le caractère {. Utilisez {\$ pour afficher littéralement {$. Quelques exemples pour être clair :

`<?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
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 parceque 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 tableaux 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()}}";
?>`

> Note: Les appels de fonctions et de méthodes dans {$} fonctionnent depuis PHP 5.

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

On peut accéder et modifier les caractères 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 de voir une chaîne de caractères comme un tableau dans ce cas.

> Note: On peut également accéder à une chaîne en utilisant des accolades, comme ceci : $str{42}. Cependant, cette syntaxe est obsolète depuis PHP 6. Utilisez les crochets à la place.

Avertissement

Écrire à une position hors de l'intervalle de l'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 positions invalides produisent une alerte `E_NOTICE`. Les positions négatives produisent une alerte `E_NOTICE` en écriture, mais lisent une chaîne vide. Seul le premier caractère d'une chaîne assignée est utilisée. Assigner une chaîne vide assigne le caractère NUL.

Exemple #8 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';
?>`

> Note: L'accès aux autres types de variables en utilisant [] ou {} retournera silencieusement `NULL`.

### Fonctions et opérateurs utiles

Une chaîne de caractères peut être concaténée en utilisant l'opérateur '.' (point). Notez que l'opérateur '+' (addition) ne fonctionnera pas. Reportez-vous aux opérateurs de chaîne pour plus d'informations.

Il y a beaucoup de fonctions utiles pour la manipulation de chaîne de caractères.

Reportez-vous à la section sur les fonctions des chaînes de caractères pour plus de précisions et à la section sur les expressions rationnelles ou sur les expressions rationnelles compatibles Perl pour des recherches et des remplacements avancés.

Il y a également des fonctions pour les URL, et des fonctions pour chiffrer, déchiffrer les chaînes de caractères (mcrypt et mhash).

Et pour finir, reportez-vous aux 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 d'une 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 lors de l'utilisation des fonctions echo() ou print() ou lorsqu'une variable est comparée à une chaîne. Les sections sur les types et sur le transtypage expliquent ce qui suit de manière plus détaillées. Reportez-vous également à la fonction settype().

La valeur booléenne `TRUE` est convertie en la chaîne "1". La valeur booléenne `FALSE` est convertie en "" (une chaîne vide). Ceci permet les conversions vers et depuis une chaîne et un booléen.

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

> Note: Le point décimal est définit dans la locale du script (catégorie LC_NUMERIC). Reportez-vous à la fonction setlocale().

Les tableaux sont toujours convertis en la chaîne "Array" ; ainsi, echo() et print() ne peuvent être utilisés pour afficher le contenu d'un tableau. Pour afficher un seul élément, utilisez un constructeur comme echo $arr['foo']. Voir ci-dessous pour des astuces permettant d'afficher le contenu complet.

Les objets en PHP 4 sont toujours convertis en la chaîne "Object". Pour afficher les valeurs des membres de l'objet (aux fins de déboguage, par exemple), lisez le paragraphes ci-dessous. Pour récupérer le nom de la classe de l'objet, utilisez la fonction get_class(). Depuis PHP 5, la méthode __toString est utilisée lorsqu'elle peut s'appliquer.

Les ressources sont toujours converties en la chaîne "Resource id #1", où 1 est le nombre unique assigné à la ressource par PHP au moment de l'exécution. Ne vous fiez pas à cette structure, il est possible qu'elle change. Pour récupérer le type de la ressource, utilisez la fonction get_resource_type().

`NULL` est toujours converti en une chaîne vide.

Au vue 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 la valeur contenue dans ce type. Reportez-vous aux fonctions print_r() et var_dump() pour plus d'informations sur le contenu de ces types.

La plupart des valeurs en PHP peuvent également être convertie en chaîne de caractères afin de les stocker. Cette méthode est appelée "linéarisation", et est effectuée par la fonction serialize(). Si le moteur PHP a été compilé avec le support WDDX, les valeurs PHP peuvent également être linéarisées en XML.

### Conversion de chaînes en nombres

Lorsqu'une chaîne de caractères est évaluée dans un contexte numérique, la valeur et le type résultants sont déterminés comme suit.

Si la chaîne de caractères ne contient aucun '.', 'e', ou 'E' et que la valeur numérique est dans l'intervalle de représentation des entiers (et notamment plus petite que `PHP_INT_MAX`), alors la chaîne de caractères sera transformée en entier. Dans les autres cas, elle sera interprétée comme un nombre décimal.

La valeur est fournie par la portion initiale de la chaîne de caractères. Si la chaîne de caractères commence par un caractère numérique valide, ce sera la valeur utilisée. Sinon, la valeur sera de 0 (zéro). Une valeur numérique valide est un signe optionnel, suivi par un ou plusieurs nombres (contenant, optionnellement, un point décimal), suivi par, éventuellement, un exponentiel. L'exponentiel est un 'e' ou 'E' suivi par un ou plusieurs nombres.

`<?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 sur ces conversions, reportez-vous au manuel Unix de la fonction strtod(3).

Pour tester un exemple 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 possible en C. Utilisez la fonction ord() et la fonction chr() pour convertir les caractères en codes ASCII.

Nombres décimaux
Les tableaux
Les types
PHP Manual