Tableau de hachages de hachage

Par exemple, j'ai tableau de simple hachages

a = [{a: :b}, {c: :d}]

Ce qui est le meilleur moyen de convertir il dans tout cela?

{a: :b, c: :d}

InformationsquelleAutor evfwcqcg | 2012-06-08

116

Vous pouvez utiliser
```
a.reduce Hash.new, :merge
```
directement les rendements
```
{:a=>:b, :c=>:d}
```
Noter que dans le cas de collisions de l'ordre est important. Dernier hachages de remplacer précédente mappages, voir par exemple:
```
[{a: :b}, {c: :d}, {e: :f, a: :g}].reduce Hash.new, :merge   # {:a=>:g, :c=>:d, :e=>:f}
```
- Hash.new, ou comme des amis aime à l'appeler, {} 🙂 Tellement que j'aime pure solution fonctionnelle, notez que merge va créer une nouvelle table de hachage sur chaque itération; on peut utiliser update à la place (il ne plaisante pas avec l'entrée de tables de hachage, c'est le point le plus important): hs.reduce({}, :update)
- poster un commentaire comme une réponse distincte - il doit obtenir plus de visibilité
- Si votre application le permet, le :update version proposée par tokland est l'option plus rapide.
InformationsquelleAutor Howard
38

Vous pouvez utiliser .inject:
```
a.inject(:merge)
#=> {:a=>:b, :c=>:d}
```
Démonstration

Qui initie une nouvelle table de hachage sur chaque itération à partir de les deux ont fusionné. Pour éviter cela, vous pouvez utiliser le destructeur :merge!( ou :update, qui est la même):
```
a.inject(:merge!)
#=> {:a=>:b, :c=>:d}
```
Démonstration
- C'est fou élégant. Je vous remercie.
- cette réponse mérite plus upvotes
InformationsquelleAutor potashin
21

Ces deux:
```
total_hash = hs.reduce({}) { |acc_hash, hash| acc_hash.merge(hash) }
total_hash = hs.reduce({}, :merge)
```
Noter que Hash#merge crée une nouvelle table de hachage sur chaque itération, ce qui peut être un problème si vous êtes à la construction d'un gros hachage. Dans ce cas, utilisez update à la place:
```
total_hash = hs.reduce({}, :update)
```
Une approche alternative serait de convertir les valeurs de hachage pour les paires et ensuite construire la finale de hachage:
```
total_hash = hs.flat_map(&:to_a).to_h
```
InformationsquelleAutor tokland
1

Je suis tombé sur cette réponse et je voulais comparer les deux options en termes de performances pour voir qui est le meilleur:
1. a.reduce Hash.new, :merge
2. a.inject(:merge)
à l'aide de ruby le test d'un module, il s'avère que l'option (2) a.inject(:merge) est plus rapide.

code utilisé pour la comparaison:
```
require 'benchmark'

input = [{b: "c"}, {e: "f"}, {h: "i"}, {k: "l"}]
n = 50_000

Benchmark.bm do |benchmark|
  benchmark.report("reduce") do
    n.times do
      input.reduce Hash.new, :merge
    end
  end

  benchmark.report("inject") do
    n.times do
      input.inject(:merge)
    end
  end
end
```
les résultats ont été
```
       user     system      total        real
reduce  0.125098   0.003690   0.128788 (  0.129617)
inject  0.078262   0.001439   0.079701 (  0.080383)
```
- Ce résultat qui me confond. Le docs dire reduce et inject sont des alias. Une vérification rapide w/ votre test montre que le ralentissement est dû à Hash.new que l'initialiseur. :merge crée une nouvelle table de hachage à chaque itération. :update ne l'est pas. Donc, une ré-exécuter avec :update montre, même avec la Hash.new, le :update version est plus rapide:`` l'utilisateur du système total réel de réduire w/ Hachage.nouvelles & :mise à jour 0.056754 0.002097 0.058851 ( 0.059330) réduire w/ :fusionner seulement 0.090021 0.001081 0.091102 ( 0.091257)``
InformationsquelleAutor bigsolom

Essayer cette

a.inject({}){|acc, hash| acc.merge(hash)} #=> {:a=>:b, :c=>:d}

InformationsquelleAutor Rahul Patel

0

Suffit d'utiliser
```
a.reduce(:merge)
#=> {:a=>:b, :c=>:d}
```
InformationsquelleAutor Ritesh katare

Vous pouvez le transformer en tableau [[:a, :b]] et après que tout traduire pour de hachage {:a=>:b}

# it works like [[:a, :b]].to_h => {:a=>:b}

[{a: :b}, {c: :d}].map { |hash| hash.to_a.flatten }.to_h

# => {:a=>:b, :c=>:d}

InformationsquelleAutor Evan Ross

Vous devez vous connecter pour publier un commentaire.