异常类层次结构

在编程中，异常（Exception）是指程序在执行过程中遇到的错误或意外情况。Ruby 提供了一套丰富的异常处理机制，帮助开发者优雅地处理这些异常情况。理解 Ruby 的异常类层次结构是掌握异常处理的基础。

1. 异常类层次结构概述

Ruby 中的异常类层次结构是一个树状结构，根节点是 Exception 类。所有的异常类都继承自 Exception 类。以下是 Ruby 异常类层次结构的主要部分：

Exception
├── NoMemoryError
├── ScriptError
│   ├── LoadError
│   ├── NotImplementedError
│   └── SyntaxError
├── SecurityError
├── SignalException
│   └── Interrupt
├── StandardError
│   ├── ArgumentError
│   ├── IOError
│   │   └── EOFError
│   ├── IndexError
│   ├── LocalJumpError
│   ├── NameError
│   │   └── NoMethodError
│   ├── RangeError
│   │   └── FloatDomainError
│   ├── RegexpError
│   ├── RuntimeError
│   ├── SystemCallError
│   │   └── Errno::*
│   ├── ThreadError
│   ├── TypeError
│   └── ZeroDivisionError
├── SystemExit
└── SystemStackError

1.1 Exception 类

Exception 是所有异常类的基类。它定义了异常的基本行为和属性。通常情况下，我们不会直接抛出 Exception 类的实例，而是使用其子类。

1.2 StandardError 类

StandardError 是 Exception 的一个子类，也是最常用的异常类。大多数内置的异常类都继承自 StandardError。例如，ArgumentError、TypeError、ZeroDivisionError 等。

1.3 其他异常类

除了 StandardError，Ruby 还定义了许多其他类型的异常类，用于处理特定类型的错误。例如：

• NoMemoryError：当系统内存不足时抛出。
• ScriptError：与脚本执行相关的错误，如 LoadError、SyntaxError 等。
• SignalException：与操作系统信号相关的异常，如 Interrupt。

2. 抛出和捕获异常

在 Ruby 中，我们可以使用 raise 方法抛出异常，使用 begin...rescue...end 结构捕获和处理异常。

2.1 抛出异常

使用 raise 方法可以抛出异常。raise 可以接受一个异常类或异常实例作为参数。

raise "This is a runtime error"

上述代码会抛出一个 RuntimeError 异常，并显示消息 "This is a runtime error"。

2.2 捕获异常

使用 begin...rescue...end 结构可以捕获和处理异常。rescue 块用于处理捕获到的异常。

begin
  # 可能会抛出异常的代码
  raise "This is a runtime error"
rescue => e
  # 处理异常
  puts "Caught an exception: #{e.message}"
end

上述代码会捕获 RuntimeError 异常，并输出 "Caught an exception: This is a runtime error"。

2.3 捕获特定类型的异常

你可以指定 rescue 块捕获特定类型的异常。

begin
  # 可能会抛出异常的代码
  raise ArgumentError, "Invalid argument"
rescue ArgumentError => e
  # 处理 ArgumentError 异常
  puts "Caught ArgumentError: #{e.message}"
rescue => e
  # 处理其他类型的异常
  puts "Caught an exception: #{e.message}"
end

上述代码会捕获 ArgumentError 异常，并输出 "Caught ArgumentError: Invalid argument"。如果抛出的是其他类型的异常，则会被第二个 rescue 块捕获。

3. 自定义异常

在某些情况下，你可能需要定义自己的异常类来处理特定的错误情况。自定义异常类通常继承自 StandardError 或其他合适的异常类。

3.1 定义自定义异常类

class MyCustomError < StandardError
  def initialize(message = "This is a custom error")
    super(message)
  end
end

3.2 抛出自定义异常

begin
  raise MyCustomError, "Something went wrong"
rescue MyCustomError => e
  puts "Caught MyCustomError: #{e.message}"
end

上述代码会抛出并捕获 MyCustomError 异常，并输出 "Caught MyCustomError: Something went wrong"。

4. 实践练习

练习 1：捕获并处理文件读取异常

编写一个 Ruby 脚本，尝试读取一个不存在的文件，并捕获 Errno::ENOENT 异常。

begin
  File.read("non_existent_file.txt")
rescue Errno::ENOENT => e
  puts "File not found: #{e.message}"
end

练习 2：自定义异常处理

定义一个自定义异常类 InvalidInputError，并在一个方法中抛出该异常。捕获并处理该异常。

class InvalidInputError < StandardError
  def initialize(message = "Invalid input")
    super(message)
  end
end

def process_input(input)
  raise InvalidInputError, "Input must be a number" unless input.is_a?(Numeric)
  puts "Processing input: #{input}"
end

begin
  process_input("not a number")
rescue InvalidInputError => e
  puts "Caught InvalidInputError: #{e.message}"
end

5. 总结

理解 Ruby 的异常类层次结构是掌握异常处理的关键。通过 raise 和 rescue 结构，你可以优雅地处理程序中的异常情况。自定义异常类可以帮助你更好地组织和处理特定类型的错误。通过实践练习，你可以更好地掌握这些概念。

希望这篇教程能帮助你更好地理解和应用 Ruby 中的异常处理机制。继续学习和实践，你将能够编写出更加健壮和可靠的 Ruby 程序。