Case em

Sobre Case

case (frequentemente chamado de switch em outras linguagens) é uma forma de expressão de controle como o if-else. O case permite encadear várias instruções if-else-if, pode ser mais legível e possibilita construções poderosas.

Um case é definido pela palavra-chave case seguida de uma expressão opcional. Depois, para cada caso, usa-se a palavra-chave when, seguida de uma expressão que é comparada à expressão do case. A palavra-chave when não deve ser indentada em relação à palavra-chave case. Depois da palavra-chave when vem o código que deve ser executado se a expressão do case corresponder à expressão do when. O case permite uma cláusula else opcional, que é executada se nenhum outro caso corresponder.

A expressão do case é avaliada e depois comparada a cada expressão do when. A comparação é feita usando o operador de subsunção do 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 subsunção do case (===)

O operador de subsunção do case (===) é um pouco diferente do operador de igualdade (==). O operador verifica se o lado direito é um membro do conjunto descrito pelo lado esquerdo. Isso significa que a posição de cada operando faz diferença. Como isso funciona depende do tipo do lado esquerdo. Por exemplo, um Range verifica se o lado direito está no intervalo, e um Object verifica se o lado direito é uma instância do Object.

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

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

Case com múltiplas expressões

O case permite corresponder várias expressões em um único caso, com cada valor possível separado por vírgula. Ele executa o código se qualquer uma das expressões corresponder. Isso pode ser útil para um único caso com vários valores possíveis.

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

Case com intervalos

O case também pode verificar se um valor está em um intervalo. Isso é feito usando um intervalo como expressão do when.

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

Case sem expressão de case

Quando não há necessidade de uma expressão do case, é possível omiti-la. Isso faz com que cada expressão do when seja avaliada quanto à sua veracidade. E faz com que se comportem como instruções 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 em uma única linha

O Crystal permite instruções case de uma única linha. Isso pode ser usado quando você tem uma instrução simples de uma única linha. A instrução de uma linha é escrita como when <expression> then <statement>. E, quando usada na cláusula else, é escrita como else <statement>.

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

Case com tipos

O case permite correspondência com tipos. A comparação usa o operador is_a? para verificar o tipo da variável. Por exemplo, isso permite um bloco para cada tipo em um tipo união.

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

Objeto implícito

O case permite o uso de um objeto implícito. Isso permite, por exemplo, que uma expressão do when seja uma chamada de método na expressão do case. Dependendo de o método retornar um valor verdadeiro ou falso, o caso corresponderá ou não.

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

Case exaustivo

O case permite cases exaustivos, o que significa que é possível garantir que todos os valores possíveis sejam tratados. É semelhante à instrução when, mas com a palavra-chave in em vez de when. Quando um case é exaustivo, ele não aceita nenhuma cláusula when ou else.

Cases exaustivos podem ser usados com Bools, tipos Union, Enum e Tuples. Os dois últimos serão abordados em conceitos posteriores.

Cases exaustivos significam que todas as possibilidades devem ser tratadas; caso contrário, um erro de compilação será gerado. Tratar tipos Union como um case exaustivo é semelhante a um case não exaustivo.

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

Bools podem ser tratados como um case exaustivo usando as palavras-chave true e false.

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