Elixir Language
Conditionals

Bemerkungen

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 wird nur verwendet, um das gegebene Muster der jeweiligen Daten abzugleichen. Hier {1,2} mit unterschiedlichen Fallmustern überein, die im Codebeispiel angegeben sind.

wenn und soweit nicht

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 CondClauseError einen CondClauseError wenn keine Bedingungen erfüllt sind.

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

Dies kann vermieden werden, indem eine Bedingung hinzugefügt wird, die immer wahr ist.

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

Es sei denn, es wird nie erwartet, dass der Standardfall erreicht wird, und das Programm sollte tatsächlich zu diesem Zeitpunkt abstürzen.

mit Klausel

with Klausel wird verwendet, um übereinstimmende Klauseln zu kombinieren. Anscheinend kombinieren wir anonyme Funktionen oder behandeln Funktionen mit mehreren Körpern (übereinstimmende Klauseln). Beachten Sie den Fall: Wir erstellen einen Benutzer, fügen ihn in die Datenbank ein, erstellen eine Begrüßungs-E-Mail und senden sie an den Benutzer.

Ohne die with Klausel könnten wir so etwas schreiben (ich habe Funktionsimplementierungen ausgelassen):

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 haben wir unsere Geschäftsprozesse des Flusses mit Griff case (es könnte sein , cond oder if ). Das führt uns zu einer sogenannten 'Pyramide des Schicksals' , weil wir uns mit möglichen Bedingungen auseinandersetzen müssen und entscheiden müssen, ob wir uns weiter bewegen oder nicht. Es wäre viel schöner, diesen Code with Anweisung neu zu schreiben:

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 dem obigen Code-Snippet haben wir geschachtelte case Klauseln mit with umgeschrieben. Innerhalb with rufen wir einige Funktionen (entweder anonym oder benannt) und Musterübereinstimmung an ihren Ausgaben auf. Wenn alle aufeinander abgestimmt, with Rückkehr do Block - Ergebnis oder else sonst Block Ergebnis.

Wir können weglassen else so with kehren entweder do Block - Ergebnis oder das erste Ergebnis ausfallen.

Der Wert von with Anweisung ist do Ergebnis des do Blocks.