Wie "reduziert" Array von Hashes mit doppelten Schlüsseln zu verschachtelten Hash?

Question

Hinweis: Es gab ein paar ähnlichen Fragen auf SO darüber, wie here und here, aber keiner scheint ganz wie das, was ich suche.

sagen, dass ich ein Array von Hashes wie dieses:

arr_with_dup_hsh_keys = [ 
    { foo: "dup", bar: 1 }, 
    { foo: "dup", bar: 2 }, 
    { foo: "dup", bar: 3 }, 
    { foo: "dup", bar: 4 }, 
    { foo: "dup", bar: 5 } 
] 

Wie reduziere ich das diese nach unten?

{ foo: "dup", bars: [1, 2, 3, 4, 5] } 

Und was, wenn es für foo unterschiedliche Werte sind?

arr_with_dup_hsh_keys = [ 
    { foo: "dup", bar: 1 }, 
    { foo: "dup", bar: 2 }, 
    { foo: "soup", bar: 3 }, 
    { foo: "dup", bar: 4 }, 
    { foo: "soup", bar: 5 } 
] 

Answer 1

def combine(arr) 
    arr.group_by {|g|g[:foo]}.values.map {|a|{foo: a.first[:foo], bar: a.map {|g| g[:bar]}}} 
end 

combine arr_with_dup_hsh_keys 
    #=> [{:foo=>"dup", :bar=>[1, 2, 3, 4, 5]}] 

arr_with_dup_hsh_keys1 = [ 
    { foo: "dup", bar: 1 }, 
    { foo: "dup", bar: 2 }, 
    { foo: "soup", bar: 3 }, 
    { foo: "dup", bar: 4 }, 
    { foo: "soup", bar: 5 } 
] 

combine arr_with_dup_hsh_keys1 
    #=> [{:foo=>"dup", :bar=>[1, 2, 4]}, {:foo=>"soup", :bar=>[3, 5]}] 

Enumerable#group_by See und beachten Sie, dass

arr_with_dup_hsh_keys1.group_by { |g| g[:foo] } 
#=> {"dup"=> [{:foo=>"dup", :bar=>1}, {:foo=>"dup", :bar=>2}, 
#    {:foo=>"dup", :bar=>4}], 
# "soup"=>[{:foo=>"soup", :bar=>3}, {:foo=>"soup", :bar=>5}]} 

Sie könnten alternativ schreibe folgendes.

def combine(arr) 
    arr.each_with_object({}) do |g,h| 
    f = g.merge(bar: [g[:bar]]) 
    h.update(f[:foo]=>f) { |_,o,n| { foo: o[:foo], bar: o[:bar]+n[:bar] } } 
    end.values 
end 

combine arr_with_dup_hsh_keys1 
    #=> [{:foo=>"dup", :bar=>[1, 2, 4]}, {:foo=>"soup", :bar=>[3, 5]}] 

Dies nutzt die Form Hash#update (aka merge!), die einen Block die Werte des Schlüssels zu bestimmen, verwendet, die in beiden fusionierten Hashes vorhanden sind. Eine Erläuterung der drei Blockvariablen finden Sie im Dokument (der erste ist der allgemeine Schlüssel, den ich mit einem Unterstrich dargestellt habe, um anzuzeigen, dass er nicht in der Blockberechnung verwendet wird).

Answer 2

Wenn Ihre Daten in Ihrer Frage wirklich so einfach ist, wird dies tun, was Sie wollen:

{ foo: "dup", 
    bars: arr_with_dup_hsh_keys.map {|hsh| hsh[:bar] } 
} 

Answer 3

Das ist, was ich kam:

a = [ 
    { foo: "dup", bar: 1 }, 
    { foo: "dup", bar: 2 }, 
    { foo: "dup", bar: 3 }, 
    { foo: "dup", bar: 4 }, 
    { foo: "dup", bar: 5 } 
] 

h = {} 
a.map(&:keys).uniq.flatten.each_with_index do |key, idx| 
    h[key] = a.map(&:values).collect { |a| a[idx]}.uniq 
end 
h 
#=> {:foo=>["dup"], :bar=>[1, 2, 3, 4, 5]}