从红宝石的哈希数组中获得独特的属性

Question

Given an array of hashes, I want to create a method that returns a hash where the keys are the unique values of the hashes in the array.

For example, I'd like to take

[
  {foo: 'bar', baz: 'bang'},
  {foo: 'rab', baz: 'bang'},
  {foo: 'bizz', baz: 'buzz'}
]

and return

{
  foo: ['bar', 'rab', 'bizz'],
  baz: ['bang', 'buzz']
}

I am currently accomplishing this using:

def my_fantastic_method(data)
  response_data = { foo: [], baz: []}
  data.each { |data| 
    data.attributes.each { |key, value| 
      response_data[key.to_sym] << value 
    } 
  }
  response_data.each { |key, value| response_data[key] = response_data[key].uniq }
  response_data
end

Is there a more elegant way of doing this? Thanks!

Answer 1

Your current approach is already pretty good; I don't see much room for improvement. I would write it like this:

def my_fantastic_method(data_list)
  data_list.each_with_object(Hash.new { |h, k| h[k] = Set.new }) do |data, result| 
    data.attributes.each do |key, value|
      result[key.to_sym] << value
    end
  end
end

• By setting a default value on each hash value, I have eliminated the need to explicitly declare foo: [], bar: [] .
• By using each_with_object , I have eliminated the need to declare a local variable and explicitly return it at the end.
• By using Set , there is no need to call uniq on the final result. This requires less code, and is more performant. However, if you really want the final result to be a mapping to Array s rather than Set s, then you would need to call to_a on each value at the end of the method.
• I have used different variable names for data_list and data . Call these whatever you like, but it's typically considered bad practice to shadow outer variables.

Answer 2

Here are a couple of one-liners. (I'm pretty sure @eiko was being facetious, but I'm proving him correct)

This one reads well and is easy to follow (caveat: requires Ruby 2.4+ for transform_values ):

array.flat_map(&:entries).group_by(&:first).transform_values{|v| v.map(&:last).uniq}

Here's another, using the block form of merge to specify an alternate merge method, which in this case is combining the values into a uniq array:

array.reduce{|h, el| h.merge(el){|k, old, new| ([old]+[new]).flatten.uniq}}

Answer 3

You already have a pretty good answer, but I felt golfy and so here is a shorter one:

def the_combiner(a)
  hash = {}
  a.map(&:to_a).flatten(1).each do |k,v|
    hash[k] ||= []
    hash[k].push(v)
  end
  hash
end

Answer 4

Try this:

array.flat_map(&:entries)
  .group_by(&:first)
  .map{|k,v| {k => v.map(&:last)} }

OR

a.inject({}) {|old_h, new_h|
  new_h.each_pair {|k, v|
    old_h.key?(k) ? old_h[k] << v : old_h[k]=[v]};
    old_h}

Answer 5

If, as in the example, all hashes have the same keys, you could do as follows.

arr = [{ foo: 'bar', baz: 'bang' },
       { foo: 'rab', baz: 'bang' },
       { foo: 'bizz', baz: 'buzz' }]

keys = arr.first.keys
keys.zip(arr.map { |h| h.values_at(*keys) }.transpose.map(&:uniq)).to_h
  #=> {:foo=>["bar", "rab", "bizz"], :baz=>["bang", "buzz"]}

The steps are as follows.

keys = arr.first.keys
  #=> [:foo, :baz]
a = arr.map { |h| h.values_at(*keys) }
  #=> [["bar", "bang"], ["rab", "bang"], ["bizz", "buzz"]]
b = a.transpose
  #=> [["bar", "rab", "bizz"], ["bang", "bang", "buzz"]]
c = b.map(&:uniq)
  #=> [["bar", "rab", "bizz"], ["bang", "buzz"]]
d = c.to_h
  #=> <array of hashes shown above>