Ruby注入，初始值为散列

有谁能告诉我为什么会发生以下情况：

['a', 'b'].inject({}) {|m,e| m[e] = e }

抛出错误：

IndexError: string not matched
        from (irb):11:in `[]='
        from (irb):11:in `block in irb_binding'
        from (irb):11:in `each'
        from (irb):11:in `inject'
        from (irb):11
        from C:/Ruby192/bin/irb:12:in `<main>'

---

块需要返回累积哈希：

['a', 'b'].inject({}) {|m,e| m[e] = e; m }

---

相反，它在第一次传递后返回字符串“a”，在下一次传递中变为

m

，最后调用字符串的

[]=

方法。

块必须返回累加器（散列），如@Rob所说。一些备选方案：

使用

Hash#update

：

hash = ['a', 'b'].inject({}) { |m, e| m.update(e => e) }

带有

可枚举的#每个_带有_对象

：

hash = ['a', 'b'].each_with_object({}) { |e, m| m[e] = e }

使用

散列#[]

：

hash = Hash[['a', 'b'].map { |e| [e, e] }]

使用

Array#to_h

（Ruby>=2.1）：

从各个方面：

require 'facets'
hash = ['a', 'b'].mash { |e| [e, e] }

---

与其使用inject，还不如深入研究

其中，

inject

要求您返回要累积到的对象，

每个带有对象的\u

自动执行

从文档中：

使用给定的任意对象迭代每个元素的给定块，并返回最初给定的对象

如果未给定块，则返回枚举数

e、 g:

---

请注意，

inject

和

each_with_object

颠倒生成参数的顺序

不错的选择。我特别喜欢原始海报的技术和映射到对然后创建新的哈希方法之间的区别：原始问题本质上是迭代的——对于每个项目，在哈希上执行此操作——因此inject看起来过于复杂（因此出现错误）。但是映射方法更多的是关于整体的：将这个单数数组变成一个对数组，然后将这个对数组变成一个散列。是否绝对有必要在末尾包含m？例如，如果块是

{| array，（k，v）| array@Ziggy:yes，这是必要的，因为赋值
散列[key]=value
returns
value
，你需要
hash
@tokland:你救了我一天！没有返回结果，我得到了错误的结果。你也可以遵循rubocp
Style/EachWithObject
约定，使用
每个带有对象的u
：
['a'，b']。每个带有对象的u（{e，m[e]=e}
hash = ['a', 'b'].map { |e| [e, e] }.to_h

require 'facets'
hash = ['a', 'b'].mash { |e| [e, e] }

evens = (1..10).each_with_object([]) {|i, a| a << i*2 }
#=> [2, 4, 6, 8, 10, 12, 14, 16, 18, 20]

[1] pry(main)> %w[a b].each_with_object({}) { |e,m| m[e] = e }
=> {"a"=>"a", "b"=>"b"}