内置 的 inject 是 非常 多态 的 ， 所以 在 尝试 从头 开始 实现 它 之前 （ 不 看 源 代码 ） ， 我们 需要 研究 它 在 不同 情况 下 的 行为 。 我 跳过 了 你 已经 知道 的 事情 （ 比如 如果 没有 显 式 提供 ， 使用 第 一 个 元素 作为 初始 值 等 ） ， 除 此 之外 ：

[1,2,3].inject(0, :+, :foo) #=> ArgumentError: wrong number of arguments (given 3, expected 0..2)
# Max. arity is strict

[1,2,3].inject(0, :+) { 1 } #=> 6
# If both symbol _and_ block are provided, the former dominates

[1,2,3].inject(:+) { |acc, x| acc } #=> :+
# With only 1 parameter and a block the former will be treated as an init value, not a proc.

[1,2,3].inject("+") #=> 6
[1,2,3].inject("+") { |acc, x| acc } #=> "+"
# Strings work too. This is important, because strings _don't respond to `to_proc`_, so we would need smth. else

[1,2,3].inject #=> LocalJumpError: no block given
# Ok, local jump error means that we try to yield in the cases where the 2nd parameter is not provided

[1,2,3].inject(nil) #=> TypeError: nil is not a symbol nor a string
# But if it is provided, we try to do with it something that quacks pretty much like `send`...

中 的 每 一 个
记住 这些 信息 后 ， 我们 可以 编写 如下 代码 ：

module Enum
  # Just for convenience, you don't need it if you implement your own `each`
  include Enumerable

  def my_inject(acc = nil, sym = nil)
    # With a single attribute and no block we assume that the init value is in fact nil
    # and what is provided should be "called" on elements somehow
    if acc && !sym && !block_given?
      sym, acc = acc, nil
    end
  
    each do |element|
      if !acc
        # If we are not initialized yet, we just assign an element to our accumulator
        # and proceed
        acc = element
      elsif sym
        # If the "symbol" was provided explicitly (or resolved as such in a single parameter case)
        # we try to call the appropriate method on the accumulator. 
        acc = acc.send(sym, element)
      else
        # Otherwise just try to yield
        acc = yield acc, element
      end
    end
    
    acc
  end
end

格式
忍耐 一下 ， 我们 就 快 到 了 ： ） 让 我们 来 看看 它 是 如何 嘎嘎 叫 的 ：

class Ary < Array
  include Enum
end

ary = Ary.new.push(1,2,3)

ary.my_inject #=> LocalJumpError: no block given
ary.my_inject(0) #=> TypeError: 0 is not a symbol nor a string
ary.my_inject("+") #=> 6
ary.my_inject(:+) #=> 6
ary.my_inject(0, :+) #=> 6
ary.my_inject(1, :+) #=> 7
ary.my_inject(1, :+) { 1 } #=> 7
ary.my_inject(:+) { |acc, x| acc } #=> :+

格式
所以 ， 几乎 是 一样 的 。 可能 还有 一些 其他 的 边缘 情况 ， 我 的 实现 不能 满足 ， 但 我 把 它们 留给 你 ： ）