Object

Parent:BasicObjectIncluded modules:MakeMakefile, Kernel

Object是所有Ruby对象的默认根。对象从BasicObject继承，它允许创建替代对象层次结构。对象的方法可用于所有类，除非明确覆盖。

对象在内核模块中混合，使内置的内核函数可以全局访问。虽然Object的实例方法是由内核模块定义的，但为了清楚起见，我们选择在此处记录它们。

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

在对象方法的描述中，参数符号指的是一个符号，它可以是带引号的字符串，也可以是符号（如:name）。

常量

ARGF

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

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

ARGV

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

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

Bignum CROSS_COMPILING DATA

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

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

$ ruby t.rb
hello world!

ENV

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

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

FALSE

一个过时的别名 false

Fixnum NIL

一个过时的别名 nil

ParseError RUBY_COPYRIGHT

Ruby的版权字符串

RUBY_DESCRIPTION

全ruby版本字符串，如ruby -v版画

RUBY_ENGINE

这个ruby使用的引擎或解释器。

RUBY_ENGINE_VERSION

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

RUBY_PATCHLEVEL

这个ruby的patchlevel。如果这是ruby的开发版本，patchlevel将为-1

RUBY_PLATFORM

这个ruby的平台

RUBY_RELEASE_DATE

这个ruby发布的日期

RUBY_REVISION

这个ruby的SVN修订版。

RUBY_VERSION

Ruby的运行版本

SCRIPT_LINES__

如果SCRIPT_LINES__在分配后将加载的文件的内容分配给散列，则将以文件名作为关键字添加一行散列。

STDERR

保持原来的stderr

STDIN

保存原始标准输入

STDOUT

保存原始标准输出

Synchronizer

提供带计数器的两阶段锁定的类。有关详细信息，请参阅Sync_m。

Synchronizer_m

用计数器提供两相锁定的模块。

TOPLEVEL_BINDING

顶级范围的绑定

TRUE

一个过时的别名 true

ThWait

这个类监视多线程的终止。可以通过类方法ThreadsWait.all_waits访问基本功能（等到指定的线程终止）。使用实例方法可以获得更好的控制。

例：

ThreadsWait.all_waits(thr1, thr2, ...) do |t|
  STDERR.puts "Thread #{t} has terminated."
end

th = ThreadsWait.new(thread1,...)
th.next_wait # next one to be done

TimeoutError

当超时超时时，超时发生。

公共类方法

yaml_tag(url) Show source

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

公共实例方法

obj !~ other → true or false Show source

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

static VALUE
rb_obj_not_match(VALUE obj1, VALUE obj2)
{
    VALUE result = rb_funcall(obj1, id_match, 1, obj2);
    return RTEST(result) ? Qfalse : Qtrue;
}

obj <=> other → 0 or nil Show source

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

将<=>用于通过各种方法来比较的对象，例如可枚举＃排序，可枚举＃最大等

您的实现<=>应返回以下值之一：-1,0,1或零。-1意味着自己比其他人小。0表示自己等于其他。1表示自己比其他人大。无意味着两个值无法比较。

当你定义<=>，你可以包括堪比获得方法<=，<，==，>=，>和between?。

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

obj === other → true or false Show source

案例平等 - 对于类Object而言，与调用实际上相同#==，但通常被后代覆盖以在case语句中提供有意义的语义。

VALUE
rb_equal(VALUE obj1, VALUE obj2)
{
    VALUE result;

    if (obj1 == obj2) return Qtrue;
    result = rb_funcall(obj1, id_eq, 1, obj2);
    if (RTEST(result)) return Qtrue;
    return Qfalse;
}

obj =~ other → nil Show source

模式匹配 - 由后代覆盖（特别是Regexp和String）以提供有意义的模式匹配语义。

static VALUE
rb_obj_match(VALUE obj1, VALUE obj2)
{
    return Qnil;
}

CSV(*args, &block) Show source

传递args给CSV.instance。

CSV("CSV,data").read
  #=> [["CSV", "data"]]

如果给出了一个块，那么该实例将通过该块并且返回值将成为该块的返回值。

CSV("CSV,data") { |c|
  c.read.any? { |a| a.include?("data") }
} #=> true

CSV("CSV,data") { |c|
  c.read.any? { |a| a.include?("zombies") }
} #=> false

# File lib/csv.rb, line 2357
def CSV(*args, &block)
  CSV.instance(*args, &block)
end

DelegateClass(superclass) Show source

该库的主要接口。定义您的课程时用于设置代表团。

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

这里有一个使用Tempfile的例子，它实际上是一个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

调用超类方法

# File lib/delegate.rb, line 377
def DelegateClass(superclass)
  klass = Class.new(Delegator)
  methods = superclass.instance_methods
  methods -= ::Delegator.public_api
  methods -= [:to_s, :inspect, :=~, :!~, :===]
  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
    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.protected_instance_methods
  end
  klass.define_singleton_method :protected_instance_methods do |all=true|
    super(all) | superclass.protected_instance_methods
  end
  return klass
end

Digest(name) → digest_subclass Show source

name即使涉及按需加载，也会以线程安全的方式返回摘要子类。

require 'digest'

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

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

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

# File ext/digest/lib/digest.rb, line 95
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

class → class Show source

返回obj的类。此方法必须始终使用明确的接收方来调用，因为class它也是Ruby中的保留字。

1.class      #=> Integer
self.class   #=> Object

VALUE
rb_obj_class(VALUE obj)
{
    return rb_class_real(CLASS_OF(obj));
}

clone(freeze: true) → an_object Show source

产生的浅表副本OBJ的-the实例变量OBJ被复制，而不是它们所引用的对象。clone复制冻结（除非：冻结关键字参数赋予一个假值）和受污染的obj状态。另请参阅下面的讨论Object#dup。

class Klass
   attr_accessor :str
end
s1 = Klass.new      #=> #<Klass:0x401b3a38>
s1.str = "Hello"    #=> "Hello"
s2 = s1.clone       #=> #<Klass:0x401b3998 @str="Hello">
s2.str[1,4] = "i"   #=> "i"
s1.inspect          #=> "#<Klass:0x401b3a38 @str=\"Hi\">"
s2.inspect          #=> "#<Klass:0x401b3998 @str=\"Hi\">"

此方法可能具有类特定的行为。如果是这样，该行为将记录在initialize_copy该类的＃方法下。

static VALUE
rb_obj_clone2(int argc, VALUE *argv, VALUE obj)
{
    static ID keyword_ids[1];
    VALUE opt;
    VALUE kwargs[1];
    VALUE clone;
    VALUE singleton;
    VALUE kwfreeze = Qtrue;

    if (!keyword_ids[0]) {
        CONST_ID(keyword_ids[0], "freeze");
    }
    rb_scan_args(argc, argv, "0:", &opt);
    if (!NIL_P(opt)) {
        rb_get_kwargs(opt, keyword_ids, 0, 1, kwargs);
        kwfreeze = kwargs[0];
        if (kwfreeze != Qundef && kwfreeze != Qtrue && kwfreeze != Qfalse) {
            rb_raise(rb_eArgError, "unexpected value for freeze: %s",
                     rb_builtin_class_name(kwfreeze));
        }
    }

    if (special_object_p(obj)) {
        if (kwfreeze == Qfalse)
            rb_raise(rb_eArgError, "can't unfreeze %s", rb_obj_classname(obj));
        return obj;
    }
    clone = rb_obj_alloc(rb_obj_class(obj));
    RBASIC(clone)->flags &= (FL_TAINT|FL_PROMOTED0|FL_PROMOTED1);
    RBASIC(clone)->flags |= RBASIC(obj)->flags & ~(FL_PROMOTED0|FL_PROMOTED1|FL_FREEZE|FL_FINALIZE);

    singleton = rb_singleton_class_clone_and_attach(obj, clone);
    RBASIC_SET_CLASS(clone, singleton);
    if (FL_TEST(singleton, FL_SINGLETON)) {
        rb_singleton_class_attached(singleton, clone);
    }

    init_copy(clone, obj);
    rb_funcall(clone, id_init_clone, 1, obj);

    if (Qfalse != kwfreeze) {
        RBASIC(clone)->flags |= RBASIC(obj)->flags & FL_FREEZE;
    }

    return clone;
}

dclone() Show source

提供了一个统一的clone操作，用于REXML :: XPathParser跨多个对象类型使用

# File lib/rexml/xpath_parser.rb, line 10
def dclone
  clone
end

default_src_encoding() Show source

不要在这里写出任何神奇的评论。

# File lib/irb/src_encoding.rb, line 2
def default_src_encoding
  return __ENCODING__
end

define_singleton_method（符号，方法）→符号显示源代码

define_singleton_method(symbol) { block } → symbol

在接收器中定义一个单例方法。该方法的参数可以是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!"

static VALUE
rb_obj_define_method(int argc, VALUE *argv, VALUE obj)
{
    VALUE klass = rb_singleton_class(obj);

    return rb_mod_define_method(argc, argv, klass);
}

display(port=$>) → nil Show source

在给定端口上打印obj（默认$>）。相当于：

def display(port=$>)
  port.write self
  nil
end

例如：

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

生产：

1cat[4, 5, 6]

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

    if (argc == 0) {
        out = rb_stdout;
    }
    else {
        rb_scan_args(argc, argv, "01", &out);
    }
    rb_io_write(out, self);

    return Qnil;
}

dup → an_object Show source

产生的浅表副本OBJ的-the实例变量OBJ被复制，而不是它们所引用的对象。dup复制obj的受污染状态。

此方法可能具有类特定的行为。如果是这样，该行为将记录在initialize_copy该类的＃方法下。

在dup vs克隆上

在一般情况下，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:0x401b3a38>
s2.foo #=> "foo"

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

VALUE
rb_obj_dup(VALUE obj)
{
    VALUE dup;

    if (special_object_p(obj)) {
        return obj;
    }
    dup = rb_obj_alloc(rb_obj_class(obj));
    init_copy(dup, obj);
    rb_funcall(dup, id_init_dup, 1, obj);

    return dup;
}

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

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

创建一个新的枚举，这将通过调用枚举method上obj，传递args（如有）。

如果给出了一个块，它将被用来计算枚举器的大小，而不需要迭代它（参见枚举器的大小）。

例子

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)

当为泛型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

%[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

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()) {
        enumerator_ptr(enumerator)->size = rb_block_proc();
    }
    return enumerator;
}

obj == other → true or false Show source

equal?(other) → true or false

eql?(other) → true or 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;
}

extend(module, ...) → obj Show source

将每个模块的实例方法作为参数添加到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"

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);
    while (argc--) {
        rb_funcall(argv[argc], id_extend_object, 1, obj);
        rb_funcall(argv[argc], id_extended, 1, obj);
    }
    return obj;
}

freeze → obj Show source

阻止对obj的进一步修改。RuntimeError如果尝试修改，则会提出A. 无法解冻冻结的物体。另见Object#frozen?。

此方法返回自我。

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

produces:

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

以下类的对象总是被冻结：整数，浮点，符号。

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

frozen? → true or false Show source

Returns the freeze status of obj.

a = [ "a", "b", "c" ]
a.freeze    #=> ["a", "b", "c"]
a.frozen?   #=> true

VALUE
rb_obj_frozen_p(VALUE obj)
{
    return OBJ_FROZEN(obj) ? Qtrue : Qfalse;
}

hash → integer Show source

为此对象生成一个Integer散列值。此功能必须具有所a.eql?(b)暗示的属性a.hash == b.hash。

散列值与eql一起使用？通过Hash类来确定两个对象是否引用相同的散列键。任何超过Integer容量的散列值在使用前都会被截断。

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

VALUE
rb_obj_hash(VALUE obj)
{
    VALUE oid = rb_obj_id(obj);
#if SIZEOF_LONG == SIZEOF_VOIDP
    st_index_t index = NUM2LONG(oid);
#elif SIZEOF_LONG_LONG == SIZEOF_VOIDP
    st_index_t index = NUM2LL(oid);
#else
# error not supported
#endif
    return LONG2FIX(rb_objid_hash(index));
}

inspect → string Show source

返回一个包含obj的人类可读表示的字符串。默认inspect显示对象的类名，对象id的编码，以及实例变量及其值的列表（通过对它们中的每一个调用检查）。用户定义的类应该重写此方法以提供更好的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>"

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

instance_of?(class) → true or false Show source

如果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

VALUE
rb_obj_is_instance_of(VALUE obj, VALUE c)
{
    c = class_or_module_required(c);
    if (rb_obj_class(obj) == c) return Qtrue;
    return Qfalse;
}

instance_variable_defined?(symbol) → true or false Show source

instance_variable_defined?(string) → true or false

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

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

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

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

instance_variable_get(symbol) → obj Show source

instance_variable_get(string) → obj

返回给定实例变量的值，如果未设置实例变量，则返回nil。@应该为常规实例变量包含变量名称的一部分。NameError如果提供的符号作为实例变量名称无效，则引发异常。字符串参数被转换为符号。

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

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

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

instance_variable_set(symbol, obj) → obj Show source

instance_variable_set(string, obj) → obj

将由符号命名的实例变量设置为给定的对象，从而使该类作者试图提供适当封装的努力受挫。此调用之前，变量不必存在。如果实例变量名称作为字符串传递，则该字符串将转换为符号。

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\">"

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

instance_variables → array Show source

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

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

VALUE
rb_obj_instance_variables(VALUE obj)
{
    VALUE ary;

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

is_a?(class) → true or false Show source

返回true如果类是类的OBJ，或者如果类是的超类的一个OBJ或模块包括在物镜。

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

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

    c = class_or_module_required(c);
    return class_search_ancestor(cl, RCLASS_ORIGIN(c)) ? Qtrue : Qfalse;
}

itself → an_object Show source

返回obj。

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

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

kind_of?(class) → true or false Show source

返回true如果类是类的OBJ，或者如果类是的超类的一个OBJ或模块包括在物镜。

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

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

    c = class_or_module_required(c);
    return class_search_ancestor(cl, RCLASS_ORIGIN(c)) ? Qtrue : Qfalse;
}

method(sym) → method Show source

在obj中查找命名方法作为接收方，返回一个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"

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

methods(regular=true) → array Show source

返回obj的public和protected方法的名称列表。这将包括obj的祖先可以访问的所有方法。如果可选参数是false，它返回一个obj <'>的公共和受保护的单例方法数组，该数组将不包含<i> 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]

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

nil? → true or false Show source

只有对象无响应true到nil?。

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

static VALUE
rb_false(VALUE obj)
{
    return Qfalse;
}

__id__ → integer Show source

object_id → integer

返回一个整数标识符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);
}

private_methods(all=true) → array Show source

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

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

protected_methods(all=true) → array Show source

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

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

to_yaml(options = {}) Show source

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

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

Also aliased as: to_yaml

public_method(sym) → method Show source

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

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

public_methods(all=true) → array Show source

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

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

public_send(symbol , args...) → obj Show source

public_send(string , args...) → obj

调用由符号标识的方法，向其传递任何指定的参数。与发送不同，#public_send仅调用公共方法。当方法由字符串标识时，字符串将转换为符号。

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

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

remove_instance_variable(symbol) → obj Show source

从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

VALUE
rb_obj_remove_instance_variable(VALUE obj, VALUE name)
{
    VALUE val = Qnil;
    const ID id = id_for_var(obj, name, an, instance);
    st_data_t n, v;
    struct st_table *iv_index_tbl;
    st_data_t index;

    rb_check_frozen(obj);
    if (!id) {
	goto not_defined;
    }

    switch (BUILTIN_TYPE(obj)) {
      case T_OBJECT:
        iv_index_tbl = ROBJECT_IV_INDEX_TBL(obj);
        if (!iv_index_tbl) break;
        if (!st_lookup(iv_index_tbl, (st_data_t)id, &index)) break;
        if (ROBJECT_NUMIV(obj) <= index) break;
        val = ROBJECT_IVPTR(obj)[index];
        if (val != Qundef) {
            ROBJECT_IVPTR(obj)[index] = Qundef;
            return val;
        }
	break;
      case T_CLASS:
      case T_MODULE:
	n = id;
	if (RCLASS_IV_TBL(obj) && st_delete(RCLASS_IV_TBL(obj), &n, &v)) {
	    return (VALUE)v;
	}
	break;
      default:
	if (FL_TEST(obj, FL_EXIVAR)) {
	    if (generic_ivar_remove(obj, id, &val)) {
		return val;
	    }
	}
	break;
    }

  not_defined:
    rb_name_err_raise("instance variable %1$s not defined",
		      obj, name);
    UNREACHABLE;
}

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

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

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

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

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

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

static VALUE
obj_respond_to(int argc, VALUE *argv, VALUE obj)
{
    VALUE mid, priv;
    ID id;
    rb_thread_t *th = GET_THREAD();

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

respond_to_missing？（symbol，include_all）→true或false显示源

respond_to_missing?(string, include_all) → true or false

DO NOT USE THIS DIRECTLY.

Hook方法返回obj是否可以响应id方法。

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

请参阅respond_to？和BasicObject的示例。

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

send(symbol , args...) → obj Show source

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

singleton_class → class Show source

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

如果obj是nil，，true或者false，它分别返回NilClass，TrueClass或FalseClass。如果obj是整型，浮点型或符号，则会引发TypeError。

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

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

singleton_method(sym) → method Show source

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

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

VALUE
rb_obj_singleton_method(VALUE obj, VALUE vid)
{
    const rb_method_entry_t *me;
    VALUE klass;
    ID id = rb_check_id(&vid);

    if (!id) {
        if (!NIL_P(klass = rb_singleton_class_get(obj)) &&
            respond_to_missing_p(klass, obj, vid, FALSE)) {
            id = rb_intern_str(vid);
            return mnew_missing(klass, obj, id, rb_cMethod);
        }
      undef:
        rb_name_err_raise("undefined singleton method `%1$s' for `%2$s'",
                          obj, vid);
    }
    if (NIL_P(klass = rb_singleton_class_get(obj)) ||
        UNDEFINED_METHOD_ENTRY_P(me = rb_method_entry_at(klass, id)) ||
        UNDEFINED_REFINED_METHOD_P(me->def)) {
        vid = ID2SYM(id);
        goto undef;
    }
    return mnew_from_me(me, klass, obj, id, rb_cMethod, FALSE);
}

singleton_methods(all=true) → array Show source

返回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]

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

    if (argc == 0) {
	recur = Qtrue;
    }
    else {
	rb_scan_args(argc, argv, "01", &recur);
    }
    klass = CLASS_OF(obj);
    origin = RCLASS_ORIGIN(klass);
    me_arg.list = st_init_numtable();
    me_arg.recur = RTEST(recur);
    if (klass && FL_TEST(klass, FL_SINGLETON)) {
	if ((mtbl = RCLASS_M_TBL(origin)) != 0) rb_id_table_foreach(mtbl, method_entry_i, &me_arg);
	klass = RCLASS_SUPER(klass);
    }
    if (RTEST(recur)) {
	while (klass && (FL_TEST(klass, FL_SINGLETON) || 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_new();
    st_foreach(me_arg.list, ins_methods_i, ary);
    st_free_table(me_arg.list);

    return ary;
}

sysread(io, size) Show source

cgi_runner.rb – CGI launcher.

$IPR: cgi_runner.rb,v 1.9 2002/09/25 11:33:15 gotoyuzo Exp $

# File lib/webrick/httpservlet/cgi_runner.rb, line 11
def sysread(io, size)
  buf = ""
  while size > 0
    tmp = io.sysread(size)
    buf << tmp
    size -= tmp.bytesize
  end
  return buf
end

taint → obj Show source

将对象标记为污点。

被标记为污染的对象将受到各种内置方法的限制。这是为了防止不安全的数据，例如从Kernel＃gets读取的命令行参数或字符串，无意中破坏用户的系统。

要检查某个对象是否受污染，请使用受污染的？

如果您的代码已检查并确定它是安全的，则应该只对一个受污染的对象进行修剪。要做到这一点使用untaint。

VALUE
rb_obj_taint(VALUE obj)
{
    if (!OBJ_TAINTED(obj) && OBJ_TAINTABLE(obj)) {
        rb_check_frozen(obj);
        OBJ_TAINT(obj);
    }
    return obj;
}

tainted? → true or false Show source

如果对象受到污染，则返回true。

请参阅污点了解更多信息。

VALUE
rb_obj_tainted(VALUE obj)
{
    if (OBJ_TAINTED(obj))
        return Qtrue;
    return Qfalse;
}

tap{|x|...} → obj Show source

产生自我到块中，然后返回自我。该方法的主要目的是“挖掘”方法链，以便对链中的中间结果执行操作。

(1..10)                .tap {|x| puts "original: #{x.inspect}"}
  .to_a                .tap {|x| puts "array: #{x.inspect}"}
  .select {|x| x%2==0} .tap {|x| puts "evens: #{x.inspect}"}
  .map {|x| x*x}       .tap {|x| puts "squares: #{x.inspect}"}

VALUE
rb_obj_tap(VALUE obj)
{
    rb_yield(obj);
    return obj;
}

timeout(*args, &block) Show source

# File lib/timeout.rb, line 119
def timeout(*args, &block)
  warn "#{caller_locations(1, 1)[0]}: Object##{__method__} is deprecated, use Timeout.timeout instead."
  Timeout.timeout(*args, &block)
end

to_enum(method = :each, *args) → enum Show source

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

创建一个新的枚举，这将通过调用枚举method上obj，传递args（如有）。

如果给出了一个块，它将被用来计算枚举器的大小，而不需要迭代它（参见枚举器的大小）。

例子

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)

当为泛型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

%[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

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()) {
        enumerator_ptr(enumerator)->size = rb_block_proc();
    }
    return enumerator;
}

to_s → string Show source

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

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);
    OBJ_INFECT(str, obj);

    return str;
}

to_yaml(options = {})

Alias for: psych_to_yaml

trust → obj Show source

弃用的方法相当于不相关的。

VALUE
rb_obj_trust(VALUE obj)
{
    rb_warning("trust is deprecated and its behavior is same as untaint");
    return rb_obj_untaint(obj);
}

unknown() Show source

mathn可以使Ruby中的数学运算更精确，并集成其他数学标准库。

没有数学：

3 / 2 => 1 # Integer

用mathn：

3 / 2 => 3/2 # Rational

mathn保持准确的价值。

Without mathn:

20 / 9 * 3 * 14 / 7 * 3 / 2 # => 18

With mathn:

20 / 9 * 3 * 14 / 7 * 3 / 2 # => 20

当你需要'mathn'时，Prime，CMath，Matrix和Vector的库也会被加载。

版权

作者：Keiju ISHITSUKA（SHL Japan Inc.）

# File lib/mathn.rb, line 40
warn('lib/mathn.rb is deprecated') if $VERBOSE

untaint → obj Show source

从物体上移除污迹。

请参阅污点了解更多信息。

VALUE
rb_obj_untaint(VALUE obj)
{
    if (OBJ_TAINTED(obj)) {
        rb_check_frozen(obj);
        FL_UNSET(obj, FL_TAINT);
    }
    return obj;
}

untrust → obj Show source

弃用的方法相当于污染。

VALUE
rb_obj_untrust(VALUE obj)
{
    rb_warning("untrust is deprecated and its behavior is same as taint");
    return rb_obj_taint(obj);
}

untrusted? → true or false Show source

弃用的方法，相当于污染？

VALUE
rb_obj_untrusted(VALUE obj)
{
    rb_warning("untrusted? is deprecated and its behavior is same as tainted?");
    return rb_obj_tainted(obj);
}

xmp(exps, bind = nil) Show source

一种便利的方法，只有当您需要IRB :: XMP标准库时才可用。

创建一个新的XMP对象，使用给定的表达式作为exps参数，并可选绑定为bind或使用顶级绑定。然后使用:XMP提示模式评估给定的表达式。

例如：

require 'irb/xmp'
ctx = binding
xmp 'foo = "bar"', ctx
#=> foo = "bar"
  #==>"bar"
ctx.eval 'foo'
#=> "bar"

有关更多信息，请参阅XMP.new。

# File lib/irb/xmp.rb, line 164
def xmp(exps, bind = nil)
  bind = IRB::Frame.top(1) unless bind
  xmp = XMP.new(bind)
  xmp.puts exps
  xmp
end

本文档系腾讯云开发者社区成员共同维护，如有问题请联系 cloudcommunity@tencent.com

最后更新于：2017-12-18