扩展Ruby类（散）的新功能（recursive_merge）

Question

如果我要递归合并2个哈希，我可以用下面的函数这样做：

def recursive_merge(a,b) 
    a.merge(b) {|key,a_item,b_item| recursive_merge(a_item,b_item) } 
end 

这个伟大的工程，因为我现在可以做：

aHash = recursive_merge(aHash,newHash) 

但我想补充一点，这是一种类似于merge!类似的自我更新风格的方法。我可以添加在返回函数：

class Hash 
    def recursive_merge(newHash) 
    self.merge { |key,a_item,b_item| a_item.recursive_merge(b_item) } 
    end 
end 

，但我不知道如何重新创建bang功能，如果没有关联更新原始对象。

class Hash 
    def recursive_merge!(newHash) 
    self.merge { |key,a_item,b_item| a_item.recursive_merge(b_item) } 
    # How do I set "self" to this new hash? 
    end 
end 

编辑例如按照意见。

h={:a=>{:b => "1"} 
h.recursive_merge!({:a=>{:c=>"2"}) 
=> {:a=>{:b=>"1", :c="2"}} 

在:b=>"1"定期合并结果通过:c="2"

Answer 1

使用merge!而不是试图更新self被覆盖。我不相信使用合并是有意义的！任何地方，但在顶层，所以我不会以递归方式调用爆炸版本。相反，使用合并！在顶层，递归地调用non-bang方法。

检查两个正在合并的值确实是散列也是明智的，否则如果您尝试对非散列对象执行recursive_merge，则可能会收到异常。

#!/usr/bin/env ruby 

class Hash 
    def recursive_merge(other) 
    self.merge(other) { |key, value1, value2| value1.is_a?(Hash) && value2.is_a?(Hash) ? value1.recursive_merge(value2) : value2} 
    end 

    def recursive_merge!(other) 
    self.merge!(other) { |key, value1, value2| value1.is_a?(Hash) && value2.is_a?(Hash) ? value1.recursive_merge(value2) : value2} 
    end 
end 


h1 = { a: { b:1, c:2 }, d:1 } 
h2 = { a: { b:2, d:4 }, d:2 } 
h3 = { d: { b:1, c:2 } } 


p h1.recursive_merge(h2) # => {:a=>{:b=>2, :c=>2, :d=>4}, :d=>2} 
p h1.recursive_merge(h3) # => {:a=>{:b=>1, :c=>2}, :d=>{:b=>1, :c=>2}} 

p h1.recursive_merge!(h2) # => {:a=>{:b=>2, :c=>2, :d=>4}, :d=>2} 
p h1 # => {:a=>{:b=>2, :c=>2, :d=>4}, :d=>2} 

如果你有特殊原因，在地方完全合并，可能是速度，你可以用做第二功能调用自身递归，而不是委托递归的第一个函数试验。请注意，如果哈希存储共享对象，可能会产生意想不到的副作用。

实施例：

h1 = { a:1, b:2 } 
h2 = { a:5, c:9 } 
h3 = { a:h1, b:h2 } 
h4 = { a:h2, c:h1 } 

p h3.recursive_merge!(h4) 
# Making recursive calls to recursive_merge 
# => {:a=>{:a=>5, :b=>2, :c=>9}, :b=>{:a=>5, :c=>9}, :c=>{:a=>1, :b=>2}} 
# Making recursive calls to recursive_merge! 
# => {:a=>{:a=>5, :b=>2, :c=>9}, :b=>{:a=>5, :c=>9}, :c=>{:a=>5, :b=>2, :c=>9}} 

正如你可以看到，第二个（共享）H1的下键存储的副本：C被更新以反映h1和h2的下键合并：一个。这可能是令人惊讶和不想要的。因此，为什么我建议使用recursive_merge进行递归，而不是recursive_merge!。