Atténuation de la fusion

Crystal dispose de ce qu'on appelle des expressions de contrôle : elles servent à contrôler la façon dont le programme s'exécute et elles prennent une valeur vraie ou fausse. Il existe des opérateurs qui permettent de créer des valeurs vraies ou fausses : ce sont les opérateurs d'égalité et de comparaison.

Il existe deux expressions de contrôle principales qui déterminent quel code sera exécuté et lequel ne le sera pas. Autrement dit, quelle branche donnée sera exécutée.

Ces deux expressions sont if et unless.

Opérateurs de comparaison

Les opérateurs de comparaison servent à comparer des valeurs et renvoient une valeur true ou false. Ces opérateurs exigent que les deux valeurs comparées soient du même type. Si les valeurs ne sont pas du même type, le compilateur lèvera une erreur. Voici une liste des opérateurs de comparaison, avec un exemple où ils renvoient true :

Opérateurs d'égalité

Les opérateurs d'égalité sont semblables aux opérateurs de comparaison, mais ils servent à vérifier si deux valeurs sont égales ou non.

L'opérateur == vérifie si deux valeurs sont égales, en tenant compte de leur type. Si les valeurs sont identiques, il renvoie true, sinon il renvoie false. L'opérateur == peut comparer n'importe quel type de valeur à n'importe quel autre type de valeur. L'opérateur != fonctionne de la même manière, mais il renvoie true si les valeurs sont différentes et false si elles sont égales.

L'instruction if

L'instruction if sert à vérifier si une condition donnée est vraie ou fausse. Si la condition est vraie, le code à l'intérieur de l'instruction if est exécuté. Une instruction if se termine par le mot-clé end.

if 1 == 1
  puts "1 is equal to 1"
end
# => 1 is equal to 1

if 1 > 2
  puts "1 is greater than 2"
end
# => no output

L'instruction unless

L'instruction unless fonctionne de façon très similaire à l'instruction if, mais elle exécute le code qu'elle contient si la condition est fausse.

unless 1 == 1
  puts "1 is not equal to 1"
end
# => no output

unless 1 > 2
  puts "1 is not greater than 2"
end
# => 1 is not greater than 2

L'instruction else

L'instruction else peut être utilisée conjointement avec les instructions if et unless. L'instruction else est exécutée si la branche if ou la branche unless n'est pas exécutée.

Même si une branche `else` peut être utilisée conjointement avec `unless,`, c'est déconseillé, car cela nuit à la lisibilité.
À la place, il est recommandé d'utiliser `if !condition` avec une branche else.

if 1 == 1
  puts "1 is equal to 1"
else
  puts "1 is not equal to 1"
end
# => 1 is equal to 1

unless 1 < 2
  puts "1 is not greater than 2"
else
  puts "1 is greater than 2"
end
# => 1 is greater than 2

Les instructions if en cascade

L'instruction elsif peut être utilisée conjointement avec l'instruction if. L'instruction elsif est exécutée si la branche if ne l'est pas et que la condition de l'instruction elsif est vraie. Les instructions elsif peuvent être enchaînées, et la première condition vraie sera exécutée. Une instruction else peut également figurer à la fin de l'instruction if : elle s'exécutera si aucune des instructions précédentes n'était vraie.

if 1 != 1
  puts "1 is not equal to 1"
elsif 1 > 2
  puts "1 is greater than 2"
else
  puts "1 is not equal to 1 and 1 is not greater than 2"
end
# => 1 is not equal to 1 and 1 is not greater than 2

Les types avec les conditions

Quand elle reçoit des valeurs de types différents, la variable porte les deux types. C'est parce que le compilateur ne sait pas quelle branche sera exécutée. Cette affectation multiple, aussi appelée union, sera expliquée dans des concepts ultérieurs. L'exemple suivant l'illustre :

if 1 == 1
  a = 1
else
  a = "1"
end

typeof(a) # => Int32 | String

L'opérateur ternaire

Crystal dispose d'un opérateur ternaire, une instruction if-else sur une seule ligne : condition ? expression_if_truthy : expression_if_falsey

1 == 1 ? puts("1 is equal to 1") : puts("1 is not equal to 1")
# => 1 is equal to 1