ruby Methods, Procs, Lambdas, and Closures

define simple method定义简单方法

关键字def用于方法定义，在其后是方法名和可选的参数名列表，参数名列表会用一对圆括号括住。构成方法主体的代码放在参数列表之后，end用于结束方法定义。

#define a method
def    factorial(n)
    if n<1
        raise "argument must be >0"
    elsif n==1
        1
    else
        n*factorial(n-1)
    end
end
puts factorial(5)

方法返回值

方法可能正常结束，也可能非正常结束。当抛出异常属于非正常结束。
如果方法正常结束，方法代码的最后一个表达式的值会作为方法调用表达式的值。

return关键字将在到达方法最后一个表达式前强行返回。如果return后面没表达式，就返回ni。

def fact2(n)
    raise "bad argument " if n<1
    return 1 if n==1
    n*fact2(n-1)
end

puts fact2(5)

对方法的最后一行也可以使用return关键字，这可以强调这个表达式用作这个方法的返回值。不过在一般的编程实践中，如非必须，会省略return。

ruby方法可以返回多个值，这必须要显式使用return语句，并把要返回的值用逗号分开：
def polar(x,y)
reutrn Maht.hypot(y,x),Math.atan2(y,x)
end

在对象上调用方法 invoking a method on a object

Methods are always invoked on an object. (This object is sometimes called the
receiver in a reference to an object-oriented paradigm in which methods are called
“messages” and are “sent to” receiver objects.) Within the body of a method, the keyword
self refers to the object on which the method was invoked. If we don’t specify
an object when invoking a method, then the method is implicitly invoked on self.

　　You’ll learn how to define methods for classes of objects in Chapter 7. Notice, however,
that you’ve already seen examples of invoking methods on objects, in code like this:
first = text.index(pattern)

　　Like most object-oriented languages, Ruby uses . to separate the object from the method
to be invoked on it. This code passes the value of the variable pattern to the method
named index of the object stored in the variable text, and stores the return value in the
variable first.

定义单键方法define a singleton method

　　目前为止，我们定义的方法都是全局方法。如果把前面的那些def语句放在一个class语句中，这些方法就成为了该类的实例方法，他们被定义在这个类的所有实例对象上。

不过，也可以使用def语句为一个特定的对象定义方法，只需简单地在def关键字后加上一个求值结果为对象的表达式，在这个表达式 之后需要一个句点符号和要定义的方法名。这样定义的方法称为单键方法，因为他只在单个对象上可用:

o="message"
def o.printme
    puts self
end
o.printme #输出message

如果在fixnum定义单键方法，会报错：<main>': can't define singleton method "printme" for Fixnum (TypeError）

取消方法定义undef method

Methods are defined with the def statement and may be undefined with the undef
statement:

def sum(x,y)
    x+y
end
puts sum(1,2)
undef sum

In this code, the def statement defines a global method, and undef undefines it. undef
also works within classes (which are the subject of Chapter 7) to undefine the instance
methods of the class. Interestingly, undef can be used to undefine inherited methods,
without affecting the definition of the method in the class from which it is inherited.
Suppose class A defines a method m, and class B is a subclass of A and therefore inherits
m. (Subclasses and inheritance are also explained in Chapter 7.) If you don’t want to

allow instances of class B to be able to invoke m, you can use undef m within the body
of the subclass.
undef is not a commonly used statement. In practice, it is much more common to
redefine a method with a new def statement than it is to undefine or delete the method.
Note that the undef statement must be followed by a single identifier that specifies the
method name. It cannot be used to undefine a singleton method in the way that def
can be used to define such a method.
Within a class or module, you can also use undef_method (a private method of Module)
to undefine methods. Pass a symbol representing the name of the method to be
undefined.