类 Object

Object 是所有 Ruby 对象的默认根。 Object 继承自 BasicObject，这允许创建备用的对象层次结构。除非显式覆盖，否则 Object 上的方法可用于所有类。

Object 混入了 Kernel 模块，使得内置的内核函数可以全局访问。尽管 Object 的实例方法由 Kernel 模块定义，但为了清晰起见，我们选择在此处记录它们。

当引用继承自 Object 的类中的常量时，你不需要使用完整的命名空间。例如，在 YourClass 中引用 File 将找到顶级的 File 类。

在 Object 方法的描述中，参数 *symbol* 指的是一个符号，它要么是带引号的字符串，要么是一个 Symbol（例如 :name）。

这里有什么¶ ↑

首先，其他地方有什么。类 Object

继承自类 BasicObject。
包含模块 Kernel。

在这里，类 Object 提供了以下方法

查询¶ ↑

!~：如果 self 与给定的对象不匹配，则返回 true，否则返回 false。
<=>：如果 self 和给定的对象 object 是同一个对象，或者如果 self == object，则返回 0；否则返回 nil。
===：实现 case 相等，实际上与调用 == 相同。
eql?：实现哈希相等，实际上与调用 == 相同。
kind_of?（别名为 is_a?）：返回给定参数是否是 self 的单例类的祖先。
instance_of?：返回 self 是否是给定类的实例。
instance_variable_defined?：返回给定的实例变量是否在 self 中定义。
method：返回 self 中给定方法的 Method 对象。
methods：返回 self 中公共和受保护方法的符号名称数组。
nil?：返回 false。（只有 nil 对方法 nil? 返回 true。）
object_id：返回与当前进程唯一的 self 对应的整数
private_methods：返回 self 中私有方法的符号名称数组。
protected_methods：返回 self 中受保护方法的符号名称数组。
public_method：返回 self 中给定公共方法的 Method 对象。
public_methods：返回 self 中公共方法的符号名称数组。
respond_to?：返回 self 是否响应给定的方法。
singleton_class：返回 self 的单例类。
singleton_method：返回 self 中给定单例方法的 Method 对象。
singleton_methods：返回 self 中单例方法的符号名称数组。
define_singleton_method：在 self 中为给定的符号方法名称和块或 proc 定义一个单例方法。
extend：将给定的模块包含在 self 的单例类中。
public_send：使用给定的参数调用 self 中的给定公共方法。
send：使用给定的参数调用 self 中的给定方法。

实例变量¶ ↑

instance_variable_get：返回 self 中给定实例变量的值，如果未设置实例变量，则返回 nil。
instance_variable_set：将 self 中给定实例变量的值设置为给定对象。
instance_variables：返回 self 中实例变量的符号名称数组。
remove_instance_variable：从 self 中移除指定的实例变量。

其他¶ ↑

clone：返回 self 的浅拷贝，包括单例类和冻结状态。
define_singleton_method：在 self 中为给定的符号方法名称和块或 proc 定义一个单例方法。
display：将 self 打印到给定的 IO 流或 $stdout。
dup：返回 self 的浅层未冻结副本。
enum_for（别名为 to_enum）：使用给定的方法、参数和块为 self 返回一个 Enumerator。
extend：将给定的模块包含在 self 的单例类中。
freeze：防止进一步修改 self。
hash：返回 self 的整数哈希值。
inspect：返回 self 的人类可读的字符串表示形式。
itself：返回 self。
method_missing：在 self 上调用未定义的方法时调用的 Method。
public_send：使用给定的参数调用 self 中的给定公共方法。
send：使用给定的参数调用 self 中的给定方法。
to_s：返回 self 的字符串表示形式。

常量

ARGF

ARGF 是一个旨在用于处理作为命令行参数给定或通过 STDIN 传入的文件脚本中的流。

有关更多详细信息，请参阅 ARGF（类）。

ARGV

ARGV 包含用于运行 ruby 的命令行参数。

可以使用像 OptionParser 这样的库来处理命令行参数。

CROSS_COMPILING

DATA

DATA 是一个 File，其中包含已执行文件的数据部分。要创建数据部分，请使用 __END__

$ cat t.rb
puts DATA.gets
__END__
hello world!

$ ruby t.rb
hello world!

ENV

ENV 是一个类似于哈希的环境变量访问器。

有关更多详细信息，请参阅 ENV（类）。

RUBY_COPYRIGHT

ruby 的版权字符串

RUBY_DESCRIPTION

完整的 ruby 版本字符串，例如 ruby -v 打印的内容

RUBY_ENGINE

此 ruby 使用的引擎或解释器。

RUBY_ENGINE_VERSION

此 ruby 使用的引擎或解释器的版本。

RUBY_PATCHLEVEL

此 ruby 的补丁级别。如果这是 ruby 的开发版本，则补丁级别将为 -1

RUBY_PLATFORM

此 ruby 的平台

RUBY_RELEASE_DATE

此 ruby 的发布日期

RUBY_REVISION

此 ruby 的 GIT 提交哈希值。

RUBY_VERSION

正在运行的 ruby 版本

Readline

Ripper

这会将 prism ripper 翻译写入 Ripper 常量，以便用户可以透明地使用 Ripper 而无需任何更改。

STDERR

保留原始 stderr

STDIN

保留原始 stdin

STDOUT

保留原始 stdout

TOPLEVEL_BINDING

顶层作用域的 Binding

公共类方法

yaml_tag (url)

源代码

# File ext/psych/lib/psych/core_ext.rb, line 3
def self.yaml_tag url
  Psych.add_tag(url, self)
end

公共实例方法

obj !~ other → true 或 false

源代码

static VALUE
rb_obj_not_match(VALUE obj1, VALUE obj2)
{
    VALUE result = rb_funcall(obj1, id_match, 1, obj2);
    return rb_obj_not(result);
}

如果两个对象不匹配（使用 *=~* 方法），则返回 true，否则返回 false。

obj <=> other → 0 或 nil

源代码

static VALUE
rb_obj_cmp(VALUE obj1, VALUE obj2)
{
    if (rb_equal(obj1, obj2))
        return INT2FIX(0);
    return Qnil;
}

如果 obj 和 other 是同一对象或 obj == other，则返回 0，否则返回 nil。

<=> 被各种方法用于比较对象，例如 Enumerable#sort、Enumerable#max 等。

你对 <=> 的实现应返回以下值之一：-1、0、1 或 nil。 -1 表示 self 小于 other。 0 表示 self 等于 other。 1 表示 self 大于 other。 Nil 表示无法比较这两个值。

当你定义 <=> 时，你可以包含 Comparable 以获得方法 <=, <, ==, >=, > 和 between?。

true === other → true 或 false

false === other → true 或 false

nil === other → true 或 false

源代码

#define case_equal rb_equal

返回 true 或 false。

类似于 Object#==，如果 object 是 Object 的实例（而不是其众多子类之一的实例）。

此方法通常被这些子类覆盖，以便在 case 语句中提供有意义的语义。

DelegateClass (superclass, &block)

源代码

# File lib/delegate.rb, line 394
def DelegateClass(superclass, &block)
  klass = Class.new(Delegator)
  ignores = [*::Delegator.public_api, :to_s, :inspect, :=~, :!~, :===]
  protected_instance_methods = superclass.protected_instance_methods
  protected_instance_methods -= ignores
  public_instance_methods = superclass.public_instance_methods
  public_instance_methods -= ignores
  klass.module_eval do
    def __getobj__ # :nodoc:
      unless defined?(@delegate_dc_obj)
        return yield if block_given?
        __raise__ ::ArgumentError, "not delegated"
      end
      @delegate_dc_obj
    end
    def __setobj__(obj)  # :nodoc:
      __raise__ ::ArgumentError, "cannot delegate to self" if self.equal?(obj)
      @delegate_dc_obj = obj
    end
    protected_instance_methods.each do |method|
      define_method(method, Delegator.delegating_block(method))
      protected method
    end
    public_instance_methods.each do |method|
      define_method(method, Delegator.delegating_block(method))
    end
  end
  klass.define_singleton_method :public_instance_methods do |all=true|
    super(all) | superclass.public_instance_methods
  end
  klass.define_singleton_method :protected_instance_methods do |all=true|
    super(all) | superclass.protected_instance_methods
  end
  klass.define_singleton_method :instance_methods do |all=true|
    super(all) | superclass.instance_methods
  end
  klass.define_singleton_method :public_instance_method do |name|
    super(name)
  rescue NameError
    raise unless self.public_instance_methods.include?(name)
    superclass.public_instance_method(name)
  end
  klass.define_singleton_method :instance_method do |name|
    super(name)
  rescue NameError
    raise unless self.instance_methods.include?(name)
    superclass.instance_method(name)
  end
  klass.module_eval(&block) if block
  return klass
end

此库的主要接口。在定义类时，用于设置委托。

class MyClass < DelegateClass(ClassToDelegateTo) # Step 1
  def initialize
    super(obj_of_ClassToDelegateTo)              # Step 2
  end
end

或者

MyClass = DelegateClass(ClassToDelegateTo) do    # Step 1
  def initialize
    super(obj_of_ClassToDelegateTo)              # Step 2
  end
end

这是来自 Tempfile 的一个使用示例，它实际上是一个 File 对象，带有一些关于存储位置以及何时应删除 File 的特殊规则。这使得它成为如何使用委托的几乎完美的教科书示例。

class Tempfile < DelegateClass(File)
  # constant and class member data initialization...

  def initialize(basename, tmpdir=Dir::tmpdir)
    # build up file path/name in var tmpname...

    @tmpfile = File.open(tmpname, File::RDWR|File::CREAT|File::EXCL, 0600)

    # ...

    super(@tmpfile)

    # below this point, all methods of File are supported...
  end

  # ...
end

调用超类方法

Digest(name) → digest_subclass

源代码

# File ext/digest/lib/digest.rb, line 110
def Digest(name)
  const = name.to_sym
  Digest::REQUIRE_MUTEX.synchronize {
    # Ignore autoload's because it is void when we have #const_missing
    Digest.const_missing(const)
  }
rescue LoadError
  # Constants do not necessarily rely on digest/*.
  if Digest.const_defined?(const)
    Digest.const_get(const)
  else
    raise
  end
end

以线程安全的方式，通过 name 返回一个 Digest 子类，即使涉及到按需加载。

require 'digest'

Digest("MD5")
# => Digest::MD5

Digest(:SHA256)
# => Digest::SHA256

Digest(:Foo)
# => LoadError: library not found for class Digest::Foo -- digest/foo

define_singleton_method(symbol, method) → symbol

define_singleton_method(symbol) { block } → symbol

源代码

static VALUE
rb_obj_define_method(int argc, VALUE *argv, VALUE obj)
{
    VALUE klass = rb_singleton_class(obj);
    const rb_scope_visibility_t scope_visi = {METHOD_VISI_PUBLIC, FALSE};

    return rb_mod_define_method_with_visibility(argc, argv, klass, &scope_visi);
}

在接收者中定义一个公共的单例方法。method 参数可以是 Proc、Method 或 UnboundMethod 对象。如果指定了一个代码块，它将被用作方法体。如果代码块或方法有参数，它们将被用作方法参数。

class A
  class << self
    def class_name
      to_s
    end
  end
end
A.define_singleton_method(:who_am_i) do
  "I am: #{class_name}"
end
A.who_am_i   # ==> "I am: A"

guy = "Bob"
guy.define_singleton_method(:hello) { "#{self}: Hello there!" }
guy.hello    #=>  "Bob: Hello there!"

chris = "Chris"
chris.define_singleton_method(:greet) {|greeting| "#{greeting}, I'm Chris!" }
chris.greet("Hi") #=> "Hi, I'm Chris!"

display(port = $>) → nil

源代码

static VALUE
rb_obj_display(int argc, VALUE *argv, VALUE self)
{
    VALUE out;

    out = (!rb_check_arity(argc, 0, 1) ? rb_ractor_stdout() : argv[0]);
    rb_io_write(out, self);

    return Qnil;
}

在给定的端口上写入 self。

1.display
"cat".display
[ 4, 5, 6 ].display
puts

输出

1cat[4, 5, 6]

dup → an_object

源代码

VALUE
rb_obj_dup(VALUE obj)
{
    VALUE dup;

    if (special_object_p(obj)) {
        return obj;
    }
    dup = rb_obj_alloc(rb_obj_class(obj));
    return rb_obj_dup_setup(obj, dup);
}

生成 obj 的浅拷贝——obj 的实例变量被复制，但它们引用的对象不会被复制。

此方法可能具有特定于类的行为。如果存在，该行为将在该类的 #initialize_copy 方法下记录。

关于 dup 与 clone¶ ↑

一般来说，clone 和 dup 在派生类中可能具有不同的语义。虽然 clone 用于复制对象，包括其内部状态，但 dup 通常使用派生对象的类来创建新实例。

当使用 dup 时，对象已扩展的任何模块都不会被复制。

class Klass
  attr_accessor :str
end

module Foo
  def foo; 'foo'; end
end

s1 = Klass.new #=> #<Klass:0x401b3a38>
s1.extend(Foo) #=> #<Klass:0x401b3a38>
s1.foo #=> "foo"

s2 = s1.clone #=> #<Klass:0x401be280>
s2.foo #=> "foo"

s3 = s1.dup #=> #<Klass:0x401c1084>
s3.foo #=> NoMethodError: undefined method `foo' for #<Klass:0x401c1084>

enum_for(method = :each, *args) → enum

enum_for(method = :each, *args){|*args| block} → enum

创建一个新的 Enumerator，它将通过在 obj 上调用 method 来枚举，并传递任何 args（如果有）。方法 yield 的内容将成为枚举器的值。

如果给出了代码块，它将被用来计算枚举器的大小，而无需迭代它（参见 Enumerator#size）。

示例¶ ↑

str = "xyz"

enum = str.enum_for(:each_byte)
enum.each { |b| puts b }
# => 120
# => 121
# => 122

# protect an array from being modified by some_method
a = [1, 2, 3]
some_method(a.to_enum)

# String#split in block form is more memory-effective:
very_large_string.split("|") { |chunk| return chunk if chunk.include?('DATE') }
# This could be rewritten more idiomatically with to_enum:
very_large_string.to_enum(:split, "|").lazy.grep(/DATE/).first

在为泛型 Enumerable 定义方法时，如果没有传递代码块，通常会调用 to_enum。

这是一个这样的示例，带有参数传递和大小调整代码块

module Enumerable
  # a generic method to repeat the values of any enumerable
  def repeat(n)
    raise ArgumentError, "#{n} is negative!" if n < 0
    unless block_given?
      return to_enum(__method__, n) do # __method__ is :repeat here
        sz = size     # Call size and multiply by n...
        sz * n if sz  # but return nil if size itself is nil
      end
    end
    each do |*val|
      n.times { yield *val }
    end
  end
end

%i[hello world].repeat(2) { |w| puts w }
  # => Prints 'hello', 'hello', 'world', 'world'
enum = (1..14).repeat(3)
  # => returns an Enumerator when called without a block
enum.first(4) # => [1, 1, 1, 2]
enum.size # => 42

别名：to_enum

obj == other → true or false

equal?(other) → true or false

eql?(other) → true or false

源代码

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

相等性 — 在 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 的对象对，这两个对象的 hash 值必须相等。因此，任何覆盖 eql? 的子类也应该适当地覆盖 hash。

对于 Object 类的对象，eql? 与 == 同义。子类通常通过将 eql? 别名为它们重写的 == 方法来延续这一传统，但也有例外。例如，Numeric 类型在 == 中执行类型转换，但在 eql? 中不执行，所以

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

extend(module, ...) → obj

源代码

static VALUE
rb_obj_extend(int argc, VALUE *argv, VALUE obj)
{
    int i;
    ID id_extend_object, id_extended;

    CONST_ID(id_extend_object, "extend_object");
    CONST_ID(id_extended, "extended");

    rb_check_arity(argc, 1, UNLIMITED_ARGUMENTS);
    for (i = 0; i < argc; i++) {
        Check_Type(argv[i], T_MODULE);
        if (FL_TEST(argv[i], RMODULE_IS_REFINEMENT)) {
            rb_raise(rb_eTypeError, "Cannot extend object with refinement");
        }
    }
    while (argc--) {
        rb_funcall(argv[argc], id_extend_object, 1, obj);
        rb_funcall(argv[argc], id_extended, 1, obj);
    }
    return obj;
}

将作为参数给出的每个模块中的实例方法添加到 obj。

module Mod
  def hello
    "Hello from Mod.\n"
  end
end

class Klass
  def hello
    "Hello from Klass.\n"
  end
end

k = Klass.new
k.hello         #=> "Hello from Klass.\n"
k.extend(Mod)   #=> #<Klass:0x401b3bc8>
k.hello         #=> "Hello from Mod.\n"

freeze → obj

源代码

VALUE
rb_obj_freeze(VALUE obj)
{
    if (!OBJ_FROZEN(obj)) {
        OBJ_FREEZE(obj);
        if (SPECIAL_CONST_P(obj)) {
            rb_bug("special consts should be frozen.");
        }
    }
    return obj;
}

阻止对 obj 进行进一步的修改。如果尝试修改，将引发 FrozenError。没有办法解冻一个冻结的对象。另请参见 Object#frozen?。

此方法返回 self。

a = [ "a", "b", "c" ]
a.freeze
a << "z"

产生

prog.rb:3:in `<<': can't modify frozen Array (FrozenError)
 from prog.rb:3

以下类的对象始终是冻结的：Integer、Float、Symbol。

hash → integer

源代码

VALUE
rb_obj_hash(VALUE obj)
{
    long hnum = any_hash(obj, objid_hash);
    return ST2FIX(hnum);
}

为此对象生成一个 Integer 哈希值。此函数必须具有以下属性：a.eql?(b) 意味着 a.hash == b.hash。

哈希值与 eql? 一起被 Hash 类用于确定两个对象是否引用同一个哈希键。任何超过 Integer 容量的哈希值都将在使用前被截断。

一个对象的哈希值在 Ruby 的调用或实现中可能并不相同。如果您需要在 Ruby 的调用和实现中获得稳定的标识符，您需要使用自定义方法生成一个。

某些核心类，如 Integer，使用内置的哈希计算，并且在用作哈希键时不调用 hash 方法。

当基于多个值实现自己的 hash 时，最佳实践是使用数组的哈希码组合类和任何值

例如

def hash
  [self.class, a, b, c].hash
end

这样做的原因是 Array#hash 方法已经具有安全有效地组合多个哈希值的逻辑。

inspect → string

源代码

static VALUE
rb_obj_inspect(VALUE obj)
{
    if (rb_ivar_count(obj) > 0) {
        VALUE str;
        VALUE c = rb_class_name(CLASS_OF(obj));

        str = rb_sprintf("-<%"PRIsVALUE":%p", c, (void*)obj);
        return rb_exec_recursive(inspect_obj, obj, str);
    }
    else {
        return rb_any_to_s(obj);
    }
}

返回一个包含 obj 的人类可读表示的字符串。默认的 inspect 显示对象的类名、其内存地址的编码以及实例变量及其值的列表（通过在每个实例变量上调用 inspect）。用户定义的类应该重写此方法以提供 obj 的更好表示。重写此方法时，它应返回一个编码与默认外部编码兼容的字符串。

[ 1, 2, 3..4, 'five' ].inspect   #=> "[1, 2, 3..4, \"five\"]"
Time.new.inspect                 #=> "2008-03-08 19:43:39 +0900"

class Foo
end
Foo.new.inspect                  #=> "#<Foo:0x0300c868>"

class Bar
  def initialize
    @bar = 1
  end
end
Bar.new.inspect                  #=> "#<Bar:0x0300c868 @bar=1>"

instance_of?(class) → true or false

源代码

VALUE
rb_obj_is_instance_of(VALUE obj, VALUE c)
{
    c = class_or_module_required(c);
    return RBOOL(rb_obj_class(obj) == c);
}

如果 obj 是给定类的实例，则返回 true。另请参见 Object#kind_of?。

class A;     end
class B < A; end
class C < B; end

b = B.new
b.instance_of? A   #=> false
b.instance_of? B   #=> true
b.instance_of? C   #=> false

instance_variable_defined?(symbol) → true or false

instance_variable_defined?(string) → true or false

源代码

static VALUE
rb_obj_ivar_defined(VALUE obj, VALUE iv)
{
    ID id = id_for_var(obj, iv, instance);

    if (!id) {
        return Qfalse;
    }
    return rb_ivar_defined(obj, id);
}

如果给定的实例变量在 obj 中定义，则返回 true。String 参数将转换为符号。

class Fred
  def initialize(p1, p2)
    @a, @b = p1, p2
  end
end
fred = Fred.new('cat', 99)
fred.instance_variable_defined?(:@a)    #=> true
fred.instance_variable_defined?("@b")   #=> true
fred.instance_variable_defined?("@c")   #=> false

instance_variable_get(symbol) → obj

instance_variable_get(string) → obj

源代码

static VALUE
rb_obj_ivar_get(VALUE obj, VALUE iv)
{
    ID id = id_for_var(obj, iv, instance);

    if (!id) {
        return Qnil;
    }
    return rb_ivar_get(obj, id);
}

返回给定实例变量的值，如果未设置实例变量，则返回 nil。常规实例变量应包含变量名的 @ 部分。如果提供的符号作为实例变量名称无效，则抛出 NameError 异常。String 参数将转换为符号。

class Fred
  def initialize(p1, p2)
    @a, @b = p1, p2
  end
end
fred = Fred.new('cat', 99)
fred.instance_variable_get(:@a)    #=> "cat"
fred.instance_variable_get("@b")   #=> 99

instance_variable_set(symbol, obj) → obj

instance_variable_set(string, obj) → obj

源代码

static VALUE
rb_obj_ivar_set_m(VALUE obj, VALUE iv, VALUE val)
{
    ID id = id_for_var(obj, iv, instance);
    if (!id) id = rb_intern_str(iv);
    return rb_ivar_set(obj, id, val);
}

将由 symbol 命名的实例变量设置为给定对象。这可能会规避类的作者预期的封装，因此应谨慎使用。变量不必在此调用之前存在。如果实例变量名称作为字符串传递，则该字符串将转换为符号。

class Fred
  def initialize(p1, p2)
    @a, @b = p1, p2
  end
end
fred = Fred.new('cat', 99)
fred.instance_variable_set(:@a, 'dog')   #=> "dog"
fred.instance_variable_set(:@c, 'cat')   #=> "cat"
fred.inspect                             #=> "#<Fred:0x401b3da8 @a=\"dog\", @b=99, @c=\"cat\">"

instance_variables → array

源代码

VALUE
rb_obj_instance_variables(VALUE obj)
{
    VALUE ary;

    ary = rb_ary_new();
    rb_ivar_foreach(obj, ivar_i, ary);
    return ary;
}

返回接收者的实例变量名称数组。请注意，仅定义访问器不会创建相应的实例变量。

class Fred
  attr_accessor :a1
  def initialize
    @iv = 3
  end
end
Fred.new.instance_variables   #=> [:@iv]

is_a?(class) → true or false

如果 class 是 obj 的类，或者 class 是 obj 的超类之一或包含在 obj 中的模块之一，则返回 true。

module M;    end
class A
  include M
end
class B < A; end
class C < B; end

b = B.new
b.is_a? A          #=> true
b.is_a? B          #=> true
b.is_a? C          #=> false
b.is_a? M          #=> true

b.kind_of? A       #=> true
b.kind_of? B       #=> true
b.kind_of? C       #=> false
b.kind_of? M       #=> true

别名：kind_of?

itself → obj

源代码

static VALUE
rb_obj_itself(VALUE obj)
{
    return obj;
}

返回接收者。

string = "my string"
string.itself.object_id == string.object_id   #=> true

kind_of?(class) → true or false

源代码

VALUE
rb_obj_is_kind_of(VALUE obj, VALUE c)
{
    VALUE cl = CLASS_OF(obj);

    RUBY_ASSERT(RB_TYPE_P(cl, T_CLASS));

    // Fastest path: If the object's class is an exact match we know `c` is a
    // class without checking type and can return immediately.
    if (cl == c) return Qtrue;

    // Note: YJIT needs this function to never allocate and never raise when
    // `c` is a class or a module.

    if (LIKELY(RB_TYPE_P(c, T_CLASS))) {
        // Fast path: Both are T_CLASS
        return class_search_class_ancestor(cl, c);
    }
    else if (RB_TYPE_P(c, T_ICLASS)) {
        // First check if we inherit the includer
        // If we do we can return true immediately
        VALUE includer = RCLASS_INCLUDER(c);
        if (cl == includer) return Qtrue;

        // Usually includer is a T_CLASS here, except when including into an
        // already included Module.
        // If it is a class, attempt the fast class-to-class check and return
        // true if there is a match.
        if (RB_TYPE_P(includer, T_CLASS) && class_search_class_ancestor(cl, includer))
            return Qtrue;

        // We don't include the ICLASS directly, so must check if we inherit
        // the module via another include
        return RBOOL(class_search_ancestor(cl, RCLASS_ORIGIN(c)));
    }
    else if (RB_TYPE_P(c, T_MODULE)) {
        // Slow path: check each ancestor in the linked list and its method table
        return RBOOL(class_search_ancestor(cl, RCLASS_ORIGIN(c)));
    }
    else {
        rb_raise(rb_eTypeError, "class or module required");
        UNREACHABLE_RETURN(Qfalse);
    }
}

如果 class 是 obj 的类，或者 class 是 obj 的超类之一或包含在 obj 中的模块之一，则返回 true。

module M;    end
class A
  include M
end
class B < A; end
class C < B; end

b = B.new
b.is_a? A          #=> true
b.is_a? B          #=> true
b.is_a? C          #=> false
b.is_a? M          #=> true

b.kind_of? A       #=> true
b.kind_of? B       #=> true
b.kind_of? C       #=> false
b.kind_of? M       #=> true

也别名为：is_a?

method(sym) → method

源代码

VALUE
rb_obj_method(VALUE obj, VALUE vid)
{
    return obj_method(obj, vid, FALSE);
}

在 obj 中查找名为 method 的方法，返回一个 Method 对象（或引发 NameError）。Method 对象充当 obj 对象实例中的闭包，因此实例变量和 self 的值仍然可用。

class Demo
  def initialize(n)
    @iv = n
  end
  def hello()
    "Hello, @iv = #{@iv}"
  end
end

k = Demo.new(99)
m = k.method(:hello)
m.call   #=> "Hello, @iv = 99"

l = Demo.new('Fred')
m = l.method("hello")
m.call   #=> "Hello, @iv = Fred"

请注意，Method 实现了 to_proc 方法，这意味着它可以与迭代器一起使用。

[ 1, 2, 3 ].each(&method(:puts)) # => prints 3 lines to stdout

out = File.open('test.txt', 'w')
[ 1, 2, 3 ].each(&out.method(:puts)) # => prints 3 lines to file

require 'date'
%w[2017-03-01 2017-03-02].collect(&Date.method(:parse))
#=> [#<Date: 2017-03-01 ((2457814j,0s,0n),+0s,2299161j)>, #<Date: 2017-03-02 ((2457815j,0s,0n),+0s,2299161j)>]

methods(regular=true) → array

源代码

VALUE
rb_obj_methods(int argc, const VALUE *argv, VALUE obj)
{
    rb_check_arity(argc, 0, 1);
    if (argc > 0 && !RTEST(argv[0])) {
        return rb_obj_singleton_methods(argc, argv, obj);
    }
    return class_instance_method_list(argc, argv, CLASS_OF(obj), 1, ins_methods_i);
}

返回 obj 的公共和受保护方法的名称列表。这将包括 obj 的祖先中可访问的所有方法。如果可选参数为 false，则返回 obj 的公共和受保护的单例方法数组，该数组将不包括 obj 中包含的模块中的方法。

class Klass
  def klass_method()
  end
end
k = Klass.new
k.methods[0..9]    #=> [:klass_method, :nil?, :===,
                   #    :==~, :!, :eql?
                   #    :hash, :<=>, :class, :singleton_class]
k.methods.length   #=> 56

k.methods(false)   #=> []
def k.singleton_method; end
k.methods(false)   #=> [:singleton_method]

module M123; def m123; end end
k.extend M123
k.methods(false)   #=> [:singleton_method]

nil? → true or false

源代码

VALUE
rb_false(VALUE obj)
{
    return Qfalse;
}

只有对象 nil 对 nil? 返回 true。

Object.new.nil?   #=> false
nil.nil?          #=> true

__id__ → integer

object_id → integer

源代码

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 的所有调用都将返回相同的数字，并且没有两个活动对象将共享一个 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

private_methods(all=true) → array

源代码

VALUE
rb_obj_private_methods(int argc, const VALUE *argv, VALUE obj)
{
    return class_instance_method_list(argc, argv, CLASS_OF(obj), 1, ins_methods_priv_i);
}

返回 obj 可访问的私有方法的列表。如果 all 参数设置为 false，则仅列出接收者中的方法。

protected_methods(all=true) → array

源代码

VALUE
rb_obj_protected_methods(int argc, const VALUE *argv, VALUE obj)
{
    return class_instance_method_list(argc, argv, CLASS_OF(obj), 1, ins_methods_prot_i);
}

返回 obj 可访问的受保护方法的列表。如果 all 参数设置为 false，则仅列出接收者中的方法。

public_method(sym) → method

源代码

VALUE
rb_obj_public_method(VALUE obj, VALUE vid)
{
    return obj_method(obj, vid, TRUE);
}

与 method 类似，仅搜索公共方法。

public_methods(all=true) → array

源代码

VALUE
rb_obj_public_methods(int argc, const VALUE *argv, VALUE obj)
{
    return class_instance_method_list(argc, argv, CLASS_OF(obj), 1, ins_methods_pub_i);
}

返回 obj 可访问的公共方法的列表。如果 all 参数设置为 false，则仅列出接收者中的方法。

public_send(symbol [, args...]) → obj

public_send(string [, args...]) → obj

源代码

static VALUE
rb_f_public_send(int argc, VALUE *argv, VALUE recv)
{
    return send_internal_kw(argc, argv, recv, CALL_PUBLIC);
}

调用由 symbol 标识的方法，并传递任何指定的参数。与 send 不同，public_send 仅调用公共方法。当方法由字符串标识时，该字符串将转换为符号。

1.public_send(:puts, "hello")  # causes NoMethodError

remove_instance_variable(symbol) → obj

remove_instance_variable(string) → obj

源代码

VALUE
rb_obj_remove_instance_variable(VALUE obj, VALUE name)
{
    const ID id = id_for_var(obj, name, an, instance);

    // Frozen check comes here because it's expected that we raise a
    // NameError (from the id_for_var check) before we raise a FrozenError
    rb_check_frozen(obj);

    if (id) {
        VALUE val = rb_ivar_delete(obj, id, Qundef);

        if (!UNDEF_P(val)) return val;
    }

    rb_name_err_raise("instance variable %1$s not defined",
                      obj, name);
    UNREACHABLE_RETURN(Qnil);
}

从 obj 中删除命名的实例变量，并返回该变量的值。名称可以作为符号或字符串传递。

class Dummy
  attr_reader :var
  def initialize
    @var = 99
  end
  def remove
    remove_instance_variable(:@var)
  end
end
d = Dummy.new
d.var      #=> 99
d.remove   #=> 99
d.var      #=> nil

respond_to?(symbol, include_all=false) → true or false

respond_to?(string, include_all=false) → true or false

源代码

static VALUE
obj_respond_to(int argc, VALUE *argv, VALUE obj)
{
    VALUE mid, priv;
    ID id;
    rb_execution_context_t *ec = GET_EC();

    rb_scan_args(argc, argv, "11", &mid, &priv);
    if (!(id = rb_check_id(&mid))) {
        VALUE ret = basic_obj_respond_to_missing(ec, CLASS_OF(obj), obj,
                                                 rb_to_symbol(mid), priv);
        if (UNDEF_P(ret)) ret = Qfalse;
        return ret;
    }
    return  RBOOL(basic_obj_respond_to(ec, obj, id, !RTEST(priv)));
}

如果 obj 响应给定的方法，则返回 true。仅当可选的第二个参数评估为 true 时，才在搜索中包含私有和受保护的方法。

如果该方法未实现，例如 Windows 上的 Process.fork、GNU/Linux 上的 File.lchmod 等，则返回 false。

如果该方法未定义，则调用 respond_to_missing? 方法并返回结果。

当方法名称参数作为字符串给出时，该字符串将转换为符号。

respond_to_missing?(symbol, include_all) → true or false

respond_to_missing?(string, include_all) → true or false

源代码

static VALUE
obj_respond_to_missing(VALUE obj, VALUE mid, VALUE priv)
{
    return Qfalse;
}

请勿直接使用此方法。

挂钩方法，用于返回 obj 是否可以响应 id 方法。

当方法名称参数作为字符串给出时，该字符串将转换为符号。

请参阅 respond_to?，以及 BasicObject 的示例。

send(symbol [, args...]) → obj

__send__(symbol [, args...]) → obj

send(string [, args...]) → obj

__send__(字符串 [, 参数...]) → 对象

源代码

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

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

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"

singleton_class → 类

源代码

static VALUE
rb_obj_singleton_class(VALUE obj)
{
    return rb_singleton_class(obj);
}

返回 obj 的单例类。如果 obj 没有单例类，则此方法会创建一个新的单例类。

如果 obj 是 nil、true 或 false，则分别返回 NilClass、TrueClass 或 FalseClass。如果 obj 是 Integer、Float 或 Symbol，则会引发 TypeError。

Object.new.singleton_class  #=> #<Class:#<Object:0xb7ce1e24>>
String.singleton_class      #=> #<Class:String>
nil.singleton_class         #=> NilClass

singleton_method(sym) → 方法

源代码

VALUE
rb_obj_singleton_method(VALUE obj, VALUE vid)
{
    VALUE sc = rb_singleton_class_get(obj);
    VALUE klass;
    ID id = rb_check_id(&vid);

    if (NIL_P(sc) ||
        NIL_P(klass = RCLASS_ORIGIN(sc)) ||
        !NIL_P(rb_special_singleton_class(obj))) {
        /* goto undef; */
    }
    else if (! id) {
        VALUE m = mnew_missing_by_name(klass, obj, &vid, FALSE, rb_cMethod);
        if (m) return m;
        /* else goto undef; */
    }
    else {
        VALUE args[2] = {obj, vid};
        VALUE ruby_method = rb_rescue(rb_obj_singleton_method_lookup, (VALUE)args, rb_obj_singleton_method_lookup_fail, Qfalse);
        if (ruby_method) {
            struct METHOD *method = (struct METHOD *)RTYPEDDATA_GET_DATA(ruby_method);
            VALUE lookup_class = RBASIC_CLASS(obj);
            VALUE stop_class = rb_class_superclass(sc);
            VALUE method_class = method->iclass;

            /* Determine if method is in singleton class, or module included in or prepended to it */
            do {
                if (lookup_class == method_class) {
                    return ruby_method;
                }
                lookup_class = RCLASS_SUPER(lookup_class);
            } while (lookup_class && lookup_class != stop_class);
        }
    }

  /* undef: */
    vid = ID2SYM(id);
    rb_name_err_raise("undefined singleton method '%1$s' for '%2$s'",
                      obj, vid);
    UNREACHABLE_RETURN(Qundef);
}

与 method 类似，仅搜索单例方法。

class Demo
  def initialize(n)
    @iv = n
  end
  def hello()
    "Hello, @iv = #{@iv}"
  end
end

k = Demo.new(99)
def k.hi
  "Hi, @iv = #{@iv}"
end
m = k.singleton_method(:hi)
m.call   #=> "Hi, @iv = 99"
m = k.singleton_method(:hello) #=> NameError

singleton_methods(all=true) → 数组

源代码

VALUE
rb_obj_singleton_methods(int argc, const VALUE *argv, VALUE obj)
{
    VALUE ary, klass, origin;
    struct method_entry_arg me_arg;
    struct rb_id_table *mtbl;
    int recur = TRUE;

    if (rb_check_arity(argc, 0, 1)) recur = RTEST(argv[0]);
    if (RCLASS_SINGLETON_P(obj)) {
        rb_singleton_class(obj);
    }
    klass = CLASS_OF(obj);
    origin = RCLASS_ORIGIN(klass);
    me_arg.list = st_init_numtable();
    me_arg.recur = recur;
    if (klass && RCLASS_SINGLETON_P(klass)) {
        if ((mtbl = RCLASS_M_TBL(origin)) != 0) rb_id_table_foreach(mtbl, method_entry_i, &me_arg);
        klass = RCLASS_SUPER(klass);
    }
    if (recur) {
        while (klass && (RCLASS_SINGLETON_P(klass) || RB_TYPE_P(klass, T_ICLASS))) {
            if (klass != origin && (mtbl = RCLASS_M_TBL(klass)) != 0) rb_id_table_foreach(mtbl, method_entry_i, &me_arg);
            klass = RCLASS_SUPER(klass);
        }
    }
    ary = rb_ary_new2(me_arg.list->num_entries);
    st_foreach(me_arg.list, ins_methods_i, ary);
    st_free_table(me_arg.list);

    return ary;
}

返回一个包含 obj 的单例方法名称的数组。如果可选的 all 参数为 true，则列表将包括 obj 中包含的模块中的方法。仅返回公共和受保护的单例方法。

module Other
  def three() end
end

class Single
  def Single.four() end
end

a = Single.new

def a.one()
end

class << a
  include Other
  def two()
  end
end

Single.singleton_methods    #=> [:four]
a.singleton_methods(false)  #=> [:two, :one]
a.singleton_methods         #=> [:two, :one, :three]

to_enum(method = :each, *args) → 枚举器

to_enum(method = :each, *args) {|*args| block} → 枚举器

源代码

static VALUE
obj_to_enum(int argc, VALUE *argv, VALUE obj)
{
    VALUE enumerator, meth = sym_each;

    if (argc > 0) {
        --argc;
        meth = *argv++;
    }
    enumerator = rb_enumeratorize_with_size(obj, meth, argc, argv, 0);
    if (rb_block_given_p()) {
        RB_OBJ_WRITE(enumerator, &enumerator_ptr(enumerator)->size, rb_block_proc());
    }
    return enumerator;
}

创建一个新的 Enumerator，它将通过在 obj 上调用 method 来枚举，并传递任何 args（如果有）。方法 yield 的内容将成为枚举器的值。

如果给出了代码块，它将被用来计算枚举器的大小，而无需迭代它（参见 Enumerator#size）。

示例¶ ↑

str = "xyz"

enum = str.enum_for(:each_byte)
enum.each { |b| puts b }
# => 120
# => 121
# => 122

# protect an array from being modified by some_method
a = [1, 2, 3]
some_method(a.to_enum)

# String#split in block form is more memory-effective:
very_large_string.split("|") { |chunk| return chunk if chunk.include?('DATE') }
# This could be rewritten more idiomatically with to_enum:
very_large_string.to_enum(:split, "|").lazy.grep(/DATE/).first

在为泛型 Enumerable 定义方法时，如果没有传递代码块，通常会调用 to_enum。

这是一个这样的示例，带有参数传递和大小调整代码块

module Enumerable
  # a generic method to repeat the values of any enumerable
  def repeat(n)
    raise ArgumentError, "#{n} is negative!" if n < 0
    unless block_given?
      return to_enum(__method__, n) do # __method__ is :repeat here
        sz = size     # Call size and multiply by n...
        sz * n if sz  # but return nil if size itself is nil
      end
    end
    each do |*val|
      n.times { yield *val }
    end
  end
end

%i[hello world].repeat(2) { |w| puts w }
  # => Prints 'hello', 'hello', 'world', 'world'
enum = (1..14).repeat(3)
  # => returns an Enumerator when called without a block
enum.first(4) # => [1, 1, 1, 2]
enum.size # => 42

也别名为：enum_for

to_s → 字符串

源代码

VALUE
rb_any_to_s(VALUE obj)
{
    VALUE str;
    VALUE cname = rb_class_name(CLASS_OF(obj));

    str = rb_sprintf("#<%"PRIsVALUE":%p>", cname, (void*)obj);

    return str;
}

返回一个表示 obj 的字符串。默认的 to_s 会打印对象的类和对象 ID 的编码。作为一种特殊情况，作为 Ruby 程序初始执行上下文的顶层对象返回 “main”。

to_yaml(options = {})

源代码

# File ext/psych/lib/psych/core_ext.rb, line 12
def to_yaml options = {}
  Psych.dump self, options
end

将对象转换为 YAML。有关可用 options 的更多信息，请参阅 Psych.dump。