在一個匿名塊

Question

，我不是做以下行爲的意義，得到（見in this SO thread）：

def def_test 
    puts 'def_test.in' 
    yield if block_given? 
    puts 'def_test.out' 
end 

def_test do 
    puts 'def_test ok' 
end 

block_test = proc do |&block| 
    puts 'block_test.in' 
    block.call if block 
    puts 'block_test.out' 
end 

block_test.call do 
    puts 'block_test' 
end 

proc_test = proc do 
    puts 'proc_test.in' 
    yield if block_given? 
    puts 'proc_test.out' 
end 

proc_test.call do 
    puts 'proc_test ok' 
end 

輸出：

def_test.in 
def_test ok 
def_test.out 
block_test.in 
block_test ok 
block_test.out 
proc_test.in 
proc_test.out 

我不介意訴諸明確聲明&塊變量，並直接調用它，但我更想理解爲什麼我最終需要。

Answer 1

lambda的是一個封閉件，它似乎被捕獲從其外範圍block_given?和塊。這種行爲確實有意義，因爲該塊或多或少是外部方法的隱含參數;如果需要，您甚至可以在指定參數中捕獲塊：

def def_test(&block) 
    frobnicate &block 
end 

因此，塊即使在未命名時也是參數列表的一部分。

考慮這種簡單的代碼：

def f 
    lambda do 
     puts "\tbefore block" 
     yield if block_given? 
     puts "\tafter block" 
    end 
end 

puts 'Calling f w/o block' 
x = f; x.call 
puts 

puts 'Calling f w/ block' 
x = f { puts "\t\tf-block" }; x.call 
puts 

puts 'Calling f w/o block but x with block' 
x = f; x.call { puts "\t\tx-block" } 
puts 

puts 'Calling f w/ block and x with block' 
x = f { puts "\t\tf-block" }; x.call { puts "\t\tx-block" } 

這產生對我以下與1.9.2：

Calling f w/o block 
    before block 
    after block 

Calling f w/ block 
    before block 
     f-block 
    after block 

Calling f w/o block but x with block 
    before block 
    after block 

Calling f w/ block and x with block 
    before block 
     f-block 
    after block 

此外，Proc#call（AKA proc ===）不取一塊：

prc === obj→result_of_proc
調用塊，用obj作爲塊的參數。它允許proc對象成爲case語句中when子句的目標。

比較與所述文檔的第一行對於Enumerable#chunk（例如）：

enum.chunk {| ELT | ...}→an_enumerator

的{...}表明chunk是記錄採取塊，爲Proc#call缺乏這種符號的表示Proc#call並不需要一個塊。

這不完全是一個權威的答案，但它可能會清除一點點。

Answer 2

block_given?認爲def範圍，不lambda範圍：

def test 
    l = lambda do 
    yield if block_given? 
    end 
    l.call 
end 

test { puts "In block" }