Ruby Enumerable.reduce用法及代码示例

reduce(p1 = v1, p2 = v2)

通过以下任一方式返回由操作数形成的对象：

• 由 symbol 命名的方法。

• 每个操作数都传递到的块。

使用 method-name 参数 symbol ，使用以下方法组合操作数：

# Sum, without initial_operand.
(1..4).inject(:+)     # => 10
# Sum, with initial_operand.
(1..4).inject(10, :+) # => 20

使用块，将每个操作数传递给块：

# Sum of squares, without initial_operand.
(1..4).inject {|sum, n| sum + n*n }    # => 30
# Sum of squares, with initial_operand.
(1..4).inject(2) {|sum, n| sum + n*n } # => 32

操作数

如果没有给出参数 initial_operand，则 inject 的操作数只是 self 的元素。示例调用及其操作数：

• (1..4).inject(:+)

  [1, 2, 3, 4] 。

• (1...4).inject(:+)

  [1, 2, 3] 。

• ('a'..'d').inject(:+)

  ['a', 'b', 'c', 'd'] 。

• ('a'...'d').inject(:+)

  ['a', 'b', 'c'] 。

具有各种类型的第一个操作数(即 self.first )的示例：

# Integer.
(1..4).inject(:+)                # => 10
# Float.
[1.0, 2, 3, 4].inject(:+)        # => 10.0
# Character.
('a'..'d').inject(:+)            # => "abcd"
# Complex.
[Complex(1, 2), 3, 4].inject(:+) # => (8+2i)

如果给定参数 initial_operand，则 inject 的操作数是该值加上 self 的元素。示例调用它们的操作数：

• (1..4).inject(10, :+)

  [10, 1, 2, 3, 4] 。

• (1...4).inject(10, :+)

  [10, 1, 2, 3] 。

• ('a'..'d').inject('e', :+)

  ['e', 'a', 'b', 'c', 'd'] 。

• ('a'...'d').inject('e', :+)

  ['e', 'a', 'b', 'c'] 。

各种类型的initial_operand 示例：

# Integer.
(1..4).inject(2, :+)               # => 12
# Float.
(1..4).inject(2.0, :+)             # => 12.0
# String.
('a'..'d').inject('foo', :+)       # => "fooabcd"
# Array.
%w[a b c].inject(['x'], :push)     # => ["x", "a", "b", "c"]
# Complex.
(1..4).inject(Complex(2, 2), :+)   # => (12+2i)

通过给定方法组合

如果给出 method-name 参数 symbol，则操作数通过该方法组合：

• 组合第一和第二操作数。

• 该结果与第三个操作数相结合。

• 该结果与第四个操作数相结合。

• 等等。

inject 的返回值是最后一个组合的结果。

对 inject 的调用计算操作数的总和：

(1..4).inject(:+) # => 10

各种方法的例子：

# Integer addition.
(1..4).inject(:+)                # => 10
# Integer multiplication.
(1..4).inject(:*)                # => 24
# Character range concatenation.
('a'..'d').inject('', :+)        # => "abcd"
# String array concatenation.
%w[foo bar baz].inject('', :+)   # => "foobarbaz"
# Hash update.
h = [{foo: 0, bar: 1}, {baz: 2}, {bat: 3}].inject(:update)
h # => {:foo=>0, :bar=>1, :baz=>2, :bat=>3}
# Hash conversion to nested arrays.
h = {foo: 0, bar: 1}.inject([], :push)
h # => [[:foo, 0], [:bar, 1]]

给定块组合

如果给定了一个块，则将操作数传递给该块：

• 第一个调用传递第一个和第二个操作数。

• 第二次调用将第一次调用的结果与第三个操作数一起传递。

• 第三次调用将第二次调用的结果与第四个操作数一起传递。

• 等等。

inject 的返回值是最后一个块调用的返回值。

对inject 的调用给出了一个写入备忘录和元素的块，并且还对元素求和：

(1..4).inject do |memo, element|
  p "Memo: #{memo}; element: #{element}"
  memo + element
end # => 10

输出：

"Memo: 1; element: 2"
"Memo: 3; element: 3"
"Memo: 6; element: 4"

Enumerable#reduce 是 Enumerable#inject 的别名。