Ruby Proc类用法及代码示例

Proc 对象是对代码块的封装，它可以存储在局部变量中，传递给方法或另一个 Proc ，并且可以被调用。 Proc 是 Ruby 中的一个基本概念，也是其函数式编程特性的核心。

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

square.call(3)  #=> 9
# shorthands:
square.(3)      #=> 9
square[3]       #=> 9

Proc 对象是 closures ，这意味着它们可以记住并且可以使用创建它们的整个上下文。

def gen_times(factor)
  Proc.new {|n| n*factor } # remembers the value of factor at the moment of creation
end

times3 = gen_times(3)
times5 = gen_times(5)

times3.call(12)               #=> 36
times5.call(5)                #=> 25
times3.call(times5.call(4))   #=> 60

创建

有几种方法可以创建 Proc

• 使用 Proc 类构造函数：

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

• 使用 Kernel#proc 方法作为 Proc.new 的简写：

  proc2 = proc {|x| x**2 }

• 将一段代码接收到 proc 参数中(注意 & )：

  def make_proc(&block)
    block
  end
  
  proc3 = make_proc {|x| x**2 }

• 使用 Kernel#lambda 方法构造具有 lambda 语义的 proc(有关 lambda 的说明，请参见下文)：

  lambda1 = lambda {|x| x**2 }

• 使用 Lambda proc literal 语法(也构造具有 lambda 语义的 proc)：

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

Lambda 和非 Lambda 语义

Procs 有两种形式：lambda 和 non-lambda(常规 procs)。区别在于：

• 在 lambdas 中，return 和 break 表示退出此 lambda；

• 在非 lambda 过程中，return 表示退出包含方法(如果在方法之外调用，将抛出 LocalJumpError)；

• 在非 lambda 过程中，break 表示退出给定块的方法。 (如果在方法返回后调用，将抛出LocalJumpError)；

• 在 lambdas 中，参数的处理方式与方法相同：严格，ArgumentError 用于参数编号不匹配，并且没有额外的参数处理；

• 常规 proc 更慷慨地接受参数：缺少的参数用 nil 填充，如果 proc 有多个参数，则单个 Array 参数将被解构，并且额外参数不会引发错误。

例子：

# +return+ in non-lambda proc, +b+, exits +m2+.
# (The block +{ return }+ is given for +m1+ and embraced by +m2+.)
$a = []; def m1(&b) b.call; $a << :m1 end; def m2() m1 { return }; $a << :m2 end; m2; p $a
#=> []

# +break+ in non-lambda proc, +b+, exits +m1+.
# (The block +{ break }+ is given for +m1+ and embraced by +m2+.)
$a = []; def m1(&b) b.call; $a << :m1 end; def m2() m1 { break }; $a << :m2 end; m2; p $a
#=> [:m2]

# +next+ in non-lambda proc, +b+, exits the block.
# (The block +{ next }+ is given for +m1+ and embraced by +m2+.)
$a = []; def m1(&b) b.call; $a << :m1 end; def m2() m1 { next }; $a << :m2 end; m2; p $a
#=> [:m1, :m2]

# Using +proc+ method changes the behavior as follows because
# The block is given for +proc+ method and embraced by +m2+.
$a = []; def m1(&b) b.call; $a << :m1 end; def m2() m1(&proc { return }); $a << :m2 end; m2; p $a
#=> []
$a = []; def m1(&b) b.call; $a << :m1 end; def m2() m1(&proc { break }); $a << :m2 end; m2; p $a
# break from proc-closure (LocalJumpError)
$a = []; def m1(&b) b.call; $a << :m1 end; def m2() m1(&proc { next }); $a << :m2 end; m2; p $a
#=> [:m1, :m2]

# +return+, +break+ and +next+ in the stubby lambda exits the block.
# (+lambda+ method behaves same.)
# (The block is given for stubby lambda syntax and embraced by +m2+.)
$a = []; def m1(&b) b.call; $a << :m1 end; def m2() m1(&-> { return }); $a << :m2 end; m2; p $a
#=> [:m1, :m2]
$a = []; def m1(&b) b.call; $a << :m1 end; def m2() m1(&-> { break }); $a << :m2 end; m2; p $a
#=> [:m1, :m2]
$a = []; def m1(&b) b.call; $a << :m1 end; def m2() m1(&-> { next }); $a << :m2 end; m2; p $a
#=> [:m1, :m2]

p = proc {|x, y| "x=#{x}, y=#{y}" }
p.call(1, 2)      #=> "x=1, y=2"
p.call([1, 2])    #=> "x=1, y=2", array deconstructed
p.call(1, 2, 8)   #=> "x=1, y=2", extra argument discarded
p.call(1)         #=> "x=1, y=", nil substituted instead of error

l = lambda {|x, y| "x=#{x}, y=#{y}" }
l.call(1, 2)      #=> "x=1, y=2"
l.call([1, 2])    # ArgumentError: wrong number of arguments (given 1, expected 2)
l.call(1, 2, 8)   # ArgumentError: wrong number of arguments (given 3, expected 2)
l.call(1)         # ArgumentError: wrong number of arguments (given 1, expected 2)

def test_return
  -> { return 3 }.call      # just returns from lambda into method body
  proc { return 4 }.call    # returns from method
  return 5
end

test_return # => 4, return from proc

Lambda 可用作 self-sufficient 函数，尤其可用作高阶函数的参数，其行为与 Ruby 方法完全相同。

Procs 对于实现迭代器很有用：

def test
  [[1, 2], [3, 4], [5, 6]].map {|a, b| return a if a + b > 10 }
                            #  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
end

在 map 内部，代码块被视为常规(非 lambda)proc，这意味着内部数组将被解构为成对的参数，并且 return 将从方法 test 退出。使用更严格的 lambda 是不可能的。

您可以使用 lambda? 实例方法从常规过程中区分 lambda。

Lambda 语义通常在 proc 生命周期内保留，包括 & -deconstruction 到代码块：

p = proc {|x, y| x }
l = lambda {|x, y| x }
[[1, 2], [3, 4]].map(&p) #=> [1, 3]
[[1, 2], [3, 4]].map(&l) # ArgumentError: wrong number of arguments (given 1, expected 2)

唯一的例外是动态方法定义：即使通过传递非 lambda 过程定义，方法仍然具有参数检查的正常语义。

class C
  define_method(:e, &proc {})
end
C.new.e(1,2)       #=> ArgumentError
C.new.method(:e).to_proc.lambda?   #=> true

此异常确保方法永远不会有异常的参数传递约定，并且可以轻松地让包装器定义行为正常的方法。

class C
  def self.def2(name, &body)
    define_method(name, &body)
  end

  def2(:f) {}
end
C.new.f(1,2)       #=> ArgumentError

包装器def2 接收 body 作为非 lambda 过程，但定义了具有正常语义的方法。

将其他对象转换为 proc

任何实现to_proc 方法的对象都可以通过& 运算符转换为proc，因此可以被迭代器使用。

class Greeter
  def initialize(greeting)
    @greeting = greeting
  end

  def to_proc
    proc {|name| "#{@greeting}, #{name}!" }
  end
end

hi = Greeter.new("Hi")
hey = Greeter.new("Hey")
["Bob", "Jane"].map(&hi)    #=> ["Hi, Bob!", "Hi, Jane!"]
["Bob", "Jane"].map(&hey)   #=> ["Hey, Bob!", "Hey, Jane!"]

在 Ruby 核心类中，此方法由 Symbol 、 Method 和 Hash 实现。

:to_s.to_proc.call(1)           #=> "1"
[1, 2].map(&:to_s)              #=> ["1", "2"]

method(:puts).to_proc.call(1)   # prints 1
[1, 2].each(&method(:puts))     # prints 1, 2

{test: 1}.to_proc.call(:test)       #=> 1
%i[test many keys].map(&{test: 1})  #=> [1, nil, nil]

孤立的 Proc

块中的return 和break 退出方法。如果从块中生成 Proc 对象并且 Proc 对象在方法返回之前仍然存在，则return 和break 无法工作。在这种情况下，return 和 break 引发 LocalJumpError 。在这种情况下， Proc 对象称为孤立的 Proc 对象。

请注意，return 和 break 的退出方法不同。有一种情况是孤立的 break 但不是孤立的 return 。

def m1(&b) b.call end; def m2(); m1 { return } end; m2 # ok
def m1(&b) b.call end; def m2(); m1 { break } end; m2 # ok

def m1(&b) b end; def m2(); m1 { return }.call end; m2 # ok
def m1(&b) b end; def m2(); m1 { break }.call end; m2 # LocalJumpError

def m1(&b) b end; def m2(); m1 { return } end; m2.call # LocalJumpError
def m1(&b) b end; def m2(); m1 { break } end; m2.call # LocalJumpError

由于 return 和 break 在 lambdas 中退出块本身，因此 lambdas 不能被孤立。

编号参数

编号参数是隐式定义的块参数，旨在简化编写短块：

# Explicit parameter:
%w[test me please].each { |str| puts str.upcase } # prints TEST, ME, PLEASE
(1..5).map { |i| i**2 } # => [1, 4, 9, 16, 25]

# Implicit parameter:
%w[test me please].each { puts _1.upcase } # prints TEST, ME, PLEASE
(1..5).map { _1**2 } # => [1, 4, 9, 16, 25]

支持从 _1 到 _9 的参数名称：

[10, 20, 30].zip([40, 50, 60], [70, 80, 90]).map { _1 + _2 + _3 }
# => [120, 150, 180]

不过，建议明智地使用它们，可能会将自己限制在 _1 和 _2 以及 one-line 块中。

编号参数不能与显式命名的参数一起使用：

[10, 20, 30].map { |x| _1**2 }
# SyntaxError (ordinary parameter is defined)

为避免冲突，命名局部变量或方法参数 _1 、 _2 等会导致警告。

_1 = 'test'
# warning: `_1' is reserved as numbered parameter

使用隐式编号参数会影响块的数量：

p = proc { _1 + _2 }
l = lambda { _1 + _2 }
p.parameters     # => [[:opt, :_1], [:opt, :_2]]
p.arity          # => 2
l.parameters     # => [[:req, :_1], [:req, :_2]]
l.arity          # => 2

带编号参数的块不能嵌套：

%w[test me].each { _1.each_char { p _1 } }
# SyntaxError (numbered parameter is already used in outer block here)
# %w[test me].each { _1.each_char { p _1 } }
#                    ^~

编号参数是在 Ruby 2.7 中引入的。