Zeichenketten in Julia

Eine Zeichenkette ist eine endliche Folge von null oder mehr Zeichen. Sie ist ein Datentyp in Programmiersprachen, der zur Darstellung von Text verwendet wird.

Julia verwendet normalerweise einfache Anführungszeichen', um einzelne Zeichen zu erstellen, und doppelte Anführungszeichen"oder drei Anführungszeichen""", um Zeichenketten zu erstellen. Zum Beispiel:

c = 'x'

str = "EXAMPLE"

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

Merkmale des Julia-String-Typs:

  • Der eingebaute konkrete Typ, der in Julia für Zeichenketten (und String-Literale) verwendet wird, ist String.
  • Julias String-Typen sind alle Untertypen des abstrakten Typs AbstractString.
  • Julia hat einen hervorragenden Typ zur Darstellung einzelner Zeichen, nämlich AbstractChar. Char ist ein eingebauter Untertyp von AbstractChar, ein 32-Bit-Primitivtyp, der jedes Unicode-Zeichen darstellen kann (basierend auf UTF-8-Kodierung).
  • Julia-Zeichenketten sind unveränderlich – der Wert eines beliebigen AbstractString-Objekts kann nicht geändert werden.

Zeichen

Einzelne Zeichen werden durch Char-Werte dargestellt.

Char ist ein primitiver 32-Bit-Typ, der in seinen entsprechenden Ganzzahlwert umgewandelt werden kann, d. h. den Unicode-Code:

Beispiel

julia> c = 'x'
'x': ASCII/Unicode U+0078 (Kategorie Ll: Buchstabe, Kleinbuchstabe)

julia> typeof(c)
Char

julia> c = Int('x')
120

julia> typeof(c)
Int64

Wir können auch einen Ganzzahlwert in ein Char umwandeln:

Beispiel

julia> Char(97)
'a': ASCII/Unicode U+0061 (Kategorie Ll: Buchstabe, Kleinbuchstabe)

julia> Char(120)
'x': ASCII/Unicode U+0078 (Kategorie Ll: Buchstabe, Kleinbuchstabe)

Wir können Vergleiche und begrenzte arithmetische Operationen mit Char-Werten durchführen:

Beispiel

julia> 'A' < 'a'
wahr

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

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

julia> 'x' - 'a'
23

julia> 'A' + 1
'B': ASCII/Unicode U+0042 (Kategorie Lu: Buchstabe, Großbuchstabe)

Zeichenketten

Zeichenketten in Julia können mit doppelten Anführungszeichen deklariert werden"oder mit drei doppelten Anführungszeichen"""Wenn Sie Anführungszeichen in einem Teil einer Zeichenkette verwenden müssen, können Sie dafür drei doppelte Anführungszeichen verwenden, wie unten gezeigt:

Beispiel

julia> str = "EXAMPLE"
"BEISPIEL"

julia> example = """Example tutorial "EXAMPLE", contains a single quote"""
“Rookie Tutorial\"EXAMPLE\", contains a single quote"

Wenn die Zeichenkette zu lang ist, können wir einen Backslash\verwenden, um sie aufzuteilen:

Beispiel

julia> "This is a long \
       line"

"This is a long line"
Julia-Zeichenketten können ebenso wie Arrays die Indexierung verwenden, um das Zeichen an einer angegebenen Position zu lesen oder die Teilzeichenkette an einer angegebenen Position zu extrahieren. Der Startindex ist1oderbegin, und die Endposition istend :

Beispiel

julia> str = "EXAMPLE"
"BEISPIEL"

julia> str[begin]
'R': ASCII/Unicode U+0052 (category Lu: Letter, uppercase)

julia> str[1]
'R': ASCII/Unicode U+0052 (category Lu: Letter, uppercase)

julia> str[2]
'U': ASCII/Unicode U+0055 (category Lu: Letter, uppercase)

julia> str[end]
'B': ASCII/Unicode U+0042 (Kategorie Lu: Buchstabe, Großbuchstabe)

julia> str[end-1]
'O': ASCII/Unicode U+004F (Kategorie Lu: Buchstabe, Großbuchstabe)

Wir können die Bereichsindizierung verwenden, um Teilzeichenfolgen zu extrahieren:

Beispiel

julia> str = "EXAMPLE"
"BEISPIEL"

julia> str[begin:end]
"BEISPIEL"

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

julia> str[2:5]
"UNOO"

Darüber hinaus liefern die Ausdrückestr[k]undstr[k:k]unterschiedliche Ergebnisse: Ersterer ruft das Zeichen an einer angegebenen Position durch Indexierung ab, und sein Typ ist Char; Letzterer liest die Zeichenkette über den angegebenen Bereich, außer dass es sich nur um eine Zeichenkette handelt, die ein einzelnes Zeichen enthält:

Beispiel

julia> str[6]
'B': ASCII/Unicode U+0042 (Kategorie Lu: Buchstabe, Großbuchstabe)

julia> str[6:6]
"B"

Die Bereichsextraktion kann auch mithilfe derSubString-Methode implementiert werden, zum Beispiel:

Beispiel

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

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

julia> typeof(substr)
SubString{String}

Zeichenkettenverkettung

Wir können die Methode string() verwenden, um mehrere Zeichenfolgen zu verketten:

Beispiel

julia> greet = "Hello"
"Hello"

julia> whom = "world"
"world"

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

Interpolation

Die Art und Weise, Zeichenfolgen durch Verkettung zu konstruieren, ist manchmal etwas umständlich. Um redundante Aufrufe von string oder wiederholte Multiplikation zu reduzieren, erlaubt Julia die Interpolation von Zeichenfolgenliteralen mit $, wie in Perl:

Beispiel

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

Dies ist lesbarer und bequemer und entspricht der obigen Zeichenkettenverkettung – das System schreibt dieses scheinbar einzeilige Zeichenkettenliteral in eine Verkettung von Zeichenkettenliteralen mit Argumenten um.string(greet, ", ", whom, ".\n")。

In$Der kürzeste vollständige Ausdruck nach dem `$` wird als der Ausdruck genommen, dessen Wert in die Zeichenkette eingefügt wird. Daher können Sie jeden Ausdruck mit Klammern in eine Zeichenkette einfügen:

Beispiel

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

Sowohl Verkettung als auch Interpolation rufen string auf, um Objekte in Zeichenkettenform umzuwandeln. string gibt jedoch tatsächlich einfach die Ausgabe von print zurück, daher sollten neue Typen eher print- oder show-Methoden als eine string-Methode hinzufügen.

Die meisten Nicht-AbstractString-Objekte werden in Zeichenketten umgewandelt, die weitgehend der Art und Weise entsprechen, wie sie als Textausdrücke eingegeben werden:

Beispiel

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

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

string ist die Identität für AbstractString- und AbstractChar-Werte, daher werden sie unverändert in Zeichenketten eingefügt, ohne Anführungszeichen oder Escaping:

Beispiel

julia> c = 'x'
'x': ASCII/Unicode U+0078 (Kategorie Ll: Buchstabe, Kleinbuchstabe)

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

Wenn du das `$` wörtlich in einem String-Literal$verwenden möchtest, maskiere es mit einem Backslash:

Beispiel

julia> print("Ich habe \$100 auf meinem Konto.\n")
Ich habe $100 auf meinem Konto.

Unicode und UTF-8

Julia unterstützt Unicode-Zeichen und Zeichenketten vollständig.

In Zeichenliteralen können Unicode-Codepunkte mit den Unicode-Escape-Sequenzen \u und \U sowie allen standardmäßigen C-Escape-Sequenzen dargestellt werden. Diese können auch verwendet werden, um Zeichenkettenliterale zu schreiben:

Beispiel

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

Ob diese Unicode-Zeichen als Escapes oder als Sonderzeichen angezeigt werden, hängt von den Locale-Einstellungen Ihres Terminals und dessen Unicode-Unterstützung ab. Zeichenkettenliterale werden in UTF-8 kodiert. UTF-8 ist eine Kodierung mit variabler Länge, was bedeutet, dass nicht alle Zeichen mit der gleichen Anzahl von Bytes (Codeeinheiten) kodiert werden. In UTF-8 werden ASCII-Zeichen (die kleiner als 0x80 (128) sind) mit einem einzigen Byte kodiert, genau wie in ASCII; Zeichen ab 0x80 und darüber werden mit bis zu 4 Bytes kodiert.


Zeichenkettenliterale mit dreifachen Anführungszeichen

Dreifache Anführungszeichen"""..."""bieten Komfort beim Erstellen längerer und komplexerer Zeichenketten. Innerhalb dreifacher Anführungszeichen können Zeilenumbrüche, Anführungszeichen und Einrückungen bequem ohne besondere Behandlung verwendet werden.

Beispiel

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

" Hello,\n  world.\n"

String-Vergleich

Wir können Vergleichsoperatoren verwenden, um Zeichenketten in lexikografischer Reihenfolge zu vergleichen:

Beispiel

julia> "abracadabra" < "xylophone"
wahr

julia> "abracadabra" == "xylophone"
false

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

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

Sie können die Funktionen findfirst und findlast verwenden, um nach dem Index eines bestimmten Zeichens zu suchen:

Beispiel

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

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

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

Sie können ein drittes Argument übergeben und die Funktionen findnext und findprev verwenden, um an einem gegebenen Offset nach einem Zeichen zu suchen:

Beispiel

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)

Sie können die Funktion occursin verwenden, um zu prüfen, ob ein Teilstring in einer Zeichenkette gefunden werden kann.

Beispiel

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

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

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

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

Das letzte Beispiel zeigt, dass occursin auch verwendet werden kann, um nach Zeichenliteralen zu suchen.

Außerdem gibt es zwei praktische Zeichenkettenfunktionen, repeat und join:

Beispiel

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

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

Weitere nützliche Funktionen sind:

  • firstindex(str)- Gibt den minimalen (Byte-)Index zurück, der zum Indizieren in str verwendet werden kann (für Strings ist dies immer 1, aber nicht unbedingt für andere Container).
  • lastindex(str)- Gibt den maximalen (Byte-)Index zurück, der zum Indizieren in str verwendet werden kann.
  • length(str)- Die Anzahl der Zeichen in str.
  • length(str, i, j)- Die Anzahl der gültigen Zeichenindizes von i bis j in str.
  • ncodeunits(str)- Die Anzahl der Codeeinheiten in der Zeichenkette.
  • codeunit(str, i)- Gibt den Wert der Codeeinheit am Index i in der Zeichenkette str zurück.
  • thisind(str, i)- Findet zu einem beliebigen Index in einer Zeichenkette den ersten Index des Zeichens, das diesen Index enthält.
  • nextind(str, i, n=1)- Findet den Anfang des n-ten Zeichens nach Index i.
  • prevind(str, i, n=1)- Findet den Anfang des n-ten Zeichens vor Index i.

Raw-String-Literale

Raw-Strings ohne Interpolation und Unescaping können durchraw"..."nicht standardmäßige String-Literale dargestellt werden. Raw-String-Literale erzeugen gewöhnliche String-Objekte, die den eingeschlossenen Inhalt exakt wie eingegeben enthalten, ohne Interpolation und Unescaping. Dies ist nützlich für Strings, die Code oder Markup in anderen Sprachen enthalten, die"oder\"\ als Sonderzeichen verwenden.

Die Ausnahme ist, dass Anführungszeichen weiterhin escaped werden müssen, zum Beispielraw"\""ist äquivalent zu"\"". Um alle Strings ausdrücken zu können, müssen auch Backslashes escaped werden, aber nur, wenn sie unmittelbar vor einem Anführungszeichen stehen.

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

Beachten Sie, dass die ersten beiden Backslashes wörtlich in der Ausgabe erscheinen, weil sie nicht vor einem Anführungszeichen stehen. Das nächste Backslash-Zeichen escaped jedoch den folgenden Backslash; und da diese Backslashes vor einem Anführungszeichen stehen, escaped der letzte Backslash ein Anführungszeichen.

Andere Erweiterungen