フィードバックはこちら
モジュールのクラスです。
constants -> [Symbol][permalink][rdoc]このメソッドを呼び出した時点で参照可能な定数名の配列を返します。
class C
FOO = 1
end
p Module.constants # => [:RUBY_PLATFORM, :STDIN, ..., :C, ...]
# 出力中に :FOO は現われない
[SEE_ALSO] Module#constants, Kernel.#local_variables, Kernel.#global_variables, Object#instance_variables, Module#class_variables
nesting -> [Class, Module][permalink][rdoc]このメソッドを呼び出した時点でのクラス/モジュールのネスト情報を配列に入れて返します。
module Foo
module Bar
module Baz
p Module.nesting # => [Foo::Bar::Baz, Foo::Bar, Foo]
end
end
end
new -> Module[permalink][rdoc]new {|mod| ... } -> Module名前の付いていないモジュールを新しく生成して返します。
ブロックが与えられると生成したモジュールをブロックに渡し、モジュールのコンテキストでブロックを実行します。
mod = Module.new
mod.module_eval {|m| ... }
mod
と同じです。ブロックの実行は Module#initialize が行います。
ブロックを与えた場合も生成したモジュールを返します。
このメソッドで生成されたモジュールは、最初に名前が必要になったときに名前が決定します。モジュールの名前は、そのモジュールが代入されている定数名のいずれかです。
m = Module.new p m # => #<Module 0lx40198a54> p m.name # => nil # まだ名前は未定 Foo = m # m.name # ここで m.name を呼べば m の名前は "Foo" に確定する Bar = m m.name # "Foo" か "Bar" のどちらかに決まる
used_modules -> [Module][permalink][rdoc]現在のスコープで using されているすべてのモジュールを配列で返します。配列内のモジュールの順番は未定義です。
module A refine Object do end end module B refine Object do end end using A using B p Module.used_modules #=> [B, A]
self < other -> bool | nil[permalink][rdoc]比較演算子。self が other の子孫である場合、 true を返します。 self が other の先祖か同一のクラス／モジュールである場合、false を返します。
継承関係にないクラス同士の比較では nil を返します。
module Foo end class Bar include Foo end class Baz < Bar end class Qux end p Bar < Foo # => true p Baz < Bar # => true p Baz < Foo # => true p Baz < Qux # => nil p Baz > Qux # => nil p Foo < Object.new # => in `<': compared with non class/module (TypeError)
self <= other -> bool | nil[permalink][rdoc]比較演算子。self が other の子孫であるか、self と other が同一クラスである場合、 true を返します。 self が other の先祖である場合、false を返します。
継承関係にないクラス同士の比較では nil を返します。
[SEE_ALSO] Module#<
例:
module Foo; end module Bar include Foo end module Baz prepend Foo end Bar.ancestors # => [Bar, Foo] Foo <= Bar # => false Bar <= Foo # => true Baz.ancestors # => [Foo, Baz] Foo <= Baz # => false Baz <= Foo # => true Foo <= Foo # => true Foo <= Object # => nil
self <=> other -> Integer | nil[permalink][rdoc]self と other の継承関係を比較します。
self と other を比較して、 self が other の子孫であるとき -1、同一のクラス／モジュールのとき 0、 self が other の先祖であるとき 1 を返します。
継承関係にないクラス同士の比較では nil を返します。
other がクラスやモジュールでなければ nil を返します。
module Foo end class Bar include Foo end class Baz < Bar end class Qux end p Bar <=> Foo # => -1 p Baz <=> Bar # => -1 p Baz <=> Foo # => -1 p Baz <=> Qux # => nil p Qux <=> Baz # => nil p Baz <=> Object.new # => nil
self === obj -> bool[permalink][rdoc]指定された obj が self かそのサブクラスのインスタンスであるとき真を返します。また、obj が self をインクルードしたクラスかそのサブクラスのインスタンスである場合にも真を返します。上記のいずれでもない場合に false を返します。
言い替えると obj.kind_of?(self) が true の場合、 true を返します。
このメソッドは主に case 文での比較に用いられます。 case ではクラス、モジュールの所属関係をチェックすることになります。
str = String.new case str when String # String === str を評価する p true # => true end
[SEE_ALSO] Object#kind_of?, Object#instance_of?, 制御構造/case
self > other -> bool | nil[permalink][rdoc]比較演算子。 self が other の先祖である場合、true を返します。 self が other の子孫か同一クラスである場合、false を返します。
継承関係にないクラス同士の比較では nil を返します。
[SEE_ALSO] Module#<
例:
module Awesome; end module Included include Awesome end module Prepended prepend Awesome end Included.ancestors # => [Included, Awesome] Awesome > Included # => true Included > Awesome # => false Prepended.ancestors # => [Awesome, Prepended] Awesome > Prepended # => true Prepended > Awesome # => false Awesome > Awesome # => false Awesome > Object # => nil
self >= other -> bool | nil[permalink][rdoc]比較演算子。self が other の先祖か同一クラスである場合、 true を返します。 self が other の子孫である場合、false を返します。
継承関係にないクラス同士の比較では nil を返します。
[SEE_ALSO] Module#<
例:
module Foo; end module Bar include Foo end module Baz prepend Foo end Bar.ancestors # => [Bar, Foo] Foo >= Bar # => true Bar >= Foo # => false Baz.ancestors # => [Foo, Baz] Foo >= Baz # => true Baz >= Foo # => false Foo >= Foo # => true Foo >= Object # => nil
ancestors -> [Class, Module][permalink][rdoc]クラス、モジュールのスーパークラスとインクルードしているモジュールを優先順位順に配列に格納して返します。
module Foo end class Bar include Foo end class Baz < Bar p ancestors p included_modules p superclass end # => [Baz, Bar, Foo, Object, Kernel, BasicObject] # => [Foo, Kernel] # => Bar
[SEE_ALSO] Module#included_modules
autoload(const_name, feature) -> nil[permalink][rdoc]定数 const_name を最初に参照した時に feature を Kernel.#require するように設定します。
[SEE_ALSO] Kernel.#autoload
例:
Date # NameError: uninitialized constant Date autoload :Date, 'date' Date # => Date
autoload?(const_name) -> String | nil[permalink][rdoc]autoload 定数がまだ定義されてない(ロードされていない) ときにそのパス名を返します。また、ロード済みなら nil を返します。
[SEE_ALSO] Kernel.#autoload?
例:
autoload :Date, 'date' autoload?(:Date) # => "date" Date autoload?(:Date) # => nil autoload?(:Foo) # => nil
module_eval(expr, fname = "(eval)", lineno = 1) -> object[permalink][rdoc]module_eval {|mod| ... } -> objectclass_eval(expr, fname = "(eval)", lineno = 1) -> objectclass_eval {|mod| ... } -> objectモジュールのコンテキストで文字列 expr またはモジュール自身をブロックパラメータとするブロックを評価してその結果を返します。
モジュールのコンテキストで評価するとは、実行中そのモジュールが self になるということです。つまり、そのモジュールの定義式の中にあるかのように実行されます。
ただし、ローカル変数は module_eval/class_eval の外側のスコープと共有します。
文字列が与えられた場合には、定数とクラス変数のスコープは自身のモジュール定義式内と同じスコープになります。ブロックが与えられた場合には、定数とクラス変数のスコープはブロックの外側のスコープになります。
例:
class C
end
a = 1
C.class_eval %Q{
def m # メソッドを動的に定義できる。
return :m, #{a}
end
}
p C.new.m #=> [:m, 1]
[SEE_ALSO] BasicObject#instance_eval, Module.new, Kernel.#eval
class_variable_defined?(name) -> bool[permalink][rdoc]name で与えられた名前のクラス変数がモジュールに存在する場合 true を返します。
class Fred
@@foo = 99
end
Fred.class_variable_defined?(:@@foo) #=> true
Fred.class_variable_defined?(:@@bar) #=> false
Fred.class_variable_defined?('@@foo') #=> true
Fred.class_variable_defined?('@@bar') #=> false
class_variables(inherit = true) -> [Symbol][permalink][rdoc]クラス／モジュールに定義されているクラス変数の名前の配列を返します。
class One @@var1 = 1 end class Two < One @@var2 = 2 end One.class_variables # => [:@@var1] Two.class_variables # => [:@@var2, :@@var1] Two.class_variables(false) # => [:@@var2]
[SEE_ALSO] Module.constants, Kernel.#local_variables, Kernel.#global_variables, Object#instance_variables, Module#constants
const_defined?(name, inherit = true) -> bool[permalink][rdoc]モジュールに name で指定される名前の定数が定義されている時真を返します。
スーパークラスや include したモジュールで定義された定数を検索対象にするかどうかは第二引数で制御することができます。
module Kernel FOO = 1 end # Object は include したモジュールの定数に対しても # true を返す p Object.const_defined?(:FOO) # => true module Bar BAR = 1 end class Object include Bar end # ユーザ定義のモジュールに対しても同様 p Object.const_defined?(:BAR) # => true class Baz include Bar end # Object 以外でも同様になった # 第二引数のデフォルト値が true であるため p Baz.const_defined?(:BAR) # => true # 第二引数を false にした場合 p Baz.const_defined?(:BAR, false) # => false
const_get(name, inherit = true) -> object[permalink][rdoc]name で指定される名前の定数の値を取り出します。
Module#const_defined? と違って Object を特別扱いすることはありません。
module Bar
BAR = 1
end
class Object
include Bar
end
# Object では include されたモジュールに定義された定数を見付ける
p Object.const_get(:BAR) # => 1
class Baz
include Bar
end
# Object以外でも同様
p Baz.const_get(:BAR) # => 1
# 定義されていない定数
p Baz.const_get(:NOT_DEFINED) #=> raise NameError
# 第二引数に false を指定すると自分自身に定義された定数から探す
p Baz.const_get(:BAR, false) #=> raise NameError
# 完全修飾名を指定すると include や自分自身へ定義されていない場合でも参照できる
p Class.const_get("Bar::BAR") # => 1
const_missing(name)[permalink][rdoc]定義されていない定数を参照したときに Ruby インタプリタがこのメソッドを呼びます。
class Foo
def Foo.const_missing(id)
warn "undefined constant #{id.inspect}"
end
Bar
end
Foo::Bar
# => undefined constant :Bar
undefined constant :Bar
const_set(name, value) -> object[permalink][rdoc]モジュールに name で指定された名前の定数を value という値として定義し、value を返します。
そのモジュールにおいてすでにその名前の定数が定義されている場合、警告メッセージが出力されます。
例:
module Foo; end
# Symbolを指定した場合
Foo.const_set(:FOO, 123)
Foo::FOO # => 123
# Stringを指定した場合
Foo.const_set('BAR', 'abc')
Foo::BAR # => "abc"
# 既に定義されている定数の名前を指定した場合
Foo.const_set('BAR', '123')
# warning: already initialized constant Foo::BAR
# warning: previous definition of BAR was here
# => "123"
# 不適切な定数名を指定した場合
Foo.const_set('foo', 1) # => NameError: wrong constant name foo
constants(inherit = true) -> [Symbol][permalink][rdoc]そのモジュール(またはクラス)で定義されている定数名の配列を返します。
inherit に真を指定するとスーパークラスやインクルードしているモジュールの定数も含みます。 Object のサブクラスの場合、Objectやそのスーパークラスで定義されている定数は含まれません。 Object.constants とすると Object クラスで定義された定数の配列が得られます。
得られる定数の順序は保証されません。
[SEE_ALSO] Module.constants, Kernel.#local_variables, Kernel.#global_variables, Object#instance_variables, Module#class_variables
Module.constants と Module#constants の違い
# 出力の簡略化のため起動時の定数一覧を取得して後で差し引く
$clist = Module.constants
class Foo
FOO = 1
end
class Bar
BAR = 1
# Bar は BAR を含む
p constants # => [:BAR]
# 出力に FOO は含まれない
p Module.constants - $clist # => [:BAR, :Bar, :Foo]
class Baz
# Baz は定数を含まない
p constants # => []
# ネストしたクラスでは、外側のクラスで定義した定数は
# 参照可能なので、BAR は、Module.constants には含まれる
# (クラス Baz も Bar の定数なので同様)
p Module.constants - $clist # => [:BAR, :Baz, :Foo, :Bar]
end
end
freeze -> self[permalink][rdoc]モジュールを凍結（内容の変更を禁止）します。
凍結したモジュールにメソッドの追加など何らかの変更を加えようとした場合に RuntimeError が発生します。
[SEE_ALSO] Object#freeze
例:
module Foo; end Foo.freeze module Foo def foo; end end # => RuntimeError: can't modify frozen module
include(*mod) -> self[permalink][rdoc]モジュール mod をインクルードします。
module M end module M2 include M end module M include M2 end
実行結果:
-:3:in `append_features': cyclic include detected (ArgumentError)
from -:3:in `include'
from -:3
インクルードとは、指定されたモジュールの定義 (メソッド、定数) を引き継ぐことです。インクルードは多重継承の代わりに用いられており、 mix-in とも呼びます。
class C include FileTest include Math end p C.ancestors # => [C, Math, FileTest, Object, Kernel]
モジュールの機能追加は、クラスの継承関係の間にそのモジュールが挿入されることで実現されています。従って、メソッドの探索などはスーパークラスよりもインクルードされたモジュールのほうが先に行われます (上の例の Module#ancestors の結果がメソッド探索の順序です)。
同じモジュールを二回以上 include すると二回目以降は無視されます。
module M end class C1 include M end class C2 < C1 include M # この include は無視される end p C2.ancestors # => [C2, C1, M, Object, Kernel]
引数に複数のモジュールを指定した場合、最後の引数から順にインクルードします。
include?(mod) -> bool[permalink][rdoc]self かその親クラス / 親モジュールがモジュール mod をインクルードしていれば true を返します。
module M end class C1 include M end class C2 < C1 end p C1.include?(M) # => true p C2.include?(M) # => true
included_modules -> [Module][permalink][rdoc]self にインクルードされているモジュールの配列を返します。
module Mixin end module Outer include Mixin end Mixin.included_modules #=> [] Outer.included_modules #=> [Mixin]
[SEE_ALSO] Module#ancestors
name -> String | nil[permalink][rdoc]to_s -> Stringinspect -> Stringモジュールやクラスの名前を文字列で返します。
このメソッドが返す「モジュール / クラスの名前」とは、より正確には「クラスパス」を指します。クラスパスとは、ネストしているモジュールすべてを「::」を使って表示した名前のことです。クラスパスの例としては「CGI::Session」「Net::HTTP」が挙げられます。
module A module B end p B.name #=> "A::B" class C end end p A.name #=> "A" p A::B.name #=> "A::B" p A::C.name #=> "A::C" # 名前のないモジュール / クラス p Module.new.name #=> nil p Class.new.name #=> nil p Module.new.to_s #=> "#<Module:0x00007f90b09112c8>" p Class.new.to_s #=> "#<Class:0x00007fa5c40b41b0>"
instance_method(name) -> UnboundMethod[permalink][rdoc]self のインスタンスメソッド name をオブジェクト化した UnboundMethod を返します。
[SEE_ALSO] Module#public_instance_method, Object#method
例:
class Interpreter
def do_a() print "there, "; end
def do_d() print "Hello "; end
def do_e() print "!\n"; end
def do_v() print "Dave"; end
Dispatcher = {
"a" => instance_method(:do_a),
"d" => instance_method(:do_d),
"e" => instance_method(:do_e),
"v" => instance_method(:do_v)
}
def interpret(string)
string.each_char {|b| Dispatcher[b].bind(self).call }
end
end
interpreter = Interpreter.new
interpreter.interpret('dave')
# => Hello there, Dave!
instance_methods(inherited_too = true) -> [Symbol][permalink][rdoc]そのモジュールで定義されている public および protected メソッド名の一覧を配列で返します。
[SEE_ALSO] Object#methods
例1:
class Foo private; def private_foo() end protected; def protected_foo() end public; def public_foo() end end # あるクラスのインスタンスメソッドの一覧を得る p Foo.instance_methods(false) p Foo.public_instance_methods(false) p Foo.private_instance_methods(false) p Foo.protected_instance_methods(false) class Bar < Foo end
実行結果
[:protected_foo, :public_foo] [:public_foo] [:private_foo] [:protected_foo]
例2:
class Bar private; def private_foo() end protected; def protected_foo() end public; def public_foo() end end # あるクラスのインスタンスメソッドの一覧を得る。 # 親のクラスのインスタンスメソッドも含めるため true を指定して # いるが、Object のインスタンスメソッドは一覧から排除している。 p Bar.instance_methods(true) - Object.instance_methods(true) p Bar.public_instance_methods(true) - Object.public_instance_methods(true) p Bar.private_instance_methods(true) - Object.private_instance_methods(true) p Bar.protected_instance_methods(true) - Object.protected_instance_methods(true)
実行結果
[:protected_foo, :public_foo] [:public_foo] [:private_foo] [:protected_foo]
method_defined?(name) -> bool[permalink][rdoc]モジュールにインスタンスメソッド name が定義されており、かつその可視性が public または protected であるときに true を返します。
[SEE_ALSO] Module#public_method_defined?, Module#private_method_defined?, Module#protected_method_defined?
例
module A
def method1() end
def protected_method1() end
protected :protected_method1
end
class B
def method2() end
def private_method2() end
private :private_method2
end
class C < B
include A
def method3() end
end
A.method_defined? :method1 #=> true
C.method_defined? "method1" #=> true
C.method_defined? "method2" #=> true
C.method_defined? "method3" #=> true
C.method_defined? "protected_method1" #=> true
C.method_defined? "method4" #=> false
C.method_defined? "private_method2" #=> false
prepend(*modules) -> self[permalink][rdoc]指定したモジュールを self の継承チェインの先頭に「追加する」ことで self の定数、メソッド、モジュール変数を「上書き」します。
継承チェイン上で、self のモジュール/クラスよりも「手前」に追加されるため、結果として self で定義されたメソッドは override されます。
modules で指定したモジュールは後ろから順に処理されるため、 modules の先頭が最も優先されます。
また、継承によってこの「上書き」を処理するため、prependの引数として渡したモジュールのインスタンスメソッドでsuperを呼ぶことで self のモジュール/クラスのメソッドを呼び出すことができます。
実際の処理は modules の各要素の prepend_features を後ろから順に呼びだすだけです。 Module#prepend_features が継承チェインの改変を実行し、結果として上のような処理が実現されます。そのため、prepend_features を override することで prepend の処理を追加/変更できます。
[SEE_ALSO] Module#prepend_features, Module#prepended
# super と prepend の組み合わせの例
module X
def foo
puts "X1" # (1x)
super # (2x)
puts "X2" # (3x)
end
end
class A
prepend X
def foo
puts "A" #(1a)
end
end
A.new.foo
# (1x) (2x)(ここの super で A#foo を呼びだす) (1a) (3x) の順に実行される
# >> X1
# >> A
# >> X2
# 2つのモジュールを X, Y を prepend X, Y という順で指定したもの
module Y
def foo
puts "Y1" #(1y)
super #(2y)
puts "Y2" #(3y)
end
end
class B
prepend X, Y
def foo
puts "B" # (1b)
end
end
B.new.foo
# (1x) (2x) (1y) (2y) (1b) (3y) (3x) の順に実行される
# X#foo のほうが Y#foo より継承チェインの手前側にあり、そちらが優先される
# >> X1
# >> Y1
# >> B
# >> Y2
# >> X2
# prepend Y, X とすると Y1 X1 B X2 Y2 の順で表示される
private_class_method(*name) -> self[permalink][rdoc]name で指定したクラスメソッド (クラスの特異メソッド) の可視性を private に変更します。
例:
module Foo def self.foo; end end Foo.singleton_class.private_method_defined?(:foo) # => false Foo.private_class_method(:foo) # => Foo Foo.singleton_class.private_method_defined?(:foo) # => true
private_instance_methods(inherited_too = true) -> [Symbol][permalink][rdoc]そのモジュールで定義されている private メソッド名の一覧を配列で返します。
[SEE_ALSO] Object#private_methods, Module#instance_methods
例:
module Foo def foo; end private def bar; end end module Bar include Foo def baz; end private def qux; end end Bar.private_instance_methods # => [:qux, :bar] Bar.private_instance_methods(false) # => [:qux]
private_method_defined?(name) -> bool[permalink][rdoc]インスタンスメソッド name がモジュールに定義されており、しかもその可視性が private であるときに true を返します。そうでなければ false を返します。
[SEE_ALSO] Module#method_defined?, Module#public_method_defined?, Module#protected_method_defined?
例
module A
def method1() end
end
class B
private
def method2() end
end
class C < B
include A
def method3() end
end
A.method_defined? :method1 #=> true
C.private_method_defined? "method1" #=> false
C.private_method_defined? "method2" #=> true
C.method_defined? "method2" #=> false
protected_instance_methods(inherited_too = true) -> [Symbol][permalink][rdoc]そのモジュールで定義されている protected メソッド名の一覧を配列で返します。
[SEE_ALSO] Object#protected_methods, Module#instance_methods
protected_method_defined?(name) -> bool[permalink][rdoc]インスタンスメソッド name がモジュールに定義されており、しかもその可視性が protected であるときに true を返します。そうでなければ false を返します。
[SEE_ALSO] Module#method_defined?, Module#public_method_defined?, Module#private_method_defined?
例
module A
def method1() end
end
class B
protected
def method2() end
end
class C < B
include A
def method3() end
end
A.method_defined? :method1 #=> true
C.protected_method_defined? "method1" #=> false
C.protected_method_defined? "method2" #=> true
C.method_defined? "method2" #=> true
public_class_method(*name) -> self[permalink][rdoc]name で指定したクラスメソッド (クラスの特異メソッド) の可視性を public に変更します。
例:
class Foo
def self.foo
"foo"
end
private_class_method :foo
end
Foo.foo # NoMethodError: private method `foo' called for Foo:Class
Foo.public_class_method(:foo) # => Foo
Foo.foo # => "foo"
public_instance_method(name) -> UnboundMethod[permalink][rdoc]self の public インスタンスメソッド name をオブジェクト化した UnboundMethod を返します。
Kernel.public_instance_method(:object_id) #=> #<UnboundMethod: Kernel#object_id> Kernel.public_instance_method(:p) # method `p' for module `Kernel' is private (NameError)
[SEE_ALSO] Module#instance_method,Object#public_method
public_instance_methods(inherited_too = true) -> [Symbol][permalink][rdoc]そのモジュールで定義されている public メソッド名の一覧を配列で返します。
[SEE_ALSO] Object#public_methods, Module#instance_methods
public_method_defined?(name) -> bool[permalink][rdoc]インスタンスメソッド name がモジュールに定義されており、しかもその可視性が public であるときに true を返します。そうでなければ false を返します。
[SEE_ALSO] Module#method_defined?, Module#private_method_defined?, Module#protected_method_defined?
例
module A
def method1() end
end
class B
protected
def method2() end
end
class C < B
include A
def method3() end
end
A.method_defined? :method1 #=> true
C.public_method_defined? "method1" #=> true
C.public_method_defined? "method2" #=> false
C.method_defined? "method2" #=> true
remove_class_variable(name) -> object[permalink][rdoc]引数で指定したクラス変数を取り除き、そのクラス変数に設定されていた値を返します。
class Foo @@foo = 1 remove_class_variable(:@@foo) # => 1 p @@foo # => uninitialized class variable @@foo in Foo (NameError) end
[SEE_ALSO] Module#remove_const, Object#remove_instance_variable
alias_method(new, original) -> self[permalink][rdoc]メソッドの別名を定義します。
alias との違いは以下の通りです。
また、クラスメソッドに対して使用することはできません。
[SEE_ALSO] クラス／メソッドの定義/alias
例:
module Kernel alias_method :foo, :puts end foo "bar" # bar
append_features(module_or_class) -> self[permalink][rdoc]モジュール(あるいはクラス)に self の機能を追加します。
このメソッドは Module#include の実体であり、 include を Ruby で書くと以下のように定義できます。
def include(*modules)
modules.reverse_each do |mod|
# append_features や included はプライベートメソッドなので
# 直接 mod.append_features(self) などとは書けない
mod.__send__(:append_features, self)
mod.__send__(:included, self)
end
end
[SEE_ALSO] Module#included
attr(*name) -> nil[permalink][rdoc]attr(name, true) -> nilattr(name, false) -> nilインスタンス変数読み取りのためのインスタンスメソッド name を定義します。
このメソッドで定義されるアクセスメソッドの定義は次の通りです。
def name @name end
第 2 引数 が true で指定された場合には、属性の書き込み用メソッド name= も同時に定義されます。その定義は次の通りです。
def name=(val) @name = val end
第 2 引数 に true か false を指定する方法は非推奨になりました。
attr_accessor(*name) -> nil[permalink][rdoc]インスタンス変数 name に対する読み取りメソッドと書き込みメソッドの両方を定義します。
このメソッドで定義されるメソッドの定義は以下の通りです。
def name @name end def name=(val) @name = val end
attr_reader(*name) -> nil[permalink][rdoc]インスタンス変数 name の読み取りメソッドを定義します。
このメソッドで定義されるメソッドの定義は以下の通りです。
def name @name end
attr_writer(*name) -> nil[permalink][rdoc]インスタンス変数 name への書き込みメソッド (name=) を定義します。
このメソッドで定義されるメソッドの定義は以下の通りです。
def name=(val) @name = val end
module_exec(*args) {|*vars| ... } -> object[permalink][rdoc]class_exec(*args) {|*vars| ... } -> object与えられたブロックを指定された args を引数としてモジュールのコンテキストで評価します。
モジュールのコンテキストで評価するとは、実行中そのモジュールが self になるということです。つまり、そのモジュールの定義式の中にあるかのように実行されます。
ローカル変数、定数とクラス変数のスコープはブロックの外側のスコープになります。
class Thing
end
c = 1
Thing.class_exec{
def hello()
"Hello there!"
end
define_method(:foo) do # ローカル変数がブロックの外側を参照している
c
end
}
t = Thing.new
p t.hello() #=> "Hello there!"
p t.foo() #=> 1
[SEE_ALSO] Module#module_eval, Module#class_eval
class_variable_get(name) -> object[permalink][rdoc]クラス／モジュールに定義されているクラス変数 name の値を返します。
class Fred @@foo = 99 end def Fred.foo class_variable_get(:@@foo) end p Fred.foo #=> 99
class_variable_set(name, val) -> object[permalink][rdoc]クラス／モジュールにクラス変数 name を定義して、その値として val をセットします。val を返します。
class Fred
@@foo = 99
def foo
@@foo
end
end
def Fred.foo(val)
class_variable_set(:@@foo, val)
end
p Fred.foo(101) # => 101
p Fred.new.foo # => 101
define_method(name, method) -> Symbol[permalink][rdoc]define_method(name) { ... } -> Symbolインスタンスメソッド name を定義します。
ブロックを与えた場合、定義したメソッドの実行時にブロックがレシーバクラスのインスタンスの上で BasicObject#instance_eval されます。
class Foo def foo() p :foo end define_method(:bar, instance_method(:foo)) end Foo.new.bar # => :foo
deprecate_constant(*name) -> self[permalink][rdoc]name で指定した定数を deprecate に設定します。 deprecate に設定した定数を参照すると警告メッセージが表示されます。
例:
FOO = 123 Object.deprecate_constant(:FOO) # => Object FOO # warning: constant ::FOO is deprecated # => 123 Object.deprecate_constant(:BAR) # NameError: constant Object::BAR not defined
extend_object(obj) -> object[permalink][rdoc]Object#extend の実体です。オブジェクトにモジュールの機能を追加します。
Object#extend は、Ruby で書くと以下のように定義できます。
def extend(*modules)
modules.reverse_each do |mod|
# extend_object や extended はプライベートメソッドなので
# 直接 mod.extend_object(self) などとは書けない
mod.__send__(:extend_object, self)
mod.__send__(:extended, self)
end
end
extend_object のデフォルトの実装では、self に定義されているインスタンスメソッドを obj の特異メソッドとして追加します。
[SEE_ALSO] Module#extended
extended(obj) -> ()[permalink][rdoc]self が他のオブジェクト に Object#extend されたときに呼ばれます。引数には extend を行ったオブジェクトが渡されます。
module Foo
def self.extended(obj)
p "#{obj} extend #{self}"
end
end
Object.new.extend Foo
# => "#<Object:0x401cbc3c> extend Foo"
[SEE_ALSO] Module#extend_object
included(class_or_module) -> ()[permalink][rdoc]self が Module#include されたときに対象のクラスまたはモジュールを引数にしてインタプリタがこのメソッドを呼び出します。
module Foo
def self.included(mod)
p "#{mod} include #{self}"
end
end
class Bar
include Foo
end
# => "Bar include Foo"
[SEE_ALSO] Module#append_features
method_added(name) -> ()[permalink][rdoc]メソッド name が追加された時にインタプリタがこのメソッドを呼び出します。
特異メソッドの追加に対するフックには BasicObject#singleton_method_added を使います。
class Foo
def Foo.method_added(name)
puts "method \"#{name}\" was added"
end
def foo
end
define_method :bar, instance_method(:foo)
end
=> method "foo" was added
method "bar" was added
method_removed(name) -> ()[permalink][rdoc]メソッドが Module#remove_method により削除された時にインタプリタがこのメソッドを呼び出します。
特異メソッドの削除に対するフックには BasicObject#singleton_method_removed を使います。
class Foo
def Foo.method_removed(name)
puts "method \"#{name}\" was removed"
end
def foo
end
remove_method :foo
end
=> method "foo" was removed
method_undefined(name) -> ()[permalink][rdoc]このモジュールのインスタンスメソッド name が Module#undef_method によって削除されるか、 undef 文により未定義にされると、インタプリタがこのメソッドを呼び出します。
特異メソッドの削除をフックするには BasicObject#singleton_method_undefined を使います。
class C
def C.method_undefined(name)
puts "method C\##{name} was undefined"
end
def foo
end
def bar
end
undef_method :foo
undef bar
end
実行結果:
method C#foo was undefined method C#bar was undefined
module_function(*name) -> self[permalink][rdoc]メソッドをモジュール関数にします。
引数が与えられた時には、引数で指定されたメソッドをモジュール関数にします。引数なしのときは今後このモジュール定義文内で新しく定義されるメソッドをすべてモジュール関数にします。
モジュール関数とは、プライベートメソッドであると同時にモジュールの特異メソッドでもあるようなメソッドです。例えば Math モジュールのメソッドはすべてモジュール関数です。
self を返します。
module_function はメソッドに「モジュール関数」という属性をつけるメソッドではなく、プライベートメソッドとモジュールの特異メソッドの 2 つを同時に定義するメソッドです。そのため、以下のように書いてもモジュール関数の別名は定義できません。
module M
def foo
p "foo"
end
module_function :foo
alias bar foo
end
M.foo # => "foo"
M.bar # => undefined method `bar' for Foo:Module (NoMethodError)
このコードでは、モジュール関数 foo とプライベートインスタンスメソッド bar を定義してしまいます。
正しくモジュール関数に別名を付けるには、以下のように、先に別名を定義してからそれぞれをモジュール関数にしなければいけません。
module M
def foo
p "foo"
end
alias bar foo
module_function :foo, :bar
end
M.foo # => "foo"
M.bar # => "foo"
prepend_features(mod) -> self[permalink][rdoc]Module#prepend から呼び出されるメソッドで、 prepend の処理の実体です。このメソッド自体は mod で指定したモジュール/クラスの継承チェインの先頭に self を追加します。
このメソッドを上書きすることで、prepend の処理を変更したり追加したりすることができます。
例
class Recorder
RECORDS = []
end
module X
def self.prepend_features(mod)
Recorder::RECORDS << mod
end
end
class A
prepend X
end
class B
include X
end
class C
prepend X
end
Recorder::RECORDS # => [A, C]
[SEE_ALSO] Module#prepend, Module#prepended
prepended(class_or_module) -> ()[permalink][rdoc]self が Module#prepend されたときに対象のクラスまたはモジュールを引数にしてインタプリタがこのメソッドを呼び出します。
module A
def self.prepended(mod)
puts "#{self} prepended to #{mod}"
end
end
module Enumerable
prepend A
end
# => "A prepended to Enumerable"
[SEE_ALSO] Module#included, Module#prepend, Module#prepend_features
private(*name) -> self[permalink][rdoc]メソッドを private に設定します。
引数なしのときは今後このクラスまたはモジュール定義内で新規に定義されるメソッドを関数形式でだけ呼び出せるように(private)設定します。
引数が与えられた時には引数によって指定されたメソッドを private に設定します。
可視性については クラス／メソッドの定義/呼び出し制限 を参照して下さい。
class Foo def foo1() 1 end # デフォルトでは public private # 可視性を private に変更 def foo2() 2 end # foo2 は private メソッド end foo = Foo.new p foo.foo1 # => 1 p foo.foo2 # => private method `foo2' called for #<Foo:0x401b7628> (NoMethodError)
private_constant(*name) -> self[permalink][rdoc]name で指定した定数の可視性を private に変更します。
[SEE_ALSO] Module#public_constant, Object#untrusted?
例:
module Foo BAR = 'bar' class Baz; end QUX = 'qux' class Quux; end private_constant :QUX private_constant :Quux end Foo::BAR # => "bar" Foo::Baz # => Foo::Baz Foo::QUX # => NameError: private constant Foo::QUX referenced Foo::Quux # => NameError: private constant Foo::Quux referenced
protected(*name) -> self[permalink][rdoc]メソッドを protected に設定します。
引数なしのときは今後このクラスまたはモジュール定義内で新規に定義されるメソッドを protected に設定します。
引数が与えられた時には引数によって指定されたメソッドを protected に設定します。
可視性については クラス／メソッドの定義/呼び出し制限 を参照して下さい。
[SEE_ALSO] Module#protected_method_defined?
public(*name) -> self[permalink][rdoc]メソッドを public に設定します。
引数なしのときは今後このクラスまたはモジュール定義内で新規に定義されるメソッドをどんな形式でも呼び出せるように(public)設定します。
引数が与えられた時には引数によって指定されたメソッドを public に設定します。
可視性については クラス／メソッドの定義/呼び出し制限 を参照して下さい。
def foo() 1 end p foo # => 1 # the toplevel default is private p self.foo # => private method `foo' called for #<Object:0x401c83b0> (NoMethodError) def bar() 2 end public :bar # visibility changed (all access allowed) p bar # => 2 p self.bar # => 2
public_constant(*name) -> self[permalink][rdoc]name で指定した定数の可視性を public に変更します。
例
module SampleModule
class SampleInnerClass
end
# => 非公開クラスであることを明示するために private にする
private_constant :SampleInnerClass
end
begin
SampleModule::SampleInnerClass
rescue => e
e # => #<NameError: private constant SampleModule::SampleInnerClass referenced>
end
module SampleModule
# => 非公開クラスであることは承知で利用するために public にする
public_constant :SampleInnerClass
end
SampleModule::SampleInnerClass # => SampleModule::SampleInnerClass
[SEE_ALSO] Module#private_constant, Object#untrusted?
refine(klass) { ... } -> Module[permalink][rdoc]引数 klass で指定したクラスまたはモジュールだけに対して、ブロックで指定した機能を提供できるモジュールを定義します。定義した機能は Module#refine を使用せずに直接 klass に対して変更を行う場合と異なり、限られた範囲のみ有効にできます。そのため、既存の機能を局所的に修正したい場合などに用いる事ができます。
refinements 機能の詳細については以下を参照してください。
定義した機能は main.using, Module#using を実行した場合のみ有効になります。
class C
def foo
puts "C#foo"
end
end
module M
refine C do
def foo
puts "C#foo in M"
end
end
end
x = C.new
x.foo # => "C#foo"
using M
x = C.new
x.foo # => "C#foo in M"
[SEE_ALSO] main.using
remove_const(name) -> object[permalink][rdoc]name で指定した定数を取り除き、その定数に設定されていた値を返します。
class Foo FOO = 1 p remove_const(:FOO) # => 1 p FOO # => uninitialized constant FOO at Foo (NameError) end
組み込みクラス/モジュールを設定している定数や Kernel.#autoload を指定した(まだロードしてない)定数を含めて削除する事ができます。
取り除かれた定数は参照できなくなりますが、消える訳ではないので注意して使用してください。
[SEE_ALSO] Module#remove_class_variable, Object#remove_instance_variable
remove_method(*name) -> self[permalink][rdoc]インスタンスメソッド name をモジュールから削除します。
Ruby 1.8.0 以降は複数のメソッド名を指定して一度に削除できます。
class C def foo end remove_method :foo remove_method :no_such_method # 例外 NameError が発生 end
[SEE_ALSO] Module#undef_method
singleton_class? -> bool[permalink][rdoc]self が特異クラスの場合に true を返します。そうでなければ false を返します。
class C end C.singleton_class? # => false C.singleton_class.singleton_class? # => true
undef_method(*name) -> self[permalink][rdoc]このモジュールのインスタンスメソッド name を未定義にします。
このモジュールのインスタンスに対して name というメソッドを呼び出すことを禁止するということです。スーパークラスの定義が継承されるかどうかという点において、「未定義」は「メソッドの削除」とは区別されます。以下のコード例を参照してください。
class A
def ok
puts 'A'
end
end
class B < A
def ok
puts 'B'
end
end
B.new.ok # => B
# undef_method の場合はスーパークラスに同名のメソッドがあっても
# その呼び出しはエラーになる
class B
undef_method :ok
end
B.new.ok # => NameError
# remove_method の場合はスーパークラスに同名のメソッドがあると
# それが呼ばれる
class B
remove_method :ok
end
B.new.ok # => A
また、undef 文と undef_method の違いは、メソッド名を String または Symbol で与えられることです。
module M1
def foo
end
def self.moo
undef foo
end
end
M1.instance_methods false #=> ["foo"]
M1.moo
M1.instance_methods false #=> []
module M2
def foo
end
def self.moo
undef_method :foo
end
end
M2.instance_methods false #=> ["foo"]
M2.moo
M2.instance_methods false #=> []
using(module) -> self[permalink][rdoc]引数で指定したモジュールで定義された拡張を現在のクラス、モジュールで有効にします。
有効にした拡張の有効範囲については以下を参照してください。
[SEE_ALSO] Module#refine, main.using
フィードバックはこちら