Elixir Language
Operatorzy

Operator rur

Operator rur |> pobiera wynik wyrażenia po lewej stronie i podaje go jako pierwszy parametr do funkcji po prawej stronie.

expression |> function

Użyj operatora rur do łączenia ze sobą wyrażeń i wizualnego dokumentowania przepływu szeregu funkcji.

Rozważ następujące:

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

W tym przykładzie Oven.bake występuje przed Ingredients.mix , ale jest wykonywany jako ostatni. Ponadto może nie być oczywiste, że :temperature jest parametrem Oven.bake

Przepisanie tego przykładu za pomocą operatora rur:

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

daje ten sam wynik, ale kolejność wykonywania jest jaśniejsza. Ponadto jest oczywiste, że :temperature jest parametrem wywołania Oven.bake . Oven.bake .

Zauważ, że podczas korzystania z operatora rur, pierwszy parametr dla każdej funkcji jest przenoszony przed operatorem rury, więc wywoływana funkcja wydaje się mieć jeden mniej parametru. Na przykład:

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

jest taki sam jak:

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

Operator rur i nawiasy

Nawiasy są potrzebne, aby uniknąć dwuznaczności:

foo 1 |> bar 2 |> baz 3

Powinny być zapisane jako:

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

Operatory logiczne

Istnieją dwa rodzaje operatorów logicznych w Elixir:

• operatory logiczne (jako pierwszy argument oczekują wartości true lub 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

Wszystkie operatory logiczne podniosą ArgumentError jeśli pierwszy argument nie będzie wartością wyłącznie logiczną, co oznacza tylko true lub false ( nil nie jest wartością logiczną).

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

• zrelaksowane operatory boolowskie (praca z dowolnym typem, wszystko, co ani false ani nil nie jest uważane za 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

Operator || zawsze zwróci pierwszy argument, jeśli jest prawdziwy (Elixir traktuje wszystko oprócz nil i false jako prawdziwe w porównaniach), w przeciwnym razie zwróci drugi.

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 && zawsze zwróci drugi argument, jeśli jest zgodny z prawdą. W przeciwnym razie powróci odpowiednio do argumentów, false lub 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

Zarówno && i || są operatorami zwarć. Wykonują tylko prawą stronę, jeśli lewa strona nie wystarcza do ustalenia wyniku.

Operator ! zwróci wartość logiczną negacji bieżącego terminu:

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

Prostym sposobem na uzyskanie wartości logicznej wybranego terminu jest po prostu podwojenie tego operatora:

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

Operatory porównania

Równość:

• równość wartości x == y ( 1 == 1.0 # true )
• nierówność wartości x == y ( 1 != 1.0 # false )
• ścisła równość x === y ( 1 === 1.0 # false )
• ścisła nierówność x === y ( 1 !== 1.0 # true )

Porównanie:

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

Jeśli typy są kompatybilne, porównanie wykorzystuje naturalne uporządkowanie. W przeciwnym razie istnieje ogólna zasada porównywania typów:

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

Dołącz do operatorów

Możesz łączyć (konkatenować) pliki binarne (w tym ciągi) i listy:

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"

Operator „In”

in operator pozwala sprawdzić, czy lista lub zakres zawiera element:

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

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