Ruby 4.0 リファレンスマニュアル

class Object

[edit]

dynamic include: JSON::Generator::GeneratorMethods::Object (by json)

要約

全てのクラスのスーパークラス。オブジェクトの一般的な振舞いを定義します。

このクラスのメソッドは上書きしたり未定義にしない限り、すべてのオブジェクトで使用できます。

目次

特異メソッド
インスタンスメソッド
privateメソッド
追加されるメソッド
再定義されたメソッド
説明のための未定義メソッド
定数

動的includeで追加されるメソッド

JSON::Generator::GeneratorMethods::Object (by json)

特異メソッド

new -> Object[permalink][rdoc][edit]

Objectクラスのインスタンスを生成して返します。 

some = Object.new
p some #=> #<Object:0x2b696d8>

インスタンスメソッド

self !~ other -> boolRuby 1.9.3 から[permalink][rdoc][edit]

自身が other とマッチしない事を判定します。

self#=~(obj) を反転した結果と同じ結果を返します。

[PARAM] other:
判定するオブジェクトを指定します。
例 
obj = 'regexp'
p (obj !~ /re/) # => false

obj = nil
p (obj !~ /re/) # => true
self <=> other -> 0 | nilRuby 1.9.3 から[permalink][rdoc][edit]

self === other である場合に 0 を返します。そうでない場合には nil を返します。

例 
a = Object.new
b = Object.new
p a <=> a # => 0
p a <=> b # => nil

[SEE_ALSO] Object#===

self == other -> bool[permalink][rdoc][edit]

オブジェクトと other が等しければ真を返します。

このメソッドは各クラスの性質に合わせて再定義すべきです。多くの場合、オブジェクトの内容が等しければ真を返すように（同値性を判定するように）再定義されることが期待されています。

デフォルトでは equal? と同じオブジェクトの同一性判定になっています。

[PARAM] other:
比較するオブジェクトです。
例 
o = Object.new
p(o.eql?(o)) #=> true
p(o.eql?(Object.new)) #=> false

下記の例のように、各クラスの性質に合わせて再定義されることが期待されています。

適切に再定義されている例 
p("foo" == "bar") #=> false
p("foo" == "foo") #=> true

p(4 == 4) #=> true
p(4 == 4.0) #=> true

[SEE_ALSO] Object#equal?,Object#eql?

self === other -> bool[permalink][rdoc][edit]

case 式で使用されるメソッドです。制御構造/case も参照してください。

このメソッドは case 式での振る舞いを考慮して、各クラスの性質に合わせて再定義すべきです。

デフォルトでは内部で Object#== を呼び出します。

when 節の式をレシーバーとして === を呼び出すことに注意してください。

また Enumerable#grep でも使用されます。

[PARAM] other:
比較するオブジェクトです。 
age = 12
# (0..2).===(12), (3..6).===(12), ... が実行される
result =
  case age
  when 0 .. 2
    "baby"
  when 3 .. 6
    "little child"
  when 7 .. 12
    "child"
  when 13 .. 18
    "youth"
  else
    "adult"
  end

puts result #=> "child"

def check arg
  case arg
  when /ruby(?!\s*on\s*rails)/i
    "hit! #{arg}"
  when String
    "Instance of String class. But don't hit."
  else
    "unknown"
  end
end

puts check([]) #=> unknown
puts check("mash-up in Ruby on Rails") #=> instance of String class. But not hit...
puts check("<Ruby's world>") #=> hit! <Ruby's world>

[SEE_ALSO] Object#==, Range#===, Module#===, Regexp#===, Enumerable#grep

_dump(limit) -> String[permalink][rdoc][edit]

Marshal?.dump において出力するオブジェクトがメソッド _dump を定義している場合には、そのメソッドの結果が書き出されます。

バージョン1.8.0以降ではObject#marshal_dump, Object#marshal_loadの使用が推奨されます。 Marshal.dump するオブジェクトが _dump と marshal_dump の両方のメソッドを持つ場合は marshal_dump が優先されます。

メソッド _dump は引数として再帰を制限するレベル limit を受け取り、オブジェクトを文字列化したものを返します。

インスタンスがメソッド _dump を持つクラスは必ず同じフォーマットを読み戻すクラスメソッド _load を定義する必要があります。_load はオブジェクトを表現した文字列を受け取り、それをオブジェクトに戻したものを返す必要があります。

[PARAM] limit:
再帰の制限レベルを表す整数です。
[RETURN]
オブジェクトを文字列化したものを返すように定義すべきです。 
class Foo
  def initialize(arg)
    @foo = arg
  end
  def _dump(limit)
    Marshal.dump(@foo, limit)
  end
  def self._load(obj)
    p obj
    Foo.new(Marshal.load(obj))
  end
end
foo = Foo.new(['foo', 'bar'])
p foo                      #=> #<Foo:0xbaf234 @foo=["foo", "bar"]>
dms = Marshal.dump(foo)
p dms                      #=> "\004\bu:\bFoo\023\004\b[\a\"\bfoo\"\bbar"
result = Marshal.load(dms) #=> "\004\b[\a\"\bfoo\"\bbar" # self._load の引数
p result                   #=> #<Foo:0xbaf07c @foo=["foo", "bar"]>

インスタンス変数の情報は普通マーシャルデータに含まれるので、上例のように _dump を定義する必要はありません(ただし _dump を定義するとインスタンス変数の情報は dump されなくなります)。 _dump/_load はより高度な制御を行いたい場合や拡張ライブラリで定義したクラスのインスタンスがインスタンス変数以外に情報を保持する場合に利用します。(例えば、クラス Time は、_dump/_load を定義しています)

[SEE_ALSO] Object#marshal_dump, Object#marshal_load, Class#_load

class -> Class[permalink][rdoc][edit]

レシーバのクラスを返します。 

p "ruby".class #=> String
p 100.class #=> Integer
p ARGV.class #=> Array
p self.class #=> Object
p Class.class #=> Class
p Kernel.class #=> Module

[SEE_ALSO] Class#superclass,Object#kind_of?,Object#instance_of?

clone(freeze: nil) -> object[permalink][rdoc][edit]

オブジェクトの複製を作成して返します。

clone は、オブジェクトの内容に加えて freeze の状態や特異メソッドなどの情報も含めた完全な複製を作成します。

clone や dup は浅い(shallow)コピーであることに注意してください。後述。

TrueClass, FalseClass, NilClass, Symbol, そして Numeric クラスのインスタンスなど一部のオブジェクトは複製ではなくインスタンス自身を返します。

[PARAM] freeze:
true を指定すると freeze されたコピーを返します。 false を指定すると freeze されていないコピーを返します。 nil を指定すると、レシーバが freeze されていれば freeze されたコピーを、freeze されていなければ freeze されていないコピーを返します。
[EXCEPTION] ArgumentError:
TrueClass などの常に freeze されているオブジェクトの freeze されていないコピーを作成しようとしたときに発生します。 
obj = "string"
def obj.fuga
end
obj.freeze

p(obj.equal?(obj))          #=> true
p(obj == obj)               #=> true
p(obj.frozen?)              #=> true
p(obj.respond_to?(:fuga))   #=> true

obj_c = obj.clone

p(obj.equal?(obj_c))        #=> false
p(obj == obj_c)             #=> true
p(obj_c.frozen?)            #=> true
p(obj_c.respond_to?(:fuga)) #=> true

[SEE_ALSO] Object#initialize_copy, Object#initialize_clone, Object#dup

深いコピーと浅いコピー

clone や dup はオブジェクト自身を複製するだけで、オブジェクトの指している先(たとえば配列の要素など)までは複製しません。これを浅いコピー(shallow copy)といいます。

深い(deep)コピーが必要な場合には、 Marshalモジュールを利用して 

Marshal.load(Marshal.dump(obj))

このように複製を作成する方法があります。ただしMarshal出来ないオブジェクトが含まれている場合には使えません。 

obj = ["a","b","c"]

obj_d = obj.dup
obj_d[0] << "PLUS"

p obj   #=> ["aPLUS", "b", "c"]
p obj_d #=> ["aPLUS", "b", "c"]

obj_m = Marshal.load(Marshal.dump(obj))
obj_m[1] << "PLUS"

p obj   #=> ["aPLUS", "b", "c"]
p obj_m #=> ["aPLUS", "bPLUS", "c"]
define_singleton_method(symbol, method) -> SymbolRuby 1.9.3 から[permalink][rdoc][edit]
define_singleton_method(symbol) { ... } -> Symbol

self に特異メソッド name を定義します。

[PARAM] symbol:
メソッド名を String または Symbol で指定します。
[PARAM] method:
Proc、Method あるいは UnboundMethod のいずれかのインスタンスを指定します。
[RETURN]
メソッド名を表す Symbol を返します。 
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!" }
p guy.hello  #=>  "Bob: Hello there!"
display(out = $stdout) -> nil[permalink][rdoc][edit]

オブジェクトを out に出力します。

以下のように定義されています。 

class Object
  def display(out = $stdout)
    out.write self
    nil
  end
end
[PARAM] out:
出力先のIOオブジェクトです。指定しない場合は標準出力に出力されます。
[RETURN]
nil を返します。 
p Object.new.display #=> #<Object:0xbb0210>

[SEE_ALSO] $stdout

dup -> object[permalink][rdoc][edit]

オブジェクトの複製を作成して返します。

dup は、オブジェクトの内容をコピーします。 Object#clone と異なり、freeze の状態や特異メソッドはコピーされません。

浅いコピー・複製の詳細は Object#clone を参照してください。 

obj = "string"
def obj.fuga
end
obj.freeze

p(obj.equal?(obj))          #=> true
p(obj == obj)               #=> true
p(obj.frozen?)              #=> true
p(obj.respond_to?(:fuga))   #=> true

obj_d = obj.dup

p(obj.equal?(obj_d))        #=> false
p(obj == obj_d)             #=> true
p(obj_d.frozen?)            #=> false # clone と異なり freeze はコピーされない
p(obj_d.respond_to?(:fuga)) #=> false # 特異メソッドもコピーされない

[SEE_ALSO] Object#initialize_copy, Object#initialize_dup, Object#clone

to_enum(method = :each, *args) -> Enumerator[permalink][rdoc][edit]
enum_for(method = :each, *args) -> Enumerator
to_enum(method = :each, *args) {|*args| ... } -> Enumerator
enum_for(method = :each, *args) {|*args| ... } -> Enumerator

Enumerator.new(self, method, *args) を返します。

ブロックを指定した場合は Enumerator#size がブロックの評価結果を返します。ブロックパラメータは引数 args です。

[PARAM] method:
メソッド名の文字列かシンボルです。
[PARAM] args:
呼び出すメソッドに渡される引数です。 
str = "xyz"

enum = str.enum_for(:each_byte)
p(a = enum.map{|b| '%02x' % b }) #=> ["78", "79", "7a"]

# protects an array from being modified
a = [1, 2, 3]
p(a.to_enum) #=> #<Enumerator: [1, 2, 3]:each>
例(ブロックを指定する場合) 
module Enumerable
  def repeat(n)
    raise ArgumentError, "#{n} is negative!" if n < 0
    unless block_given?
      # __method__ はここでは :repeat
      return to_enum(__method__, n) do
        # size メソッドが nil でなければ size * n を返す。
        sz = size
        sz * n if sz
      end
    end
    each do |*val|
      n.times { yield *val }
    end
  end
end

%i[hello world].repeat(2) { |w| puts w }
# => 'hello', 'hello', 'world', 'world'
enum = (1..14).repeat(3)
# => #<Enumerator: 1..14:repeat(3)>
p enum.first(4) # => [1, 1, 1, 2]
p enum.size # => 42

[SEE_ALSO] Enumerator, Enumerator#size

eql?(other) -> bool[permalink][rdoc][edit]

オブジェクトと other が等しければ真を返します。Hash のキー比較をはじめ、Array#uniq や Set など、要素の同値性を判定するさまざまな場面で Object#hash とともに使われます。

このメソッドは各クラスの性質に合わせて再定義すべきです。多くの場合、 == と同様に同値性の判定をするように再定義されていますが、適切にキー判定ができるようにより厳しくなっている場合もあります。

デフォルトでは equal? と同じオブジェクトの同一性判定になっています。

このメソッドを再定義した時には Object#hash メソッドも再定義しなければなりません。

[PARAM] other:
比較するオブジェクトです。 
p("foo".eql?("bar")) #=> false
p("foo".eql?("foo")) #=> true

p(4.eql?(4)) #=> true
p(4.eql?(4.0)) #=> false

[SEE_ALSO] Object#hash,Object#equal?,Object#==,Array#uniq,Set

equal?(other) -> bool[permalink][rdoc][edit]

other が self 自身の時、真を返します。

二つのオブジェクトが同一のものかどうか調べる時に使用します。このメソッドを再定義してはいけません。

お互いのObject#object_idが一致するかどうかを調べます。

[PARAM] other:
比較するオブジェクトです。 
p("foo".equal?("bar")) #=> false
p("foo".equal?("foo")) #=> false

p(4.equal?(4)) #=> true
p(4.equal?(4.0)) #=> false

p(:foo.equal? :foo) #=> true

[SEE_ALSO] Object#object_id,Object#==,Object#eql?,Symbol

extend(*modules) -> self[permalink][rdoc][edit]

引数で指定したモジュールのインスタンスメソッドを self の特異メソッドとして追加します。

Module#include は、クラス(のインスタンス)に機能を追加しますが、extend は、ある特定のオブジェクトだけにモジュールの機能を追加したいときに使用します。

引数に複数のモジュールを指定した場合、最後の引数から逆順に extend を行います。

[PARAM] modules:
モジュールを任意個指定します（クラスは不可）。
[RETURN]
self を返します。 
module Foo
  def a
    'ok Foo'
  end
end

module Bar
  def b
    'ok Bar'
  end
end

obj = Object.new
obj.extend Foo, Bar
p obj.a #=> "ok Foo"
p obj.b #=> "ok Bar"

class Klass
  include Foo
  extend Bar
end

p Klass.new.a #=> "ok Foo"
p Klass.b     #=> "ok Bar"

extend の機能は、「特異クラスに対する Module#include」と言い替えることもできます。ただしその場合、フック用のメソッドが Module#extended ではなく Module#included になるという違いがあります。 

# obj.extend Foo, Bar とほぼ同じ
class << obj
  include Foo, Bar
end

[SEE_ALSO] Module#extend_object,Module#include,Module#extended

freeze -> self[permalink][rdoc][edit]

オブジェクトを凍結（内容の変更を禁止）します。

凍結されたオブジェクトの変更は例外 FrozenError を発生させます。いったん凍結されたオブジェクトを元に戻す方法はありません。

凍結されるのはオブジェクトであり、変数ではありません。代入などで変数の指すオブジェクトが変化してしまうことは freeze では防げません。 freeze が防ぐのは、 破壊的な操作 と呼ばれるもの一般です。変数への参照自体を凍結したい場合は、グローバル変数なら Kernel?.trace_var が使えます。

[RETURN]
self を返します。 
a1 = "foo".freeze
a1 = "bar"
p a1 #=> "bar"

a2 = "foo".freeze
a2.replace("bar") # can't modify frozen String (FrozenError)

凍結を解除することはできませんが、Object#dup を使えばほぼ同じ内容の凍結されていないオブジェクトを得ることはできます。 

a = [1].freeze
p a.frozen?     #=> true

a[0] = "foo"
p a             # can't modify frozen Array (FrozenError)

b = a.dup
p b             #=> [1]
p b.frozen?     #=> false

b[0] = "foo"
p b             #=> ["foo"]

[SEE_ALSO] Object#frozen?,Object#dup,Kernel?.trace_var

frozen? -> bool[permalink][rdoc][edit]

オブジェクトが凍結（内容の変更を禁止）されているときに真を返します。 

obj = "someone"
p obj.frozen? #=> false
obj.freeze
p obj.frozen? #=> true

[SEE_ALSO] Object#freeze

hash -> Integer[permalink][rdoc][edit]

オブジェクトのハッシュ値を返します。このハッシュ値は、Object#eql? と合わせて Hash クラスで、2つのオブジェクトを同一のキーとするか判定するために用いられます。

2つのオブジェクトのハッシュ値が異なるとき、直ちに異なるキーとして判定されます。逆に、2つのハッシュ値が同じとき、さらに Object#eql? での比較により判定されます。そのため、同じキーとして判定される状況は Object#eql? の比較で真となる場合のみであり、このとき前段階としてハッシュ値どうしが等しい必要があります。つまり、 

A.eql?(B) ならば A.hash == B.hash

の関係が満たされている必要があります。

ただし、ハッシュのキーとして Integer, Symbol, String などの特定の組み込みクラスが使われるときは、組込みのハッシュ関数が使用され、hash メソッドは呼ばれません。

hash メソッドを再定義する場合は、一様に分布する任意の整数を返すようにします。

[RETURN]
ハッシュ値を返します。Ruby 内部の固定長整数 fixnum に収まらない場合は切り捨てられます。 
p self.hash #=> 2013505522753096494
p 0.hash    #=> 2647535320520409998
p 0.0.hash  #=> -2975129765814025835
p nil.hash  #=> 2401531420355998067

p "ruby".hash #=> 4460896024486900438
p "ruby".hash #=> 4460896024486900438
p :ruby.hash  #=> 3979895509189707770
p :ruby.hash  #=> 3979895509189707770

[SEE_ALSO] Object#eql?, Hash#[]

inspect -> String[permalink][rdoc][edit]

オブジェクトを人間が読める形式に変換した文字列を返します。

組み込み関数 Kernel?.p は、このメソッドの結果を使用してオブジェクトを表示します。 

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

inspect メソッドをオーバーライドしなかった場合、クラス名とインスタンス変数の名前、値の組を元にした文字列を返します。 

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

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

inspect をオーバーライドしていない場合、 instance_variables_to_inspect を定義することで、inspect の出力に含めるインスタンス変数を制御できます。このメソッドは、表示したいインスタンス変数名を Symbol の配列で返すようにします（デフォルトの実装は nil を返し、その場合は全てのインスタンス変数が表示されます）。パスワードなどの機密情報を持つインスタンス変数を inspect の出力（ログなど）に含めたくない場合に利用できます。 

class Foo
  def initialize
    @a = 1
    @password = "secret"
    @b = 2
  end
  private def instance_variables_to_inspect = [:@a, :@b]
end
p Foo.new.inspect                # => "#<Foo:0x0300c868 @a=1, @b=2>"

[SEE_ALSO] Kernel?.p

instance_of?(klass) -> bool[permalink][rdoc][edit]

オブジェクトがクラス klass の直接のインスタンスである時真を返します。

obj.instance_of?(c) が成立する時には、常に obj.kind_of?(c) も成立します。

[PARAM] klass:
Classかそのサブクラスのインスタンスです。 
class C < Object
end
class S < C
end

obj = S.new
p obj.instance_of?(S)       # true
p obj.instance_of?(C)       # false

[SEE_ALSO] Object#kind_of?,Object#class

instance_variable_defined?(var) -> bool[permalink][rdoc][edit]

インスタンス変数 var が定義されていたら真を返します。

[PARAM] var:
インスタンス変数名を文字列か Symbol で指定します。 
class Fred
  def initialize(p1, p2)
    @a, @b = p1, p2
  end
end
fred = Fred.new('cat', 99)
p fred.instance_variable_defined?(:@a)    #=> true
p fred.instance_variable_defined?("@b")   #=> true
p fred.instance_variable_defined?("@c")   #=> false

[SEE_ALSO] Object#instance_variable_get,Object#instance_variable_set,Object#instance_variables

instance_variable_get(var) -> object | nil[permalink][rdoc][edit]

オブジェクトのインスタンス変数の値を取得して返します。

インスタンス変数が定義されていなければ nil を返します。

[PARAM] var:
インスタンス変数名を文字列か Symbol で指定します。 
class Foo
  def initialize
    @foo = 1
  end
end

obj = Foo.new
p obj.instance_variable_get("@foo")     #=> 1
p obj.instance_variable_get(:@foo)      #=> 1
p obj.instance_variable_get(:@bar)      #=> nil

[SEE_ALSO] Object#instance_variable_set,Object#instance_variables,Object#instance_variable_defined?

instance_variable_set(var, value) -> object[permalink][rdoc][edit]

オブジェクトのインスタンス変数 var に値 value を設定します。

インスタンス変数が定義されていなければ新たに定義されます。

[PARAM] var:
インスタンス変数名を文字列か Symbol で指定します。
[PARAM] value:
設定する値です。
[RETURN]
value を返します。 
obj = Object.new
p obj.instance_variable_set("@foo", 1)  #=> 1
p obj.instance_variable_set(:@foo, 2)   #=> 2
p obj.instance_variable_get(:@foo)      #=> 2

[SEE_ALSO] Object#instance_variable_get,Object#instance_variables,Object#instance_variable_defined?

instance_variables -> [Symbol][permalink][rdoc][edit]

オブジェクトのインスタンス変数名をシンボルの配列として返します。 

obj = Object.new
obj.instance_eval { @foo, @bar = nil }
p obj.instance_variables

#=> [:@foo, :@bar]

[SEE_ALSO] Object#instance_variable_get, Kernel?.local_variables, Kernel?.global_variables, Module.constants, Module#constants, Module#class_variables

is_a?(mod) -> bool[permalink][rdoc][edit]
kind_of?(mod) -> bool

オブジェクトが指定されたクラス mod かそのサブクラスのインスタンスであるとき真を返します。

また、オブジェクトがモジュール mod をインクルードしたクラスかそのサブクラスのインスタンスである場合にも真を返します。 Module#includeだけではなく、Object#extendやModule#prependによってサブクラスのインスタンスになる場合も含みます。上記のいずれでもない場合に false を返します。

[PARAM] mod:
クラスやモジュールなど、Moduleかそのサブクラスのインスタンスです。 
module M
end
class C < Object
  include M
end
class S < C
end

obj = S.new
p obj.is_a?(S)       # true
p obj.is_a?(C)       # true
p obj.is_a?(Object)  # true
p obj.is_a?(M)       # true
p obj.is_a?(Hash)    # false

[SEE_ALSO] Object#instance_of?,Module#===,Object#class

itself -> objectRuby 2.2.0 から[permalink][rdoc][edit]

self を返します。 

string = 'my string' # => "my string"
p string.itself.object_id == string.object_id # => true
marshal_dump -> object[permalink][rdoc][edit]

Marshal?.dump を制御するメソッドです。

Marshal.dump(some) において、出力するオブジェクト some がメソッド marshal_dump を持つ場合には、その返り値がダンプされたものが Marshal.dump(some) の返り値となります。

marshal_dump/marshal_load の仕組みは Ruby 1.8.0 から導入されました。これから書くプログラムでは _dump/_load ではなく marshal_dump/marshal_load を使うべきです。

[RETURN]
任意のオブジェクトで marshal_load の引数に利用できます。 
class Foo
  def initialize(arg)
    @foo = arg
  end
  def marshal_dump
    @foo
  end
  def marshal_load(obj)
    p obj
    @foo = obj
  end
end
foo = Foo.new(['foo', 'bar'])
p foo                      #=> #<Foo:0xbaf3b0 @foo=["foo", "bar"]>
dms = Marshal.dump(foo)
p dms                      #=> "\004\bU:\bFoo[\a\"\bfoo\"\bbar"
result = Marshal.load(dms) #=> ["foo", "bar"] # marshal_load の引数
p result                   #=> #<Foo:0xbaf2ac @foo=["foo", "bar"]>

インスタンス変数の情報は普通マーシャルデータに含まれるので、上例のように marshal_dump を定義する必要はありません (ただし marshal_dump を定義するとインスタンス変数の情報はダンプされなくなるので、marshal_dump/marshal_load で扱う必要があります)。 marshal_dump/marshal_load はより高度な制御を行いたい場合や拡張ライブラリで定義したクラスのインスタンスがインスタンス変数以外に情報を保持する場合に利用します。

特に、marshal_dump/marshal_load を定義したオブジェクトは特異メソッドが定義されていてもマーシャルできるようになります (特異メソッドの情報が自動的に dump されるようになるわけではなく、 marshal_dump/marshal_load によりそれを実現する余地があるということです)。

[SEE_ALSO] Object#marshal_load, Marshal

marshal_load(obj) -> object[permalink][rdoc][edit]

Marshal?.load を制御するメソッドです。

some のダンプ結果（Marshal.dump(some)） をロードする（Marshal.load(Marshal.dump(some))）には some がメソッド marshal_load を持っていなければなりません。このとき、marshal_dump の返り値が marshal_load の引数に利用されます。 marshal_load 時の self は、生成されたばかり（Class#allocate されたばかり） の状態です。

marshal_dump/marshal_load の仕組みは Ruby 1.8.0 から導入されました。これから書くプログラムでは _dump/_load ではなく marshal_dump/marshal_load を使うべきです。

[PARAM] obj:
marshal_dump の返り値のコピーです。
[RETURN]
返り値は無視されます。

[SEE_ALSO] Object#marshal_dump, Marshal

method(name) -> Method[permalink][rdoc][edit]

オブジェクトのメソッド name をオブジェクト化した Method オブジェクトを返します。

[PARAM] name:
メソッド名をSymbol またはStringで指定します。
[EXCEPTION] NameError:
定義されていないメソッド名を引数として与えると発生します。 
me = -365.method(:abs)
p me #=> #<Method: Integer#abs>
p me.call #=> 365

Method・UnboundMethod オブジェクトを取得するメソッドの対比は次のとおりです。

メソッド対象可視性の制限返り値
Object#methodレシーバのメソッド（特異メソッドを含む）なしMethod
Object#public_methodレシーバのメソッド（特異メソッドを含む）public のみMethod
Object#singleton_methodレシーバの特異メソッドのみなしMethod
Module#instance_methodself のインスタンスメソッドなしUnboundMethod
Module#public_instance_methodself のインスタンスメソッドpublic のみUnboundMethod

UnboundMethod はレシーバに束縛されていない状態のメソッドオブジェクトです。UnboundMethod#bind でレシーバに束縛すると Method になり、逆に Method#unbind で UnboundMethod に戻せます。

[SEE_ALSO] Module#instance_method, Method, BasicObject#__send__, Object#send, Kernel?.eval, Object#singleton_method

methods(include_inherited = true) -> [Symbol][permalink][rdoc][edit]

そのオブジェクトに対して呼び出せるメソッド名の一覧を返します。このメソッドは public メソッドおよび protected メソッドの名前を返します。

ただし特別に、引数が偽の時は Object#singleton_methods(false) と同じになっています。

[PARAM] include_inherited:
引数が偽の時は Object#singleton_methods(false) と同じになります。
例1 
class Parent
  private;   def private_parent()   end
  protected; def protected_parent() end
  public;    def public_parent()    end
end

class Foo < Parent
  private;   def private_foo()   end
  protected; def protected_foo() end
  public;    def public_foo()    end
end

obj = Foo.new
class <<obj
    private;   def private_singleton()   end
    protected; def protected_singleton() end
    public;    def public_singleton()    end
end

# あるオブジェクトの応答できるメソッドの一覧を得る。
p obj.methods(false)
p obj.public_methods(false)
p obj.private_methods(false)
p obj.protected_methods(false)

# 実行結果
[:protected_singleton, :public_singleton]
[:public_singleton, :public_foo]
[:private_singleton, :private_foo]
[:protected_singleton, :protected_foo]
例2 
# あるオブジェクトの応答できるメソッドの一覧を得る。
# 自身のクラスの親クラスのインスタンスメソッドも含めるために true を指定して
# いるが、Object のインスタンスメソッドは一覧から排除している。
p obj.methods(true)           - Object.instance_methods(true)
p obj.public_methods(true)    - Object.public_instance_methods(true)
p obj.private_methods(true)   - Object.private_instance_methods(true)
p obj.protected_methods(true) - Object.protected_instance_methods(true)

# 実行結果
[:protected_singleton, :public_singleton, :protected_foo, :public_foo, :protected_parent, :public_parent]
[:public_singleton, :public_foo, :public_parent]
[:private_singleton, :private_foo, :private_parent]
[:protected_singleton, :protected_foo, :protected_parent]

メソッド名一覧を取得するメソッド同士の対比は次のとおりです。Object#methods 系はレシーバ自身が応答できるメソッド（特異メソッドを含む）を対象にするのに対し、Module#instance_methods 系はクラス・モジュールが持つインスタンスメソッド（特異メソッドは含まない）を対象にします。

メソッド対象含まれる可視性特異メソッド
Object#methodsレシーバpublic, protected含む
Object#public_methodsレシーバpublic含む
Object#private_methodsレシーバprivate含む
Object#protected_methodsレシーバprotected含む
Object#singleton_methodsレシーバpublic, protected特異メソッドのみ
Module#instance_methodsself のインスタンスpublic, protected含まない
Module#public_instance_methodsself のインスタンスpublic含まない
Module#private_instance_methodsself のインスタンスprivate含まない
Module#protected_instance_methodsself のインスタンスprotected含まない

継承したメソッドを含めるかどうかなどを引数で制御できますが、引数の意味はメソッドごとに異なります（Object#methods は引数が false のとき特異メソッドのみを返します）。詳細は各メソッドの説明を参照してください。

[SEE_ALSO] Module#instance_methods,Object#singleton_methods

nil? -> bool[permalink][rdoc][edit]

レシーバが nil であれば真を返します。 

p false.nil? #=> false
p nil.nil? #=> true

[SEE_ALSO] NilClass

object_id -> Integer[permalink][rdoc][edit]

各オブジェクトに対して一意な整数を返します。あるオブジェクトに対してどのような整数が割り当てられるかは不定です。

Rubyでは、(Garbage Collectされていない)アクティブなオブジェクト間で重複しない整数(object_id)が各オブジェクトにひとつずつ割り当てられています。このメソッドはその値を返します。

TrueClass, FalseClass, NilClass, Symbol, Integer クラスのインスタンスなど Immutable（変更不可）なオブジェクトの一部は同じ内容ならば必ず同じ object_id になります。

これは、Immutable ならば複数の場所から参照されても破壊的操作による問題が発生しないので、同じ内容のインスタンスを複数生成しないという内部実装が理由です。 

p "ruby".object_id #=> 60
p "ruby".object_id #=> 80

p [].object_id #=> 100
p [].object_id #=> 120

p :ruby.object_id #=> 710428
p :ruby.object_id #=> 710428

p 11.object_id #=> 23
p 11.object_id #=> 23

p true.object_id #=> 20
p true.object_id #=> 20

[SEE_ALSO] Object#equal?,BasicObject#__id__,Symbol

private_methods(include_inherited = true) -> [Symbol][permalink][rdoc][edit]

そのオブジェクトが理解できる private メソッド名の一覧を返します。

[PARAM] include_inherited:
偽となる値を指定すると自身のクラスのスーパークラスで定義されたメソッドを除きます。

[SEE_ALSO] Module#private_instance_methods,Object#methods,Object#singleton_methods

protected_methods(include_inherited = true) -> [Symbol][permalink][rdoc][edit]

そのオブジェクトが理解できる protected メソッド名の一覧を返します。

[PARAM] include_inherited:
偽となる値を指定すると自身のクラスのスーパークラスで定義されたメソッドを除きます。

[SEE_ALSO] Module#protected_instance_methods,Object#methods,Object#singleton_methods

public_method(name) -> MethodRuby 1.9.3 から[permalink][rdoc][edit]

オブジェクトの public メソッド name をオブジェクト化した Method オブジェクトを返します。

[PARAM] name:
メソッド名を Symbol または String で指定します。
[EXCEPTION] NameError:
定義されていないメソッド名や、 protected メソッド名、 private メソッド名を引数として与えると発生します。 
p 1.public_method(:to_int) #=> #<Method: Integer#to_int>
1.public_method(:p)      #   method 'p' for class 'Integer' is private (NameError)

[SEE_ALSO] Object#method,Object#public_send,Module#public_instance_method

public_methods(include_inherited = true) -> [Symbol][permalink][rdoc][edit]

そのオブジェクトが理解できる public メソッド名の一覧を返します。

[PARAM] include_inherited:
偽となる値を指定すると自身のクラスのスーパークラスで定義されたメソッドを除きます。

[SEE_ALSO] Module#public_instance_methods,Object#methods,Object#singleton_methods

public_send(name, *args) -> objectRuby 1.9.3 から[permalink][rdoc][edit]
public_send(name, *args) { .... } -> object

オブジェクトの public メソッド name を args を引数にして呼び出し、メソッドの実行結果を返します。

ブロック付きで呼ばれたときはブロックもそのまま引き渡します。 

p 1.public_send(:+, 2)  # => 3
[PARAM] name:
文字列かSymbol で指定するメソッド名です。
[PARAM] args:
呼び出すメソッドに渡す引数です。
[EXCEPTION] ArgumentError:
name を指定しなかった場合に発生します。
[EXCEPTION] NoMethodError:
protected メソッドや private メソッドに対して実行した場合に発生します。 
1.public_send(:puts, "hello")  # ~> NoMethodError

[SEE_ALSO] BasicObject#__send__, Object#send

remove_instance_variable(name) -> object[permalink][rdoc][edit]

オブジェクトからインスタンス変数 name を取り除き、そのインスタンス変数に設定されていた値を返します。

[PARAM] name:
削除するインスタンス変数の名前をシンボルか文字列で指定します。
[EXCEPTION] NameError:
オブジェクトがインスタンス変数 name を持たない場合に発生します。 
class Foo
  def foo
    @foo = 1
    p remove_instance_variable(:@foo) #=> 1
    p remove_instance_variable(:@foo) # instance variable @foo not defined (NameError)
  end
end
Foo.new.foo

[SEE_ALSO] Module#remove_class_variable,Module#remove_const

respond_to?(name, include_all = false) -> bool[permalink][rdoc][edit]

オブジェクトがメソッド name を持つとき真を返します。

オブジェクトが メソッド name を持つというのは、オブジェクトが メソッド name に応答できることをいいます。

Windows での Process.fork や GNU/Linux での File.lchmod のような NotImplementedError が発生する場合は false を返します。

※ NotImplementedError が発生する場合に false を返すのは Rubyの組み込みライブラリや標準ライブラリなど、C言語で実装されているメソッドのみです。 Rubyで実装されたメソッドで NotImplementedError が発生する場合は true を返します。

メソッドが定義されていない場合は、Object#respond_to_missing? を呼び出してその結果を返します。

[PARAM] name:
Symbol または文字列で指定するメソッド名です。
[PARAM] include_all:
private メソッドと protected メソッドを確認の対象に含めるかを true か false で指定します。省略した場合は false(含めない) を指定した事になります。 
class F
  def hello
    "Bonjour"
  end
end

class D
  private
  def hello
    "Guten Tag"
  end
end
list = [F.new,D.new]

list.each{|it| puts it.hello if it.respond_to?(:hello)}
#=> Bonjour

list.each{|it| it.instance_eval("puts hello if it.respond_to?(:hello, true)")}
#=> Bonjour
#   Guten Tag

module Template
  def main
    start
    template_method
    finish
  end

  def start
    puts "start"
  end

  def template_method
    raise NotImplementedError.new
  end

  def finish
    puts "finish"
  end
end

class ImplTemplateMethod
  include Template
  def template_method
    "implement template_method"
  end
end

class NotImplTemplateMethod
  include Template

  # not implement template_method
end

puts ImplTemplateMethod.new.respond_to?(:template_method) # => true
# NotImplementedError が発生しているが、Rubyによる実装部のため true を返す
puts NotImplTemplateMethod.new.respond_to?(:template_method) # => true
# GNU/Linux で実行。C言語による実装部のため false を返す
puts File.respond_to?(:lchmod)         # => false

[SEE_ALSO] Module#method_defined?

send(name, *args) -> object[permalink][rdoc][edit]
send(name, *args) { .... } -> object

オブジェクトのメソッド name を args を引数にして呼び出し、メソッドの実行結果を返します。

ブロック付きで呼ばれたときはブロックもそのまま引き渡します。

send が再定義された場合に備えて別名 __send__ も用意されており、ライブラリではこちらを使うべきです。また __send__ は再定義すべきではありません。

send, __send__ は、メソッドの呼び出し制限にかかわらず任意のメソッドを呼び出せます。 クラス／メソッドの定義/呼び出し制限 も参照してください。

public メソッドだけ呼び出せれば良い場合は Object#public_send を使う方が良いでしょう。

[PARAM] name:
文字列かSymbol で指定するメソッド名です。
[PARAM] args:
呼び出すメソッドに渡す引数です。 
p -365.send(:abs) #=> 365
p "ruby".send(:sub,/./,"R") #=> "Ruby"


class Foo
  def foo() "foo" end
  def bar() "bar" end
  def baz() "baz" end
end

# 任意のキーとメソッド(の名前)の関係をハッシュに保持しておく
# レシーバの情報がここにはないことに注意
methods = {1 => :foo,
  2 => :bar,
  3 => :baz}

# キーを使って関連するメソッドを呼び出す
# レシーバは任意(Foo クラスのインスタンスである必要もない)
p Foo.new.send(methods[1])      # => "foo"
p Foo.new.send(methods[2])      # => "bar"
p Foo.new.send(methods[3])      # => "baz"

[SEE_ALSO] Object#public_send, BasicObject#__send__, Object#method, Kernel?.eval, Proc, Method

singleton_class -> ClassRuby 1.9.3 から[permalink][rdoc][edit]

レシーバの特異クラスを返します。まだ特異クラスがなければ、新しく作成します。

レシーバが nil か true か false なら、それぞれ NilClass, TrueClass, FalseClass を返します。

[EXCEPTION] TypeError:
レシーバが Integer、Float、Symbol の場合に発生します。 
p Object.new.singleton_class  #=> #<Class:#<Object:0xb7ce1e24>>
p String.singleton_class    #=> #<Class:String>
p nil.singleton_class       #=> NilClass

[SEE_ALSO] Object#class

singleton_method(name) -> MethodRuby 2.1.0 から[permalink][rdoc][edit]

オブジェクトの特異メソッド name をオブジェクト化した Method オブジェクトを返します。

特異クラスに include / prepend されたモジュールのインスタンスメソッド（例えば Object#extend で追加したモジュールのメソッド）も対象になります。

[PARAM] name:
メソッド名をSymbol またはStringで指定します。
[EXCEPTION] NameError:
定義されていないメソッド名を引数として与えると発生します。 
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)    # => #<Method: #<Demo:0xf8b0c3c4 @iv=99>.hi>
p m.call #=> "Hi, @iv = 99"
m = k.singleton_method(:hello) # ~> NameError
例: extend で追加したモジュールのメソッド 
o = Object.new
o.extend(Module.new { def a = 1 })
p o.singleton_method(:a).call # => 1

[SEE_ALSO] Module#instance_method, Method, BasicObject#__send__, Object#send, Kernel?.eval, Object#method

singleton_methods(inherited_too = true) -> [Symbol][permalink][rdoc][edit]

そのオブジェクトに対して定義されている特異メソッド名 (public あるいは protected メソッド) の一覧を返します。

inherited_too が真のときは継承した特異メソッドを含みます。継承した特異メソッドとは Object#extend によって追加された特異メソッドや、 self がクラスの場合はスーパークラスのクラスメソッド(Classのインスタンスの特異メソッド)などです。

singleton_methods(false) は、Object#methods(false) と同じです。

[PARAM] inherited_too:
継承した特異メソッドを含める場合は真を、そうでない場合は偽を指定します。
例1 
Parent = Class.new

class <<Parent
  private;   def private_class_parent() end
  protected; def protected_class_parent() end
  public;    def public_class_parent() end
end

Foo = Class.new(Parent)

class <<Foo
  private;   def private_class_foo() end
  protected; def protected_class_foo() end
  public;    def public_class_foo() end
end

module Bar
  private;   def private_bar()   end
  protected; def protected_bar() end
  public;    def public_bar()    end
end

obj = Foo.new
class <<obj
  include Bar
  private;   def private_self()   end
  protected; def protected_self() end
  public;    def public_self()    end
end

# あるオブジェクトの特異メソッドの一覧を得る。
p obj.singleton_methods(false)
p obj.methods(false)
p Foo.singleton_methods(false)

#実行結果

[:protected_self, :public_self]
[:protected_self, :public_self]
[:protected_class_foo, :public_class_foo]
例2 
# あるオブジェクトの特異メソッドの一覧を得る。
# 親クラスのクラスメソッドも含まれるよう true を指定したが、
# Object のクラスメソッドは一覧から排除している。

p obj.singleton_methods(true)
p Foo.singleton_methods(true) - Object.singleton_methods(true)

#実行結果

[:protected_self, :public_self, :protected_bar, :public_bar]
[:protected_class_foo, :public_class_foo, :protected_class_parent, :public_class_parent]

[SEE_ALSO] Object#methods,Object#extend

tap {|x| ... } -> self[permalink][rdoc][edit]

self を引数としてブロックを評価し、self を返します。

メソッドチェインの途中で直ちに操作結果を表示するためにメソッドチェインに "入り込む" ことが、このメソッドの主目的です。 

(1..10)                  .tap {|x| puts "original: #{x}" }
  .to_a                  .tap {|x| puts "array:    #{x}" }
  .select {|x| x.even? } .tap {|x| puts "evens:    #{x}" }
  .map {|x| x*x }        .tap {|x| puts "squares:  #{x}" }

[SEE_ALSO] Object#yield_self

yield_self {|x| ... } -> objectRuby 2.5.0 から[permalink][rdoc][edit]
yield_self -> EnumeratorRuby 2.5.0 から
then {|x| ... } -> objectRuby 2.6.0 から
then -> EnumeratorRuby 2.6.0 から

self を引数としてブロックを評価し、ブロックの結果を返します。

例 
p 3.next.then {|x| x**x }.to_s           # => "256"
p "my string".yield_self {|s| s.upcase } # => "MY STRING"

値をメソッドチェインのパイプラインに次々と渡すのは良い使い方です。

メソッドチェインのパイプライン 
require 'open-uri'
require 'json'

construct_url(arguments).
  yield_self {|url| URI(url).read }.
  yield_self {|response| JSON.parse(response) }

ブロックなしで呼び出されたときは Enumerator を返します。例えば条件によって値を捨てるのに使えます。 

# 条件にあうので何もしない
p 1.yield_self.detect(&:odd?)          # => 1
# 条件に合わないので値を捨てる
p 2.yield_self.detect(&:odd?)          # => nil

[SEE_ALSO] Object#tap

to_s -> String[permalink][rdoc][edit]

オブジェクトの文字列表現を返します。

Kernel?.print や Kernel?.sprintf は文字列以外のオブジェクトが引数に渡された場合このメソッドを使って文字列に変換します。 

class Foo
  def initialize num
    @num = num
  end
end
it = Foo.new(40)

puts it #=> #<Foo:0x2b69110>

class Foo
  def to_s
    "Class:Foo Number:#{@num}"
  end
end

puts it #=> Class:Foo Number:40

[SEE_ALSO] Object#to_str,Kernel?.String

privateメソッド

initialize(*args, &block) -> object[permalink][rdoc][edit]

ユーザ定義クラスのオブジェクト初期化メソッド。

このメソッドは Class#new から新しく生成されたオブジェクトの初期化のために呼び出されます。他の言語のコンストラクタに相当します。デフォルトの動作ではなにもしません。

initialize には Class#new に与えられた引数がそのまま渡されます。

サブクラスではこのメソッドを必要に応じて再定義されることが期待されています。

initialize という名前のメソッドは自動的に private に設定されます。

[PARAM] args:
初期化時の引数です。
[PARAM] block:
初期化時のブロック引数です。必須ではありません。 
class Foo
  def initialize name
    puts "initialize Foo"
    @name = name
  end
end

class Bar < Foo
  def initialize name, pass
    puts "initialize Bar"
    super name
    @pass = pass
  end
end

it = Bar.new('myname','0500')
p it
#=> initialize Bar
#   initialize Foo
#   #<Bar:0x2b68f08 @name="myname", @pass="0500">

[SEE_ALSO] Class#new

initialize_clone(obj, freeze: nil) -> objectRuby 1.9.2 から[permalink][rdoc][edit]

Object#clone がオブジェクトを複製する際に呼び出すメソッドです。

デフォルトの実装は freeze キーワード引数を無視して Object#initialize_copy を呼び出し、self を返します。複製したオブジェクトを freeze するかどうかは、このメソッドの呼び出し元である Object#clone が判断します。

freeze キーワード引数には、Object#clone に渡された freeze の値がそのまま渡されます。 clone と dup で挙動を変えたいなどの理由でこのメソッドを再定義する場合は、 freeze キーワード引数を受け取り、super へそのまま渡すようにしてください。

initialize_clone という名前のメソッドは自動的に private に設定されます。

[PARAM] freeze:
Object#clone に渡された freeze の値(true, false, nil のいずれか)が渡されます。

[SEE_ALSO] Object#clone, Object#initialize_copy, Object#initialize_dup

initialize_copy(obj) -> object[permalink][rdoc][edit]

(拡張ライブラリによる) ユーザ定義クラスのオブジェクトコピーの初期化メソッド。

このメソッドは self を obj の内容で置き換えます。ただし、self のインスタンス変数や特異メソッドは変化しません。

デフォルトでは、Object#clone の内部で Object#initialize_clone から、また Object#dup の内部で Object#initialize_dup から呼ばれます。

initialize_copy は、Ruby インタプリタが知り得ない情報をコピーするために使用(定義)されます。例えば C 言語でクラスを実装する場合、情報をインスタンス変数に保持させない場合がありますが、そういった内部情報を initialize_copy でコピーするよう定義しておくことで、dup や clone を再定義する必要がなくなります。

デフォルトの Object#initialize_copy の実装は、 self が freeze されていないことと、 self と obj のクラスが一致していることをチェックして self を返します。

initialize_copy という名前のメソッドは自動的に private に設定されます。

[EXCEPTION] TypeError:
レシーバが freeze されているか、obj のクラスがレシーバのクラスと異なる場合に発生します。

[SEE_ALSO] Object#clone,Object#dup

dup や clone は以下の手順でオブジェクトを複製します。

obj.dup は、 obj.class のアロケータを呼び出して新しいオブジェクトを生成します。新たに生成したオブジェクトに対して obj のインスタンス変数、ファイナライザをコピーします。 obj.clone は、さらに特異メソッドもコピーします。

その後、新しいオブジェクトに対して initialize_dup 経由で initialize_copy を呼びます。 obj.clone は initialize_clone 経由で initialize_copy を呼びます。

最後に obj.clone は、 obj が freeze されているか、引数に freeze: true を指定した場合、新しいオブジェクトを freeze します。

例: ユーザ定義クラスに追加のコピー処理を定義する 
class MyClass
  attr_reader :data
  def initialize(data)
    @data = data
  end

  # 通常dupはインスタンス変数をそのまま引き継ぐが、
  # initialize_copyを定義することでインスタンス変数の指すオブジェクトもコピーできる
  def initialize_copy(source)
    super
    @data = data.dup
  end
end

a = MyClass.new([1])
b = a.dup
a.data << 2

p a.data  # => [1, 2]
p b.data  # => [1]

obj = Object.new
class <<obj
  attr_accessor :foo
  def bar
    :bar
  end
end

def check(obj)
  puts "instance variables: #{obj.inspect}"
  print "singleton methods: "
  begin
    p obj.bar
  rescue NameError
    p $!
  end
end

obj.foo = 1

check Object.new.send(:initialize_copy, obj)
        #=> instance variables: #<Object:0x4019c9d4>
        #   singleton methods: #<NoMethodError: ...>
check obj.dup
        #=> instance variables: #<Object:0x4019c9c0 @foo=1>
        #   singleton methods: #<NoMethodError: ...>
check obj.clone
        #=> instance variables: #<Object:0x4019c880 @foo=1>
        #   singleton methods: :bar

[SEE_ALSO] Object#initialize_clone, Object#initialize_dup

initialize_dup(obj) -> objectRuby 1.9.2 から[permalink][rdoc][edit]

Object#dup がオブジェクトを複製する際に呼び出すメソッドです。

デフォルトでは Object#initialize_copy を呼び出します。

initialize_dup という名前のメソッドは自動的に private に設定されます。

[SEE_ALSO] Object#dup, Object#initialize_copy, Object#initialize_clone

respond_to_missing?(symbol, include_private) -> boolRuby 1.9.3 から[permalink][rdoc][edit]

自身が symbol で表されるメソッドに対し BasicObject#method_missing で反応するつもりならば真を返します。

Object#respond_to? はメソッドが定義されていない場合、デフォルトでこのメソッドを呼びだし問合せます。

BasicObject#method_missing を override した場合にこのメソッドも override されるべきです。

このメソッドの既定の実装(Object#respond_to_missing?)は常に false を返します。

[PARAM] symbol:
メソッド名シンボル
[PARAM] include_private:
private method も含めたい場合に true が渡されます
例 
class Sample
  def method_missing(name, *args)
    if name =~ /^to_*/
      p [name, *args] # => [:to_sample, "sample args1", "sample args2"]
      return
    else
      super
    end
  end

  def respond_to_missing?(sym, include_private)
    (sym =~ /^to_*/) ? true : super
  end
end

s = Sample.new
s.to_sample("sample args1", "sample args2")
p s.respond_to?(:to_sample)  # => true
p s.respond_to?(:sample)  # => false

[SEE_ALSO] Object#respond_to?, BasicObject#method_missing

追加されるメソッド

pretty_inspect -> String[permalink][rdoc][edit] [added by pp]

self を pp で表示したときの結果を文字列として返します。

pretty_print(pp) -> ()[permalink][rdoc][edit] [added by pp]

PP.pp や Kernel?.pp がオブジェクトの内容を出力するときに呼ばれるメソッドです。PP オブジェクト pp を引数として呼ばれます。

あるクラスの pp の出力をカスタマイズしたい場合は、このメソッドを再定義します。そのとき pretty_print メソッドは指定された pp に対して表示したい自身の内容を追加していかなければいけません。いくつかの組み込みクラスについて、 pp ライブラリはあらかじめ pretty_print メソッドを定義しています。

[PARAM] pp:
PP オブジェクトです。 
class Array
  def pretty_print(q)
    q.group(1, '[', ']') {
      q.seplist(self) {|v|
        q.pp v
      }
    }
  end
end

[SEE_ALSO] Object#pretty_print_cycle, Object#inspect, PrettyPrint#text, PrettyPrint#group, PrettyPrint#breakable

pretty_print_cycle(pp) -> ()[permalink][rdoc][edit] [added by pp]

プリティプリント時にオブジェクトの循環参照が検出された場合、 Object#pretty_print の代わりに呼ばれるメソッドです。

あるクラスの pp の出力をカスタマイズしたい場合は、このメソッドも再定義する必要があります。

[PARAM] pp:
PP オブジェクトです。 
class Array
  def pretty_print_cycle(q)
    q.text(empty? ? '[]' : '[...]')
  end
end

[SEE_ALSO] Object#pretty_print

pretty_print_inspect -> String[permalink][rdoc][edit] [added by pp]

Object#pretty_print を使って Object#inspect と同様にオブジェクトを人間が読める形式に変換した文字列を返します。

出力する全てのオブジェクトに Object#pretty_print が定義されている必要があります。そうでない場合には RuntimeError が発生します。

[EXCEPTION] RuntimeError:
出力する全てのオブジェクトに Object#pretty_print が定義されていない場合に発生します。
pretty_print_instance_variables -> [String | Symbol][permalink][rdoc][edit] [added by pp]

プリティプリント時に表示すべき自身のインスタンス変数名の配列をソートして返します。返されたインスタンス変数はプリティプリント時に表示されます。

pp に表示したくないインスタンス変数がある場合にこのメソッドを再定義します。

to_yaml(options = {}) -> String[permalink][rdoc][edit] [added by psych]
psych_to_yaml(options = {}) -> StringRuby 1.9.3 から [added by psych]

オブジェクトを YAML document に変換します。

options でオプションを指定できます。 Psych.dump と同じなので詳しくはそちらを参照してください。

syck に to_yaml メソッドがあるため、 psych_to_yaml が別名として定義されています。将来的に syck が廃止された場合 psych_to_yaml は廃止される予定であるため、特別の事情がない限り to_yaml を用いてください。

[PARAM] options:
出力オプション

[SEE_ALSO] Psych.dump

yaml_tag(tag) -> ()Ruby 1.9.3 から[permalink][rdoc][edit] [added by psych]

クラスと tag の間を関連付けます。

これによって tag 付けされた YAML ドキュメントを Ruby のオブジェクトに変換したりその逆をしたりできます。

[PARAM] tag:
対象のクラスに関連付けるタグの文字列

Example

require 'psych'
  
class Foo
  def initialize(x)
    @x = x
  end
  
  attr_reader :x
end
  
# Dumps Ruby object normally  
p Psych.dump(Foo.new(3)) 
# =>
# --- !ruby/object:Foo
# x: 3
  
# Registers tag with class Foo
Foo.yaml_as("tag:example.com,2013:foo")
# ... and dumps the object of Foo class
Psych.dump(Foo.new(3), STDOUT)
# =>
# --- !<tag:example.com,2013:foo>
# x: 3 
  
# Loads the object from the tagged YAML node
p Psych.load(<<EOS)
--- !<tag:example.com,2012:foo>
x: 8
EOS
# => #<Foo:0x0000000130f48 @x=8>

再定義されたメソッド

ARGV -> Array[permalink][rdoc][edit] [redefined by optparse]

Ruby スクリプトに与えられた引数を表す配列です。

optparse を require することにより、ARGV は OptionParser::Arguable を Object#extend します。

[SEE_ALSO] OptionParser::Arguable

説明のための未定義メソッド

to_a -> Array[permalink][rdoc][edit] [nomethod by _builtin]

オブジェクトを配列に変換した結果を返します。デフォルトでは定義されていません。

説明のためここに記載してありますが、このメソッドは実際には Object クラスには定義されていません。必要に応じてサブクラスで定義すべきものです。 

p( {'a'=>1}.to_a )  # [["a", 1]]
p ['array'].to_a    # ["array"]
p nil.to_a          # []

[SEE_ALSO] Object#to_ary,Kernel?.Array

to_ary -> Array[permalink][rdoc][edit] [nomethod by _builtin]

オブジェクトの Array への暗黙の変換が必要なときに内部で呼ばれます。デフォルトでは定義されていません。

説明のためここに記載してありますが、このメソッドは実際には Object クラスには定義されていません。必要に応じてサブクラスで定義すべきものです。

このメソッドを定義する条件は、

  • 配列が使われるすべての場面で代置可能であるような、
  • 配列そのものとみなせるようなもの

という厳しいものになっています。 

class Foo
  def to_ary
    [3,4]
  end
end

it = Foo.new
p([1,2] + it) #=> [1, 2, 3, 4]

[SEE_ALSO] Object#to_a,Kernel?.Array

to_hash -> Hash[permalink][rdoc][edit] [nomethod by _builtin]

オブジェクトの Hash への暗黙の変換が必要なときに内部で呼ばれます。デフォルトでは定義されていません。

説明のためここに記載してありますが、このメソッドは実際には Object クラスには定義されていません。必要に応じてサブクラスで定義すべきものです。

このメソッドを定義する条件は、

  • ハッシュが使われるすべての場面で代置可能であるような、
  • ハッシュそのものとみなせるようなもの

という厳しいものになっています。 

class Foo
  def to_hash
    {'as' => 24}
  end
end

it = Foo.new
p({:as => 12}.merge(it)) #=> {"as"=>24, :as=>12}
to_int -> Integer[permalink][rdoc][edit] [nomethod by _builtin]

オブジェクトの Integer への暗黙の変換が必要なときに内部で呼ばれます。デフォルトでは定義されていません。

説明のためここに記載してありますが、このメソッドは実際には Object クラスには定義されていません。必要に応じてサブクラスで定義すべきものです。

このメソッドを定義する条件は、

  • 整数が使われるすべての場面で代置可能であるような、
  • 整数そのものとみなせるようなもの

という厳しいものになっています。 

class Foo
  def to_int
    1
  end
end

ary = [:a, :b, :c]
p(ary[Foo.new]) # => :b

[SEE_ALSO] Kernel?.Integer

to_io -> IO[permalink][rdoc][edit] [nomethod by _builtin]

オブジェクトの IO への暗黙の変換が必要なときに内部で呼ばれます。デフォルトでは定義されていません。

説明のためここに記載してありますが、このメソッドは実際には Object クラスには定義されていません。必要に応じてサブクラスで定義すべきものです。

このメソッドを定義する条件は、

  • IOオブジェクトが使われるすべての場面で代置可能であるような、
  • IOオブジェクトそのものとみなせるようなもの

という厳しいものになっています。

to_proc -> Proc[permalink][rdoc][edit] [nomethod by _builtin]

オブジェクトの Proc への暗黙の変換が必要なときに内部で呼ばれます。デフォルトでは定義されていません。

説明のためここに記載してありますが、このメソッドは実際には Object クラスには定義されていません。必要に応じてサブクラスで定義すべきものです。 

def doing
  yield
end

class Foo
  def to_proc
    Proc.new{p 'ok'}
  end
end

it = Foo.new
p doing(&it) #=> "ok"
to_regexp -> Regexp[permalink][rdoc][edit] [nomethod by _builtin]

オブジェクトの Regexp への暗黙の変換が必要なときに内部で呼ばれます。デフォルトでは定義されていません。

説明のためここに記載してありますが、このメソッドは実際には Object クラスには定義されていません。必要に応じてサブクラスで定義すべきものです。

このメソッドを定義する条件は、

  • 正規表現が使われるすべての場面で代置可能であるような、
  • 正規表現そのものとみなせるようなもの

という厳しいものになっています。 

class Foo
  def to_regexp
    /[\d]+/
  end
end

it = Foo.new
p Regexp.union(/^at/, it) #=> /(?-mix:^at)|(?-mix:[\d]+)/
to_str -> String[permalink][rdoc][edit] [nomethod by _builtin]

オブジェクトの String への暗黙の変換が必要なときに内部で呼ばれます。デフォルトでは定義されていません。

説明のためここに記載してありますが、このメソッドは実際には Object クラスには定義されていません。必要に応じてサブクラスで定義すべきものです。

このメソッドを定義する条件は、

  • 文字列が使われるすべての場面で代置可能であるような、
  • 文字列そのものとみなせるようなもの

という厳しいものになっています。 

class Foo
  def to_str
    'Edition'
  end
end

it = Foo.new
p('Second' + it) #=> "SecondEdition"

[SEE_ALSO] Object#to_s,Kernel?.String

定数

ARGF -> Object[permalink][rdoc][edit]

引数 (なければ標準入力) で構成される仮想ファイル (詳細は ARGF、ARGF.class を参照)。

つまり Kernel?.gets は ARGF.class#gets と同じ意味です。 ARGF.class#file で現在読み込み中のファイルオブジェクトが、 ARGF.class#filename で現在読み込み中のファイル名が得られます。

ARGV -> Array[permalink][rdoc][edit]

Ruby スクリプトに与えられた引数を表す配列です。

組み込み変数 $* の別名です。 Ruby 自身に対する引数は取り除かれています。

例:

スクリプト argv.rb の内容が 

p ARGV

であったとします。このときシェルから次を実行すると、 

$ ruby argv.rb foo bar baz

結果は以下のように出力されます。 

["foo", "bar", "baz"]
DATA -> File[permalink][rdoc][edit]

スクリプトの __END__ プログラムの終り以降をアクセスする File オブジェクト。

プログラム・文・式/プログラムの終りも参照。

ソースファイルの __END__ 以降は解析・実行の対象にならないのでその部分にプログラムが利用するためのデータを書き込んでおくことができます。 DATA 定数はそのデータ部分にアクセスするための File オブジェクトを保持しています。

__END__ を含まないプログラムにおいては DATA は定義されません。

注意

  • DATA.rewind で移動する読みとり位置は __END__ 直後ではなく、 スクリプトファイルの先頭です。
  • スクリプトが標準入力から読みこまれた場合は標準入力になります。
  • スクリプトがファイルや標準入力から読みこまれなかった場合や、 __END__ で終っていない場合には定義されません。
  • Kernel?.require や Kernel?.load で 読み込まれたファイルの中であってもそのファイル (__FILE__, 変数と定数/擬似変数) ではなく実行されたファイル ($0) を指します。

例1

print DATA.gets # => 故人西辞黄鶴楼
print DATA.gets # => 烟花三月下揚州
print DATA.gets # => 孤帆遠影碧空尽
print DATA.gets # => 唯見長江天際流
p DATA.gets     # => nil

__END__
故人西辞黄鶴楼
烟花三月下揚州
孤帆遠影碧空尽
唯見長江天際流

例2

sum = 0
DATA.each_line do |line|
  sum += line.to_i
end

DATA.rewind
p DATA.gets    # => "sum = 0¥n"

__END__
17
19
23
29
31

例3

DATA.gets    # => uninitialized constant DATA (NameError)

例4

ファイル library.rb と app.rb の内容が以下であったとします。

library.rb 
print DATA.gets

__END__
data from library
app.rb 
require_relative 'library.rb'

__END__
data from app

このときシェルから次を実行すると 

$ ruby app.rb

結果は以下のように出力されます。 

data from app
ENV -> Object[permalink][rdoc][edit]

環境変数を表す (擬似) 連想配列 (詳細は ENV を参照)。

この連想配列の値を変更すると子プロセスの環境として引き継がれます。

RUBY_COPYRIGHT -> String[permalink][rdoc][edit]

Ruby のコピーライトを表す文字列。

RUBY_DESCRIPTION -> String[permalink][rdoc][edit]

Ruby の詳細を表す文字列。

ruby -v で表示される内容が格納されています。

RUBY_ENGINE -> StringRuby 1.9.3 から[permalink][rdoc][edit]

Ruby処理系実装の種類を表す文字列。

例 
$ ruby-1.9.1 -ve 'p RUBY_ENGINE'
ruby 1.9.1p0 (2009-03-04 revision 22762) [x86_64-linux]
"ruby"
$ jruby -ve 'p RUBY_ENGINE'
jruby 1.2.0 (ruby 1.8.6 patchlevel 287) (2009-03-16 rev 9419) [i386-java]
"jruby"
RUBY_ENGINE_VERSION -> StringRuby 2.3.0 から[permalink][rdoc][edit]

Ruby処理系実装のバージョンを表す文字列。

RUBY_PATCHLEVEL -> Integer[permalink][rdoc][edit]

Ruby のパッチレベルを表す Integer オブジェクトです。

パッチレベルはRubyの各バージョンに対するバグ修正パッチの適用をカウントしています。 teeny リリースのそれぞれについてパッチレベルは 0 から始まり、その teeny リリースに対してバグ修正パッチが適用される度に増えていきます。

パッチレベルという概念および RUBY_PATCHLEVEL 定数は、 Ruby 1.8.5-p1 以降、 1.8.6 以降で導入されました。 1.8.5やそれ以前のバージョンでは定義されていません。

RUBY_PLATFORM -> String[permalink][rdoc][edit]

プラットフォームを表す文字列。

RUBY_RELEASE_DATE -> String[permalink][rdoc][edit]

Ruby のリリース日を表す文字列。

RUBY_REVISION -> StringRuby 1.9.3 から[permalink][rdoc][edit]

Ruby の GIT コミットハッシュを表す String オブジェクトです。

RUBY_VERSION -> String[permalink][rdoc][edit]

Ruby のバージョンを表す文字列。

Ruby のバージョンは、major.minor.teeny という形式です。

SCRIPT_LINES__ -> Hash[permalink][rdoc][edit]

ソースファイル別にまとめられたソースコードの各行。

この定数は、デフォルトでは定義されていません。この定数がハッシュとして定義された後にソースがコンパイルされると、そのソースファイル名をキーに、ソースを行毎に分割した配列を値にしたハッシュ要素が設定されます。

この定数はデバッガ (debug) などで利用されています。

また、 Kernel?.eval によるコンパイルは対象にはなりません。

例 
require 'pp'
SCRIPT_LINES__ = {}
require 'English'
pp SCRIPT_LINES__

# => {"/usr/local/lib/ruby/1.6/English.rb"=>
#     ["alias $ERROR_INFO              $!\n",
#      "alias $ERROR_POSITION          $@\n",
#      "alias $LOADED_FEATURES         $\"\n",
#               :
#               :
#      "alias $POSTMATCH               $'\n",
#      "alias $LAST_PAREN_MATCH        $+\n"]}
STDERR -> IO[permalink][rdoc][edit]

標準エラー出力。$stderr のデフォルト値。 $stderr も参照してください。

STDERR は、 ruby プロセスが起動された時点での標準エラー出力を表します。起動時点では $stderr も同じ値に初期化されています。

$stderr に他の出力オブジェクトを代入することで簡易なリダイレクトを実現できます。そして、 $stderr に STDERR を代入すればこのリダイレクトを復元できるわけです。

注意

STDERR は ruby 自体が起動された時点での標準エラー出力です。「システムにおける標準のエラー出力ストリーム」とは異なります。

多くのシステムでは標準のエラー出力ストリームは端末です。 ruby 自体が他のストリームに向けてエラー出力をリダイレクトされた状態で起動された場合、 STDERR が保持するのは端末ではなく、リダイレクト先のストリームです。

STDIN -> IO[permalink][rdoc][edit]

標準入力。$stdin のデフォルト値。 $stdin も参照してください。

STDIN は、 ruby プロセスが起動された時点での標準入力を表します。起動時点では $stdin も同じ値に初期化されています。

$stdin に他の入力オブジェクトを代入することで簡易なリダイレクトを実現できます。そして、 $stdin に STDIN を代入すればこのリダイレクトを復元できるわけです。

注意

STDIN は ruby 自体が起動された時点での標準入力です。「システムにおける標準の入力ストリーム」とは異なります。

多くのシステムでは標準の入力ストリームは端末です。 ruby 自体が他のストリームに向けて入力をリダイレクトされた状態で起動された場合、 STDIN が保持するのは端末ではなく、リダイレクト先のストリームです。

STDOUT -> IO[permalink][rdoc][edit]

標準出力。$stdout のデフォルト値。 $stdout も参照してください。

STDOUT は、 ruby プロセスが起動された時点での標準出力を表します。起動時点では $stdout も同じ値に初期化されています。

$stdout に他の出力オブジェクトを代入することで簡易なリダイレクトを実現できます。そして、 $stdout に STDOUT を代入すればこのリダイレクトを復元できるわけです。

注意

STDOUT は ruby 自体が起動された時点での標準出力です。「システムにおける標準の出力ストリーム」とは異なります。

多くのシステムでは標準の出力ストリームは端末です。 ruby 自体が他のストリームに向けて出力をリダイレクトされた状態で起動された場合、 STDOUT が保持するのは端末ではなく、リダイレクト先のストリームです。

TOPLEVEL_BINDING -> Binding[permalink][rdoc][edit]

トップレベルでの Binding オブジェクト。

詳細は Binding を参照してください。