Elisir - Sigilli

In questo capitolo esploreremo i sigilli, i meccanismi forniti dal linguaggio per lavorare con le rappresentazioni testuali. I sigilli iniziano con il carattere tilde (~) seguito da una lettera (che identifica il sigillo) e quindi da un delimitatore; facoltativamente, i modificatori possono essere aggiunti dopo il delimitatore finale.

Regex

Le espressioni regolari in Elisir sono sigilli. Abbiamo visto il loro utilizzo nel capitolo String. Facciamo di nuovo un esempio per vedere come possiamo usare le espressioni regolari in Elixir.

# A regular expression that matches strings which contain "foo" or
# "bar":
regex = ~r/foo|bar/
IO.puts("foo" =~ regex)
IO.puts("baz" =~ regex)

Quando il programma di cui sopra viene eseguito, produce il seguente risultato:

true
false

I sigilli supportano 8 diversi delimitatori -

~r/hello/
~r|hello|
~r"hello"
~r'hello'
~r(hello)
~r[hello]
~r{hello}
~r<hello>

Il motivo dietro il supporto di delimitatori diversi è che diversi delimitatori possono essere più adatti a sigilli diversi. Ad esempio, l'uso delle parentesi per le espressioni regolari può essere una scelta confusa in quanto possono mescolarsi con le parentesi all'interno della regex. Tuttavia, le parentesi possono essere utili per altri sigilli, come vedremo nella prossima sezione.

Elixir supporta regex compatibili con Perl e supporta anche i modificatori. Puoi leggere di più sull'uso delle espressioni regolari qui .

Stringhe, elenchi di caratteri ed elenchi di parole

Oltre alle espressioni regolari, Elixir ha altri 3 sigilli incorporati. Diamo uno sguardo ai sigilli.

stringhe

Il sigillo ~ s è usato per generare stringhe, come le virgolette doppie. Il sigillo ~ è utile, ad esempio, quando una stringa contiene virgolette sia doppie che singole -

new_string = ~s(this is a string with "double" quotes, not 'single' ones)
IO.puts(new_string)

Questo sigillo genera stringhe. Quando il programma di cui sopra viene eseguito, produce il seguente risultato:

"this is a string with \"double\" quotes, not 'single' ones"

Elenchi di caratteri

Il sigillo ~ c viene utilizzato per generare elenchi di caratteri -

new_char_list = ~c(this is a char list containing 'single quotes')
IO.puts(new_char_list)

Quando il programma di cui sopra viene eseguito, produce il seguente risultato:

this is a char list containing 'single quotes'

Elenchi di parole

Il sigillo ~ w viene utilizzato per generare elenchi di parole (le parole sono solo stringhe regolari). All'interno del sigillo ~ w, le parole sono separate da spazi bianchi.

new_word_list = ~w(foo bar bat)
IO.puts(new_word_list)

Quando il programma di cui sopra viene eseguito, produce il seguente risultato:

foobarbat

Il sigillo ~ w accetta anche il c, s e a modificatori (rispettivamente per elenchi di caratteri, stringhe e atomi), che specificano il tipo di dati degli elementi dell'elenco risultante -

new_atom_list = ~w(foo bar bat)a
IO.puts(new_atom_list)

Quando il programma di cui sopra viene eseguito, produce il seguente risultato:

[:foo, :bar, :bat]

Interpolazione e fuga nei sigilli

Oltre ai sigilli minuscoli, Elixir supporta i sigilli maiuscoli per gestire i caratteri di fuga e l'interpolazione. Sebbene sia ~ s che ~ S restituiscano stringhe, il primo consente codici di escape e interpolazione mentre il secondo no. Consideriamo un esempio per capire questo:

~s(String with escape codes \x26 #{"inter" <> "polation"})
# "String with escape codes & interpolation"
~S(String without escape codes \x26 without #{interpolation})
# "String without escape codes \\x26 without \#{interpolation}"

Sigilli personalizzati

Possiamo facilmente creare i nostri sigilli personalizzati. In questo esempio, creeremo un sigillo per convertire una stringa in maiuscolo.

defmodule CustomSigil do
   def sigil_u(string, []), do: String.upcase(string)
end

import CustomSigil

IO.puts(~u/tutorials point/)

Quando eseguiamo il codice sopra, produce il seguente risultato:

TUTORIALS POINT

Per prima cosa definiamo un modulo chiamato CustomSigil e all'interno di quel modulo, abbiamo creato una funzione chiamata sigil_u. Poiché non esiste un sigillo ~ u esistente nello spazio del sigillo esistente, lo useremo. La _u indica che si desidera utilizzare u come carattere dopo la tilde. La definizione della funzione deve accettare due argomenti, un input e un elenco.