遍历哈希数组并合并[关闭]

Question

我有一个这样的哈希数组：

[{:a=>"a", :b=>"b", :c=>"c", :d=>"d"}, 
 {:a=>"a", :b=>nil, :c=>"notc", :d=>"d"}]

我想遍历哈希并将它们合并到特定键相同的位置，例如：a。如果下一个键元素相同 - 忽略它，但如果键不同，则创建一个数组。结果将如下所示：

{:a=>"a", :b=>"b", :c=>["c","notc"], :d=>"d"}

我想我已经对哈希数组做了一个 for 循环，然后使用 merge! 方法，但不知道从哪里开始

Answer 1

我也会像这样使用Hash#merge!（又名update）（让a 表示您的哈希数组的名称）：

a.each_with_object({}) do |g,h|
  h.update(g) do |_,o,n|
    case o
    when Array
      o.include?(n) ? o : o + [n]
    else
      o.eql?(n) ? o : [o,n] 
    end
  end
end
  #=> {:a=>"a", :b=>["b", nil], :c=>["c", "notc"], :d=>"d"} 

当o是一个数组时，如果不想合并nil的值，将以下行改为：

(o.include?(n) || n.nil?) ? o : o + [n]

步骤：

a = [{:a=>"a",  :b=>"b", :c=>"c",    :d=>"d"}, 
     {:a=>"a",  :b=>nil, :c=>"notc", :d=>"d"},
     {:a=>"aa", :b=>"b", :c=>"cc",   :d=>"d"},
]

enum = a.each_with_object({})
  #-> #<Enumerator: [{:a=>"a",  :b=>"b", :c=>"c",    :d=>"d"},
  #                  {:a=>"a",  :b=>nil, :c=>"notc", :d=>"d"},
  #                  {:a=>"aa", :b=>"b", :c=>"cc",   :d=>"d"}]
  #    :each_with_object({})> 

我们可以通过将枚举器转换为数组来查看枚举器的值（将被传递到块中）：

enum.to_a
  #=> [[{:a=>"a",  :b=>"b", :c=>"c",    :d=>"d"}, {}],
  #    [{:a=>"a",  :b=>nil, :c=>"notc", :d=>"d"}, {}],
  #    [{:a=>"aa", :b=>"b", :c=>"cc",   :d=>"d"}, {}]] 

传入第一个值并将其分配给块变量：

g,h = enum.next
  #=> [{:a=>"a", :b=>"b", :c=>"c", :d=>"d"}, {}] 
g #=> {:a=>"a", :b=>"b", :c=>"c", :d=>"d"} 
h #=> {} 

update 的块用于确定在被合并的两个散列中存在的键的值。由于h 目前为空（{}），因此它不用于此合并：

h.update(g)
  #=> {:a=>"a", :b=>"b", :c=>"c", :d=>"d"} 

h 的新值被返回。

现在将enum 的第二个值传递到块中：

g,h = enum.next
  #=> [{:a=>"a", :b=>nil, :c=>"notc", :d=>"d"},
  #    {:a=>"a", :b=>"b", :c=>"c",    :d=>"d"}] 
g #=>  {:a=>"a", :b=>nil, :c=>"notc", :d=>"d"} 
h #=>  {:a=>"a", :b=>"b", :c=>"c",    :d=>"d"} 

并执行：

h.update(g)

当要合并来自g 的:a=>"a" 时，update 会看到h 包含相同的键:a。因此，它根据块来确定合并散列中:a 的值。它将以下值传递给块：

k = :a
o = "a"
n = "a"

其中k 是键，o（用于“旧”）是h 中k 的值，n（用于“新”）是@ 中k 的值987654352@。 （我们没有在块中使用k，所以我将块变量命名为_ 来表示。）在case 语句中，o 不是一个数组，所以：

o.eql?(n) ? o : [o,n]
  #=> "a".eql?("a") ? "a" : ["a","a"] 
  #=> "a"

返回到 update 以作为 :a 的值。即值不变。

当密钥为:b时：

k = :b
o = "b"
n = nil

同样，o 不是数组，所以我们再次执行：

o.eql?(n) ? o : [o,n] 
  #=> ["b", nil] 

但这次返回的是一个数组。合并enum 的第二个元素的其余计算类似地进行。合并后：

h #=> {:a=>"a", :b=>["b", nil], :c=>["c", "notc"], :d=>"d"} 

当enum的第三个元素中的:c=>"cc"被合并时，以下值被传递给update的块：

_ :c
o = ["c", "notc"]
n = "cc"

由于o是一个数组，我们执行case语句的下面一行：

o.include?(n) ? o : o + [n]
  #=> ["c", "notc", "cc"]

并且:c 的值被分配了该值。其余的计算类似地执行。

Answer 2

我会这样做：

array = [{ :a=>"a", :b=>"b", :c=>"c",    :d=>"d" }, 
         { :a=>"a", :b=>nil, :c=>"notc", :d=>"d" }]

result = array.reduce({}) do |memo, hash|
  memo.merge(hash) do |_, left, right|
    combined = Array(left).push(right).uniq.compact
    combined.size > 1 ? combined : combined.first
  end
end

puts result
#=> { :a=>"a", :b=>"b", :c=>["c", "notc"], :d=>"d" }

Array(left) 将确保一个哈希值是一个数组。 push(right) 将来自另一个哈希的值添加到该数组中。 uniq.compact 删除 nil 值和重复项。

如果数组只包含一个元素，combined.size > 1 ? combined : combined.first 行只返回元素。

Answer 3

假设hs = [{:a=>"a", :b=>"b", :c=>"c", :d=>"d"}, {:a=>"a", :b=>nil, :c=>"notc", :d=>"d"}]，您可以使用（诚然，非常密集的）单线做到这一点：

Hash[hs.map { |h| h.map { |k,v| [k, v] } }.sort_by(&:first).reduce { |left,right| left.zip(right) }.map { |a| [a.first.first, a.map(&:last).compact.uniq] }]

解开这里发生的事情：

首先我们使用map 将哈希数组转换为对数组的数组，然后使用sort_by 对数组进行排序，使所有键都“对齐”。

[{:a=>"a", :b=>"b", :c=>"c", :d=>"d"}, {:a=>"a", :b=>nil, :c=>"notc", :d=>"d"}]变成

[[[:a, "a"], [:b, "b"], [:c, "c"], [:d, "d"]], [[:a, "a"], [:b, nil], [:c, "notc"], [:d, "d"]]]

就是这个部分：

 hs.map { |h| h.map { |k,v| [k, v] } }.sort_by(&:first).

然后，我们使用reduce 并将所有数组压缩在一起，zip 只需要两个数组[1,2,3]、[:a,:b,:c] 并输出一个数组，如：[[1,:a],[2,:b],[3,:c]]

    reduce { |left,right| left.zip(right) }.

此时我们已经将所有数据按key分组在一起，需要对key的所有副本进行去重，我们可以去掉nils并将值uniq：

    map { |a| [a.first.first, a.map(&:last).compact.uniq] }]

这是一个撬动会话的示例：

[31] pry(main)> Hash[hs.map { |h| h.map { |k,v| [k, v] } }.sort_by(&:first).reduce { |left,right| left.zip(right) }.map { |a| [a.first.first, a.map(&:last).compact.uniq] }]
=> {:a=>["a"], :b=>["b"], :c=>["c", "notc"], :d=>["d"]}