Example:
class Foo < Super def test : end : end
Syntax:
class identifier ['<' superclass ] expr .. end
Defines a class. Class names are identifiers beginning with an uppercase letter.
Class definitions assign a class to a constant specified by an identifier. In Ruby, classes, too, are objects and one instance of the Class class.
When a class is already defined, writing a class definition with the same class name will add to the existing class definition.
class Foo < Array def foo end end class Foo def bar end end
In a class definition, self
is that class itself; otherwise,
it is no different from a top-level definition. Class definitions can contain arbitrary
expressions that will be executed when the class is defined.
Class definitions can operate as nests. In the following example, there is absolutely no functional relationship (such as inheritance) between the outer class Foo and the inner class Bar, other than the fact that the constant Bar is Foo's inner constant Foo::Bar. Class nests group together semantically related classes into the outer class or module, and can be used to express an inclusion relationship.
class Foo class Bar end end
Class definitions return the result of the last evaluated expression. If that expression does not return a value, the class definition returns nil.
Example:
module Foo def test : end : end
Syntax:
module identifier expr .. end
Defines a module. Module names are identifiers beginning with an uppercase letter.
Module definitions assign a module to a constant specified by an identifier. In Ruby, modules, too, are objects and one instance of the Module class.
When a module is already defined, writing a module definition with the same module name will add to the existing module definition.
Module definitions return the result of the last evaluated expression. If that expression does not return a value, the module definition returns nil.
Example:
def fact(n) if n == 1 then 1 else n * fact(n-1) end end
Syntax:
def methodname ['(' [arg ['=' default]] ... [',' '*' arg] ')'] expr .. [rescue [error_type,..] [then] expr ..].. [ensure expr ..] end
Defines a method, or in other words, defines the method of a class or module if within the definition of that class or module. If top-level, defines methods that can be called from anywhere. This kind of method can be used like functions are in other scripting languages.
Method names can be normal identifiers or redefinable operators (==, +, -, and so on; see Operator Expressions).
When a default expression has been provided to a dummy argument, it becomes the default value when the actual argument is omitted through a method call. The default expression is evaluated at the time of the call and in the context of the method definition.
When the last dummy argument has a * immediately before it, the remaining actual arguments are all stored in this argument as an array.
Example:
# method with no argument. end omitted below def foo end # method with arguments def foo(arg, arg2) # method with default argument def foo(arg = nil) # with everything def foo(arg, arg2, arg3 = nil, *rest) # operator format def ==(other) def +(other) def *(other)
For method definition, each type of dummy argument can only be specified according to the following sequence. Any of the following arguments can be omitted:
The following method definitions have special formats:
# unary plus/minus def +@ def -@ # element substitution def foo=(value) # obj.foo = value # [] and []= def [](key) # obj[key] def []=(key, value) # obj[key] = value def []=(key, key2, value) # obj[key, key2] = value
Furthermore, a begin expression as well as
rescue
and/or ensure
clauses can be specified to trap
exceptions when executing a method.
Method definition returns nil.
When a method is called, its expressions are evaluated in the following order:
rescue
or else
clauses (when specified),
depending on whether an exception has been thrownensure
clause (when specified)Everything is evaluated in the method's context, including the argument's default expression.
The method's return value is the value passed to
return. When return
is not called,
returns the value of the last evaluated expression in the method,
before any ensure
clause is executed.
Methods cannot be called before they are defined. Take the following example:
foo def foo print "foo\n" end
Calling an undefined method, as in the above example, throws a NameError exception.
Example:
def foo.test print "this is foo\n" end
Syntax:
def expr '.' identifier ['(' [ argument ['=' default]] ... [',' '*' argument ]')'] expr .. [rescue [error_type,..] [then] expr ..].. [else expr ..] [ensure expr ..] end
A singleton method belongs to a certain object and not to a class. Singleton-method definitions can be nested.
The singleton methods of a class carry over to its subclasses. In other words, they act like the class methods in other object-oriented languages.
Singleton-method definitions return nil.
In Ruby, class methods are the methods specific to a class. Classes are also objects, so these singleton methods can be defined like regular objects.
Therefore, when a method in a class object is defined in some way, that object becomes a class method. Specifically, these methods can be defined in the following way (as can modules):
# singleton method class Hoge def Hoge.foo end end # can use outside class definition, too def Hoge.bar end # even if the class name changes, you don't have to change the method class Hoge def self.baz end end
Example:
alias foo bar alias :foo :bar
Syntax:
alias newmethod oldmethod
Assigns an alias to a method or global variable. Specifies an identifier or a Symbol as the method name (expressions like obj.method are not permitted). alias's argument performs no evaluation of method calls or the like.
An aliased method carries over that method definition, retaining it even if the original method is redefined. This can be used when you want to change the actions of a given method, then use the result of the original method in the redefined method.
# defining method "foo" def foo "foo" end # setting alias (retracting method definition) alias :_orig_foo :foo # "foo" redefined (using the old definition) def foo _orig_foo * 2 end p foo # => "foofoo"
alias
returns nil.