我想合并一个嵌套的哈希表。
a = {:book=>
[{:title=>"Hamlet",
:author=>"William Shakespeare"
}]}
b = {:book=>
[{:title=>"Pride and Prejudice",
:author=>"Jane Austen"
}]}
我希望合并后的结果是：
{:book=>
[{:title=>"Hamlet",
:author=>"William Shakespeare"},
{:title=>"Pride and Prejudice",
:author=>"Jane Austen"}]}
如何最好地完成这个目标？
对于Rails 3.0.0+或更高版本，ActiveSupport提供了deep_merge函数，该函数能够实现您所要求的功能。
deep_merge方法，但它只从4.0.2版本开始接受块。 - mirelon我找到了一个更通用的深度合并算法在这里，并且像这样使用它：
class ::Hash
def deep_merge(second)
merger = proc { |key, v1, v2| Hash === v1 && Hash === v2 ? v1.merge(v2, &merger) : v2 }
self.merge(second, &merger)
end
end
a.deep_merge(b)
在Jon M和koendc的回答基础上，以下代码将处理哈希的合并及其nil值，但它也将联合两个哈希中存在的所有数组（具有相同的键）：
class ::Hash
def deep_merge(second)
merger = proc { |_, v1, v2| Hash === v1 && Hash === v2 ? v1.merge(v2, &merger) : Array === v1 && Array === v2 ? v1 | v2 : [:undefined, nil, :nil].include?(v2) ? v1 : v2 }
merge(second.to_h, &merger)
end
end
a.deep_merge(b)
为了多样化，如果你想以相同的方式合并哈希表中的所有键，则可以这样做：
a.merge(b) { |k, x, y| x + y }
Hash#merge方法时，k是要合并的键，其中键存在于a和b中，x是a[k]的值，y是b[k]的值。块的结果成为合并哈希的键k的值。{:color=>"red"} 不在你的示例中。正如我在我的答案中所说，只有当你想以相同的方式合并哈希表中的所有键时，这才有效。 - RussellHash#merge 接受可选块。 - Damien Wilsona.merge(b) { |k, x, y| x + (y ? y : []) } - Dave source = {:x => [1,2,3], :y => 2}
dest = {:x => [4,5,'6'], :y => [7,8,9]}
dest.deep_merge!(source)
Results: {:x => [1,2,3,4,5,'6'], :y => 2}
我觉得所有的回答都太复杂了。这是我最终想到的：
# @param tgt [Hash] target hash that we will be **altering**
# @param src [Hash] read from this source hash
# @return the modified target hash
# @note this one does not merge Arrays
def self.deep_merge!(tgt_hash, src_hash)
tgt_hash.merge!(src_hash) { |key, oldval, newval|
if oldval.kind_of?(Hash) && newval.kind_of?(Hash)
deep_merge!(oldval, newval)
else
newval
end
}
end
注：使用公共的、WTFPL或其他许可证
这里有一个更好的解决方案，用到了细化技术来进行递归合并，并且提供了bang方法和块支持。此代码可以在纯Ruby上运行。
module HashRecursive
refine Hash do
def merge(other_hash, recursive=false, &block)
if recursive
block_actual = Proc.new {|key, oldval, newval|
newval = block.call(key, oldval, newval) if block_given?
[oldval, newval].all? {|v| v.is_a?(Hash)} ? oldval.merge(newval, &block_actual) : newval
}
self.merge(other_hash, &block_actual)
else
super(other_hash, &block)
end
end
def merge!(other_hash, recursive=false, &block)
if recursive
self.replace(self.merge(other_hash, recursive, &block))
else
super(other_hash, &block)
end
end
end
end
using HashRecursive
使用 HashRecursive 后，您可以像未修改过一样使用默认的 Hash::merge 和 Hash::merge!。您可以像以前一样在这些方法中使用块。
新的变化是您可以将布尔值 recursive（第二个参数）传递给这些修改过的方法，它们将递归地合并哈希。
简单用法示例已写在此答案中。下面是一个高级示例。
这个问题中的示例很糟糕，因为它与递归合并无关。以下行将符合问题的示例：
a.merge!(b) {|k,v1,v2| [v1, v2].all? {|v| v.is_a?(Array)} ? v1+v2 : v2}
让我举个更好的例子来展示上面代码的威力。想象一下有两个房间，每个房间里都有一个书架。每个书架上有3排，每排目前有2本书。代码：
room1 = {
:shelf => {
:row1 => [
{
:title => "Hamlet",
:author => "William Shakespeare"
}
],
:row2 => [
{
:title => "Pride and Prejudice",
:author => "Jane Austen"
}
]
}
}
room2 = {
:shelf => {
:row2 => [
{
:title => "The Great Gatsby",
:author => "F. Scott Fitzgerald"
}
],
:row3 => [
{
:title => "Catastrophe Theory",
:author => "V. I. Arnol'd"
}
]
}
}
我们将把第二个房间书架上的书移动到第一个房间书架上相同的行。首先，我们将在不设置recursive标志的情况下执行此操作，即与使用未修改的Hash::merge!相同：
room1.merge!(room2) {|k,v1,v2| [v1, v2].all? {|v| v.is_a?(Array)} ? v1+v2 : v2}
puts room1
room1 = {
:shelf => {
:row2 => [
{
:title => "The Great Gatsby",
:author => "F. Scott Fitzgerald"
}
],
:row3 => [
{
:title => "Catastrophe Theory",
:author => "V. I. Arnol'd"
}
]
}
}
正如您所看到的，没有设置 recursive 强制我们丢弃了宝贵的书籍。
现在我们将使用设置 recursive 标志为 true 来完成相同的操作。您可以将 recursive=true 或只是 true 作为第二个参数传递：
room1.merge!(room2, true) {|k,v1,v2| [v1, v2].all? {|v| v.is_a?(Array)} ? v1+v2 : v2}
puts room1
room1 = {
:shelf => {
:row1 => [
{
:title => "Hamlet",
:author => "William Shakespeare"
}
],
:row2 => [
{
:title => "Pride and Prejudice",
:author => "Jane Austen"
},
{
:title => "The Great Gatsby",
:author => "F. Scott Fitzgerald"
}
],
:row3 => [
{
:title => "Catastrophe Theory",
:author => "V. I. Arnol'd"
}
]
}
}
上述代码可以重写为：
room1 = room1.merge(room2, recursive=true) do |k, v1, v2|
if v1.is_a?(Array) && v2.is_a?(Array)
v1+v2
else
v2
end
end
puts room1
或者
block = Proc.new {|k,v1,v2| [v1, v2].all? {|v| v.is_a?(Array)} ? v1+v2 : v2}
room1.merge!(room2, recursive=true, &block)
puts room1
就是这样。此外，请查看我对Hash::each(Hash::each_pair)的递归版本在这里。
我认为Jon M的回答是最好的，但当你合并一个值为nil/undefined的哈希表时，它会失败。 这个更新解决了这个问题：
class ::Hash
def deep_merge(second)
merger = proc { |key, v1, v2| Hash === v1 && Hash === v2 ? v1.merge(v2, &merger) : [:undefined, nil, :nil].include?(v2) ? v1 : v2 }
self.merge(second, &merger)
end
end
a.deep_merge(b)
nil值存在问题。请给出一个存在问题的例子。 - akostadinova[:book] = a[:book] + b[:book]
或者
a[:book] << b[:book].first