Regulärer Chatbot

Reguläre Ausdrücke sind eine äußerst vielseitige Methode, um Strings mit Musterabgleich zu prüfen. Dafür nutzen sie eine eigens für diesen Zweck entwickelte domänenspezifische Sprache (DSL).

Wie einige andere Programmiersprachen versucht Julia gar nicht erst, eine eigene Regex-Bibliothek zu implementieren. Stattdessen greift es auf die weit verbreitete Bibliothek PCRE2 zurück und bietet damit eine Regex-Syntax, die identisch ist mit (zum Beispiel) Gleam und sehr ähnlich zu JavaScript.

• Regex101
• RegExr
• RexEgg
• RegexOne
• Regular Expressions Info

Julias Schnittstelle zu regulären Ausdrücken wird im Handbuch beschrieben.

Ein regulärer Ausdruck in Julia ist einfach ein String, dem vor dem öffnenden " ein r vorangestellt wird. Die gesamte grundlegende Funktionalität ist Teil der Standardbibliothek.

Tatsächlich sind viele der Funktionen, die bereits im Konzept Strings behandelt wurden, standardmäßig für Regex-Suchen ausgelegt, zum Beispiel occursin().

julia> re = r"test$"
r"test$"

julia> typeof(re)
Regex

# Does a string end with "test"?
julia> occursin(re, "this is a test")
true

julia> occursin(re, "these are tests")
false

Nach dem schließenden Anführungszeichen können Modifiziererzeichen stehen, etwa i für eine Übereinstimmung ohne Beachtung der Groß- und Kleinschreibung.

julia> occursin(r"test", "Testing")
false

julia> occursin(r"test"i, "Testing")
true

Capture-Gruppen

Häufig wollen wir wissen, was übereinstimmt. Dazu fügst du Capture-Gruppen in runden Klammern in den Regex ein und verwendest anschließend die Funktion match().

julia> m = match(r"(\d+g) .* (\d+ml)", "dissolve 25g sugar in 200ml water")
RegexMatch("25g sugar in 200ml", 1="25g", 2="200ml")

julia> m.captures
2-element Vector{Union{Nothing, SubString{String}}}:
 "25g"
 "200ml"

# how many matches?
julia> length(m.captures)
2

# what matched?
julia> m[1], m[2]
("25g", "200ml")

# Starting positions of the matches (character index)
julia> m.offsets
2-element Vector{Int64}:
 10
 23

Natürlich können Übereinstimmungen fehlschlagen. Das Ergebnis ist dann der spezielle Wert Nothing statt eines RegexMatch. Sei also darauf vorbereitet, das zu prüfen.

# failed match
m = match(r"(not here)", "dissolve 25g sugar in 200ml water")

julia> typeof(m)
Nothing

julia> isnothing(m)
true

Obwohl match standardmäßig am Anfang des Strings beginnt, kannst du auch einen Offset n angeben, um die ersten n Zeichen zu ignorieren.

# capture first match
julia> m = match(r"(\wat)", "cat, sat, mat")
RegexMatch("cat", 1="cat")

# ignore first 5 characters, then match
julia> m = match(r"(\wat)", "cat, sat, mat", 5)
RegexMatch("sat", 1="sat")

In Julia findet match() nur die erste Übereinstimmung im Ziel-String. Einen globalen Modifikator wie in manchen anderen Sprachen gibt es nicht.

Stattdessen gibt es eachmatch(), das einen Iterator über die Übereinstimmungen zurückgibt. Dieser wird erst bei Bedarf ausgewertet, du musst ihn also möglicherweise in das gewünschte Format umwandeln.

julia> matches = eachmatch(r"(\wat)", "cat, sat, mat")
Base.RegexMatchIterator{String}(r"(\wat)", "cat, sat, mat", false)

# convert to vector
julia> collect(matches)
3-element Vector{RegexMatch}:
 RegexMatch("cat", 1="cat")
 RegexMatch("sat", 1="sat")
 RegexMatch("mat", 1="mat")

# convert with comprehension
julia> [m.match for m in matches]
3-element Vector{SubString{String}}:
 "cat"
 "sat"
 "mat"

# broadcast an anonymous function
julia> (m -> m.match).(matches)
3-element Vector{SubString{String}}:
 "cat"
 "sat"
 "mat"

Ersetzen

Ein häufiger Grund für den Einsatz eines Regex ist es, die Übereinstimmung durch einen anderen String zu ersetzen.

Die Funktion replace() wurde im Konzept Strings behandelt, wo String-Literale zur Suche dienten. Dieselbe Funktion kann die volle Stärke des Regex-Matchings nutzen.

julia> replace("some string", r"[aeiou]" => "*")
"s*m* str*ng"

julia> replace("first second", r"(\w+) (?<agroup>\w+)" => s"\g<agroup> \1")
"second first"

Das zweite Beispiel oben zeigt, wie sowohl nummerierte als auch benannte Capture-Gruppen in der Ersetzung verwendet werden können, und zwar innerhalb eines s" "-Strings.

Weitere Details findest du im Handbuch: Dies ist ein Thema, das die meisten Programmierer immer wieder zur Dokumentation zurückzwingt!