Ruby 1.9.2 リファレンスマニュアル > ライブラリ一覧 > 組み込みライブラリ > Moduleクラス

class Module

クラスの継承リスト: Module < Object < Kernel < BasicObject

Abstract

モジュールのクラスです。

特異メソッド

constants -> [String]

このメソッドを呼び出した時点で参照可能な定数名の配列を返します。

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]

このメソッドを呼び出した時点でのクラス/モジュールのネスト情報を配列に入れて返します。

module Foo
  module Bar
    module Baz
      p Module.nesting   # => [Foo::Bar::Baz, Foo::Bar, Foo]
    end
  end
end

new -> Module

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

比較演算子。self が other の子孫である場合、 true を返します。 self が other の先祖か同一のクラス／モジュールである場合、false を返します。

継承関係にないクラス同士の比較では nil を返します。

[PARAM] other:: 比較対象のモジュールやクラス
[EXCEPTION] other:: がクラスやモジュールでなければ例外 TypeError が発生します。

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

比較演算子。self が other の子孫であるか、self と other が同一クラスである場合、 true を返します。 self が other の先祖である場合、false を返します。

継承関係にないクラス同士の比較では nil を返します。

[PARAM] other:: 比較対象のモジュールやクラス
[EXCEPTION] other:: がクラスやモジュールでなければ例外 TypeError が発生します。

[SEE_ALSO] Module#<

self <=> other -> Integer | nil

self と other の継承関係を比較します。

self と other を比較して、 self が other の子孫であるとき -1、同一のクラス／モジュールのとき 0、 self が other の先祖であるとき 1 を返します。

継承関係にないクラス同士の比較では nil を返します。

other がクラスやモジュールでなければ nil を返します。

[PARAM] other:: 比較対象のクラスやモジュール

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     # => -1
p Qux <=> Baz     # => -1
p Baz <=> Qux     # => nil
p Qux <=> Baz     # => nil

p Baz <=> Object.new  # => nil

self === obj -> bool

指定された obj が自身かそのサブクラスのインスタンスであるとき真を返します。また、obj が自身をインクルードしたクラスかそのサブクラスのインスタンスである場合にも真を返します。上記のいずれでもない場合に false を返します。

言い替えると obj.kind_of?(self) が true の場合、 true を返します。

このメソッドは主に case 文での比較に用いられます。 case ではクラス、モジュールの所属関係をチェックすることになります。

str = String.new
case str
when String     # String === str を評価する
  p true        # => true
end

[PARAM] obj:: 任意のオブジェクト

[SEE_ALSO] Object#kind_of?, Object#instance_of?, 制御構造/case

self > other -> bool | nil

比較演算子。 self が other の先祖である場合、true を返します。 self が other の子孫か同一クラスである場合、false を返します。

継承関係にないクラス同士の比較では nil を返します。

[PARAM] other:: 比較対象のモジュールやクラス
[EXCEPTION] other:: がクラスやモジュールでなければ例外 TypeError が発生します。

[SEE_ALSO] Module#<

self >= other -> bool | nil

比較演算子。self が other の先祖か同一クラスである場合、 true を返します。 self が other の子孫である場合、false を返します。

継承関係にないクラス同士の比較では nil を返します。

[PARAM] other:: 比較対象のモジュールやクラス
[EXCEPTION] other:: がクラスやモジュールでなければ例外 TypeError が発生します。

[SEE_ALSO] Module#<

ancestors -> [Class, Module]

クラス、モジュールのスーパークラスとインクルードしているモジュールを優先順位順に配列に格納して返します。

module Foo
end
class Bar
  include Foo
end
class Baz < Bar
  p ancestors
  p included_modules
  p superclass
end
# => [Baz, Bar, Foo, Object, Kernel]
# => [Foo, Kernel]
# => Bar

[SEE_ALSO] Module#included_modules

autoload(const_name, feature) -> nil

定数 const_name を最初に参照した時に feature を Kernel.#require するように設定します。

[PARAM] const_name:: String または Symbol で指定します。なお、const_name には、"::" 演算子を含めることはできません。つまり、トップレベルの定数しか指定できません。
[PARAM] feature:: Kernel.#require と同様な方法で autoload する対象を指定する。

[SEE_ALSO] Kernel.#autoload を参照。

autoload?(const_name) -> String | nil

autoload 定数がまだ定義されてない(ロードされていない) ときにそのパス名を返します。また、ロード済みなら nil を返します。

[PARAM] const_name:: String または Symbol で指定します。

[SEE_ALSO] Kernel.#autoload?

module_eval(expr, fname = "(eval)", lineno = 1) -> object

module_eval {|mod| ... } -> object

class_eval(expr, fname = "(eval)", lineno = 1) -> object

class_eval {|mod| ... } -> object

モジュールのコンテキストで文字列 expr またはモジュール自身をブロック引数とするブロックを評価してその結果を返します。

モジュールのコンテキストで評価するとは、実行中そのモジュールが self になるということです。つまり、そのモジュールの定義式の中にあるかのように実行されます。

ただし、ローカル変数だけは module_eval/class_eval の外側のスコープと共有します。定数とクラス変数のスコープは、自身のモジュール定義式内と同じスコープになります。

[PARAM] expr:: 評価される文字列。
[PARAM] fname:: 文字列を指定します。ファイル fname に文字列 expr が書かれているかのように実行されます。スタックトレースの表示などを差し替えることができます。
[PARAM] lineno:: 文字列を指定します。行番号 lineno から文字列 expr が書かれているかのように実行されます。スタックトレースの表示などを差し替えることができます。

例:

class C
end
a = 1
C.class_eval %Q{
  def m                   # メソッドを動的に定義できる。
    return :m, #{a}
  end
}

p C.new.m        #=> [:m, 1]

[SEE_ALSO] Object#instance_eval, Module.new

class_variable_defined?(name) -> bool

name で与えられた名前のクラス変数がモジュールに存在する場合 true を返します。

[PARAM] name:: Symbol か String を指定します。

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 -> [Symbol]

クラス／モジュールに定義されているクラス変数の名前の配列を返します。

スーパークラスやインクルードしているモジュールのクラス変数も含みます。

[SEE_ALSO] Module.constants, Kernel.#local_variables, Kernel.#global_variables, Object#instance_variables, Module#constants

const_defined?(name, inherit = true) -> bool

モジュールに name で指定される名前の定数が定義されている時真を返します。

スーパークラスや include したモジュールで定義された定数を検索対象にするかどうかは第二引数で制御することができます。

[PARAM] name:: String, Symbol で指定される定数名。
[PARAM] inherit:: false を指定するとスーパークラスや 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

モジュールに定義されている name で指定される名前の定数の値を取り出します。

Module#const_defined? と違って Object を特別扱いすることはありません。

[PARAM] name:: 定数名。String か Symbol で指定します。
[PARAM] inherit:: false を指定するとスーパークラスや include したモジュールで定義された定数は対象にはなりません。
[EXCEPTION] NameError:: 定数が定義されていないときに発生します。

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

const_missing(name)

定義されていない定数を参照したときに Ruby インタプリタがこのメソッドを呼びます。

[PARAM] name:: 参照した定数名の Symbol
[EXCEPTION] NameError:: このメソッドを呼び出した場合、デフォルトで発生する例外

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

モジュールに name で指定された名前の定数を value という値として定義し、value を返します。

そのモジュールにおいてすでにその名前の定数が定義されている場合、警告メッセージが出力されます。

[PARAM] name:: Symbol,String で定数の名前を指定します。
[PARAM] value:: セットしたい値を指定します。

constants(inherit = true) -> [Symbol]

そのモジュール(またはクラス)で定義されている定数名の配列を返します。

[PARAM] inherit:: true を指定するとスーパークラスや include したモジュールで定義された定数が対象にはなります。false を指定した場合対象にはなりません。

[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 - $clist                # => ["BAR"]
   # 出力に FOO は含まれない
   p Module.constants - $clist         # => ["BAR", "Bar", "Foo"]
   class Baz
     # Baz は定数を含まない
     p constants - $clist              # => []

     # ネストしたクラスでは、外側のクラスで定義した定数は
     # 参照可能なので、BAR は、Module.constants には含まれる
     # (クラス Baz も Bar の定数なので同様)
     p Module.constants - $clist       # => ["BAR", "Baz", "Bar", "Foo"]
   end
 end

include?(mod) -> bool

self かその親クラス / 親モジュールがモジュール mod をインクルードしていれば true を返します。

[PARAM] mod:: Module を指定します。

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]

インクルードされているモジュールの配列を返します。

[SEE_ALSO] Module#ancestors

instance_method(name) -> UnboundMethod

self のインスタンスメソッドをオブジェクト化した UnboundMethod を返します。

[PARAM] name:: Symbol か String です。
[EXCEPTION] NameError:: self に存在しないメソッドを指定した場合に発生します。

[SEE_ALSO] Object#method

instance_methods(inherited_too = true) -> [Symbol]

そのモジュールで定義されている public および protected メソッド名の一覧を配列で返します。

[PARAM] inherited_too:: false を指定するとそのモジュールで定義されているメソッドのみ返します。

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

# あるクラスのインスタンスメソッドの一覧を得る。
# 親のクラスのインスタンスメソッドも含めるため 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, inherit = true) -> bool

モジュールにインスタンスメソッド name が定義されているとき true を返します。

[PARAM] name:: Symbol か String を指定します。

[SEE_ALSO] Module#public_method_defined?, Module#private_method_defined?, Module#protected_method_defined?

name -> String

to_s -> String

モジュールやクラスの名前を文字列で返します。

このメソッドが返す「モジュール / クラスの名前」とは、より正確には「クラスパス」を指します。クラスパスとは、ネストしているモジュールすべてを「::」を使って表示した名前のことです。クラスパスの例としては「CGI::Session」「Net::HTTP」が挙げられます。

[RETURN]: 名前のないモジュール / クラスに対しては nil を返します。

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

private_class_method(*name) -> self

name で指定したクラスメソッド (クラスの特異メソッド) の可視性を private に変更します。

[PARAM] name:: 0 個以上の String か Symbol を指定します。

private_instance_methods(inherited_too = true) -> [Symbol]

そのモジュールで定義されている private メソッド名の一覧を配列で返します。

[PARAM] inherited_too:: false を指定するとそのモジュールで定義されているメソッドのみ返します。

[SEE_ALSO] Object#private_methods, Module#instance_methods

private_method_defined?(name) -> bool

インスタンスメソッド name がモジュールに定義されており、しかもその可視性が private であるときに true を返します。そうでなければ false を返します。

[PARAM] name:: Symbol か String を指定します。

[SEE_ALSO] Module#method_defined?

protected_instance_methods(inherited_too = true) -> [Symbol]

そのモジュールで定義されている protected メソッド名の一覧を配列で返します。

[PARAM] inherited_too:: false を指定するとそのモジュールで定義されているメソッドのみ返します。

[SEE_ALSO] Object#protected_methods, Module#instance_methods

protected_method_defined?(name) -> bool

インスタンスメソッド name がモジュールに定義されており、しかもその可視性が protected であるときに true を返します。そうでなければ false を返します。

[PARAM] name:: Symbol か String を指定します。

[SEE_ALSO] Module#method_defined?

public_class_method(*name) -> self

name で指定したクラスメソッド (クラスの特異メソッド) の可視性を public に変更します。

[PARAM] name:: 0 個以上の String か Symbol を指定します。

public_instance_methods(inherited_too = true) -> [Symbol]

そのモジュールで定義されている public メソッド名の一覧を配列で返します。

[PARAM] inherited_too:: false を指定するとそのモジュールで定義されているメソッドのみ返します。

[SEE_ALSO] Object#public_methods, Module#instance_methods

public_method_defined?(name) -> bool

インスタンスメソッド name がモジュールに定義されており、しかもその可視性が public であるときに true を返します。そうでなければ false を返します。

[PARAM] name:: Symbol か String を指定します。

[SEE_ALSO] Module#method_defined?

privateメソッド

alias_method(new, original) -> self

メソッドの別名を定義します。

alias との違いは以下の通りです。

メソッド名は String または Symbol で指定します
グローバル変数の別名をつけることはできません

また、クラスメソッドに対して使用することはできません。

[PARAM] new:: 新しいメソッド名。String または Symbol で指定します。
[PARAM] original:: 元のメソッド名。String または Symbol で指定します。

[SEE_ALSO] クラスとメソッドの定義/alias

append_features(module_or_class) -> self

モジュール(あるいはクラス)に self の機能を追加します。

このメソッドは Module#include の実体であり、 include を Ruby で書くと以下のように定義できます。

def include(*modules)
  modules.each {|mod|
    # append_features はプライベートメソッドなので
    # 直接 mod.append_features(self) とは書けない
    mod.__send!(:append_features, self)
    mod.__send!(:included, self)
  }
end

attr(name, assignable = false) -> nil

インスタンス変数読み取りのためのインスタンスメソッド name を定義します。

このメソッドで定義されるアクセスメソッドの定義は次の通りです。

def name
  @name
end

省略可能な第 2 引数 assignable が指定されその値が真である場合には、属性の書き込み用メソッド name= も同時に定義されます。その定義は次の通りです。

def name=(val)
  @name = val
end

[PARAM] name:: String または Symbol で指定します。
[PARAM] assignable:: true を指定するとインスタンス変数書き込み用のインスタンスメソッドも定義します。

attr_accessor(*name) -> nil

インスタンス変数 name に対する読み取りメソッドと書き込みメソッドの両方を定義します。

このメソッドで定義されるメソッドの定義は以下の通りです。

def name
  @name
end
def name=(val)
  @name = val
end

[PARAM] name:: String または Symbol を 1 つ以上指定します。

attr_reader(*name) -> nil

インスタンス変数 name の読み取りメソッドを定義します。

このメソッドで定義されるメソッドの定義は以下の通りです。

def name
  @name
end

[PARAM] name:: String または Symbol を 1 つ以上指定します。

attr_writer(*name) -> nil

インスタンス変数 name への書き込みメソッド (name=) を定義します。

このメソッドで定義されるメソッドの定義は以下の通りです。

def name=(val)
  @name = val
end

[PARAM] name:: String または Symbol を 1 つ以上指定します。

module_exec(*args) {|*vars| ... } -> object

class_exec(*args) {|*vars| ... } -> object

与えられたブロックを指定された args を引数としてモジュールのコンテキストで評価します。

ただし、ローカル変数だけは外側のスコープと共有します。定数とクラス変数のスコープは、自身のモジュール定義式内と同じスコープになります。

[PARAM] args:: ブロックに渡す引数を指定します。

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

クラス／モジュールに定義されているクラス変数 name の値を返します。

[PARAM] name:: String または Symbol を指定します。
[EXCEPTION] NameError:: クラス変数 name が定義されていない場合、発生します。

class Fred
  @@foo = 99
end

def Fred.foo
  class_variable_get(:@@foo)
end

p Fred.foo #=> 99

class_variable_set(name, val) -> object

クラス／モジュールにクラス変数 name を定義して、その値として val をセットします。val を返します。

[PARAM] name:: String または Symbol を指定します。

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

define_method(name) { ... } -> Proc

インスタンスメソッド name を定義します。

ブロックを与えた場合、定義したメソッドの実行時にブロックがレシーバクラスのインスタンスの上で Object#instance_eval されます。

[PARAM] name:: String または Symbol を指定します。
[PARAM] method:: Proc、Method あるいは UnboundMethod のいずれかのインスタンスを指定します。
[RETURN]: 引数 method を与えたときはそれを、ブロック付きで呼びだしたときはブロックを Proc 化したオブジェクトを、それぞれ返します。

class Foo
  def foo() p :foo end
  define_method(:bar, instance_method(:foo))
end
Foo.new.bar    # => :foo

extend_object(module) -> Module

Object#extend の実体です。オブジェクトにモジュールの機能を追加します。

Object#extend は、Ruby で書くと以下のように定義できます。

def extend(*modules)
  modules.each {|mod| mod.__send__ :extend_object, self }
end

extend_object のデフォルトの実装では、self に定義されているメソッドを object の特異メソッドとして追加します。

[PARAM] module:: Enumerable など Module クラスのインスタンスを指定します。
[RETURN]: module で指定されたモジュールを返します。

extended(class_or_module) -> ()

self が他のオブジェクトに Object#extend されたときに呼ばれます。引数には extend を行ったオブジェクトが渡されます。

[PARAM] class_or_module:: Object#extend を行ったオブジェクト

module Foo
  def self.extended(mod)
    p "#{mod} extend #{self}"
  end
end

Object.new.extend Foo

# => "#<Object:0x401cbc3c> extend Foo"

include(*mod) -> self

モジュール mod をインクルードします。

[PARAM] mod:: Module のインスタンス( Enumerable など)を指定します。
[EXCEPTION] ArgumentError:: 継承関係が循環してしまうような include を行った場合に発生します。

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) -> ()

self が Module#include されたときに対象のクラスまたはモジュールを引数にしてインタプリタがこのメソッドを呼び出します。

[PARAM] class_or_module:: Module#include を実行したオブジェクト

module Foo
  def self.included(mod)
    p "#{mod} include #{self}"
  end
end
class Bar
  include Foo
end
# => "Bar include Foo"

local_methods -> Array

Returns a list of the local methods defined in mod.

method_added(name) -> ()

メソッド name が追加された時にインタプリタがこのメソッドを呼び出します。

特異メソッドの追加に対するフックには Object#singleton_method_added を使います。

[PARAM] name:: 追加されたメソッドの名前が Symbol で渡されます。

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) -> ()

メソッドが Module#remove_method により削除された時にインタプリタがこのメソッドを呼び出します。

特異メソッドの削除に対するフックには Object#singleton_method_removed を使います。

[PARAM] name:: 削除されたメソッド名が Symbol で渡されます。

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) -> ()

このモジュールのインスタンスメソッド name が Module#undef_method によって削除されるか、 undef 文により未定義にされると、インタプリタがこのメソッドを呼び出します。

特異メソッドの削除をフックするには Object#singleton_method_undefined を使います。

[PARAM] name:: 削除/未定義にされたメソッド名が Symbol で渡されます。

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

メソッドをモジュール関数にします。

引数が与えられた時には、引数で指定されたメソッドをモジュール関数にします。引数なしのときは今後このモジュール定義文内で新しく定義されるメソッドをすべてモジュール関数にします。

モジュール関数とは、プライベートメソッドであると同時にモジュールの特異メソッドでもあるようなメソッドです。例えば Math モジュールのメソッドはすべてモジュール関数です。

self を返します。

[PARAM] name:: String または Symbol を 0 個以上指定します。

注意

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"

private(*name) -> self

メソッドを private に設定します。

引数なしのときは今後このクラスまたはモジュール定義内で新規に定義されるメソッドを関数形式でだけ呼び出せるように(private)設定します。

引数が与えられた時には引数によって指定されたメソッドを private に設定します。

[PARAM] name:: String または Symbol を 0 個以上指定します。
[EXCEPTION] NameError:: 存在しないメソッド名を指定した場合に発生します。

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)

protected(*name) -> self

メソッドを protected に設定します。

引数なしのときは今後このクラスまたはモジュール定義内で新規に定義されるメソッドを protected に設定します。

引数が与えられた時には引数によって指定されたメソッドを protected に設定します。

[PARAM] name:: String または Symbol を 0 個以上指定します。
[EXCEPTION] NameError:: 存在しないメソッド名を指定した場合に発生します。

public(*name) -> self

メソッドを public に設定します。

引数なしのときは今後このクラスまたはモジュール定義内で新規に定義されるメソッドをどんな形式でも呼び出せるように(public)設定します。

引数が与えられた時には引数によって指定されたメソッドを public に設定します。

[PARAM] name:: String または Symbol を 0 個以上指定します。
[EXCEPTION] NameError:: 存在しないメソッド名を指定した場合に発生します。

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

remove_class_variable(name) -> object

引数で指定したクラス変数を取り除き、そのクラス変数に設定されていた値を返します。

[PARAM] name:: String または Symbol を指定します。
[RETURN]: 引数で指定されたクラス変数に設定されていた値を返します。
[EXCEPTION] NameError:: 引数で指定されたクラス変数がそのモジュールやクラスに定義されていない場合に発生します。

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

remove_const(name) -> object

name で指定した定数を取り除き、その定数に設定されていた値を返します。

[PARAM] name:: String または Symbol を指定します。
[RETURN]: 引数で指定された定数に設定されていた値を返します。
[EXCEPTION] NameError:: 引数で指定された定数がそのモジュールやクラスに定義されていない場合に発生します。

class Foo
  FOO = 1
  p remove_const(:FOO)    # => 1
  p FOO     # => uninitialized constant FOO at Foo (NameError)
end

現在のところ組み込みクラス/モジュールを設定している定数や Kernel.#autoload を指定した(まだロードしてない)定数を削除できないという制約があります。

class Object
  remove_const :Array
end
=> -:2:in `remove_const': cannot remove Object::Array (NameError)

[SEE_ALSO] Module#remove_class_variable, Object#remove_instance_variable

remove_method(*name) -> self

インスタンスメソッド name をモジュールから削除します。

Ruby 1.8.0 以降は複数のメソッド名を指定して一度に削除できます。

[PARAM] name:: String または Symbol を一つ以上指定します。
[EXCEPTION] NameError:: 指定したメソッドが定義されていない場合に発生します。

class C
  def foo
  end

  remove_method :foo
  remove_method :no_such_method   # 例外 NameError が発生
end

[SEE_ALSO] Module#undef_method

undef_method(*name) -> self

このモジュールのインスタンスメソッド name を未定義にします。

[PARAM] name:: String または Symbol を一つ以上指定します。
[EXCEPTION] NameError:: 指定したインスタンスメソッドが定義されていない場合に発生します。

「未定義にする」とは

このモジュールのインスタンスに対して 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 #=> []

追加されるメソッド

rake_extension(method) { ... } [added by rake]

与えられたブロック内で既に存在するメソッドを再定義しようとした場合に警告を表示します。この場合、ブロックは評価されません。

[PARAM] method:: ブロック内で再定義する予定のメソッド名を指定します。

例:

class String
  rake_extension("xyz") do
    def xyz
      ...
    end
  end
end

class Module

Abstract

特異メソッド

インスタンスメソッド

privateメソッド

注意

「未定義にする」とは

追加されるメソッド

Methods

Classes