Espressioni regolari in

Informazioni su Espressioni regolari

Le espressioni regolari (regex) sono uno strumento potente per lavorare con le stringhe in Elixir. Le espressioni regolari in Elixir seguono la specifica PCRE (Perl Compatible Regular Expressions). I pattern di stringa che rappresentano il significato dell'espressione regolare vengono prima compilati e poi usati per trovare corrispondenze in tutta o parte di una stringa.

In Elixir, il modo più comune per creare espressioni regolari è usare il sigil ~r. I sigil forniscono scorciatoie di zucchero sintattico per le attività più comuni in Elixir. In questo caso, ~r è una scorciatoia per usare Regex.compile!/2.

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

L'operatore =~/2 è utile per eseguire una corrispondenza regex su una stringa e restituire un risultato boolean.

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

Ripasso della sintassi delle regex

• Alcuni caratteri in un pattern di espressione regolare hanno un significato speciale; per usare il carattere in modo letterale va preceduto da una barra di escape \, ad esempio ~r/\?/.
• Le classi di caratteri (ad esempio \d, \w) permettono ai pattern di trovare corrispondenze con un intervallo di caratteri
• Le alternanze (|) permettono ai pattern di trovare corrispondenze con un pattern o con un altro
• I quantificatori ({N, M}, *, ?) permettono ai pattern di trovare corrispondenze con un numero specificato di ripetizioni
• I gruppi (()) permettono a parti di un pattern di funzionare come un'unica unità

Catture

Le espressioni regolari sono utili anche per estrarre una parte di una stringa. Questa operazione si chiama cattura. Per catturare una parte di una stringa, crea un gruppo (()) per la parte che vuoi catturare e usa Regex.run.

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

Le catture sono numerate (a partire da 1) e possono essere usate anche nel risultato quando si sostituiscono parti di una stringa con un'espressione regolare:

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

Le catture possono anche essere nominate aggiungendo ?<name> dopo la parentesi di apertura. Usa Regex.named_captures/3 per ottenere una mappa con le catture nominate.

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

Modificatori

Il comportamento di un'espressione regolare può essere modificato aggiungendo dei flag speciali alla fine dell'espressione regolare, ad esempio ~r/test/i.

• caseless i: non distingue tra maiuscole e minuscole

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

• unicode u: abilita pattern specifici per Unicode come \p e fa sì che le classi di caratteri come \w, ecc., trovino corrispondenze anche su Unicode

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

• E altro ancora: dotall, multiline, extended, firstline, ungreedy

Costruire espressioni regolari dinamicamente

Poiché il sigil ~r è una scorciatoia per "pattern" |> Regex.escape() |> Regex.compile!(), puoi anche usare l'interpolazione di stringhe per costruire dinamicamente un pattern di espressione regolare:

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

Espressioni regolari rispetto al modulo String

Anche se le espressioni regolari sono potenti, non è sempre saggio usarle:

• Vanno compilate prima dell'uso; questo richiede tempo di calcolo e memoria.
• Possono essere più lente rispetto all'uso di semplici funzioni per stringhe.

Come regola generale, è meglio usare le funzioni del modulo String quando possibile.

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