一、闭包是什么？从买菜说起

想象你去菜市场买菜，摊主老王认识你，每次都会给你留最新鲜的蔬菜。这个"老王记得你"的关系，就像编程中的闭包——函数和它记得的环境的组合。

在Ruby中，闭包通常用Proc或lambda实现。看个例子：

# 技术栈：Ruby 3.0
def setup_greeting(name)
  # 返回一个lambda，它"记住"了传入的name
  ->(time) { puts "#{time}好，#{name}！" }
end

morning_greeting = setup_greeting("张三")
morning_greeting.call("早") #=> "早好，张三！"

这里setup_greeting返回的lambda就是闭包，它带着name="张三"的记忆。就像老王记得你的口味一样。

二、作用域链：变量的寻宝地图

当闭包嵌套时，Ruby会像考古学家一样层层挖掘变量：

def outer_function
  outer_var = "外层"
  -> {
    inner_var = "内层"
    -> {
      # 这里能访问outer_var和inner_var
      puts "#{outer_var} -> #{inner_var}"
    }
  }
end

deep_closure = outer_function.call.call
deep_closure.call #=> "外层 -> 内层"

变量查找顺序就像剥洋葱：

  1. 先找当前作用域
  2. 找不到就往上一层函数找
  3. 直到顶层作用域

三、函数式编程实战：用闭包造工具

闭包特别适合用来创建工厂函数。比如做个计数器生成器：

def create_counter(start = 0)
  count = start
  # 返回两个闭包：一个计数，一个重置
  [-> { count += 1 }, -> { count = start }]
end

increment, reset = create_counter(10)
puts increment.call #=> 11
puts increment.call #=> 12
reset.call
puts increment.call #=> 10

这比用类实现更轻量，就像随身携带瑞士军刀而不是工具箱。

四、高级技巧：闭包的三副面孔

Ruby中有三种闭包形态，区别很微妙：

# 1. Proc（像灵活的胖子）
p = Proc.new { |x| x * 2 }
puts p.call(3) #=> 6
puts p.call    #=> nil（不报错！）

# 2. lambda（像严格的瘦子）
l = ->(x) { x * 2 }
puts l.call(3) #=> 6
# puts l.call  #=> 报错！参数不足

# 3. 代码块（隐形的精灵）
def yield_twice
  yield(1)
  yield(2)
end
yield_twice { |x| puts x * 10 } #=> 10, 20

五、避坑指南：闭包使用的雷区

  1. 内存泄漏陷阱
    闭包会持有外部变量，可能导致对象无法释放：

    def leak_memory
  big_data = "X" * 1024**2 # 1MB数据
  -> { puts big_data[0] }  # 闭包持有整个big_data！
end

  2. 变量捕获意外
    Ruby的闭包是"晚绑定"的：

    funcs = []
(1..3).each do |i|
  funcs << -> { puts i } # 你以为捕获的是1/2/3？
end
funcs.each(&:call) #=> 全输出3！

    修正方法：用参数传递或Object#tap。

六、现实中的应用场景

  1. 回调机制：比如Rails的after_save
  2. 延迟执行：将计算过程打包传递
  3. DSL设计：让API读起来像自然语言
  4. 线程安全：闭包自带的隔离特性

举个Web框架的例子：

# 模拟路由定义
router = Router.new
router.get "/users" do |req|
  # 这个闭包在请求到达时才执行
  "Hello, #{req.params[:name]}!"
end

七、为什么选择闭包？优劣分析

✅ 优点：

  • 减少重复代码（DRY原则）
  • 创建有状态的函数
  • 实现控制反转

❌ 缺点：

  • 调试困难（调用栈不明显）
  • 性能略低于普通方法调用
  • 可能引发内存问题

八、总结：闭包就像时间胶囊

闭包把代码和它诞生时的环境一起封装，就像把2023年的空气封存在玻璃瓶里。在函数式编程中，它让我们能够：

  1. 创建灵活的行为单元
  2. 构建抽象层次
  3. 实现优雅的惰性计算

下次看到->{}时，不妨想想——这不仅是语法，更是一种编程哲学的体现。