ruby - 使用哈希默认值时出现奇怪的意外行为(消失/更改值)，例如哈希.new([])

Question

考虑这段代码:

h = Hash.new(0)  # New hash pairs will by default have 0 as values
h[1] += 1  #=> {1=>1}
h[2] += 2  #=> {2=>2}

没关系，但是:

h = Hash.new([])  # Empty array as default value
h[1] <<= 1  #=> {1=>[1]}                  ← Ok
h[2] <<= 2  #=> {1=>[1,2], 2=>[1,2]}      ← Why did `1` change?
h[3] << 3   #=> {1=>[1,2,3], 2=>[1,2,3]}  ← Where is `3`?

此时我希望散列为:

{1=>[1], 2=>[2], 3=>[3]}

但远非如此。发生了什么，我怎样才能得到我期望的行为？

Answer 1

首先，请注意，此行为适用于随后发生变化的任何默认值(例如哈希和字符串)，而不仅仅是数组。它也同样适用于 Array.new(3, []) 中的填充元素。 .

TL;DR:使用 Hash.new { |h, k| h[k] = [] }如果您想要最惯用的解决方案并且不在乎为什么。

---

什么不起作用

为什么 Hash.new([])不工作

让我们更深入地了解为什么 Hash.new([])不起作用:

h = Hash.new([])
h[0] << 'a'  #=> ["a"]
h[1] << 'b'  #=> ["a", "b"]
h[1]         #=> ["a", "b"]

h[0].object_id == h[1].object_id  #=> true
h  #=> {}

我们可以看到我们的默认对象正在被重用和变异(这是因为它作为唯一的默认值传递，哈希无法获得新的默认值)，但为什么没有数组中的键或值，尽管 h[1]仍然给我们一个值(value)？这是一个提示:

h[42]  #=> ["a", "b"]

每个[]返回的数组call 只是默认值，我们一直在改变它，所以现在包含我们的新值。自 <<不赋值给散列(在 Ruby 中没有 = 就永远不会赋值 ^†)，我们从来没有把任何东西放入我们的实际散列中。相反，我们必须使用 <<= (它是 <<，因为 += 是 +):

h[2] <<= 'c'  #=> ["a", "b", "c"]
h             #=> {2=>["a", "b", "c"]}

这等同于:

h[2] = (h[2] << 'c')

为什么 Hash.new { [] }不工作

使用 Hash.new { [] }解决了重用和改变原始默认值的问题(因为每次调用给定的 block ，返回一个新数组)，但不是赋值问题:

h = Hash.new { [] }
h[0] << 'a'   #=> ["a"]
h[1] <<= 'b'  #=> ["b"]
h             #=> {1=>["b"]}

---

什么起作用

赋值方式

如果我们记得始终使用 <<= , 然后 Hash.new { [] } 是一个可行的解决方案，但它有点古怪且不合常理(我从未见过 <<= 在野外使用过)。如果<<，它也容易出现细微的错误被无意中使用。

可变方式

documentation for Hash.new 状态(强调我自己的):

If a block is specified, it will be called with the hash object and the key, and should return the default value. It is the block’s responsibility to store the value in the hash if required.

因此，如果我们希望使用 <<，我们必须将默认值存储在 block 内的散列中。而不是 <<= :

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

这有效地将分配从我们的个人调用(将使用 <<= )移动到传递给 Hash.new 的 block ，消除使用时意外行为的负担 << .

请注意，此方法与其他方法之间存在一个功能差异:这种方法在读取时分配默认值(因为分配总是在 block 内发生)。例如:

h1 = Hash.new { |h, k| h[k] = [] }
h1[:x]
h1  #=> {:x=>[]}

h2 = Hash.new { [] }
h2[:x]
h2  #=> {}

不可变方式

你可能想知道为什么 Hash.new([])在 Hash.new(0) 时不起作用工作得很好。关键是 Ruby 中的数值是不可变的，所以我们自然永远不会就地改变它们。如果我们将默认值视为不可变的，我们可以使用 Hash.new([])也很好:

h = Hash.new([].freeze)
h[0] += ['a']  #=> ["a"]
h[1] += ['b']  #=> ["b"]
h[2]           #=> []
h              #=> {0=>["a"], 1=>["b"]}

但是，请注意 ([].freeze + [].freeze).frozen? == false .因此，如果要确保始终保持不变性，则必须注意重新卡住新对象。

---

结论

在所有方式中，我个人更喜欢“不可变方式”——不可变性通常会使事情的推理变得更加简单。毕竟，这是唯一不可能出现隐藏或微妙的意外行为的方法。然而，最常见和惯用的方式是“可变方式”。

最后，散列默认值的这种行为在 Ruby Koans 中有所说明。 .

---

_{^† 这不是严格意义上的，像 instance_variable_set 这样的方法绕过这个，但是它们必须存在用于元编程，因为 = 中的左值不能是动态的。}