©
本文档使用php.cn手册发布
一些其它语言有函数，过程，方法等，而Ruby中只有方法：一段表达式代码，返回一个值。
到目前为止，我们在这本书中只是基本的介绍了如何定义，使用方法，现在，我们会继续深入的探讨一些关于方法更深层的东西。
如同在前面看到的一样，定义一个方法用关键字def开头，方法名应该以小写字母开头[如果你用大写字母开头定义一个方法，你不会立即得到一个错误，但是当你调用这个方法时，Ruby首先认为你访问的是一个常量，所以可能会解析错误]，如果一个方法主要用来完成一些查询操作（不专指数据库查询），通常以一个问号"?"结束，作为函数名的最后一个字母，比如instance_of?等。如果一个方法有一定危险，或者可能修改方法的接受者，通常以"!"结尾，比如String类提供了chop和chop!两个方法，第一个方法返回一个修改过的字符串，而第二个方法直接就修改了接收者本身。"?"和"!"是唯一两个能作为方法名后缀的特殊字符。
我们已经指定了方法名，如果需要，我们可以定义一些参数，这些参数用双括号括起来，作用域范围都是局部变量，一些例子如下：
def myNewMethod(arg1, arg2, arg3) # 3 arguments # Code for the method would go here end def myOtherNewMethod # No arguments # Code for the method would go here end |
Ruby允许为方法的参数设置默认值：如果调用者没有显示的为这些参数提供值，将使用这些默认值。通过"="，就可以为这些参数设定默认值。
def coolDude(arg1="Miles", arg2="Coltrane", arg3="Roach") |
||
"#{arg1}, #{arg2}, #{arg3}." |
||
end |
||
|
||
coolDude |
? | "Miles, Coltrane, Roach." |
coolDude("Bart") |
? | "Bart, Coltrane, Roach." |
coolDude("Bart", "Elwood") |
? | "Bart, Elwood, Roach." |
coolDude("Bart", "Elwood", "Linus") |
? | "Bart, Elwood, Linus." |
方法体中包含了一般的Ruby表达式，但是你不能在方法里面定义实例方法，类或者模块。方法的返回值是方法体最后一行执行后的结果，或者你显示的用一个return语句。
如果我们想给方法传入一个数目不定的参数，或者把所有参数放到一个参数中进行传递的话，该怎么办呢？我们可以在普通的参数后面加入一个特殊的参数，这个参数以"*"开头，就可以达到这个目的了。
def varargs(arg1, *rest) |
||
"Got #{arg1} and #{rest.join(', ')}" |
||
end |
||
|
||
varargs("one") |
? | "Got one and " |
varargs("one", "two") |
? | "Got one and two" |
varargs "one", "two", "three" |
? | "Got one and two, three" |
在这个例子中，第一个参数很普通，直接作为第一个参数变量，而后面以"*"开头的参数，将会包括调用时候后面的所有参数，是一个Array的结构，包括了从第二个开始的所有参数。
在讨论块和迭代的那章时，我们知道，当一个方法被调用时候，可以接收一个block，而我们在方法中可以用yield来执行这个block。
def takeBlock(p1) if block_given? yield(p1) else p1 end end |
takeBlock("no block") |
? | "no block" |
takeBlock("no block") { |s| s.sub(/no /, '') } |
? | "block" |
但是，当方法接受参数中最后一个参数以"&"开始的时候，任何给定的block都会转换为Proc对象，并且这个Proc对象将会赋值给这个参数（下例中block指向一个Proc对象）。
class TaxCalculator |
||
def initialize(name, &block) |
||
@name, @block = name, block |
||
end |
||
def getTax(amount) |
||
"#@name on #{amount} = #{ @block.call(amount) }" |
||
end |
||
end |
||
|
||
tc = TaxCalculator.new("Sales tax") { |amt| amt * 0.075 } |
||
|
||
tc.getTax(100) |
? | "Sales tax on 100 = 7.5" |
tc.getTax(250) |
? | "Sales tax on 250 = 18.75" |
通常，调用一个方法需要指定一个接收者，方法名，还有一些参数或者block。
connection.downloadMP3("jitterbug") { |p| showProgress(p) } |
在这个例子里，connection是接收者，downloadMP3是方法名，"jitterbug"是一个参数，{ |p| showProgress(p) }是传递给这个方法的块。
对于类或者模块方法来说，接收者是类或模块名：
File.size("testfile") Math.sin(Math::PI/4) |
如果你省略了接收者，那么默认为self是接收者，即当前对象：
self.id |
? | 537794160 |
id |
? | 537794160 |
self.type |
? | Object |
type |
? | Object |
这种机制也是Ruby实现private方法的体现，private方法不能用一个接收者来直接调用，只能在当前对象中使用。
方法名后面是可选的参数，如果不会出现歧义的话，调用方法时参数可以不加括号括起来[Ruby文档有时候也叫做这样的方法是命令（commands）]，然而，除非特别简单的方法，否则还是加上括号的好，要不可能容易出错，比如，你的方法嵌套在另一个方法调用之中。
a = obj.hash # Same as a = obj.hash() # this. obj.someMethod "Arg1", arg2, arg3 # Same thing as obj.someMethod("Arg1", arg2, arg3) # with parentheses. |
前面我们已经说过了，在一个方法的参数前面可以加一个星号，这样所有后面的参数都被放到了一个数组中，反过来，Ruby也支持调用的时候指定一个数组代替若干个参数。
在调用方法的时候，你可以使用一个数组作为一个参数，它的每个元素都将作为一个单独的参数使用。使用的时候，需要在这个作为参数的数组前面加一个星号。
def five(a, b, c, d, e) |
||
"I was passed #{a} #{b} #{c} #{d} #{e}" |
||
end |
||
|
||
five(1, 2, 3, 4, 5 ) |
? | "I was passed 1 2 3 4 5" |
five(1, 2, 3, *['a', 'b']) |
? | "I was passed 1 2 3 a b" |
five(*(10..14).to_a) |
? | "I was passed 10 11 12 13 14" |
我们已经看过了如何把一个方法和一个块联系起来。
listBones("aardvark") do |aBone| # ... end |
通常，这已经足够好了，我们可以给一个方法提供一个机构良好的块，而不必再方法中使用很多的if或者while等语句。
但是有些时候，你需要更灵活一些，比如，下面的例子，如果选择times，即输入t，将会打印2，4，6，8等等：
print "(t)imes or (p)lus: " times = gets print "number: " number = gets.to_i if times =~ /^t/ puts((1..10).collect { |n| n*number }.join(", ")) else puts((1..10).collect { |n| n+number }.join(", ")) end |
(t)imes or (p)lus: t number: 2 2, 4, 6, 8, 10, 12, 14, 16, 18, 20 |
虽然这样可以工作，但是不是很完美，我们可以把负责计算的部分抽出来组成一个block。
print "(t)imes or (p)lus: " times = gets print "number: " number = gets.to_i if times =~ /^t/ calc = proc { |n| n*number } else calc = proc { |n| n+number } end puts((1..10).collect(&calc).join(", ")) |
(t)imes or (p)lus: t number: 2 2, 4, 6, 8, 10, 12, 14, 16, 18, 20 |
如果最后一个方法的最后一个参数以"&"开头，Ruby把它最为一个Proc来处理，传到相应的block。
这种技术也有另外的用处，比如我们使用迭代器处理一些数据，把每个步骤地结果存储到一个数组中，我们下面将用到前面的Fibonacci 例子来产生一组数据：a = [] |
||
fibUpTo(20) { |val| a << val } |
? | nil |
a.inspect |
? | "[1, 1, 2, 3, 5, 8, 13]" |
尽管这样已经可以工作了，但是这显示出来的意图不像我们想象的那么明晰，所以，我们取而代之的是另外定义了一个方法into，它将返回一个完成填充array功能的block。（注意返回的block是一个闭包closure，即使into返回了，它还指向参数anArray）
def into(anArray) |
||
return proc { |val| anArray << val } |
||
end |
||
|
||
fibUpTo 20, &into(a = []) |
||
a.inspect |
? | "[1, 1, 2, 3, 5, 8, 13]" |
一些语言支持基于键的参数，即hash结构的参数。不按照参数的个数和位置来调用一个方法，而是用一个hash结构的键－值结构来设定参数，而不是按位置。Ruby1。6不支持这种特性，1。8支持。[本书写的是基于1.6，而目前最新的Ruby是1.8]
同时，人们可以用hash结构来实现这一功能，比如，我们要为我们的SongList实现一个按名字查找的功能。class SongList def createSearch(name, params) # ... end end aList.createSearch("short jazz songs", { 'genre' => "jazz", 'durationLessThan' => 270 } ) |
第一个参数是查找的名称，第二个参数是一个hash结构，包含了各种查找的参数。使用hash结构，我们可以是有一些键－值特性：音乐流派是jazz，时长小于4.5分钟。但是这段代码不是太好，而且大括号中的内容很容易被误认为块。所以，Ruby提供了一个快捷方式，你可以在方法的参数中指定键=>值的结构，像普通的参数那样。这样的结构都将作为一个hash结构传给方法，而不需要大扩号了。
aList.createSearch("short jazz songs", 'genre' => "jazz", 'durationLessThan' => 270 ) |
