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)
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;
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.
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 comme identifiant de fermeture s'il apparaît dans le corps
du texte.
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;
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
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
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; } ?>
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 :
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é
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 :
// 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";
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]));
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.
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.
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 booltrue est convertie en la chaîne"1". La boolfalse 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().
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 :
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.
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.
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.
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.
<?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
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().
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:
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: