Methods

Key characteristics of Ruby methods:

• They are defined on a class or a module
• They are defined at runtime e.g. by the def statement or by calling the Module.define_method method
• Methods can also be redefined, removed or undefined
• Method calls are invoked on an object, and resolved at runtime using a "message-passing" paradigm - at the time of method call, the object's class and its ancestor classes are searched until one is found which has the method defined on it
• A method's "signature" is just its name - there is no overloading to allow method calls on the same method with different arguments to be resolved to different implementations
• They have powerful and flexible options for passing arguments
• The name of a method can be an operator, such as +, in order to define the behaviour of the operator for a class/module

#Method names A method name may be:

• Any combination of "identity characters" (i.e. alphanumeric, _ or non-ASCII characters), as long as it doesn't begin with a digit
• The name can be one of Ruby's 41 reserved words (e.g. class), but there are restrictions on what syntax you can use to call it
• The name may begin with an uppercase letter (which is a name normally interpreted as a constant), but there are restrictions on what syntax you can use to call it
• One of the following operators: | (binary bitwise or) ^ (binary bitwise xor) & (binary bitwise and) <=> (comparison operator) == (equal to) === (case expression match) =~ (match) !~ (not match) > (greater than) >= (greater than or equal to) < (less than) <= (less than or equal to) != (not equal to) << (bitwise left shift) >> (bitwise right shift) + (binary plus) - (binary minus) * (multiply) / (divide) % (modulus) ** (power) ! (boolean unary not) ~ (complement)
• One of the following tokens +@ (defines unary plus e.g. +value) -@ (defines unary minus e.g. -value) [] (defines array reference get e.g. value[1]) []= (defines array reference set e.g. value[1] = 'hello') ` (defines processing of backquote literal) !@ (same as !) ~@ (same as ~)

Method signature and resolution Method missing Method invocation styles (method & command call) Method formal arguments Method call arguments Permitted method names Undefining Blocks and block arguments send()