Chatbot con expresiones regulares

Las expresiones regulares son una forma muy versátil de hacer coincidir patrones en strings, usando un lenguaje de dominio específico (DSL) diseñado para ese propósito.

Como varios otros lenguajes de programación, Julia no intenta implementar su propia biblioteca de Regex. En su lugar, envuelve la popular biblioteca PCRE2, ofreciendo así una sintaxis de Regex idéntica a la de (por ejemplo) Gleam, y muy similar a la de JavaScript.

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

La interfaz de Julia con las expresiones regulares se describe en el manual.

Una expresión regular en Julia es simplemente un string al que se le antepone una r antes de la " de apertura. Toda la funcionalidad básica es parte de la biblioteca estándar.

De hecho, muchas de las funciones que ya se trataron en el concepto Strings están diseñadas para hacer búsquedas con Regex de forma estándar, como 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

Puedes poner caracteres modificadores después de la comilla de cierre, como i para una coincidencia que no distingue mayúsculas y minúsculas.

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

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

Capturas

Con frecuencia queremos saber qué coincide. Esto se logra incluyendo grupos de captura entre paréntesis dentro de la regex, y luego usando la función 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

Por supuesto, las coincidencias pueden fallar. El resultado será entonces el valor especial Nothing en lugar de un RegexMatch, así que prepárate para verificarlo.

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

julia> typeof(m)
Nothing

julia> isnothing(m)
true

Aunque match comienza por defecto al inicio del string, también podemos especificar un desplazamiento n para ignorar los primeros n caracteres.

# 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")

En Julia, match() solo encuentra la primera coincidencia dentro del string objetivo: no hay un modificador global como en otros lenguajes.

En su lugar, tenemos eachmatch(), que devuelve un iterador de coincidencias. Se evalúa de forma perezosa, así que puede que necesites convertirlo al formato que quieras.

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"

Reemplazo

Una razón común para usar una Regex es reemplazar la coincidencia con un string diferente.

La función replace() se trató en el concepto Strings, usando literales de string sobre los que buscar. La misma función puede aprovechar toda la potencia de las coincidencias con Regex.

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

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

El segundo ejemplo de arriba muestra cómo se pueden usar tanto grupos de captura numerados como con nombre en el reemplazo, dentro de un string s" ".

Consulta el manual para más detalles: ¡este es un tema que constantemente obliga a la mayoría de los programadores a volver a la documentación!