класс BasicObject

#define rb_obj_initialize rb_obj_dummy0

Возвращает новый экземпляр BasicObject.

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

Логическое отрицание.

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

Возвращает true, если два объекта не равны, и false в противном случае.

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

Равенство — на уровне 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? возвращает true, если obj и other являются одним и тем же ключом хеша. Метод Hash использует его для проверки равенства элементов. Для любой пары объектов, для которой eql? возвращает true, значения хеша обоих объектов должны совпадать. Поэтому любой подкласс, переопределяющий eql?, должен также соответствующим образом переопределить hash.

Для объектов класса Object eql? является синонимом ==. Подклассы обычно сохраняют эту традицию, создавая псевдоним eql? для переопределённого метода ==, однако бывают исключения. Например, типы Numeric выполняют преобразование типов при сравнении через ==, но не через eql?, поэтому:

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

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);
}

Возвращает целочисленный идентификатор для obj.

Для заданного объекта все вызовы object_id возвращают одно и то же число, и ни у каких двух активных объектов идентификаторы не совпадают.

Примечание: некоторые объекты встроенных классов повторно используются для оптимизации. Это относится к непосредственным значениям и замороженным строковым литералам.

BasicObject реализует __id__, а Kernel реализует object_id.

Непосредственные значения передаются не по ссылке, а по значению: nil, true, false, Fixnum, символы и некоторые значения Float.

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_f_send(int argc, VALUE *argv, VALUE recv)
{
    return send_internal_kw(argc, argv, recv, CALL_FCALL);
}

Вызывает метод, указанный в symbol, и передаёт ему заданные аргументы. Если метод указан строкой, она преобразуется в символ.

BasicObject реализует __send__, а Kernel реализует send. __send__ безопаснее, чем send, если у obj есть метод с таким же именем, как у Socket. См. также public_send.

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

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);
}

Вычисляет строку с исходным кодом Ruby или заданный блок в контексте получателя (obj). Чтобы задать контекст, во время выполнения кода переменной 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_exec_internal(int argc, const VALUE *argv, VALUE self)
{
    return yield_under(self, TRUE, argc, argv, 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_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);
}

Вызывается Ruby, когда obj получает сообщение, которое не может обработать. 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

#define rb_obj_singleton_method_added rb_obj_dummy1

Вызывается как обратный вызов при добавлении метода-одиночки к получателю.

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_removed 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_undefined 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