Elixir Language
Les opérateurs
Recherche…
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
oufalse
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
ninil
n'est considéré commetrue
)
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