Julia Language
Cordes

Syntaxe

• "[chaîne]"
• '[Valeur scalaire Unicode]'
• graphemes ([string])

Paramètres

Bonjour le monde!

Les chaînes de caractères de Julia sont délimitées à l'aide du " symbole:

julia> mystring = "Hello, World!"
"Hello, World!"

Notez que contrairement à d'autres langues, le symbole ' ne peut pas être utilisé à la place. ' définit un littéral de caractère ; c'est un type de données Char et ne stockera qu'une seule valeur scalaire Unicode :

julia> 'c'
'c'

julia> 'character'
ERROR: syntax: invalid character literal

On peut extraire les valeurs scalaires unicode d'une chaîne en l'itérant avec une boucle for :

julia> for c in "Hello, World!"
           println(c)
       end
H
e
l
l
o
,
 
W
o
r
l
d
!

Graphemes

Le type Char de Julia représente une valeur scalaire Unicode , qui correspond dans certains cas uniquement à ce que les humains perçoivent comme un "caractère". Par exemple, une représentation du caractère é, comme dans résumé, est en fait une combinaison de deux valeurs scalaires Unicode:

julia> collect("é")
2-element Array{Char,1}:
 'e'
 '́'

Les descriptions Unicode de ces points de code sont "LETTRE MINUSCULE LATINE E" et "ACCENT COMBINANT AIGU". Ensemble, ils définissent un seul caractère "humain", ce qui signifie que les termes Unicode sont appelés graphèmes . Plus précisément, l'Annexe Unicode n ° 29 motive la définition d'un cluster grapheme car:

Il est important de reconnaître que ce que l'utilisateur considère comme un «caractère» - une unité de base d'un système d'écriture pour une langue - peut ne pas être un simple point de code Unicode. Au lieu de cela, cette unité de base peut être composée de plusieurs points de code Unicode. Pour éviter toute ambiguïté avec l'utilisation informatique du terme caractère, cela s'appelle un caractère perçu par l'utilisateur. Par exemple, «G» + accent aigu est un caractère perçu par l'utilisateur: les utilisateurs le considèrent comme un seul caractère, mais sont en réalité représentés par deux points de code Unicode. Ces caractères perçus par l'utilisateur sont approximés par ce qu'on appelle un cluster de graphèmes, qui peut être déterminé par programmation.

Julia fournit la fonction graphemes pour parcourir les grappes de graphèmes dans une chaîne:

julia> for c in graphemes("résumé")
           println(c)
       end
r
é
s
u
m
é

Notez que le résultat, en imprimant chaque caractère sur sa propre ligne, est meilleur que si nous avions itéré sur les valeurs scalaires Unicode:

julia> for c in "résumé"
           println(c)
       end
r
e

s
u
m
e

Généralement, lorsque vous travaillez avec des caractères dans un sens perçu par l'utilisateur, il est plus utile de traiter des grappes de graphèmes qu'avec des valeurs scalaires Unicode. Par exemple, supposons que nous voulions écrire une fonction pour calculer la longueur d'un seul mot. Une solution naïve serait d'utiliser

julia> wordlength(word) = length(word)
wordlength (generic function with 1 method)

Nous notons que le résultat est contre-intuitif lorsque le mot inclut des grappes de graphèmes composées de plusieurs points de code:

julia> wordlength("résumé")
8

Lorsque nous utilisons la définition la plus correcte, en utilisant la fonction graphemes , nous obtenons le résultat attendu:

julia> wordlength(word) = length(graphemes(word))
wordlength (generic function with 1 method)

julia> wordlength("résumé")
6

Convertir les types numériques en chaînes

Il existe de nombreuses façons de convertir des types numériques en chaînes dans Julia:

julia> a = 123
123

julia> string(a)
"123"

julia> println(a)
123

La fonction string() peut également prendre plus d'arguments:

julia> string(a, "b")
"123b"

Vous pouvez également insérer (aka interpoler) des entiers (et certains autres types) dans des chaînes en utilisant $ :

julia> MyString = "my integer is $a"
"my integer is 123"

Astuce de performance: Les méthodes ci-dessus peuvent être très pratiques par moments. Mais, si vous exécutez beaucoup d'opérations de ce type et que vous êtes préoccupé par la vitesse d'exécution de votre code, le guide de performance de Julia vous le déconseille, mais plutôt les méthodes ci-dessous:

Vous pouvez fournir plusieurs arguments à print() et println() qui fonctionneront exactement comme string() opère sur plusieurs arguments:

julia> println(a, "b")
123b

Ou, lorsque vous écrivez dans un fichier, vous pouvez également utiliser, par exemple

open("/path/to/MyFile.txt", "w") do file
    println(file, a, "b", 13)
end

ou

file = open("/path/to/MyFile.txt", "a")
println(file, a, "b", 13)
close(file)

Celles-ci sont plus rapides car elles évitent de devoir d'abord former une chaîne à partir de morceaux donnés, puis de la sortir (soit sur l'écran de la console, soit sur un fichier) et de ne sortir que séquentiellement les différentes pièces.

Crédits: Réponse basée sur SO Question Quelle est la meilleure façon de convertir un Int en String dans Julia? avec la réponse de Michael Ohlrogge et la contribution de Fengyang Wang

Interpolation de chaîne (valeur d'insertion définie par la variable dans la chaîne)

Dans Julia, comme dans de nombreux autres langages, il est possible d'interpoler en insérant des valeurs définies par des variables dans des chaînes. Pour un exemple simple:

n = 2
julia> MyString = "there are $n ducks"
"there are 2 ducks"

Nous pouvons utiliser d'autres types que numériques, par exemple

Result = false
julia> println("test results is $Result")
test results is false

Vous pouvez avoir plusieurs interpolations dans une chaîne donnée:

MySubStr = "a32"
MyNum = 123.31
println("$MySubStr  ,   $MyNum")

Astuce de performance L' interpolation est très pratique. Mais si vous le faites très rapidement, ce n’est pas le plus efficace. Au lieu de cela, voir Convertir les types numériques en chaînes pour obtenir des suggestions lorsque les performances posent problème.

Utilisation du sprint pour créer des chaînes avec des fonctions IO

Les chaînes peuvent être créées à partir de fonctions qui fonctionnent avec des objets IO en utilisant la fonction sprint . Par exemple, la fonction code_llvm accepte un objet IO comme premier argument. Typiquement, il est utilisé comme

julia> code_llvm(STDOUT, *, (Int, Int))

define i64 @"jlsys_*_46115"(i64, i64) #0 {
top:
  %2 = mul i64 %1, %0
  ret i64 %2
}

Supposons que nous voulons cette sortie sous forme de chaîne à la place. Alors on peut simplement faire

julia> sprint(code_llvm, *, (Int, Int))
"\ndefine i64 @\"jlsys_*_46115\"(i64, i64) #0 {\ntop:\n  %2 = mul i64 %1, %0\n  ret i64 %2\n}\n"

julia> println(ans)

define i64 @"jlsys_*_46115"(i64, i64) #0 {
top:
  %2 = mul i64 %1, %0
  ret i64 %2
}

La conversion des résultats de fonctions "interactives" comme code_llvm en chaînes peut être utile pour une analyse automatisée, telle que le test de la régression du code généré.

La fonction sprint est une fonction d'ordre supérieur qui prend comme premier argument la fonction opérant sur les objets IO . Dans les coulisses, il crée un IOBuffer dans la RAM, appelle la fonction donnée et prend les données du tampon dans un objet String .