Elixir Language
Warunkowe

Uwagi

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"

walizka

 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

wielkość case jest używana tylko do dopasowania podanego wzorca określonych danych. Tutaj {1,2} odpowiada różnemu wzorowi wielkości liter podanemu w przykładzie kodu.

jeśli i chyba

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

war

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 zgłasza CondClauseError jeśli nie są spełnione żadne warunki.

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

Można tego uniknąć, dodając warunek, który zawsze będzie prawdziwy.

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

Chyba że nigdy nie oczekuje się, że osiągnie domyślny przypadek, a program w rzeczywistości powinien się zawiesić w tym momencie.

z klauzulą

with klauzulą służy do łączenia pasujących klauzul. Wygląda na to, że łączymy funkcje anonimowe lub obsługujemy funkcję z wieloma obiektami (dopasowane zdania). Rozważmy przypadek: tworzymy użytkownika, wstawiamy go do DB, następnie tworzymy e-mail z pozdrowieniami, a następnie wysyłamy do użytkownika.

Bez klauzuli with moglibyśmy napisać coś takiego (pominąłem implementacje funkcji):

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

Tutaj zajmujemy się przepływem naszego procesu biznesowego ze case (może to być cond lub if ). To prowadzi nas do tak zwanej „piramidy zagłady” , ponieważ musimy poradzić sobie z możliwymi warunkami i zdecydować: czy iść dalej, czy nie. O wiele lepiej byłoby przepisać ten kod za with instrukcji:

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

W powyższym fragmencie kodu przepisujemy zagnieżdżone klauzule case with . Wewnątrz with wzywamy niektórych funkcji (zarówno anonimowych lub nazwie) i wzorzec spotkanie na swoich wyjściach. Jeśli wszystko dopasowane, with powrotem do wynik bloku lub else rezultatu bloku inaczej.

Możemy pominąć else tak with powróci albo do wynik bloku lub wynik pierwszym niepowodzeniem.

Tak więc wartością instrukcji with jest wynik do bloku.