Elixir Language
Voorwaardelijke

Opmerkingen

unless false, do: IO.puts("Condition is false")
# Outputs "Condition is false"

# With an `else`:
if false, do: IO.puts("Condition is true"), else: IO.puts("Condition is false")
# Outputs "Condition is false"

geval

 case {1, 2} do
  {3, 4} ->
    "This clause won't match."
  {1, x} ->
    "This clause will match and bind x to 2 in this clause."
  _ ->
    "This clause would match any value."
end

case wordt alleen gebruikt om overeen te komen met het gegeven patroon van de specifieke gegevens. Hier komt {1,2} overeen met een ander casuspatroon dat in het codevoorbeeld wordt gegeven.

als en tenzij

if true do
    "Will be seen since condition is true."
end    

if false do
    "Won't be seen since condition is false."
else
    "Will be seen.
end

unless false do
    "Will be seen."
end

unless true do 
    "Won't be seen."
else
    "Will be seen."
end

cond

cond do 
   0 == 1 -> IO.puts "0 = 1"
   2 == 1 + 1 -> IO.puts "1 + 1 = 2" 
   3 == 1 + 2 -> IO.puts "1 + 2 = 3" 
end

# Outputs "1 + 1 = 2" (first condition evaluating to true)

cond zal een CondClauseError als er geen voorwaarden zijn CondClauseError .

cond do
  1 == 2 -> "Hmmm"
  "foo" == "bar" -> "What?"
end
# Error

Dit kan worden voorkomen door een voorwaarde toe te voegen die altijd waar zal zijn.

cond do
  ... other conditions
  true -> "Default value"
end

Tenzij het nooit wordt verwacht het standaardgeval te bereiken, en het programma zou eigenlijk moeten crashen op dat punt.

met clausule

with clausule wordt gebruikt om overeenkomende clausules te combineren. Het lijkt erop dat we anonieme functies combineren of de functie afhandelen met meerdere instanties (overeenkomende clausules). Overweeg het geval: we maken een gebruiker, voegen deze in DB in, maken vervolgens begroetings-e-mail en verzenden deze naar de gebruiker.

Zonder de with clausule zouden we zoiets kunnen schrijven (ik heb functies-implementaties weggelaten):

case create_user(user_params) do
  {:ok, user} ->
    case Mailer.compose_email(user) do
      {:ok, email} ->
        Mailer.send_email(email)
      {:error, reason} ->
        handle_error
    end
  {:error, changeset} ->
    handle_error
end

Hier behandelen we de stroom van ons bedrijfsproces met case (het kan cond of if ). Dat leidt ons naar de zogenaamde 'pyramide van de ondergang' , omdat we te maken hebben met mogelijke omstandigheden en beslissen: of we verder gaan of niet. Het zou veel leuker zijn om deze code te herschrijven with statement:

with {:ok, user} <- create_user(user_params),
     {:ok, email} <- Mailer.compose_email(user) do
  {:ok, Mailer.send_email}
else
  {:error, _reason} ->
    handle_error
end

In het bovenstaande codefragment herschrijven we geneste case clausules met with . Binnen with roepen we enkele functies (ofwel anonieme of genoemd) en het patroon wedstrijd op hun uitgangen. Als alles afgestemd, with terugkeer do blok resultaat, of else blokkeren resultaat anders.

We kunnen else weglaten else dus with retourneert u do blokresultaat of het eerste mislukte resultaat.

De waarde van with statement is dus het do block-resultaat.