Julia Chaînes de caractères

Une chaîne de caractères est une séquence finie de zéro ou plusieurs caractères. C'est un type de données dans les langages de programmation utilisé pour représenter

Julia utilise généralement des guillemets simples'pour créer des caractères individuels, et des guillemets doubles"ou des guillemets"""pour créer des chaînes de caractères. Par exemple :

c = 'x'

str = "EXAMPLE"

example = """Example "EXAMPLE",包含了单个引号"""

Caractéristiques du type de chaîne Julia :

  • Le type concret intégré utilisé pour les chaînes (et les littéraux de chaîne) en Julia est.
  • Les types de chaînes de Julia sont tous des sous-types du type abstrait AbstractString.
  • Julia dispose d'un excellent type pour représenter des caractères individuels, à savoir AbstractChar. Char est un sous-type intégré, un type de 32 bits qui peut représenter n'importe quel caractère Unicode (basé sur l'encodage).
  • Les chaînes de caractères Julia sont immuables — la valeur d’un objet AbstractString ne peut pas être modifiée.

Caractères

Les caractères individuels sont représentés par des valeurs Char.

Char est un type primitif de 32 bits qui peut être converti en sa valeur entière correspondante, c’est-à-dire le code Unicode :

Exemple

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

julia> typeof(c)
Char

julia> c = Int('x')
120

julia> typeof(c)
Int64

Nous pouvons également convertir une valeur entière en un Char :

Exemple

julia> Char(97)
'a': ASCII/Unicode U+0061 (catégorie Ll : Lettre, minuscule)

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

Nous pouvons effectuer des comparaisons et des opérations arithmétiques limitées sur des valeurs Char :

Exemple

julia> 'A' < 'a'
vrai

julia> 'A' <= 'a' <= 'Z'
false

julia> 'A' <= 'X' <= 'Z'
vrai

julia> 'x' - 'a'
23

julia> 'A' + 1
'B': ASCII/Unicode U+0042 (catégorie Lu : Lettre, majuscule)

Chaînes de caractères

Les chaînes de caractères en Julia peuvent être déclarées à l’aide de guillemets doubles"ou de trois guillemets doubles"""Si vous devez utiliser des guillemets dans une partie d’une chaîne, vous pouvez utiliser trois guillemets doubles pour ce faire, comme illustré ci-dessous :

Exemple

julia> str = "EXAMPLE"
"EXAMPLE"

julia> example = """Tutoriel d'exemple "EXAMPLE", contient une apostrophe"""
“Tutoriel pour débutants\"EXAMPLE\", contient une apostrophe"

Si la chaîne est trop longue, nous pouvons utiliser une barre oblique inversée\pour la diviser :

Exemple

julia> "Ceci est une longue \
       ligne"

"Ceci est une longue ligne"
Les chaînes Julia peuvent aussi, comme les tableaux, utiliser l'indexation pour lire le caractère à une position spécifiée ou extraire la sous-chaîne à une position spécifiée. L'index de début est1oubegin, et la position de fin estend :

Exemple

julia> str = "EXAMPLE"
"EXAMPLE"

julia> str[begin]
'R': ASCII/Unicode U+0052 (catégorie Lu: Lettre, majuscule)

julia> str[1]
'R': ASCII/Unicode U+0052 (catégorie Lu: Lettre, majuscule)

julia> str[2]
'U': ASCII/Unicode U+0055 (catégorie Lu: Lettre, majuscule)

julia> str[end]
'B': ASCII/Unicode U+0042 (catégorie Lu : Lettre, majuscule)

julia> str[end-1]
'O': ASCII/Unicode U+004F (catégorie Lu : Lettre, majuscule)

Nous pouvons utiliser l'indexation de plage pour extraire des sous-chaînes :

Exemple

julia> str = "EXAMPLE"
"EXAMPLE"

julia> str[begin:end]
"EXAMPLE"

julia> str[begin:end-1]
"RUNOO"

julia> str[2:5]
"UNOO"

De plus, les expressionsstr[k]etstr[k:k]donnent des résultats différents : la première obtient le caractère à une position spécifiée via l'indexation, et son type est Char ; la seconde lit la chaîne via la plage donnée, sauf qu'il s'agit juste d'une chaîne contenant un seul caractère :

Exemple

julia> str[6]
'B': ASCII/Unicode U+0042 (catégorie Lu : Lettre, majuscule)

julia> str[6:6]
"B"

L'extraction de plage peut également être implémentée en utilisant la méthodeSubString, par exemple :

Exemple

julia> str = "long string"
"long string"

julia> substr = SubString(str, 1, 4)
"long"

julia> typeof(substr)
SubString{String}

Concaténation de chaînes

Nous pouvons utiliser la méthode string() pour concaténer plusieurs chaînes de caractères :

Exemple

julia> greet = "Hello"
"Hello"

julia> whom = "world"
"world"

julia> string(greet, ", ", whom, ".\n")
"Hello, world.\n"

Interpolation

La façon de construire des chaînes par concaténation est parfois un peu fastidieuse. Pour réduire les appels redondants à string ou la multiplication répétée, Julia permet l'interpolation de littéraux de chaîne à l'aide de $, comme en Perl :

Exemple

julia> "$greet, $whom."\n"
"Hello, world.\n"

C'est plus lisible et pratique, et c'est équivalent à la concaténation — le système réécrit ce littéral de chaîne apparemment sur une seule ligne en une concaténation de littéraux de chaîne avec des arguments.string(greet, ", ", whom, ".\n")。

Dans$l'expression complète la plus courte après le `$` est considérée comme l'expression dont la valeur est insérée dans la chaîne. Par conséquent, vous pouvez insérer n'importe quelle expression dans la chaîne en utilisant des parenthèses :

Exemple

julia> "1 + 2 = $(1 + 2)"
"1 + 2 = 3"

La concaténation et l'interpolation appellent toutes deux string pour convertir les objets en forme de chaîne. Cependant, string renvoie en fait simplement la sortie de print, donc les nouveaux types devraient ajouter des méthodes print ou show plutôt qu'une méthode string.

La plupart des objets non-AbstractString sont convertis en chaînes qui correspondent étroitement à la façon dont ils sont saisis comme expressions textuelles :

Exemple

julia> v = [1,2,3]
3-element Vector{Int64}:
 1
 2
 3

julia> "v: $v"
"v: [1, 2, 3]"

string est l'identité pour les valeurs AbstractString et AbstractChar, de sorte qu'elles sont insérées dans les chaînes telles quelles, sans guillemets ni échappement :

Exemple

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

julia> "hi, $c"
"hi, x"

Si vous souhaitez inclure le littéral `$` dans une chaîne littérale$, échappez-le avec une barre oblique inverse :

Exemple

julia> print("I have \$100 in my account.\n")
J'ai $100 sur mon compte.

Unicode et UTF-8

Julia prend entièrement en charge les caractères et les chaînes Unicode.

Dans les littéraux de caractère, les points de code Unicode peuvent être représentés à l'aide des séquences d'échappement Unicode \u et \U, ainsi que de toutes les séquences d'échappement C standard. Elles peuvent également être utilisées pour écrire des littéraux de chaîne :

Exemple

julia> s = "\u2200 x \u2203 y"
"∀ x ∃ y"

Le fait que ces caractères Unicode soient affichés sous forme de séquences d'échappement ou de caractères spéciaux dépend des paramètres régionaux de votre terminal et de sa prise en charge d'Unicode. Les littéraux de chaîne sont encodés en UTF-8. UTF-8 est un encodage à longueur variable, ce qui signifie que tous les caractères ne sont pas encodés avec le même nombre d'octets (unités de code). En UTF-8, les caractères ASCII (ceux inférieurs à 0x80 (128)) sont encodés avec un seul octet, exactement comme en ASCII ; les caractères à partir de 0x80 et au-dessus sont encodés avec jusqu'à 4 octets.


Littéraux de chaîne entre guillemets triples

Les guillemets triples"""..."""facilitent la création de chaînes plus longues et plus complexes. À l'intérieur des guillemets triples, les sauts de ligne, les guillemets et l'indentation peuvent être utilisés commodément sans traitement particulier.

Exemple

julia> str = """
           Hello,
           world.
         """

" Hello,\n  world.\n"

Comparaison de chaînes

Nous pouvons utiliser des opérateurs de comparaison pour comparer des chaînes dans l'ordre lexicographique :

Exemple

julia> "abracadabra" < "xylophone"
vrai

julia> "abracadabra" == "xylophone"
false

julia> "Hello, world." != "Goodbye, world."
vrai

julia> "1 + 2 = 3" == "1 + 2 = $(1 + 2)"
vrai

Vous pouvez utiliser les fonctions findfirst et findlast pour rechercher l'indice d'un caractère spécifique :

Exemple

julia> findfirst(isequal('o'), "xylophone")
4

julia> findlast(isequal('o'), "xylophone")
7

julia> findfirst(isequal('z'), "xylophone")

Vous pouvez passer un troisième argument et utiliser les fonctions findnext et findprev pour rechercher un caractère à un décalage donné :

Exemple

julia> findnext(isequal('o'), "xylophone", 1)
4

julia> findnext(isequal('o'), "xylophone", 5)
7

julia> findprev(isequal('o'), "xylophone", 5)
4

julia> findnext(isequal('o'), "xylophone", 8)

Vous pouvez utiliser la fonction occursin pour vérifier si une sous-chaîne peut être trouvée dans une chaîne.

Exemple

julia> occursin("world", "Hello, world.")
vrai

julia> occursin("o", "Xylophon")
vrai

julia> occursin("a", "Xylophon")
false

julia> occursin('o', "Xylophon")
vrai

Le dernier exemple montre que occursin peut également être utilisé pour rechercher des littéraux de caractères.

Il existe aussi deux fonctions de chaîne pratiques, repeat et join :

Exemple

julia> repeat(".:Z:.", 10)
".:Z:..:Z:..:Z:..:Z:..:Z:..:Z:..:Z:..:Z:..:Z:..:Z:."

julia> join(["apples", "bananas", "pineapples"], ", ", " and ")
"apples, bananas and pineapples"

Autres fonctions utiles :

  • firstindex(str)- Renvoie l'index minimal (en octets) pouvant être utilisé pour indexer str (pour les chaînes, il vaut toujours 1, mais pas nécessairement pour d'autres conteneurs).
  • lastindex(str)- Renvoie l'index maximal (en octets) pouvant être utilisé pour indexer str.
  • length(str)- Le nombre de caractères dans str.
  • length(str, i, j)- Le nombre d'indices de caractères valides de i à j dans str.
  • ncodeunits(str)- Le nombre d'unités de code dans la chaîne.
  • codeunit(str, i)- Renvoie la valeur de l'unité de code à l'index i dans la chaîne str.
  • thisind(str, i)- Étant donné un index arbitraire dans une chaîne, trouve le premier index du caractère qui contient cet index.
  • nextind(str, i, n=1)- Trouve le début du n-ième caractère après l'index i.
  • prevind(str, i, n=1)- Trouve le début du n-ième caractère avant l'indice i.

Littéraux de chaînes brutes

Les chaînes brutes sans interpolation ni déséchappement peuvent être représentées parraw"..."littéraux de chaîne non standard. Les littéraux de chaîne brute produisent des objets String ordinaires qui contiennent le contenu inclus exactement tel qu'en entrée, sans interpolation ni déséchappement. Ceci est utile pour les chaînes contenant du code ou du balisage dans d'autres langages qui utilisent"ou\"\ comme caractère spécial.

L'exception est que les guillemets doivent toujours être échappés, par exempleraw"\""est équivalent à"\"". Afin de pouvoir exprimer toutes les chaînes, les barres obliques inverses doivent également être échappées, mais seulement lorsqu'elles apparaissent immédiatement avant un guillemet.

julia> println(raw"\\ \\\"")
\\ \"

Notez que les deux premières barres obliques inverses apparaissent textuellement dans la sortie car elles ne sont pas avant un guillemet. Cependant, le caractère de barre oblique inverse suivant échappe la barre oblique inverse suivante ; et comme ces barres obliques inverses apparaissent avant un guillemet, la dernière barre oblique inverse échappe un guillemet.

Autres extensions