Raise for throwing errors in Ruby - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the output of this Ruby code with raise?

Look at this Ruby code that uses raise. What will it print or return when run?

Ruby

def check_age(age)
  raise "Age must be positive" if age <= 0
  "Age is #{age}"
end

begin
  puts check_age(-1)
rescue => e
  puts e.message
end

A Age must be positive

B Age is -1

C RuntimeError: Age must be positive

D No output

💡 Hint

Think about what raise does and how rescue catches errors.

The raise command throws an error with the message "Age must be positive" because the age is -1. The rescue block catches this error and prints only the message, so the output is "Age must be positive".

🧠 Conceptual

intermediate

Which statement about raise in Ruby is true?

Choose the correct statement about how raise works in Ruby.

A <code>raise</code> only works with <code>begin</code> blocks and nowhere else.

B <code>raise</code> stops the program immediately without any chance to handle the error.

C <code>raise</code> creates an error that can be caught by <code>rescue</code> blocks.

D <code>raise</code> automatically fixes the error it detects.

💡 Hint

Think about how Ruby handles errors and exceptions.

raise creates an exception that can be caught and handled by rescue blocks. It does not stop the program immediately if handled, and it does not fix errors automatically.

🔧 Debug

advanced

Why does this Ruby code raise an error?

Look at this Ruby code. It raises an error. What is the cause?

Ruby

def divide(a, b)
  raise "Cannot divide by zero" if b == 0
  a / b
end

puts divide(10, 0)

A Because the method is missing a return statement.

B Because dividing by zero is not allowed and <code>raise</code> triggers the error.

C Because <code>raise</code> is used incorrectly without an error class.

D Because the method does not handle the error with <code>rescue</code>.

💡 Hint

Think about what happens when b is zero and how raise works.

The code raises an error because dividing by zero is not allowed. The raise command triggers a RuntimeError with the message "Cannot divide by zero" when b is zero.

📝 Syntax

advanced

Which option correctly raises a custom error in Ruby?

Choose the correct Ruby code that raises a custom error with the message "Invalid input".

A raise "Invalid input"

B raise new ArgumentError("Invalid input")

C raise ArgumentError("Invalid input")

D raise ArgumentError, "Invalid input"

💡 Hint

Remember the syntax for raising errors with a specific error class and message.

Option D uses the correct syntax: raise ArgumentError, "Invalid input". Option D raises a RuntimeError by default. Option D and D are syntax errors.

🚀 Application

expert

What is the output of this Ruby code with nested raise and rescue?

Analyze this Ruby code with nested raise and rescue. What will it print?

Ruby

def test
  begin
    raise "First error"
  rescue
    begin
      raise "Second error"
    rescue => e
      return e.message
    end
  end
end

puts test

A Second error

B RuntimeError

C No output

D First error

💡 Hint

Follow the flow of errors and rescue blocks carefully.

The first raise triggers "First error" but it is rescued immediately. Inside that rescue, another raise triggers "Second error" which is rescued and its message is returned. So the output is "Second error".

Practice

1. What does the raise keyword do in Ruby?

easy

A. It stops the program and throws an error.

B. It prints a message to the screen.

C. It creates a new variable.

D. It repeats a block of code.

Solution

1. Step 1: Understand the purpose of raise

   The raise keyword is used to stop the program and signal that an error has occurred.

2. Step 2: Compare with other options

   Printing messages, creating variables, or repeating code are not what raise does.

3. Final Answer:

   It stops the program and throws an error. -> Option A

4. Quick Check:

   raise stops program = D [OK]

Hint: Remember: raise means stop and show error [OK]

Common Mistakes:

• Thinking raise prints messages
• Confusing raise with loops
• Assuming raise creates variables

2. Which of the following is the correct syntax to raise a runtime error with a message in Ruby?

easy

A. raise "Error happened"

B. throw "Error happened"

C. error.raise("Error happened")

D. raise: "Error happened"

Solution

1. Step 1: Recall Ruby syntax for raising errors

   In Ruby, raise followed by a string message raises a RuntimeError with that message.

2. Step 2: Check each option

   raise "Error happened" uses correct syntax. throw "Error happened" uses throw which is different. error.raise("Error happened") is invalid method call. raise: "Error happened" has wrong colon usage.

3. Final Answer:

   raise "Error happened" -> Option A

4. Quick Check:

   Correct raise syntax = A [OK]

Hint: Use raise followed by message in quotes [OK]

Common Mistakes:

• Using throw instead of raise
• Adding colon after raise
• Calling raise as a method on error

3. What will be the output of this Ruby code?

def check_age(age)
  raise "Age must be 18 or older" if age < 18
  "Access granted"
end

puts check_age(20)

medium

A. Age must be 18 or older

B. No output

C. RuntimeError: Age must be 18 or older

D. Access granted

Solution

1. Step 1: Analyze the condition in the method

   The method raises an error only if age is less than 18. Here, age is 20, so no error is raised.

2. Step 2: Determine the returned value and output

   Since no error is raised, the method returns "Access granted" which is printed by puts.

3. Final Answer:

   Access granted -> Option D

4. Quick Check:

   Age 20 >= 18, no error = B [OK]

Hint: Raise only triggers if condition is true [OK]

Common Mistakes:

• Assuming error always raises
• Confusing error message with output
• Ignoring the if condition

4. Identify the error in this Ruby code snippet:

def divide(a, b)
  raise "Cannot divide by zero" if b = 0
  a / b
end

puts divide(10, 0)

medium

A. Division operator is incorrect

B. Missing parentheses in raise statement

C. Using assignment (=) instead of comparison (==) in the if condition

D. Method divide is not defined

Solution

1. Step 1: Check the if condition syntax

   The condition uses b = 0 which assigns 0 to b instead of comparing it. This is a common mistake.

2. Step 2: Understand the impact

   Because of assignment, b becomes 0, and since 0 is falsy in Ruby, the condition evaluates to false, so the raise is not triggered. The intended check is b == 0.

3. Final Answer:

   Using assignment (=) instead of comparison (==) in the if condition -> Option C

4. Quick Check:

   Use == for comparison, not = [OK]

Hint: Use == to compare, not = which assigns [OK]

Common Mistakes:

• Confusing = and ==
• Thinking raise needs parentheses
• Assuming divide method is missing

5. You want to raise a custom error type ArgumentError with a message "Invalid input" when a method receives a negative number. Which code correctly does this?

hard

A. ArgumentError.raise("Invalid input") if number < 0

B. raise ArgumentError, "Invalid input" if number < 0

C. raise "ArgumentError: Invalid input" if number < 0

D. raise ArgumentError("Invalid input") if number < 0

Solution

1. Step 1: Understand how to raise custom error types

   In Ruby, you can raise a specific error class by passing it as the first argument to raise, followed by the message.

2. Step 2: Check each option's syntax

   raise ArgumentError, "Invalid input" if number < 0 correctly uses raise ArgumentError, "Invalid input". raise "ArgumentError: Invalid input" if number < 0 treats the error as a string only. ArgumentError.raise("Invalid input") if number < 0 is invalid as raise is not a method on ArgumentError. raise ArgumentError("Invalid input") if number < 0 is invalid syntax.

3. Final Answer:

   raise ArgumentError, "Invalid input" if number < 0 -> Option B

4. Quick Check:

   Raise with error class and message = C [OK]

Hint: Use raise ErrorClass, "message" for custom errors [OK]

Common Mistakes:

• Passing error as string only
• Using wrong syntax with parentheses
• Confusing new method call with raise