Blackjack

case (souvent appelé switch dans d'autres langages) est une forme d'expression de contrôle, comme if-else. case permet d'enchaîner plusieurs instructions if-else-if, ce qui peut être plus lisible, et autorise des constructions puissantes.

Un case est défini par le mot-clé case, suivi d'une expression facultative. Ensuite, pour chaque cas, on utilise le mot-clé when, suivi d'une expression que l'on compare à 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 à exécuter si l'expression du case correspond à l'expression du when. case accepte une instruction else facultative, qui est exécutée si aucun autre cas ne correspond.

L'expression du case est évaluée, puis comparée à chaque expression when. La comparaison utilise l'opérateur de subsomption (===).

case 1
when 1
  puts "One"
when 2
  puts "Two"
else
  puts "Other"
end
# => One

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

L'opérateur de subsomption (===)

L'opérateur de subsomption (===) est un peu différent de l'opérateur d'égalité (==). Cet opérateur 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 dans lequel les opérandes sont placés a son importance. Le fonctionnement dépend du type de l'opérande de gauche : par exemple, un Range vérifie si l'opérande de droite se trouve dans l'intervalle, tandis qu'un Object vérifie si l'opérande de droite est une instance de Object.

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

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

Le case avec plusieurs expressions

Un case permet de faire correspondre plusieurs expressions dans un seul 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 pour un même cas ayant plusieurs valeurs possibles.

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

Le case avec des intervalles

Un case peut aussi vérifier qu'une valeur se trouve dans un intervalle. Pour cela, on utilise un intervalle comme expression when.

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

Le case sans expression

Quand l'expression du case n'est pas nécessaire, il est possible de l'omettre. Chaque expression when est alors évaluée pour sa valeur de vérité, ce qui les fait se comporter comme des instructions if-else-if.

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

Le when sur une seule ligne

Crystal autorise les instructions case sur une seule ligne. C'est utile lorsque l'instruction tient sur une ligne simple. La forme sur une seule ligne s'écrit when <expression> then <statement>. Et dans l'instruction else, elle s'écrit else <statement>.

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

Le case avec des types

case permet de faire correspondre des types. La comparaison utilise l'opérateur is_a? pour vérifier le type de la variable. Cela permet par exemple d'avoir une branche pour chaque type d'un type union.

case var
when Int32
  puts "Int32"
when String
  puts "String"
else
  puts "Other"
end

L'objet implicite

case permet d'utiliser un objet implicite. Une expression when peut alors être, par exemple, un appel de méthode sur l'expression du case. Selon que la méthode renvoie une valeur considérée comme vraie ou comme fausse, le cas correspond ou non.

case 1
when .odd?
  puts "Odd"
when .even?
  puts "Even"
end