Elixir - Sigilos

En este capítulo, vamos a explorar los sigilos, los mecanismos proporcionados por el lenguaje para trabajar con representaciones textuales. Los sigilos comienzan con el carácter de tilde (~) seguido de una letra (que identifica el sigilo) y luego un delimitador; opcionalmente, se pueden agregar modificadores después del delimitador final.

Regex

Las expresiones regulares en Elixir son sigilos. Hemos visto su uso en el capítulo String. Tomemos de nuevo un ejemplo para ver cómo podemos usar expresiones regulares en Elixir.

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

Cuando se ejecuta el programa anterior, produce el siguiente resultado:

true
false

Los sellos admiten 8 delimitadores diferentes:

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

La razón detrás de admitir diferentes delimitadores es que diferentes delimitadores pueden ser más adecuados para diferentes sigilos. Por ejemplo, usar paréntesis para expresiones regulares puede ser una elección confusa ya que pueden mezclarse con los paréntesis dentro de la expresión regular. Sin embargo, los paréntesis pueden ser útiles para otros sigilos, como veremos en la siguiente sección.

Elixir admite expresiones regulares compatibles con Perl y también admite modificadores. Puede leer más sobre el uso de expresiones regulares aquí .

Cadenas, listas de caracteres y listas de palabras

Aparte de las expresiones regulares, Elixir tiene 3 sellos incorporados más. Echemos un vistazo a los sigilos.

Instrumentos de cuerda

El sigilo ~ s se usa para generar cadenas, al igual que las comillas dobles. El sigilo ~ s es útil, por ejemplo, cuando una cadena contiene comillas simples y dobles:

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

Este sigilo genera hilos. Cuando se ejecuta el programa anterior, produce el siguiente resultado:

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

Listas de caracteres

El sigilo ~ c se usa para generar listas de caracteres:

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

Cuando se ejecuta el programa anterior, produce el siguiente resultado:

this is a char list containing 'single quotes'

Listas de palabras

El sigilo ~ w se usa para generar listas de palabras (las palabras son cadenas regulares). Dentro del sigilo ~ w, las palabras están separadas por espacios en blanco.

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

Cuando se ejecuta el programa anterior, produce el siguiente resultado:

foobarbat

El sigilo ~ w también acepta el c, s y a modificadores (para listas de caracteres, cadenas y átomos, respectivamente), que especifican el tipo de datos de los elementos de la lista resultante -

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

Cuando se ejecuta el programa anterior, produce el siguiente resultado:

[:foo, :bar, :bat]

Interpolación y escape en sigilos

Además de los sigilos en minúsculas, Elixir admite sigilos en mayúsculas para lidiar con caracteres de escape e interpolación. Mientras que ~ sy ~ S devolverán cadenas, el primero permite códigos de escape e interpolación, mientras que el segundo no. Consideremos un ejemplo para entender esto:

~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}"

Sigilos personalizados

Podemos crear fácilmente nuestros propios sellos personalizados. En este ejemplo, crearemos un sigilo para convertir una cadena a mayúsculas.

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

import CustomSigil

IO.puts(~u/tutorials point/)

Cuando ejecutamos el código anterior, produce el siguiente resultado:

TUTORIALS POINT

Primero definimos un módulo llamado CustomSigil y dentro de ese módulo, creamos una función llamada sigil_u. Como no hay un sigilo ~ u existente en el espacio de sigilo existente, lo usaremos. El _u indica que deseamos usar u como el carácter después de la tilde. La definición de la función debe tener dos argumentos, una entrada y una lista.