为什么显式返回在 Proc 中会产生影响？

Question

def foo
  f = Proc.new { return "return from foo from inside proc" }
  f.call # control leaves foo here
  return "return from foo" 
end

def bar
  b = Proc.new { "return from bar from inside proc" }
  b.call # control leaves bar here
  return "return from bar" 
end

puts foo # prints "return from foo from inside proc" 
puts bar # prints "return from bar" 

我认为 return 关键字在 Ruby 中是可选的，并且无论您是否请求，您总是会 return 。鉴于此，我发现令人惊讶的是 foo 和 bar 具有不同的输出，这是由 foo 包含显式 return 的事实决定的Proc f 中的 code>。

有谁知道为什么会这样？

Answer 1

Ruby 具有三种结构：

1. 块不是对象，而是由 { ... } 或 do 创建的...结束。
2. proc 是由 Proc.new 或 proc 创建的 Proc 对象。
3. lambda 是由 lambda（或 Ruby 1.8 中的 proc）创建的 Proc。

Ruby 具有三个从某些内容返回的关键字：

1. return 终止它所在的方法或 lambda。
2. next 终止它所在的块、proc 或 lambda。
3. break 终止生成块或调用其所在的 proc 或 lambda 的方法。

在 lambda 中，无论出于何种原因，return 的行为类似于 next。 next 和 break 之所以如此命名，是因为它们最常与 each 等方法一起使用，其中终止块将导致迭代继续使用集合的下一个元素，终止每个将导致您中断跳出循环。

---

If you use return inside the definition of foo, you will return from foo, even if it is inside a block or a proc. To return from a block, you can use the next keyword instead.

def foo
  f = Proc.new { next "return from foo from inside proc" }
  f.call # control leaves foo here
  return "return from foo" 
end
puts foo # prints "return from foo"

Answer 2

这是 Proc 的语义；它不一定是所有块的语义。我同意这有点令人困惑。它的存在是为了增加灵活性（也许部分原因是 Ruby 除了其实现之外没有规范）。

该行为在 Proc 实现中定义。 Lambda 的行为有所不同，因此如果您希望返回不退出封闭方法，请使用 lambda强>。或者，从您的 Proc 中省略 return 关键字。

对 Ruby 闭包的深入研究在这里。这是一次精彩的曝光。

所以：

def foo   
  f = Proc.new {
    p2 = Proc.new { return "inner proc"};
    p2.call
    return "proc"
  }
  f.call
  return "foo"
end

def foo2
  result = Proc.new{"proc"}.call
  "foo2 (proc result is: #{result})"
end

def bar
  l = lambda { return "lambda" }
  result = l.call
  return "bar (lambda result is: #{result})"
end

puts foo
# inner proc
puts foo2
# foo (proc result is: proc) 
puts bar
# bar (lambda result is: lambda) 

Answer 3

这样想：Proc.new 只是创建一个作为调用函数一部分的代码块。 proc/lambda 创建一个具有特殊绑定的匿名函数。一些代码示例会有所帮助：

def foo
  f = Proc.new { return "return from foo from inside Proc.new" }
  f.call # control leaves foo here
  return "return from foo" 
end

相当于

def foo
  begin
    return "return from foo from inside begin/end" }
  end

  return "return from foo" 
end

所以很明显，返回将仅从函数“foo”返回

相比之下：

def foo
  f = proc { return "return from foo from inside proc" }
  f.call # control stasy in foo here
  return "return from foo" 
end

相当于（忽略绑定，因为在本示例中未使用）：

def unonymous_proc
  return "return from foo from inside proc"
end

def foo
  unonymous_proc()
  return "return from foo" 
end

这显然不会从 foo 返回并继续执行下一条语句。