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 定義了一個沒有技巧的方法。