Case en

Acerca de Case

case (a menudo llamado switch en otros lenguajes) es una forma de expresión de control como if-else. case permite encadenar varias sentencias if-else-if, puede ser más legible y permite construcciones potentes.

Un case se define con la palabra clave case seguida de una expresión opcional. Luego, 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 tener sangría respecto de 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. case permite una sentencia 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 comparación se hace con 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 diferente del operador de igualdad (==). El operador verifica si el lado derecho es un miembro del conjunto que describe 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 verificaría si el lado derecho está en el rango, o un Object verificarí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

case permite hacer coincidir varias expresiones en un solo caso, con cada valor posible separado por una coma. Ejecutará el código si alguna de las expresiones coincide. Esto puede ser ú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 verificar si un valor está en un rango. Esto se logra 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 de caso

Cuando no se necesita una expresión de caso, es posible omitirla. Al hacerlo, cada expresión del when se evalúa según su valor de verdad. Y hace que se comporten como sentencias 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 sentencias case de una sola línea. Esto se puede usar cuando tienes una sentencia simple de una sola línea. El when de una sola línea se escribe como when <expression> then <statement>. Y cuando se usa en la sentencia 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 coincidencias con tipos. La comparación usará el operador is_a? para verificar el tipo de la variable. Por ejemplo, esto permite una rama para cada tipo en 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 asegurarse de que se manejen todos los valores posibles. Es similar a la sentencia when, pero con la palabra clave in en lugar de when. Cuando un case es exhaustivo, no admite sentencias when ni else.

Los casos exhaustivos se pueden usar con Bools, tipos Union, Enum y Tuples. Los dos últimos se verán en conceptos posteriores.

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

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

Los Bools se pueden manejar como un caso exhaustivo usando las palabras clave true y false.

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