Elixir Language
operatori

L'operatore del tubo

L'operatore di pipe |> prende il risultato di un'espressione a sinistra e lo alimenta come primo parametro di una funzione a destra.

expression |> function

Usa Pipe Operator per concatenare le espressioni e per documentare visivamente il flusso di una serie di funzioni.

Considera quanto segue:

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

Nell'esempio, Oven.bake arriva prima di Ingredients.mix , ma viene eseguito per ultimo. Inoltre, potrebbe non essere ovvio che :temperature è un parametro di Oven.bake

Riscrivi questo esempio usando l'operatore di pipe:

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

dà lo stesso risultato, ma l'ordine di esecuzione è più chiaro. Inoltre, è chiaro che :temperature è un parametro della chiamata Oven.bake .

Si noti che quando si utilizza Pipe Operator, il primo parametro per ciascuna funzione viene riposizionato prima dell'operatore Pipe e quindi la funzione chiamata sembra avere un parametro in meno. Per esempio:

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

equivale a:

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

Operatore del tubo e parentesi

Le parentesi sono necessarie per evitare l'ambiguità:

foo 1 |> bar 2 |> baz 3

Dovrebbe essere scritto come:

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

Operatori booleani

Esistono due tipi di operatori booleani in elisir:

• operatori booleani (si aspettano che sia true o false come primo argomento)

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

Tutti gli operatori booleani genereranno ArgumentError se il primo argomento non sarà strettamente booleano, il che significa solo true o false ( nil non è 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

• operatori booleani rilassati (funzionano con qualsiasi tipo, tutto ciò che né false né nil è considerato 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

Operatore || restituirà sempre il primo argomento se è vero (Elixir considera tutto tranne nil e false per essere vero nei confronti), altrimenti restituirà il secondo.

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

L'operatore && e restituirà sempre il secondo argomento se è vero. Altrimenti tornerà rispettivamente agli argomenti, 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

Sia && che || sono operatori di cortocircuito. Eseguono solo il lato destro se il lato sinistro non è sufficiente per determinare il risultato.

Operatore ! restituirà il valore booleano della negazione del termine corrente:

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

Un modo semplice per ottenere il valore booleano del termine selezionato è semplicemente raddoppiare questo operatore:

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

Operatori di confronto

Uguaglianza:

• valore uguaglianza x == y ( 1 == 1.0 # true )
• disuguaglianza di valore x == y ( 1 != 1.0 # false )
• uguaglianza rigorosa x === y ( 1 === 1.0 # false )
• disuguaglianza rigorosa x === y ( 1 !== 1.0 # true )

Confronto:

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

Se i tipi sono compatibili, il confronto utilizza l'ordinamento naturale. Altrimenti esiste una regola di confronto dei tipi generali:

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

Unisciti agli operatori

Puoi unire (concatenare) i binari (comprese le stringhe) e gli elenchi:

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"

Operatore "In"

in operatore consente di verificare se un elenco o un intervallo include un elemento:

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

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