Exception

class Exception

Parent:Object

类Exception的子类用于在begin ... end块中的Kernel＃raise和rescue语句之间进行通信。异常对象包含关于异常的信息 - 它的类型（异常的类名），可选的描述性字符串和可选的回溯信息。异常子类可能会添加其他信息，如NameError＃名称。

程序可以创建Exception的子类，通常是StandardError或RuntimeError，以提供自定义类并添加其他信息。有关raise和的默认值，请参阅下面的子类列表rescue。

当发生异常但尚未处理（在rescue，ensure，at_exit和END块中）时，全局变量$！将包含当前异常，$ @将包含当前异常的回溯。

建议库应该有一个StandardError或RuntimeError的子类，并且有特定的异常类型从中继承。这允许用户抢救一般的异常类型，以捕获库的所有异常，即使未来版本的库添加新的异常子类时也是如此。

例如：

class MyLibrary
  class Error < RuntimeError
  end

  class WidgetError < Error
  end

  class FrobError < Error
  end

end

为了处理WidgetError和FrobError，库用户可以拯救MyLibrary :: Error。

Exception的内置子类是：

NoMemoryError

-  [LoadError](loaderror)

-  [NotImplementedError](notimplementederror)

-  [SyntaxError](syntaxerror)

SecurityError

-  [Interrupt](interrupt)

StandardError – default for rescue

-  [ArgumentError](argumenterror)

    -  [UncaughtThrowError](uncaughtthrowerror)

-  [EncodingError](encodingerror)

-  [FiberError](fibererror)

-  [IOError](ioerror)

    -  [EOFError](eoferror)

-  [IndexError](indexerror)

    -  [KeyError](keyerror)

    -  [StopIteration](stopiteration)

-  [LocalJumpError](localjumperror)

-  [NameError](nameerror)

    -  [NoMethodError](nomethoderror)

-  [RangeError](rangeerror)

    -  [FloatDomainError](floatdomainerror)

-  [RegexpError](regexperror)

-  [RuntimeError](runtimeerror) – default for `raise`

-  [SystemCallError](systemcallerror)

    -  Errno::\*

-  [ThreadError](threaderror)

-  [TypeError](typeerror)

-  [ZeroDivisionError](zerodivisionerror)

SystemExit

公共类方法

exception(string) → an_exception or exc

如果没有参数，或者参数与接收器相同，则返回接收器。否则，创建一个与接收者类相同的新异常对象，但消息等于string.to_str。

json_create(object) Show source

通过构造具有消息m的新的Exception对象和使用to_json序列化的backtrace b来反序列化JSON字符串

# File ext/json/lib/json/add/exception.rb, line 10
def self.json_create(object)
  result = new(object['m'])
  result.set_backtrace object['b']
  result
end

new(msg = nil) → exception Show source

构造一个新的Exception对象，可选地传入消息。

static VALUE
exc_initialize(int argc, VALUE *argv, VALUE exc)
{
    VALUE arg;

    rb_scan_args(argc, argv, "01", &arg
    rb_ivar_set(exc, id_mesg, arg
    rb_ivar_set(exc, id_bt, Qnil

    return exc;
}

公共实例方法

exc == obj → true or false Show source

平等 - 如果obj不是Exception，则返回false。否则，如果exc和obj共享相同的类、消息和回溯，则返回true。

static VALUE
exc_equal(VALUE exc, VALUE obj)
{
    VALUE mesg, backtrace;

    if (exc == obj) return Qtrue;

    if (rb_obj_class(exc) != rb_obj_class(obj)) {
        int status = 0;

        obj = rb_protect(try_convert_to_exception, obj, &status
        if (status || obj == Qundef) {
            rb_set_errinfo(Qnil
            return Qfalse;
        }
        if (rb_obj_class(exc) != rb_obj_class(obj)) return Qfalse;
        mesg = rb_check_funcall(obj, id_message, 0, 0
        if (mesg == Qundef) return Qfalse;
        backtrace = rb_check_funcall(obj, id_backtrace, 0, 0
        if (backtrace == Qundef) return Qfalse;
    }
    else {
        mesg = rb_attr_get(obj, id_mesg
        backtrace = exc_backtrace(obj
    }

    if (!rb_equal(rb_attr_get(exc, id_mesg), mesg))
        return Qfalse;
    if (!rb_equal(exc_backtrace(exc), backtrace))
        return Qfalse;
    return Qtrue;
}

as_json(*) Show source

返回一个散列，它将变成一个JSON对象并表示这个对象。

# File ext/json/lib/json/add/exception.rb, line 18
def as_json(*)
  {
    JSON.create_id => self.class.name,
    'm'            => message,
    'b'            => backtrace,
  }
end

backtrace → array Show source

返回与异常相关的任何回溯。回溯是一个字符串数组，每个字符串都包含“filename：lineNo：in'method'''或'filename：lineNo。''

def a
  raise "boom"
end

def b
  a()
end

begin
  b()
rescue => detail
  print detail.backtrace.join("\n")
end

产生结果：

prog.rb:2:in `a'
prog.rb:6:in `b'
prog.rb:10

static VALUE
exc_backtrace(VALUE exc)
{
    VALUE obj;

    obj = rb_attr_get(exc, id_bt

    if (rb_backtrace_p(obj)) {
        obj = rb_backtrace_to_str_ary(obj
        /* rb_ivar_set(exc, id_bt, obj */
    }

    return obj;
}

backtrace_locations → array Show source

返回与异常相关的任何回溯。此方法与#backtrace类似，但回溯是Thread :: Backtrace :: Location的数组。

现在，这个方法不受#set_backtrace的影响。

static VALUE
exc_backtrace_locations(VALUE exc)
{
    VALUE obj;

    obj = rb_attr_get(exc, id_bt_locations
    if (!NIL_P(obj)) {
        obj = rb_backtrace_to_location_ary(obj
    }
    return obj;
}

cause → an_exception or nil Show source

返回此异常发生时的前一个异常（$！）。这对包装异常并保留原始异常信息很有用。

static VALUE
exc_cause(VALUE exc)
{
    return rb_attr_get(exc, id_cause
}

exception(string) → an_exception or exc Show source

如果没有参数，或者参数与接收器相同，则返回接收器。否则，创建一个与接收者类相同的新异常对象，但消息等于string.to_str。

static VALUE
exc_exception(int argc, VALUE *argv, VALUE self)
{
    VALUE exc;

    if (argc == 0) return self;
    if (argc == 1 && self == argv[0]) return self;
    exc = rb_obj_clone(self
    exc_initialize(argc, argv, exc

    return exc;
}

inspect → string Show source

返回这个异常的类名和消息

static VALUE
exc_inspect(VALUE exc)
{
    VALUE str, klass;

    klass = CLASS_OF(exc
    exc = rb_obj_as_string(exc
    if (RSTRING_LEN(exc) == 0) {
        return rb_str_dup(rb_class_name(klass)
    }

    str = rb_str_buf_new2("#<"
    klass = rb_class_name(klass
    rb_str_buf_append(str, klass
    rb_str_buf_cat(str, ": ", 2
    rb_str_buf_append(str, exc
    rb_str_buf_cat(str, ">", 1

    return str;
}

message → string Show source

返回调用的结果exception.to_s。通常这会返回异常的消息或名称。

static VALUE
exc_message(VALUE exc)
{
    return rb_funcallv(exc, idTo_s, 0, 0
}

set_backtrace(backtrace) → array Show source

设置与exc相关的回溯信息。回溯必须是#backtrace中描述的格式的String对象或单个字符串的数组。

static VALUE
exc_set_backtrace(VALUE exc, VALUE bt)
{
    return rb_ivar_set(exc, id_bt, rb_check_backtrace(bt)
}

to_json(*args) Show source

将消息m和回溯数组存储b存为JSON字符串的类名（Exception）

# File ext/json/lib/json/add/exception.rb, line 28
def to_json(*args)
  as_json.to_json(*args)
end

to_s → string Show source

返回异常的消息（如果没有消息设置，则返回异常的名称）。

static VALUE
exc_to_s(VALUE exc)
{
    VALUE mesg = rb_attr_get(exc, idMesg

    if (NIL_P(mesg)) return rb_class_name(CLASS_OF(exc)
    return rb_String(mesg
}