Les chaînes de caractères
Une chaîne de caractères est une série de caractères, où un caractère est
la même chose qu'un octet. De ce fait, PHP ne supporte que les jeux de
caractères comportant 256 caractères différents, et, donc,
n'a pas de support natif pour l'Unicode.
Reportez-vous aux
détails sur le type
chaîne de caractères pour plus d'informations.
Note:
Sur les systèmes 32-bit une chaîne de caractères peut être d'une taille allant
jusqu'au plus 2Go (2147483647 octets maximum).
Syntaxe
Une chaîne de caractères littérale peut être spécifiée de 4 façons différentes :
Guillemets simples
La façon la plus simple de spécifier une chaîne de caractères est de l'entourer de guillemets
simples (le caractère '
).
Pour spécifier un guillemet simple littéral, il doit être échappé à l'aide
d'un antislash (\
). Pour spécifier un antislash littéral,
doublez-le (\\
).
Toute les autres instances d'antislash seront traitées comme un antislash
littéral : ce qui signifie que les autres séquences auquelles vous
êtes éventuellement habitués (comme \r
ou \n
)
s'afficheront telles quelles, sans avoir une quelconque signification particulière.
Note:
Contrairement aux syntaxes avec double guillemets
et heredoc, les
variables et les séquences d'échappement
pour les caractères spéciaux ne seront pas interprétées lorsqu'elles
figurent dans une chaîne de caractères entourée de guillemets simples.
Guillemets doubles
Si la chaîne de caractères est entouré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 |
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 ou 0x0B (11) en ASCII) |
\e |
échappement (ESC or 0x1B (27) en ASCII) |
\f |
Saut de page (FF ou 0x0C (12) en ASCII) |
\\ |
Antislash |
\$ |
Signe dollar |
\" |
Guillemet double |
\[0-7]{1,3} |
La séquence de caractères correspondant à cette expression rationnelle
est un caractère, en notation octale, qui débordera
silencieusement pour s'adapter à un octet
(e.g. "\400" === "\000")
|
\x[0-9A-Fa-f]{1,2} |
La séquence de caractères correspondant à cette expression rationnelle
est un caractère, en notation hexadécimale
|
\u{[0-9A-Fa-f]+} |
La séquence de caractères correspondant à
l'expression régulière est un point de code Unicode, qui
sera la sortie de la chaîne de caractères
représentant le codepoint UTF-8
|
De la même façon que pour les chaîne de caractères entourées de guillemets simples,
l'échappement de tout autre caractère affichera l'antislash.
La fonctionnalité la plus intéressante des chaîne de caractères guillemets doubles
est que les noms de variables seront interprétés. Voir la documentation sur
l'analyse des chaînes de caractères
pour plus de détails.
Syntaxe Heredoc
Une troisième façon de délimiter une chaîne de caractères est la syntaxe Heredoc :
<<<
. Après cet opérateur, un identifiant
est fourni, suivi d'une nouvelle ligne. La chaîne de caractères en elle-même vient ensuite,
suivie du même identifiant pour fermer la notation.
L'identifiant de fin doit commencer à la première colonne de
la ligne. De plus, l'identifiant doit suivre les mêmes règles que n'importe
quel autre libellé PHP : il ne doit contenir que des caractères alphanumériques et
des soulignés, et doit commencer par un caractère non numérique ou un souligné
("underscore"
).
Avertissement
Il est très important de noter que la ligne contenant l'identifiant de fin ne
doit contenir aucun autre caractère, mis à part un point-virgule (;
).
Cela signifie en particulier que l'identifiant
ne doit pas être indenté, et qu'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 telle que définie par le système d'exploitation ; sur les
systèmes Unix, incluant macOS, il s'agit du caractère \n
.
Le délimiteur de fermeture 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.
Exemple #1 Exemple invalide
<?php
class foo {
public $bar = <<<EOT
bar
EOT;
}
// L'identifiant ne doit pas être indenté
?>
Exemple #2 Exemple valide
<?php
class foo {
public $bar = <<<EOT
bar
EOT;
}
?>
Heredoc contenant des variables ne peuvent être utilisé pour initialiser
les propriétés d'une classe.
Heredoc se comporte exactement comme une chaîne de caractères guillemets doubles,
sans les guillemets doubles. Cela signifie que les guillemets dans une
syntaxe Heredoc n'ont pas besoin d'être échappés, mais que les codes d'échappement
listés plus haut peuvent toujours être utilisés. Les variables seront interprétées,
mais les mêmes précautions doivent être prises lorsque des variables complexes
sont exprimées dans une Heredoc comme avec chaîne de caractères.
Exemple #3 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 __construct()
{
$this->foo = 'Foo';
$this->bar = array('Bar1', 'Bar2', 'Bar3');
}
}
$foo = new foo();
$name = 'MyName';
echo <<<EOT
Mon nom est "$name". J'affiche quelques $foo->foo.
Maintenant, j'affiche quelques {$foo->bar[1]}.
Et ceci devrait afficher un 'A' majuscule : \x41
EOT;
?>
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 données en paramètre à une fonction :
Exemple #4 Exemple d'utilisation de Heredoc pour passer des arguments
<?php
var_dump(array(<<<EOD
foobar!
EOD
));
Il est possible d'initialiser les variables statiques et les propriétés
ou constantes de classes avec la syntaxe Heredoc :
Exemple #5 Utilisation de Heredoc pour initialiser des valeurs 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;
}
?>
L'identifiant ouvrant Heredoc peut éventuellement
être écrit entre guillemets doubles :
Exemple #6 Utilisation des guillemets doubles avec Heredoc
<?php
echo <<<"FOOBAR"
Hello World!
FOOBAR;
?>
Nowdoc
Nowdoc est aux chaînes guillemets simples ce qu'Heredoc est aux chaînes
guillemets doubles. Un Nowdoc est spécifié de manière similaire à un Heredoc,
mais aucune analyse n'est effectuée à l'intérieur d'une
Nowdoc. Cette syntaxe est idéale pour embarquer du code PHP ou d'autres
larges blocs de texte, sans avoir besoin d'échapper quoi que ce soit.
Elle partage quelques fonctionnalités avec la syntaxe SGML
<![CDATA[ ]]>
, en ce qu'elle déclare un bloc
de texte qui ne doit pas être analysé.
Nowdoc est identifié avec la même séquence <<<
utilisée par Heredoc, mais l'identifiant qui suit est entouré de guillemets
simples, comme <<<'EOT'
. Toutes les règles concernant
les identifiants Heredoc s'appliquent également aux identifiants Nowdoc,
et, tout particulièrement, celles concernant la forme de l'identifiant de fin.
Exemple #7 Exemple de chaîne Nowdoc
<?php
echo = <<<'EOD'
Exemple de chaîne sur plusieurs lignes en utilisant la syntaxe Nowdoc.
Les barre oblique inversée sont toujours traité de façon littérale,
par exemple \\ and \'.
EOD;
L'exemple ci-dessus va afficher :
Exemple de chaîne sur plusieurs lignes en utilisant la syntaxe Nowdoc.
Les barre oblique inversée sont toujours traité de façon littérale,
par exemple \\ and \'.
Exemple #8 Exemple 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'
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
Exemple #9 Exemple avec des données statiques
<?php
class foo {
public $bar = <<<'EOT'
bar
EOT;
}
?>
Analyse des variables
Lorsqu'une chaîne de caractères est spécifiée entre guillemets doubles ou en Heredoc,
les variables qu'elle contient sont interprétées.
Il existe 2 types de syntaxes : une
simple et une
complexe.
La syntaxe simple est la plus commune et la plus pratique. Elle fournit
une façon d'embarquer une variable, une valeur de tableau, ou une
propriété d'objet dans une chaîne de caractères avec un minimum d'effort.
La syntaxe complexe se reconnaît à l'utilisation d'accolades autour de
l'expression.
Syntaxe simple
Si un signe dollar ($
) est rencontré, l'analyseur prendra
autant de caractères que possible pour former un nom de variable valide.
Entourer le nom de la variable avec des accolades, pour spécifier
explicitement la fin de celui-ci.
De la même façon, un index d'un tableau ou une propriété d'un objet
peut être analysé. Avec les indices de tableaux, le crochet fermant
(]
) marque la fin de l'index. Les mêmes règles sont
appliquées aux propriétés d'objets que pour les simples variables.
Exemple #10 Exemple de la syntaxe simple
<?php
$juices = array("pomme", "poire", "koolaid1" => "raisin");
echo "Il a bu du jus de $juices[0].".PHP_EOL;
echo "Il a bu du jus de $juices[1].".PHP_EOL;
echo "Il a bu du jus de $juices[koolaid1].".PHP_EOL;
class people {
public $john = "John Smith";
public $jane = "Jane Smith";
public $robert = "Robert Paulsen";
public $smith = "Smith";
}
$people = new people();
echo "$people->john a bu du jus de $juices[0].".PHP_EOL;
echo "$people->john a dit bonjour à $people->jane.".PHP_EOL;
echo "$people->john's wife greeted $people->robert.".PHP_EOL;
echo "$people->robert a dit bonjour aux $people->smiths."; // Ne fonctionne pas
?>
L'exemple ci-dessus va afficher :
Il a bu du jus de pomme.
Il a bu du jus de poire.
Il a bu du jus de raisin.
John Smith a bu du jus de pomme.
John Smith a dit bonjour à Jane Smith.
John Smith's wife greeted Robert Paulsen.
Robert Paulsen a dit bonjour aux .
À partir de PHP 7.1.0 les indices numériques négatifs
sont aussi supportés.
Exemple #11 Indices numériques négatifs
<?php
$string = 'string';
echo "Le personnage à l'index -2 est $string[-2].", PHP_EOL;
$string[-3] = 'o';
echo "Change le caractère à l'index -3 par o donne $string.", PHP_EOL;
?>
L'exemple ci-dessus va afficher :
Le personnage à l'index -2 est n.
Change le caractère à l'index -3 par o donne strong.
Pour tout ce qui est plus complexe, vous devriez utiliser la
syntaxe complexe.
Syntaxe complexe
Cette syntaxe est appelée complexe, non pas parce qu'elle est complexe,
mais parce qu'elle permet l'utilisation d'expressions complexes.
Toute variable scalaire, élément de tableau, ou attribut d'objet représentable
en tant que chaîne de caractères peut être utilisé avec cette syntaxe. Écrivez simplement
l'expression de la même façon qu'elle apparaitrait à l'extérieur
de la chaîne de caractères et, ensuite, entourez-là des caractères {
et }
. Sachant que {
ne peut pas être
échappé, cette syntaxe ne sera reconnue que lorsque le $
suit immédiatement {
. Utiliser {\$
pour afficher littéralement {$
.
Voici quelques exemples pour éclaircir ceci :
Il est également possible d'accéder aux propriétés de classes en utilisant
des variables contenues dans des chaînes, en utilisant cette syntaxe.
Note:
Les valeurs accédé via les fonctions, méthodes, variables statiques de classes,
ainsi que les constantes de classes à l'intérieur de {$}
sont interprétée
comme le nom d'une variable dans le contexte où la chaîne est définie.
L'utilisation de simples accolades ({}
) ne fonctionnera
pas pour accéder à la valeur retournée par des fonctions, méthodes, ou
les valeurs de constantes et de variables statiques de classes.
Accès et modification d'une chaîne, par caractère
On peut accéder à, et modifier un, caractère d'une chaîne de caractères en spécifiant
sa position (à partir de 0) après la chaîne de caractères en utilisant les crochets de
tableau, tel que $str[42].
Il convient dans ce cas de voir une chaîne de caractères comme un tableau de caractères.
Les fonctions substr() et substr_replace()
peuvent être utilisées lorsque vous voulez extraire ou remplacer plus d'un caractère.
Note:
À partir de PHP 7.1.0, les positions négatives dans les chaînes de
caractères sont aussi supportées. Cela spécifie la position en partant
de la fin de la chaîne de caractères.
Auparavant, les index négatif émettait E_NOTICE
pour
la lecture (donnant une chaîne vide) et E_WARNING
pour
l'écriture (laissant la chaîne inchangée).
Note:
Antérieur à PHP 8.0.0, les strings pouvait aussi être accédé
en utilisant les accolades, comme ceci $str{42}.
La syntaxe avec les accolades a été rendu obsolète en PHP 7.4.0 et n'est
plus supportée à partir de PHP 8.0.0.
Avertissement
Écrire à une position hors de l'intervalle 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 types de positions invalides émettent une E_WARNING
.
Seul le premier caractère d'une chaîne assignée est utilisé.
À partir de PHP 7.1.0, assigner une chaîne vide lève une erreur fatale.
Auparavant, cela affectait un octet NULL.
Avertissement
En interne, les chaînes PHP sont des tableaux d'octets. Ainsi, l'accès ou la
modification d'une chaîne en utilisant les crochets d'un tableau n'est pas
multi-octets, et ne doit être utilisé qu'avec les chaînes dont l'encodage
est sur un seul octet, comme ISO-8859-1.
Note:
À partir de PHP 7.1.0, appliquer un index vide sur une chaîne vide lève
une erreur fatale.
Auparavant, la chaîne était silencieusement convertie en un tableau.
Exemple #12 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';
?>
Les positions d'une chaîne doivent être un entier,
ou des chaînes pouvant être converties en entier, sinon, une alerte
sera émise.
Exemple #13 Exemple de Positions de Chaîne Invalide
<?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 (pas des tableaux
ni des objets implémentant les interfaces appropriées) en utilisant
[]
ou {}
retournera
silencieusement null
.
Note:
Les caractères dans une chaîne de caractères littérales peuvent être
accédé en utilisant la syntaxe []
ou {}
.
Note:
Accéder aux caractères dans une chaîne de caractères littérales en
utilisant la syntaxe {}
a été rendu obsolète en PHP 7.4.
Ceci a été supprimée en PHP 8.0.
Une valeur peut être convertie en une chaîne de caractères en utilisant le mot-clé
(string)
ou la fonction strval().
La conversion en 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 notamment
lors de l'utilisation des fonctions echo ou
print, ou lorsqu'une variable est comparée à une chaîne de caractères.
Les sections sur les types et sur le
transtypage expliquent
ce qui suit de manière plus détaillée. Voir aussi la fonction
settype().
Une valeur booléen true
est convertie en la chaîne de caractères
"1"
. Une valeur booléen false
est convertie en
""
(une chaîne vide). Ceci permet les conversions vers
et depuis les valeurs booléen et chaîne de caractères.
Un entier ou un nombre décimal est converti en une chaîne de caractères représentant
le nombre de façon textuelle (y compris l'exposant pour les nombre décimal).
Les nombres à virgule flottante peuvent être convertis en utilisant
la notation exponentielle (4.1E+6
).
Note:
À partir de PHP 8.0.0, le point décimal est toujours
.
. Antérieur à PHP 8.0.0, le point décimal est défini
dans la locale du script (catégorie LC_NUMERIC).
Voir la fonction setlocale().
Les tableau sont toujours convertis en la chaîne de caractères
"Array"
; à cause de cela,
echo et print
ne peuvent pas afficher par eux-même le contenu d'un tableau.
Pour afficher un seul élément, il faut utiliser une syntaxe tel que
echo $arr['foo']
. Voir ci-dessous pour des astuces
permettant d'afficher le contenu complet.
Pour pouvoir convertir un objet en chaîne de caractères la méthode magique
__toString doit être utilisée.
Les ressources sont toujours converties en chaîne de caractères sous la forme
"Resource id #1"
, où 1
est l'identifiant
assigné à la ressource par PHP lors de l'exécution. Alors qu'il ne faut pas se fier
à cette structure, car susceptible d'évoluer, elle sera néanmoins unique pour une
ressource donnée durant toute la durée d'exécution du script courant (ie une
requête web ou un processus CLI). Pour récupérer le type d'une
ressource, utilisez la fonction get_resource_type().
null
est toujours converti en une chaîne vide.
Au vu 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 sa
valeur, mis à part son type. Voir les fonctions print_r()
et var_dump() pour inspecter
plus efficacement les contenus de ces types.
La plupart des valeurs en PHP peuvent également être converties en chaîne de caractères
afin de les stocker. Cette méthode est appelée "linéarisation", et
est effectuée par serialize().
Détails sur le type "chaîne de caractères"
Le type chaîne de caractères en PHP est implémenté sous la forme d'un tableau d'octets
accompagné d'un entier indiquant la longueur de la mémoire tampon. Il n'a aucune
information sur la traduction octet/caractère, laissant cette tâche au programmeur.
Il n'y a aucune limitation sur les valeurs pouvant être présentes dans une chaîne ;
en particulier, les octets dont la valeur est 0
(“octets NUL”)
sont autorisés à n'importe quel endroit de la chaîne (cependant, quelques fonctions,
indiquées dans ce manuel comme n'étant pas “sécurisées au niveau binaire”, peuvent
ignorer tous les octets après un octet nul.)
La nature même du type "chaîne de caractères" explique
qu'il n'existe pas de type “byte” en PHP - les chaînes de caractères jouent ce rôle.
Les fonctions qui ne retournent pas de données textuelles - par exemple, des données
arbitraires lues depuis un socket réseau - continueront de retourner des chaînes
de caractères.
PHP ne dictant aucun encodage spécifique pour les chaînes
de caractères, on pourrait se demander comment les chaînes littérales
sont codés. Par exemple, est-ce que la chaîne
"á"
équivaut à la chaîne "\xE1"
(ISO-8859-1),
"\xC3\xA1"
(UTF-8, C form),
"\x61\xCC\x81"
(UTF-8, D form) ou à une autre des représentations possibles ?
La réponse est que la chaîne sera encodée suivant l'encodage courant du script.
Aussi, si le script est écrit en ISO-8859-1, alors, la chaîne sera encodée en
ISO-8859-1 ; et ainsi de suite. Toutefois, ceci n'est pas vrai si Zend Multibyte est
activé ; dans ce cas, le script peut être écrit dans n'importe quel encodage (qui sera explicitement
déclaré, ou bien détecté), puis sera converti en un encodage interne, qui sera
utilisé pour les chaînes littérales. Notez qu'il existe des contraintes sur
l'encodage du script (ou sur l'encodage interne, si Zend Multibyte est activé) -
cela signifie quasiment toujours que l'encodage utilisé doit être un sur-ensemble compatible
d'ASCII, comme UTF-8 ou ISO-8859-1. Notez cependant que les encodages dépendant
de l'état, où les mêmes valeurs de l'octet peuvent être utilisées dans des
états de décalage initial et non-initial, peuvent être problématiques.
Bien évidemment, pour être utiles, les fonctions qui opèrent sur du texte peuvent devoir
faire des hypothèses sur la façon dont est encodé la chaîne de caractères.
Malheureusement, ces hypothèses ne sont pas les mêmes suivant les fonctions de
PHP :
-
Certaines fonctions supposent que la chaîne est encodée en utilisant un (quelconque) encodage
à un seul octet, mais n'ont pas besoin d'interpréter ces octets sous la forme
de caractères. C'est actuellement le cas, par exemple, pour les fonctions
substr(), strpos(),
strlen() et strcmp().
Une autre façon de voir ces fonctions est qu'elles opèrent sur les mémoires
tampons ; autrement dit, qu'elles fonctionnent avec les octets et leurs positions.
-
D'autres fonctions reçoivent l'encodage de la chaîne en paramètre, éventuellement en
assumant un encodage par défaut si ce n'est pas le cas. C'est le cas de la fonction
htmlentities() ainsi que de la majorité des fonctions de l'extension
mbstring.
-
D'autres utilisent la locale courante (voir setlocale()),
mais opèrent octet par octet. C'est le cas de strcasecmp(),
strtoupper(), et ucfirst().
Cela signifie qu'elles ne peuvent être utilisées qu'avec les encodages sur
un seul octet, et si l'encodage correspond à la locale.
Par exemple,
strtoupper("á")
peut retourner
"Á"
si la locale est correctement positionnée et si
á
est encodé sur un seul octet. Si la chaîne est encodée
en UTF-8, le résultat correct ne sera pas retourné, et la chaîne résultante pourra
être (ou non) corrompue, suivant la locale courante.
-
Enfin, elles peuvent juste supposer que la chaîne utilise un encodage
spécifique, généralement UTF-8. C'est le cas de la plupart des fonctions
de l'extension intl ainsi que de celles
de l'extension PCRE (dans ce dernier cas,
uniquement lorsque le modificateur
u
est utilisé).
Bien que ce soit en raison de leur buts spécifiques, la fonction
utf8_decode() assume un encodage UTF-8 et la fonction
utf8_encode() pré-suppose un encodage ISO-8859-1.
Pour conclure, le fait d'écrire un programme correct en utilisant Unicode
dépend de l'utilisation ou non de fonctions qui ne fonctionnent pas en Unicode,
et qui corrompront très certainement les données ; il conviendra donc d'utiliser des fonctions
qui fonctionnent correctement, générallement depuis les extensions
intl et mbstring.
Cependant, l'utilisation de fonctions qui peuvent gérer des encodages Unicode
n'est que le commencement. Quelques soient les fonctions fournies par le langage,
il est essentiel de connaître les spécifications de l'Unicode. Par exemple, un
programme qui assume qu'il n'y a que des caractères en majuscule et en minuscule
fait une mauvaise hypothèse.