Elixir Language
operatörer

Röroperatören

Röroperatören |> tar resultatet av ett uttryck till vänster och matar det som den första parametern till en funktion till höger.

expression |> function

Använd röroperatören för att kedja uttryck tillsammans och för att visuellt dokumentera flödet av en serie funktioner.

Tänk på följande:

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

I exemplet kommer Oven.bake före Ingredients.mix , men den körs senast. Det kanske inte är uppenbart att :temperature är en parameter för Oven.bake

Omskriva detta exempel med Pipe Operator:

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

ger samma resultat, men exekveringsordningen är tydligare. Dessutom är det tydligt att :temperature är en parameter för Oven.bake samtalet.

Observera att när du använder röroperatören flyttas den första parametern för varje funktion till före röroperatören, så att den funktion som kallas verkar ha en färre parameter. Till exempel:

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

är det samma som:

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

Röroperatör och parenteser

Pareteser behövs för att undvika tvetydighet:

foo 1 |> bar 2 |> baz 3

Bör skrivas som:

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

Booleska operatörer

Det finns två typer av booleska operatörer i Elixir:

• booleska operatörer (de förväntar sig antingen true eller false som deras första 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

Alla booleaska operatörer kommer att höja ArgumentError om det första argumentet inte är strikt booleskt värde, vilket bara betyder true eller false ( nil är inte booleskt).

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

• avslappnade booleska operatörer (arbetar med någon typ, allt som varken false eller nil anses vara 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

Operatör || kommer alltid att återvända första argumentet om det är sant (Elixir behandlar allt utom nil och false att vara sant i jämförelser), annars kommer den andra att återvända.

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

Operatör && kommer alltid att returnera det andra argumentet om det är sant. Annars återgår respektive till argumenten, false eller 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

Både && och || är kortslutningsoperatörer. De kör bara höger sida om vänster sida inte är tillräckligt för att bestämma resultatet.

Operatör ! kommer att returnera det booleska värdet av avveckling av nuvarande term:

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

Enkelt sätt att få booleskt värde på vald term är att helt enkelt fördubbla denna operatör:

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

Jämförelseoperatörer

Jämlikhet:

• värde jämlikhet x == y ( 1 == 1.0 # true )
• värde ojämlikhet x == y ( 1 != 1.0 # false )
• strikt jämlikhet x === y ( 1 === 1.0 # false )
• strikt ojämlikhet x === y ( 1 !== 1.0 # true )

Jämförelse:

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

Om typer är kompatibla använder jämförelsen naturlig beställning. Annars finns det allmänna typer av jämförelseregel:

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

Gå med operatörer

Du kan gå med (sammanfoga) binärer (inklusive strängar) och listor:

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" -operatör

in operatören kan du kontrollera om en lista eller ett intervall innehåller ett objekt:

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

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