Ruby 块与 proc：yield 关键字与 lambda

编写 Ruby 代码时，你经常会遇到需要重复执行某段逻辑或将其作为参数传递的场景。Ruby 提供了块、Proc 和 Lambda 三种机制来处理这些需求。它们看起来相似，但在行为上有关键区别。本文将直接演示如何定义和使用它们，并理清 yield、Proc 与 Lambda 之间的关系。

1. 使用块与 yield 关键字

块是 Ruby 中最基础的闭包形式，它依附于方法调用存在，不能单独使用。yield 是在方法内部执行所传块的关键字。

1.1 定义并执行简单块

打开你的 Ruby 编辑器或 IRB 交互终端。定义一个包含 yield 的方法：

def execute_block
  puts "步骤一：开始"
  yield
  puts "步骤三：结束"
end

调用该方法并传入一个块：

execute_block { puts "步骤二：执行块内代码" }

输出结果将按顺序打印三个步骤。yield 会暂时让出控制权给传入的代码块，执行完毕后再返回方法内部继续向下运行。

1.2 传递参数给块

块不仅可以执行代码，还可以接收方法通过 yield 传递过来的参数。

修改方法定义，传入参数给 yield：

def calculate_value(x, y)
  puts "正在计算..."
  result = yield(x, y)
  puts "计算结果: #{result}"
end

调用该方法时，在块中使用竖线 | | 接收参数：

calculate_value(10, 5) { |a, b| a + b }

这里 a 接收了 10，b 接收了 5，块返回的和 15 被赋值给了 result。

1.3 检查块是否传递

如果不确保调用方是否传入了块，直接使用 yield 会导致报错。使用 block_given? 方法进行检查：

def safe_run
  if block_given?
    yield
  else
    puts "未提供代码块"
  end
end

safe_run
safe_run { puts "块已执行" }

2. 将块转换为 Proc 对象

块是匿名的，无法直接赋值给变量。如果你想将块作为对象存储、传递或多次调用，需要将其转换为 Proc。

2.1 使用 & 符号捕获块

在方法参数列表末尾添加 &block，Ruby 会自动将传入的块转换为 Proc 对象。

定义一个接收 Proc 对象的方法：

def run_proc(&my_proc)
  puts "Proc 对象类: #{my_proc.class}"
  my_proc.call
end

调用该方法：

run_proc { puts "这是被捕获的 Proc" }

2.2 使用 Proc.new 手动创建

除了通过方法参数捕获，你也可以直接实例化 Proc。

创建一个 Proc 变量并调用它：

double = Proc.new { |x| x * 2 }

puts double.call(5)
# 或者使用简写语法
puts double.(5)
puts double[5]

2.3 Proc 的参数宽容性

Proc 对参数的处理非常宽容。如果定义的参数与传入的参数数量不匹配，它通常会尝试适应，而不是报错。

执行以下代码观察现象：

flexible_proc = Proc.new { |a, b| "a=#{a}, b=#{b}" }

puts flexible_proc.call(1)       # 输出: a=1, b= (缺失部分设为 nil)
puts flexible_proc.call(1, 2, 3) # 输出: a=1, b=2 (多余参数被忽略)

3. 理解 Lambda 的特性

Lambda 也是闭包的一种，语法上类似于 Proc，但在参数检查和返回行为上更像一个普通的方法。Lambda 是 Proc 类的一个实例，但拥有特殊的 lambda? 标志。

3.1 创建 Lambda

使用 -> 语法或 lambda 方法创建 Lambda：

# 语法一（推荐，简洁）
add_lambda = ->(a, b) { a + b }

# 语法二
multiply_lambda = lambda { |a, b| a * b }

调用方式与 Proc 完全一致：

puts add_lambda.call(3, 4)

3.2 Lambda 的严格参数检查

与 Proc 不同，Lambda 对参数数量要求非常严格。

尝试传入错误数量的参数：

strict_lambda = ->(x) { x * 2 }

begin
  strict_lambda.call(1, 2)
rescue ArgumentError => e
  puts "报错: #{e.message}"
end

程序会抛出 wrong number of arguments 错误。

3.3 return 关键字的行为差异

这是 Proc 和 Lambda 最致命的区别。

• Lambda 中的 return：仅仅从 Lambda 自身返回。
• Proc 中的 return：会从定义该 Proc 的作用域（通常是外层方法）直接返回。

对比以下两段代码。

Lambda 示例（安全）：

def test_lambda
  l = -> { return "Lambda 返回" }
  puts l.call
  puts "方法继续执行"
end

puts test_lambda

输出会包含“方法继续执行”，因为 return 只退出了 Lambda。

Proc 示例（危险）：

def test_proc
  p = Proc.new { return "Proc 返回" }
  puts p.call
  puts "这行永远不会打印"
end

puts test_proc

输出只包含“Proc 返回”。一旦执行 p.call，整个 test_proc 方法立即终止。

为了直观理解这种跳转逻辑，请参考下方的执行流程图：

4. Proc 与 Lambda 的核心差异总结

为了快速查阅，下表总结了两者的主要区别：

选择使用哪种对象时遵循以下原则：

• 使用 Lambda 当你需要一个功能类似于“辅助函数”的闭包，且希望参数检查严格，不希望 return 影响外部流程。
• 使用 Proc 当你需要利用“跳出外层方法”的特性（极少见），或者需要极其灵活的参数传递时。