Ruby Proc 与 Lambda

在 Ruby 中，Proc 和 Lambda 是将代码块作为对象进行处理的核心工具。它们允许你封装一段行为，将其像数据一样传递，并在未来的某个时刻执行。这为代码复用、灵活性以及函数式编程技巧开启了强大的可能性。

理解 Proc 和 Lambda 对于编写更具表现力、更易维护的 Ruby 代码至关重要。基于上一章关于方法和代码块的知识，本章将深入剖析它们的特性、区别以及实际应用。

1. 理解 Proc

Proc（“procedure”的缩写，意为过程）是一种将代码块封装成对象的方法。封装后的对象可以存储在变量中，作为参数传递给方法，甚至可以从方法中返回。本质上，Proc 将一段代码块变成了 Ruby 程序中的“一等公民”。

1.1 创建 Proc

在 Ruby 中创建 Proc 有几种常见的方式：

使用 Proc.new：这是最常见且最明确的创建方式。你将一个代码块传递给 Proc.new，它会返回一个 Proc 对象。

# 使用 Proc.new 创建一个 Proc
my_proc = Proc.new { puts "来自 Proc 内部的问候！" }

# 调用这个 Proc
my_proc.call

使用 proc 关键字：proc 是一个等同于 Proc.new 的关键字。它提供了一种更简洁的语法来创建 Proc。

# 使用 'proc' 关键字创建一个 Proc
my_proc = proc { puts "来自 Proc 内部的问候！" }

# 调用这个 Proc
my_proc.call

方法转 Proc 操作符 (&)：当你把一个方法作为参数传递给另一个方法时，可以使用 & 操作符将该方法转换为 Proc。这在你希望将某个现成的方法当作代码块使用时特别方便。

def my_method(arg)
  puts "方法被调用，参数为: #{arg}"
end

# 使用 & 操作符将方法转换为 proc 的示例
def another_method(proc)
  proc.call("Hello")
end

another_method(&method(:my_method)) # 在传递之前，将 my_method 转换为 proc

1.2 调用 Proc

一旦你拥有了一个 Proc 对象，你就可以使用 call 方法或 [] 操作符来执行它包含的代码。

# 使用 'call' 方法
my_proc = Proc.new { |name| puts "你好，#{name}！" }
my_proc.call("Alice")

# 使用 '[]' 操作符（等同于 call）
my_proc = Proc.new { |name| puts "你好，#{name}！" }
my_proc["Bob"]

1.3 Proc 的参数处理

Proc 在处理参数时非常灵活。它们不强制要求严格的参数数量（Arity）。这意味着你可以用比它定义的更多或更少的参数来调用 Proc。

参数过少：如果你调用 Proc 时提供的参数少于它的期望值，缺失的参数将被赋值为 nil。

my_proc = Proc.new { |x, y| puts "x: #{x}, y: #{y}" }
my_proc.call(1)  # 输出: x: 1, y: 
my_proc.call(1,2) # 输出: x: 1, y: 2

参数过多：如果你调用 Proc 时提供的参数多于它的期望值，多余的参数将被直接忽略。

my_proc = Proc.new { |x, y| puts "x: #{x}, y: #{y}" }
my_proc.call(1, 2, 3)  # 输出: x: 1, y: 2

1.4 示例：Proc 作为闭包 (Closure)

Proc 会保持对其被定义时所在作用域的访问权限。这意味着它们可以“记住”其周围环境中的变量，即使那个环境已经不复存在。这种特性被称为闭包 (Closure)。

def counter
  count = 0
  Proc.new { count += 1; puts count }
end

my_counter = counter  # my_counter 是由 counter 方法返回的 Proc
my_counter.call # 输出: 1
my_counter.call # 输出: 2
my_counter.call # 输出: 3

在这个例子中，counter 方法内部创建的 Proc 保留了对 count 变量的访问权，即使 counter 方法已经执行完毕并返回。每次执行 my_counter.call 时，它都会递增并打印 count 的值。

2. 理解 Lambda

Lambda 是 Ruby 中将代码块定义为对象的另一种方式。与 Proc 类似，Lambda 也可以存储在变量中、作为参数传递并从方法中返回。然而，Lambda 与 Proc 之间存在一些关键差异，特别是在处理参数和 return 语句的行为上。

2.1 创建 Lambda

创建 Lambda 主要有两种方式：

使用 lambda 关键字：这是定义 Lambda 最常见的方式。它类似于 Proc.new，但底层行为不同。

# 使用 'lambda' 关键字创建 Lambda
my_lambda = lambda { |name| puts "你好，#{name}！" }

# 调用 Lambda
my_lambda.call("Charlie")

使用 ->（箭头语法 / Stabby lambda）：这种语法提供了一种更简洁的定义 Lambda 的方式，特别适合简短的单行 Lambda。

# 使用 '->' 语法创建 Lambda
my_lambda = ->(name) { puts "你好，#{name}！" }

# 调用 Lambda
my_lambda.call("Diana")

2.2 调用 Lambda

调用 Lambda 的方式与调用 Proc 完全相同：使用 call 方法或 [] 操作符。

# 使用 'call' 方法
my_lambda = lambda { |name| puts "你好，#{name}！" }
my_lambda.call("Eve")

# 使用 '[]' 操作符
my_lambda = lambda { |name| puts "你好，#{name}！" }
my_lambda["Frank"]

2.3 Lambda 的参数处理 (Arity)

与 Proc 不同，Lambda 强制要求严格的参数数量。这意味着调用 Lambda 时，必须提供与其期望完全一致的参数个数。如果提供的参数数量不对，程序将抛出 ArgumentError 异常。

my_lambda = lambda { |x, y| puts "x: #{x}, y: #{y}" }

# 下面这行代码会抛出 ArgumentError: wrong number of arguments (given 1, expected 2)
# my_lambda.call(1)

# 下面这行代码会抛出 ArgumentError: wrong number of arguments (given 3, expected 2)
# my_lambda.call(1, 2, 3)

my_lambda.call(1,2) # 输出: x: 1, y: 2

2.4 Lambda 中的 return 语句

Lambda 内部的 return 语句行为与 Proc 不同。在 Lambda 中，return 语句只会退出 Lambda 本身，并将控制权交还给调用它的方法。这与常规方法中 return 的工作方式非常相似。

(注：如果在 Proc 中使用 return，它会尝试退出定义该 Proc 的整个外部方法。)

def my_method
  my_lambda = lambda { return "从 Lambda 中返回" }
  result = my_lambda.call
  puts "这行代码将会被执行"
  return result
end

puts my_method 
# 输出: 这行代码将会被执行
#         从 Lambda 中返回

在这个例子中，my_lambda 内部的 return 仅仅退出了 Lambda 块。随后的 puts "这行代码将会被执行" 依然会正常运行，最后 my_method 返回了 Lambda 给出的值。

2.5 示例：Lambda 用于数据验证

Lambda 经常被用于数据验证场景，此时你需要确保在进行计算前满足特定条件。Lambda 严格的参数要求使其非常适合这种工作。

def process_data(data, validator)
  if validator.call(data)
    puts "数据有效。正在处理..."
    # 在此处执行数据处理
  else
    puts "数据无效。操作中止。"
  end
end

is_number = ->(x) { x.is_a? Numeric }

process_data(10, is_number)     # 输出: 数据有效。正在处理...
process_data("abc", is_number)  # 输出: 数据无效。操作中止。

3. Proc 与 Lambda 的核心差异

4. 如何选择 Proc 与 Lambda

选择使用 Proc 还是 Lambda 取决于你代码的具体需求。

建议使用 Lambda 的场景：

• 你需要严格的参数检查。
• 你希望 return 语句的表现像常规方法一样（仅仅跳出当前代码块）。
• 你必须确保代码块接收到预期数量的参数。

建议使用 Proc 的场景：

• 你在参数传递方面需要极大的灵活性（允许忽略多余参数或接受缺失参数）。
• 你确实希望 return 语句能直接中断并退出包含它的整个外部方法。
• 你正在处理的 API 或代码期望接收一个 block，但不强制要求严格的参数验证。

5. 实用案例与演示

5.1 案例 1：使用 Proc 格式化数据

假设你想以不同的方式格式化数据。你可以使用 Proc 来封装格式化逻辑。

def format_data(data, formatter)
  formatter.call(data)
end

to_uppercase = Proc.new { |str| str.upcase }
to_lowercase = Proc.new { |str| str.downcase }

data = "Hello World"

puts format_data(data, to_uppercase) # 输出: HELLO WORLD
puts format_data(data, to_lowercase) # 输出: hello world

5.2 案例 2：使用 Lambda 过滤数据

假设你需要根据特定条件过滤数据。你可以使用 Lambda 定义过滤逻辑。

def filter_data(data, filter_criteria)
  data.select { |item| filter_criteria.call(item) }
end

numbers = [1, 2, 3, 4, 5, 6]
is_even = ->(x) { x % 2 == 0 }

even_numbers = filter_data(numbers, is_even)
puts even_numbers.inspect # 输出: [2, 4, 6]

5.3 案例 3：结合 & 与 Proc 进行方法委托

想象一下，你有一个类，并且想快速地将一个方法调用委托给内部的一个对象。

class Logger
  def log(message)
    puts "记录日志: #{message}"
  end
end

class Service
  def initialize
    @logger = Logger.new
  end

  def log_message(&block) # 接收一个代码块 (自动转换为 Proc)
    @logger.instance_eval &block # 在 Logger 实例的上下文中执行该代码块
  end
end

service = Service.new
service.log_message { log("这是一条被委托的消息") } 
# 输出: 记录日志: 这是一条被委托的消息

在这个例子中，Service 类中的 log_message 方法接收一个 block（通过 & 隐式转换为 Proc）。然后，它使用 instance_eval 在 @logger 对象的上下文中执行该 block，从而有效地将 log 方法调用委托给了 Logger 实例。