Elixir Language
Los operadores

El operador de tubería

El operador de tubería |> toma el resultado de una expresión de la izquierda y la alimenta como primer parámetro a una función de la derecha.

expression |> function

Utilice el operador de tubería para encadenar expresiones y documentar visualmente el flujo de una serie de funciones.

Considera lo siguiente:

Oven.bake(Ingredients.Mix([:flour, :cocoa, :sugar, :milk, :eggs, :butter]), :temperature)

En el ejemplo, Oven.bake aparece antes que Ingredients.mix , pero se ejecuta en último lugar. Además, puede que no sea obvio que :temperature es un parámetro de Oven.bake

Reescribiendo este ejemplo usando el operador de tubería:

[:flour, :cocoa, :sugar, :milk, :eggs, :butter]
|> Ingredients.mix
|> Oven.bake(:temperature)

Da el mismo resultado, pero el orden de ejecución es más claro. Además, está claro que :temperature es un parámetro para la llamada Oven.bake .

Tenga en cuenta que cuando se usa el operador de tuberías, el primer parámetro para cada función se reubica antes que el operador de tuberías, por lo que la función a la que se llama parece tener un parámetro menos. Por ejemplo:

Enum.each([1, 2, 3], &(&1+1)) # produces [2, 3, 4]

es lo mismo que:

[1, 2, 3]
|> Enum.each(&(&1+1))

Operador de tuberías y paréntesis.

Se necesitan paréntesis para evitar la ambigüedad:

foo 1 |> bar 2 |> baz 3

Debe escribirse como:

foo(1) |> bar(2) |> baz(3)

operadores booleanos

Hay dos tipos de operadores booleanos en Elixir:

• operadores booleanos (esperan que sea true o false como su primer argumento)

x or y      # true if x is true, otherwise y

x and y     # false if x is false, otherwise y

not x       # false if x is true, otherwise true

Todos los operadores booleanos generarán ArgumentError si el primer argumento no es estrictamente un valor booleano, lo que significa que solo es true o false ( nil no es booleano).

iex(1)> false and 1 # return false
iex(2)> false or 1 # return 1 
iex(3)> nil and 1 # raise (ArgumentError) argument error: nil

• Operadores booleanos relajados (trabajo con cualquier tipo, todo lo que ni false ni nil se considera true )

x || y     # x if x is true, otherwise y

x && y     # y if x is true, otherwise false

!x         # false if x is true, otherwise true

Operador || siempre devolverá el primer argumento si es veraz (Elixir trata todo excepto nil y false para que sea cierto en las comparaciones), de lo contrario, devolverá el segundo.

iex(1)> 1 || 3 # return 1, because 1 is truthy
iex(2)> false || 3 # return 3
iex(3)> 3 || false # return 3
iex(4)> false || nil # return nil
iex(5)> nil || false # return false

Operator && siempre devolverá el segundo argumento si es veraz. De lo contrario, volverá respectivamente a los argumentos, false o nil .

iex(1)> 1 && 3 # return 3, first argument is truthy
iex(2)> false && 3 # return false
iex(3)> 3 && false # return false 
iex(4)> 3 && nil # return nil
iex(5)> false && nil # return false
iex(6)> nil && false # return nil

Ambos && y || Son operadores de cortocircuito. Solo ejecutan el lado derecho si el lado izquierdo no es suficiente para determinar el resultado.

Operador ! devolverá el valor booleano de negación del término actual:

iex(1)> !2 # return false
iex(2)> !false # return true
iex(3)> !"Test" # return false
iex(4)> !nil # return true

La forma simple de obtener el valor booleano del término seleccionado es simplemente duplicar este operador:

iex(1)> !!true # return true
iex(2)> !!"Test" # return true
iex(3)> !!nil # return false
iex(4)> !!false # return false

Operadores de comparación

Igualdad:

• igualdad de valor x == y ( 1 == 1.0 # true )
• desigualdad de valor x == y ( 1 != 1.0 # false )
• igualdad estricta x === y ( 1 === 1.0 # false )
• desigualdad estricta x === y ( 1 !== 1.0 # true )

Comparación:

• x > y
• x >= y
• x < y
• x <= y

Si los tipos son compatibles, la comparación usa orden natural. De lo contrario hay regla general de comparación de tipos:

number < atom < reference < function < port < pid < tuple < map < list < binary

Unirse a los operadores

Puede unir (concatenar) binarios (incluidas cadenas) y listas:

iex(1)> [1, 2, 3] ++ [4, 5]
[1, 2, 3, 4, 5]

iex(2)> [1, 2, 3, 4, 5] -- [1, 3]
[2, 4, 5]

iex(3)> "qwe" <> "rty"
"qwerty"

Operador 'In'

in operador le permite verificar si una lista o un rango incluye un elemento:

iex(4)> 1 in [1, 2, 3, 4]
true

iex(5)> 0 in (1..5)
false