Pushing Hash onto Array: last Hash overwriting previous array elements - arrays

Question

I have the following Ruby script:
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
This returns an array of hashes, whose :name keys are all from the last element.
[
[0] {
:name => "smith"
},
[1] {
:name => "smith"
},
[2] {
:name => "smith"
}
]
I would expect it to return the following, but I'm stuck trying to figure out why the last Hash element is overwriting all previous array elements:
[
[0] {
:name => "bob"
},
[1] {
:name => "jack"
},
[2] {
:name => "smith"
}
]
EDIT: Thank you all for your answers. It's nice to have some different methods laid out of accomplishing the same thing. I've tested each solution and each one is great. I ended up using the one which was most similar to my original code; but my use case is a simple, local script - it's not being used in an industrial-sized app - in which case, I would probably choose a different solution.

Answer 1

Look at your code carefully, you'll see that you've only created a single instance of Hash. Your iterator keeps blowing away earlier efforts with .clear, setting the element to the current iterate, and adding the reference to that one Hash object to different array locations in array_of_hashes. But at the end of the day, they all point to the same Hash object, and that Hash object contains only the last thing you put into it.

Answer 2

Take note of (and understand) the answer by #pjs and the comment by #tadman as they explain why you are getting the results you are getting.
I would actually instead do something like:
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"}]
Some notes:
The Array#collect method will return an array, so you don't need to manually add to an array you've initialized your self.
You can just return a new Hash for each item which will be returned in the collect block

Answer 3

You should try something like
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
with a new instance being pushed into the array for every new item.

Answer 4

I would write
[:name].product(arr).map { |pair| Hash[[pair]] }
#=> [{:name=>"bob"}, {:name=>"jack"}, {:name=>"smith"}]
or (for Ruby v2.0+)
[:name].product(arr).map { |pair| [pair].to_h }
The steps:
a = [:name].product(arr)
#=> [[:name, "bob"], [:name, "jack"], [:name, "smith"]]
enum = a.map
# => #<Enumerator: [[:name, "bob"], [:name, "jack"], [:name, "smith"]]:map>
Note that by sending the method Enumerator#each to enum we obtain the desired result:
enum.each { |pair| [pair].to_h }
#=> [{:name=>"bob"}, {:name=>"jack"}, {:name=>"smith"}]
(Enumerator#each will invoke Array#each because a.class #=> Array.)
Enumerator#each sets the block variable to the first element of enum:
pair = enum.next
#=> [:name, "bob"]
and the block calculation is performed:
[pair].to_h
#=> [[:name, "bob"]].to_h
#=> {:name=>"bob"}
Next, the second element of enum, [:name, "jack"], is mapped to:
pair = enum.next
#=> [:name, "jack"]
[pair].to_h
#=> [[:name, "jack"]].to_h
#=> {:name=>"jack"}
Lastly,
pair = enum.next
#=> [:name, "smith"]
[pair].to_h
#=> [[:name, "smith"]].to_h
#=> {:name=>"smith"}

Answer 5

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