BlackJack

Case (muitas vezes 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 e pode ser mais legível, sem deixar de oferecer controle de fluxo.

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 ficar 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 instrução 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 com o operador de igualdade de case (===).

value = 1
case value
when 1
  "One"
when 2
  "Two"
else
  "Other"
end

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

Operador de igualdade de case (===)

O operador de igualdade de case (===) é um pouco diferente do operador de igualdade (==). Ele verifica se o lado direito é um membro do conjunto descrito pelo lado esquerdo. Isso significa que a posição de cada operando importa. 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 múltiplas expressões

Os cases permitem corresponder a várias expressões em um único case, com cada valor possível separado por vírgula. O código é executado se qualquer uma das expressões corresponder. Isso pode ser útil quando você quer que um único case tenha vários valores possíveis.

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

Case com intervalos

Os cases também podem verificar se um valor está em um intervalo. Para isso, basta usar 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 de case, é possível omiti-la. Assim, cada expressão de case é avaliada quanto à sua veracidade, o que faz com que se comportem como instruções if-else-if.

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

When em uma linha

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

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

Case com tipos

O case permite fazer correspondência com tipos. Isso é útil quando você quer comportamentos diferentes dependendo do tipo de uma variável.

case var
when Integer
  "Integer"
when String
  "String"
else
  "Other"
end