Pushing Hash auf Array: letzte Hash Überschreiben vorherige Feldelemente

Question

I den folgenden Ruby-Skript habe:

arr = ['bob', 'jack', 'smith'] 
array_of_hashes = Array.new 
hash = Hash.new 

arr.each do |item| 
    hash.clear 
    hash[:name] = item 
    array_of_hashes << hash 
end 

puts array_of_hashes 

Dies gibt einen Array von Hashes, das: Namen Schlüssel alle aus dem letzten Elemente sind.

[ 
    [0] { 
     :name => "smith" 
    }, 
    [1] { 
     :name => "smith" 
    }, 
    [2] { 
     :name => "smith" 
    } 
] 

Ich würde erwarten, dass es die folgenden zurückzukehren, aber ich bin fest versuchen, warum Element der letzte Hash, um herauszufinden, wird alle bisherigen Array-Elemente zu überschreiben:

[ 
    [0] { 
     :name => "bob" 
    }, 
    [1] { 
     :name => "jack" 
    }, 
    [2] { 
     :name => "smith" 
    } 
] 

EDIT: Vielen Dank für deine Antworten. Es ist schön, einige verschiedene Methoden zu haben, um das Gleiche zu erreichen. Ich habe jede Lösung getestet und jede ist großartig. Am Ende benutzte ich das, das meinem ursprünglichen Code am ähnlichsten war; aber mein Anwendungsfall ist ein einfaches lokales Skript - es wird nicht in einer industriellen App verwendet - in diesem Fall würde ich wahrscheinlich eine andere Lösung wählen.

Answer 1

Sie sollten für jeden neuen Artikel etwas wie

arr = ['bob', 'jack', 'smith'] 
array_of_hashes = Array.new 

arr.each { |item| 
    hash = Hash.new 
    hash[:name] = item 
    array_of_hashes << hash 
} 

puts array_of_hashes 

mit einer neuen Instanz wird in das Array geschoben versuchen.

Answer 2

Sehen Sie sich Ihren Code genau an. Sie werden sehen, dass Sie nur eine einzige Instanz von Hash erstellt haben. Ihr Iterator entfernt frühere Bemühungen mit .clear, setzt das Element auf die aktuelle Iteration und fügt den Verweis auf dieses Objekt Hash zu verschiedenen Array-Positionen in array_of_hashes hinzu. Aber am Ende des Tages zeigen alle auf das gleiche Hash Objekt, und das Hash Objekt enthält nur das letzte, was Sie hineingesteckt haben.

Answer 3

Beachten Sie (und verstehen) die Antwort von @pjs und den Kommentar von @tadman, da sie erklären, warum Sie die Ergebnisse erhalten, die Sie bekommen.

Ich würde eigentlich stattdessen so etwas wie:

names = ['bob', 'jack', 'smith'] 

# combine the results into an array of Hashes 
array_of_hashes = 
    names.collect do |item| 
    { name: item } 
    end 

# output the results 
array_of_hashes # [{name: "bob"}, {name: "jack"},{name:"smith"}] 

Einige Hinweise:

• Die Array#collect Methode gibt einen Array zurück, so dass Sie nicht manuell auf einen Array hinzufügen, müssen Sie‘ habe dein Selbst initialisiert.
• Sie können nur einen neuen Hash für jedes Element zurück, die

Answer 4

im collect Block zurückgegeben werden ich

[:name].product(arr).map { |pair| Hash[[pair]] } 
    #=> [{:name=>"bob"}, {:name=>"jack"}, {:name=>"smith"}] 

oder (für Ruby v2 schreiben würde.0+)

[:name].product(arr).map { |pair| [pair].to_h } 

Die Schritte:

a = [:name].product(arr) 
    #=> [[:name, "bob"], [:name, "jack"], [:name, "smith"]] 
enum = a.map 
    # => #<Enumerator: [[:name, "bob"], [:name, "jack"], [:name, "smith"]]:map> 

beachte, dass das Verfahren durch das Senden zu Enumerator#eachenum wir das gewünschte Ergebnis erhalten:

enum.each { |pair| [pair].to_h } 
    #=> [{:name=>"bob"}, {:name=>"jack"}, {:name=>"smith"}] 

(Enumerator#each wird aufrufen Array#each weil a.class #=> Array.)

Enumerator#each setzt die Blockvariablen auf das erste Element der enum:

pair = enum.next 
    #=> [:name, "bob"] 

und dem Block-Berechnung durchgeführt wird:

[pair].to_h 
    #=> [[:name, "bob"]].to_h 
    #=> {:name=>"bob"} 

nächstes wird das zweite Element des enum wird [:name, "jack"], abgebildet auf:

Zuletzt,

pair = enum.next 
    #=> [:name, "smith"] 
[pair].to_h 
    #=> [[:name, "smith"]].to_h 
    #=> {:name=>"smith"} 

Answer 5

Sie können versuchen, diese zu

>>> names = ['bob', 'jack', 'smith'] 
>>> names.inject([]){|s,p| s << {name: p}} 
=> [{:name=>"bob"}, {:name=>"jack"}, {:name=>"smith"}]