Expresiones regulares en

Acerca de Expresiones regulares

Las expresiones regulares (regex) son una herramienta muy potente para trabajar con strings en Elixir. Las expresiones regulares de Elixir siguen la especificación PCRE (Perl Compatible Regular Expressions). Los patrones de string que representan el significado de la expresión regular se compilan primero y después se usan para buscar coincidencias con todo un string o con una parte de él.

En Elixir, la forma más habitual de crear expresiones regulares es usar el sigil ~r. Los sigils proporcionan atajos de azúcar sintáctico para tareas comunes en Elixir. En este caso, ~r es un atajo para usar Regex.compile!/2.

Regex.compile!("test") == ~r/test/
# => true

El operador =~/2 es útil para buscar una coincidencia de una expresión regular en un string y obtener un resultado boolean.

"this is a test" =~ ~r/test/
# => true

Repaso de la sintaxis de las expresiones regulares

• Algunos caracteres de un patrón de expresión regular tienen un significado especial; para usar el carácter de forma literal hay que escaparlo con \, p. ej. ~r/\?/.
• Las clases de caracteres (p. ej. \d, \w) permiten que un patrón coincida con un rango de caracteres
• Las alternancias (|) permiten que un patrón coincida con un patrón u otro
• Los cuantificadores ({N, M}, *, ?) permiten que un patrón coincida con un número determinado de repeticiones
• Los grupos (()) permiten que partes de un patrón funcionen como una unidad

Capturas

Las expresiones regulares también son útiles para extraer una parte de un string. A esto se le llama captura. Para capturar una parte de un string, crea un grupo (()) para la parte que quieres capturar y usa Regex.run.

Regex.run(~r/Weight: (\d*)g/, "Weight: 150g")
# => ["Weight: 150g", "150"]

Las capturas están numeradas (empezando por 1) y también se pueden usar en el resultado al reemplazar partes de un string con una expresión regular:

Regex.replace(~r/Weight: (\d*)g/, "Weight: 150g", "Gewicht: \\1g")
# => "Gewicht: 150g"

Las capturas también se pueden nombrar añadiendo ?<name> después del paréntesis de apertura. Usa Regex.named_captures/3 para obtener un mapa con las capturas con nombre.

Regex.named_captures(~r/Weight: (?<weight>\d*)g/, "Weight: 150g")
# => %{"weight" => "150"}

Modificadores

El comportamiento de una expresión regular se puede modificar añadiendo modificadores especiales al final de la expresión regular, p. ej. ~r/test/i.

• caseless i - no distingue mayúsculas y minúsculas

  "A" =~ ~r/a/
  # => false
  "A" =~ ~r/a/i
  # => true
  

• unicode u - habilita patrones específicos de Unicode como \p y hace que las clases de caracteres como \w, etc. también coincidan con caracteres Unicode

  "ö" =~ ~r/^\w$/
  # => false
  "ö" =~ ~r/^\w$/u
  # => true
  

• Y más: dotall, multiline, extended, firstline, ungreedy

Construir expresiones regulares dinámicamente

Como el sigil ~r es un atajo para "pattern" |> Regex.escape() |> Regex.compile!(), también puedes usar la interpolación de string para construir dinámicamente un patrón de expresión regular:

anchor = "$"
regex = ~r/end of the line#{anchor}/
"end of the line?" =~ regex
# => false
"end of the line" =~ regex
# => true

Las expresiones regulares frente al módulo String

Aunque las expresiones regulares son potentes, no siempre es aconsejable usarlas:

• Hay que compilarlas antes de usarlas, lo que consume tiempo de cálculo y memoria.
• Pueden ser más lentas que usar funciones de string normales.

Como norma general, es mejor usar las funciones del módulo String siempre que sea posible.

# Don't use regular expressions to check a suffix:
if "YELLING!" =~ ~r/!$/, do: "Whoa, chill out!"

# Use a string function:
if String.ends_with?("YELLING!", "!"), do: "Whoa, chill out!"