Elixir Language
Operatoren

Der Pipe Operator

Der Pipe-Operator |> nimmt das Ergebnis eines Ausdrucks auf der linken Seite und führt ihn als ersten Parameter einer Funktion auf der rechten Seite zu.

expression |> function

Verwenden Sie den Pipe Operator, um Ausdrücke miteinander zu verketten und den Fluss einer Reihe von Funktionen visuell zu dokumentieren.

Folgendes berücksichtigen:

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

In dem Beispiel steht Oven.bake vor Ingredients.mix , wird jedoch zuletzt ausgeführt. Es kann auch nicht offensichtlich sein, dass :temperature ein Parameter von Oven.bake

Dieses Beispiel mit dem Pipe Operator neu schreiben:

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

gibt das gleiche Ergebnis, aber die Reihenfolge der Ausführung ist klarer. Außerdem ist klar :temperature ist ein Parameter für den Aufruf von Oven.bake .

Beachten Sie, dass bei Verwendung des Pipe-Operators der erste Parameter für jede Funktion vor dem Pipe-Operator verschoben wird, und die aufgerufene Funktion scheint einen Parameter weniger zu haben. Zum Beispiel:

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

ist das gleiche wie:

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

Rohrbediener und Klammern

Klammern sind erforderlich, um Mehrdeutigkeiten zu vermeiden:

foo 1 |> bar 2 |> baz 3

Sollte geschrieben werden als:

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

boolesche Operatoren

Es gibt zwei Arten von booleschen Operatoren in Elixir:

• boolesche Operatoren (sie erwarten als erstes Argument entweder true oder 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

Alle booleschen Operatoren lösen ArgumentError wenn das erste Argument kein strikt boolescher Wert ist, dh nur true oder false ( nil ist nicht boolean).

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

• Entspannte boolesche Operatoren (arbeiten mit jedem Typ, alles, was weder false noch nil ist, wird als 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

Betreiber || wird immer das erste Argument zurückgeben, wenn es wahr ist (Elixir behandelt alles außer nil und false , um bei Vergleichen wahr zu sein), andernfalls wird das zweite zurückgegeben.

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 && gibt immer das zweite Argument zurück, wenn es wahr ist. Andernfalls kehren die Argumente false bzw. 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

Sowohl && als auch || sind Kurzschlussoperatoren. Sie führen die rechte Seite nur dann aus, wenn die linke Seite nicht ausreicht, um das Ergebnis zu bestimmen.

Betreiber ! gibt den booleschen Wert der Negation des aktuellen Begriffs zurück:

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

Ein einfacher Weg, um den booleschen Wert des ausgewählten Begriffs zu erhalten, besteht darin, diesen Operator einfach zu verdoppeln:

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

Vergleichsoperatoren

Gleichberechtigung:

• Wertgleichheit x == y ( 1 == 1.0 # true )
• Wertungleichheit x == y ( 1 != 1.0 # false )
• strikte Gleichheit x === y ( 1 === 1.0 # false )
• strikte Ungleichung x === y ( 1 !== 1.0 # true )

Vergleich:

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

Wenn Typen kompatibel sind, verwendet der Vergleich eine natürliche Reihenfolge. Ansonsten gibt es eine allgemeine Typenvergleichsregel:

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

Operator beitreten

Sie können Binärdateien (einschließlich Zeichenfolgen) und Listen verknüpfen (verketten):

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' Operator

in Operator können Sie prüfen, ob eine Liste oder ein Bereich ein Element enthält:

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

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