Case en

Acerca de Case

case (al que a menudo se hace referencia como switch en otros lenguajes) es una forma de expresión de control como if-else. case permite encadenar varias instrucciones if-else-if, puede ser más legible y permite crear construcciones potentes.

Un case se define con la palabra clave case seguida de una expresión opcional. Después, para cada caso se usa la palabra clave when seguida de una expresión que se compara con la expresión del case. La palabra clave when no debe estar indentada respecto a la palabra clave case. Después de la palabra clave when va el código que debe ejecutarse si la expresión del case coincide con la expresión del when. Un case admite una instrucción else opcional que se ejecuta si ningún otro caso coincide.

La expresión del case se evalúa y luego se compara con cada expresión del when. La expresión se compara usando el operador de subsunción de case (===).

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

Operador de subsunción de case (===)

El operador de subsunción de case (===) es un poco distinto del operador de igualdad (==). El operador comprueba si el lado derecho es un miembro del conjunto descrito por el lado izquierdo. Esto significa que sí importa dónde se coloca cada operando. Cómo funciona depende del tipo del lado izquierdo; por ejemplo, un Range comprobaría si el lado derecho está dentro del rango, o un Object comprobaría si el lado derecho es una instancia de Object.

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

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

case con varias expresiones

Los case permiten hacer coincidir varias expresiones en un mismo caso, con cada valor posible separado por una coma. Ejecutará el código si alguna de las expresiones coincide. Esto puede resultar útil para un solo caso con varios valores posibles.

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

case con rangos

Los case también pueden comprobar si un valor está dentro de un rango. Esto se consigue usando un rango como expresión del when.

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

case sin expresión

Cuando no se necesita una expresión de case, es posible omitirla. Si lo haces, cada expresión se evaluará según si es verdadera o falsa. Y hará que se comporten como instrucciones 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

when en una sola línea

Crystal permite instrucciones case de una sola línea. Esto puede usarse cuando tienes una instrucción simple de una sola línea. La instrucción de una sola línea se escribe como when <expression> then <statement>. Y cuando se usa en la instrucción else, se escribe como else <statement>.

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

case con tipos

case permite hacer coincidir tipos. La comparación usará el operador is_a? para comprobar el tipo de la variable. Por ejemplo, esto permite una rama para cada tipo de un tipo unión.

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

Objeto implícito

case permite usar un objeto implícito. Esto permite, por ejemplo, que una expresión del when sea una llamada a un método sobre la expresión del case. Según si el método devuelve un valor verdadero o falso, el caso coincidirá o no.

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

case exhaustivo

case permite casos exhaustivos, lo que significa que es posible garantizar que se contemplen todos los valores posibles. Es similar a la instrucción when, pero con la palabra clave in en lugar de when. Cuando un case es exhaustivo, no admite instrucciones when ni else.

Los case exhaustivos pueden usarse con Bools, tipos Union, Enum y Tuples. Los dos últimos se tratarán en conceptos posteriores.

Los case exhaustivos implican que deben contemplarse todas las posibilidades; de lo contrario, se producirá un error de compilación. Tratar tipos Union como un case exhaustivo es similar a un case no exhaustivo.

var : (Int32 | String | Bool)
case var 
in Int32
  puts "Int32"
in String
  puts "String"
in Bool
  puts "Bool"
end

Los Bools pueden tratarse como un case exhaustivo usando las palabras clave true y false.

var : Bool
case var
in true
  puts "True"
in false
  puts "False"
end