Ruby method 学习笔记
学习笔记，来自于Programming Ruby 1.9

Ruby 关于Method

一、 定义方法
使用关键字 def
方法名称以小写字母或下划线开头，后面跟着字母、数字和下划线
有的方法名后面跟着？，！或＝
方法名有?通常意味着方法返回boolean型结果
例：

1.even? # => false2.even? # => true1.instance_of?(Fixnum) # => true

方法名后有！，则此方法的接收者将被修改
方法名后加＝，通常意味着赋值

Ruby方法的参数可以设定默认值

def cool_dude(arg1="Miles", arg2="Coltrane", arg3="Roach")"#{arg1}, #{arg2}, #{arg3}."endcool_dude # => "Miles, Coltrane, Roach."cool_dude("Bart") # => "Bart, Coltrane, Roach."cool_dude("Bart", "Elwood") # => "Bart, Elwood, Roach."cool_dude("Bart", "Elwood", "Linus") # => "Bart, Elwood, Linus."

二、可变长度的参数
在参数前加＊号，用以接收多个参数值或可变参数值

def varargs(arg1, *rest)"arg1=#{arg1}. rest=#{rest.inspect}"endvarargs("one") # => arg1=one. rest=[]varargs("one", "two") # => arg1=one. rest=[two]varargs "one", "two", "three" # => arg1=one. rest=[two, three]

使用＊号表示一个在方法中不使用，但可能在父类中使用到的参数

class Child < Parent  def do_something(*not_used)    # our processing    super  endend

这种情况下，可以不需要写参数名称，只使用＊表示参数

class Child < Parent  def do_something(*)    # our processing    super  endend

在Ruby1.9中，我们可以把此类参数放在任何位置，如：

def split_apart(first, *splat, last)  puts "First: #{first.inspect}, splat: #{splat.inspect}, " +    "last: #{last.inspect}"endsplit_apart(1,2)split_apart(1,2,3)split_apart(1,2,3,4)produces:First: 1, splat: [], last: 2First: 1, splat: [2], last: 3First: 1, splat: [2, 3], last: 4

三、方法和Block
在方法中使用block通常使用yield

def double(p1)  yield(p1*2)enddouble(3) {|val| "I got #{val}" } # => "I got 6"double("tom") {|val| "Then I got #{val}" } # => "Then I got tomtom"

然而，如果方法定义中的最后一个参数以&开头，则，所有相关的block都会转换为Proc对象。

class TaxCalculator  def initialize(name, &block)    @name, @block = name, block  end  def get_tax(amount)    "#@name on #{amount} = #{ @block.call(amount) }"  endendtc = TaxCalculator.new("Sales tax") {|amt| amt * 0.075 }tc.get_tax(100) # => "Sales tax on 100 = 7.5"tc.get_tax(250) # => "Sales tax on 250 = 18.75"

四、方法调用
方法的默认接收者为self
在一个类方法或module中的方法，接收者为类或module的名称

五、把参数传给一个方法
六、方法的返回值
每一个调用的方法都会有一个返回值。方法的返回值是最后一个语句执行的结果

def meth_one  "one"endmeth_one # => "one"def meth_two(arg)  case  when arg > 0 then "positive"  when arg < 0 then "negative"  else "zero"  endendmeth_two(23) # => "positive"meth_two(0) # => "zero"

Ruby有一个关于return 的语句
如果return多个值，则方法会返回一个数组

def meth_three  100.times do |num|    square = num*num    return num, square if square > 1000  endendmeth_three # => [32, 1024]num, square = meth_threenum # => 32square # => 1024

七、Splat，将扩张集合到方法调用中
这个是Ruby1.9中的特性
之前我们看到在方法定义的参数中，在参数前加＊，可以将多个参数值传给一个参数，
这里正好相反。
调用一个方法时，你可以把任意的集合或列举型对象转变成组合的元素，然后把这些元素传递给单独的参数了。在传递的数组参数前加上＊。

def five(a, b, c, d, e)  "I was passed #{a} #{b} #{c} #{d} #{e}"endfive(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(*['a', 'b'], 1, 2, 3) # => "I was passed a b 1 2 3"five(*(10..14)) # => "I was passed 10 11 12 13 14"five(*[1,2], 3, *(4..5)) # => "I was passed 1 2 3 4 5"

八、让Blocks更加动态一些
如果方法的最后一个参数值有&，Ruby假定这是一个Proc对象，Ruby会把该Proc 对象转换为一个block，然后在方法中使用。
九、收集Hash变量
一般方法中，参数值对应一定的参数变量，传递参数就需要按照一定的顺序。
在Ruby中可以使用Hash的键值对，来传递参数。

class SongList  def search(name, params)    # ...  endendlist.search(:titles,  { :genre => "jazz", :duration_less_than => 270 })

此处，可以将Hash作为一个键＝>值参数列表。

list.search(:titles,  :genre => 'jazz',  :duration_less_than => 270)

在Ruby1.9中，可以写成：

list.search(:titles, genre: 'jazz', duration_less_than: 270)