Ruby 2.0.0 リファレンスマニュアル > ライブラリ一覧 > 組み込みライブラリ > Moduleクラス
クラスの継承リスト: Module < Object < Kernel < BasicObject
モジュールのクラスです。
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" のどちらかに決まる
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#<
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#<
self >= other -> bool | nil
[permalink][rdoc]比較演算子。self が other の先祖か同一クラスである場合、 true を返します。 self が other の子孫である場合、false を返します。
継承関係にないクラス同士の比較では nil を返します。
[SEE_ALSO] Module#<
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
autoload?(const_name) -> String | nil
[permalink][rdoc]autoload 定数がまだ定義されてない(ロードされていない) ときにそのパス名を返します。 また、ロード済みなら nil を返します。
[SEE_ALSO] Kernel.#autoload?
module_eval(expr, fname = "(eval)", lineno = 1) -> object
[permalink][rdoc]module_eval {|mod| ... } -> object
class_eval(expr, fname = "(eval)", lineno = 1) -> object
class_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 を返します。
そのモジュールにおいてすでにその名前の定数が定義されている場合、警 告メッセージが出力されます。
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
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
[permalink][rdoc]to_s -> String
inspect -> 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
instance_method(name) -> UnboundMethod
[permalink][rdoc]self のインスタンスメソッド name をオブジェクト化した UnboundMethod を返します。
[SEE_ALSO] Module#public_instance_method, Object#method
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 が定義されているとき true を返します。
[SEE_ALSO] Module#public_method_defined?, Module#private_method_defined?, Module#protected_method_defined?
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
# 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 に変更します。
private_instance_methods(inherited_too = true) -> [Symbol]
[permalink][rdoc]そのモジュールで定義されている private メソッド名 の一覧を配列で返します。
[SEE_ALSO] Object#private_methods, Module#instance_methods
private_method_defined?(name) -> bool
[permalink][rdoc]インスタンスメソッド name がモジュールに定義されており、 しかもその可視性が private であるときに true を返します。 そうでなければ false を返します。
[SEE_ALSO] Module#method_defined?
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?
public_class_method(*name) -> self
[permalink][rdoc]name で指定したクラスメソッド (クラスの特異メソッド) の 可視性を public に変更します。
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?
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
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, assignable = false) -> nil
[permalink][rdoc]インスタンス変数読み取りのためのインスタンスメソッド name を定義します。
このメソッドで定義されるアクセスメソッドの定義は次の通りです。
def name @name end
省略可能な第 2 引数 assignable が指定されその値が真である 場合には、属性の書き込み用メソッド name= も同時に定義されます。 その定義は次の通りです。
def name=(val) @name = val end
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) -> Proc | Method | UnboundMethod
[permalink][rdoc]define_method(name) { ... } -> Proc
インスタンスメソッド name を定義します。
ブロックを与えた場合、定義したメソッドの実行時にブロックが レシーバクラスのインスタンスの上で BasicObject#instance_eval されます。
class Foo def foo() p :foo end define_method(:bar, instance_method(:foo)) end Foo.new.bar # => :foo
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
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]
引数に複数のモジュールを指定した場合、 最後の引数から順にインクルードします。
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 の処理を変更したり 追加したりすることができます。
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
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?
protected(*name) -> self
[permalink][rdoc]メソッドを protected に設定します。
引数なしのときは今後このクラスまたはモジュール定義内で新規に定義さ れるメソッドを protected に設定します。
引数が与えられた時には引数によって指定されたメソッドを protected に設定します。
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 に変更します。
[SEE_ALSO] Module#private_constant, Object#untrusted?
refine(klass) { ... } -> Module
[permalink][rdoc]引数 klass で指定したクラスだけに対して、ブロックで指定した機能を提供で きるモジュールを定義します。定義した機能は Module#refine を使用せずに直 接 klass に対して変更を行う場合と異なり、限られた範囲のみ有効にできます。 そのため、既存の機能を局所的に修正したい場合などに用いる事ができます。
refinements 機能の詳細については以下を参照してください。
定義した機能は main.using を実行した場合のみ有効になります。
[注意] refinements は 2.0 現在、実験的な機能として提供されています。以 降のバージョンで仕様が変更になる可能性があります。使用すると必ず警告が 表示されます。
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
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 #=> []