来自数组的Ruby深层嵌套哈希

我需要转换此阵列：

[:a, :b, :c, :d, :e]

放入此哈希：

{:a=>{:b=>{:c=>{:d=>:e}}}}

不幸的是，我错过了大脑的递归叶。我发现

#http://firedev.com/posts/2015/bottomless-ruby-hash/
类BottomlessHashh，k{h[k]=self.class.new}
结束
结束

当我在努力理解“”时，如果你把它明确地写出来

bhash = BottomlessHash.new
bhash[:a][:b][:c][:d] = :e 
bhash # => {:a=>{:b=>{:c=>{:d=>:e}}}} 

但是，我无法找到一种以编程方式传递任意值的方法

store

不起作用，

send（“[：a][：b][：c][：d]=”，：e）

项=[：a，：b，：c，：d，：e]
#迭代版本
def哈希化（项目）
items=items.dup
结果=items.pop
result={items.pop=>result}直到items.empty？
结果
结束
hashify（items）#=>{:a=>{:b=>{:c=>{:d=>:e}}
#递归版本
def哈希化（项目）
如果items.size<2，则返回items.last
*头，倒数第二，最后=项目
hashify（head+[{倒数第二=>last}]）
结束
hashify（items）#=>{:a=>{:b=>{:c=>{:d=>:e}}

项目=[：a，：b，：c，：d，：e]
#迭代版本
def哈希化（项目）
items=items.dup
结果=items.pop
result={items.pop=>result}直到items.empty？
结果
结束
hashify（items）#=>{:a=>{:b=>{:c=>{:d=>:e}}
#递归版本
def哈希化（项目）
如果items.size<2，则返回items.last
*头，倒数第二，最后=项目
hashify（head+[{倒数第二=>last}]）
结束
hashify（items）#=>{:a=>{:b=>{:c=>{:d=>:e}}
send
所做的是调用一个方法，只调用一个方法，该方法具有零个或多个参数。它不能同时调用多个方法。您的示例如下：

send("[:a][:b][:c][:d]=", :e)

这是试图调用一个名为
[：a][：b][：b][：d]=
的方法，该方法不存在，因此
发送失败

下面是实际的Ruby代码：

x[:a][:b][:c][:d] = :e

由Ruby解释为：

x.send(:[], :a).send(:[], :b).send(:[], :c).send(:[]=, :d, :e)

这是一种很长很难看的方式来完成原始代码所做的事情。这里的关键是，每个
[…]
部分表示一个方法调用，该方法调用返回某个内容，然后根据该内容对下一部分求值，或将其链接

现在来看原始部分，这个椒盐卷饼刺：

super &-> h, k { h[k] = self.class.new }

&
表示“作为块参数传递此过程”，如中所述，对于具有签名的方法：

initialize(&block)

其中，
&block
表示该方法的块（如果给定），如：

Hash.new { |h,k| h[k] = { } }

在更基本的实现中

->h，k{…}
部分传统上写为：

lambda { |h, k| ... }

这可能更容易识别。
发送
所做的是调用一个方法，只调用一个，具有零个或多个参数的方法。它不能同时调用多个方法。您的示例如下：

send("[:a][:b][:c][:d]=", :e)

[:a, :b, :c, :d, :e].reverse_each.inject{|h, k| {k => h}}
# => {:a=>{:b=>{:c=>{:d=>:e}}}}

这是试图调用一个名为
[：a][：b][：b][：d]=
的方法，该方法不存在，因此
发送失败

下面是实际的Ruby代码：

x[:a][:b][:c][:d] = :e

由Ruby解释为：

x.send(:[], :a).send(:[], :b).send(:[], :c).send(:[]=, :d, :e)

这是一种很长很难看的方式来完成原始代码所做的事情。这里的关键是，每个
[…]
部分表示一个方法调用，该方法调用返回某个内容，然后根据该内容对下一部分求值，或将其链接

现在来看原始部分，这个椒盐卷饼刺：

super &-> h, k { h[k] = self.class.new }

&
表示“作为块参数传递此过程”，如中所述，对于具有签名的方法：

initialize(&block)

其中，
&block
表示该方法的块（如果给定），如：

Hash.new { |h,k| h[k] = { } }

在更基本的实现中

->h，k{…}
部分传统上写为：

lambda { |h, k| ... }

如果数组有0或1个元素，结果应该是什么？如果数组有0或1个元素，结果应该是什么？
[:a, :b, :c, :d, :e].reverse_each.inject{|h, k| {k => h}}
# => {:a=>{:b=>{:c=>{:d=>:e}}}}