Expressões regulares em

Sobre Expressões regulares

As expressões regulares (regex) são uma ferramenta poderosa para trabalhar com strings em Elixir. As expressões regulares em Elixir seguem a especificação PCRE (Perl Compatible Regular Expressions). Os padrões de string que representam o significado da expressão regular são primeiro compilados e só depois usados para corresponder a toda a string ou a parte dela.

Em Elixir, a forma mais comum de criar expressões regulares é usar o sigil ~r. Os sigils fornecem atalhos de açúcar sintático para tarefas comuns em Elixir. Neste caso, ~r é um atalho para usar Regex.compile!/2.

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

O operador =~/2 é útil para fazer uma correspondência de expressão regular numa string e devolver um resultado boolean.

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

Revisão da sintaxe das expressões regulares

• Alguns carateres num padrão de expressão regular têm um significado especial; para usar o caráter tal como é, é preciso escapá-lo com \, por exemplo ~r/\?/.
• Classes de carateres (por exemplo, \d, \w) permitem que os padrões correspondam a um intervalo de carateres
• Alternâncias (|) permitem que os padrões correspondam a um padrão ou a outro
• Quantificadores ({N, M}, *, ?) permitem que os padrões correspondam a um número especificado de padrões repetidos
• Grupos (()) permitem que partes dos padrões funcionem como uma unidade

Capturas

As expressões regulares também são úteis para extrair uma parte de uma string. A isto chama-se capturar. Para capturar uma parte de uma string, cria um grupo (()) para a parte que queres capturar e usa Regex.run.

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

As capturas são numeradas (a começar em 1) e também podem ser usadas no resultado ao substituir partes de uma string com uma expressão regular:

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

As capturas também podem ter nome, acrescentando ?<name> depois do parêntese de abertura. Usa Regex.named_captures/3 para obteres um mapa com as capturas com nome.

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

Modificadores

O comportamento de uma expressão regular pode ser modificado acrescentando flags especiais no fim da expressão regular, por exemplo ~r/test/i.

• caseless i - não distingue maiúsculas de minúsculas

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

• unicode u - ativa padrões específicos do Unicode, como \p, e faz com que classes de carateres como \w, entre outras, também correspondam em Unicode

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

• E mais: dotall, multiline, extended, firstline, ungreedy

Construir expressões regulares dinamicamente

Como o sigil ~r é um atalho para "pattern" |> Regex.escape() |> Regex.compile!(), também podes usar interpolação de strings para construir dinamicamente um padrão de expressão regular:

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

Expressões regulares vs o módulo String

Embora as expressões regulares sejam poderosas, nem sempre é aconselhável usá-las:

• Têm de ser compiladas antes de serem usadas, o que consome tempo de processamento e memória.
• Podem ser mais lentas do que usar funções de string simples.

Como regra geral, é melhor usar as funções do módulo String sempre que possível.

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