Ruby Case Examples: Ranges, Strings and Regexp

Case. A case-statement tests values.

It matches the value of a variable against ranges and other values. It yields a specified value. It influences control flow.

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.

Case. This example uses a 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.

Ranges: We use numeric ranges in the when-statements. To specify a range, separate two numbers with two periods.

Based on:

Ruby 2

Ruby program that uses case-statement

# 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"

Output

Low
Medium
High
Invalid

Else statement. Case optionally has an else-statement. If it appears, this must come at the end. If no other ranges or values match, the else-statement is reached.

Tip: In a C-like language, the else is equivalent to a "default" case, which matches unmatched values.

Numbers. A case requires no ranges. In this example, we use simple number "when" statements. For example, we return 400 when the value equals 4.

Note: The case statement evaluates and its result is stored in the "result" variable's memory location.

Expression: We use the case as an expression in this program, one that is evaluated to return a value.

Tip: In Ruby, expressions and statements are often interchangeable. This makes constructs like "case" useful in many contexts.

Ruby program that uses case, no ranges

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

Output

5
500

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.

Also: This case expression uses an else-statement. If the value of "name" is not matched, the value 3 is returned by this expression.

Ruby program that uses string case

# 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

Output

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.

Ruby program that uses when, multiple values

apartment = 200

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

Output

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.

Here: The case block detects that the word "Alexandria" starts with the letter "A." The Regexp is described.

Ruby program that uses Regexp, case

value = "alexandria"

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

Output

Starts with letter A

Pattern description

^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.

Tip: After a Regexp matches a value in a case, its groups are stored in a special variable $1. We get the captured value there.

Tip 2: We can also directly display the value of $1 in a puts call with the code #$1. This helps us develop a simple text parser.

Ruby program that uses case, Regexp, captures

# 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

Output

Value argument = 100
String argument = box

Performance. 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.

However: To boost performance, it is sometimes helpful to replace cases with if-statements.

Ruby that times case-statement

count = 100000
n1 = Time.now.usec

x = 0
v = 5

# 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

# 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)

Output

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.

Related Links