Ruby注入递归？

目标是从

['a'，'b'，'c']

开始，最后以

{'a'=>{'b'=>{'c'=>{}}}

所以，为了确定方向，我做了以下工作：

['a','b','c'].inject({}){|h,v| h.update(v => {})}
# => {"a"=>{}, "b"=>{}, "c"=>{}} 

然后我想，如果我真的传递了结果散列，它将递归并嵌套，但是：

['a','b','c'].inject({}){|h,v| h.update(v => {}); h[v]}
# => {} 

为什么会这样？你知道如何在优雅的单衬里中达到预期效果吗

['a','b','c'].reverse.inject({}) {|r,v| {v=>r}}

换句话说：

构造一个散列，其中键是第一个数组元素（“反转后的c”），种子（空散列）是值。在每一步构造一个新的散列，其中键是数组中的下一个值，该值是上一步返回的散列

以下是inject每次迭代后的结果：

r={}，v='c'

返回

{'c'=>{}

r={'c'=>{}，v='b'

返回

{'b'=>{'c'=>{}}

---

r={'b'=>{'c'=>{}}，v='a'

返回

{'a'=>{'b'=>{'c'=>{}}}}

Zettetic已经给了你一个有效的解决方案，但你的解决方案不起作用的原因如下：

['a','b','c'].inject({}){|h,v| h.update(v => {}); h[v]}

这确实会创建散列

{'a'=>{'b'=>{'c'=>{}}}

，但是，

inject

不会返回该散列，它返回最后一次调用块的结果，这就是

{}

，因为

h

将是为最后一个元素创建的散列，即

{c'=>{}

，因此

h[v]

将是

{}

要查看您想要的散列确实已创建，只是没有返回，您可以先将传入的散列存储在变量中，如下所示：

hash = {}
['a','b','c'].inject(hash){|h,v| h.update(v => {}); h[v]}

---

这样，

inject

仍将返回

{}

，但

hash

现在将包含hash

{'a'=>{'b'=>{'c'=>{}}

。也就是说，泽蒂提的解决方案更好，因为它更清楚发生了什么。在inject中对累加器进行变异通常会让人困惑，而且会带来更多麻烦。

通过引用传递还是通过值传递？