Ruby Proc.lambda?用法及代码示例

lambda? → true or false

如果 Proc 对象是 lambda，则返回 true。 false 如果非 lambda。

lambda-ness 影响参数处理和 return 和 break 的行为。

proc 生成的 Proc 对象忽略额外的参数。

proc {|a,b| [a,b] }.call(1,2,3)    #=> [1,2]

它为缺少的参数提供nil。

proc {|a,b| [a,b] }.call(1)        #=> [1,nil]

它扩展了单个数组参数。

proc {|a,b| [a,b] }.call([1,2])    #=> [1,2]

lambda 生成的 Proc 对象没有这样的技巧。

lambda {|a,b| [a,b] }.call(1,2,3)  #=> ArgumentError
lambda {|a,b| [a,b] }.call(1)      #=> ArgumentError
lambda {|a,b| [a,b] }.call([1,2])  #=> ArgumentError

Proc#lambda? 是技巧的谓词。如果没有应用技巧，它会返回 true。

lambda {}.lambda?            #=> true
proc {}.lambda?              #=> false

Proc.new 与 proc 相同。

Proc.new {}.lambda?          #=> false

lambda 、 proc 和 Proc.new 保留了 & 参数给出的 Proc 对象的技巧。

lambda(&lambda {}).lambda?   #=> true
proc(&lambda {}).lambda?     #=> true
Proc.new(&lambda {}).lambda? #=> true

lambda(&proc {}).lambda?     #=> false
proc(&proc {}).lambda?       #=> false
Proc.new(&proc {}).lambda?   #=> false

& 参数生成的 Proc 对象有技巧

def n(&b) b.lambda? end
n {}                         #=> false

& 参数保留技巧，如果 Proc 对象由 & 参数给出。

n(&lambda {})                #=> true
n(&proc {})                  #=> false
n(&Proc.new {})              #=> false

从方法转换的 Proc 对象没有任何技巧。

def m() end
method(:m).to_proc.lambda?   #=> true

n(&method(:m))               #=> true
n(&method(:m).to_proc)       #=> true

define_method 与方法定义相同。定义的方法没有技巧。

class C
  define_method(:d) {}
end
C.new.d(1,2)       #=> ArgumentError
C.new.method(:d).to_proc.lambda?   #=> true

define_method 总是定义一个没有技巧的方法，即使给出了一个非 lambda Proc 对象。这是唯一没有保留技巧的例外。

class C
  define_method(:e, &proc {})
end
C.new.e(1,2)       #=> ArgumentError
C.new.method(:e).to_proc.lambda?   #=> true

此异常确保方法永远不会有技巧，并使包装器可以轻松定义行为正常的方法。

class C
  def self.def2(name, &body)
    define_method(name, &body)
  end

  def2(:f) {}
end
C.new.f(1,2)       #=> ArgumentError

包装器def2 定义了一个没有技巧的方法。