Elixir Language
операторы

Оператор труб

Оператор трубы |> принимает результат выражения слева и передает его в качестве первого параметра функции справа.

expression |> function

Используйте оператор трубы для объединения выражений вместе и визуального документирования потока ряда функций.

Рассмотрим следующее:

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

В примере, Oven.bake приходит до Ingredients.mix , но выполняется последним. Кроме того, не может быть очевидно, что :temperature является параметром Oven.bake

Переписывая этот пример с помощью оператора труб:

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

дает тот же результат, но порядок выполнения более ясен. Кроме того, ясно, что :temperature является параметром для вызова Oven.bake .

Обратите внимание, что при использовании оператора трубок первый параметр для каждой функции перемещается до оператора трубы, и поэтому вызываемая функция имеет один меньший параметр. Например:

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

такой же как:

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

Оператор и круглые скобы

Круглые скобки необходимы, чтобы избежать двусмысленности:

foo 1 |> bar 2 |> baz 3

Должен быть написан как:

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

Булевы операторы

В Эликсире существует два типа булевых операторов:

• логические операторы (они ожидают, что в качестве первого аргумента они будут либо true либо false )

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

Все логические операторы будут поднимать ArgumentError если первый аргумент не будет строго логическим значением, что означает только true или false ( nil не является логическим).

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

• релаксированные булевы операторы (работа с любым типом, все, что ни false ни nil считается 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

Оператор || всегда будет возвращать первый аргумент, если он правдивый (Elixir рассматривает все, кроме nil и false чтобы быть истинным в сравнении), в противном случае вернется второй.

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

Оператор && всегда будет возвращать второй аргумент, если он прав. В противном случае возвращаются соответственно аргументам, false или 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

И && и || являются операторами короткого замыкания. Они выполняют только правую сторону, если левой части недостаточно, чтобы определить результат.

Оператор ! будет возвращать логическое значение отрицания текущего термина:

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

Простой способ получить логическое значение выбранного термина - просто удвоить этот оператор:

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

Операторы сравнения

Равенство:

• value равен x == y ( 1 == 1.0 # true )
• значение неравенства x == y ( 1 != 1.0 # false )
• строгое равенство x === y ( 1 === 1.0 # false )
• строгое неравенство x === y ( 1 !== 1.0 # true )

Сравнение:

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

Если типы совместимы, сравнение использует естественный порядок. В противном случае существует правило сравнения общих типов:

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

Присоединяйтесь

Вы можете объединять (объединить) двоичные файлы (включая строки) и списки:

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"

Оператор «В»

in операторе позволяет проверить, содержит ли список или диапазон элемент:

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

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