Case

In Ruby a case-statement tests values. The statement matches the value of a variable against ranges and other values. And it yields a specified value.

Ranges, expressions

Case is an alternative syntax form to the if-statement. We use ranges, strings and numbers with cases. We can assign or return the case's result.

Number example

This is the simplest case example. In the case, we use simple number "when" statements. For example, we return 400 when the value equals 4.

value = 5

# Use case with numbers, no ranges.
result = case value
    when 4 then 400
    when 5 then 500
    when 6 then 600
    else 0
end

# Display input and output.
puts value
puts result
5
500

Range example

Here we use case in a method. The method test() returns the value from a case-statement evaluation. It returns the strings Low, Medium or High based on the parameter.

# Test method.
def test(quality)
    # Return a case.
    return case quality
        when 0..2 then "Low"
        when 3..5 then "Medium"
        when 6..8 then "High"
        else "Invalid"
    end
end

# Call test method.
print test(0), "\n"
print test(4), "\n"
print test(8), "\n"
print test(-1), "\n"
Low
Medium
High
Invalid

String

A string can be used in a case. In this example, we use a string in a case expression, and then assign an integer to the result. The case evaluates to the value 2.

# The value.
name = "sam"

# Assign to result of string case expression.
id = case name
    when "edna" then 0
    when "fred" then 1
    when "sam" then 2
    else 3
end

# Display result.
puts id
2

When

This can have multiple values in it. Here we see a when statement that matches if the variable equals 100 or 200. This syntax form is a good choice when a range is unnecessary.

apartment = 200

case apartment
    when 100, 200
        # Has two possible matching values.
        puts "100 or 200"
    when 0
        puts "Zero"
end
100 or 200

Regexp

A case can use Regexp in the when statements. Here we use a regular expression to test first letters. Any regular expression can be used. And we can even capture groups.

value = "alexandria"

# Use case with regular expressions.
case value
    when /^a/
        puts "Starts with letter A"
    when /^b/
        puts "Starts with B"
end
Starts with letter A
^a     String starts with a lowercase letter A.
^b     String starts with a "b".

Regexp, captures

This example combines many constructs in Ruby. We use an iterator (each) over a string array. We then use a case-statement with regular expressions.

# An array of strings.
values = ["value 100", "string box"]

# Loop over strings.
values.each do |value|
    # Use regular expression in case-statement.
    # ... Use capturing.
    case value
        when /value (\d+)/
            # Access the capture from $1.
            argument = $1
            # Use format string to display argument.
            puts "Value argument = %s" % argument
        when /string (.+)/
            # Directly display captured value.
            puts "String argument = #$1"
    end
end
Value argument = 100
String argument = box

Case benchmark

In this test, case has no performance advantage. It is many times slower than an equivalent if-statement. This depends on the data being tested.

count = 100000
n1 = Time.now.usec

x = 0
v = 5

# Version 1: assign a variable with a case-statement.
count.times do
    x = case v
        when 0..1 then 1
        when 2..3 then 2
        when 4..6 then 3
        else 0
    end
end
puts x

n2 = Time.now.usec

# Version 2: assign a variable with an if-statement.
count.times do
    if v >= 0 && v <= 1
        x = 1
    elsif v >= 2 && v <= 3
        x = 2
    elsif v >= 4 && v <= 6
        x = 3
    else
        x = 0
    end
end
puts x

n3 = Time.now.usec

# Times.
puts ((n2 - n1) / 1000)
puts ((n3 - n2) / 1000)
3
3
92 ms,  case-statement
15 ms,  if-elsif-else statements

A summary

Case is a selection statement. It is similar, conceptually, to switch statements and to select-case statements in other languages.

Case has advantages

Its syntax is clear and easy to read. It also has limitations—it may evaluate slower. We used a case-statement in a method.