Rails mappant un tableau de hachages sur un hachage unique

92

J'ai un tableau de hachages comme ceci:

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

Et j'essaie de mapper ceci sur un hachage unique comme ceci:

{"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 de manière plus idiomatique (de préférence sans utiliser de variable locale).

Comment puis-je faire ceci?

ruby-on-rails ruby arrays hash Bart Platak
la source

Réponses:

161

Vous pouvez composer Enumerable#reduceet Hash#mergeaccomplir ce que vous voulez.

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

Réduire un tableau un peu comme 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 + 3et donner 6.

Dans notre cas, nous faisons quelque chose de similaire, mais avec la fonction de fusion, 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}
cjhveal
la source
1
Merci, c'est une excellente réponse :) Très bien expliqué!
Bart Platak
41
input.reduce (&: merge) est suffisant.
redgetan
@redgetan est-ce différent de input.reduce(:merge)?
David van Geest
1
@David van Geest: Dans ce cas, ils sont équivalents. L'esperluette unaire telle qu'utilisée ici crée un bloc à partir du symbole. Cependant, réduire a un cas particulier qui accepte un symbole. Je voulais éviter l'opérateur esperluette unaire pour simplifier l'exemple, mais redgetan a raison de dire que la valeur initiale est facultative dans ce cas.
cjhveal
1
Notez que si vous utilisez à la merge!place, mergecela modifiera le premier hachage (ce que vous ne voudrez peut-être pas) mais ne créera pas de hachage intermédiaire pour chaque nouvelle fusion.
Phrogz
50

Que diriez-vous:

h = [{"testPARAM1"=>"testVAL1"}, {"testPARAM2"=>"testVAL2"}]
r = h.inject(:merge)
Shigeya
la source
Ce schéma est effectivement le même que ce que Joshua a répondu, mais en appliquant à plusieurs reprises #merge (nom de méthode passé en tant que symbole) sur tous les hachages (pensez à injecter comme à l'injection d'un opérateur entre les éléments). Reportez-vous à #inject .
shigeya
2
Pourquoi n'avons-nous pas besoin de l'esperluette, comme dans h.inject (&: merge)?
Donato
5
Parce que la méthode inject accepte un symbole comme paramètre à interpréter également comme nom de méthode. C'est la fonction d'inject.
shigeya
9

Utilisez #inject

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

Ici, vous pouvez utiliser injecter ou réduire à partir de la classe Enumerable , car les deux sont des alias l'un de l'autre, il n'y a donc 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"}
Nikhil Mohadikar
la source