Ruby Lambda 与 Proc LocalJumpError

Question

Ruby 和 StackOverflow 新手在这里使用 Ruby 进行工作，并遇到了我的第一个主要障碍。我真的很难理解 Procs 和 Lambdas。这是我正在使用的代码。

def procBuilder(message)
  Proc.new{ puts message; return}
end

def test
  puts "entering method"
  p = procBuilder("entering proc")
  p.call
  puts "exit method"
end

test

按照设计，这是为了抛出 LocalJumpError，但我不明白为什么。如果我不得不猜测这是做什么的，我猜它最初会在 p = procBuilder("entering proc") 运行时打印“entering proc”，然后在 p.call 上抛出错误，因为 p.call 没有传递任何字符串，但显然我错过了这两行之间发生的一些关键事情。我也不完全理解为什么这适用于 lambda 而不是 proc，但我想理解错误也能解决该问题。

预先感谢您的澄清

Answer 1

这是我对相关问题给出的答案。它讨论了一些关于 lambda 与 proc 和 LocalJumpErrors 的内容。

在过程中，return 是一段特殊的语法，它从过程的词法范围返回，而不是过程本身。因此它试图从已经退出的 procBuilder 中返回。

有几种方法可以解决此问题：

1. 根本不使用 return。 Ruby 将自行将控制权返回给 proc 的调用者。
2. 将 proc 更改为 lambda，其行为符合您的预期。 Lambda 的行为类似于方法；过程就像块一样。

至于您预期的错误，您不应该得到它。 procBuilder 返回包含消息变量的过程。您不需要过程本身的任何参数。

编辑：回答您的附加问题。该过程是一个闭包。它“捕获”了消息变量（procBuilder 中的局部变量），该变量在创建 proc 时处于作用域内。现在，proc 可以在您的程序中漫游，消息变量隐藏在其中，准备在您调用它时打印。唯一的麻烦是 return 语句，它有一个额外的要求，即词法范围仍然是“活动的”。

这一切的原因是这种行为在区块中确实很有帮助。在这种情况下，它根本没有帮助，所以您应该只使用 lambda ，其中 return 意味着不那么疯狂。

关于 ruby​​ 中闭包的非常棒的教程： http://innig.net/software /ruby/closures-in-ruby.rb

Answer 2

proc 和方法或 lambda 之间的一个重要区别是它们处理 return 语句的方式。如果一个方法定义在另一个方法内部，则内部方法中的 return 语句仅从内部方法本身退出，然后外部方法继续执行。这同样适用于在 lambda 中定义 lambda、在方法中定义 lambda 或在 lambda 中定义方法。但是，当在方法内定义 proc 时，return 语句将从 proc 以及外部（封闭）方法中退出。示例：

def meditate
    puts "Adjusting posture…"
    p = Proc.new { puts "Ringing bell…"; return }
    p.call
    puts "Sitting still…"  # This is not executed
end

meditate

Output:
Adjusting posture…
Ringing bell…

请注意该方法的最后一行没有执行，因为 proc 中的 return 语句已从 proc 和封闭方法中退出。

如果我们定义一个没有封闭（外部）方法的 proc 并使用 return 语句，它将抛出 LocalJumpError。

p = Proc.new { puts "Ringing bell…"; return }
p.call
Output:
Ringing bell…
LocalJumpError: unexpected return

发生这种情况是因为当在 proc 内到达 return 语句时，它不是从调用它的上下文返回，而是从定义它（proc）的范围返回。在下面的示例中，发生 LocalJumpError 是因为 proc 试图从定义它的顶级环境返回。

def meditate p
    puts "Adjusting posture…"
    p.call
    puts "Sitting still…"  # This is not executed
end

p = Proc.new { puts "Ringing bell…"; return }

meditate p
Output:
Adjusting posture…
Ringing bell…
LocalJumpError: unexpected return

通常，在过程中使用 return 语句不是一个好主意。过程通常在方法之间传递，如果定义过程的方法已经返回，它将抛出异常。在下面的示例中，我们可以删除 return 语句。然而，有些情况下我们实际上需要返回一些东西。在后者中，最好使用 lambda 而不是 proc。稍后我们将看到 lambda 以不同的方式处理 return 语句，更像是方法。

下面是另一个涉及 return 语句的场景：

def zafu_factory
    # This method will return the following proc implicitly
    Proc.new { puts "Round black zafu"; return }
end

def meditate
    puts "Adjusting posture…"
    p = zafu_factory
    p.call
    puts "Sitting still…"  # This is not executed
end

meditate
Output:
Adjusting posture…
Round black zafu
LocalJumpError: unexpected return

刚刚发生了什么？ zafu_factory 方法创建并隐式返回一个过程。然后，该 proc 由 meditate 方法调用，并且当到达 proc 内的 return 语句时，它尝试从定义它的上下文（zafu_factory 方法）返回。但是，zafu_factory 已经返回了 proc，并且方法每次调用时只能返回一次。换句话说，抛出异常是因为当调用proc时zafu_factory方法已经返回并尝试第二次返回。

有关 Proc 和 Lambda 的更多信息，请参阅此博客文章： Ruby 中的闭包