Case/when statement in Ruby - Deep Dive

Overview - Case/when statement

What is it?

A case/when statement in Ruby is a way to choose between many options based on a value. It checks a value against different conditions and runs the code for the first matching condition. This helps avoid writing many if/else statements and makes the code cleaner and easier to read. It works like a decision tree that picks one path depending on the input.

Why it matters

Without case/when, programmers would write long chains of if/else statements that are harder to read and maintain. Case/when makes decision-making in code simpler and clearer, reducing mistakes and improving speed when reading or changing code. It helps programs handle many choices smoothly, which is common in real-world tasks like menus, commands, or responses.

Where it fits

Before learning case/when, you should understand basic Ruby syntax and if/else statements. After mastering case/when, you can explore more advanced control flow like loops, methods, and pattern matching introduced in newer Ruby versions.

Mental Model

Core Idea

A case/when statement picks one matching option from many choices based on a value, running only the code for that match.

Think of it like...

It's like a vending machine where you press a button for your snack choice, and the machine gives you exactly that snack without checking all other options.

┌───────────────┐
│   case value  │
├───────────────┤
│ when option1  │ → run code for option1
│ when option2  │ → run code for option2
│ when option3  │ → run code for option3
│ else          │ → run default code
└───────────────┘

Build-Up - 7 Steps

1

Foundation

Basic if/else decision making

Concept: Understanding simple if/else statements to choose between two options.

In Ruby, you can use if/else to run code based on a condition: ```ruby number = 5 if number > 3 puts "Big number" else puts "Small number" end ``` This checks if number is greater than 3 and prints accordingly.

Result

Big number

Knowing if/else is essential because case/when builds on the idea of choosing code paths based on conditions.

2

Foundation

Multiple if/elsif/else chains

Concept: Using if/elsif/else to handle more than two choices.

You can check many conditions in order: ```ruby score = 85 if score >= 90 puts "A grade" elsif score >= 80 puts "B grade" elsif score >= 70 puts "C grade" else puts "Fail" end ``` This picks the first true condition and runs its code.

Result

B grade

Handling many choices with if/elsif/else works but can get long and harder to read, which case/when solves.

3

Intermediate

Introducing case/when syntax

🤔Before reading on: do you think case/when can replace if/elsif/else for multiple choices? Commit to your answer.

Concept: Case/when provides a cleaner way to write multiple-choice decisions based on one value.

Instead of many if/elsif, use case/when: ```ruby grade = 'B' case grade when 'A' puts "Excellent" when 'B' puts "Good" when 'C' puts "Average" else puts "Unknown grade" end ``` It compares grade to each when value and runs the matching block.

Result

Good

Understanding case/when simplifies reading and writing multiple-choice logic by focusing on one value.

4

Intermediate

Using ranges and multiple matches

🤔Before reading on: Can case/when handle ranges or multiple values in one when? Commit to your answer.

Concept: When clauses can match ranges or multiple values, making case/when very flexible.

You can write: ```ruby score = 75 case score when 90..100 puts "A" when 80..89 puts "B" when 70..79 puts "C" else puts "Fail" end ``` Or match multiple values: ```ruby fruit = 'apple' case fruit when 'apple', 'banana', 'orange' puts "Fruit is common" else puts "Fruit is rare" end ``` This matches if fruit is any of the listed values.

Result

C Fruit is common

Knowing that when can match ranges or lists reduces code duplication and handles complex conditions elegantly.

5

Intermediate

Using else as a fallback option

Concept: The else clause runs if no when matches, providing a default action.

If none of the when conditions match, else runs: ```ruby color = 'purple' case color when 'red' puts "Stop" when 'green' puts "Go" else puts "Unknown color" end ``` This ensures your code handles unexpected values safely.

Result

Unknown color

Including else prevents errors or silence when input is unexpected, improving program robustness.

6

Advanced

Case statement without an argument

🤔Before reading on: Do you think case can be used without a value to compare? Commit to your answer.

Concept: Case can be used without a value, making it behave like if/elsif chains with conditions in when clauses.

You can write: ```ruby number = 7 case when number < 5 puts "Small" when number < 10 puts "Medium" else puts "Large" end ``` Here, each when is a condition evaluated as true or false.

Result

Medium

Knowing case without an argument lets you write cleaner if/elsif logic when conditions are complex or unrelated to one value.

7

Expert

How case/when uses === operator internally

🤔Before reading on: Does case/when use simple equality (==) or something else to match? Commit to your answer.

Concept: Case/when uses the === operator to test matches, which allows flexible matching like ranges, classes, and custom objects.

When Ruby evaluates `case value`, it checks each `when condition` by calling `condition === value`. For example: - For ranges, `Range#===` checks if value is inside the range. - For classes, `Class#===` checks if value is an instance. - For other objects, it falls back to equality. This is why case/when can match many types elegantly.

Result

Understanding this explains why case/when works with ranges, classes, and more.

Knowing the use of === operator reveals the powerful flexibility behind case/when and how to extend it with custom classes.

Under the Hood

Ruby's case statement evaluates the expression once and then compares it to each when clause using the === operator. This operator is called on the when clause with the case expression as the argument. If any when clause returns true for ===, its block runs and the case ends. If none match, the else block runs if present. This design allows matching against ranges, classes, or any object that defines ===, making case/when very flexible.

Why designed this way?

The case/when statement was designed to be more powerful than simple equality checks. Using === lets Ruby support many matching styles without extra syntax. This design choice keeps the language elegant and extensible. Alternatives like only using == would limit matching to exact equality, reducing usefulness. The flexibility also aligns with Ruby's philosophy of making code readable and expressive.

┌───────────────┐
│ Evaluate expr │
└──────┬────────┘
       │
       ▼
┌─────────────────────────────┐
│ For each when_clause in order│
│  Call when_clause === expr   │
│  If true → run block, exit  │
│  Else → check next when     │
└─────────────┬───────────────┘
              │
              ▼
       ┌─────────────┐
       │ else block? │
       └─────┬───────┘
             │ yes
             ▼
       Run else block
             │ no
             ▼
          Do nothing

Myth Busters - 4 Common Misconceptions

Quick: Does case/when always use simple equality (==) to match values? Commit to yes or no.

Common Belief: Case/when uses == to compare the case value and when values.

Reality: Case/when uses the === operator, which can behave differently depending on the object, allowing flexible matching.

Why it matters: Assuming == causes confusion when ranges or classes match unexpectedly, leading to bugs or misuse.

Quick: Can you use multiple values in one when separated by commas? Commit to yes or no.

Common Belief: Each when can only check one value at a time.

Reality: You can list multiple values separated by commas in one when clause to match any of them.

Why it matters: Not knowing this leads to repetitive code and missed opportunities for cleaner logic.

Quick: Does else in case/when always have to be last? Commit to yes or no.

Common Belief: Else can appear anywhere in the case statement.

Reality: Else must be the last clause; placing it earlier causes syntax errors or unreachable code.

Why it matters: Misplacing else causes runtime errors or unexpected behavior, frustrating beginners.

Quick: Can case/when be used without a case expression? Commit to yes or no.

Common Belief: Case/when always requires a value to compare against.

Reality: Case can be used without an expression, turning when clauses into conditions evaluated as true/false.

Why it matters: Not knowing this limits how flexibly you can write conditional logic, missing a powerful pattern.

Expert Zone

1

When matching classes in when clauses, case/when uses Class#=== which checks inheritance, allowing polymorphic matching.

2

Custom objects can define their own === method to control how they match in case/when, enabling domain-specific logic.

3

Using case without an expression is effectively syntactic sugar for if/elsif chains, but can improve readability in complex conditions.

When NOT to use

Avoid case/when when conditions require complex boolean logic combining multiple variables or side effects; use if/elsif instead. Also, for pattern matching on data structures, Ruby's newer pattern matching syntax (introduced in Ruby 2.7) is more powerful and expressive.

Production Patterns

In real-world Ruby apps, case/when is often used for routing commands, handling user input, or mapping values to actions. Developers also use it with ranges for grading systems or with classes for type-based dispatch. Advanced usage includes defining custom === methods for domain-specific matching.

Connections

Pattern Matching (Ruby 2.7+)

Builds on and extends case/when by allowing deep matching of data structures.

Understanding case/when prepares you for pattern matching, which generalizes and enhances decision logic in Ruby.

Switch Statement (JavaScript)

Similar control flow structure for multi-way branching based on a value.

Knowing case/when helps grasp switch statements in other languages, showing a common programming pattern.

Decision Trees (Machine Learning)

Both select outcomes based on conditions branching from a root value.

Seeing case/when as a simple decision tree helps understand how programs and algorithms make choices step-by-step.

Common Pitfalls

#1 Misunderstanding that case/when uses == instead of === for matching.

Wrong approach:

case value
when 1..5
puts "In range"
end
# Assumes == is used, but 3 === 1..5 is false

Correct approach:

case value
when 1..5
puts "In range"
end
# Actually calls (1..5) === value, which works correctly

Root cause:

Confusing the matching operator causes unexpected matches or misses.

#2 Placing else clause before all when clauses.

Wrong approach:

case x
else
puts "default"
when 1
puts "one"
end

Correct approach:

case x
when 1
puts "one"
else
puts "default"
end

Root cause:

Misunderstanding syntax rules leads to syntax errors or unreachable code.

#3 Using commas in when clause but forgetting parentheses in complex expressions.

Wrong approach:

case fruit
when 'apple', 'banana' + 'orange'
puts "Fruit"
end

Correct approach:

case fruit
when 'apple', ('banana' + 'orange')
puts "Fruit"
end

Root cause:

Not understanding operator precedence causes unexpected behavior.

Key Takeaways

Case/when statements let you choose one action from many options based on a single value, making code cleaner than long if/else chains.

They use the === operator internally, which allows matching ranges, classes, and custom objects, giving great flexibility.

When clauses can match multiple values or ranges, and else provides a fallback for unmatched cases.

Case can be used without an expression, turning when clauses into conditions like if/elsif chains.

Understanding case/when prepares you for more advanced Ruby features like pattern matching and helps write clearer, more maintainable code.

Practice

1.

What does the case/when statement do in Ruby?

easy

A. It chooses which code to run based on matching a value.

B. It repeats code multiple times.

C. It defines a new method.

D. It creates a new variable.

Solution

1. Step 1: Understand the purpose of case/when

   The case/when statement compares a value to different options to decide which code to run.

2. Step 2: Compare with other options

   Repeating code is done by loops, defining methods uses def, and variables are created by assignment, so these are incorrect.

3. Final Answer:

   It chooses which code to run based on matching a value. -> Option A

4. Quick Check:

   case/when selects code by value match [OK]

Hint: Remember: case/when picks code by matching values [OK]

Common Mistakes:

• Confusing case/when with loops
• Thinking case/when defines methods
• Believing case/when creates variables

2.

Which of the following is the correct syntax for a case/when statement in Ruby?

case x
  when 1
    puts "One"
  when 2
    puts "Two"
  else
    puts "Other"
end

easy

A. case x
when 1
puts "One"
when 2
puts "Two"
else
puts "Other"
end

B. case x {
when 1:
puts "One"
when 2:
puts "Two"
else:
puts "Other"
}

C. switch(x) {
case 1:
puts "One"
case 2:
puts "Two"
default:
puts "Other"
}

D. if x == 1 then puts "One" elsif x == 2 then puts "Two" else puts "Other" end

Solution

1. Step 1: Check Ruby case/when syntax

   Ruby uses case followed by when clauses and ends with end. No braces or colons are used.

2. Step 2: Compare options

   case x when 1 puts "One" when 2 puts "Two" else puts "Other" end matches Ruby syntax exactly. Options B and C use braces and colons like other languages. if x == 1 then puts "One" elsif x == 2 then puts "Two" else puts "Other" end is an if/elsif, not case/when.

3. Final Answer:

   case x when 1 puts "One" when 2 puts "Two" else puts "Other" end -> Option A

4. Quick Check:

   Ruby case/when uses no braces or colons [OK]

Hint: Ruby case/when uses no braces or colons, just end [OK]

Common Mistakes:

• Using braces or colons like other languages
• Confusing case/when with switch/case from other languages
• Using if/elsif instead of case/when

3.

What is the output of this Ruby code?

grade = 'B'
case grade
when 'A'
  puts "Excellent"
when 'B', 'C'
  puts "Good"
when 'D'
  puts "Pass"
else
  puts "Fail"
end

medium

A. Fail

B. Excellent

C. Pass

D. Good

Solution

1. Step 1: Identify the value of grade

   The variable grade is set to 'B'.

2. Step 2: Match grade in case/when

   The when 'B', 'C' line matches 'B', so it runs puts "Good".

3. Final Answer:

   Good -> Option D

4. Quick Check:

   grade 'B' matches when 'B', 'C' [OK]

Hint: Check all values in when line, including multiple matches [OK]

Common Mistakes:

• Only checking first value in when list
• Confusing else output
• Ignoring multiple values in one when

4.

Find the error in this Ruby code snippet:

score = 85
case score
when 90..100
  puts "A"
when 80..89
  puts "B"
when 70..79
  puts "C"
else
  puts "F"
end

Why does it not print "B" for score 85?

medium

A. Ranges in when must be strings, not numbers.

B. The case statement compares score with ranges incorrectly; use case with when and ===.

C. The code is correct; it will print "B" as expected.

D. The ranges overlap and cause confusion.

Solution

1. Step 1: Understand how case/when works with ranges

   Ruby's case/when uses the === operator, which works with ranges to check if a value is inside.

2. Step 2: Check the given score and ranges

   Score 85 falls inside 80..89, so puts "B" will run correctly.

3. Final Answer:

   The code is correct; it will print "B" as expected. -> Option C

4. Quick Check:

   Ranges work with case/when using === [OK]

Hint: Ranges work naturally in when clauses with case [OK]

Common Mistakes:

• Thinking ranges must be strings
• Believing case/when can't handle ranges
• Assuming overlapping ranges cause errors here

5.

You want to write a Ruby case/when statement that prints "Weekend" for Saturday and Sunday, "Weekday" for Monday to Friday, and "Invalid" for any other input. Which code correctly does this?

hard

A. case day
when 'Saturday', 'Sunday'
puts "Weekend"
when 'Monday'..'Friday'
puts "Weekday"
else
puts "Invalid"
end

B. case day
when 'Saturday', 'Sunday'
puts "Weekend"
when 'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday'
puts "Weekday"
else
puts "Invalid"
end

C. case day
when 'Saturday'..'Sunday'
puts "Weekend"
when 'Monday'..'Friday'
puts "Weekday"
else
puts "Invalid"
end

D. case day
when ['Saturday', 'Sunday']
puts "Weekend"
when ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']
puts "Weekday"
else
puts "Invalid"
end

Solution

1. Step 1: Understand how to list multiple values in when

   Use commas to separate multiple values in one when line, like when 'Saturday', 'Sunday'.

2. Step 2: Check each option

   case day when 'Saturday', 'Sunday' puts "Weekend" when 'Monday'..'Friday' puts "Weekday" else puts "Invalid" end incorrectly uses a range of strings 'Monday'..'Friday' which does not work as expected for days. case day when ['Saturday', 'Sunday'] puts "Weekend" when ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday'] puts "Weekday" else puts "Invalid" end uses arrays in when, which does not match values correctly. case day when 'Saturday'..'Sunday' puts "Weekend" when 'Monday'..'Friday' puts "Weekday" else puts "Invalid" end uses string ranges like 'Saturday'..'Sunday' which is not meaningful for days. case day when 'Saturday', 'Sunday' puts "Weekend" when 'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday' puts "Weekday" else puts "Invalid" end correctly lists each weekday separately with commas.

3. Final Answer:

   case day when 'Saturday', 'Sunday' puts "Weekend" when 'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday' puts "Weekday" else puts "Invalid" end -> Option B

4. Quick Check:

   Use commas for multiple values in when [OK]

Hint: Use commas, not ranges or arrays, for multiple when values [OK]

Common Mistakes:

• Using ranges of strings for days
• Using arrays inside when clauses
• Trying to use string ranges that don't work