Ruby doesn’t have a switch statement, unlike other programming languages. Instead, there’s the case expression, which is much versatile and powerful than a switch.
A case expression in ruby consists of three parts.
case: The variable we are going to match.when: A condition to match.else: The default choice.
size = 10
case size
when 0
puts "Small size"
when 10
puts "Medium size"
when 20
puts "Large size"
else
puts "Invalid size"
end
Because case is a statement, you can assign its value to a variable.
size = 10
message = case size
when 0
"Small size"
when 10
"Medium size"
when 20
"Large size"
else
"Invalid size"
end
puts message # Medium size
It’s also possible to match ruby symbols in a case statement.
size = :small
message = case size
when :small
"Small size"
when :medium
"Medium size"
when :large
"Large size"
else
"Invalid size"
end
puts message # Small size
In a case expression, ruby compares the value in the when clause with the value in the case clause using the === operator. The order of comparison is important. In the above example, ruby compares :small === size, not size === :small.
You might wonder what difference the order would make, but this allows ruby to do pretty sophisticated comparisons using Ranges, classes, regular expressions, etc. Let’s consider an example that illustrates this.
Ruby defines the === operator such that it returns true when you use it with a class as the first operand and the instance as the second operand. That is, String === "" returns true, however "" === String returns false. This allows us to use a case statement to figure out the type of a variable, as follows:
obj = 10
case obj
when String
puts "It's a string"
when Fixnum
puts "It's a number"
else
puts "It's neither a string nor a number"
end
# It's a number
You can also match multiple values separated by a comma in a single when. In a case statement, a comma , is equivalent to || in an if statement.
val = 3
case val
when 1, 4, 9
puts "It's a square"
when 2, 3, 5, 6, 7, 8
puts "Not a square"
end
# Not a square
Here’s a pretty sophisticated example from Dave Thomas’s classic book “Programming Ruby” that shows the power of ruby’s case expression.
case inputLine
when "debug"
dumpDebugInfo
dumpSymbols
when /p\s+(\w+)/
dumpVariable($1)
when "quit", "exit"
exit
else
print "Illegal command: #{inputLine}"
end
An important difference with the switch statement in other languages is that case doesn’t have a fall-through, so you don’t need to use a break statement after the end of each block.