proc and lambda

A return from inside a block that’s still in scope acts as a return from that scope. A return
from a block whose original context is not longer valid raises an exception (LocalJumpError
or ThreadError depending on the context). The following example illustrates the first case:

引用

def meth1
  (1..10).each do |val|
    return val # returns from meth1
  end
end
meth1 # => 1

This example shows a return failing because the context of its block no longer exists:

def meth2(&b) 
  b 
end 
res = meth2 { return } 
res.call 
produces: 
prog.rb:5:in `block in <main>': unexpected return (LocalJumpError) 
from /tmp/prog.rb:6:in `call' 
from /tmp/prog.rb:6:in `<main>' 

And here’s a return failing because the block is created in one thread and called in another:

def meth3 
  yield 
end 
t = Thread.new do 
  meth3 { return } 
end 
t.join 
produces: 
prog.rb:6:in `block (2 levels) in <main>': unexpected return (LocalJumpError) 
from /tmp/prog.rb:2:in `meth3' 
from /tmp/prog.rb:6:in `block in <main>' 

The situation with Proc objects is slightly more complicated. If you use Proc.new to create
a proc from a block, that proc acts like a block, and the previous rules apply:

def meth4 
p = Proc.new { return 99 } 
p.call 
puts "Never get here" 
end 
meth4 # => 99 

If the Proc object is created using Kernel.lambda, it behaves more like a free-standing
method body: a return simply returns from the block to the caller of the block:

def meth5 
p = lambda { return 99 } 
res = p.call 
"The block returned #{res}" 
end 
meth5 # => "The block returned 99" 

Because of this, if you use Module#define_method, you’ll probably want to pass it a proc
created using lambda, not Proc.new, because return will work as expected in the former and
will generate a LocalJumpError in the latter.

1.8中Proc.new和lambda的行为是一样的,但在1.9中Proc.new发生改变,所以在新代码尽量不要使用Proc.new,除非你确信你的代码不会运行在1.8的环境中