Blackjack

O case (referido frequentemente como switch noutras linguagens) é uma forma de expressão de controlo, como o if-else. O case permite encadear várias instruções if-else-if e pode ser mais legível, mantendo ainda o controlo do fluxo.

Um case é definido pela palavra-chave case, seguida de uma expressão opcional. Depois, para cada case, 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 case corresponder.

A expressão do case é avaliada e depois comparada com 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 (==). O operador verifica se o lado direito é 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 cases permitem corresponder a várias expressões num único case, com cada valor possível separado por uma vírgula. O código é executado se alguma das expressões corresponder. Isto pode ser útil quando queres 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á 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

Quando não é precisa uma expressão do case, é possível omiti-la. Assim, cada expressão do case é avaliada quanto à sua veracidade. E 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 numa só linha

O Ruby permite instruções case numa só linha. Isto pode ser usado quando tens uma instrução simples de uma linha. A instrução when de uma linha escreve-se como when <expression> then <statement>. E, quando usada na instrução else, escreve-se como else <statement>.

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

Case com tipos

O case permite corresponder a tipos. Isto é útil quando queres comportamentos diferentes consoante o tipo de uma variável.

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