Merge hashes with multiple keys/values

Question

I have an array of hashes of which I merge hashes that contain specific duplicate key value.

combined_keywords = new_array_of_hashes.each_with_object(Hash.new(0)){|oh, newh|
        newh[oh[:keyword]] += oh[:total_value].to_f
    }

This creates an array of hashes that look like this:

 { :ACTUAL_KEYWORD => ACTUAL_TOTAL_VALUE }

I'm new to ruby and I don't quite understand the magic behind this. I have an additional key and value to consolidate and now I'm lost. The root of the issue is I don't understand how the consolidation is occurring in this line: newh[oh[:keyword]] += oh[:total_value].to_f

I tried this with no luck:

combined_keywords = new_array_of_hashes.each_with_object(Hash.new(0)){|oh, newh|
            newh[oh[:keyword]] += oh[:total_value].to_f
            newh[oh[:keyword]] += oh[:revenue_per_transaction].to_f
        }

I really just need an array of consildated hashes each similar to:

{ :keyword => "ACTUAL_KEYWORD", :total_value => ACTUAL_TOTAL_VALUE, :revenue_per_transaction => ACTUAL_REVENUE }

Edit:

Input

new_array_of_hashes = [
  { keyword: 'foo', total_value: 1, revenue_per_transaction: 5 },
  { keyword: 'bar', total_value: 2, revenue_per_transaction: 4 },
  { keyword: 'bar', total_value: 4, revenue_per_transaction: 4 },
  { keyword: 'foo', total_value: 3, revenue_per_transaction: 5 },
]

Desired Output

combined_keywords = [
  { keyword: 'foo', total_value: 4, revenue_per_transaction: 10 },
  { keyword: 'bar', total_value: 6, revenue_per_transaction: 8 },
]

Answer 1

Let's say you have:

new_array_of_hashes = [
  { keyword: 'foo', total_value: 1 },
  { keyword: 'bar', total_value: 2 },
  { keyword: 'bar', total_value: 4 },
  { keyword: 'foo', total_value: 3 },
]

Now we'll step through your code:

combined_keywords = new_array_of_hashes.each_with_object(Hash.new(0)){|oh, newh|
  newh[oh[:keyword]] += oh[:total_value].to_f
}

This will loop over each hash in the array. We also setup a new hash which returns 0 if we access a key that doesn't exist:

# Pass 1
oh = { keyword: 'foo', total_value: 1 }
newh = {}
newh[ oh[:keyword] ]  #=> newh['foo'] This key doesn't exist and returns 0
oh[:total_value].to_f #=> 1.to_f => 1.0
newh[oh[:keyword]] += oh[:total_value].to_f
#=> newh['foo'] = newh['foo'] + oh[:total_value].to_f
#=> newh['foo'] = 0 + 1.0

# Pass 2
oh = { keyword: 'bar', total_value: 2 }
newh = { 'foo' => 1.0 }
newh[ oh[:keyword] ]  #=> newh['bar'] This key doesn't exist and returns 0
oh[:total_value].to_f #=> 2.to_f => 2.0
newh[oh[:keyword]] += oh[:total_value].to_f
#=> newh['bar'] = newh['bar'] + oh[:total_value].to_f
#=> newh['bar'] = 0 + 2.0

Now since we have keys for the next two iterations we access things as normal:

# Pass 3
oh = { keyword: 'bar', total_value: 4 }
newh = { 'foo' => 1.0, 'bar' => 2.0 }
newh[ oh[:keyword] ]  #=> newh['bar'] This key now exists and returns 2.0
oh[:total_value].to_f #=> 4.to_f => 4.0
newh[oh[:keyword]] += oh[:total_value].to_f
#=> newh['bar'] = newh['bar'] + oh[:total_value].to_f
#=> newh['bar'] = 2.0 + 4.0

# Pass 4
oh = { keyword: 'foo', total_value: 3 }
newh = { 'foo' => 1.0, 'bar' => 6.0 }
newh[ oh[:keyword] ]  #=> newh['foo'] This key now exists and returns 1.0
oh[:total_value].to_f #=> 3.to_f => 3.0
newh[oh[:keyword]] += oh[:total_value].to_f
#=> newh['foo'] = newh['foo'] + oh[:total_value].to_f
#=> newh['foo'] = 1.0 + 3.0

When the block returns it will return newh; this is how each_with_object works.

As you can see, what is returned is a hash of the form:

{ 'foo' => 4.0, 'bar' => 6.0 }

So this is only a combined array where the new key was the stored :keyword object, and the value was the sum total.

Based on your new hash form

{
  keyword: "ACTUAL_KEYWORD",
  total_value: ACTUAL_TOTAL_VALUE,
  revenue_per_transaction: ACTUAL_REVENUE
}

This format won't make much sense. Since hashes only have key:value pairs. You may need to have a hash of sub-hashes, or run through the loop twice. Once for :total_value and once for :revenue_per_transaction. It will really depend what you want your final object(s) to be.

Edit:

Based on your new expected input and output, you could use:

sum_keys = [:total_value, :revenue_per_transaction]
new_array_of_hashes.group_by{ |h| h[:keyword] }
                   .map{ |keyword, related|
                     tmp = {keyword: keyword}
                     tmp.merge! Hash[sum_keys.zip Array.new(sum_keys.size, 0)]
                     related.reduce(tmp){ |summed, h|
                       sum_keys.each{ |key| summed[key] += h[key] }
                       summed
                     }
                   }

#=> [
#  { keyword: 'foo', total_value: 4, revenue_per_transaction: 10 },
#  { keyword: 'bar', total_value: 6, revenue_per_transaction: 8 },
#]

It's a bit messy. I'd probably refactor what the map call is doing into it's own helper method. The reason I'm providing a start value to reduce is because otherwise it will mutate the original hash from new_array_of_hashes.

Answer 2

Given

foos = [ { :key => 'Foo', :value => 1, :revenue => 2 },
         { :key => 'Foo', :value => 4, :revenue => 8 } ]

You can do this

foos.each_with_object(Hash.new(0)) do |foo_hash, new_hash|
  new_hash[:keyword] = foo_hash[:key]
  new_hash[:total_value] += foo_hash[:value]
  new_hash[:total_revenue] += foo_hash[:revenue]
end

So each_with_object allows you to pass an argument to an enumerable's .each block. In this case you are passing Hash.new(0). The 0 argument is a way to set a default hash value so you don't have to explicitly zero the value to zero in the loop and just get right to incrementing. The += is just shorthand. So a += b is equivalent to a = a + b.

The clunky thing about the loop is it sets the new_hash[:keyword] value on every pass. You could tack on a if new_hash[:keyword] == 0 (because it initials to zero) but that's just a bandaid. The problem lies in the original hashes structure. If :key aways equals 'Foo' then 'Foo' is superfluous. If it's not always 'Foo' then this loop isn't very useful.

The loop above yields

{ :keyword => 'Foo', :total_value => 5, :total_revenue => 10 }