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)
Une chaîne littérale peut être spécifiée de quatre manières différentes :
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.
<?php
echo 'ceci est une chaîne simple';
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.';
// Affiche : Arnold a dit un jour : "Je reviendrai"
echo 'Arnold a dit un jour : "Je reviendrai"';
// Affiche : Vous avez supprimé C:\*.* ?
echo 'Vous avez supprimé C:\\*.* ?';
// Affiche : Vous avez supprimé C:\*.* ?
echo 'Vous avez supprimé C:\*.* ?';
// Affiche : Cela ne s'étendra pas : \n une nouvelle ligne
echo 'Cela ne s\'étendra pas : \n une nouvelle ligne';
// Affiche : Les variables ne $s\'étendent pas $non plus
echo 'Les variables ne $s\'étendent pas $non plus';
?>
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 :
| 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.
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 #1 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 #2 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 :
PHP Parse error: Niveau d'indentation du corps invalide (attend un niveau d'indentation d'au moins 3) dans example.php à la ligne 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 #3 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 :
Erreur d'analyse PHP : indentation invalide - les onglets et les espaces ne peuvent pas être mélangés dans example.php ligne 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 #4 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"
}
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 #5 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 :
Erreur d'analyse PHP : erreur de syntaxe, identifiant inattendu "ING", attente de "]" dans example.php à la ligne 6
Pour éviter ce problème, il est sûr de suivre la règle simple : ne pas choisir comme identifiant de fermeture s'il apparaît dans le corps du texte.
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 #6 Exemple invalide, avant 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 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 #8 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 #9 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 #10 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 #11 Utilisation de guillemets doubles dans le Heredoc
<?php
echo <<<"FOOBAR"
Bonjour le monde !
FOOBAR;
?>
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 #12 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 #13 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 : \x41Exemple #14 Exemple de données statiques
<?php
class foo {
public $bar = <<<'EOT'
bar
EOT;
}
?>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.
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 :
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]*
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"
Note: S'il n'est pas possible de former un nom valide, le signe dollar reste 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 #15 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 #16 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.
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 :
<?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:\folder\{fantastic}.txt
echo "C:\folder\{$great}.txt";
// Fonctionne, affiche : C:\folder\fantastic.txt
echo "C:\\folder\\{$great}.txt";
?>Note: Comme cette syntaxe permet des expressions arbitraires, il est possible d'utiliser des variables variables dans la syntaxe avancée.
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_NOTICEpour la lecture (produisant une chaîne vide) etE_WARNINGpour 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.
É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.
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 #17 Quelques exemples de chaînes
<?php
// Obtenez le premier caractère d'une chaîne
$str = 'Ceci est un test.';
$first = $str[0];
// Obtenez le troisième caractère d'une chaîne
$third = $str[2];
// Obtenez le dernier caractère d'une chaîne.
$str = 'Ceci est toujours un test.';
$last = $str[strlen($str)-1];
// Modifiez le dernier caractère d'une chaîne
$str = 'Regardez la mer';
$str[strlen($str)-1] = 'e';
?>Les offsets de chaîne doivent être des entiers ou des chaînes ressemblant à des entiers, sinon un avertissement sera émis.
Exemple #18 Exemple d'offsets de chaîne illégaux
<?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 (à l'exception des tableaux ou objets implémentant les interfaces appropriées) en utilisant
[]ou{}renvoie silencieusementnull.
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.
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.
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().
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 :
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.
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
);
?>In PHP 8.2 using ${var} in strings is deprecated, use {$var} instead:
<?php
$juice = "apple";
// Valid. Explicitly specify the end of the variable name by enclosing it in braces:
echo "He drank some juice made of {$juice}s.";
?>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.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.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 STRINGSimple 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 . '"';
}
?>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.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.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().<?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
?>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(...)}
?>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)
?>