Un guide de l'Unicode compréhensible en Perl 5

En Perl, les chaînes de caractères peuvent contenir tous les caractères Unicode (jusqu'à un point de code maximal de U+10FFFF). En interne, Perl représente les chaînes avec un encodage UTF-8 à taille variable (actuellement de 1 à 4 octets), en raison de la bonne utilisation de l'espace de cet encodage et du fait que l'encodage est le même que l'ASCII pour les caractères jusqu'à 127, ce qui est pratique.

Les chaînes de caractères qui proviennent de l'extérieur de votre programme (noms de fichiers, contenu de fichiers, arguments de la ligne de commande, entrée standard STDIN, etc.) et même le texte même de votre programme ne sont toujours qu'un flux d'octets (valeurs comprises entre 0 et 255), car c'est la façon dont les programmes communiquent entre eux. C'est la raison pour laquelle il faut les décoder lorsque l'on attend qu'ils contiennent des caractères Unicode. Dans la terminologie Perl, le décodage est précisément l'opération qui consiste à convertir un flux d'octets en un flux de caractères Unicode. Il existe plusieurs manières de le faire.

Inversement, les chaînes de caractères en sortie de votre programme (noms de fichiers, contenu de fichiers, sortie standard STDIN, sortie d'erreur STDERR, etc.) doivent être encodées en octets à partir de l'encodage attendu.

À moins qu'un module dédié du CPAN ne s'en charge, le décodage des entrées et l'encodage des sorties doivent également être mis en place pour les accès aux serveurs de bases de données et l'utilisation de formats de données sérialisés comme JSON, XML, YAML, etc.

1-1. Syntaxe des chaînes▲

Mais commençons par le commencement. Avant de nous plonger dans les subtilités du décodage et de l'encodage, voyons comment configurer un programme ou un module Perl pour éviter quelques-unes des surprises les plus déplaisantes susceptibles d'arriver avec des chaînes Unicode.

La façon la plus simple d'y arriver est de commencer votre programme avec le pragma :

use 5.12.0;

Ou, mieux, si votre version de Perl est suffisamment récente :

use 5.16.0;

Ceci dit à Perl de ne pas tenir compte d'une ancienne sémantique historique (connue sous le nom d'Unicode Bug, avec un B majuscule, parmi les hackers des entrailles de Perl) qui faisait que certaines opérations sur les chaînes dépendaient de la variable interne « UTF-8 flag » utilisée par Perl pour se souvenir de l'encodage interne des chaînes. Autrement dit, utiliser cette version minimale de Perl garantit que les opérations sur les chaînes seront conformes à la sémantique Unicode et que vous n'avez pas à vous préoccuper de la représentation interne de vos chaînes.

Pour entrer dans les détails, cette instruction use dit à Perl de charger la fonctionnalité unicode_strings feature et de l'activer pour l'ensemble de votre fichier (mais pas des modules qu'il charge !). Si vous désirez n'activer que cette fonctionnalité, vous pouvez également écrire :

use feature 'unicode_strings';

Pour des scripts unilignes, vous pouvez également utiliser l'option -E de la ligne de commande au lieu de l'instruction use <version>.

Voici un bref exemple de ce bogue Unicode. Le caractère U+00FF LATIN SMALL LETTER Y WITH DIAERESIS (y avec tréma ou ÿ) a une version en capitales qui tombe en dehors de l'intervalle 0-255, U+0178 LATIN CAPITAL LETTER Y WITH DIAERESIS. Si la fonctionnalité unicode_strings a été activée, uc() renvoie le caractère voulu :

$ perl -CS -lE '$_="\xff";print;print uc'
ÿ
Ÿ

(Ceci suppose que votre terminal comprend l'UTF-8 - sinon, l'affichage sera légèrement perturbé.)

Mais sans ce pragma, uc() renvoie souvent son argument inchangé :

$ perl -CS -le '$_="\xff";print;print uc'
ÿ
ÿ

Mais pas toujours :

$ perl -CS -le '$_=substr("\xff\x{100}",0,1);print;print uc'
ÿ
Ÿ

La raison de cette incohérence est que l'état interne de la chaîne, telle qu'elle était implémentée en Perl, fuit, ce qui change la sémantique de la fonction uc(). Ceci est à éviter, donc protégez-vous et activez la fonctionnalité unicode_strings !

Dans un script uniligne, vous pouvez utiliser l'option -C de la ligne de commande pour dire à Perl de s'attendre (ou pas) à trouver de l'Unicode dans une partie au moins de l'environnement d'exécution du programme. Les différentes syntaxes de cette option sont décrites dans la documentation perlrun, mais celle qui nous intéresse au premier chef ici est -CS, qui dit que l'entrée standard, la sortie standard et la sortie d'erreur ont toutes un encodage en UTF-8. (L'option inverse est -C0, et assure que rien ne doit s'attendre à des données Unicode par défaut.)

3-1. Affichages en sortie▲

$ perl -E 'print "\xff"' | xxd
0000000: ff                                       .
$ perl -CS -E 'print "\xff"' | xxd
0000000: c3bf                                     ..

$ perl -e 'printf "%b\n", hex "c3bf"'
1100001110111111
# 110_00011 + 10_111111
#     00011      111111
#        11      111111
$ perl -e 'printf "%b\n", hex "ff"'
11111111

3-2. Données en entrée▲

$ perl -E 'print "\xc3\xbf"' | perl -E '$x = <>; printf "%d %x\n", length $x, ord $x'
2 c3
$ perl -E 'print "\xc3\xbf"' | perl -CS -E '$x = <>; printf "%d %x\n", length $x, ord $x'
1 ff

3-3. La variable d'environnement PERL_UNICODE▲

Perl émet différents warnings quand il détecte que vous mélangez des octets et des chaînes Unicode, ou que vous utilisez des choses étranges en Unicode. Ces avertissements appartiennent à la catégorie des warnings utf8 et à ses sous-catégories.

4-1. Wide character in ...▲

$ perl -CS -E 'print "\x{133}"' | xxd
0000000: c4b3

$ perl -CS -E 'print "\x{2A6A5}"' | xxd
0000000: f0aa 9aa5

$ perl -E 'print "\x{133}"' | xxd
Wide character in print at -e line 1.
0000000: c4b3

4-2. Malformed UTF-8 character▲

$ perl -E 'print "\xff"' | perl -CS -pE1 | xxd
Malformed UTF-8 character (unexpected end of string) in print, <> line 1.
0000000: ff                                       .

4-3. "..." does not map to Unicode▲

$ perl -E 'print "\xc1\x9c"' | perl -CS -wpE1 | xxd
utf8 "\xC1" does not map to Unicode, <> line 1.
0000000: c19c                                     ..

La seule utilisation du pragma utf8 comme ci-dessous :

use utf8;

au début de votre fichier est de dire à Perl que le reste du fichier, en particulier les chaînes et les expressions régulières, est encodé en UTF-8. C'est tout. Ce pragma n'a pas d'impact mesurable sur la durée de compilation ou d'exécution du programme.

Mon conseil personnel serait cependant d'éviter de mettre de l'UTF-8 dans vos programmes, à moins que vous ne soyez sûr à 100 % que ça ne va pas être corrompu par des éditeurs, des terminaux ou des collègues. Le pragma utf8 vous permet également d'utiliser de l'UTF-8 dans les noms des fonctions ou des variables, mais, de mon expérience, c'est rarement une bonne idée. Par exemple, les deux formes suivantes du caractère « è » sont définies comme canoniquement équivalentes en Unicode, mais si vous utilisez l'une pour l'autre, Perl sera perdu, parce que le compilateur ne normalise pas (encore) les identifiants canoniquement équivalents de façon unique :

$ perl -CS -E '$_="sub ad\xe8le { say q/ok/ } ade\x{300}le()";eval $_ or print $@'
Undefined subroutine &main::ade\x{0300}le called at (eval 1) line 1.

(Soit dit en passant, eval() fonctionne correctement ici avec du code Perl en Unicode grâce à l'option -E de la ligne de commande, qui active la fonctionnalité unicode_eval ; sans cela, eval() garderait sa sémantique historique de toujours comprendre son argument comme un flux d'octets.)

Perl dispose de deux fonctions internes, utf8::encode et utf8::decode, qui assurent l'encodage et le décodage de bas niveau de l'UTF-8. À noter que ce sont des fonctions internes, il n'y a pas besoin d'activer utf8 ou un quelconque autre pragma pour les charger, comme pour toutes les fonctions internes. Qu'est-ce que cela signifie ? Reprenons la liste d'exemples que nous avons déjà vus.

L'encodage est la conversion en un flux d'octets que vous pouvez envoyer vers l'extérieur de votre programme :

$ perl -wE '$x="\xff";utf8::encode($x);print $x' | xxd
0000000: c3bf                                     ..
$ perl -wE '$x="\x{133}";utf8::encode($x);print $x' | xxd
0000000: c4b3                                      ..

Le décodage est la conversion d'un flux d'octets en caractères Unicode (si possible) :

$ perl -wE '$x="\xc3\xbf";utf8::decode($x);printf "%d %x\n", length $x, ord $x'
1 ff
$ perl -wE '$x="\xc4\xb3";utf8::decode($x);printf "%d %x\n", length $x, ord $x'
1 133

Les deux fonctions transforment leurs arguments en place. utf8::encode ne renvoie rien ; utf8::decode renvoie une valeur booléenne spécifiant si le décodage a pu être effectué avec succès.

Ces deux fonctions sont d'assez bas niveau : elles n'émettent pas de warnings, et n'effectuent que les vérifications de base ; il convient généralement de les manipuler avec précaution. Pour des primitives d'encodage et de décodage de plus haut niveau, considérez le module Encode (voir § 8 ci-dessous).

Ces fonctions sont de plus bas niveau encore que les précédentes et leur utilité est très limitée en général. Alors que les fonctions utf8::encode et utf8::decode peuvent convertir le flux d'octets ou de points de code représentant une chaîne, utf8::downgrade et utf8::upgrade n'y toucheront pas. Leur rôle consiste uniquement à s'assurer qu'en interne, la chaîne est encodée en UTF-8 (upgrade) ou non (downgrade).

À noter que, par défaut, utf8::downgrade terminera le programme en erreur si la chaîne reçue en paramètre ne peut pas être représentée sous la forme d'octets.

$ perl -E '$x="\x{133}"; eval { utf8::downgrade($x);1 } or print "error: $@"'
error: Wide character in subroutine entry at -e line 1.

Le module Encode fournit des routines de conversion et de validation d'encodage et prend en charge non seulement l'UTF-8 mais aussi une vaste palette d'autres encodages spécifiques.

Les fonctions encode et decode exportées par le module Encode ont le même but que les versions utf8:: ayant le même nom, elles convertissent respectivement vers et depuis l'encodage spécifié. Contrairement à ces fonctions de bas niveau, elles renvoient la valeur convertie :

$ perl -MEncode -wE 'print encode("UTF-8","\xff")' | xxd
0000000: c3bf                                     ..
$ perl -MEncode -wE '$x=decode("UTF-8","\xc3\xbf");printf "%d %x\n", length $x, ord $x'
1 ff

La gestion des erreurs peut être ajustée finement. Par défaut, tout caractère qui ne peut pas être décodé sera remplacé par le caractère spécial U+FFFD REPLACEMENT CHARACTER \x{fffd} qui, d'après la norme, s'utilise pour remplacer tout caractère entrant dont la valeur est inconnue ou non représentable en Unicode :

$ perl -MEncode -wE '$x=decode("UTF-8","\xff");printf "%d %x\n", length $x, ord $x'
1 fffd

Mais il est aussi possible de déclencher une exception :

$ perl -MEncode -wE 'say decode("UTF-8","\xff",Encode::FB_CROAK)'
utf8 "\xFF" does not map to Unicode at /Users/rgs/perl5/perlbrew/perls/perl-5.18.2/lib/5.18.2/darwin-2level/Encode.pm line 176.

ou de demander le renvoi d'une version plus facile à lire pour un humain de la chaîne qui ne peut être décodée :

$ perl -MEncode -wE 'say decode("UTF-8","\xff",Encode::FB_PERLQQ)'
\xFF

Voir la documentation du module Encode pour une liste complète des options et possibilités.

Le module Encode fournit enfin deux fonctions internes, _utf8_on et _utf8_off, qui sont essentiellement équivalentes à utf8::decode et utf8::encode respectivement. Elles n'effectuent aucune vérification et leur emploi est déconseillé.

$ perl -MEncode -wE '$x="\xc4\xb3";Encode::_utf8_on($x);printf "%d %x\n", length $x, ord $x'
1 133
$ perl -MEncode -wE '$x="\x{133}";Encode::_utf8_off($x);printf "%d %x\n", length $x, ord $x'
2 c4

Depuis la version 5.16, Perl a une nouvelle fonction interne, fc, qui assure les changements de casse (conversion entre capitales et minuscules) en Unicode. C'est la façon adéquate de mettre en œuvre une comparaison insensible à la casse entre des chaînes. Par exemple, en ce qui concerne les formes finales et non finales de la lettre grecque sigma (respectivement \x{03c2} et \x{03c3}), la forme finale est convertie en forme non finale, ce qui n'est pas le cas avec la fonction lc, puisque les deux formes sont déjà en minuscules :

$ perl -CS -E '$_="\x{3A3}\x{3C3}\x{3C2}";say;say lc;say uc;say fc'
\x{03a3}\x{03c3}\x{03c2}
\x{03c3}\x{03c3}\x{03c2}
\x{03a3}\x{03a3}\x{03a3}
\x{03c3}\x{03c3}\x{03c3}

En Unicode, un graphème est un caractère logique qui peut se représenter avec plusieurs caractères Unicode distincts et combinés.

Par exemple, le c cédille (LATIN SMALL LETTER ç) peut s'écrire sous la forme d'un caractère unique U+00E7, ou sous celle d'une juxtaposition de la lettre « c » ordinaire (U+0063) et du caractère U+0327, COMBINING CEDILLA:

$ perl -CS -wE 'say chr 0xe7, " ", "c", chr 0x327'
ç c\x{0327}

Le premier a une longueur de 1 et le second de 2 :

$ perl -CS -wE 'say length for "\xe7", "c\x{327}"'
1
2

C'est le comportement voulu, mais ça peut conduire à des résultats inattendus si vous avez l'intention de travailler avec des graphèmes, mais travaillez en fait avec des caractères.

Il existe une fonctionnalité de Perl qui comprend les graphèmes : l'atome \X des expressions régulières, qui reconnaît un graphème unique, même s'il se compose de plusieurs caractères. Cela vous permet d'extraire des graphèmes uniques d'une chaîne :

$ perl -CS -wE 'say length, " $_" for "\xe7c\x{327}c" =~ /\X/g'
1 ç
2 c\x{0327}
1 c

À noter également que la version 5.22.0 de Perl introduit une nouvelle assertion d'expression régulière, \b{gcb} (pour «  grapheme cluster boundary ») qui reconnaît uniquement les limites entre les graphèmes.

L'Unicode réserve de façon permanente 66 points de code comme « non-caractères », qui ne doivent pas être utilisés pour les échanges de données entre les applications. Comme le dit la norme, ces codes sont réservés aux utilisations internes aux processus. Leur utilisation déclenche des warnings, même si les warnings ne sont pas activés :

$ perl -CS -E 'say "\x{fffe}"' | xxd
Unicode non-character U+FFFE is illegal for open interchange at -e line 1.
0000000: efbf be0a

Pour désactiver ce warning, vous devez le faire explicitement avec une instruction no warning nonchar, ou un équivalent :

$ perl -M-warnings=nonchar -CS -E 'say "\x{fffe}"' | xxd
0000000: efbf be0a

À partir de Perl 5.14, il existe une option /a pour forcer une sémantique ASCII sur la reconnaissance des expressions régulières. Qu'est-ce que cela veut dire ?

Par défaut, les séquences \d, \s, \w et les classes de caractères Posix reconnaissent les caractères Unicode :

$ perl -Mcharnames=:full -E 'say "\N{FULLWIDTH DIGIT SEVEN}" =~ /\d/ ? "matches" : "not"'
matches

Avec le flag /a, la reconnaissance se limite aux caractères ASCII, si bien, par exemple, que \d ne reconnaîtra que les chiffres ASCII de l'intervalle 0 à 9 :

$ perl -Mcharnames=:full -E 'say "\N{FULLWIDTH DIGIT SEVEN}" =~ /\d/a ? "matches" : "not"'
not
$ perl -E 'say 7 =~ /\d/a ? "matches" : "not"'
matches

12-1. Encore plus ASCII avec l'option /aa▲

$ perl -Mcharnames=:full -E 'say "\N{KELVIN SIGN}" =~ /K/i ? "match" : "no"'
match
$ perl -Mcharnames=:full -E 'say "\N{KELVIN SIGN}" =~ /K/ai ? "match" : "no"'
match
$ perl -Mcharnames=:full -E 'say "\N{KELVIN SIGN}" =~ /K/aai ? "match" : "no"'
no

$ perl -Mcharnames=:full -E 'say "\N{LATIN SMALL LIGATURE FI}" =~ /fi/i ? "match" : "no"'
match
$ perl -Mcharnames=:full -E 'say "\N{LATIN SMALL LIGATURE FI}" =~ /fi/ai ? "match" : "no"'
match
$ perl -Mcharnames=:full -E 'say "\N{LATIN SMALL LIGATURE FI}" =~ /fi/aai ? "match" : "no"'
no

Perl fournit des moyens facilitant la lecture d'un fichier ou l'écriture dans un fichier tout en, respectivement, décodant ou décodant les données.

13-1. La couche d'entrée-sortie :utf8 de PerlIO▲

open my $fh, "<:utf8", $file or die $!;

$ perl -E 'say for PerlIO::get_layers(STDIN)'
unix
perlio
$ perl -CI -E 'say for PerlIO::get_layers(STDIN)'
unix
perlio
utf8

open my $fh, ">:utf8", $file or die $!;

13-2. La couche :encoding(UTF-8) de PerlIO▲

13-3. Manipulation de couches : binmode▲

binmode STDIN, ':encoding(UTF-8)';

13-4. Spécifier les couches par défaut : use open▲

13-5. Lire depuis des scalaires▲

$ perl -CS -wE 'open $fh,"<",\"oeuf" or die "Cannot open scalar: $!";say <$fh>'
oeuf
$ perl -CS -wE 'open $fh,"<",\"œuf" or die "Cannot open scalar: $!";say <$fh>'
Strings with code points over 0xFF may not be mapped into in-memory file handles
Cannot open scalar: Invalid argument at -e line 1.

$ perl -CS -wE 'utf8::encode($x="œuf"); open $fh,"<", \$x; utf8::decode($y=<$fh>); say $y'
œuf

Perl est livré avec deux modules Unicode qui aident à manipuler les chaînes de caractères conformément aux règles de la norme.

14-1. Unicode::Normalize▲

$ perl -MUnicode::Normalize -E 'printf "%04x\n", ord for split //, NFD("\xe7")'
0063
0327

$ perl -MUnicode::Normalize -E 'say NFKD("\x{24B6}")'
A

14-2. Unicode::Collate▲

14-3. Unicode::UCD▲

$ perl -MUnicode::UCD=charinfo -MUnicode::Normalize -E 'say charinfo(ord)->{name} for split //, NFD("\xe7")'
LATIN SMALL LETTER C
COMBINING CEDILLA

• Unicode Introduction, sur le site perltuts.com

• La documentation standard livrée avec Perl :

  • le document de référence sur l'Unicode en Perl : perlunicode ;
  • le livre de recettes (cookbook) : perlunicook ;
  • la foire aux questions (FAQ) : perlunifaq ;
  • une introduction à l'Unicode en Perl : perluniintro. Il existe une version française de ce document (perluniintro), mais elle est ancienne et en grande partie périmée ;
  • un tutoriel pour commencer : perlunitut ;
  • la page de réponses de Tom Christiansen sur Stackoverflow.

Nous remercions Rafael Garcia-Suarez de nous avoir donné l'aimable autorisation de publier cette version française de son article, dont l'original se trouve à cette adresse.

Nous remercions Laurent Rosenfeld pour la traduction de ce document, Djibril pour la mise au format de ce site et la relecture de la traduction, et ClaudeLeloup pour la relecture orthographique.