BasicObject

父：

BasicObject是Ruby中所有类的父类。这是一个明确的空白类。

BasicObject可用于创建独立于Ruby对象层次结构的对象层次结构，Delegator类之类的代理对象或其他必须避免来自Ruby方法和类的命名空间污染的用途。

为避免污染其他用户的BasicObject，应该创建一个BasicObject的适当命名的子类，而不是直接修改BasicObject：

class MyObjectSystem < BasicObject
end

BasicObject不包括内核（对于类似的方法puts），而BasicObject不在标准库的名称空间中，因此不使用完整的类路径就可以找到常见的类。

可以使用各种策略将标准库的有用部分提供给BasicObject的子类。子类include Kernel可以获得puts，exit等等。可以创建和包含定制的内核模块，或者可以通过method_missing使用委托：

class MyObjectSystem < BasicObject
  DELEGATE = [:puts, :p]

  def method_missing(name, *args, &block)
    super unless DELEGATE.include? name
    ::Kernel.send(name, *args, &block)
  end

  def respond_to_missing?(name, include_private = false)
    DELEGATE.include?(name) or super
  end
end

从Ruby标准库访问类和模块可以在BasicObject子类中通过引用根::File或类似的所需常量来获得::Enumerator。像method_missing一样，可以使用const_missing将常量查找委托给Object：

class MyObjectSystem < BasicObject
  def self.const_missing(name)
    ::Object.const_get(name)
  end
end

公共类方法

new() 显示源文件

没有记录

static VALUE
rb_obj_dummy(void)
{
    return Qnil;
}

公共实例方法

!obj →true或false显示来源

布尔否定。

VALUE
rb_obj_not(VALUE obj)
{
    return RTEST(obj) ? Qfalse : Qtrue;
}

obj != other →true或false显示源

如果两个对象不相等则返回true，否则返回false。

VALUE
rb_obj_not_equal(VALUE obj1, VALUE obj2)
{
    VALUE result = rb_funcall(obj1, id_eq, 1, obj2);
    return RTEST(result) ? Qfalse : Qtrue;
}

obj == other→true或false显示来源

平等-在Object水平，==返回true只有当obj和other是同一对象。通常，这个方法在后代类中被覆盖以提供类特定的含义。

与此不同==，该equal?方法不应被子类覆盖，因为它用于确定对象标识（即，a.equal?(b)当且仅当a与对象相同时b）：

obj = "a"
other = obj.dup

obj == other      #=> true
obj.equal? other  #=> false
obj.equal? obj    #=> true

该eql?方法返回trueif obj和other引用相同的散列键。Hash使用它来测试成员是否相等。对于课堂上的对象而言Object，它eql?是同义词==。子类通常通过别名eql?重写==方法来延续这一传统，但也有例外。Numeric类型，例如，执行类型转换==，但不跨越eql?，因此：

1 == 1.0     #=> true
1.eql? 1.0   #=> false

VALUE
rb_obj_equal(VALUE obj1, VALUE obj2)
{
    if (obj1 == obj2) return Qtrue;
    return Qfalse;
}

__id__→整数显示源文件

object_id→整数

返回一个整数标识符obj。

object_id对于给定对象的所有调用都会返回相同的数字，并且没有两个活动对象将共享一个ID。

注意：内建类的一些对象被重新用于优化。立即值和冻结字符串文字就是这种情况。

立即值不按引用传递，而是由值传递：nil，true，false，Fixnums，符号，还有一些浮标。

Object.new.object_id  == Object.new.object_id  # => false
(21 * 2).object_id    == (21 * 2).object_id    # => true
"hello".object_id     == "hello".object_id     # => false
"hi".freeze.object_id == "hi".freeze.object_id # => true

VALUE
rb_obj_id(VALUE obj)
{
    /*
     *                32-bit VALUE space
     *          MSB ------------------------ LSB
     *  false   00000000000000000000000000000000
     *  true    00000000000000000000000000000010
     *  nil     00000000000000000000000000000100
     *  undef   00000000000000000000000000000110
     *  symbol  ssssssssssssssssssssssss00001110
     *  object  oooooooooooooooooooooooooooooo00        = 0 (mod sizeof(RVALUE))
     *  fixnum  fffffffffffffffffffffffffffffff1
     *
     *                    object_id space
     *                                       LSB
     *  false   00000000000000000000000000000000
     *  true    00000000000000000000000000000010
     *  nil     00000000000000000000000000000100
     *  undef   00000000000000000000000000000110
     *  symbol   000SSSSSSSSSSSSSSSSSSSSSSSSSSS0        S...S % A = 4 (S...S = s...s * A + 4)
     *  object   oooooooooooooooooooooooooooooo0        o...o % A = 0
     *  fixnum  fffffffffffffffffffffffffffffff1        bignum if required
     *
     *  where A = sizeof(RVALUE)/4
     *
     *  sizeof(RVALUE) is
     *  20 if 32-bit, double is 4-byte aligned
     *  24 if 32-bit, double is 8-byte aligned
     *  40 if 64-bit
     */
    if (STATIC_SYM_P(obj)) {
        return (SYM2ID(obj) * sizeof(RVALUE) + (4 << 2)) | FIXNUM_FLAG;
    }
    else if (FLONUM_P(obj)) {
#if SIZEOF_LONG == SIZEOF_VOIDP
        return LONG2NUM((SIGNED_VALUE)obj);
#else
        return LL2NUM((SIGNED_VALUE)obj);
#endif
    }
    else if (SPECIAL_CONST_P(obj)) {
        return LONG2NUM((SIGNED_VALUE)obj);
    }
    return nonspecial_obj_id(obj);
}

send(symbol , args...) →obj显示源

__send__(symbol , args...) → obj

send(string , args...) → obj

__send__(string , args...) → obj

调用由符号标识的方法，向其传递任何指定的参数。__send__如果名称send与obj中的现有方法冲突，则可以使用。当方法由字符串标识时，字符串将转换为符号。

class Klass
  def hello(*args)
    "Hello " + args.join(' ')
  end
end
k = Klass.new
k.send :hello, "gentle", "readers"   #=> "Hello gentle readers"

VALUE
rb_f_send(int argc, VALUE *argv, VALUE recv)
{
    return send_internal(argc, argv, recv, CALL_FCALL);
}

equal?(other) → true 或 false 显示资源

平等-在Object水平，==返回true只有当obj和other是同一对象。通常，这个方法在后代类中被覆盖以提供类特定的含义。

与此不同==，该equal?方法不应被子类覆盖，因为它用于确定对象标识（即，a.equal?(b)当且仅当a与对象相同时b）：

obj = "a"
other = obj.dup

obj == other      #=> true
obj.equal? other  #=> false
obj.equal? obj    #=> true

如果 obj和other引用相同的散列键，该eql?方法返回true。Hash使用它来测试成员是否相等。对于课堂上的对象而言Object，它eql?是同义词==。子类通常通过别名eql?重写==方法来延续这一传统，但也有例外。Numeric类型，例如，执行类型转换==，但不跨越eql?，因此：

1 == 1.0     #=> true
1.eql? 1.0   #=> false

VALUE
rb_obj_equal(VALUE obj1, VALUE obj2)
{
    if (obj1 == obj2) return Qtrue;
    return Qfalse;
}

instance_eval(string [, filename , lineno] ) →obj显示源文件

instance_eval {|obj| block } → obj

在接收器（obj）的上下文中评估包含Ruby源代码或给定块的字符串。为了设置上下文，在代码执行时变量self设置为obj，从而使代码可以访问obj的实例变量和私有方法。

当instance_eval给定一个块时，obj也作为块的唯一参数传入。

当instance_eval给定一个String时，可选的第二个和第三个参数提供报告编译错误时使用的文件名和起始行号。

class KlassWithSecret
  def initialize
    @secret = 99
  end
  private
  def the_secret
    "Ssssh! The secret is #{@secret}."
  end
end
k = KlassWithSecret.new
k.instance_eval { @secret }          #=> 99
k.instance_eval { the_secret }       #=> "Ssssh! The secret is 99."
k.instance_eval {|obj| obj == self } #=> true

VALUE
rb_obj_instance_eval(int argc, const VALUE *argv, VALUE self)
{
    VALUE klass = singleton_class_for_eval(self);
    return specific_eval(argc, argv, klass, self);
}

instance_exec(arg...) {|var...| block } → obj Show source

在接收器（obj）的上下文中执行给定的块。为了设置上下文，在代码执行时将该变量self设置为obj，从而使代码可以访问obj的实例变量。参数作为块参数传递。

class KlassWithSecret
  def initialize
    @secret = 99
  end
end
k = KlassWithSecret.new
k.instance_exec(5) {|x| @secret+x }   #=> 104

VALUE
rb_obj_instance_exec(int argc, const VALUE *argv, VALUE self)
{
    VALUE klass = singleton_class_for_eval(self);
    return yield_under(klass, self, argc, argv);
}

私有实例方法

method_missing(symbol , *args ) → result显示源文件

当obj发送消息时，由Ruby调用它无法处理。符号是调用方法的符号，args是传递给它的任何参数。默认情况下，解释器在调用此方法时引发错误。但是，可以重写该方法以提供更多动态行为。如果决定不应该处理某种特定方法，那么应该调用超级方法，以便祖先能够找到缺失的方法。下面的例子创建一个类Roman，它响应名称由罗马数字组成的方法，返回相应的整数值。

class Roman
  def roman_to_int(str)
    # ...
  end
  def method_missing(methId)
    str = methId.id2name
    roman_to_int(str)
  end
end

r = Roman.new
r.iv      #=> 4
r.xxiii   #=> 23
r.mm      #=> 2000

static VALUE
rb_method_missing(int argc, const VALUE *argv, VALUE obj)
{
    rb_thread_t *th = GET_THREAD();
    raise_method_missing(th, argc, argv, obj, th->method_missing_reason);
    UNREACHABLE;
}

singleton_method_added（符号）显示源代码

无论何时将单例方法添加到接收方，都会调用回调函数。

module Chatty
  def Chatty.singleton_method_added(id)
    puts "Adding #{id.id2name}"
  end
  def self.one()     end
  def two()          end
  def Chatty.three() end
end

生产：

Adding singleton_method_added
Adding one
Adding three

static VALUE
rb_obj_dummy(void)
{
    return Qnil;
}

singleton_method_removed（符号）显示源

每当从接收器中删除一个单例方法时调用回调函数。

module Chatty
  def Chatty.singleton_method_removed(id)
    puts "Removing #{id.id2name}"
  end
  def self.one()     end
  def two()          end
  def Chatty.three() end
  class << self
    remove_method :three
    remove_method :one
  end
end

生产：

Removing three
Removing one

static VALUE
rb_obj_dummy(void)
{
    return Qnil;
}

singleton_method_undefined（符号）显示源代码

当接收器中的单例方法未定义时，作为回调调用。

module Chatty
  def Chatty.singleton_method_undefined(id)
    puts "Undefining #{id.id2name}"
  end
  def Chatty.one()   end
  class << self
     undef_method(:one)
  end
end

生产：

Undefining one

static VALUE
rb_obj_dummy(void)
{
    return Qnil;
}