Wie man alle Schlüssel eines Hashes durch einen neuen Satz gegebener Schlüssel ändert

Question

Wie ändere ich alle Schlüssel eines Hash durch einen neuen Satz gegebener Schlüssel?

Gibt es eine Möglichkeit, das elegant zu machen?

Answer 1

Ich gehe davon aus Sie keys den Hash zu ändern, ohne die Werte zu ändern:

hash = {"nr"=>"123", "name"=>"Herrmann Hofreiter", "pferd"=>"010 000 777", "land"=>"hight land"} 
header = ["nr", "name", "hourse", "land"] 
new_hash = header.zip(hash.values).to_h 

Ergebnis: { "nr" => "123", " Name "=>" Herrmann Hofreiter "," hourse "=>" 010 000 777 "," Land "=>" hohes Land "}

Answer 2

Die exakte Lösung würde von dem Format ab, die Sie die neuen Schlüssel haben in (oder wenn Sie den neuen Schlüssel aus dem alten Schlüssel ableiten können.)

Sie haben Unter der Annahme einer Hash-h, deren Schlüssel Sie ändern möchten und ein Hash-new_keys, die die aktuellen Schlüssel zu den neuen Schlüssel Karten könnten Sie tun:

h.keys.each do |key| 
    h[new_keys[key]] = h[key] # add entry for new key 
    k.delete(key)    # remove old key 
end 

Answer 3

Vorausgesetzt Sie haben eine Hash haben die alten Schlüssel zu neuen Schlüssel abbildet, können Sie etwas tun, wie

hsh.map {|k, v| [key_map[k], v] }.to_h 

Answer 4

Wenn Sie auch über die Leistung Sorge, dies ist schneller:

hsh.keys.each { |k| hsh[ key_map[k] ] = hsh.delete(k) if key_map[k] } 

Sie keine neue Hash erstellen und benennen Sie nur die notwendigen Schlüssel. Das gibt Ihnen bessere Leistung.

Sie können mehr Details in "How to elegantly rename all keys in a hash in Ruby?"

Answer 5

Einen anderen Weg, es zu tun finden:

hash = { 
    'foo' => 1, 
    'bar' => 2 
} 

new_keys = { 
    'foo' => 'foozle', 
    'bar' => 'barzle' 
} 

new_keys.values.zip(hash.values_at(*new_keys.keys)).to_h 
# => {"foozle"=>1, "barzle"=>2} 

es nach unten brechen:

new_keys 
.values # => ["foozle", "barzle"] 
.zip(
    hash.values_at(*new_keys.keys) # => [1, 2] 
) # => [["foozle", 1], ["barzle", 2]] 
.to_h 
# => {"foozle"=>1, "barzle"=>2} 

---

Es ist Benchmark Zeit ..

Während ich die Einfachheit von Jörn Antwort mag, ich bin nicht sicher war, es so schnell war, wie es sein sollte, dann sah ich selvamani Kommentar:

require 'fruity' 

HASH = { 
    'foo' => 1, 
    'bar' => 2 
} 

NEW_KEYS = { 
    'foo' => 'foozle', 
    'bar' => 'barzle' 
} 

compare do 
    mittag { HASH.dup.map {|k, v| [NEW_KEYS[k], v] }.to_h } 
    ttm  { h = HASH.dup; NEW_KEYS.values.zip(h.values_at(*NEW_KEYS.keys)).to_h } 
    selvamani { h = HASH.dup; h.keys.each { |key| h[NEW_KEYS[key]] = h.delete(key)}; h } 
end 

# >> Running each test 2048 times. Test will take about 1 second. 
# >> selvamani is faster than ttm by 39.99999999999999% ± 10.0% 
# >> ttm is faster than mittag by 10.000000000000009% ± 10.0% 

Diese sind sehr nahe beieinander Geschwindigkeit weise ausgeführt, so dass jeder wird tun, aber 39% zahlt sich im Laufe der Zeit aus, also bedenken Sie das. Ein paar Antworten wurden nicht berücksichtigt, da es potenzielle Fehler gibt, die schlechte Ergebnisse liefern.

Answer 6

h = { 'foo'=>1, 'bar'=>2 } 
key_map = { 'foo'=>'foozle', 'bar'=>'barzle' } 

h.each_with_object({}) { |(k,v),g| g[key_map[k]]=v } 
    #=> {"foozle"=>1, "barzle"=>2} 

oder

h.reduce({}) { |g,(k,v)| g.merge(key_map[k]=>v) } 
    #=> {"foozle"=>1, "barzle"=>2}