Ruby 块 Block、Proc、Lambda 彻底分清
在 Ruby 的世界里，Block、Proc、Lambda 三者如影随形，却又各怀心思。90% 的开发者都曾在它们之间迷失方向。今天，我们就把这三兄弟的脾气秉性，一次性说透。
一、先认清本质：谁是对象，谁是"寄人篱下"
表格
特性 Block Proc Lambda
是否独立存在 ❌ 否 ✅ 是 ✅ 是
本质 语法结构（代码片段） Proc 类实例 Proc 类实例（特殊的）
创建方式 {...} 或 do...end Proc.new {...} lambda {...} 或 ->(x){...}
调用方式 yield .call .call
一句话总结：Block 是"临时工"，Proc 和 Lambda 是"正式员工"。
Block 依附于方法调用而存在，不能独立存活。而 Proc 和 Lambda 都是 Proc 类的实例，可以赋值、传递、存储，随时调用。
二、参数检查：宽松派 vs 严格派
这是 Proc 和 Lambda 最直观的分水岭。
ruby
Lambda：严格检查，少一个参数都不行
lam = ->(x) { puts x }
lam.call(2) # ✅ 输出 2
lam.call # ❌ ArgumentError: wrong number of arguments (0 for 1)
lam.call(1, 2, 3) # ❌ ArgumentError: wrong number of arguments (3 for 1)
Proc：宽松处理，多余忽略，缺少补 nil
proc = Proc.new { |x| puts x }
proc.call(2) # ✅ 输出 2
proc.call # ✅ 输出 nil（不报错）
proc.call(1, 2, 3) # ✅ 输出 1（多余参数被忽略）
结论：需要严格参数校验时，选 Lambda；需要容错灵活时，选 Proc。
三、Return 行为：这才是最致命的陷阱！
很多人栽在这里，因为 return 在三者中的行为截然不同。
Lambda 中的 return → 仅退出 Lambda 自身
ruby
def lambda_test
lam = lambda { return "我从 lambda 回来了" }
lam.call
puts "Hello World"
end
lambda_test
输出：Hello World
return 只是从 lambda 内部跳出，外部代码继续执行，行为和普通方法里的 return 一致。
Proc 中的 return → 直接炸穿外层方法！
ruby
def proc_test
proc = Proc.new { return }
proc.call
puts "Hello World"
end
proc_test
输出：（什么都没有）
return 直接从 proc_test 方法中返回了，后面的 puts 永远不会被执行。这就是所谓的非局部返回，也是最容易踩的坑。
Block 中的 return → 同 Proc，炸穿外层方法
Block 的 return 行为与 Proc 完全一致------从定义它的方法中直接返回。
表格
类型 return 行为
Lambda 仅从 lambda 自身返回，外部继续执行
Proc 从包含它的方法中直接返回
Block 从包含它的方法中直接返回
四、闭包能力：三者都能"记住"外部变量
Ruby 的块、Proc、Lambda 全部支持闭包（Closure），能够捕获定义时的上下文环境。
ruby
def make_counter
count = 0
Proc.new { count += 1 }
end
counter = make_counter
puts counter.call # 1
puts counter.call # 2
puts counter.call # 3
每次调用，count 持续累加。这就是闭包的威力------变量被"冻结"在创建时的作用域中，即使外部函数已退出，依然可以访问和修改。
五、性能对比：该用谁？
表格
类型 创建开销 调用速度 最佳场景
Block 最低 最高 迭代器（each/map/select）、临时逻辑
Proc 中等 中等 需复用的灵活逻辑、回调机制
Lambda 较高 高 函数式编程、需要严格参数校验的场景
原则：能用 Block 就用 Block，需要复用或严格校验时才升级到 Proc/Lambda。
六、实战：何时选谁？
表格
场景 推荐 理由
each、map、select 迭代 Block 轻量高效，语法简洁
策略模式 / 回调函数 Proc 可存储、可传递，参数容错
函数式编程 / 柯里化 Lambda 严格参数 + 局部 return，行为可预测
替代 if/elsif/else Lambda 封装条件逻辑，减少嵌套
DSL（如 Rails） Block do...end 语法天然适合领域特定语言
策略模式实战示例
ruby
discount_strategies = {
regular: Proc.new { |price| price * 0.9 },
premium: Proc.new { |price| price * 0.7 },
vip: Proc.new { |price| price \* 0.5, 100.max }
}
puts discount_strategies:vip.call(200) # 100
puts discount_strategies:vip.call(80) # 80（最低优惠 100 未触发）
无需条件分支，哈希键直接分发策略，代码干净又易扩展。
七、一张图总结
text
┌─────────────┐
│ Block │ ← 临时工，依附方法，不能独立存在
│ {...} │ return 炸穿外层，无参数检查
└──────┬──────┘
│ 封装为对象
┌──────────┴──────────┐
▼ ▼
┌─────────────┐ ┌─────────────┐
│ Proc │ │ Lambda │
│ 宽松派 │ │ 严格派 │
│ 参数不校验 │ │ 参数严格校验 │
│ return 炸穿 │ │ return 局部 │
└─────────────┘ └─────────────┘
记住这三句话，你就彻底赢了：
Block 是语法，Proc/Lambda 是对象。
Lambda 像方法（严参数、局部 return），Proc 像"野路子"（松参数、炸穿 return）。
能用 Block 就别造对象，需要复用和校验时再上 Proc/Lambda。
Ruby 的优雅，就藏在这些细微的差别里。用对了，代码如诗；用错了，满屏 Bug。现在，你知道该怎么选了。