红宝石哈希与块合并

Question

Trying to use ruby Hash merge! on multiple hashes, starting with an empty hash

a = {}
b = {x: 1.2, y: 1.3}
c = {x: 1.4, y: 1.5}
fact = 100 # need to multiply values that are merged in with this
a.merge!(b) {|k,v1,v2| v1 + v2 * fact} # it doesn't multiply values with     fact
a.merge!(c) {|k,v1,v2| v1 + v2 * fact} #it does multiply values with fact

So first merge does not give me result I was expecting, while the second merge does. Please note that in real app keys are not limited to x and y, there can be many different keys.

Answer 1

The first merge works as described in the documentation .

The block is invoked only to solve conflicts, when a key is present in both hashes. On the first call to Hash#merge! , a is empty, hence no conflict occurred and the content of b is copied into a without any changes.

You can fix the code by initializing a with {x: 0, y: 0} .

Answer 2

I would be inclined to perform the merge as follows.

a = {}
b = {x: 1.2, y: 1.3}
c = {x: 1.4, y: 1.5}
[b, c].each_with_object(a) { |g,h| h.update(g) { |_,o,n| o+n } }.
  tap { |h| h.keys.each { |k| h[k] *= 10 } }
  #=> {:x=>25.999999999999996, :y=>28.0}

Note that this works with any number of hashes ( b , c , d , ...) and any number of keys ({ x: 1.2, y: 1.3, z: 2.1, ... }`).

The steps are as follows ¹ .

e = [b, c].each_with_object(a)
  #=> #<Enumerator: [{:x=>1.2, :y=>1.3}, {:x=>1.4, :y=>1.5}]:each_with_object({})>

We can see the values that will be generated by this enumerator by applying Enumerable#entries ² :

e.entries
  #=> [[{:x=>1.2, :y=>1.3}, {}], [{:x=>1.4, :y=>1.5}, {}]]

We can use Enumerator#next to generate the first value of e and assign the two block variables to it (that is, "pass e.next to the block"):

g,h = e.next
  #=> [{:x=>1.2, :y=>1.3}, {}]
g #=> {:x=>1.2, :y=>1.3}
h #=> {}

Next we perform the block calculation.

f = h.update(g) { |_,o,n| o+n }
  #=> {:x=>1.2, :y=>1.3}

Here I have used the form of Hash.update (aka merge! ) which employs a block to determine the values of keys that are present in both hashes being merged. (See the doc for details.) As h is now empty (no keys), the block is not used for this merge.

The next and last value of e is now generated and the process is repeated.

g,h = e.next
  #=> [{:x=>1.4, :y=>1.5}, {:x=>1.2, :y=>1.3}]
g #=> {:x=>1.4, :y=>1.5}
h #=> {:x=>1.2, :y=>1.3}
f = h.update(g) { |_,o,n| o+n }
  #=> {:x=>2.5999999999999996, :y=>2.8}

Since g and h both have a key :x , the block is used to determine the new value of h[:x]

_ #=> :x
o #=> 1.4
n #=> 1.2
h[:x] = o + n
  #=> 2.6

Similarly, h[:y| = 2.8 h[:y| = 2.8 .

The last step uses Object#tap to multiple each value by 10 .

f.tap { |g| g.keys.each { |k| h[k] *= 10 } }
  #=> {:x=>25.999999999999996, :y=>28.0}

tap does nothing more than save a line of code and the creation of a local variable, as I could have instead written:

h = [b, c].each_with_object(a) { |g,h| h.update(g) { |_,o,n| o+n } }
h.keys.each { |k| h[k] *= 10 }
h

Another option (that does not use tap ) is to write:

f = [b, c].flat_map(&:keys).uniq.product([0]).to_h
  #=> {:x=>0, :y=>0}
[b, c].each_with_object(f) { |g,h| h.update(g) { |_,o,n| o+10*n } }
  #=> {:x=>26.0, :y=>28.0}

^{1 Experienced Rubiests: GORY DETAIL ALERT!}

^{2 Hash#to_a could also be used here.}