RubyDev - The Home for Ruby Developers

Ruby Exception Handling Mastery

Master Ruby's exception handling system with begin/rescue/ensure/end blocks, raise statements, and custom exceptions. Learn how to write robust, error-resistant code that gracefully handles unexpected situations.

Understanding Exceptions

Exception: An object that represents an error or unexpected condition that occurs during program execution. Instead of crashing, Ruby allows you to "catch" and handle these exceptions gracefully.

Real-World Analogy

Think of exceptions like fire safety systems: Just as buildings have fire alarms, sprinklers, and emergency exits to handle fires gracefully (instead of just burning down), your code should have exception handling to deal with errors without crashing.

🚀 Interactive Practice

Interactive Code Runner

Ruby Code Editor

Output will appear here when you run the code...

🎯 Key Takeaways

begin/rescue/end: Basic exception handling structure
ensure clause: Always runs, perfect for cleanup
raise: Manually trigger exceptions with meaningful messages
Exception objects: Contain class, message, and backtrace information

Exception handling in Ruby allows you to gracefully manage errors and unexpected conditions. Master begin/rescue/ensure blocks, raise statements, and custom exceptions for robust applications.

Basic Exception Handling

Exception Handling: Use begin/rescue/ensure blocks to catch and handle exceptions gracefully, ensuring your application continues running even when errors occur.

Basic begin/rescue Block

# Basic exception handling
begin
  result = 10 / 0
rescue
ZeroDivisionError => e
  puts "Error: \#{e.message}"
  result = 0
end

puts
result
# 0

Multiple Exception Types

# Handling multiple exception types
def
safe_divide
(a, b)
            begin
    a / b
  rescue
ZeroDivisionError
    puts "Cannot divide by zero"
    0
  rescue
TypeError
    puts "Invalid input types"
    0
  end
end

puts
safe_divide(10, 2)
# 5
puts
safe_divide(10, 0)
# 0

Ensure Block

# Using ensure for cleanup
def
read_file_safely
(filename)
            file = nil
  begin
    file = File.open(filename)
    file.read
  rescue
Errno::ENOENT
    puts "File not found: \#{filename}"
    nil
  ensure
    file.close if file
  end
end

Raising Exceptions

Raising Exceptions: Use the 'raise' keyword to signal errors and exceptional conditions in your code.

Basic raise Statement

# Raising exceptions
def
validate_age
(age)
            raise "Age must be positive" if age < 0
  raise "Age must be less than 150" if age > 150
  puts "Valid age: \#{age}"
end

begin
  validate_age(25)
rescue
RuntimeError => e
  puts "Error: \#{e.message}"
end

Raising Specific Exception Types

# Raising specific exception types
def
withdraw
(amount, balance)
          raiseArgumentError
, "Amount must be positive"if amount <= 0
raiseRuntimeError
, "Insufficient funds"if amount > balance
  balance - amount
end

begin
  result = withdraw(100, 50)
rescue
ArgumentError => e
  puts "Argument error: \#{e.message}"
rescue
RuntimeError => e
  puts "Runtime error: \#{e.message}"
end

Interactive Practice: Exception Handling

Practice Time: Try these exception handling examples. Understanding these patterns will make you a more effective Ruby programmer.

Interactive Code Runner

Ruby Code Editor

# Try these comprehensive exception handling examples!

# 1. Basic exception handling
def safe_divide(a, b)
  begin
    result = a / b
    puts "#{a} ÷ #{b} = #{result}"
    result
  rescue ZeroDivisionError => e
    puts "Error: #{e.message}"
    puts "Cannot divide by zero!"
    0
  rescue TypeError => e
    puts "Error: #{e.message}"
    puts "Please provide numbers only!"
    0
  end
end

puts "=== Safe Division Examples ==="
safe_divide(10, 2)    # 5
safe_divide(10, 0)    # Error handling
safe_divide(10, "2")  # Error handling

# 2. File operations with ensure
def read_file_with_cleanup(filename)
  file = nil
  begin
    file = File.open(filename, 'r')
    content = file.read
    puts "File content length: #{content.length}"
    content
  rescue Errno::ENOENT => e
    puts "File not found: #{filename}"
    nil
  rescue Errno::EACCES => e
    puts "Permission denied: #{filename}"
    nil
  ensure
    if file
      file.close
      puts "File closed successfully"
    end
  end
end

puts "
=== File Operations ==="
# This will fail gracefully
read_file_with_cleanup("nonexistent.txt")

# 3. Custom validation with exceptions
def validate_user_input(name, age, email)
  errors = []
  
  errors << "Name cannot be empty" if name.nil? || name.strip.empty?
  errors << "Age must be a positive number" if age.nil? || age <= 0
  errors << "Email must contain @" if email.nil? || !email.include?('@')
  
  unless errors.empty?
    raise ArgumentError, "Validation failed: #{errors.join(', ')}"
  end
  
  puts "User validation passed: #{name}, #{age}, #{email}"
  true
end

puts "
=== User Validation ==="
begin
  validate_user_input("Alice", 25, "alice@example.com")
rescue ArgumentError => e
  puts "Validation error: #{e.message}"
end

begin
  validate_user_input("", -5, "invalid-email")
rescue ArgumentError => e
  puts "Validation error: #{e.message}"
end

# 4. Retry pattern with exponential backoff
def fetch_data_with_retry(url, max_retries = 3)
  retries = 0
  
  begin
    puts "Attempting to fetch: #{url} (attempt #{retries + 1})"
    # Simulate network request that might fail
    if rand < 0.7  # 70% chance of failure
      raise StandardError, "Network timeout"
    end
    
    puts "Successfully fetched data from #{url}"
    "Data from #{url}"
    
  rescue StandardError => e
    retries += 1
    
    if retries <= max_retries
      wait_time = 2 ** retries  # Exponential backoff
      puts "Failed: #{e.message}. Retrying in #{wait_time} seconds..."
      sleep(wait_time)
      retry
    else
      puts "Max retries reached. Giving up."
      raise
    end
  end
end

puts "
=== Retry Pattern ==="
begin
  result = fetch_data_with_retry("https://api.example.com/data")
  puts "Final result: #{result}"
rescue StandardError => e
  puts "Final error: #{e.message}"
end

# Add your own exception handling experiments below!

Output will appear here when you run the code...

Best Practices & Common Patterns

✅ Best Practices

Use specific exception types when possible
Always use ensure for cleanup operations
Provide meaningful error messages
Handle exceptions at the appropriate level
Use rescue modifiers for simple cases
Log exceptions for debugging

❌ Common Pitfalls

Rescuing Exception instead of specific types
Swallowing exceptions without handling
Not cleaning up resources in ensure
Using exceptions for control flow
Not providing context in error messages
Overusing exception handling

Exception Handling Mastery Summary

You've Mastered Ruby Exception Handling!

Exception Handling

begin/rescue/ensure blocks

Raising Exceptions

raise keyword and error signaling

Error Recovery

Graceful error handling and cleanup

Exception handling is crucial for building robust Ruby applications. Use it wisely to handle errors gracefully while maintaining application stability and providing meaningful feedback to users.

Exception-handling

Ruby Exception Handling Mastery

Understanding Exceptions

Real-World Analogy

🚀 Interactive Practice

Interactive Code Runner

Ruby Code Editor

🎯 Key Takeaways

Basic Exception Handling

Basic begin/rescue Block

Multiple Exception Types

Ensure Block

Raising Exceptions

Basic raise Statement

Raising Specific Exception Types

Interactive Practice: Exception Handling

Interactive Code Runner

Ruby Code Editor

Best Practices & Common Patterns

✅ Best Practices

❌ Common Pitfalls

Exception Handling Mastery Summary

You've Mastered Ruby Exception Handling!

Exception Handling

Raising Exceptions

Error Recovery

Quick Navigation

Related Topics

Video Tutorial

Ruby Language

Rails Framework

Production Ready

Exception-handling

Ruby Exception Handling Mastery

Understanding Exceptions

Real-World Analogy

🚀 Interactive Practice

Interactive Code Runner

Ruby Code Editor

🎯 Key Takeaways

Basic Exception Handling

Basic begin/rescue Block

Multiple Exception Types

Ensure Block

Raising Exceptions

Basic raise Statement

Raising Specific Exception Types

Interactive Practice: Exception Handling

Interactive Code Runner

Ruby Code Editor

Best Practices & Common Patterns

✅ Best Practices

❌ Common Pitfalls

Exception Handling Mastery Summary

You've Mastered Ruby Exception Handling!

Exception Handling

Raising Exceptions

Error Recovery

Quick Navigation

Related Topics

Video Tutorial