Case em

Sobre Case

case (ao qual se chama muitas vezes switch noutras linguagens) é uma forma de expressão de controlo, tal como o if-else. O case permite encadear várias instruções if-else-if, pode ser mais legível e permite 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 com a expressão do case. A palavra-chave when não deve estar indentada em relação à palavra-chave case. A seguir à 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 instrução else opcional, que é executada se nenhum outro caso corresponder.

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

O operador de subsunção de case (===) é um pouco diferente do operador de igualdade (==). O operador verifica se o lado direito é um membro do conjunto descrito pelo lado esquerdo. Isto significa que a posição de cada operando é importante. O funcionamento 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 várias expressões

Os case permitem corresponder a várias expressões num único caso, com cada valor possível separado por uma vírgula. O código é executado se qualquer uma das expressões corresponder. Isto 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

Os case também podem verificar se um valor está num intervalo. Para isso, usa-se 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 é necessária uma expressão de case, é possível omiti-la. Ao fazê-lo, cada expressão passa a ser avaliada pela 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 numa só linha

O Crystal permite instruções case numa só linha. Podes usar isto quando tens uma instrução simples de uma só linha. A forma de uma só linha, no caso do when, escreve-se como when <expression> then <statement>. E, quando usada na instrução else, escreve-se 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 fazer correspondência com tipos. A comparação usa o operador is_a? para verificar o tipo da variável. Por exemplo, isto permite um ramo para cada tipo de um tipo união.

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

Objeto implícito

O case permite usar um objeto implícito. Isto permite, por exemplo, que uma expressão do when seja uma chamada de método sobre a expressão do case. Consoante o método devolva 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 casos exaustivos, o que significa que é possível garantir que todos os valores possíveis são tratados. É semelhante à instrução when, mas com a palavra-chave in em vez de when. Quando um case é exaustivo, não suporta instruções when nem else.

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

Um caso exaustivo significa que todas as possibilidades têm de ser tratadas; caso contrário, será gerado um erro de compilação. Tratar tipos Union como um caso exaustivo é semelhante a um caso não exaustivo.

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

Os Bools podem ser tratados como um caso exaustivo através das palavras-chave true e false.

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