在匿名区块中产生

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

我不介意显式声明 &block 变量并直接调用它，但我更希望了解为什么我最终需要这样做。

Answer 1

block_given? 考虑def 范围，而不是lambda 范围：

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

test { puts "In block" }

Answer 2

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 不占用块。

这并不完全是一个权威的答案，但也许它会澄清一点。