Echange de clés et de valeurs dans un hachage

Dans Ruby, comment échanger des clés et des valeurs sur un hachage?

Disons que j’ai le Hash suivant:

{:a=>:one, :b=>:two, :c=>:three} 

Que je veux transformer en:

 {:one=>:a, :two=>:b, :three=>:c} 

L’utilisation d’une carte semble plutôt fastidieuse. Y a-t-il une solution plus courte?

Ruby a une méthode d’assistance pour le hachage qui vous permet de traiter un hachage comme s’il était inversé.

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

Si vous souhaitez conserver le hachage inversé, Hash # invert devrait fonctionner dans la plupart des cas.

 {a: 1, b: 2, c: 3}.invert => {1=>:a, 2=>:b, 3=>:c} 

MAIS…

Si vous avez des valeurs en double, invert va supprimer toutes vos valeurs sauf la dernière. De même, la key ne renverra que le premier match.

 {a: 1, b: 2, c: 2}.key(2) => :b {a: 1, b: 2, c: 2}.invert => {1=>:a, 2=>:c} 

Donc, si vos valeurs sont uniques, vous pouvez utiliser Hash#invert si ce n’est pas le cas, alors vous pouvez conserver toutes les valeurs sous forme de tableau, comme ceci:

 class Hash # like invert but not lossy # {"one"=>1,"two"=>2, "1"=>1, "2"=>2}.inverse => {1=>["one", "1"], 2=>["two", "2"]} def safe_invert each_with_object({}) do |(key,value),out| out[value] ||= [] out[value] << key end end end 

Note: Ce code avec des tests est maintenant ici .

Ou en bref ...

 class Hash def safe_invert self.each_with_object({}){|(k,v),o|(o[v]||=[])< 

Vous pariez qu’il y en a un! Il y a toujours un moyen plus court de faire les choses en Ruby!

C’est assez simple, utilisez simplement Hash#invert :

 {a: :one, b: :two, c: :three}.invert => {:one=>:a, :two=>:b, :three=>:c} 

Et voilà!

 # this doesn't looks quite as elegant as the other solutions here, # but if you call inverse twice, it will preserve the elements of the original hash # true inversion of Ruby Hash / preserves all elements in original hash # eg hash.inverse.inverse ~ h class Hash def inverse i = Hash.new self.each_pair{ |k,v| if (v.class == Array) v.each{ |x| i[x] = i.has_key?(x) ? [k,i[x]].flatten : k } else i[v] = i.has_key?(v) ? [k,i[v]].flatten : k end } return i end end 

Hash#inverse vous donne:

  h = {a: 1, b: 2, c: 2} h.inverse => {1=>:a, 2=>[:c, :b]} h.inverse.inverse => {:a=>1, :c=>2, :b=>2} # order might not be preserved h.inverse.inverse == h => true # true-ish because order might change 

alors que la méthode d’ invert intégrée est juste cassée:

  h.invert => {1=>:a, 2=>:c} # FAIL h.invert.invert == h => false # FAIL 

Utiliser un tableau

 input = {:key1=>"value1", :key2=>"value2", :key3=>"value3", :key4=>"value4", :key5=>"value5"} output = Hash[input.to_a.map{|m| m.reverse}] 

Utiliser le hachage

 input = {:key1=>"value1", :key2=>"value2", :key3=>"value3", :key4=>"value4", :key5=>"value5"} output = input.invert 
 files = { 'Input.txt' => 'Randy', 'Code.py' => 'Stan', 'Output.txt' => 'Randy' } h = Hash.new{|h,k| h[k] = []} files.map {|k,v| h[v]<< k} puts h 

Cela va gérer les valeurs en double aussi.

Si vous avez un hachage où les clés sont uniques, vous pouvez utiliser Hash # invert :

 > {a: 1, b: 2, c: 3}.invert => {1=>:a, 2=>:b, 3=>:c} 

Cela ne fonctionnera pas si vous avez des clés non uniques, cependant, où seules les dernières clés vues seront conservées:

 > {a: 1, b: 2, c: 3, d: 3, e: 2, f: 1}.invert => {1=>:f, 2=>:e, 3=>:d} 

Si vous avez un hash avec des clés non uniques, vous pouvez le faire:

 > hash={a: 1, b: 2, c: 3, d: 3, e: 2, f: 1} > hash.each_with_object(Hash.new { |h,k| h[k]=[] }) {|(k,v), h| h[v] << k } => {1=>[:a, :f], 2=>[:b, :e], 3=>[:c, :d]} 

Si les valeurs du hachage sont déjà des tableaux, vous pouvez faire:

 > hash={ "A" => [14, 15, 16], "B" => [17, 15], "C" => [35, 15] } > hash.each_with_object(Hash.new { |h,k| h[k]=[] }) {|(k,v), h| v.map {|t| h[t] << k} } => {14=>["A"], 15=>["A", "B", "C"], 16=>["A"], 17=>["B"], 35=>["C"]}