Examples of Ruby Rescue Block Example

Understanding Ruby Rescue Blocks

In Ruby programming, handling exceptions is crucial for building robust applications. The rescue block allows you to gracefully handle errors without crashing your application. Below are three practical examples that illustrate how to use the Ruby rescue block effectively.

Example 1: Handling File Not Found Errors

In this scenario, we will read from a file and handle the possibility that the file might not exist. This is a common use case for file I/O operations.

When attempting to read a file, if the file does not exist, Ruby raises a Errno::ENOENT exception. By using a rescue block, we can catch this error and handle it gracefully, perhaps by informing the user or creating a new file.

begin
  file_content = File.read('non_existent_file.txt')
  puts file_content
rescue Errno::ENOENT => e
  puts "Error: The file does not exist. Please check the filename."  
#  # Optionally create a new file or log the error  
  File.open('non_existent_file.txt', 'w') { |f| f.write('This is a new file.') }
end

In this example, if the file isn’t found, the rescue block executes, informing the user of the error and creating a new file with a default message.

Example 2: Handling Division by Zero Errors

Another common scenario is handling mathematical errors, such as division by zero. This is a straightforward example where we perform a division and handle the potential ZeroDivisionError exception.

Dividing a number by zero raises an exception that can be caught using the rescue block, allowing the program to continue running smoothly.

begin
  numerator = 10
  denominator = 0
  result = numerator / denominator
  puts "The result is #{result}"
rescue ZeroDivisionError => e
  puts "Error: Division by zero is not allowed."
  result = nil  # Assign a default value or handle the error accordingly.
end

In this example, if the denominator is zero, the rescue block catches the error and outputs a user-friendly message instead of crashing the program.

Example 3: Handling Multiple Exceptions

In more complex applications, you may need to handle different types of exceptions. In this example, we will attempt to parse an integer from a string and handle both ArgumentError and StandardError exceptions.

This is useful when dealing with user inputs or data parsing where multiple errors may arise.

begin
  input = 'abc'
  number = Integer(input)  # This will raise an ArgumentError
  puts "Parsed number: #{number}"
rescue ArgumentError => e
  puts "Error: Invalid input. Please enter a valid number."
rescue StandardError => e
  puts "An unexpected error occurred: #{e.message}"
end

In this case, if the input is not a valid integer, the rescue block for ArgumentError is triggered, providing informative feedback. If any other unexpected error occurs, it will be caught by the StandardError rescue block.

These examples of Ruby rescue block example illustrate the versatility and importance of exception handling in Ruby programming, ensuring that your code remains robust and user-friendly.