Expressões regulares em

Sobre Expressões regulares

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 depois usados para buscar correspondência com toda ou parte de uma string.

Em Elixir, a forma mais comum de criar expressões regulares é usar o sigil ~r. Os sigils são açúcar sintático: atalhos 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 verificar se uma string corresponde a uma expressão regular e retornar um resultado boolean.

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

Revisão da sintaxe de regex

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

Capturas

As expressões regulares também são úteis para extrair uma parte de uma string. Isso é o que chamamos de captura. Para capturar uma parte de uma string, crie um grupo (()) para a parte que você quer capturar e use Regex.run.

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

As capturas são numeradas (a partir de 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 ser nomeadas acrescentando ?<name> depois do parêntese de abertura. Use Regex.named_captures/3 para obter um mapa com as capturas nomeadas.

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 diferencia maiúsculas de minúsculas

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

• unicode u - habilita padrões específicos do Unicode, como \p, e faz com que classes de caracteres como \w etc. também correspondam a caracteres Unicode

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

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

Construindo expressões regulares dinamicamente

Como o sigil ~r é um atalho para "pattern" |> Regex.escape() |> Regex.compile!(), você também pode 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

Apesar de as expressões regulares serem poderosas, nem sempre é uma boa ideia usá-las:

• Elas precisam ser compiladas antes do uso, o que consome tempo de processamento e memória.
• Elas 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!"