Elixir Language
Les opérateurs

L'opérateur de tuyaux

Le Pipe Operator |> prend le résultat d'une expression à gauche et l'utilise comme premier paramètre d'une fonction à droite.

expression |> function

Utilisez l'opérateur Pipe pour enchaîner les expressions et documenter visuellement le déroulement d'une série de fonctions.

Considérer ce qui suit:

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

Dans l'exemple, Oven.bake arrive avant Ingredients.mix , mais il est exécuté en dernier. En outre, il peut ne pas être évident que :temperature est un paramètre de Oven.bake

Réécriture de cet exemple à l'aide de l'opérateur Pipe:

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

donne le même résultat, mais l'ordre d'exécution est plus clair. De plus, il est clair que :temperature est un paramètre de l'appel Oven.bake .

Notez que lors de l'utilisation de l'opérateur Pipe, le premier paramètre de chaque fonction est déplacé avant l'opérateur Pipe, de sorte que la fonction appelée semble avoir un paramètre de moins. Par exemple:

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

est le même que:

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

Conducteur et parenthèses

Les parenthèses sont nécessaires pour éviter toute ambiguïté:

foo 1 |> bar 2 |> baz 3

Devrait être écrit comme:

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

opérateurs booléens

Il existe deux types d’opérateurs booléens dans Elixir:

• les opérateurs booléens (ils s'attendent à true ou false comme premier argument)

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

Tous les opérateurs booléens déclencheront ArgumentError si le premier argument ne sera pas strictement une valeur booléenne, ce qui signifie seulement true ou false ( nil n'est pas booléen).

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

• opérateurs booléens décontractés (travail avec n'importe quel type, tout ce que ni false ni nil n'est considéré comme 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

Opérateur || retournera toujours le premier argument si c'est vrai (Elixir traite tout sauf nil et false pour être vrai dans les comparaisons), sinon retournera le second.

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'opérateur && renverra toujours le deuxième argument si c'est vrai. Sinon, reviendra respectivement aux arguments, false ou 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

Les deux && et || sont des opérateurs de court-circuit. Ils n'exécutent que le côté droit si le côté gauche n'est pas suffisant pour déterminer le résultat.

Opérateur ! renverra une valeur booléenne de négation du terme courant:

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

Un moyen simple d'obtenir une valeur booléenne du terme sélectionné est de simplement doubler cet opérateur:

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

Opérateurs de comparaison

Égalité:

• valeur égalité x == y ( 1 == 1.0 # true )
• valeur inégalité x == y ( 1 != 1.0 # false )
• égalité stricte x === y ( 1 === 1.0 # false )
• Inégalité stricte x === y ( 1 !== 1.0 # true )

Comparaison:

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

Si les types sont compatibles, la comparaison utilise l'ordre naturel. Sinon, il existe une règle de comparaison des types généraux:

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

Rejoindre les opérateurs

Vous pouvez joindre (concaténer) des binaires (y compris des chaînes) et des listes:

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"

Opérateur 'In'

in operator vous permet de vérifier si une liste ou une plage contient un élément:

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

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