Rails 将哈希数组映射到单个哈希

小开

hashes = [{"testPARAM1"=>"testVAL1"}, {"testPARAM2"=>"testVAL2"}]
merged = hashes.inject({}) { |aggregate, hash| aggregate.merge hash }
merged # => {"testPARAM1"=>"testVAL1", "testPARAM2"=>"testVAL2"}

小开

How about:

h = [{"testPARAM1"=>"testVAL1"}, {"testPARAM2"=>"testVAL2"}]
r = h.inject(:merge)

小开

最佳答案

You could compose Enumerable#reduce and Hash#merge to accomplish what you want.

input = [{"testPARAM1"=>"testVAL1"}, {"testPARAM2"=>"testVAL2"}]
input.reduce({}, :merge)
is {"testPARAM2"=>"testVAL2", "testPARAM1"=>"testVAL1"}

Reducing an array sort of like sticking a method call between each element of it.

For example [1, 2, 3].reduce(0, :+) is like saying 0 + 1 + 2 + 3 and gives 6.

In our case we do something similar, but with the merge function, which merges two hashes.

[{:a => 1}, {:b => 2}, {:c => 3}].reduce({}, :merge)
is {}.merge({:a => 1}.merge({:b => 2}.merge({:c => 3})))
is {:a => 1, :b => 2, :c => 3}

小开

Here you can use either inject or reduce from Enumerable class as both of them are aliases of each other so there is no performance benefit to either.

 sample = [{"testPARAM1"=>"testVAL1"}, {"testPARAM2"=>"testVAL2"}]


result1 = sample.reduce(:merge)
# {"testPARAM1"=>"testVAL1", "testPARAM2"=>"testVAL2"}


result2 = sample.inject(:merge)
# {"testPARAM1"=>"testVAL1", "testPARAM2"=>"testVAL2"}

小开

Every answers until now are advising to use Enumerable#reduce (or inject which is an alias) + Hash#merge but beware, while being clean, concise and human readable this solution will be hugely time consuming and have a large memory footprint on large arrays.

I have compiled different solutions and benchmarked them.

Some options

a = [{'a' => {'x' => 1}}, {'b' => {'x' => 2}}]


# to_h
a.to_h { |h| [h.keys.first, h.values.first] }


# each_with_object
a.each_with_object({}) { |x, h| h.store(x.keys.first, x.values.first) }
# each_with_object (nested)
a.each_with_object({}) { |x, h| x.each { |k, v| h.store(k, v) } }
# map.with_object
a.map.with_object({}) { |x, h| h.store(x.keys.first, x.values.first) }
# map.with_object (nested)
a.map.with_object({}) { |x, h| x.each { |k, v| h.store(k, v) } }


# reduce + merge
a.reduce(:merge) # take wayyyyyy to much time on large arrays because Hash#merge creates a new hash on each iteration
# reduce + merge!
a.reduce(:merge!) # will modify a in an unexpected way

Benchmark script

It's important to use bmbm and not bm to avoid differences are due to the cost of memory allocation and garbage collection.

require 'benchmark'


a = (1..50_000).map { |x| { "a#{x}" => { 'x' => x } } }


Benchmark.bmbm do |x|
x.report('to_h:') { a.to_h { |h| [h.keys.first, h.values.first] } }
x.report('each_with_object:') { a.each_with_object({}) { |x, h| h.store(x.keys.first, x.values.first) } }
x.report('each_with_object (nested):') { a.each_with_object({}) { |x, h| x.each { |k, v| h.store(k, v) } } }
x.report('map.with_object:') { a.map.with_object({}) { |x, h| h.store(x.keys.first, x.values.first) } }
x.report('map.with_object (nested):') { a.map.with_object({}) { |x, h| x.each { |k, v| h.store(k, v) } } }
x.report('reduce + merge:') { a.reduce(:merge) }
x.report('reduce + merge!:') { a.reduce(:merge!) }
end

Note: I initially tested with a 1_000_000 items array but as reduce + merge is costing exponentially much time it will take to much time to end.

Benchmark results

50k items array

Rehearsal --------------------------------------------------------------
to_h:                        0.031464   0.004003   0.035467 (  0.035644)
each_with_object:            0.018782   0.003025   0.021807 (  0.021978)
each_with_object (nested):   0.018848   0.000000   0.018848 (  0.018973)
map.with_object:             0.022634   0.000000   0.022634 (  0.022777)
map.with_object (nested):    0.020958   0.000222   0.021180 (  0.021325)
reduce + merge:              9.409533   0.222870   9.632403 (  9.713789)
reduce + merge!:             0.008547   0.000000   0.008547 (  0.008627)
----------------------------------------------------- total: 9.760886sec


user     system      total        real
to_h:                        0.019744   0.000000   0.019744 (  0.019851)
each_with_object:            0.018324   0.000000   0.018324 (  0.018395)
each_with_object (nested):   0.029053   0.000000   0.029053 (  0.029251)
map.with_object:             0.021635   0.000000   0.021635 (  0.021782)
map.with_object (nested):    0.028842   0.000005   0.028847 (  0.029046)
reduce + merge:             17.331742   6.387505  23.719247 ( 23.925125)
reduce + merge!:             0.008255   0.000395   0.008650 (  0.008681)

2M items array (excluding `reduce + merge`)

Rehearsal --------------------------------------------------------------
to_h:                        2.036005   0.062571   2.098576 (  2.116110)
each_with_object:            1.241308   0.023036   1.264344 (  1.273338)
each_with_object (nested):   1.126841   0.039636   1.166477 (  1.173382)
map.with_object:             2.208696   0.026286   2.234982 (  2.252559)
map.with_object (nested):    1.238949   0.023128   1.262077 (  1.270945)
reduce + merge!:             0.777382   0.013279   0.790661 (  0.797180)
----------------------------------------------------- total: 8.817117sec


user     system      total        real
to_h:                        1.237030   0.000000   1.237030 (  1.247476)
each_with_object:            1.361288   0.016369   1.377657 (  1.388984)
each_with_object (nested):   1.765759   0.000000   1.765759 (  1.776274)
map.with_object:             1.439949   0.029580   1.469529 (  1.481832)
map.with_object (nested):    2.016688   0.019809   2.036497 (  2.051029)
reduce + merge!:             0.788528   0.000000   0.788528 (  0.794186)