Expressions régulières en

À propos de Expressions régulières

Les expressions régulières (regex) sont un outil puissant pour manipuler les strings en Elixir. En Elixir, les expressions régulières suivent la spécification PCRE (Perl Compatible Regular Expressions). Les motifs sous forme de string qui représentent la signification de l'expression régulière sont d'abord compilés, puis utilisés pour faire correspondre tout ou partie d'une string.

En Elixir, la façon la plus courante de créer des expressions régulières est d'utiliser le sigil ~r. Les sigils offrent un sucre syntaxique sous forme de raccourcis pour des tâches courantes en Elixir. Ici, ~r est un raccourci pour Regex.compile!/2.

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

L'opérateur =~/2 permet de tester une string contre une expression régulière et de renvoyer un résultat boolean.

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

Rappel de la syntaxe des expressions régulières

• Certains caractères d'un motif d'expression régulière ont un sens particulier ; pour utiliser le caractère tel quel, il faut l'échapper avec \, par exemple ~r/\?/.
• Les classes de caractères (par exemple \d, \w) permettent à un motif de correspondre à une plage de caractères
• Les alternances (|) permettent à un motif de correspondre à un motif ou à un autre
• Les quantificateurs ({N, M}, *, ?) permettent à un motif de correspondre à un nombre donné de répétitions
• Les groupes (()) permettent à certaines parties d'un motif de fonctionner comme une unité

Captures

Les expressions régulières servent aussi à extraire une partie d'une string. On parle alors de capture. Pour capturer une partie d'une string, crée un groupe (()) autour de la partie à capturer, puis utilise Regex.run.

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

Les captures sont numérotées (à partir de 1) et peuvent aussi être utilisées dans le résultat lorsqu'on remplace des parties d'une string à l'aide d'une expression régulière :

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

On peut également nommer les captures en ajoutant ?<name> après la parenthèse ouvrante. Utilise Regex.named_captures/3 pour récupérer une map contenant les captures nommées.

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

Modificateurs

On peut modifier le comportement d'une expression régulière en ajoutant des options spéciales à la fin de l'expression régulière, par exemple ~r/test/i.

• caseless i : insensible à la casse

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

• unicode u : active les motifs propres à Unicode comme \p et fait en sorte que les classes de caractères comme \w, etc. correspondent aussi aux caractères Unicode

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

• Et plus encore : dotall, multiline, extended, firstline, ungreedy

Construis des expressions régulières dynamiquement

Comme le sigil ~r est un raccourci pour "pattern" |> Regex.escape() |> Regex.compile!(), tu peux aussi utiliser l'interpolation de chaîne pour construire dynamiquement un motif d'expression régulière :

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

Les expressions régulières face au module String

Bien que les expressions régulières soient puissantes, il n'est pas toujours sage de les utiliser :

• Elles doivent être compilées avant d'être utilisées, ce qui consomme du temps de calcul et de la mémoire.
• Elles peuvent être plus lentes que de simples fonctions de manipulation de strings.

En règle générale, mieux vaut utiliser les fonctions du module String chaque fois que c'est possible.

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