Julia Language
Zeichenketten

Syntax

• "[string]"
• "[Unicode-Skalarwert]"
• Graphemes ([Zeichenfolge])

Parameter

Hallo Welt!

Zeichenfolgen in Julia werden mit dem Symbol " :

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

Beachten Sie, dass im Gegensatz zu anderen Sprachen das ' Symbol nicht verwendet werden kann. ' definiert ein Zeichenliteral ; Dies ist ein Char Datentyp und speichert nur einen einzelnen Unicode-Skalarwert :

julia> 'c'
'c'

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

Man kann die Unicode-Skalarwerte aus einem String extrahieren, indem man ihn mit einer for Schleife durchläuft :

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

Graphemes

Julias Char Typ steht für einen Unicode-Skalarwert , der nur in einigen Fällen dem entspricht, was Menschen als "Zeichen" wahrnehmen. Zum Beispiel ist eine Darstellung des Zeichens é wie in einem Lebenslauf tatsächlich eine Kombination aus zwei Unicode-Skalarwerten:

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

Die Unicode-Beschreibungen für diese Codepunkte lauten "LATIN SMALL LETTER E" und "COMBINING ACUTE ACCENT". Zusammen definieren sie ein einzelnes "menschliches" Zeichen, bei dem Unicode-Begriffe als Graphem bezeichnet werden . Genauer gesagt, motiviert Unicode-Anhang Nr. 29 die Definition eines Graphem-Clusters aus folgenden Gründen:

Es ist wichtig zu wissen, dass das, was der Benutzer als "Zeichen" betrachtet - eine Grundeinheit eines Schriftsystems für eine Sprache - möglicherweise nicht nur ein einzelner Unicode-Codepunkt ist. Stattdessen kann diese Basiseinheit aus mehreren Unicode-Codepunkten bestehen. Um Mehrdeutigkeiten bei der Verwendung des Begriffs "Zeichen" durch den Computer zu vermeiden, wird dies als vom Benutzer wahrgenommenes Zeichen bezeichnet. Zum Beispiel ist „G“ + Akzentakzent ein vom Benutzer wahrgenommenes Zeichen: Benutzer halten es für ein einzelnes Zeichen, werden jedoch tatsächlich durch zwei Unicode-Codepunkte dargestellt. Diese vom Benutzer wahrgenommenen Zeichen werden durch einen sogenannten Graphem-Cluster approximiert, der programmgesteuert bestimmt werden kann.

Julia bietet die graphemes Funktion zum Durchlaufen der Graphem-Cluster in einer Zeichenfolge:

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

Beachten Sie, dass das Ergebnis, wenn Sie jedes Zeichen in einer eigenen Zeile drucken, besser ist, als wenn wir die Unicode-Skalarwerte durchlaufen hätten:

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

s
u
m
e

Normalerweise ist es bei der Arbeit mit Zeichen im Sinne des Benutzers sinnvoller, mit Graphem-Clustern zu arbeiten als mit Unicode-Skalarwerten. Angenommen, wir möchten eine Funktion schreiben, um die Länge eines einzelnen Wortes zu berechnen. Eine naive Lösung wäre zu verwenden

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

Das Ergebnis ist nicht intuitiv, wenn das Wort Graphem-Cluster enthält, die aus mehr als einem Codepunkt bestehen:

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

Wenn wir die korrektere Definition mit der Funktion graphemes verwenden, erhalten wir das erwartete Ergebnis:

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

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

Konvertieren Sie numerische Typen in Strings

Es gibt zahlreiche Möglichkeiten, numerische Typen in Strings in Julia zu konvertieren:

julia> a = 123
123

julia> string(a)
"123"

julia> println(a)
123

Die Funktion string() kann auch mehr Argumente annehmen:

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

Sie können Integer (auch als Interpolation bezeichnet) (und bestimmte andere Typen) mit $ in Strings einfügen:

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

Leistungstipp: Die oben genannten Methoden können zuweilen recht bequem sein. Wenn Sie jedoch viele, viele derartige Vorgänge ausführen und sich Gedanken über die Ausführungsgeschwindigkeit Ihres Codes machen, empfiehlt der Julia- Leistungsführer dagegen und stattdessen die folgenden Methoden:

Sie können für print() und println() mehrere Argumente println() die genau so funktionieren, wie string() für mehrere Argumente:

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

Oder wenn Sie in eine Datei schreiben, können Sie auf ähnliche Weise verwenden, z

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

oder

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

Diese sind schneller, da sie es vermeiden, zuerst eine Zeichenfolge aus bestimmten Teilen zu formen und dann auszugeben (entweder an die Konsolenanzeige oder in eine Datei) und stattdessen einfach die verschiedenen Teile nacheinander ausgeben.

Credits: Antwort basierend auf SO Frage Wie kann ich ein Int in einen String in Julia am besten konvertieren? mit Antwort von Michael Ohlrogge und Input von Fengyang Wang

String-Interpolation (Einfügung eines Wertes durch eine Variable in einen String)

In Julia ist es wie in vielen anderen Sprachen möglich, durch Einfügen von durch Variablen definierten Werten in Strings zu interpolieren. Für ein einfaches Beispiel:

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

Wir können andere Typen als numerische verwenden, z

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

Sie können mehrere Interpolationen innerhalb einer gegebenen Zeichenfolge haben:

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

Leistungstipp Interpolation ist ziemlich bequem. Aber wenn Sie es oft sehr schnell machen, ist es nicht das effizienteste. Siehe unter Konvertieren numerischer Typen in Zeichenfolgen für Vorschläge, wenn Leistung ein Problem ist.

Verwenden von sprint zum Erstellen von Zeichenfolgen mit E / A-Funktionen

Zeichenfolgen können aus Funktionen erstellt werden, die mit IO Objekten arbeiten, indem Sie die sprint Funktion verwenden. Zum Beispiel kann die code_llvm nimmt Funktion ein IO - Objekt als erstes Argument. Normalerweise wird es gerne verwendet

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

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

Angenommen, wir möchten diese Ausgabe stattdessen als Zeichenfolge. Dann können wir es einfach tun

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
}

Umwandeln der Ergebnisse der „interaktiven“ Funktionen wie code_llvm in Strings können für die automatisierte Analyse, wie nützlich sein Testen , ob generierte Code haben regressiert kann.

Die sprint Funktion ist eine Funktion höherer Ordnung, die als erstes Argument die Funktion der IO Objekte verwendet. Hinter den Kulissen erstellt es einen IOBuffer im RAM, ruft die angegebene Funktion auf und übernimmt die Daten aus dem Puffer in ein String Objekt.