Rails mapping d'un tableau de hashs sur un seul hash

Question

J'ai un tableau de hachages comme ceci :

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

Et j'essaie de faire correspondre ça à un seul hachage, comme ça :

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

Je l'ai réalisé en utilisant

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

Mais je me demandais s'il était possible de le faire d'une manière plus idiomatique (de préférence sans utiliser de variable locale).

Comment puis-je le faire ?

Answer 1

Vous pourriez composer Enumerable#reduce y Hash#merge pour accomplir ce que vous voulez.

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

Réduire un tableau revient en quelque sorte à coller un appel de méthode entre chaque élément de celui-ci.

Par exemple [1, 2, 3].reduce(0, :+) c'est comme dire 0 + 1 + 2 + 3 et donne 6 .

Dans notre cas, nous faisons quelque chose de similaire, mais avec la fonction merge, qui fusionne deux hachages.

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

Pourquoi pas :

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

Answer 3

Toutes les réponses jusqu'à présent conseillent d'utiliser Enumerable#reduce (ou inject qui est un alias) + Hash#merge Mais attention, bien qu'elle soit propre, concise et lisible par l'homme, cette solution prendra énormément de temps et aura une grande empreinte mémoire sur les grands tableaux.

J'ai compilé différentes solutions et les ai comparées.

Quelques 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

Il est important d'utiliser bmbm et non bm pour éviter les différences sont dues au coût de l'allocation de la mémoire et de la collecte des déchets.

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

Remarque : j'ai initialement testé avec un tableau de 1_000_000 éléments mais comme reduce + merge coûte exponentiellement beaucoup de temps, il faudra trop de temps pour y mettre fin.

Résultats de l'évaluation comparative

Tableau de 50k articles

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)

Tableau de 2 millions d'articles (à l'exclusion de 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

Utilisez #injection

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

Answer 5

Ici, vous pouvez utiliser soit injecter ou réduire le site de Énumérable car ces deux classes sont des alias l'une de l'autre et ne présentent aucun avantage en termes de performances.

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

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

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