Blackjack

case (spesso chiamato «switch» in altri linguaggi) è una forma di espressione di controllo come if-else. case permette di concatenare più istruzioni if-else-if, può essere più leggibile e consente costrutti potenti.

Un case è definito dalla parola chiave case seguita da un'espressione facoltativa. Poi, per ogni caso, si usa la parola chiave when seguita da un'espressione che viene confrontata con l'espressione del case. La parola chiave when non deve essere indentata rispetto alla parola chiave case. Dopo la parola chiave when c'è il codice che deve essere eseguito se l'espressione del case corrisponde all'espressione del when. Il case consente un'istruzione else facoltativa, che viene eseguita se nessun altro caso corrisponde.

L'espressione del case viene valutata e poi confrontata con ogni espressione dei when. Il confronto avviene usando l'operatore di sussunzione del 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

Operatore di sussunzione del case (===)

L'operatore di sussunzione del case (===) è un po' diverso dall'operatore di uguaglianza (==). L'operatore verifica se il lato destro è un membro dell'insieme descritto dal lato sinistro. Questo significa che conta dove viene posizionato ciascun operando. Come funziona dipende dal tipo del lato sinistro: per esempio, un Range verifica se il lato destro è nell'intervallo, mentre un Object verifica se il lato destro è un'istanza di Object.

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

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

Case con più espressioni

I case permettono di far corrispondere più espressioni in un unico case, con ogni valore possibile separato da una virgola. Il codice viene eseguito se una qualsiasi delle espressioni corrisponde. Può essere utile per un singolo case con più valori possibili.

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

Case con gli intervalli

I case possono anche verificare se un valore è in un intervallo. Per farlo, si usa un intervallo come espressione del when.

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

Case senza espressione del case

Quando non serve un'espressione del case, è possibile ometterla. In questo modo, ogni espressione dei when viene valutata in base alla sua veridicità. E li fa comportare come istruzioni 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 su una sola riga

Crystal consente istruzioni case su una sola riga. Si può usare quando si ha un'istruzione semplice su una sola riga. La forma su una sola riga dell'istruzione si scrive come when <expression> then <statement>. E quando si usa nell'istruzione else, si scrive come else <statement>.

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

Case con i tipi

Il case permette di far corrispondere dei tipi. Il confronto userà l'operatore is_a? per verificare il tipo della variabile. Per esempio, questo permette di avere un ramo per ogni tipo in un tipo unione.

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

Oggetto implicito

Il case permette l'uso di un oggetto implicito. Questo permette, per esempio, che un'espressione del when sia una chiamata a un metodo sull'espressione del case. A seconda che il metodo restituisca un valore vero o falso, il caso corrisponderà oppure no.

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