Elixir Language
Conditionnels

Remarques

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"

Cas

 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 est uniquement utilisé pour correspondre au modèle donné des données particulières. Ici, {1,2} correspond à un modèle de cas différent donné dans l'exemple de code.

si et à moins

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 va CondClauseError une CondClauseError si aucune condition n'est vraie.

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

Cela peut être évité en ajoutant une condition qui sera toujours vraie.

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

À moins que l'on ne s'attende jamais à ce qu'il atteigne le cas par défaut, le programme devrait en fait tomber en panne à ce stade.

avec clause

with clause with est utilisée pour combiner des clauses de correspondance. Il semble que nous combinions des fonctions anonymes ou des fonctions de gestion avec plusieurs corps (clauses correspondantes). Considérez le cas: nous créons un utilisateur, l'insérons dans la base de données, puis créons un message électronique d'accueil et l'envoyons à l'utilisateur.

Sans la clause with , nous pourrions écrire quelque chose comme ceci (j'ai omis les implémentations de fonctions):

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

Ici, nous traitons le flux de notre processus métier avec la case (il pourrait être cond ou if ). Cela nous conduit à ce qu'on appelle la «pyramide de malheur» , car nous devons faire face aux conditions possibles et décider: aller plus loin ou non. Il serait beaucoup plus intéressant de réécrire ce code avec with :

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

Dans l'extrait de code ci-dessus, nous avons réécrit les clauses de case imbriquées avec with . Au sein with nous invoquons certaines fonctions (anonymes ou nommés) et correspondance de motif sur leurs sorties. Si tout adapté, with le retour do fait bloc, ou else résultat bloc autrement.

Nous pouvons omettre d' else façon with renverra soit do résultat de bloc ou le premier échec résultat.

Ainsi, la valeur de with instruction est le résultat de son bloc do .