Rescue modifier (inline form) in Ruby - Step-by-Step Execution

Concept Flow - Rescue modifier (inline form)

Try expression

↓

Success?

Yes→Return value

No↓

Rescue exception

↓

Return rescue value

The rescue modifier tries to run an expression and if an error happens, it returns a fallback value instead.

Execution Sample

Ruby

result = 10 / 0 rescue "Error"
puts result

This code tries to divide 10 by 0, which causes an error, so it returns "Error" instead.

Execution Table

Step	Expression	Error Raised?	Rescue Triggered?	Result
1	10 / 0	Yes (ZeroDivisionError)	Yes	"Error" assigned to result
2	puts result	No	No	Prints: Error

💡 Execution continues after printing the rescue value because the error was handled inline.

Variable Tracker

Variable	Start	After Step 1	After Step 2
result	nil	"Error"	"Error"

Key Moments - 3 Insights

Why does the code not crash when dividing by zero?

Because the rescue modifier catches the ZeroDivisionError inline and assigns "Error" to result, as shown in step 1 of the execution_table.

Does the rescue modifier catch all errors?

No, it only catches StandardError and its subclasses by default, which includes ZeroDivisionError here, as seen in the rescue triggered column.

What happens if no error occurs?

The expression result is assigned normally without rescue, so the rescue part is skipped, as would be shown if the expression succeeded.

Visual Quiz - 3 Questions

Look at the execution_table, what is the value of 'result' after step 1?

A 0

B "Error"

C nil

D 10

💡 Hint

Check the 'Result' column in step 1 where the rescue assigns "Error" to result.

At which step does the rescue modifier handle the error?

A Step 2

B No rescue triggered

C Step 1

D Before step 1

💡 Hint

Look at the 'Rescue Triggered?' column in the execution_table.

If the division was 10 / 2 instead, what would 'result' be after step 1?

A 5

B "Error"

C nil

D 0

💡 Hint

If no error occurs, rescue is skipped and the expression result is assigned normally.

Concept Snapshot

rescue modifier syntax:
expression rescue fallback_value

Runs expression; if error occurs, returns fallback_value instead.
Only rescues StandardError and subclasses.
Useful for short error handling inline.
Example: x = 1/0 rescue "fail"

Full Transcript

The rescue modifier in Ruby lets you try an expression and if it causes an error, you get a fallback value instead. For example, dividing by zero causes an error, but with rescue modifier, you can catch it inline and assign a string like "Error". The flow is: try the expression, if no error, return its value; if error, return the rescue value. This is shown in the execution table where dividing 10 by 0 raises ZeroDivisionError, rescue triggers, and "Error" is assigned to result. Then printing result outputs "Error". This modifier only catches StandardError and subclasses. If no error happens, rescue is skipped and the expression result is used. This is a simple way to handle errors without writing full begin-rescue-end blocks.

Practice

1. What does the rescue modifier do in Ruby when used like value = 10 / x rescue 0?

easy

A. It ignores the division and returns nil

B. It always returns 10 divided by x

C. It returns 0 if dividing by x causes an error

D. It raises an error if x is zero

Solution

1. Step 1: Understand the rescue modifier usage

   The rescue modifier catches exceptions raised by the expression before it and returns the value after rescue if an error occurs.

2. Step 2: Apply to the example

   If 10 / x raises an error (like division by zero), the rescue modifier returns 0 instead of crashing.

3. Final Answer:

   It returns 0 if dividing by x causes an error -> Option C

4. Quick Check:

   rescue modifier returns fallback on error [OK]

Hint: Rescue modifier returns fallback if error happens [OK]

Common Mistakes:

• Thinking rescue modifier prevents all errors
• Assuming it always returns the original expression
• Confusing rescue modifier with if-else

2. Which of the following is the correct syntax for using the rescue modifier inline in Ruby?

easy

A. result = some_method rescue fallback_value

B. result = rescue some_method fallback_value

C. result = some_method ? rescue fallback_value

D. result = some_method else rescue fallback_value

Solution

1. Step 1: Recall the rescue modifier syntax

   The rescue modifier is placed after an expression, followed by the fallback value, like expression rescue fallback.

2. Step 2: Match with options

   Only result = some_method rescue fallback_value matches this syntax correctly: result = some_method rescue fallback_value.

3. Final Answer:

   result = some_method rescue fallback_value -> Option A

4. Quick Check:

   Correct rescue modifier syntax = result = some_method rescue fallback_value [OK]

Hint: Rescue modifier goes after expression, then fallback [OK]

Common Mistakes:

• Placing rescue before the expression
• Using question marks or else with rescue modifier
• Confusing rescue modifier with rescue block

3. What is the output of this Ruby code?

value = Integer('abc') rescue 'error'
puts value

medium

A. abc

B. error

C. 0

D. Raises an exception

Solution

1. Step 1: Understand Integer conversion with invalid string

   Calling Integer('abc') raises an ArgumentError because 'abc' is not a valid number.

2. Step 2: Apply rescue modifier

   The rescue modifier catches this error and returns the string 'error' instead of crashing.

3. Final Answer:

   error -> Option B

4. Quick Check:

   Invalid Integer conversion rescued to 'error' [OK]

Hint: Rescue returns fallback when conversion fails [OK]

Common Mistakes:

• Expecting the original string as output
• Thinking rescue returns nil by default
• Assuming code raises exception without rescue

4. Identify the error in this Ruby code snippet using rescue modifier:

result = 10 / 0 rescue puts 'Error!'

medium

A. No error; prints 'Error!' and result is nil

B. Syntax error because rescue modifier cannot follow puts

C. Runtime error because rescue modifier is misplaced

D. result will be 0 without error

Solution

1. Step 1: Analyze rescue modifier with puts

   The rescue modifier catches the division by zero error and executes puts 'Error!', which prints the message.

2. Step 2: Understand return value of puts

   puts returns nil, so result is assigned nil after rescue.

3. Final Answer:

   No error; prints 'Error!' and result is nil -> Option A

4. Quick Check:

   Rescue modifier runs puts and assigns nil [OK]

Hint: Rescue modifier returns last expression value after rescue [OK]

Common Mistakes:

• Expecting rescue modifier to return printed string
• Thinking rescue modifier causes syntax error here
• Assuming result keeps original expression value

5. You want to safely convert user input to integer but return -1 if conversion fails. Which code correctly uses rescue modifier for this?

hard

A. num = Integer(user_input) else rescue -1

B. num = rescue Integer(user_input) -1

C. num = Integer(user_input) ? rescue -1

D. num = Integer(user_input) rescue -1

Solution

1. Step 1: Understand rescue modifier placement

   The rescue modifier must come after the expression to catch exceptions and provide fallback.

2. Step 2: Check options for correct syntax and logic

   Only num = Integer(user_input) rescue -1 correctly places rescue after Integer(user_input) and returns -1 on failure.

3. Final Answer:

   num = Integer(user_input) rescue -1 -> Option D

4. Quick Check:

   Correct rescue modifier usage for fallback = num = Integer(user_input) rescue -1 [OK]

Hint: Put rescue after expression, then fallback value [OK]

Common Mistakes:

• Placing rescue before expression
• Using invalid syntax with question marks or else
• Forgetting rescue modifier for error handling