Unicode

Le module Unicode fournit des fonctionnalités essentielles pour la gestion des caractères et des chaînes Unicode. Il inclut la validation, la détermination de la catégorie, la normalisation, la transformation de cas et la segmentation des graphèmes, permettant une gestion efficace des données Unicode.

Unicode.julia_chartransform(c::Union{Char,Integer})

Mappez le caractère Unicode (Char) ou le point de code (Integer) c au caractère ou point de code "équivalent" correspondant, respectivement, selon l'équivalence personnalisée utilisée dans le parseur Julia (en plus de la normalisation NFC).

Par exemple, 'µ' (U+00B5 micro) est traité comme équivalent à 'μ' (U+03BC mu) par le parseur de Julia, donc julia_chartransform effectue cette transformation tout en laissant les autres caractères inchangés :

julia> Unicode.julia_chartransform('µ')
'μ': Unicode U+03BC (catégorie Ll: Lettre, minuscule)

julia> Unicode.julia_chartransform('x')
'x': ASCII/Unicode U+0078 (catégorie Ll: Lettre, minuscule)

julia_chartransform est principalement utile pour être passé à la fonction Unicode.normalize afin d'imiter la normalisation utilisée par le parseur Julia :

julia> s = "µö"
"µö"

julia> s2 = Unicode.normalize(s, compose=true, stable=true, chartransform=Unicode.julia_chartransform)
"μö"

julia> collect(s2)
2-element Vector{Char}:
 'μ': Unicode U+03BC (catégorie Ll: Lettre, minuscule)
 'ö': Unicode U+00F6 (catégorie Ll: Lettre, minuscule)

julia> s2 == string(Meta.parse(s))
true

Unicode.isassigned(c) -> Bool

Retourne true si le caractère ou l'entier donné est un point de code Unicode assigné.

Exemples

julia> Unicode.isassigned(101)
true

julia> Unicode.isassigned('\x01')
true

isequal_normalized(s1::AbstractString, s2::AbstractString; casefold=false, stripmark=false, chartransform=identity)

Renvoie si s1 et s2 sont des chaînes Unicode équivalentes de manière canonique. Si casefold=true, ignore la casse (effectue un pliage de casse Unicode) ; si stripmark=true, supprime les marques diacritiques et autres caractères combinants.

Comme avec Unicode.normalize, vous pouvez également passer une fonction arbitraire via le mot-clé chartransform (mappant les points de code Integer à des points de code) pour effectuer des normalisations personnalisées, telles que Unicode.julia_chartransform.

Exemples

Par exemple, la chaîne "noël" peut être construite de deux manières équivalentes de manière canonique en Unicode, selon que "ë" est formé à partir d'un seul point de code U+00EB ou à partir du caractère ASCII 'e' suivi du caractère combinant U+0308 diacritique.

julia> s1 = "noël"
"noël"

julia> s2 = "noël"
"noël"

julia> s1 == s2
false

julia> isequal_normalized(s1, s2)
true

julia> isequal_normalized(s1, "noel", stripmark=true)
true

julia> isequal_normalized(s1, "NOËL", casefold=true)
true

Unicode.normalize(s::AbstractString; keywords...)
Unicode.normalize(s::AbstractString, normalform::Symbol)

Normalisez la chaîne s. Par défaut, la composition canonique (compose=true) est effectuée sans garantir la stabilité de la version Unicode (compat=false), ce qui produit la chaîne équivalente la plus courte possible mais peut introduire des caractères de composition non présents dans les versions Unicode antérieures.

Alternativement, l'une des quatre "formes normales" de la norme Unicode peut être spécifiée : normalform peut être :NFC, :NFD, :NFKC ou :NFKD. Les formes normales C (composition canonique) et D (décomposition canonique) convertissent différentes représentations visuellement identiques de la même chaîne abstraite en une seule forme canonique, la forme C étant plus compacte. Les formes normales KC et KD canonisent également les "équivalents de compatibilité" : elles convertissent des caractères qui sont abstraitement similaires mais visuellement distincts en un choix canonique unique (par exemple, elles développent les ligatures en caractères individuels), la forme KC étant plus compacte.

Alternativement, un contrôle plus fin et des transformations supplémentaires peuvent être obtenus en appelant Unicode.normalize(s; keywords...), où un nombre quelconque des options de mots-clés booléens suivants (qui sont tous par défaut à false sauf pour compose) sont spécifiés :

• compose=false : ne pas effectuer de composition canonique
• decompose=true : effectuer une décomposition canonique au lieu d'une composition canonique (compose=true est ignoré si présent)
• compat=true : les équivalents de compatibilité sont canonisés
• casefold=true : effectuer un pliage de casse Unicode, par exemple pour une comparaison de chaînes insensible à la casse
• newline2lf=true, newline2ls=true, ou newline2ps=true : convertir diverses séquences de nouvelle ligne (LF, CRLF, CR, NEL) en un caractère de saut de ligne (LF), de séparation de ligne (LS) ou de séparation de paragraphe (PS), respectivement
• stripmark=true : supprimer les marques diacritiques (par exemple, les accents)
• stripignore=true : supprimer les caractères "ignorables par défaut" d'Unicode (par exemple, le trait d'union souple ou le marqueur de gauche à droite)
• stripcc=true : supprimer les caractères de contrôle ; les tabulations horizontales et les sauts de page sont convertis en espaces ; les nouvelles lignes sont également converties en espaces à moins qu'un drapeau de conversion de nouvelle ligne ne soit spécifié
• rejectna=true : lancer une erreur si des points de code non attribués sont trouvés
• stable=true : imposer la stabilité de la version Unicode (ne jamais introduire de caractères manquants dans les versions Unicode antérieures)

Vous pouvez également utiliser le mot-clé chartransform (qui par défaut est identity) pour passer une fonction arbitraire mappant des points de code Integer à des points de code, qui est appelée sur chaque caractère de s au fur et à mesure qu'il est traité, afin d'effectuer des normalisations supplémentaires arbitraires. Par exemple, en passant chartransform=Unicode.julia_chartransform, vous pouvez appliquer quelques normalisations de caractères spécifiques à Julia qui sont effectuées par Julia lors de l'analyse des identifiants (en plus de la normalisation NFC : compose=true, stable=true).

Par exemple, NFKC correspond aux options compose=true, compat=true, stable=true.

Exemples

julia> "é" == Unicode.normalize("é") #LHS: Unicode U+00e9, RHS: U+0065 & U+0301
true

julia> "μ" == Unicode.normalize("µ", compat=true) #LHS: Unicode U+03bc, RHS: Unicode U+00b5
true

julia> Unicode.normalize("JuLiA", casefold=true)
"julia"

julia> Unicode.normalize("JúLiA", stripmark=true)
"JuLiA"

graphemes(s::AbstractString) -> GraphemeIterator

Renvoie un itérateur sur les sous-chaînes de s qui correspondent aux graphèmes étendus dans la chaîne, tels que définis par Unicode UAX #29. (En gros, ce sont ce que les utilisateurs percevraient comme des caractères uniques, même s'ils peuvent contenir plus d'un point de code ; par exemple, une lettre combinée avec un accent est un seul graphème.)

graphemes(s::AbstractString, m:n) -> SubString

Renvoie un SubString de s consistant en les graphèmes m-ième à n-ième de la chaîne s, où le deuxième argument m:n est un AbstractUnitRange de type entier.

De manière générale, cela correspond aux "caractères" perçus par l'utilisateur de m:n dans la chaîne. Par exemple :

julia> s = graphemes("exposé", 3:6)
"posé"

julia> collect(s)
5-element Vector{Char}:
 'p': ASCII/Unicode U+0070 (catégorie Ll: Lettre, minuscule)
 'o': ASCII/Unicode U+006F (catégorie Ll: Lettre, minuscule)
 's': ASCII/Unicode U+0073 (catégorie Ll: Lettre, minuscule)
 'e': ASCII/Unicode U+0065 (catégorie Ll: Lettre, minuscule)
 '́': Unicode U+0301 (catégorie Mn: Marque, non espacée)

Cela consiste en les 3ème à 7ème points de code (Chars) dans "exposé", car le graphème "é" est en réalité deux points de code Unicode (un 'e' suivi d'un caractère combinant accent aigu U+0301).

Parce que trouver les limites des graphèmes nécessite une itération sur le contenu de la chaîne, la fonction graphemes(s, m:n) nécessite un temps proportionnel à la longueur de la chaîne (nombre de points de code) avant la fin de la sous-chaîne.