Elixir Language
villkors

Anmärkningar

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"

fall

 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 används endast för att matcha det givna mönstret för den specifika datan. Här är {1,2} matchande med olika fallmönster som ges i kodexemplet.

om och om inte

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 höjer en CondClauseError om inga villkor är sanna.

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

Detta kan undvikas genom att lägga till ett villkor som alltid kommer att vara sant.

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

Såvida det aldrig förväntas nå standardfallet, och programmet bör faktiskt krascha vid den punkten.

med klausul

with klausul används för att kombinera matchande klausuler. Det ser ut som att vi kombinerar anonyma funktioner eller hanterar funktion med flera organ (matchande klausuler). Tänk på fallet: vi skapar en användare, sätter in den i DB, skapar sedan hälsningsmeddelande och skickar sedan till användaren.

Utan with klausulen kan vi skriva något liknande (jag utelämnade funktioner implementationer):

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

Här hanterar vi vår affärsprocesss flöde med case (det kan vara cond eller if ). Det leder oss till den så kallade "undergångspyramiden" , eftersom vi måste ta itu med möjliga förhållanden och besluta: huruvida vi ska gå vidare eller inte. Det skulle vara mycket trevligare att skriva om denna kod med with uttalande:

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

I koden utdrag ovan vi har omskrivnings kapslade case klausuler med with . Inom with åberopar vi vissa funktioner (antingen anonyma eller namngivna) och mönster matchar på deras utgångar. Om allt matchas with retur do blockera resultat eller else blockera resultatet annars.

Vi kan utelämna else så with kommer att återvända antingen do blockera resultat eller den första misslyckas resultatet.

Så är värdet av with uttalande dess do block-resultat.