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

Question

我有一个像这样的哈希数组：

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

我正在尝试将其映射到单个哈希上，如下所示：

{"testPARAM2"=>"testVAL2", "testPARAM1"=>"testVAL1"}

我已经使用

实现了它

  par={}
  mitem["params"].each { |h| h.each {|k,v| par[k]=v} } 

但我想知道是否可以以更惯用的方式执行此操作（最好不使用局部变量）。

我该怎么做？

Answer 1

您可以组合

Enumerable#reduce

和

Hash#merge

来完成您想要的。

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

减少数组有点像在数组的每个元素之间添加方法调用。

例如

[1, 2, 3].reduce(0, :+)

就像说

0 + 1 + 2 + 3

并给出

6

。

在我们的例子中，我们做了类似的事情，但是使用了合并函数，它合并了两个哈希值。

[{: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}

Answer 2

怎么样：

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

Answer 3

到目前为止，每个答案都建议使用

Enumerable#reduce

（或

inject

，这是一个别名）+

Hash#merge

，但要注意，虽然干净、简洁且易于阅读，但此解决方案将非常耗时并且在大型数组上占用大量内存。

我已经编译了不同的解决方案并对它们进行了基准测试。

一些选择

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

基准脚本

使用 bmbm 而不是

bm

很重要，以避免由于内存分配和垃圾收集的成本而产生差异。

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

注意：我最初使用 1_000_000 个项目数组进行测试，但由于

reduce + merge

会花费指数级的时间，因此需要很长时间才能结束。

基准结果

50k 项数组

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 项数组（不包括

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)

Answer 4

使用#注入

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

Answer 5

2023年更新：

Ruby 3 中的

merge 方法现在支持多个参数。 这意味着，我们可以提供多个哈希值，它们将被合并在一起。

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

如果你有一个哈希数组，你可以使用 splat 运算符来传播参数：

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

Answer 6

在这里，您可以使用

Enumerable 类中的 inject 或 reduce，因为它们都是彼此的别名，因此两者都没有性能优势。

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

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

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