Strings

Der Typ AbstractString ist der Supertyp aller String-Implementierungen in Julia. Strings sind Kodierungen von Sequenzen von Unicode Codepunkten, wie sie durch den Typ AbstractChar dargestellt werden. Julia trifft einige Annahmen über Strings:

• Strings sind in Bezug auf feste "Codeeinheiten" kodiert

  • Codeeinheiten können mit codeunit(s, i) extrahiert werden
  • Die erste Codeeinheit hat den Index 1
  • Die letzte Codeeinheit hat den Index ncodeunits(s)
  • Jeder Index i, so dass 1 ≤ i ≤ ncodeunits(s), ist im Bereich

• Die String-Indizierung erfolgt in Bezug auf diese Codeeinheiten:

  • Zeichen werden durch s[i] mit einem gültigen String-Index i extrahiert
  • Jedes AbstractChar in einem String wird durch eine oder mehrere Codeeinheiten kodiert
  • Nur der Index der ersten Codeeinheit eines AbstractChar ist ein gültiger Index
  • Die Kodierung eines AbstractChar ist unabhängig von dem, was ihm vorausgeht oder folgt
  • String-Kodierungen sind selbstsynchronisierend – d.h. isvalid(s, i) ist O(1)

Einige String-Funktionen, die Codeeinheiten, Zeichen oder Teilstrings aus Strings extrahieren, geben einen Fehler aus, wenn Sie ihnen ungültige oder außerhalb des Bereichs liegende String-Indizes übergeben. Dazu gehören codeunit(s, i) und s[i]. Funktionen, die String-Indexarithmetik durchführen, gehen entspannter mit der Indizierung um und geben Ihnen den nächstgelegenen gültigen String-Index zurück, wenn er im Bereich liegt, oder verhalten sich, wenn sie außerhalb des Bereichs liegen, so, als ob es eine unendliche Anzahl von Zeichen gibt, die jede Seite des Strings polstern. Normalerweise haben diese imaginären Polsterzeichen eine Codeeinheitslänge von 1, aber String-Typen können unterschiedliche "imaginäre" Zeichengrößen wählen, die für ihre Implementierungen sinnvoll sind (z.B. können Teilstrings die Indexarithmetik an den zugrunde liegenden String weitergeben, in den sie eine Ansicht bieten). Entspannte Indizierungsfunktionen umfassen diejenigen, die für die Indexarithmetik gedacht sind: thisind, nextind und prevind. Dieses Modell ermöglicht es, dass die Indexarithmetik mit außerhalb des Bereichs liegenden Indizes als Zwischenwerte funktioniert, solange man sie niemals verwendet, um ein Zeichen abzurufen, was oft hilft, die Notwendigkeit zu vermeiden, um Randfälle herum zu codieren.

Siehe auch codeunit, ncodeunits, thisind, nextind, prevind.

Der AbstractChar-Typ ist der Supertyp aller Zeichenimplementierungen in Julia. Ein Zeichen repräsentiert einen Unicode-Codepunkt und kann über die codepoint-Funktion in eine Ganzzahl umgewandelt werden, um den numerischen Wert des Codepunkts zu erhalten, oder aus derselben Ganzzahl konstruiert werden. Diese numerischen Werte bestimmen, wie Zeichen mit < und == verglichen werden, zum Beispiel. Neue T <: AbstractChar-Typen sollten mindestens eine codepoint(::T)-Methode und einen T(::UInt32)-Konstruktor definieren.

Ein gegebener AbstractChar-Subtyp kann möglicherweise nur eine Teilmenge von Unicode darstellen, in welchem Fall die Umwandlung von einem nicht unterstützten UInt32-Wert einen Fehler auslösen kann. Umgekehrt repräsentiert der eingebaute Char-Typ ein Superset von Unicode (um ungültige Byte-Streams verlustfrei zu kodieren), in welchem Fall die Umwandlung eines Nicht-Unicode-Wertes zu UInt32 einen Fehler auslöst. Die isvalid-Funktion kann verwendet werden, um zu überprüfen, welche Codepunkte in einem gegebenen AbstractChar-Typ darstellbar sind.

Intern kann ein AbstractChar-Typ eine Vielzahl von Kodierungen verwenden. Die Umwandlung über codepoint(char) wird diese Kodierung nicht offenbaren, da sie immer den Unicode-Wert des Zeichens zurückgibt. print(io, c) eines beliebigen c::AbstractChar erzeugt eine Kodierung, die durch io bestimmt wird (UTF-8 für alle eingebauten IO-Typen), gegebenenfalls durch Umwandlung in Char.

write(io, c) hingegen kann eine Kodierung ausgeben, die von typeof(c) abhängt, und read(io, typeof(c)) sollte dieselbe Kodierung lesen wie write. Neue AbstractChar-Typen müssen ihre eigenen Implementierungen von write und read bereitstellen.

Char(c::Union{Number,AbstractChar})

Char ist ein 32-Bit AbstractChar Typ, der die Standarddarstellung von Zeichen in Julia ist. Char ist der Typ, der für Zeichenliterale wie 'x' verwendet wird, und es ist auch der Elementtyp von String.

Um beliebige Byte-Streams, die in einem String gespeichert sind, verlustfrei darzustellen, kann ein Char-Wert Informationen speichern, die nicht in einen Unicode-Codepunkt konvertiert werden können — die Umwandlung eines solchen Char in UInt32 wird einen Fehler auslösen. Die Funktion isvalid(c::Char) kann verwendet werden, um zu überprüfen, ob c ein gültiges Unicode-Zeichen darstellt.

codepoint(c::AbstractChar) -> Integer

Gibt den Unicode-Codepunkt (eine nicht signierte Ganzzahl) zurück, der dem Zeichen c entspricht (oder wirft eine Ausnahme, wenn c kein gültiges Zeichen darstellt). Für Char ist dies ein UInt32-Wert, aber AbstractChar-Typen, die nur eine Teilmenge von Unicode darstellen, können eine ganzzahlige Zahl anderer Größe zurückgeben (z. B. UInt8).

length(s::AbstractString) -> Int
length(s::AbstractString, i::Integer, j::Integer) -> Int

Gibt die Anzahl der Zeichen im String s von den Indizes i bis j zurück.

Dies wird als die Anzahl der Codeeinheitsindizes von i bis j berechnet, die gültige Zeichenindizes sind. Mit nur einem einzelnen String-Argument wird die Anzahl der Zeichen im gesamten String berechnet. Mit den Argumenten i und j wird die Anzahl der Indizes zwischen i und j einschließlich der gültigen Indizes im String s berechnet. Neben den gültigen Werten kann i den ungültigen Wert ncodeunits(s) + 1 und j den ungültigen Wert 0 annehmen.

Siehe auch isvalid, ncodeunits, lastindex, thisind, nextind, prevind.

Beispiele

julia> length("jμΛIα")
5

sizeof(str::AbstractString)

Größe in Bytes des Strings str. Entspricht der Anzahl der Codeeinheiten in str multipliziert mit der Größe in Bytes einer Codeeinheit in str.

Beispiele

julia> sizeof("")
0

julia> sizeof("∀")
3

*(s::Union{AbstractString, AbstractChar}, t::Union{AbstractString, AbstractChar}...) -> AbstractString

Verkettet Zeichenfolgen und/oder Zeichen und erzeugt eine String oder AnnotatedString (je nach Bedarf). Dies entspricht dem Aufruf der Funktion string oder annotatedstring mit den Argumenten. Die Verkettung von eingebauten Zeichenfolgen-Typen erzeugt immer einen Wert des Typs String, aber andere Zeichenfolgen-Typen können wählen, eine Zeichenfolge eines anderen Typs zurückzugeben, wenn dies angemessen ist.

Beispiele

julia> "Hello " * "world"
"Hello world"

julia> 'j' * "ulia"
"julia"

^(s::Union{AbstractString,AbstractChar}, n::Integer) -> AbstractString

Wiederhole einen String oder ein Zeichen n Mal. Dies kann auch als repeat(s, n) geschrieben werden.

Siehe auch repeat.

Beispiele

julia> "Test "^3
"Test Test Test "

string(n::Integer; base::Integer = 10, pad::Integer = 1)

Konvertiert eine Ganzzahl n in einen String in der angegebenen Basis, wobei optional eine Anzahl von Ziffern zum Auffüllen angegeben werden kann.

Siehe auch digits, bitstring, count_zeros.

Beispiele

julia> string(5, base = 13, pad = 4)
"0005"

julia> string(-13, base = 5, pad = 4)
"-0023"

string(xs...)

Erstellen Sie eine Zeichenkette aus beliebigen Werten mit der print Funktion.

string sollte normalerweise nicht direkt definiert werden. Stattdessen definieren Sie eine Methode print(io::IO, x::MyType). Wenn string(x) für einen bestimmten Typ sehr effizient sein muss, kann es sinnvoll sein, eine Methode zu string hinzuzufügen und print(io::IO, x::MyType) = print(io, string(x)) zu definieren, um sicherzustellen, dass die Funktionen konsistent sind.

Siehe auch: String, repr, sprint, show.

Beispiele

julia> string("a", 1, true)
"a1true"

repeat(s::AbstractString, r::Integer)

Wiederhole einen String r Mal. Dies kann als s^r geschrieben werden.

Siehe auch ^.

Beispiele

julia> repeat("ha", 3)
"hahaha"

repeat(c::AbstractChar, r::Integer) -> String

Wiederhole ein Zeichen r Mal. Dies kann auch erreicht werden, indem man c^r aufruft.

Beispiele

julia> repeat('A', 3)
"AAA"

repr(x; context=nothing)

Erstellen Sie einen String aus jedem Wert mit der show Funktion. Sie sollten keine Methoden zu repr hinzufügen; definieren Sie stattdessen eine show Methode.

Das optionale Schlüsselwort-Argument context kann auf ein :key=>value Paar, ein Tupel von :key=>value Paaren oder ein IO oder IOContext Objekt gesetzt werden, dessen Attribute für den I/O-Stream verwendet werden, der an show übergeben wird.

Beachten Sie, dass repr(x) normalerweise ähnlich ist, wie der Wert von x in Julia eingegeben werden würde. Siehe auch repr(MIME("text/plain"), x), um stattdessen eine "schön formatierte" Version von x zurückzugeben, die mehr für den menschlichen Konsum gedacht ist, was dem REPL-Display von x entspricht.

Beispiele

julia> repr(1)
"1"

julia> repr(zeros(3))
"[0.0, 0.0, 0.0]"

julia> repr(big(1/3))
"0.333333333333333314829616256247390992939472198486328125"

julia> repr(big(1/3), context=:compact => true)
"0.333333"

String(s::AbstractString)

Erstellt einen neuen String aus einem vorhandenen AbstractString.

SubString(s::AbstractString, i::Integer, j::Integer=lastindex(s))
SubString(s::AbstractString, r::UnitRange{<:Integer})

Wie getindex, aber gibt eine Ansicht in den übergeordneten String s im Bereich i:j oder r zurück, anstatt eine Kopie zu erstellen.

Das @views Makro konvertiert alle String-Slices s[i:j] in Substrings SubString(s, i, j) in einem Codeblock.

Beispiele

julia> SubString("abc", 1, 2)
"ab"

julia> SubString("abc", 1:2)
"ab"

julia> SubString("abc", 2)
"bc"

LazyString <: AbstractString

Eine faule Darstellung der String-Interpolation. Dies ist nützlich, wenn ein String in einem Kontext konstruiert werden muss, in dem die tatsächliche Interpolation und String-Konstruktion unnötig oder unerwünscht ist (z. B. in Fehlerpfaden von Funktionen).

Dieser Typ ist so konzipiert, dass er zur Laufzeit kostengünstig zu konstruieren ist und versucht, so viel Arbeit wie möglich entweder auf das Makro oder auf spätere Druckoperationen zu verlagern.

Beispiele

julia> n = 5; str = LazyString("n ist ", n)
"n ist 5"

Siehe auch @lazy_str.

Erweiterte Hilfe

Sicherheitsmerkmale für nebenläufige Programme

Ein fauler String selbst führt nicht zu Nebenläufigkeitsproblemen, selbst wenn er in mehreren Julia-Aufgaben gedruckt wird. Wenn jedoch print-Methoden auf einem erfassten Wert ohne Synchronisationen aufgerufen werden, kann es bei der Ausgabe des faulen Strings zu Problemen kommen. Darüber hinaus können die print-Methoden auf den erfassten Werten mehrmals aufgerufen werden, obwohl nur genau ein Ergebnis zurückgegeben wird.

lazy"str"

Erstellen Sie einen LazyString mit der regulären String-Interpolation-Syntax. Beachten Sie, dass Interpolationen zum Zeitpunkt der Konstruktion von LazyString ausgewertet werden, aber das Drucken bis zum ersten Zugriff auf den String verzögert wird.

Siehe die LazyString Dokumentation für die Sicherheitsmerkmale für nebenläufige Programme.

Beispiele

julia> n = 5; str = lazy"n ist $n"
"n ist 5"

julia> typeof(str)
LazyString

transcode(T, src)

Konvertieren Sie Zeichendaten zwischen Unicode-Codierungen. src ist entweder ein String oder ein Vector{UIntXX} von UTF-XX-Codeeinheiten, wobei XX 8, 16 oder 32 ist. T gibt die Codierung des Rückgabewerts an: String, um einen (UTF-8-codierten) String zurückzugeben, oder UIntXX, um einen Vector{UIntXX} von UTF-XX-Daten zurückzugeben. (Das Alias Cwchar_t kann ebenfalls als Ganzzahltyp verwendet werden, um wchar_t*-Strings zu konvertieren, die von externen C-Bibliotheken verwendet werden.)

Die Funktion transcode ist erfolgreich, solange die Eingabedaten vernünftig in der Zielcodierung dargestellt werden können; sie ist immer erfolgreich für Konvertierungen zwischen UTF-XX-Codierungen, selbst für ungültige Unicode-Daten.

Derzeit wird nur die Konvertierung zu/von UTF-8 unterstützt.

Beispiele

julia> str = "αβγ"
"αβγ"

julia> transcode(UInt16, str)
3-element Vector{UInt16}:
 0x03b1
 0x03b2
 0x03b3

julia> transcode(String, transcode(UInt16, str))
"αβγ"

unsafe_string(p::Ptr{UInt8}, [length::Integer])

Kopiere einen String von der Adresse eines C-Stil (NUL-terminierten) Strings, der als UTF-8 kodiert ist. (Der Zeiger kann danach sicher freigegeben werden.) Wenn length angegeben ist (die Länge der Daten in Bytes), muss der String nicht NUL-terminiert sein.

Diese Funktion ist als "unsicher" gekennzeichnet, da sie abstürzt, wenn p keine gültige Speicheradresse für Daten der angeforderten Länge ist.

ncodeunits(s::AbstractString) -> Int

Gibt die Anzahl der Codeeinheiten in einem String zurück. Indizes, die im Bereich liegen, um auf diesen String zuzugreifen, müssen 1 ≤ i ≤ ncodeunits(s) erfüllen. Nicht alle solchen Indizes sind gültig – sie können nicht der Anfang eines Zeichens sein, aber sie geben einen Codeeinheitswert zurück, wenn codeunit(s,i) aufgerufen wird.

Beispiele

julia> ncodeunits("The Julia Language")
18

julia> ncodeunits("∫eˣ")
6

julia> ncodeunits('∫'), ncodeunits('e'), ncodeunits('ˣ')
(3, 1, 2)

Siehe auch codeunit, checkbounds, sizeof, length, lastindex.

codeunit(s::AbstractString) -> Type{<:Union{UInt8, UInt16, UInt32}}

Gibt den Codeeinheitstyp des angegebenen Zeichenfolgenobjekts zurück. Für ASCII-, Latin-1- oder UTF-8-codierte Zeichenfolgen wäre dies UInt8; für UCS-2 und UTF-16 wäre es UInt16; für UTF-32 wäre es UInt32. Der Codeeinheitstyp muss nicht auf diese drei Typen beschränkt sein, aber es ist schwer, weit verbreitete Zeichenkodierungen zu finden, die nicht eine dieser Einheiten verwenden. codeunit(s) ist dasselbe wie typeof(codeunit(s,1)), wenn s eine nicht leere Zeichenfolge ist.

Siehe auch ncodeunits.

codeunit(s::AbstractString, i::Integer) -> Union{UInt8, UInt16, UInt32}

Gibt den Codeeinheitswert im String s am Index i zurück. Beachten Sie, dass

codeunit(s, i) :: codeunit(s)

Das heißt, der Wert, der von codeunit(s, i) zurückgegeben wird, ist vom Typ, der von codeunit(s) zurückgegeben wird.

Beispiele

julia> a = codeunit("Hello", 2)
0x65

julia> typeof(a)
UInt8

Siehe auch ncodeunits, checkbounds.

codeunits(s::AbstractString)

Erhalten Sie ein vektorähnliches Objekt, das die Codeeinheiten eines Strings enthält. Gibt standardmäßig einen CodeUnits-Wrapper zurück, aber codeunits kann optional für neue String-Typen definiert werden, wenn dies erforderlich ist.

Beispiele

julia> codeunits("Juλia")
6-element Base.CodeUnits{UInt8, String}:
 0x4a
 0x75
 0xce
 0xbb
 0x69
 0x61

ascii(s::AbstractString)

Konvertiere einen String in den Typ String und überprüfe, ob er nur ASCII-Daten enthält, andernfalls wird ein ArgumentError ausgelöst, der die Position des ersten nicht-ASCII-Bytes angibt.

Siehe auch das isascii Prädikat, um nicht-ASCII-Zeichen zu filtern oder zu ersetzen.

Beispiele

julia> ascii("abcdeγfgh")
ERROR: ArgumentError: invalid ASCII at index 6 in "abcdeγfgh"
Stacktrace:
[...]

julia> ascii("abcdefgh")
"abcdefgh"

Regex(pattern[, flags]) <: AbstractPattern

Ein Typ, der einen regulären Ausdruck darstellt. Regex-Objekte können verwendet werden, um Zeichenfolgen mit match zu vergleichen.

Regex-Objekte können mit dem @r_str String-Makro erstellt werden. Der Konstruktor Regex(pattern[, flags]) wird normalerweise verwendet, wenn der pattern-String interpoliert werden muss. Siehe die Dokumentation des String-Makros für Details zu den Flags.

@r_str -> Regex

Konstruiere einen Regex, wie r"^[a-z]*$", ohne Interpolation und Unescaping (außer für das Anführungszeichen " welches weiterhin escaped werden muss). Der Regex akzeptiert auch ein oder mehrere Flags, die nach dem abschließenden Anführungszeichen aufgeführt sind, um sein Verhalten zu ändern:

• i aktiviert die Groß-/Kleinschreibung ignorierende Übereinstimmung
• m behandelt die Tokens ^ und $ als Übereinstimmung mit dem Anfang und Ende einzelner Zeilen, anstatt mit dem gesamten String.
• s erlaubt es dem . Modifikator, Zeilenumbrüche zu matchen.
• x aktiviert den "freien Modus": Whitespace zwischen Regex-Tokens wird ignoriert, es sei denn, er ist mit \ escaped, und # im Regex wird als Beginn eines Kommentars behandelt (der bis zum Zeilenende ignoriert wird).
• a aktiviert den ASCII-Modus (deaktiviert UTF und UCP Modi). Standardmäßig matchen \B, \b, \D, \d, \S, \s, \W, \w usw. basierend auf Unicode-Zeicheneigenschaften. Mit dieser Option matchen diese Sequenzen nur ASCII-Zeichen. Dies schließt \u ein, das den angegebenen Zeichenwert direkt als ein einzelnes Byte ausgibt und nicht versucht, es in UTF-8 zu kodieren. Wichtig ist, dass diese Option das Matching gegen ungültige UTF-8-Strings ermöglicht, indem sowohl Matcher als auch Ziel als einfache Bytes behandelt werden (als wären sie ISO/IEC 8859-1 / Latin-1 Bytes) anstatt als Zeichencodierungen. In diesem Fall wird diese Option oft mit s kombiniert. Diese Option kann weiter verfeinert werden, indem das Muster mit (UCP) oder (UTF) beginnt.

Siehe Regex, wenn Interpolation benötigt wird.

Beispiele

julia> match(r"a+.*b+.*?d$"ism, "Goodbye,\nOh, angry,\nBad world\n")
RegexMatch("angry,\nBad world")

Dieser Regex hat die ersten drei Flags aktiviert.

SubstitutionString(substr) <: AbstractString

Speichert den gegebenen String substr als SubstitutionString, zur Verwendung in regulären Ausdrucksersetzungen. Am häufigsten wird es mit dem @s_str Makro erstellt.

Beispiele

julia> SubstitutionString("Hello \\g<name>, it's \\1")
s"Hello \g<name>, it's \1"

julia> subst = s"Hello \g<name>, it's \1"
s"Hello \g<name>, it's \1"

julia> typeof(subst)
SubstitutionString{String}

@s_str -> SubstitutionString

Konstruiere eine Substitutionszeichenkette, die für reguläre Ausdrucksersetzungen verwendet wird. Innerhalb der Zeichenkette beziehen sich Sequenzen der Form \N auf die N-te Erfassungsgruppe im regulären Ausdruck, und \g<groupname> bezieht sich auf eine benannte Erfassungsgruppe mit dem Namen groupname.

Beispiele

julia> msg = "#Hello# from Julia";

julia> replace(msg, r"#(.+)# from (?<from>\w+)" => s"FROM: \g<from>; MESSAGE: \1")
"FROM: Julia; MESSAGE: Hello"

@raw_str -> String

Erstellen Sie einen Rohstring ohne Interpolation und Unescaping. Die Ausnahme ist, dass Anführungszeichen weiterhin escaped werden müssen. Rückwärtsschslashes escapen sowohl Anführungszeichen als auch andere Rückwärtsschslashes, jedoch nur, wenn eine Folge von Rückwärtsschslashes einem Anführungszeichen vorausgeht. Somit kodiert 2n Rückwärtsschslashes, gefolgt von einem Anführungszeichen, n Rückwärtsschslashes und das Ende des Literals, während 2n+1 Rückwärtsschslashes, gefolgt von einem Anführungszeichen, n Rückwärtsschslashes, gefolgt von einem Anführungszeichen, kodiert.

Beispiele

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

julia> println(raw"\"")
"

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

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

@b_str

Erstellen Sie einen unveränderlichen Byte (UInt8) Vektor mit String-Syntax.

Beispiele

julia> v = b"12\x01\x02"
4-element Base.CodeUnits{UInt8, String}:
 0x31
 0x32
 0x01
 0x02

julia> v[2]
0x32

@html_str -> Docs.HTML

Erstellen Sie ein HTML-Objekt aus einem Literalstring.

Beispiele

julia> html"Julia"
HTML{String}("Julia")

@text_str -> Docs.Text

Erstellen Sie ein Text-Objekt aus einem Literalstring.

Beispiele

julia> text"Julia"
Julia

isvalid(value) -> Bool

Gibt true zurück, wenn der angegebene Wert für seinen Typ gültig ist, der derzeit entweder AbstractChar oder String oder SubString{String} sein kann.

Beispiele

julia> isvalid(Char(0xd800))
false

julia> isvalid(SubString(String(UInt8[0xfe,0x80,0x80,0x80,0x80,0x80]),1,2))
false

julia> isvalid(Char(0xd799))
true

isvalid(T, value) -> Bool

Gibt true zurück, wenn der angegebene Wert für diesen Typ gültig ist. Typen können derzeit entweder AbstractChar oder String sein. Werte für AbstractChar können vom Typ AbstractChar oder UInt32 sein. Werte für String können von diesem Typ, SubString{String}, Vector{UInt8} oder einem zusammenhängenden Teilarray davon sein.

Beispiele

julia> isvalid(Char, 0xd800)
false

julia> isvalid(String, SubString("thisisvalid",1,5))
true

julia> isvalid(Char, 0xd799)
true

isvalid(s::AbstractString, i::Integer) -> Bool

Prädikat, das angibt, ob der gegebene Index der Beginn der Kodierung eines Zeichens in s ist oder nicht. Wenn isvalid(s, i) wahr ist, dann gibt s[i] das Zeichen zurück, dessen Kodierung an diesem Index beginnt; wenn es falsch ist, wird s[i] einen ungültigen Indexfehler oder einen Bereichsfehler auslösen, abhängig davon, ob i im Bereich liegt. Damit isvalid(s, i) eine O(1)-Funktion sein kann, muss die Kodierung von s selbstsynchronisierend sein. Dies ist eine grundlegende Annahme der generischen Zeichenfolgenunterstützung von Julia.

Siehe auch getindex, iterate, thisind, nextind, prevind, length.

Beispiele

julia> str = "αβγdef";

julia> isvalid(str, 1)
true

julia> str[1]
'α': Unicode U+03B1 (Kategorie Ll: Buchstabe, Kleinbuchstabe)

julia> isvalid(str, 2)
false

julia> str[2]
ERROR: StringIndexError: ungültiger Index [2], gültige benachbarte Indizes [1]=>'α', [3]=>'β'
Stacktrace:
[...]

match(r::Regex, s::AbstractString[, idx::Integer[, addopts]])

Sucht nach dem ersten Treffer des regulären Ausdrucks r in s und gibt ein RegexMatch Objekt zurück, das den Treffer enthält, oder nichts, wenn der Treffer fehlgeschlagen ist. Der übereinstimmende Teilstring kann durch den Zugriff auf m.match abgerufen werden, und die erfassten Sequenzen können durch den Zugriff auf m.captures abgerufen werden. Das optionale Argument idx gibt einen Index an, an dem die Suche beginnen soll.

Beispiele

julia> rx = r"a(.)a"
r"a(.)a"

julia> m = match(rx, "cabac")
RegexMatch("aba", 1="b")

julia> m.captures
1-element Vector{Union{Nothing, SubString{String}}}:
 "b"

julia> m.match
"aba"

julia> match(rx, "cabac", 3) === nothing
true

eachmatch(r::Regex, s::AbstractString; overlap::Bool=false)

Sucht nach allen Übereinstimmungen des regulären Ausdrucks r in s und gibt einen Iterator über die Übereinstimmungen zurück. Wenn overlap true ist, dürfen die übereinstimmenden Sequenzen sich in den Indizes des ursprünglichen Strings überlappen, andernfalls müssen sie aus unterschiedlichen Zeichenbereichen stammen.

Beispiele

julia> rx = r"a.a"
r"a.a"

julia> m = eachmatch(rx, "a1a2a3a")
Base.RegexMatchIterator{String}(r"a.a", "a1a2a3a", false)

julia> collect(m)
2-element Vector{RegexMatch}:
 RegexMatch("a1a")
 RegexMatch("a3a")

julia> collect(eachmatch(rx, "a1a2a3a", overlap = true))
3-element Vector{RegexMatch}:
 RegexMatch("a1a")
 RegexMatch("a2a")
 RegexMatch("a3a")

RegexMatch <: AbstractMatch

Ein Typ, der ein einzelnes Match zu einem Regex darstellt, das in einem String gefunden wurde. Typischerweise erstellt aus der match Funktion.

Das Feld match speichert den Teilstring des gesamten übereinstimmenden Strings. Das Feld captures speichert die Teilstrings für jede Capture-Gruppe, indiziert nach Nummer. Um nach dem Namen der Capture-Gruppe zu indizieren, sollte stattdessen das gesamte Match-Objekt indiziert werden, wie in den Beispielen gezeigt. Der Standort des Beginns des Matches wird im Feld offset gespeichert. Das Feld offsets speichert die Standorte des Beginns jeder Capture-Gruppe, wobei 0 eine Gruppe bezeichnet, die nicht erfasst wurde.

Dieser Typ kann als Iterator über die Capture-Gruppen des Regex verwendet werden, der die in jeder Gruppe erfassten Teilstrings liefert. Aufgrund dessen können die Erfassungen eines Matches destrukturiert werden. Wenn eine Gruppe nicht erfasst wurde, wird stattdessen nothing anstelle eines Teilstrings zurückgegeben.

Methoden, die ein RegexMatch-Objekt akzeptieren, sind definiert für iterate, length, eltype, keys, haskey, und getindex, wobei die Schlüssel die Namen oder Nummern einer Capture-Gruppe sind. Siehe keys für weitere Informationen.

Beispiele

julia> m = match(r"(?<hour>\d+):(?<minute>\d+)(am|pm)?", "11:30 in the morning")
RegexMatch("11:30", hour="11", minute="30", 3=nothing)

julia> m.match
"11:30"

julia> m.captures
3-element Vector{Union{Nothing, SubString{String}}}:
 "11"
 "30"
 nothing


julia> m["minute"]
"30"

julia> hr, min, ampm = m; # destrukturiere Capture-Gruppen durch Iteration

julia> hr
"11"

keys(m::RegexMatch) -> Vector

Gibt einen Vektor von Schlüsseln für alle Erfassungsgruppen des zugrunde liegenden regulären Ausdrucks zurück. Ein Schlüssel ist enthalten, auch wenn die Erfassungsgruppe nicht übereinstimmt. Das heißt, idx wird im Rückgabewert enthalten sein, auch wenn m[idx] == nothing.

Unbenannte Erfassungsgruppen haben ganzzahlige Schlüssel, die ihrem Index entsprechen. Benannte Erfassungsgruppen haben Zeichenfolgen-Schlüssel.

Beispiele

julia> keys(match(r"(?<hour>\d+):(?<minute>\d+)(am|pm)?", "11:30"))
3-element Vector{Any}:
  "hour"
  "minute"
 3

isless(a::AbstractString, b::AbstractString) -> Bool

Überprüfen, ob der String a im alphabetischen Vergleich (technisch gesehen, im lexikografischen Vergleich nach Unicode-Codepunkten) vor dem String b kommt.

Beispiele

julia> isless("a", "b")
true

julia> isless("β", "α")
false

julia> isless("a", "a")
false

==(a::AbstractString, b::AbstractString) -> Bool

Überprüfen, ob zwei Strings zeichenweise (technisch gesehen, Unicode-Codepunkt für Codepunkt) gleich sind. Sollten einer der Strings ein AnnotatedString sein, müssen auch die String-Eigenschaften übereinstimmen.

Beispiele

julia> "abc" == "abc"
true

julia> "abc" == "αβγ"
false

cmp(a::AbstractString, b::AbstractString) -> Int

Vergleiche zwei Strings. Gib 0 zurück, wenn beide Strings die gleiche Länge haben und das Zeichen an jedem Index in beiden Strings gleich ist. Gib -1 zurück, wenn a ein Präfix von b ist oder wenn a alphabetisch vor b kommt. Gib 1 zurück, wenn b ein Präfix von a ist oder wenn b alphabetisch vor a kommt (technisch gesehen, lexikografische Reihenfolge nach Unicode-Codepunkten).

Beispiele

julia> cmp("abc", "abc")
0

julia> cmp("ab", "abc")
-1

julia> cmp("abc", "ab")
1

julia> cmp("ab", "ac")
-1

julia> cmp("ac", "ab")
1

julia> cmp("α", "a")
1

julia> cmp("b", "β")
-1

lpad(s, n::Integer, p::Union{AbstractChar,AbstractString}=' ') -> String

Stringify s und fügen Sie den resultierenden String links mit p auf, um ihn n Zeichen lang (in textwidth) zu machen. Wenn s bereits n Zeichen lang ist, wird ein gleichwertiger String zurückgegeben. Standardmäßig mit Leerzeichen auffüllen.

Beispiele

julia> lpad("März", 10)
"     März"

rpad(s, n::Integer, p::Union{AbstractChar,AbstractString}=' ') -> String

Stringify s und fügen Sie den resultierenden String rechts mit p auf, um ihn n Zeichen (in textwidth) lang zu machen. Wenn s bereits n Zeichen lang ist, wird ein gleichwertiger String zurückgegeben. Standardmäßig mit Leerzeichen auffüllen.

Beispiele

julia> rpad("März", 20)
"März               "

findfirst(pattern::AbstractString, string::AbstractString)
findfirst(pattern::AbstractPattern, string::String)

Finde das erste Vorkommen von pattern in string. Entspricht findnext(pattern, string, firstindex(s)).

Beispiele

julia> findfirst("z", "Hello to the world") # gibt nichts zurück, wird aber nicht im REPL angezeigt

julia> findfirst("Julia", "JuliaLang")
1:5

findnext(pattern::AbstractString, string::AbstractString, start::Integer)
findnext(pattern::AbstractPattern, string::String, start::Integer)

Finde das nächste Vorkommen von pattern in string, beginnend an der Position start. pattern kann entweder eine Zeichenkette oder ein regulärer Ausdruck sein, in diesem Fall muss string vom Typ String sein.

Der Rückgabewert ist ein Bereich von Indizes, an dem die übereinstimmende Sequenz gefunden wird, so dass s[findnext(x, s, i)] == x:

findnext("substring", string, i) == start:stop, so dass string[start:stop] == "substring" und i <= start, oder nothing, wenn keine Übereinstimmung gefunden wurde.

Beispiele

julia> findnext("z", "Hello to the world", 1) === nothing
true

julia> findnext("o", "Hello to the world", 6)
8:8

julia> findnext("Lang", "JuliaLang", 2)
6:9

findnext(ch::AbstractChar, string::AbstractString, start::Integer)

Finde das nächste Vorkommen des Zeichens ch in string, beginnend an der Position start.

Beispiele

julia> findnext('z', "Hello to the world", 1) === nothing
true

julia> findnext('o', "Hello to the world", 6)
8

findlast(pattern::AbstractString, string::AbstractString)

Finde das letzte Vorkommen von pattern in string. Entspricht findprev(pattern, string, lastindex(string)).

Beispiele

julia> findlast("o", "Hello to the world")
15:15

julia> findfirst("Julia", "JuliaLang")
1:5

findlast(ch::AbstractChar, string::AbstractString)

Finde das letzte Vorkommen des Zeichens ch in string.

Beispiele

julia> findlast('p', "happy")
4

julia> findlast('z', "happy") === nothing
true

findprev(pattern::AbstractString, string::AbstractString, start::Integer)

Finde das vorherige Vorkommen von pattern in string, beginnend an der Position start.

Der Rückgabewert ist ein Bereich von Indizes, an dem die übereinstimmende Sequenz gefunden wird, sodass s[findprev(x, s, i)] == x:

findprev("substring", string, i) == start:stop, sodass string[start:stop] == "substring" und stop <= i, oder nothing, wenn keine Übereinstimmung gefunden wurde.

Beispiele

julia> findprev("z", "Hello to the world", 18) === nothing
true

julia> findprev("o", "Hello to the world", 18)
15:15

julia> findprev("Julia", "JuliaLang", 6)
1:5

occursin(needle::Union{AbstractString,AbstractPattern,AbstractChar}, haystack::AbstractString)

Bestimmen Sie, ob das erste Argument ein Teilstring des zweiten ist. Wenn needle ein regulärer Ausdruck ist, wird überprüft, ob haystack ein Treffer enthält.

Beispiele

julia> occursin("Julia", "JuliaLang ist ziemlich cool!")
true

julia> occursin('a', "JuliaLang ist ziemlich cool!")
true

julia> occursin(r"a.a", "aba")
true

julia> occursin(r"a.a", "abba")
false

Siehe auch contains.

occursin(haystack)

Erstellen Sie eine Funktion, die überprüft, ob ihr Argument in haystack vorkommt, d.h. eine Funktion, die äquivalent zu needle -> occursin(needle, haystack) ist.

Die zurückgegebene Funktion hat den Typ Base.Fix2{typeof(occursin)}.

Beispiele

julia> search_f = occursin("JuliaLang ist eine Programmiersprache");

julia> search_f("JuliaLang")
true

julia> search_f("Python")
false

reverse(s::AbstractString) -> AbstractString

Kehrt einen String um. Technisch gesehen kehrt diese Funktion die Codepunkte in einem String um und ihre Hauptnützlichkeit liegt in der Verarbeitung von Strings in umgekehrter Reihenfolge, insbesondere bei umgekehrten regulären Ausdruckssuchen. Siehe auch reverseind, um Indizes in s in Indizes in reverse(s) und umgekehrt zu konvertieren, sowie graphemes aus dem Modul Unicode, um auf benutzerlich sichtbare "Zeichen" (Grapheme) anstelle von Codepunkten zu operieren. Siehe auch Iterators.reverse für die Iteration in umgekehrter Reihenfolge, ohne eine Kopie zu erstellen. Benutzerdefinierte String-Typen müssen die Funktion reverse selbst implementieren und sollten typischerweise einen String mit demselben Typ und derselben Kodierung zurückgeben. Wenn sie einen String mit einer anderen Kodierung zurückgeben, müssen sie auch reverseind für diesen String-Typ überschreiben, um s[reverseind(s,i)] == reverse(s)[i] zu erfüllen.

Beispiele

julia> reverse("JuliaLang")
"gnaLailuJ"

!!! Hinweis Die folgenden Beispiele können auf verschiedenen Systemen unterschiedlich gerendert werden. Die Kommentare geben an, wie sie gerendert werden sollen.

Kombinierende Zeichen können zu überraschenden Ergebnissen führen:

julia> reverse("ax̂e") # Der Hut ist über x im Eingabewert, über e im Ausgabewert
"êxa"

julia> using Unicode

julia> join(reverse(collect(graphemes("ax̂e")))) # kehrt Grapheme um; der Hut ist über x in beiden Eingabe- und Ausgabewerten
"ex̂a"

replace([io::IO], s::AbstractString, pat=>r, [pat2=>r2, ...]; [count::Integer])

Suchen Sie nach dem angegebenen Muster pat in s und ersetzen Sie jede Vorkommen durch r. Wenn count angegeben ist, ersetzen Sie höchstens count Vorkommen. pat kann ein einzelnes Zeichen, ein Vektor oder eine Menge von Zeichen, eine Zeichenkette oder ein regulärer Ausdruck sein. Wenn r eine Funktion ist, wird jedes Vorkommen durch r(s) ersetzt, wobei s der übereinstimmende Teilstring ist (wenn pat ein AbstractPattern oder AbstractString ist) oder Zeichen (wenn pat ein AbstractChar oder eine Sammlung von AbstractChar ist). Wenn pat ein regulärer Ausdruck ist und r eine SubstitutionString ist, werden die Erfassungsgruppenreferenzen in r durch den entsprechenden übereinstimmenden Text ersetzt. Um Instanzen von pat aus string zu entfernen, setzen Sie r auf die leere String ("").

Der Rückgabewert ist ein neuer String nach den Ersetzungen. Wenn das Argument io::IO bereitgestellt wird, wird der transformierte String stattdessen in io geschrieben (Rückgabe von io). (Zum Beispiel kann dies in Verbindung mit einem IOBuffer verwendet werden, um ein vorab zugewiesenes Pufferarray vor Ort wiederzuverwenden.)

Mehrere Muster können angegeben werden, und sie werden gleichzeitig von links nach rechts angewendet, sodass nur ein Muster auf ein beliebiges Zeichen angewendet wird, und die Muster werden nur auf den Eingabetext und nicht auf die Ersetzungen angewendet.

Beispiele

julia> replace("Python is a programming language.", "Python" => "Julia")
"Julia is a programming language."

julia> replace("The quick foxes run quickly.", "quick" => "slow", count=1)
"The slow foxes run quickly."

julia> replace("The quick foxes run quickly.", "quick" => "", count=1)
"The  foxes run quickly."

julia> replace("The quick foxes run quickly.", r"fox(es)?" => s"bus\1")
"The quick buses run quickly."

julia> replace("abcabc", "a" => "b", "b" => "c", r".+" => "a")
"bca"

eachsplit(str::AbstractString, dlm; limit::Integer=0, keepempty::Bool=true)
eachsplit(str::AbstractString; limit::Integer=0, keepempty::Bool=false)

Teile str an den Vorkommen des Trennzeichens dlm und gebe einen Iterator über die Teilstrings zurück. dlm kann eines der Formate sein, die als erstes Argument von findnext erlaubt sind (d.h. als Zeichenkette, regulärer Ausdruck oder Funktion), oder als einzelnes Zeichen oder Sammlung von Zeichen.

Wenn dlm weggelassen wird, wird standardmäßig isspace verwendet.

Die optionalen Schlüsselwortargumente sind:

• limit: die maximale Größe des Ergebnisses. limit=0 bedeutet keine maximale Größe (Standard)
• keepempty: ob leere Felder im Ergebnis beibehalten werden sollen. Standard ist false ohne ein dlm-Argument, true mit einem dlm-Argument.

Siehe auch split.

Beispiele

julia> a = "Ma.rch"
"Ma.rch"

julia> b = eachsplit(a, ".")
Base.SplitIterator{String, String}("Ma.rch", ".", 0, true)

julia> collect(b)
2-element Vector{SubString{String}}:
 "Ma"
 "rch"

eachrsplit(str::AbstractString, dlm; limit::Integer=0, keepempty::Bool=true)
eachrsplit(str::AbstractString; limit::Integer=0, keepempty::Bool=false)

Gibt einen Iterator über SubStrings von str zurück, die beim Splitten an dem Trennzeichen dlm erzeugt werden und in umgekehrter Reihenfolge (von rechts nach links) ausgegeben werden. dlm kann eines der Formate sein, die als erstes Argument von findprev erlaubt sind (d.h. ein String, ein einzelnes Zeichen oder eine Funktion) oder eine Sammlung von Zeichen.

Wenn dlm weggelassen wird, wird standardmäßig isspace verwendet, und keepempty standardmäßig auf false gesetzt.

Die optionalen Schlüsselwortargumente sind:

• Wenn limit > 0, wird der Iterator höchstens limit - 1 Mal splitten, bevor der Rest des Strings ungeteilt zurückgegeben wird. limit < 1 bedeutet keine Begrenzung der Splits (Standard).
• keepempty: ob leere Felder beim Iterieren zurückgegeben werden sollen. Standard ist false ohne ein dlm-Argument, true mit einem dlm-Argument.

Beachten Sie, dass diese Funktion im Gegensatz zu split, rsplit und eachsplit die Teilstrings von rechts nach links iteriert, wie sie im Eingabetext vorkommen.

Siehe auch eachsplit, rsplit.

Beispiele

julia> a = "Ma.r.ch";

julia> collect(eachrsplit(a, ".")) == ["ch", "r", "Ma"]
true

julia> collect(eachrsplit(a, "."; limit=2)) == ["ch", "Ma.r"]
true

split(str::AbstractString, dlm; limit::Integer=0, keepempty::Bool=true)
split(str::AbstractString; limit::Integer=0, keepempty::Bool=false)

Teile str in ein Array von Teilstrings auf, basierend auf Vorkommen des Trennzeichens dlm. dlm kann eines der Formate sein, die als erstes Argument von findnext erlaubt sind (d.h. als String, regulärer Ausdruck oder Funktion), oder als einzelnes Zeichen oder eine Sammlung von Zeichen.

Wenn dlm weggelassen wird, wird standardmäßig isspace verwendet.

Die optionalen Schlüsselwortargumente sind:

• limit: die maximale Größe des Ergebnisses. limit=0 bedeutet keine maximale Größe (Standard)
• keepempty: ob leere Felder im Ergebnis beibehalten werden sollen. Standard ist false ohne ein dlm-Argument, true mit einem dlm-Argument.

Siehe auch rsplit, eachsplit.

Beispiele

julia> a = "Ma.rch"
"Ma.rch"

julia> split(a, ".")
2-element Vector{SubString{String}}:
 "Ma"
 "rch"

rsplit(s::AbstractString; limit::Integer=0, keepempty::Bool=false)
rsplit(s::AbstractString, chars; limit::Integer=0, keepempty::Bool=true)

Ähnlich wie split, aber beginnend vom Ende des Strings.

Beispiele

julia> a = "M.a.r.c.h"
"M.a.r.c.h"

julia> rsplit(a, ".")
5-element Vector{SubString{String}}:
 "M"
 "a"
 "r"
 "c"
 "h"

julia> rsplit(a, "."; limit=1)
1-element Vector{SubString{String}}:
 "M.a.r.c.h"

julia> rsplit(a, "."; limit=2)
2-element Vector{SubString{String}}:
 "M.a.r.c"
 "h"

strip([pred=isspace,] str::AbstractString) -> SubString
strip(str::AbstractString, chars) -> SubString

Entfernt führende und nachfolgende Zeichen aus str, entweder die, die durch chars angegeben sind, oder die, für die die Funktion pred true zurückgibt.

Das Standardverhalten besteht darin, führende und nachfolgende Leerzeichen und Trennzeichen zu entfernen: siehe isspace für genaue Details.

Das optionale Argument chars gibt an, welche Zeichen entfernt werden sollen: es kann ein einzelnes Zeichen, ein Vektor oder eine Menge von Zeichen sein.

Siehe auch lstrip und rstrip.

Beispiele

julia> strip("{3, 5}\n", ['{', '}', '\n'])
"3, 5"

lstrip([pred=isspace,] str::AbstractString) -> SubString
lstrip(str::AbstractString, chars) -> SubString

Entfernt führende Zeichen aus str, entweder die, die durch chars angegeben sind, oder die, für die die Funktion pred true zurückgibt.

Das Standardverhalten besteht darin, führende Leerzeichen und Trennzeichen zu entfernen: siehe isspace für genaue Details.

Das optionale Argument chars gibt an, welche Zeichen entfernt werden sollen: es kann ein einzelnes Zeichen oder ein Vektor oder eine Menge von Zeichen sein.

Siehe auch strip und rstrip.

Beispiele

julia> a = lpad("März", 20)
"               März"

julia> lstrip(a)
"März"

rstrip([pred=isspace,] str::AbstractString) -> SubString
rstrip(str::AbstractString, chars) -> SubString

Entfernt nachfolgende Zeichen von str, entweder die, die durch chars angegeben sind, oder die, für die die Funktion pred true zurückgibt.

Das Standardverhalten besteht darin, nachfolgende Leerzeichen und Trennzeichen zu entfernen: siehe isspace für genaue Details.

Das optionale Argument chars gibt an, welche Zeichen entfernt werden sollen: es kann ein einzelnes Zeichen oder ein Vektor oder eine Menge von Zeichen sein.

Siehe auch strip und lstrip.

Beispiele

julia> a = rpad("März", 20)
"März               "

julia> rstrip(a)
"März"

startswith(s::AbstractString, prefix::Union{AbstractString,Base.Chars})

Gibt true zurück, wenn s mit prefix beginnt, das ein String, ein Zeichen oder ein Tupel/Vektor/Menge von Zeichen sein kann. Wenn prefix ein Tupel/Vektor/Menge von Zeichen ist, wird getestet, ob das erste Zeichen von s zu dieser Menge gehört.

Siehe auch endswith, contains.

Beispiele

julia> startswith("JuliaLang", "Julia")
true

startswith(io::IO, prefix::Union{AbstractString,Base.Chars})

Überprüfen, ob ein IO-Objekt mit einem Präfix beginnt, das entweder eine Zeichenkette, ein Zeichen oder ein Tupel/Vektor/Menge von Zeichen sein kann. Siehe auch peek.

startswith(prefix)

Erstellen Sie eine Funktion, die überprüft, ob ihr Argument mit prefix beginnt, d.h. eine Funktion, die äquivalent zu y -> startswith(y, prefix) ist.

Die zurückgegebene Funktion hat den Typ Base.Fix2{typeof(startswith)}, der verwendet werden kann, um spezialisierte Methoden zu implementieren.

Beispiele

julia> startswith("Julia")("JuliaLang")
true

julia> startswith("Julia")("Ends with Julia")
false

startswith(s::AbstractString, prefix::Regex)

Gibt true zurück, wenn s mit dem Regex-Muster prefix beginnt.

Siehe auch occursin und endswith.

Beispiele

julia> startswith("JuliaLang", r"Julia|Romeo")
true

endswith(s::AbstractString, suffix::Union{AbstractString,Base.Chars})

Gibt true zurück, wenn s mit suffix endet, das ein String, ein Zeichen oder ein Tupel/Vektor/Menge von Zeichen sein kann. Wenn suffix ein Tupel/Vektor/Menge von Zeichen ist, wird getestet, ob das letzte Zeichen von s zu dieser Menge gehört.

Siehe auch startswith, contains.

Beispiele

julia> endswith("Sunday", "day")
true

endswith(suffix)

Erstellen Sie eine Funktion, die überprüft, ob ihr Argument mit suffix endet, d.h. eine Funktion, die äquivalent zu y -> endswith(y, suffix) ist.

Die zurückgegebene Funktion hat den Typ Base.Fix2{typeof(endswith)}, der verwendet werden kann, um spezialisierte Methoden zu implementieren.

Beispiele

julia> endswith("Julia")("Ends with Julia")
true

julia> endswith("Julia")("JuliaLang")
false

endswith(s::AbstractString, suffix::Regex)

Gibt true zurück, wenn s mit dem Regex-Muster suffix endet.

Siehe auch occursin und startswith.

Beispiele

julia> endswith("JuliaLang", r"Lang|Roberts")
true

contains(haystack::AbstractString, needle)

Gibt true zurück, wenn haystack needle enthält. Dies ist dasselbe wie occursin(needle, haystack), wird jedoch zur Konsistenz mit startswith(haystack, needle) und endswith(haystack, needle) bereitgestellt.

Siehe auch occursin, in, issubset.

Beispiele

julia> contains("JuliaLang is pretty cool!", "Julia")
true

julia> contains("JuliaLang is pretty cool!", 'a')
true

julia> contains("aba", r"a.a")
true

julia> contains("abba", r"a.a")
false

contains(needle)

Erstellen Sie eine Funktion, die überprüft, ob ihr Argument needle enthält, d.h. eine Funktion, die äquivalent zu haystack -> contains(haystack, needle) ist.

Die zurückgegebene Funktion hat den Typ Base.Fix2{typeof(contains)}, der verwendet werden kann, um spezialisierte Methoden zu implementieren.

first(s::AbstractString, n::Integer)

Holen Sie sich eine Zeichenkette, die aus den ersten n Zeichen von s besteht.

Beispiele

julia> first("∀ϵ≠0: ϵ²>0", 0)
""

julia> first("∀ϵ≠0: ϵ²>0", 1)
"∀"

julia> first("∀ϵ≠0: ϵ²>0", 3)
"∀ϵ≠"

last(s::AbstractString, n::Integer)

Holen Sie sich eine Zeichenkette, die aus den letzten n Zeichen von s besteht.

Beispiele

julia> last("∀ϵ≠0: ϵ²>0", 0)
""

julia> last("∀ϵ≠0: ϵ²>0", 1)
"0"

julia> last("∀ϵ≠0: ϵ²>0", 3)
"²>0"

uppercase(c::AbstractChar)

Konvertiere c in Großbuchstaben.

Siehe auch lowercase, titlecase.

Beispiele

julia> uppercase('a')
'A': ASCII/Unicode U+0041 (Kategorie Lu: Buchstabe, Großbuchstabe)

julia> uppercase('ê')
'Ê': Unicode U+00CA (Kategorie Lu: Buchstabe, Großbuchstabe)

uppercase(s::AbstractString)

Gibt s mit allen Zeichen in Großbuchstaben zurück.

Siehe auch lowercase, titlecase, uppercasefirst.

Beispiele

julia> uppercase("Julia")
"JULIA"

lowercase(c::AbstractChar)

Konvertiere c in Kleinbuchstaben.

Siehe auch uppercase, titlecase.

Beispiele

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

julia> lowercase('Ö')
'ö': Unicode U+00F6 (Kategorie Ll: Buchstabe, Kleinbuchstabe)

lowercase(s::AbstractString)

Gibt s mit allen Zeichen in Kleinbuchstaben zurück.

Siehe auch uppercase, titlecase, lowercasefirst.

Beispiele

julia> lowercase("STRINGS AND THINGS")
"strings and things"

titlecase(c::AbstractChar)

Konvertiere c in Titelcase. Dies kann sich von Großbuchstaben für Digraphen unterscheiden, vergleiche das Beispiel unten.

Siehe auch uppercase, lowercase.

Beispiele

julia> titlecase('a')
'A': ASCII/Unicode U+0041 (Kategorie Lu: Buchstabe, Großbuchstabe)

julia> titlecase('dž')
'Dž': Unicode U+01C5 (Kategorie Lt: Buchstabe, Titelcase)

julia> uppercase('dž')
'DŽ': Unicode U+01C4 (Kategorie Lu: Buchstabe, Großbuchstabe)

titlecase(s::AbstractString; [wordsep::Function], strict::Bool=true) -> String

Kapitalisiere das erste Zeichen jedes Wortes in s; wenn strict wahr ist, wird jedes andere Zeichen in Kleinbuchstaben umgewandelt, andernfalls bleiben sie unverändert. Standardmäßig werden alle Nicht-Buchstaben, die ein neues Graphem beginnen, als Worttrennzeichen betrachtet; ein Prädikat kann als Schlüsselwort wordsep übergeben werden, um zu bestimmen, welche Zeichen als Worttrennzeichen betrachtet werden sollen. Siehe auch uppercasefirst, um nur das erste Zeichen in s zu kapitalisieren.

Siehe auch uppercase, lowercase, uppercasefirst.

Beispiele

julia> titlecase("the JULIA programming language")
"The Julia Programming Language"

julia> titlecase("ISS - international space station", strict=false)
"ISS - International Space Station"

julia> titlecase("a-a b-b", wordsep = c->c==' ')
"A-a B-b"

uppercasefirst(s::AbstractString) -> String

Gibt s mit dem ersten Zeichen in Großbuchstaben zurück (technisch "Titelcase" für Unicode). Siehe auch titlecase, um das erste Zeichen jedes Wortes in s zu kapitalisieren.

Siehe auch lowercasefirst, uppercase, lowercase, titlecase.

Beispiele

julia> uppercasefirst("python")
"Python"

lowercasefirst(s::AbstractString)

Gibt s zurück, wobei das erste Zeichen in Kleinbuchstaben umgewandelt wird.

Siehe auch uppercasefirst, uppercase, lowercase, titlecase.

Beispiele

julia> lowercasefirst("Julia")
"julia"

join([io::IO,] iterator [, delim [, last]])

Fügen Sie jeden iterator zu einem einzelnen String zusammen, indem Sie den angegebenen Trennzeichen (falls vorhanden) zwischen benachbarten Elementen einfügen. Wenn last angegeben ist, wird es anstelle von delim zwischen den letzten beiden Elementen verwendet. Jedes Element des iterator wird über print(io::IOBuffer, x) in einen String umgewandelt. Wenn io angegeben ist, wird das Ergebnis in io geschrieben, anstatt als String zurückgegeben zu werden.

Beispiele

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

julia> join([1,2,3,4,5])
"12345"

chop(s::AbstractString; head::Integer = 0, tail::Integer = 1)

Entfernt die ersten head und die letzten tail Zeichen von s. Der Aufruf chop(s) entfernt das letzte Zeichen von s. Wenn mehr Zeichen entfernt werden sollen als length(s), wird ein leerer String zurückgegeben.

Siehe auch chomp, startswith, first.

Beispiele

julia> a = "März"
"März"

julia> chop(a)
"Mar"

julia> chop(a, head = 1, tail = 2)
"är"

julia> chop(a, head = 5, tail = 5)
""

chopprefix(s::AbstractString, prefix::Union{AbstractString,Regex}) -> SubString

Entfernt das Präfix prefix von s. Wenn s nicht mit prefix beginnt, wird ein String, der s entspricht, zurückgegeben.

Siehe auch chopsuffix.

Beispiele

julia> chopprefix("Hamburger", "Ham")
"burger"

julia> chopprefix("Hamburger", "hotdog")
"Hamburger"

chopsuffix(s::AbstractString, suffix::Union{AbstractString,Regex}) -> SubString

Entfernt das Suffix suffix von s. Wenn s nicht mit suffix endet, wird ein String, der s entspricht, zurückgegeben.

Siehe auch chopprefix.

Beispiele

julia> chopsuffix("Hamburger", "er")
"Hamburg"

julia> chopsuffix("Hamburger", "hotdog")
"Hamburger"

chomp(s::AbstractString) -> SubString

Entfernt ein einzelnes abschließendes Zeilenumbruchzeichen von einem String.

Siehe auch chop.

Beispiele

julia> chomp("Hello\n")
"Hello"

thisind(s::AbstractString, i::Integer) -> Int

Wenn i innerhalb der Grenzen von s liegt, gibt den Index des Beginns des Zeichens zurück, dessen Kodierungseinheit i Teil davon ist. Mit anderen Worten, wenn i der Beginn eines Zeichens ist, gib i zurück; wenn i nicht der Beginn eines Zeichens ist, spule zurück bis zum Beginn eines Zeichens und gib diesen Index zurück. Wenn i gleich 0 oder ncodeunits(s)+1 ist, gib i zurück. In allen anderen Fällen wirf BoundsError.

Beispiele

julia> thisind("α", 0)
0

julia> thisind("α", 1)
1

julia> thisind("α", 2)
1

julia> thisind("α", 3)
3

julia> thisind("α", 4)
ERROR: BoundsError: attempt to access 2-codeunit String at index [4]
[...]

julia> thisind("α", -1)
ERROR: BoundsError: attempt to access 2-codeunit String at index [-1]
[...]

nextind(str::AbstractString, i::Integer, n::Integer=1) -> Int

• Fall n == 1

  Wenn i im Bereich von s liegt, gibt den Index des Beginns des Zeichens zurück, dessen Kodierung nach dem Index i beginnt. Mit anderen Worten, wenn i der Beginn eines Zeichens ist, gibt den Beginn des nächsten Zeichens zurück; wenn i nicht der Beginn eines Zeichens ist, gehe vorwärts, bis der Beginn eines Zeichens erreicht ist, und gib diesen Index zurück. Wenn i gleich 0 ist, gib 1 zurück. Wenn i im Bereich liegt, aber größer oder gleich lastindex(str) ist, gib ncodeunits(str)+1 zurück. Andernfalls wird BoundsError ausgelöst.

• Fall n > 1

  Verhält sich wie die Anwendung von n-mal nextind für n==1. Der einzige Unterschied ist, dass, wenn n so groß ist, dass die Anwendung von nextind ncodeunits(str)+1 erreichen würde, jede verbleibende Iteration den zurückgegebenen Wert um 1 erhöht. Das bedeutet, dass in diesem Fall nextind einen Wert größer als ncodeunits(str)+1 zurückgeben kann.

• Fall n == 0

  Gib i nur zurück, wenn i ein gültiger Index in s ist oder gleich 0 ist. Andernfalls wird StringIndexError oder BoundsError ausgelöst.

Beispiele

julia> nextind("α", 0)
1

julia> nextind("α", 1)
3

julia> nextind("α", 3)
ERROR: BoundsError: attempt to access 2-codeunit String at index [3]
[...]

julia> nextind("α", 0, 2)
3

julia> nextind("α", 1, 2)
4

prevind(str::AbstractString, i::Integer, n::Integer=1) -> Int

• Fall n == 1

  Wenn i im Bereich von s liegt, gibt den Index des Beginns des Zeichens zurück, dessen Kodierung vor dem Index i beginnt. Mit anderen Worten, wenn i der Beginn eines Zeichens ist, gibt den Beginn des vorherigen Zeichens zurück; wenn i nicht der Beginn eines Zeichens ist, spule bis zum Beginn eines Zeichens zurück und gib diesen Index zurück. Wenn i gleich 1 ist, gib 0 zurück. Wenn i gleich ncodeunits(str)+1 ist, gib lastindex(str) zurück. Andernfalls wird BoundsError ausgelöst.

• Fall n > 1

  Verhält sich wie die Anwendung von n Mal prevind für n==1. Der einzige Unterschied ist, dass, wenn n so groß ist, dass die Anwendung von prevind 0 erreichen würde, jede verbleibende Iteration den zurückgegebenen Wert um 1 verringert. Das bedeutet, dass in diesem Fall prevind einen negativen Wert zurückgeben kann.

• Fall n == 0

  Gib i nur zurück, wenn i ein gültiger Index in str ist oder gleich ncodeunits(str)+1 ist. Andernfalls wird StringIndexError oder BoundsError ausgelöst.

Beispiele

julia> prevind("α", 3)
1

julia> prevind("α", 1)
0

julia> prevind("α", 0)
ERROR: BoundsError: attempt to access 2-codeunit String at index [0]
[...]

julia> prevind("α", 2, 2)
0

julia> prevind("α", 2, 3)
-1

textwidth(c)

Gibt die Anzahl der Spalten an, die benötigt werden, um ein Zeichen zu drucken.

Beispiele

julia> textwidth('α')
1

julia> textwidth('⛵')
2

textwidth(s::AbstractString)

Gibt die Anzahl der benötigten Spalten zurück, um einen String zu drucken.

Beispiele

julia> textwidth("März")
5

isascii(c::Union{AbstractChar,AbstractString}) -> Bool

Überprüfen, ob ein Zeichen zum ASCII-Zeichensatz gehört oder ob dies für alle Elemente eines Strings zutrifft.

Beispiele

julia> isascii('a')
true

julia> isascii('α')
false

julia> isascii("abc")
true

julia> isascii("αβγ")
false

Zum Beispiel kann isascii als Prädikatsfunktion für filter oder replace verwendet werden, um nicht-ASCII-Zeichen zu entfernen oder zu ersetzen:

julia> filter(isascii, "abcdeγfgh") # nicht-ASCII-Zeichen verwerfen
"abcdefgh"

julia> replace("abcdeγfgh", !isascii=>' ') # nicht-ASCII-Zeichen durch Leerzeichen ersetzen
"abcde fgh"

isascii(cu::AbstractVector{CU}) where {CU <: Integer} -> Bool

Überprüfen, ob alle Werte im Vektor zum ASCII-Zeichensatz (0x00 bis 0x7f) gehören. Diese Funktion ist dazu gedacht, von anderen String-Implementierungen verwendet zu werden, die eine schnelle ASCII-Prüfung benötigen.

iscntrl(c::AbstractChar) -> Bool

Überprüft, ob ein Zeichen ein Steuerzeichen ist. Steuerzeichen sind die nicht druckbaren Zeichen des Latin-1-Teils von Unicode.

Beispiele

julia> iscntrl('\x01')
true

julia> iscntrl('a')
false

isdigit(c::AbstractChar) -> Bool

Überprüft, ob ein Zeichen eine Dezimalziffer (0-9) ist.

Siehe auch: isletter.

Beispiele

julia> isdigit('❤')
false

julia> isdigit('9')
true

julia> isdigit('α')
false

isletter(c::AbstractChar) -> Bool

Überprüfen, ob ein Zeichen ein Buchstabe ist. Ein Zeichen wird als Buchstabe klassifiziert, wenn es zur Unicode-Allgemeinkategorie Buchstabe gehört, d.h. ein Zeichen, dessen Kategorienummer mit 'L' beginnt.

Siehe auch: isdigit.

Beispiele

julia> isletter('❤')
false

julia> isletter('α')
true

julia> isletter('9')
false

islowercase(c::AbstractChar) -> Bool

Überprüft, ob ein Zeichen ein Kleinbuchstabe ist (gemäß der abgeleiteten Eigenschaft Lowercase des Unicode-Standards).

Siehe auch isuppercase.

Beispiele

julia> islowercase('α')
true

julia> islowercase('Γ')
false

julia> islowercase('❤')
false

isnumeric(c::AbstractChar) -> Bool

Überprüft, ob ein Zeichen numerisch ist. Ein Zeichen wird als numerisch klassifiziert, wenn es zur Unicode-Allgemeinkategorie Zahl gehört, d.h. ein Zeichen, dessen Kategorienummer mit 'N' beginnt.

Beachten Sie, dass diese breite Kategorie Zeichen wie ¾ und ௰ umfasst. Verwenden Sie isdigit, um zu überprüfen, ob ein Zeichen eine Dezimalziffer zwischen 0 und 9 ist.

Beispiele

julia> isnumeric('௰')
true

julia> isnumeric('9')
true

julia> isnumeric('α')
false

julia> isnumeric('❤')
false

isprint(c::AbstractChar) -> Bool

Überprüft, ob ein Zeichen druckbar ist, einschließlich Leerzeichen, jedoch nicht ein Steuerzeichen.

Beispiele

julia> isprint('\x01')
false

julia> isprint('A')
true

ispunct(c::AbstractChar) -> Bool

Überprüft, ob ein Zeichen zur Unicode-Allgemeinkategorie Interpunktion gehört, d.h. ein Zeichen, dessen Kategoriencode mit 'P' beginnt.

Beispiele

julia> ispunct('α')
false

julia> ispunct('/')
true

julia> ispunct(';')
true

isspace(c::AbstractChar) -> Bool

Überprüft, ob ein Zeichen ein beliebiges Leerzeichen ist. Beinhaltet ASCII-Zeichen '\t', '\n', '\v', '\f', '\r' und ' ', das Latin-1-Zeichen U+0085 sowie Zeichen in der Unicode-Kategorie Zs.

Beispiele

julia> isspace('\n')
true

julia> isspace('\r')
true

julia> isspace(' ')
true

julia> isspace('\x20')
true

isuppercase(c::AbstractChar) -> Bool

Überprüft, ob ein Zeichen ein Großbuchstabe ist (gemäß der abgeleiteten Eigenschaft Uppercase des Unicode-Standards).

Siehe auch islowercase.

Beispiele

julia> isuppercase('γ')
false

julia> isuppercase('Γ')
true

julia> isuppercase('❤')
false

isxdigit(c::AbstractChar) -> Bool

Überprüfen, ob ein Zeichen eine gültige hexadezimale Ziffer ist. Beachten Sie, dass x (wie im Standardpräfix 0x) nicht eingeschlossen ist.

Beispiele

julia> isxdigit('a')
true

julia> isxdigit('x')
false

escape_string(str::AbstractString[, esc]; keep = ())::AbstractString
escape_string(io, str::AbstractString[, esc]; keep = ())::Nothing

Allgemeines Escaping von traditionellen C- und Unicode-Escape-Sequenzen. Die erste Form gibt den escaped String zurück, die zweite gibt das Ergebnis an io aus.

Backslashes (\) werden mit einem doppelten Backslash ("\\") escaped. Nicht druckbare Zeichen werden entweder mit ihren standardmäßigen C-Escape-Codes escaped, "\0" für NUL (wenn eindeutig), Unicode-Codepunkt ("\u"-Präfix) oder hex ("\x"-Präfix).

Das optionale Argument esc gibt an, welche zusätzlichen Zeichen ebenfalls mit einem vorangestellten Backslash escaped werden sollen (" wird auch standardmäßig in der ersten Form escaped).

Das Argument keep gibt eine Sammlung von Zeichen an, die so belassen werden sollen, wie sie sind. Beachten Sie, dass esc hier Vorrang hat.

Siehe auch unescape_string für die umgekehrte Operation.

Beispiele

julia> escape_string("aaa\nbbb")
"aaa\\nbbb"

julia> escape_string("aaa\nbbb"; keep = '\n')
"aaa\nbbb"

julia> escape_string("\xfe\xff") # ungültiges utf-8
"\\xfe\\xff"

julia> escape_string(string('\u2135','\0')) # eindeutig
"ℵ\\0"

julia> escape_string(string('\u2135','\0','0')) # \0 wäre mehrdeutig
"ℵ\\x000"

escape_raw_string(s::AbstractString, delim='"') -> AbstractString
escape_raw_string(io, s::AbstractString, delim='"')

Ent escape a string auf die Weise, die für das Parsen von rohen String-Literalen verwendet wird. Für jedes doppelte Anführungszeichen (") im Eingabestring s (oder delim, falls angegeben) zählt diese Funktion die Anzahl n der vorhergehenden Rückwärtsschläge (\) und erhöht dann die Anzahl der Rückwärtsschläge von n auf 2n+1 (auch für n = 0). Sie verdoppelt auch eine Folge von Rückwärtsschlägen am Ende des Strings.

Diese Escape-Konvention wird in rohen Strings und anderen nicht standardmäßigen String-Literalen verwendet. (Es ist auch die Escape-Konvention, die vom Microsoft C/C++ Compiler-Laufzeitumgebung erwartet wird, wenn sie einen Befehlszeilenstring in das argv[]-Array parst.)

Siehe auch escape_string.

unescape_string(str::AbstractString, keep = ())::AbstractString
unescape_string(io, s::AbstractString, keep = ())::Nothing

Allgemeines Unescaping von traditionellen C- und Unicode-Escape-Sequenzen. Die erste Form gibt den entkommenen String zurück, die zweite gibt das Ergebnis an io aus. Das Argument keep gibt eine Sammlung von Zeichen an, die (neben Rückwärtsschrägstrichen) so belassen werden sollen, wie sie sind.

Die folgenden Escape-Sequenzen werden erkannt:

• Entkommener Rückwärtsschrägstrich (\\)
• Entkommener Doppelanführungszeichen (\")
• Standard C-Escape-Sequenzen (\a, \b, \t, \n, \v, \f, \r, \e)
• Unicode BMP-Codepunkte (\u mit 1-4 nachfolgenden hexadezimalen Ziffern)
• Alle Unicode-Codepunkte (\U mit 1-8 nachfolgenden hexadezimalen Ziffern; max Wert = 0010ffff)
• Hexadezimale Bytes (\x mit 1-2 nachfolgenden hexadezimalen Ziffern)
• Oktale Bytes (\ mit 1-3 nachfolgenden oktalen Ziffern)

Siehe auch escape_string.

Beispiele

julia> unescape_string("aaa\\nbbb") # C-Escape-Sequenz
"aaa\nbbb"

julia> unescape_string("\\u03c0") # unicode
"π"

julia> unescape_string("\\101") # oktal
"A"

julia> unescape_string("aaa \\g \\n", ['g']) # Verwendung des `keep`-Arguments
"aaa \\g \n"

AnnotatedString{S <: AbstractString} <: AbstractString

Ein String mit Metadaten, in Form von annotierten Regionen.

Genauer gesagt, ist dies ein einfacher Wrapper um jeden anderen AbstractString, der es ermöglicht, Regionen des umschlossenen Strings mit beschrifteten Werten zu annotieren.

                           C
                    ┌──────┸─────────┐
  "this is an example annotated string"
  └──┰────────┼─────┘         │
     A        └─────┰─────────┘
                    B

Das obige Diagramm stellt ein AnnotatedString dar, bei dem drei Bereiche annotiert wurden (beschriftet mit A, B und C). Jede Annotation enthält ein Label (Symbol) und einen Wert (Any). Diese drei Informationen werden als @NamedTuple{region::UnitRange{Int64}, label::Symbol, value} gehalten.

Labels müssen nicht einzigartig sein, dieselbe Region kann mehrere Annotationen mit demselben Label enthalten.

Code, der für AnnotatedStrings im Allgemeinen geschrieben wird, sollte die folgenden Eigenschaften bewahren:

• Auf welche Zeichen eine Annotation angewendet wird
• Die Reihenfolge, in der Annotationen auf jedes Zeichen angewendet werden

Zusätzliche Semantiken können durch spezifische Verwendungen von AnnotatedStrings eingeführt werden.

Eine Folgerung dieser Regeln ist, dass benachbarte, nacheinander platzierte Annotationen mit identischen Labels und Werten äquivalent zu einer einzelnen Annotation sind, die den kombinierten Bereich umfasst.

Siehe auch AnnotatedChar, annotatedstring, annotations und annotate!.

Konstruktoren

AnnotatedString(s::S<:AbstractString) -> AnnotatedString{S}
AnnotatedString(s::S<:AbstractString, annotations::Vector{@NamedTuple{region::UnitRange{Int64}, label::Symbol, value}})

Ein AnnotatedString kann auch mit annotatedstring erstellt werden, das ähnlich wie string funktioniert, aber alle in den Argumenten vorhandenen Annotationen beibehält.

Beispiele

julia> AnnotatedString("this is an example annotated string",
                    [(1:18, :A => 1), (12:28, :B => 2), (18:35, :C => 3)])
"this is an example annotated string"

AnnotatedChar{S <: AbstractChar} <: AbstractChar

Ein Char mit Anmerkungen.

Genauer gesagt, ist dies ein einfacher Wrapper um jeden anderen AbstractChar, der eine Liste von beliebigen beschrifteten Anmerkungen (@NamedTuple{label::Symbol, value}) mit dem umschlossenen Zeichen hält.

Siehe auch: AnnotatedString, annotatedstring, annotations und annotate!.

Konstruktoren

AnnotatedChar(s::S) -> AnnotatedChar{S}
AnnotatedChar(s::S, annotations::Vector{@NamedTuple{label::Symbol, value}})

Beispiele

julia> AnnotatedChar('j', :label => 1)
'j': ASCII/Unicode U+006A (Kategorie Ll: Buchstabe, Kleinbuchstabe)

annotatedstring(values...)

Erstellt eine AnnotatedString aus beliebig vielen values unter Verwendung ihrer printed Darstellung.

Dies funktioniert wie string, sorgt jedoch dafür, dass alle vorhandenen Anmerkungen (in Form von AnnotatedString oder AnnotatedChar Werten) erhalten bleiben.

Siehe auch AnnotatedString und AnnotatedChar.

Beispiele

julia> annotatedstring("now a AnnotatedString")
"now a AnnotatedString"

julia> annotatedstring(AnnotatedString("annotated", [(1:9, :label => 1)]), ", and unannotated")
"annotated, and unannotated"

annotations(str::Union{AnnotatedString, SubString{AnnotatedString}},
            [position::Union{Integer, UnitRange}]) ->
    Vector{@NamedTuple{region::UnitRange{Int64}, label::Symbol, value}}

Erhalten Sie alle Annotationen, die auf `str` zutreffen. Sollte `position` angegeben werden, werden nur Annotationen zurückgegeben, die sich mit `position` überschneiden.

Annotationen werden zusammen mit den Regionen, auf die sie zutreffen, in Form eines Vektors von Region-Annotation-Tupeln bereitgestellt.

In Übereinstimmung mit der in [`AnnotatedString`](@ref) dokumentierten Semantik entspricht die Reihenfolge der zurückgegebenen Annotationen der Reihenfolge, in der sie angewendet wurden.

Siehe auch: [`annotate!`](@ref).

annotations(chr::AnnotatedChar) -> Vector{@NamedTuple{label::Symbol, value}}

Holen Sie sich alle Annotationen von chr in Form eines Vektors von Annotationspaaren.

annotate!(str::AnnotatedString, [range::UnitRange{Int}], label::Symbol, value)
annotate!(str::SubString{AnnotatedString}, [range::UnitRange{Int}], label::Symbol, value)

Annotieren Sie einen Bereich von str (oder den gesamten String) mit einem beschrifteten Wert (label => value). Um vorhandene label-Annotationen zu entfernen, verwenden Sie einen Wert von nothing.

Die Reihenfolge, in der Annotationen auf str angewendet werden, ist semantisch bedeutungsvoll, wie in AnnotatedString beschrieben.

annotate!(char::AnnotatedChar, label::Symbol, value::Any)

Annotiere char mit dem Paar label => value.