Blackjack

Case (souvent appelé switch dans d'autres langages) est une forme d'expression de contrôle, comme if-else. Un case permet d'enchaîner plusieurs instructions if-else-if et peut être plus lisible tout en assurant le contrôle du flux.

Un case est défini par le mot-clé case suivi d'une expression optionnelle. Ensuite, pour chaque cas, on utilise le mot-clé when suivi d'une expression qui est comparée à l'expression du case. Le mot-clé when ne doit pas être indenté par rapport au mot-clé case. Après le mot-clé when vient le code qui doit être exécuté si l'expression du case correspond à l'expression du when. Le case accepte une instruction else optionnelle, qui est exécutée si aucun autre cas ne correspond.

L'expression du case est évaluée, puis comparée à chaque expression du when. La comparaison se fait à l'aide de l'opérateur d'égalité de case (===).

value = 1
case value
when 1
  "One"
when 2
  "Two"
else
  "Other"
end

# This is the same as:
value = 1
if 1 === value
  "One"
elsif 2 === value
  "Two"
else
  "Other"
end

L'opérateur d'égalité de case (===)

L'opérateur d'égalité de case (===) est un peu différent de l'opérateur d'égalité (==). Il vérifie si l'opérande de droite est un membre de l'ensemble décrit par l'opérande de gauche. Cela signifie que l'ordre des opérandes a son importance. Le fonctionnement dépend du type de l'opérande de gauche : par exemple, un Range vérifie si la valeur de droite appartient à l'intervalle, tandis qu'un Object vérifie si celle de droite est une instance de cet Object.

(1..3) == 1  # => false
(1..3) === 1 # => true

String == "foo"  # => false
String === "foo" # => true

Les case avec plusieurs expressions

Un case permet de faire correspondre plusieurs expressions dans un même cas, chaque valeur possible étant séparée par une virgule. Le code est exécuté si l'une des expressions correspond. C'est utile lorsque tu veux qu'un même cas ait plusieurs valeurs possibles.

case var
when 1, 2
  "One or two"
else
  "Other"
end

Les case avec des intervalles

Un case peut aussi vérifier si une valeur se trouve dans un intervalle. Il suffit pour cela d'utiliser un intervalle comme expression du when.

case var
when 1..3
  puts "One to three"
else
  puts "Other"
end

Les case sans expression de case

Lorsqu'une expression de case n'est pas nécessaire, il est possible de l'omettre. Chaque expression du when est alors évaluée pour sa valeur de vérité, et les cas se comportent comme des instructions if-else-if.

case
when 1 == 1
  "One is equal to one"
when 1 > 2
  "One is greater than two"
else
  "Other"
end

Le when sur une seule ligne

Ruby permet d'écrire des case sur une seule ligne. C'est utile lorsque tu as une instruction simple, elle aussi sur une seule ligne. Le when sur une seule ligne s'écrit when <expression> then <statement>. Et lorsqu'il est utilisé dans le else, il s'écrit else <statement>.

case var
when 1 then "One"
when 2 then "Two"
else "Other"
end

Les case avec des types

Un case permet aussi de faire correspondre des types. C'est utile lorsque tu veux un comportement différent selon le type d'une variable.

case var
when Integer
  "Integer"
when String
  "String"
else
  "Other"
end