为什么明确的返回作出一个Proc有区别吗？为什么明确的返回作出一个Proc有区别吗？(Why doe

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 。

有谁知道为什么是这样的话？

Answer 1:

Ruby有三种结构：

1. A 嵌段是不是一个对象，并且由创建{ ... }或do ... end 。
2. 一个PROC是一个Proc通过创建的对象Proc.new或proc 。
3. 一个lambda是一个Proc通过创建lambda （或proc在红宝石1.8）。

Ruby有三个关键字，从返回一些东西：

1. return终止该方法或λ是英寸
2. next终止块，PROC，或λ是英寸
3. break终止该屈服于块或调用的PROC或λ是在该方法中。

在lambda表达式， return的行为就像next ，无论出于何种原因。 next和break被命名为他们，因为他们是最常见的类似方法使用方式each ，其中，终止该块会导致重复，将恢复与集合的下一个元素，并终止each会使你跳出循环。

---

如果您使用return的定义中foo ，你将返回从foo ，哪怕是块或proc中。 要从块返回，您可以使用next关键字。

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 S; 它不一定对所有块的语义。 我同意这是一个有点混乱。 这是有更大的灵活性（也许部分导致Ruby没有规范，除了它的实现）。

该行为在定义Proc实施。 Lambda小号行为不同，所以如果你想你的return 不是退出了封闭的方法，使用lambda表达式 。 或者，省略了return ，从您的关键字Proc 。

RUBYS倒闭的深入研究是在这里 。 这是一个奇妙的揭露。

所以：

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 /λ创建具有特殊的绑定匿名函数。 一个小的代码示例将帮助：

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

所以很明显，回报率将刚刚从函数“富”返回

相反：

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的返回，并继续到下一个语句。

文章来源: Why does explicit return make a difference in a Proc?