blocks、procs 和 lambdas 之间有什么区别？

Question

Accepted Answer

这三种是 Ruby 处理**代码块作为数据**的方式。**block** 被传递给方法（不是对象）；**Proc** 和 **lambda** 是包装 block 的对象（可调用、可存储）。Procs 和 lambdas 在参数检查和 `return` 行为上有细微差异。

## Blocks — 传递给方法（不是对象）

```ruby
[1, 2, 3].each { |n| puts n }     # the { } is a block — passed to each
# a block is NOT an object; it's part of the method call, can't be stored in a variable directly
```

block 是传递给方法的代码（在 `{ }` 或 `do...end` 中）— 它不是你能存储的独立对象；它与方法调用相关联。

## Procs 和 lambdas — 块作为可存储对象

```ruby
# a Proc — a block turned into an object you can store and call
square = Proc.new { |x| x * x }
square.call(5)        # 25
square.(5)            # 25 (alternate call syntax)

# a lambda — also a callable object (a "stricter" Proc)
double = lambda { |x| x * 2 }
double = ->(x) { x * 2 }   # the -> "stabby lambda" syntax
double.call(5)        # 10
```

Procs 和 lambdas 将 block 包装成**对象**，你可以将其分配给变量、传递，并稍后调用（`.call`）— 对于存储可重用的行为很有用。

## 关键区别：参数和 return

```text
1. ARGUMENT CHECKING:
   lambda → STRICT: errors if wrong number of arguments (like a method)
   proc   → LENIENT: ignores extra args, fills missing with nil

2. RETURN behavior:
   lambda → `return` returns from the LAMBDA (like a normal method)
   proc   → `return` returns from the ENCLOSING METHOD (can surprise you!)
```

```ruby
def test_proc
  p = Proc.new { return 10 }
  p.call                       # returns from test_proc ENTIRELY → 10
  return 20                    # never reached!
end

def test_lambda
  l = lambda { return 10 }
  l.call                       # returns from the LAMBDA only → 10
  return 20                    # reached → test_lambda returns 20
end
```

最重要的区别：**lambda 的行为像一个方法**（严格的参数检查，`return` 仅退出 lambda），而 **proc 更加宽松**（忽略参数不匹配，`return` 退出外层方法 — 这可能导致意外行为）。**通常首选 lambdas**，因为它们有方法般的、可预测的行为。

## 为什么这很重要

理解 blocks、procs 和 lambdas — 特别是它们的区别 — 是重要的 Ruby 知识，反映了对 Ruby 如何将代码作为数据处理的深层理解。**Blocks** 最为常见（传递给方法用于迭代和回调 — Ruby 的标志性特性），而 **procs 和 lambdas** 将 blocks 转变为可存储、可重用的对象，你可以将其分配给变量、传递，并稍后调用（对于存储行为、构建函数式模式和将回调作为值传递很有用）。

**procs 和 lambdas 之间的关键区别**虽然微妙，但很重要，是一个常见的面试话题：**参数检查**（lambdas 像方法一样严格，procs 宽松）以及特别是 **`return` 行为**（lambda 的 `return` 仅退出 lambda，而 proc 的 `return` 退出*外层方法* — 这可能导致意外的、难以调试的行为）。

理解这些区别 — **lambda 的行为像方法**（严格、可预测、返回作用域局限）而 **proc 具有意外的返回语义**更加宽松 — 对于正确使用它们以及**倾向于使用 lambdas** 的普遍建议很重要，因为它们有可预测的、方法式的行为。

Blocks 是日常 Ruby，procs/lambdas 用于可存储的回调和函数式模式，而理解全部三种（尤其是 proc-vs-lambda 返回和参数区别）反映了扎实的 Ruby 知识，帮助你避免 proc 返回的陷阱，是一个经典的面试话题，可以区分真正理解 Ruby 如何将代码作为对象处理的开发者。