浅谈Ruby中的block, proc, lambda, method object的区别

前言

当你们在百度中搜索“block proc lambda”的时候，会出来不少关于这几个概念之间区别的介绍，既然搜索结果中已经有了这些介绍，那为何还要写这篇文章？

相信看过百度搜索结果中排名靠前的几篇文章的同窗，都会发现其实这些文章并无很好的说明他们之间区别是什么，大多只是介绍各自的用法，加上些许的区别，即便个别介绍了一些区别，也不够系统，不够深刻。

正是基于上述缘由，才酝酿了本文。本文以简单示例的方式，详细的介绍了它们之间的区别。相信您阅读完本文，必定会豁然开朗，并在从此的开发中准确并优雅的使用它们。

因为时间，我的能力水平等有限，本文不免有错误或缺失之处，欢迎不吝指出。

block & proc

在介绍它们的区别以前，咱们先来看一段有关block的简单使用方法：

   def use_yield                                                                                         
       yield
   end
   
   use_yield do
       puts 'use yield'
   end
   
   def use_block_call(&block)
       block.call
  end
 
  use_block do
      puts 'use block call'
  end

 

以上介绍了两种在函数中使用block的方式，第一种是经过yield来使用block，另一种则是经过block.call来使用block。

proc全称为procedure，中文翻译为过程，步骤。关于block和proc的区别，咱们先来看一个简单的示例。

   def what_am_i(&block)                                                                                 
       block.class
   end
   puts what_am_i {}  # =< Proc

 

定义一个函数what_am_i并接受一个block，执行体中打印了block的类型，从执行的结果咱们看到block的类型为proc,即说明block为proc的一种。

block和proc之间的区别主要有两个：一是proc能够重复使用，若是某个block将在多个地方被用到，则咱们能够将其定义为proc。另一个区别就是当某个函数须要执行多个闭包的时候，此时咱们就没法使用block而只有使用proc或其余的闭包。

示例以下，在执行某个具体的操做的先后，调用了咱们本身的proc。

   def action(code)                                                                                      
       code[:before].call
       puts 'processing...'
       code[:after].call
   end
  
   action :before => Proc.new {puts 'before action'},
       :after => Proc.new {puts 'after action'}

 

proc & lambda

关于proc和lambda的区别，咱们先来看一个简单的例子。

   def args(code)                                                                                        
       code.call 'one','two'
   end
  
   args Proc.new { |a,b| puts a,b}
   args lambda {|a,b| puts a,b}

 

上述示例，第一眼看去发觉lambda和proc之间没什么区别或者很难发现它们的区别是什么。

接下来，咱们对上述示例作一下简单的修改，咱们将以前的接受两个参数修改成三个，看看会发生什么状况。

   def args(code)
       code.call 'one','two'
   end
   
   args Proc.new { |a,b,c| puts a,b,c}
   args lambda {|a,b,c| puts a,b,c} # =< wrong number of arguments (2 for 3) (ArgumentError)

 

运行修改后的示例，发现lambda闭包出错了，出错的信息为，错误的参数个数。

至此，咱们很快就发现了它们之间的一个区别是，lambda会检查参数的个数，而proc则不会，proc默认将缺失的参数视为nil，并继续执行代码，这是为何呢？在本节的最后，咱们会道出这其中的原因。

在了解到它们的第一个区别以后，接下来咱们再来看一个示例。

   def proc_return•                                                                                      
       Proc.new {return 'Proc.new'}.call
       puts 'proc_return method finished'
   end
   
   def lambda_return
       lambda { return 'lambda'}.call
       puts 'lambda_return method finished'
   end
   
  puts proc_return # =< Proc.new
  puts lambda_return # =< lambda_return method finished

 

这个示例很是的简单，咱们定义了两个函数proc_return以及lambda_return。这两个函数一个用proc实现，另一个用lambda实现，执行体都只有一行代码，就是返回一段字符串。

执行的结果出乎咱们的意料，proc并未执行return以后的代码，而lambda执行了return以后的代码。

综上所述，咱们得出了proc和lambda的两个重要区别，一是lambda会进行参数个数的检查而proc则不会，另外lambda会执行return以后的代码而proc则不会。

为何会出现上述状况，本质的缘由在于，proc只是一段嵌入的代码片断而lambda则是匿名函数，正由于是匿名函数，因此会检查函数调用参数，并在函数调用结束以后，继续执行后面的代码，而proc因为是嵌入的一段代码片断，在执行完return语句后，就已经返回，因此再也不执行以后的代码。

lambda & method object

   def greeting                                                                                          
       puts 'hello, method object'
   end
   
   method(:greeting).call
   
   lambda{puts 'hello, lambda'}.call

 

lambda和method object的用法基本一致，其惟一的区别在于lambda为匿名函数，而method object为命名函数。

总结

关于block,proc,lambda, method object这四者之间的区别可总结为如下：

block和proc本质上是一段嵌入的代码块，并不是函数。而lambda和method object都是函数，只不过lambda是匿名函数，而method object为命名函数。

从本质上理解了它们的区别，咱们在从此的开发中就会正确且优雅的运用它们。

引用

[1] http://www.reactive.io/tips/2008/12/21/understanding-ruby-blocks-procs-and-lambdas/

相关代码

无

若是您对算法或编程感兴趣，欢迎扫描下方二维码并关注公众号“算法与编程之美”，和您一块儿探索算法和编程的神秘之处，给您不同的解题分析思路。