Class | Module |
In: |
object.c
|
A Module is a collection of methods and constants. The methods in a module may be instance methods or module methods. Instance methods appear as methods in a class when the module is included, module methods do not. Conversely, module methods may be called without creating an encapsulating object, while instance methods may not. (See Module#module_function)
In the descriptions that follow, the parameter syml refers to a symbol, which is either a quoted string or a Symbol (such as :name).
module Mod include Math CONST = 1 def meth # ... end end Mod.class #=> Module Mod.constants #=> ["E", "PI", "CONST"] Mod.instance_methods #=> ["meth"]
Returns an array of the names of all constants defined in the system. This list includes the names of all modules and classes.
p Module.constants.sort[1..5]
produces:
["ARGV", "ArgumentError", "Array", "Bignum", "Binding"]
Returns the list of Modules nested at the point of call.
module M1 module M2 $a = Module.nesting end end $a #=> [M1::M2, M1] $a[0].name #=> "M1::M2"
Creates a new anonymous module. If a block is given, it is passed the module object, and the block is evaluated in the context of this module using module_eval.
Fred = Module.new do def meth1 "hello" end def meth2 "bye" end end a = "my string" a.extend(Fred) #=> "my string" a.meth1 #=> "hello" a.meth2 #=> "bye"
Returns true if mod is a subclass of other. Returns nil if there’s no relationship between the two. (Think of the relationship in terms of the class definition: "class A<B" implies "A<B").
Returns true if mod is a subclass of other or is the same as other. Returns nil if there’s no relationship between the two. (Think of the relationship in terms of the class definition: "class A<B" implies "A<B").
Comparison—Returns -1 if mod includes other_mod, 0 if mod is the same as other_mod, and +1 if mod is included by other_mod or if mod has no relationship with other_mod. Returns nil if other_mod is not a module.
Equality—At the Object level, == returns true only if obj and other are the same object. Typically, this method is overridden in descendent classes to provide class-specific meaning.
Unlike ==, the equal? method should never be overridden by subclasses: it is used to determine object identity (that is, a.equal?(b) iff a is the same object as b).
The eql? method returns true if obj and anObject have the same value. Used by Hash to test members for equality. For objects of class Object, eql? is synonymous with ==. Subclasses normally continue this tradition, but there are exceptions. Numeric types, for example, perform type conversion across ==, but not across eql?, so:
1 == 1.0 #=> true 1.eql? 1.0 #=> false
Case Equality—Returns true if anObject is an instance of mod or one of mod’s descendents. Of limited use for modules, but can be used in case statements to classify objects by class.
Returns true if mod is an ancestor of other. Returns nil if there’s no relationship between the two. (Think of the relationship in terms of the class definition: "class A<B" implies "B>A").
Returns true if mod is an ancestor of other, or the two modules are the same. Returns nil if there’s no relationship between the two. (Think of the relationship in terms of the class definition: "class A<B" implies "B>A").
Makes new_name a new copy of the method old_name. This can be used to retain access to methods that are overridden.
module Mod alias_method :orig_exit, :exit def exit(code=0) puts "Exiting with code #{code}" orig_exit(code) end end include Mod exit(99)
produces:
Exiting with code 99
Returns a list of modules included in mod (including mod itself).
module Mod include Math include Comparable end Mod.ancestors #=> [Mod, Comparable, Math] Math.ancestors #=> [Math]
When this module is included in another, Ruby calls append_features in this module, passing it the receiving module in mod. Ruby’s default implementation is to add the constants, methods, and module variables of this module to mod if this module has not already been added to mod or one of its ancestors. See also Module#include.
Defines a named attribute for this module, where the name is symbol.id2name, creating an instance variable (@name) and a corresponding access method to read it. If the optional writable argument is true, also creates a method called name= to set the attribute.
module Mod attr :size, true end
is equivalent to:
module Mod def size @size end def size=(val) @size = val end end
Equivalent to calling ``attrsymbol, true’’ on each symbol in turn.
module Mod attr_accessor(:one, :two) end Mod.instance_methods.sort #=> ["one", "one=", "two", "two="]
Creates instance variables and corresponding methods that return the value of each instance variable. Equivalent to calling ``attr:name’’ on each name in turn.
Registers filename to be loaded (using Kernel::require) the first time that name (which may be a String or a symbol) is accessed in the namespace of mod.
module A end A.autoload(:B, "b") A::B.doit # autoloads "b"
Returns filename to be loaded if name is registered as autoload in the namespace of mod.
module A end A.autoload(:B, "b") A.autoload?(:B) # => "b"
Evaluates the string or block in the context of mod. This can be used to add methods to a class. module_eval returns the result of evaluating its argument. The optional filename and lineno parameters set the text for error messages.
class Thing end a = %q{def hello() "Hello there!" end} Thing.module_eval(a) puts Thing.new.hello() Thing.module_eval("invalid code", "dummy", 123)
produces:
Hello there! dummy:123:in `module_eval': undefined local variable or method `code' for Thing:Class
Returns the value of the given class variable (or throws a NameError exception). The @@ part of the variable name should be included for regular class variables
class Fred @@foo = 99 end def Fred.foo class_variable_get(:@@foo) #=> 99 end
Sets the class variable names by symbol to object.
class Fred @@foo = 99 def foo @@foo end end def Fred.foo class_variable_set(:@@foo, 101) #=> 101 end Fred.foo Fred.new.foo #=> 101
Returns an array of the names of class variables in mod and the ancestors of mod.
class One @@var1 = 1 end class Two < One @@var2 = 2 end One.class_variables #=> ["@@var1"] Two.class_variables #=> ["@@var2", "@@var1"]
Invoked when a reference is made to an undefined constant in mod. It is passed a symbol for the undefined constant, and returns a value to be used for that constant. The following code is a (very bad) example: if reference is made to an undefined constant, it attempts to load a file whose name is the lowercase version of the constant (thus class Fred is assumed to be in file fred.rb). If found, it returns the value of the loaded class. It therefore implements a perverse kind of autoload facility.
def Object.const_missing(name) @looked_for ||= {} str_name = name.to_s raise "Class not found: #{name}" if @looked_for[str_name] @looked_for[str_name] = 1 file = str_name.downcase require file klass = const_get(name) return klass if klass raise "Class not found: #{name}" end
Sets the named constant to the given object, returning that object. Creates a new constant if no constant with the given name previously existed.
Math.const_set("HIGH_SCHOOL_PI", 22.0/7.0) #=> 3.14285714285714 Math::HIGH_SCHOOL_PI - Math::PI #=> 0.00126448926734968
Returns an array of the names of the constants accessible in mod. This includes the names of constants in any included modules (example at start of section).
Defines an instance method in the receiver. The method parameter can be a Proc or Method object. If a block is specified, it is used as the method body. This block is evaluated using instance_eval, a point that is tricky to demonstrate because define_method is private. (This is why we resort to the send hack in this example.)
class A def fred puts "In Fred" end def create_method(name, &block) self.class.send(:define_method, name, &block) end define_method(:wilma) { puts "Charge it!" } end class B < A define_method(:barney, instance_method(:fred)) end a = B.new a.barney a.wilma a.create_method(:betty) { p self } a.betty
produces:
In Fred Charge it! #<B:0x401b39e8>
Extends the specified object by adding this module’s constants and methods (which are added as singleton methods). This is the callback method used by Object#extend.
module Picky def Picky.extend_object(o) if String === o puts "Can't add Picky to a String" else puts "Picky added to #{o.class}" super end end end (s = Array.new).extend Picky # Call Object.extend (s = "quick brown fox").extend Picky
produces:
Picky added to Array Can't add Picky to a String
Returns true if module is included in mod or one of mod’s ancestors.
module A end class B include A end class C < B end B.include?(A) #=> true C.include?(A) #=> true A.include?(A) #=> false
Callback invoked whenever the receiver is included in another module or class. This should be used in preference to Module.append_features if your code wants to perform some action when a module is included in another.
module A def A.included(mod) puts "#{self} included in #{mod}" end end module Enumerable include A end
Returns the list of modules included in mod.
module Mixin end module Outer include Mixin end Mixin.included_modules #=> [] Outer.included_modules #=> [Mixin]
Returns an UnboundMethod representing the given instance method in mod.
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_byte {|b| Dispatcher[b].bind(self).call } end end interpreter = Interpreter.new interpreter.interpret('dave')
produces:
Hello there, Dave!
Returns an array containing the names of public instance methods in the receiver. For a module, these are the public methods; for a class, they are the instance (not singleton) methods. With no argument, or with an argument that is false, the instance methods in mod are returned, otherwise the methods in mod and mod’s superclasses are returned.
module A def method1() end end class B def method2() end end class C < B def method3() end end A.instance_methods #=> ["method1"] B.instance_methods(false) #=> ["method2"] C.instance_methods(false) #=> ["method3"] C.instance_methods(true).length #=> 43
Returns true if the named method is defined by mod (or its included modules and, if mod is a class, its ancestors). Public and protected methods are matched.
module A def method1() end end class B def method2() end 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? "method4" #=> false
Evaluates the string or block in the context of mod. This can be used to add methods to a class. module_eval returns the result of evaluating its argument. The optional filename and lineno parameters set the text for error messages.
class Thing end a = %q{def hello() "Hello there!" end} Thing.module_eval(a) puts Thing.new.hello() Thing.module_eval("invalid code", "dummy", 123)
produces:
Hello there! dummy:123:in `module_eval': undefined local variable or method `code' for Thing:Class
Creates module functions for the named methods. These functions may be called with the module as a receiver, and also become available as instance methods to classes that mix in the module. Module functions are copies of the original, and so may be changed independently. The instance-method versions are made private. If used with no arguments, subsequently defined methods become module functions.
module Mod def one "This is one" end module_function :one end class Cls include Mod def callOne one end end Mod.one #=> "This is one" c = Cls.new c.callOne #=> "This is one" module Mod def one "This is the new one" end end Mod.one #=> "This is one" c.callOne #=> "This is the new one"
With no arguments, sets the default visibility for subsequently defined methods to private. With arguments, sets the named methods to have private visibility.
module Mod def a() end def b() end private def c() end private :a end Mod.private_instance_methods #=> ["a", "c"]
Makes existing class methods private. Often used to hide the default constructor new.
class SimpleSingleton # Not thread safe private_class_method :new def SimpleSingleton.create(*args, &block) @me = new(*args, &block) if ! @me @me end end
Returns a list of the private instance methods defined in mod. If the optional parameter is not false, the methods of any ancestors are included.
module Mod def method1() end private :method1 def method2() end end Mod.instance_methods #=> ["method2"] Mod.private_instance_methods #=> ["method1"]
Returns true if the named private method is defined by _ mod_ (or its included modules and, if mod is a class, its ancestors).
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
With no arguments, sets the default visibility for subsequently defined methods to protected. With arguments, sets the named methods to have protected visibility.
Returns a list of the protected instance methods defined in mod. If the optional parameter is not false, the methods of any ancestors are included.
Returns true if the named protected method is defined by mod (or its included modules and, if mod is a class, its ancestors).
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
With no arguments, sets the default visibility for subsequently defined methods to public. With arguments, sets the named methods to have public visibility.
Returns a list of the public instance methods defined in mod. If the optional parameter is not false, the methods of any ancestors are included.
Returns true if the named public method is defined by mod (or its included modules and, if mod is a class, its ancestors).
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
Removes the definition of the sym, returning that constant’s value.
class Dummy @@var = 99 puts @@var remove_class_variable(:@@var) puts(defined? @@var) end
produces:
99 nil
Removes the definition of the given constant, returning that constant’s value. Predefined classes and singleton objects (such as true) cannot be removed.
Removes the method identified by symbol from the current class. For an example, see Module.undef_method.
Return a string representing this module or class. For basic classes and modules, this is the name. For singletons, we show information on the thing we’re attached to as well.
Prevents the current class from responding to calls to the named method. Contrast this with remove_method, which deletes the method from the particular class; Ruby will still search superclasses and mixed-in modules for a possible receiver.
class Parent def hello puts "In parent" end end class Child < Parent def hello puts "In child" end end c = Child.new c.hello class Child remove_method :hello # remove from child, still in parent end c.hello class Child undef_method :hello # prevent any calls to 'hello' end c.hello
produces:
In child In parent prog.rb:23: undefined method `hello' for #<Child:0x401b3bb4> (NoMethodError)