原文出处：Understanding Ruby Blocks,Procs and Lambdas
blocks，Procs和lambda(在编程领域被称为闭包)是Ruby中很强大的特性，也是最容易引起误解的特性。
这有可能是因为Ruby使用相当独特的方式来处理闭包。Ruby有四种处理闭包的方式，每一种方式都稍有点不同，甚至有点荒诞，这使得事情变得有点复杂。有不少网站提供了一些关于Ruby闭包的工作方式，但是我还没有找到一个非常有效的指南，希望本篇文章会成为这样的一篇指南。
一、首先来说blocks
最普遍，最简单也最没有争议的Ruby解决闭包的方式就是blocks，使用下面的语法：
array = [1,2,3,4] array.collect! do |n| n ** 2 end puts array.inspect # => [1,4,9,16]
那么，这个代码描述了什么呢？
1、我们将collect!方法和一个代码块发送在了一个Array上。（译者注：有的语言中将方法调用描述为在某个对象上发送了一个消息）
2、在collect!方法中代码块通过变量跟其进行交互(在本例中是n)，并且对变量n求了平方。
3、接下来数组中的每个元素都被求了平方。
在collect!方法中使用代码块是很简单的，我们只需要设想collect!方法将会使代码块作用在数组的每个元素上即可。然而，如果我们想自己写一个类似于collect!的方法会是怎么样呢？我们写一个叫iterate!的方法看看。
class Array
def iterate!
self.each_with_index do |n,i|
self[i] = yield(n)
end
end
end
array = [1,4]
array.iterate! do |n|
n ** 2
end
puts array.inspect
# => [1,16]
我们重新打开了Array类并且把我们自己的iterate!方法放在了里面。我们要遵守Ruby中的约定并在方法名后面放置一个！符号，从而提醒调用者，因为这个方法有可能会带来危险！（译者注：由于iterate方法修改了数组本身）然后我们可以像使用collect!方法一样使用iterate!方法。
代码块的问题在于，你无法给他指定一个明确的名称，从而可以在iterate!方法里面调用。相反，你通过在方法里面调用yield关键字将会执行代码块中的代码。另外，请注意我们如何将n传递给了yield关键字，传递给yield中的n对应了代码块管道列表中的变量。让我们概括一下发生的事情：
1、把iterate!方法扩展到了数组中。
2、当yield被调用时，数字n(n第一次是1，第二次是2，等等)将会被传递给代码块。
3、代码块中将会把n取平方，然后返回。
4、Yield输出了代码块中的值，并且重写了数组中的元素。
5、数组中的每一个元素都会执行这个过程。
目前我们有一个灵活的方式对代码块和方法之间交互。设想代码块是一个API，你可以通过代码块来对数组中的元素求平方、求立方、转化为字符串打印在屏幕等。这些无限的假设使得你的方法非常灵活和强大。
然而，这只是开始，在方法中使用yield关键字是使用代码块的其中一种方法，还有另外一个方式被称作Proc，让我们来看看。
class Array
def iterate!(&code)
self.each_with_index do |n,i|
self[i] = code.call(n)
end
end
end
array = [1,16]
这似乎跟前面的例子很相像，但是有两个区别。第一，我们传递了一个用&符号标记的参数&code。第二，在iterate!方法中，我们通过&code发送call方法而不是yield关键字来调用方法块。这两个实例的结果都是一样的，但是如果是这样，为什么我们需要不同的语法呢？先让我们看看blocks究竟是什么：
def what_am_i(&block)
block.class
end
puts what_am_i {}
# => Proc
block是一个Proc！话虽如此，可是Proc又是什么？
二、Procs
Blocks使用起来非常方便和简单，然而如果有这样的一个需求：同一个blocks要被使用多次。多次使用同一个blocks将会违反DRY原则，Ruby作为一门面向对象的语言，他可以用相当简洁的方式将可重用的代码保存在一个对象中，这种可重用的代码块被称为Proc（procedure的简写），blocks和Proc之间唯一的区别是blocks是一个不能被保存的Proc，因此，他是一种一次性的解决方案。通过使用Procs，我们可以这样做：
class Array
def iterate!(code)
self.each_with_index do |n,i|
self[i] = code.call(n)
end
end
end
array_1 = [1,4]
array_2 = [2,5]
square = Proc.new do |n|
n ** 2
end
array_1.iterate!(square)
array_2.iterate!(square)
puts array_1.inspect
puts array_2.inspect
# => [1,16]
# => [4,16,25]
为什么要小写block，大写Proc？
我总是将Proc以大写开头是因为它是Ruby中一个类。然而，blocks没有自己的类，他仅仅是ruby中的一个语法。因此我会把block以小写开头，在接下来的教程中，我们将会使用以小写开头的lambda，我这样做是出于相同的原因。
请注意我们为何没在iterate!中使用带&符号的code参数？这是因为使用Procs和使用其他数据类型没有什么不同，当我们把Procs当作其他数据类型一样，我们让Ruby解释器做出一些有意思的事情。试一试：
class Array
def iterate!(code)
self.each_with_index do |n,4]
array.iterate!(Proc.new do |n|
n ** 2
end)
puts array.inspect
# => [1,16]
以上是大多数语言处理闭包的方式，并且这种方式等同于发送一个代码块。也许你会说这不是Ruby风格，我会同意你的说法，因为这正是Ruby要引入blocks的原因之一。
如果是这样，为什么不能完全使用blocks呢？原因很简单，如果我们想传递两个闭包该怎么做？blocks变得过于有限，通过Procs我们可以这样：
def callbacks(procs)
procs[:starting].call
puts "Still going"
procs[:finishing].call
end
callbacks(:starting => Proc.new { puts "Starting" },:finishing => Proc.new { puts "Finishing" })
# => Starting
# => Still going
# => Finishing
因此，什么时候使用blocks而不是Procs?我的逻辑如下：
block：你的方法把对象分解为更小的片段，并且你想要跟这些代码片段交互。
block：你想要以原子方式运行多个表达式，像数据库迁移。
Proc：你想多次重用同一个代码块
Proc：你的方法有超过一个的回调
三、Lambda
到目前为止，你已经用两种方式使用了Procs，直接传递代码块和当作一个变量来传递。这种Procs的使用方式跟其他语言中的匿名方法，lambda有点类似。Ruby中也可以直接使用lambda，让我们来看看：
class Array
def iterate!(code)
self.each_with_index do |n,4]
array.iterate!(lambda { |n| n ** 2 })
puts array.inspect
# => [1,16]
初次看上去，lambda似乎跟Procs是一样的。然而，他们有两个细微的差别。第一，不像Procs，lambda会检查所传递的参数：
def args(code)
one,two = 1,2
code.call(one,two)
end
args(Proc.new{|a,b,c| puts "Give me a #{a} and a #{b} and a #{c.class}"})
args(lambda{|a,c| puts "Give me a #{a} and a #{b} and a #{c.class}"})
# => Give me a 1 and a 2 and a NilClass
# *.rb:8: ArgumentError: wrong number of arguments (2 for 3) (ArgumentError)
在Proc的例子中，多余的变量为设置为了nil，然而在lambda中，Ruby将会抛出一个错误。
第二个不同是：在Procs遇到return将会终止方法并返回值，lambda中遇到return将不会终止代码，是不是有点混乱？让我们看一个例子：
def proc_return
Proc.new { return "Proc.new"}.call
return "proc_return method finished"
end
def lambda_return
lambda { return "lambda" }.call
return "lambda_return method finished"
end
puts proc_return
puts lambda_return
# => Proc.new
# => lambda_return method finished
在proc_return中，我们的方法被return关键字打断了，剩下的方法被终止了并输出了字符串Proc.new。另一方面，在lambda_return中返回了字符串并继续执行了剩下的语句。为什么会有这样的不同？
答案是：过程(procedure)和方法(method)的概念差异。Procs在Ruby中是代码片段，并不是方法。而我们可以将lambda看作是一种方法的编写方式，你可以理解为匿名方法。
什么时候使用匿名方法(lambda)来替换Proc呢？看看接下来的例子：
def generic_return(code)
code.call
return "generic_return method finished"
end
puts generic_return(Proc.new { return "Proc.new" })
puts generic_return(lambda { return "lambda" })
# => *.rb:6: unexpected return (LocalJumpError)
# => generic_return method finished
在Proc的使用中，参数不能有return关键字。然而在lambda中，可以写return并可以正确执行。这种不同的语义形式表现在类似的实例中：
def generic_return(code)
one,two = 1,2
three,four = code.call(one,two)
return "Give me a #{three} and a #{four}"
end
puts generic_return(lambda { |x,y| return x + 2,y + 2 })
puts generic_return(Proc.new { |x,y| [x + 2,y + 2] })
# => Give me a 3 and a 4
# => *.rb:9: unexpected return (LocalJumpError)
# => Give me a 3 and a 4
在这里，方法generic_return期望闭包返回两个值。如果要实现这个需求没有return关键字显得不够那么清晰，在lambda中一切都很正常，但是在Proc中就会报错。
所以何时使用Proc和lambda？老实说，除了参数检查，不同的只是你如何看待闭包。如果你觉得传递的是代码块，请使用Proc；如果你觉得你将一个方法传递到了另一个方法中，lambda对你更有意义。如果将lambda看作是方法，如何将已经存在的方法传递给另一个方法呢？
四、Method对象
目前，你已经有一个正常工作的方法，但是你想把此方法当作闭包传递个另一个方法中，为了达到这个目的，你可以使用Ruby提供的method方法。
class Array
def iterate!(code)
self.each_with_index do |n,i|
self[i] = code.call(n)
end
end
end
def square(n)
n ** 2
end
array = [1,4]
array.iterate!(method(:square))
puts array.inspect
# => [1,16]
在这个例子中，我们已经有一个叫做square的方法，我们可以把它转化为一个方法对象并且传递给iterate!，这个method对象是什么类型呢？
def square(n) n ** 2 end puts method(:square).class # => Method
正如你所见，square不是一个Proc类型，而是一个Method类型。有趣的是这个Method对象更像是一个lambda，因为从概念上可以发现他俩的表现一样。只是这个方法有一个名称叫做square，而lambda是匿名方法。
五、结论
截至目前，我们看到了Ruby中使用闭包的四种方式：blocks，Procs，lambda和Method。同时我们还知道了blocks和Procs是代码块，而lambda和Method是方法。通过本文的实例，能帮你在不同的场景选择有效的使用方法。现在可以向你的小伙伴展示ruby灵活的特性了。
版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容， 请发送邮件至 dio@foxmail.com 举报，一经查实，本站将立刻删除。