## Chaînes

Une chaîne est une série de caractères, où un caractère est le même qu'un octet. Cela signifie que PHP ne prend en charge qu'un ensemble de 256 caractères, et n'offre donc pas de prise en charge native de l'Unicode. Voir les détails du type chaîne.

> Note: Sur les versions 32 bits, une chaîne peut être aussi grande que 2 Go (2147483647 octets maximum)

### Syntaxe

Une chaîne littérale peut être spécifiée de quatre manières différentes :

- entre guillemets simples
- entre guillemets doubles
- syntaxe heredoc
- syntaxe nowdoc

#### Entre guillemets simples

La manière la plus simple de spécifier une chaîne est de l'encadrer de guillemets simples (le caractère `'`).

Pour spécifier un guillemet simple littéral, échappez-le avec un antislash (`\`). Pour spécifier un antislash littéral, doublez-le (`\\`). Toutes les autres occurrences de l'antislash seront traitées comme un antislash littéral : cela signifie que les autres séquences d'échappement que vous pourriez connaître, telles que `\r` ou `\n`, seront sorties littéralement comme spécifié plutôt que d'avoir une signification spéciale.

> Note: Contrairement aux guillemets doubles et syntaxes heredoc, les variables et les séquences d'échappement pour les caractères spéciaux ne seront pas étendues lorsqu'elles se trouvent dans des chaînes entre guillemets simples.

Exemple #1 Variantes de syntaxe

`<?php
echo 'ceci est une chaîne simple', PHP_EOL;
echo 'Vous pouvez également avoir des nouvelles intégrées dans
les chaînes de cette manière, car c'est
acceptable de le faire.', PHP_EOL;
// Affiche : Arnold a dit un jour : "Je reviendrai"
echo 'Arnold a dit un jour : "Je reviendrai"', PHP_EOL;
// Affiche : Vous avez supprimé C:\*.* ?
echo 'Vous avez supprimé C:\\*.* ?', PHP_EOL;
// Affiche : Vous avez supprimé C:\*.* ?
echo 'Vous avez supprimé C:\*.* ?', PHP_EOL;
// Affiche : Cela ne s'étendra pas : \n une nouvelle ligne
echo 'Cela ne s\'étendra pas : \n une nouvelle ligne', PHP_EOL;
// Affiche : Les variables ne $s\'étendent pas $non plus
echo 'Les variables ne $s\'étendent pas $non plus', PHP_EOL;
?>`

#### Entre guillemets doubles

Si la chaîne est encadré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` | retour à la ligne (LF ou 0x0A (10) en ASCII)
`\r` | retour chariot (CR ou 0x0D (13) en ASCII)
`\t` | tabulation horizontale (HT ou 0x09 (9) en ASCII)
`\v` | tabulation verticale (VT ou 0x0B (11) en ASCII)
`\e` | échapper (ESC ou 0x1B (27) en ASCII)
`\f` | avance de formulaire (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 régulière `[0-7]{1,3}` est un caractère en notation octale (par exemple, `"\101" === "A"`), qui déborde silencieusement pour s'adapter à un octet (par exemple, `"\400" === "\000"`)
`\x[0-9A-Fa-f]{1,2}` | Hexadécimal : la séquence de caractères correspondant à l'expression régulière `[0-9A-Fa-f]{1,2}` est un caractère en notation hexadécimale (par exemple, `"\x41" === "A"`)
`\u{[0-9A-Fa-f]+}` | Unicode : la séquence de caractères correspondant à l'expression régulière `[0-9A-Fa-f]+` est un point de code Unicode, qui sera sorti dans la chaîne sous la représentation UTF-8 de ce point de code. Les accolades sont requises dans la séquence. Par exemple, `"\u{41}" === "A"`

Comme pour les chaînes entre guillemets simples, échapper tout autre caractère entraînera également l'impression de l'antislash.

La caractéristique la plus importante des chaînes entre guillemets doubles est le fait que les noms de variables seront étendus. Voir l'interpolation de chaînes pour plus de détails.

#### Heredoc

Une troisième manière de délimiter les chaînes 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 à nouveau pour fermer la citation.

L'identifiant de fermeture peut être indenté par des espaces ou des tabulations, auquel cas l'indentation sera supprimée de toutes les lignes dans la chaîne doc. Avant PHP 7.3.0, l'identifiant de fermeture doit commencer dans la première colonne de la ligne.

De plus, l'identifiant de fermeture doit suivre les mêmes règles de nommage que tout autre label en PHP : il doit contenir uniquement des caractères alphanumériques et des soulignés, et doit commencer par un caractère non numérique ou un souligné.

Exemple #2 Exemple de base de Heredoc à partir de PHP 7.3.0

`<?php
// pas d'indentation
echo <<<END
a
b
c
\n
END;
// 4 espaces d'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 fermeture est indenté plus que n'importe quelle ligne du corps, alors une ParseError sera levée :

Exemple #3 L'identifiant de fermeture ne doit pas être indenté plus que n'importe quelle ligne du corps

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

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

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

Si l'identifiant de fermeture est indenté, des tabulations peuvent également être utilisées, cependant, les tabulations et les espaces ne doivent pas être mélangés concernant l'indentation de l'identifiant de fermeture et l'indentation du corps (jusqu'à l'identifiant de fermeture). Dans l'un de ces cas, une ParseError sera levée. Ces contraintes d'espace ont été incluses car le mélange d'espaces et de tabulations pour l'indentation nuit à la lisibilité.

Exemple #4 Indentation différente pour le corps (espaces) identifiant de fermeture

`<?php
// Tout le code suivant ne fonctionne pas.
// indentation différente pour le corps (espaces) marqueur de fin (tabulations)
{
echo <<<END
a
END;
}
// mélange d'espaces et de tabulations dans le corps
{
echo <<<END
a
END;
}
// mélange d'espaces et de tabulations dans le marqueur de fin
{
echo <<<END
a
END;
}`

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

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

L'identifiant de fermeture pour la chaîne du corps n'est pas requis pour être suivi d'un point-virgule ou d'un saut de ligne. Par exemple, le code suivant est autorisé à partir de PHP 7.3.0 :

Exemple #5 Continuation d'une expression après un identifiant de fermeture

`<?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 fermeture a été trouvé au début d'une ligne, alors peu importe s'il faisait partie d'un autre mot, il peut être considéré comme l'identifiant de fermeture et provoquer une ParseError.

Exemple #6 L'identifiant de fermeture dans le corps de la chaîne tend à provoquer une ParseError

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

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

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

Pour éviter ce problème, il est sûr de suivre la règle simple : ne pas choisir un mot qui apparaît dans le corps du texte en tant qu identifiant de fermeture.

Avertissement

Avant PHP 7.3.0, il est très important de noter que la ligne contenant l' identifiant de fermeture ne doit contenir aucun autre caractère, sauf un point-virgule (`;`). Cela signifie surtout que l'identifiant ne peut pas être indenté, et il ne doit pas y avoir d'espaces ou d'onglets avant ou après le point-virgule. Il est également important de réaliser que le premier caractère avant l'identifiant de fermeture doit être un saut de ligne tel que défini par le système d'exploitation local. C'est `\n` sur les systèmes UNIX, y compris macOS. Le délimiteur de fermeture doit également être suivi d'un saut de ligne.

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

Exemple #7 Exemple invalide, avant PHP 7.3.0

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

Exemple #8 Exemple valide, même avant PHP 7.3.0

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

Les heredocs contenant des variables ne peuvent pas être utilisés pour initialiser des propriétés de classe.

Le texte heredoc se comporte exactement comme une string entre guillemets doubles, sans les guillemets. Cela signifie que les guillemets dans un heredoc n'ont pas besoin d'être échappés, mais les codes d'échappement mentionnés ci-dessus peuvent toujours être utilisés. Les variables sont développées, mais il faut prendre le même soin lors de l'expression de variables complexes à l'intérieur d'un heredoc que pour les strings.

Exemple #9 Exemple de citation de chaîne heredoc

`<?php
$str = <<<EOD
Exemple de chaîne
s'étendant sur plusieurs lignes
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". Je suis en train d'imprimer $foo->foo.
Maintenant, j'imprime {$foo->bar[1]}.
Cela devrait imprimer un 'A' majuscule : \x41
EOT;
?>`

L'exemple ci-dessus va afficher :

    Mon nom est "MyName". Je suis en train d'imprimer Foo.
    Maintenant, j'imprime Bar2.
    Cela devrait imprimer un 'A' majuscule : A

Il est également possible d'utiliser la syntaxe heredoc pour passer des données aux arguments de fonction :

Exemple #10 Heredoc dans les exemples d'arguments

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

Il est possible d'initialiser des variables statiques et des propriétés/constants de classe en utilisant la syntaxe heredoc :

Exemple #11 Utilisation d'Heredoc pour initialiser des valeurs statiques

`<?php
// Variables statiques
function foo()
{
static $bar = <<<LABEL
Rien ici...
LABEL;
}
// Propriétés/constants de classe
class foo
{
const BAR = <<<FOOBAR
Exemple de constante
FOOBAR;
public $baz = <<<FOOBAR
Exemple de propriété
FOOBAR;
}
?>`

L'identifiant d'ouverture du Heredoc peut éventuellement être encadré de guillemets doubles :

Exemple #12 Utilisation de guillemets doubles dans le Heredoc

`<?php
echo <<<"FOOBAR"
Bonjour le monde !
FOOBAR;
?>`

#### Nowdoc

Les nowdocs sont aux chaînes entre guillemets simples ce que les heredocs sont aux chaînes entre guillemets doubles. Un nowdoc est spécifié de manière similaire à un heredoc, mais aucune interpolation de chaîne n'est effectuée à l'intérieur d'un nowdoc. La construction est idéale pour intégrer du code PHP ou d'autres blocs de texte volumineux sans avoir besoin d'échapper. Il partage certaines caractéristiques avec la construction SGML `<![CDATA[ ]]>`, en ce sens qu'elle déclare un bloc de texte qui n'est pas destiné à être analysé.

Un nowdoc est identifié par la même séquence `<<<` utilisée pour les heredocs, mais l'identifiant qui suit est encadré de guillemets simples, par exemple `<<<'EOT'`. Toutes les règles pour les identifiants heredoc s'appliquent également aux identifiants nowdoc, en particulier celles concernant l'apparence de l'identifiant de fermeture.

Exemple #13 Exemple de citation de chaîne nowdoc

`<?php
echo <<<'EOD'
Exemple de chaîne s'étendant sur plusieurs lignes
utilisant la syntaxe nowdoc. Les barres obliques inverses sont toujours traitées littéralement,
c'est-à-dire \\ et \'.
EOD;`

L'exemple ci-dessus va afficher :

    Exemple de chaîne s'étendant sur plusieurs lignes
    utilisant la syntaxe nowdoc. Les barres obliques inverses sont toujours traitées littéralement,
    c'est-à-dire \\ et \'.

Exemple #14 Exemple de citation 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'
Mon nom est "$name". Je suis en train d'imprimer $foo->foo.
Maintenant, j'imprime {$foo->bar[1]}.
Cela ne devrait pas imprimer un 'A' majuscule : \x41
EOT;
?>`

L'exemple ci-dessus va afficher :

    Mon nom est "$name". Je suis en train d'imprimer $foo->foo.
    Maintenant, j'imprime {$foo->bar[1]}.
    Cela ne devrait pas imprimer un 'A' majuscule : \x41

Exemple #15 Exemple de données statiques

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

#### Interpolation de chaînes

Lorsqu'une chaîne est spécifiée entre guillemets doubles ou avec heredoc, des variables peuvent être substituées à l'intérieur.

Il existe deux types de syntaxe : une de base et une avancée. La syntaxe de base est la plus courante et la plus pratique. Elle offre un moyen d'incorporer une variable, une valeur tableau ou une propriété objet dans une chaîne avec un minimum d'effort.

##### Syntaxe de base

Si un signe dollar (`$`) est rencontré, les caractères qui le suivent et qui peuvent être utilisés dans un nom de variable seront interprétés comme tels et substitués.

`<?php
$juice = "pomme";
echo "Il a bu un peu de $juice jus." . PHP_EOL;
?>`

L'exemple ci-dessus va afficher :

    Il a bu un peu de pomme jus.

Formuellement, la structure pour la syntaxe de substitution de variable de base est la suivante :

Exemple #16 Interpolation de chaînes

    string-variable::
         variable-name   (offset-or-property)?
       | ${   expression   }

    offset-or-property::
         offset-in-string
       | property-in-string

    offset-in-string::
         [   name   ]
       | [   variable-name   ]
       | [   integer-literal   ]

    property-in-string::
         ->  name

    variable-name::
         $   name

    name::
         [a-zA-Z_\x80-\xff][a-zA-Z0-9_\x80-\xff]*

Avertissement

La syntaxe `${ expression }` est dépréciée depuis PHP 8.2.0, car elle peut être interprétée comme des variables de variables :

`<?php
const foo = 'bar';
$foo = 'foo';
$bar = 'bar';
var_dump("${foo}");
var_dump("${(foo)}");
?>`

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

    Déprécié : Utiliser ${var} dans des chaînes est déprécié, utilisez {$var} à la place dans le fichier à la ligne 6

    Déprécié : Utiliser ${expr} (variables de variables) dans des chaînes est déprécié, utilisez {${expr}} à la place dans le fichier à la ligne 9
    string(3) "foo"
    string(3) "bar"

L'exemple ci-dessus va afficher :

    string(3) "foo"
    string(3) "bar"

La syntaxe d'interpolation de chaîne avancée devrait être utilisée à la place.

> Note: S'il n'est pas possible de former un nom valide, le signe dol tel quel dans la chaîne :

> `<?php
> echo "Aucune interpolation $ n'a eu lieu\n";
> echo "Aucune interpolation $\n n'a eu lieu\n";
> echo "Aucune interpolation $2 n'a eu lieu\n";
> ?>`

> L'exemple ci-dessus va afficher :

>     Aucune interpolation $  n'a eu lieu
>     Aucune interpolation $
>      n'a eu lieu
>     Aucune interpolation $2 n'a eu lieu

Exemple #17 Interpolation de la valeur de la première dimension d'un tableau ou d'une propriété

`<?php
$juices = array("pomme", "orange", "string_key" => "violet");
echo "Il a bu un peu de $juices[0] jus.";
echo PHP_EOL;
echo "Il a bu un peu de $juices[1] jus.";
echo PHP_EOL;
echo "Il a bu un peu de $juices[string_key] jus.";
echo PHP_EOL;
class A {
public $s = "chaîne";
}
$o = new A();
echo "Valeur de l'objet : $o->s.";
?>`

L'exemple ci-dessus va afficher :

    Il a bu un peu de pomme jus.
    Il a bu un peu de orange jus.
    Il a bu un peu de violet jus.
    Valeur de l'objet : chaîne.

> Note: La clé du tableau doit être non citée, et il n'est donc pas possible de référencer une constante comme clé avec la syntaxe de base. Utilisez la syntaxe avancée à la place.

Depuis PHP 7.1.0, les indices numériques négatifs sont également supportés.

Exemple #18 Indices numériques négatifs

`<?php
$string = 'chaîne';
echo "Le caractère à l'indice -2 est $string[-2].", PHP_EOL;
$string[-3] = 'o';
echo "Changer le caractère à l'indice -3 en o donne $string.", PHP_EOL;
?>`

L'exemple ci-dessus va afficher :

    Le caractère à l'indice -2 est n.
    Changer le caractère à l'indice -3 en o donne strong.

Pour tout ce qui est plus complexe, la syntax avancée doit être utilisée.

##### Syntaxe avancée (syntax de accolades)

La syntaxe avancée permet l'interpolation de variables avec des accesseurs arbitraires.

Toute variable scalaire, élément de tableau ou propriété d'objet (statique ou non) avec une représentation chaîne peut être incluse via cette syntaxe. L'expression est écrite de la même manière que celle qui apparaîtrait en dehors de la chaîne, puis entourée de `{` et `}`. Étant donné que `{` ne peut pas être échappé, cette syntaxe ne sera reconnue que lorsque le `$` suit immédiatement le `{`. Utilisez `{\$` pour obtenir un `{$`. Voici quelques exemples pour clarifier :

Exemple #19 Syntaxe avec des accolades

`<?php
const DATA_KEY = 'const-key';
$great = 'fantastique';
$arr = [
'1',
'2',
'3',
[41, 42, 43],
'key' => 'Valeur indexée',
'const-key' => 'Clé avec un signe moins',
'foo' => ['foo1', 'foo2', 'foo3']
];
// Ne fonctionnera pas, affiche : This is { fantastic}
echo "Ceci est { $great}";
// Fonctionne, affiche : This is fantastic
echo "Ceci est {$great}";
class Square {
public $width;
public function __construct(int $width) { $this->width = $width; }
}
$square = new Square(5);
// Fonctionne
echo "Ce carré mesure {$square->width}00 centimètres de large.";
// Fonctionne, les clés entre guillemets ne fonctionnent qu'avec la syntaxe des accolades
echo "Cela fonctionne : {$arr['key']}";
// Fonctionne
echo "Cela fonctionne : {$arr[3][2]}";
echo "Cela fonctionne : {$arr[DATA_KEY]}";
// Lors de l'utilisation de tableaux multidimensionnels, utilisez toujours des accolades autour des tableaux
// lorsqu'ils sont à l'intérieur de chaînes
echo "Cela fonctionne : {$arr['foo'][2]}";
echo "Cela fonctionne : {$obj->values[3]->name}";
echo "Cela fonctionne : {$obj->$staticProp}";
// Ne fonctionnera pas, affiche : C:\directory\{fantastic}.txt
echo "C:\directory\{$great}.txt";
// Fonctionne, affiche : C:\directory\fantastic.txt
echo "C:\\directory\\{$great}.txt";
?>`

> Note: Comme cette syntaxe permet des expressions arbitraires, il est possible d'utiliser des variables variables dans la syntaxe avancée.

#### Accès et modification de chaîne par caractère

Les caractères dans les chaînes peuvent être accédés et modifiés en spécifiant l'offset basé sur zéro du caractère souhaité après la chaîne à l'aide de crochets array, comme dans $str[42]. Pensez à une chaîne comme à un tableau de caractères à cette fin. Les fonctions substr() et substr_replace() peuvent être utilisées lorsque vous souhaitez extraire ou remplacer plus d'un caractère.

> Note: Depuis PHP 7.1.0, les offsets de chaîne négatifs sont également supportés. Ceux-ci spécifient l'offset à partir de la fin de la chaîne. Auparavant, les offsets négatifs émettaient `E_NOTICE` pour la lecture (produisant une chaîne vide) et `E_WARNING` pour l'écriture (laissant la chaîne intacte).

> Note: Avant PHP 8.0.0, les chaînes pouvaient également être accédées en utilisant des accolades, comme dans $str{42}, pour le même objectif. Cette syntaxe de accolades a été dépréciée depuis PHP 7.4.0 et n'est plus prise en charge depuis PHP 8.0.0.

Avertissement

Écrire à un offset hors de portée remplit la chaîne d'espaces. Les types non entiers sont convertis en entier. Un type d'offset illégal émet `E_WARNING`. Seul le premier caractère d'une chaîne assignée est utilisé. Depuis PHP 7.1.0, assigner une chaîne vide génère une erreur fatale. Auparavant, cela assignait un octet NULL.

Avertissement

En interne, les chaînes PHP sont des tableaux d'octets. En conséquence, accéder ou modifier une chaîne à l'aide de crochets de tableau n'est pas sûr pour les multi-octets, et ne devrait être fait qu'avec des chaînes en encodage à un seul octet tel que ISO-8859-1.

> Note: Depuis PHP 7.1.0, appliquer l'opérateur d'index vide sur une chaîne vide génère une erreur fatale. Auparavant, la chaîne vide était silencieusement convertie en tableau.

Exemple #20 Quelques exemples de chaînes

`<?php
// Obtenez le premier caractère d'une chaîne
$str = 'Ceci est un test.';
$first = $str[0];
var_dump($first);
// Obtenez le troisième caractère d'une chaîne
$third = $str[2];
var_dump($third);
// Obtenez le dernier caractère d'une chaîne.
$str = 'Ceci est toujours un test.';
$last = $str[strlen($str)-1];
var_dump($last);
// Modifiez le dernier caractère d'une chaîne
$str = 'Regardez la mer';
$str[strlen($str)-1] = 'e';
var_dump($str);
?>`

Les offsets de chaîne doivent être des entiers ou des chaînes ressemblant à des entiers, sinon un avertissement sera émis.

Exemple #21 Exemple d'offsets de chaîne illégaux

`<?php
$str = 'abc';
foreach ($keys as $keyToTry) {
var_dump(isset($str[$keyToTry]));
try {
var_dump($str[$keyToTry]);
} catch (TypeError $e) {
echo $e->getMessage(), PHP_EOL;
}
echo PHP_EOL;
}
?>`

L'exemple ci-dessus va afficher :

    bool(true)
    string(1) "b"

    bool(false)
    Cannot access offset of type string on string

    bool(false)
    Cannot access offset of type string on string

    bool(false)

    Warning: Illegal string offset "1x" in Standard input code on line 10
    string(1) "b"

> Note:

> Accéder à des variables d'autres types (à l'exception des tableaux ou objets implémentant les interfaces appropriées) en utilisant `[]` ou `{}` renvoie silencieusement `null`.

> Note:

> Les caractères dans les littéraux de chaîne peuvent être accédés en utilisant `[]` ou `{}`.

> Note:

> Accéder à des caractères dans des littéraux de chaîne en utilisant la syntaxe `{}` a été déprécié dans PHP 7.4. Cela a été supprimé dans PHP 8.0.

### Fonctions et opérateurs utiles

Les chaînes peuvent être concaténées à l'aide de l'opérateur '.' (point). Notez que l'opérateur '+' (addition) ne fonctionnera pas pour cela. Consultez les opérateurs de chaîne pour plus d'informations.

Il existe plusieurs fonctions utiles pour la manipulation des chaînes.

Consultez la section des fonctions de chaîne pour les fonctions générales, et la section des fonctions d'expressions régulières compatibles Perl pour des fonctionnalités avancées de recherche et de remplacement.

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

Enfin, consultez également les fonctions de type caractère.

### Conversion en chaîne

Une valeur peut être convertie en chaîne à l'aide du cast `(string)` ou de la fonction strval(). La conversion en chaîne est effectuée automatiquement dans le contexte d'une expression où une chaîne est nécessaire. Cela se produit lors de l'utilisation des fonctions echo ou print, ou lorsque une variable est comparée à une chaîne. Les sections sur Types et Type Juggling clarifieront ce qui suit. Voir également la fonction settype().

Une valeur bool `true` est convertie en la chaîne `"1"`. La bool `false` est convertie en `""` (la chaîne vide). Cela permet une conversion aller-retour entre les valeurs bool et chaîne.

Un int ou float est converti en une chaîne représentant le nombre textuellement (y compris la partie exponentielle pour les float). Les nombres à virgule flottante peuvent être convertis à l'aide de la notation exponentielle (`4.1E+6`).

> Note:

> À partir de PHP 8.0.0, le caractère de la virgule décimale est toujours un point ("`.`"). Avant PHP 8.0.0, le caractère de la virgule décimale est défini dans la locale du script (catégorie LC_NUMERIC). Consultez la fonction setlocale().

Les tableaux sont toujours convertis en la chaîne `"Array"`; de ce fait, echo et print ne peuvent pas à eux seuls afficher le contenu d'un tableau. Pour afficher un seul élément, utilisez une construction telle que `echo $arr['foo']`. Consultez ci-dessous des conseils sur la visualisation de tout le contenu.

Afin de convertir des objets en chaînes, la méthode magique __toString doit être utilisée.

Les ressources sont toujours converties en chaînes avec la structure `"Resource id #1"`, où `1` est le numéro de ressource attribué au ressource par PHP à l'exécution. Bien que la structure exacte de cette chaîne ne doive pas être considérée comme fiable et soit sujette à changement, elle sera toujours unique pour une ressource donnée pendant la durée d'exécution d'un script (c'est-à-dire une requête Web ou un processus CLI) et ne sera pas réutilisée. Pour obtenir le type d'une ressource, utilisez la fonction get_resource_type().

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

Comme indiqué ci-dessus, convertir directement un tableau, un objet ou une ressource en chaîne ne fournit pas d'informations utiles sur la valeur au-delà de son type. Consultez les fonctions print_r() et var_dump() pour des moyens plus efficaces d'inspecter le contenu de ces types.

La plupart des valeurs PHP peuvent également être converties en chaînes pour un stockage permanent. Cette méthode est appelée sérialisation et est effectuée par la fonction serialize().

### Détails du type chaîne

La chaîne en PHP est implémentée comme un tableau d'octets et un entier indiquant la longueur du tampon. Elle n'a aucune information sur la façon dont ces octets se traduisent en caractères, laissant cette tâche au programmeur. Il n'y a pas de limitations sur les valeurs que la chaîne peut être composée ; en particulier, les octets de valeur `0` (« octets NUL ») sont autorisés partout dans la chaîne (cependant, quelques fonctions, dites dans ce manuel de ne pas être « sûres pour les binaires », peuvent transmettre les chaînes à des bibliothèques qui ignorent les données après un octet NUL.)

Cette nature du type chaîne explique pourquoi il n'y a pas de type « octet » distinct en PHP – les chaînes prennent ce rôle. Les fonctions qui ne renvoient pas de données textuelles – par exemple, des données arbitraires lues à partir d'une socket réseau – renverront tout de même des chaînes.

Étant donné que PHP ne dicte pas un encodage spécifique pour les chaînes, on pourrait se demander comment les littéraux de chaînes sont encodés. Par exemple, la chaîne `"á"` est-elle équivalente à `"\xE1"` (ISO-8859-1), `"\xC3\xA1"` (UTF-8, forme C), `"\x61\xCC\x81"` (UTF-8, forme D) ou toute autre représentation possible ? La réponse est que la chaîne sera encodée de la manière dont elle est encodée dans le fichier script. Ainsi, si le script est écrit en ISO-8859-1, la chaîne sera encodée en ISO-8859-1 et vice versa. Cependant, cela ne s'applique pas si Zend Multibyte est activé ; dans ce cas, le script peut être écrit dans un encodage arbitraire (qui est explicitement déclaré ou détecté) et ensuite converti dans un certain encodage interne, qui sera ensuite l'encodage utilisé pour les littéraux de chaînes. Notez qu'il y a certaines contraintes sur l'encodage du script (ou sur l'encodage interne, si Zend Multibyte est activé) – cela signifie presque toujours que cet encodage doit être un superset compatible de l'ASCII, tel que UTF-8 ou ISO-8859-1. Notez cependant que les encodages dépendants de l'état où les mêmes valeurs d'octets peuvent être utilisées dans des états de décalage initiaux et non initiaux peuvent poser problème.

Bien sûr, afin d'être utiles, les fonctions qui opèrent sur du texte peuvent devoir faire certaines hypothèses sur la façon dont la chaîne est encodée. Malheureusement, il y a beaucoup de variations à ce sujet dans les fonctions de PHP :

- Certaines fonctions supposent que la chaîne est encodée dans un (tout) encodage à un octet, mais elles n'ont pas besoin d'interpréter ces octets comme des caractères spécifiques. C'est le cas, par exemple, de substr(), strpos(), strlen() ou strcmp(). Une autre façon de penser à ces fonctions est qu'elles opèrent sur des tampons mémoire, c'est-à-dire qu'elles fonctionnent avec des octets et des décalages d'octets.
- D'autres fonctions reçoivent l'encodage de la chaîne, supposant éventuellement un défaut si aucune information de ce type n'est donnée. C'est le cas de htmlentities() et de la majorité des fonctions dans l'extension mbstring.
- D'autres utilisent la locale actuelle (voir setlocale()), mais fonctionnent octet par octet.
- Enfin, elles peuvent simplement supposer que la chaîne utilise un encodage spécifique, généralement UTF-8. C'est le cas de la plupart des fonctions dans l'extension intl et dans l'extension PCRE (dans ce dernier cas, seulement lorsque le modificateur `u` est utilisé).

En fin de compte, cela signifie que l'écriture de programmes corrects utilisant Unicode dépend d'éviter soigneusement les fonctions qui ne fonctionneront pas et qui corrompront très probablement les données, et d'utiliser à la place les fonctions qui se comportent correctement, généralement provenant des extensions intl et mbstring. Cependant, utiliser des fonctions capables de gérer les encodages Unicode n'est que le début. Peu importe les fonctions que le langage fournit, il est essentiel de connaître la spécification Unicode. Par exemple, un programme qui suppose qu'il n'y a que des majuscules et des minuscules fait une hypothèse erronée.