Why does shoveling a string into a hash cause this result? [duplicate]

Answer 1

A hint as to the reason is in the name of the tests.

test_default_value_is_the_same_object is there to show you that when you ask for hash[:some_value_that_doesnt_exist_yet], by default, you get back the default value you specified -- which is the same object every time. By modifying that object, you modify it for every nonexistent key. Modifying hash[:one] also modifies hash[:two].

test_default_value_with_block shows the construction of a Hash using a block, which will be used to provide a new value for each key. When you do it like that, the values for hash[:one] and hash[:two] are distinct.

Answer 2

You have created a new Hash with an Array as an accumulator when the key is not present so

hash = Hash.new([]) 
hash[:one] << "uno" 
hash[:one] == ["uno"] #=> true

but

hash[:two] << "dos" 
(hash[:one] == hash[:two]) && (hash[:two] == ["uno","dos"]) #=> true
hash[:three] == ["uno","dos"] #=> true

because ["uno","dos"] is the original array created with the Hash and hash[:non_existant_key] points to it.

Note: no keys have actually been added to hash in this case. It would be similar to

 a = []
 hash = {}
 hash.fetch(:one,a) << 'uno'
 hash.fetch(:two,a) << 'dos'
 hash.fetch(:three, a) 
 #=> ['uno','dos']
 hash
 #=> {}

To solve this you can use this syntax as mentioned in your second test

hash = Hash.new {|h,k| h[k] = [] } 

This means fro every new key instantiate a new Array as its value rather than reusing the same Array over and over again

This is the problem with the Hash.new(obj) syntax when obj is a mutable object