Programming Ruby 1.9学习笔记之一---Ruby的块(Block)

[size=large]Programming Ruby 1.9学习笔记之一---Ruby的块(Block)[/size]


Ruby中的块是比较有意思的地方，块体现了Ruby灵活之处。块就是一些语句的集合，类似于匿名函数或回调函数。

一，块的声明
块的声明在函数调用之后，用{..}括起来，或do..end封装。{}一般用在单行语句上，do..end用在多行语句上。

(1..4).each{|v| print "#{v} "} #输出1 2 3 4

块可以带参数，与函数参数不同，块参数用||封装，当然，可以带多个参数。这些参数怎么定义，实际上是在函数内部定义好的，后面会讲到。

二，块内变量的访问
块内可以访问块外的变量，也就是块外的变量在块内是可见的，如

sum = 0
(1..5).each do |v|
	name = 'smile' #name属于块内变量，其可视范围只能在块内。假设块外没有相同名称的变量.
	sum += v #sum在块内可见
end
p sum #输出15，sum已改变。
p name #Error! name不可访问。

正因块内可以块外的变量所以可能不小心修改了一些外部变量，这是我们不希望的。幸运的是Ruby1.9版本后，提供了一种安全的方式声明块内变量，在块参数后面加";"，块内变量放在";"之后.

name = 'outside'
sum = 0
(1..5).each do |v;name| #name在";"之后，可以声明多个变量，用逗号隔开
	name = 'inside' #name属于块内变量，其可视范围只能在块内.假设块外没有相同名称的变量。
	sum += v #sum在块内可访问
end
p sum #输出15，sum已改变。
p name #输出outside，没有变。

三，yield语句
看这里，可能还不是很明白，函数是如何调用块的。现在就来介绍块的调用，关键是yield语句。在函数体中，如果用yield，函数会调用函数的块。

def threeTime
	yield
	yield
	yield
end
threeTime{p 'Hello world!'}

输出三行Hello world!，是不是很简单呢。现在应该明白了吧，是yield调用的块。
块的参数是怎么回事呢?估计你已经想到了，就是yield的参数，跟一般函数一样yield可以带参数的。看例子

def takeBlock(p1)
  if block_given? ＃ 判断是否有块，如果在yield时，没有声明块，会出错，所以在这里作判断会好点。
    yield(p1) #把p1传给块参数，既下面块声明中的s
  else
    p1
  end
endie

takeBlock("no block") 	#输出"no block"
takeBlock("no block") { |s| s.sub(/no /, '') } 	#输出"block"

既然yield能传参数给块，反过来，块能不能传值给yield呢?答案是肯定的。块中最后一句语句的值会自动传给yield。请看示例

def nTime
  i = yield #第一次调用时，返回块的值
  (0..i).each {|v| yield(v)} # 此处yield也可以放在块中
end
nTime do |v|
 print "#{v} " if v
 9 #yield调用时返回的数
end
#输出1 2 3 4 5 6 7 8 9

当然上例只是拿来做例子，实际上没有人会这样定义，更好的定义如下:

def nTime(n)
  (0..n).each {|v| yield(v)}
end
nTime(9) do |v|
 print "#{v} "
end

我们来看下Array中的find实现

class Array
  def find
    for i in 0...size
      value = self[i]
      return value if yield(value)
    end
    return nil
  end
end
[1, 3, 5, 7, 9].find {|v| v > 5 } #实现查找第一个大于5的数，输出7。

因为块的出现，Ruby中少了许多for语句，代码看上去更人性化，写代码不再是枯燥的事，而是一种享受。

块也可以转换成对象。在定义函数中，如果最后一个参数名以"&"符号开头，会把块转换成Proc对象并付值给参数。看示例：

class ProcExample
  def pass_in_block(&action) #action以&开头，是一个Proc的实例
   @stored_proc = action
  end
  def use_proc(parameter)
    @stored_proc.call(parameter) #调用Proc.call方法
  end
end
eg = ProcExample.new
eg.pass_in_block { |param| puts "The parameter is #{param}" }
eg.use_proc(99) ＃>>The parameter is 99

如果Proc做为函数的返回值可不可以呢？看下面：

def create_block_object(&block)
  block #直接返回，注意这里不用写&
end
bo = create_block_object { |param| puts "You called me with #{param}" }
bo.call "cat" #=>You called me with cat

是不是很有趣呢？

事实上，Ruby有两种方式把Block直接转换为Proc对象

bo1 = lambda { |param| puts "You called me with #{param}" } ＃使用lambda函数，比较怪异的名字
bo1.call "cat"
bo2 = Proc.new { |param| puts "You called me with #{param}" } ＃使用Proc.new函数
bo2.call "cat"
bo3 = ->(param) {puts "You called me with #{param}" } #Ruby1.9后出现的
bo3.call "cat"

传递块的另一种方式

def fun #不带参数的
  yield
end
proc = ->{p 'haha'}

fun &proc
#####
def fun2(x) #带参数的
  yield x
end
proc2 = ->(x){p x}
fun2 1,&proc2

总结:Ruby的块比java中匿名函数更加简洁与直观。希望大家喜欢上Ruby。