8

I was adding items to a Hash key. I was expecting to get a structure like this:

{ 
  'a' : [1],
  'b' : [2, 3, 4]
}

I used an Array to initialize the Hash.

irb> hash = Hash.new([])
 => {}

Then started using it:

irb> hash['a'] << 1
 => [1] 
irb> hash['b'] << 2
 => [1, 2]

But it turns out:

irb> hash
 => {}
Cheng
  • 4,816
  • 4
  • 41
  • 44
  • Are you unsure about the output you are seeing? Or what the Hash actually contains? It is unclear what you are looking for here. – jmccarthy Mar 30 '11 at 16:03

4 Answers4

11

Try the following instead:

hash = Hash.new{|h, k| h[k] = []}
hash['a'] << 1 # => [1]
hash['b'] << 2 # => [2]

The reason you got your unexpected results is that you specified an empty array as default value, but the same array is used; no copy is done. The right way is to initialize the value with a new empty array, as in my code.

Marc-André Lafortune
  • 78,216
  • 16
  • 166
  • 166
  • +1 "you specified an empty array as default value, but the same array is used". Bingo! – the Tin Man Mar 30 '11 at 19:14
  • What?! This is really strange to me. When you use a string that string is not being re-used. The string might be some sort of value type, but I thought "everything" was an object in Ruby. Why the difference between strings and other objects? – Automatico Dec 10 '13 at 23:05
  • @Cort3z: Not sure what you mean. Maybe this can help show there is no difference: `a = b = 'foo'; a.replace 'bar'; b # => 'bar'` – Marc-André Lafortune Dec 11 '13 at 02:56
  • Maybe I was unclear: What I meant was that I think it is strange that when you do `Hash.new([])` it uses the same array object, but when you do `Hash.new("string")` it does not use the same string. – Automatico Dec 11 '13 at 11:47
  • @Cort3z: It will use the same string. `h = Hash.new("don't do this"); h[0].upcase!; h[1] # => "DON'T DO THIS"` – Marc-André Lafortune Dec 11 '13 at 19:41
  • @Marc-AndréLafortune Now I see what is going on. I was doing `h = Hash.new("W"); h["test"] = "data"; p h["a"] #=> "W"`. I guess it reassigns the object for `h["test"]` only, and not actually change the object. – Automatico Dec 11 '13 at 21:41
4

The constructor you used stores [] as the default value to return when accessing keys that are unknown. Since Array#<< modifies its receiver in place this initially empty array grows.

To explain in more detail:

When you do hash['a'] << 1 this is what happens:

  1. hash looks to see if there is a key named 'a'
  2. It finds that no, there is no such key.
  3. It looks if it has stored a default value to return.
  4. Since you constructed it with Hash.new([]) it does have such a value, [] and it returns that.
  5. Now [] << 1 is evaluated and this means that hash now stores [1] as the value to return when a previously unencountered key is requested.

If what you want is to store the key value pair instead use the third form of the constructor with a block:

hash = Hash.new{|h, key| h[key] = []}
Jakub Hampl
  • 39,863
  • 10
  • 77
  • 106
2

hash['a'] << 1 and hash['b'] << 2 isn't correct syntax for creating a key/value pair. You have to use = for that:

hash['a'] = []
hash['a'] << 1

hash['b'] = []
hash['b'] << 2

That should give you the hash {'a' : [1], 'b' : [2]}

McStretch
  • 20,495
  • 2
  • 35
  • 40
1

This is exactly the behavior that you would expect to see.

You never add anything to the Hash, therefore the Hash is completely empty. When you look up a key, that key will never exist, therefore it returns the default value, which you have specified to be an Array.

So, you look up the key 'a', which doesn't exist, and thus returns the Array you specified as the default value. Then, you call << on that Array, which appends a value (1) to it.

Next, you look up the key 'b', which also doesn't exist, and thus returns the Array you specified as the default value, which now contains the element 1 you added earlier. Then, you call << on that Array, appending the value 2 to it.

You end up with a Hash that is still empty, since you never added anything to it. The default value of the Hash is now an array containing the values 1 and 2.

The output you are seeing is because IRb always prints the result of the last expression that was evaluated. The last expression in your example is calling << on the Array. << returns its receiver, which then is the return value of the entire expression and thus what IRb prints out.

Jörg W Mittag
  • 363,080
  • 75
  • 446
  • 653