Elixir Language
operators

De pijpexploitant

De pijpexploitant |> neemt het resultaat van een uitdrukking aan de linkerkant en voert deze als de eerste parameter naar een functie aan de rechterkant.

expression |> function

Gebruik de Pipe Operator om expressies aan elkaar te koppelen en de stroom van een reeks functies visueel te documenteren.

Stel je de volgende situatie voor:

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

In het voorbeeld komt Oven.bake voor Ingredients.mix , maar wordt het als laatste uitgevoerd. Ook is het misschien niet duidelijk dat :temperature een parameter is van Oven.bake

Dit voorbeeld herschrijven met behulp van de Pipe Operator:

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

geeft hetzelfde resultaat, maar de volgorde van uitvoering is duidelijker. Verder is het duidelijk dat :temperature een parameter is voor de Oven.bake oproep.

Merk op dat bij gebruik van de pijpexploitant de eerste parameter voor elke functie wordt verplaatst naar vóór de pijpexploitant, en dus lijkt de opgeroepen functie een parameter minder te hebben. Bijvoorbeeld:

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

is hetzelfde als:

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

Pijpoperator en haakjes

Haakjes zijn nodig om dubbelzinnigheid te voorkomen:

foo 1 |> bar 2 |> baz 3

Moet worden geschreven als:

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

Booleaanse operatoren

Er zijn twee soorten booleaanse operatoren in Elixir:

• booleaanse operatoren (ze verwachten true of false als hun eerste 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

Alle booleans-operators zullen ArgumentError opwerpen als het eerste argument niet strikt Booleaanse waarde is, wat alleen true of false ( nil is niet Booleaans).

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

• ontspannen booleaanse operatoren (werk met elk type, alles dat noch false noch nil als true wordt beschouwd)

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 || zal altijd het eerste argument retourneren als het waar is (Elixir behandelt alles behalve nil en false om waar te zijn in vergelijkingen), anders zal het tweede argument terugkeren.

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 && retourneert altijd het tweede argument als het waar is. Anders keren respectievelijk terug naar de argumenten, false of 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

Zowel && als || zijn kortsluiting exploitanten. Ze voeren alleen de rechterkant uit als de linkerkant niet genoeg is om het resultaat te bepalen.

Operator ! retourneert Booleaanse waarde van ontkenning van huidige term:

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

Eenvoudige manier om de Booleaanse waarde van de geselecteerde term te krijgen, is deze operator eenvoudig te verdubbelen:

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

Vergelijkingsoperatoren

Gelijkheid:

• waarde gelijkheid x == y ( 1 == 1.0 # true )
• waarde ongelijkheid x == y ( 1 != 1.0 # false )
• strikte gelijkheid x === y ( 1 === 1.0 # false )
• strikte ongelijkheid x === y ( 1 !== 1.0 # true )

Vergelijking:

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

Als types compatibel zijn, maakt vergelijking gebruik van natuurlijke ordening. Anders is er een algemene regel voor het vergelijken van typen:

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

Word lid van operators

U kunt binaire bestanden (inclusief tekenreeksen) en lijsten samenvoegen (samengevoegd):

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 kunt u controleren of een lijst of bereik een item bevat:

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

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