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 的別名。