class BasicObject

返回一个新的 BasicObject。

#define rb_obj_initialize rb_obj_dummy0

布尔值取反。

VALUE
rb_obj_not(VALUE obj)
{
    return RBOOL(!RTEST(obj));
}

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

VALUE
rb_obj_not_equal(VALUE obj1, VALUE obj2)
{
    VALUE result = rb_funcall(obj1, id_eq, 1, obj2);
    return rb_obj_not(result);
}

相等性 — 在 Object 级别，== 仅在 obj 和 other 是同一对象时才返回 true。通常，此方法在子类中被重写以提供特定于类的含义。

与 == 不同，equal? 方法永远不应被子类重写，因为它用于确定对象身份（也就是说，当且仅当 a 与 b 是同一对象时，a.equal?(b)）。

obj = "a"
other = obj.dup

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

如果 obj 和 other 指的是同一个哈希键，则 eql? 方法返回 true。 Hash 使用此方法来测试成员是否相等。 对于任何一对 eql? 返回 true 的对象，两个对象的哈希值必须相等。 因此，任何重写 eql? 的子类也应适当地重写 hash。

对于类 Object 的对象，eql? 与 == 同义。 子类通常通过将 eql? 别名为其重写的 == 方法来继续此传统，但也有例外。 例如，Numeric 类型在 == 中执行类型转换，而不是在 eql? 中，因此

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

VALUE
rb_obj_equal(VALUE obj1, VALUE obj2)
{
    return RBOOL(obj1 == obj2);
}

返回 obj 的整数标识符。

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

注意：为了优化，内置类的某些对象会被重用。对于立即值和冻结的字符串文字，就是这种情况。

BasicObject 实现 +__id__+，Kernel 实现 object_id。

立即值不是通过引用传递，而是通过值传递：nil、true、false、Fixnums、Symbols 和一些 Floats。

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)
{
    /* If obj is an immediate, the object ID is obj directly converted to a Numeric.
     * Otherwise, the object ID is a Numeric that is a non-zero multiple of
     * (RUBY_IMMEDIATE_MASK + 1) which guarantees that it does not collide with
     * any immediates. */
    return rb_find_object_id(rb_gc_get_objspace(), obj, rb_gc_impl_object_id);
}

调用由 symbol 标识的方法，并传递任何指定的参数。当方法由字符串标识时，该字符串将转换为符号。

BasicObject 实现 +__send__+，Kernel 实现 send。当 obj 具有像 Socket 这样的相同方法名称时，__send__ 比 send 更安全。另请参见 public_send。

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_kw(argc, argv, recv, CALL_FCALL);
}

在接收者（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

static VALUE
rb_obj_instance_eval_internal(int argc, const VALUE *argv, VALUE self)
{
    return specific_eval(argc, argv, self, TRUE, RB_PASS_CALLED_KEYWORDS);
}

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

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

static VALUE
rb_obj_instance_exec_internal(int argc, const VALUE *argv, VALUE self)
{
    return yield_under(self, TRUE, argc, argv, RB_PASS_CALLED_KEYWORDS);
}

当向 obj 发送它无法处理的消息时，由 Ruby 调用。 symbol 是调用方法的符号，args 是传递给它的任何参数。默认情况下，当调用此方法时，解释器会引发错误。但是，可以重写此方法以提供更动态的行为。如果确定不应处理特定方法，则应调用 super，以便祖先可以拾取丢失的方法。下面的示例创建一个类 Roman，该类响应名称由罗马数字组成的方法，并返回相应的整数值。

class Roman
  def roman_to_int(str)
    # ...
  end

  def method_missing(symbol, *args)
    str = symbol.id2name
    begin
      roman_to_int(str)
    rescue
      super(symbol, *args)
    end
  end
end

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

static VALUE
rb_method_missing(int argc, const VALUE *argv, VALUE obj)
{
    rb_execution_context_t *ec = GET_EC();
    raise_method_missing(ec, argc, argv, obj, ec->method_missing_reason);
    UNREACHABLE_RETURN(Qnil);
}

每当向接收者添加单例方法时，都会作为回调调用。

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

#define rb_obj_singleton_method_added rb_obj_dummy1

每当从接收者中删除单例方法时，都会作为回调调用。

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

#define rb_obj_singleton_method_removed rb_obj_dummy1

每当在接收者中取消定义单例方法时，都会作为回调调用。

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

#define rb_obj_singleton_method_undefined rb_obj_dummy1