当前位置: 首页 > 工具软件 > procs > 使用案例 >

[翻译]理解Ruby中的blocks,Procs和lambda

罗梓
2023-12-01

原文出处: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, 2, 3, 4]

array.iterate! do |n|
  n ** 2
end

puts array.inspect

# => [1, 4, 9, 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, 2, 3, 4]

array.iterate! do |n|
  n ** 2
end

puts array.inspect

# => [1, 4, 9, 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, 2, 3, 4]
array_2 = [2, 3, 4, 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, 4, 9, 16]
# => [4, 9, 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, i|
      self[i] = code.call(n)
    end
  end
end

array = [1, 2, 3, 4]

array.iterate!(Proc.new do |n|
  n ** 2
end)

puts array.inspect

# => [1, 4, 9, 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, i|
      self[i] = code.call(n)
    end
  end
end

array = [1, 2, 3, 4]

array.iterate!(lambda { |n| n ** 2 })

puts array.inspect

# => [1, 4, 9, 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, b, 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| 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, 2, 3, 4]

array.iterate!(method(:square))

puts array.inspect

# => [1, 4, 9, 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灵活的特性了。

 类似资料: