Ruby Hash是否保留一个单独的读取值列表与指定的值？

Question

这与Ruby hash default value behavior

有关

但也许那里的解释不包括这一部分：看来Ruby的Hash默认值是独立的，无论你是“读它”，还是看“设置什么”？

一个例子是：

foo = Hash.new([])

foo[123].push("hi")

p foo       # => {}
p foo[123]  # => ["hi"]
p foo       # => {}

foo[123]如何有一个值，但是foo都是空的，有点超出我的理解......我能理解的唯一方法是Ruby Hash保留一个单独的列表“读”或“吸气”，但不知何故，“内部”指定值是不同的。

如果Ruby的设计原则之一是“给程序员带来最少的惊喜”，那么foo是空的，但foo[123]是某种东西，在某种程度上是这样的，对于我

（实际上我还没有看到其他语言...如果有其他语言有类似行为的情况，也许更容易建立联系。）

Answer 1

假设`

h = Hash.new(:cat)
h[:a] = 1
h[:b] = 2
h #=> {:a=>1, :b=>2}

现在

h[:a] #=> 1
h[:b] #=> 2
h[:c] #=> :cat
h[:d] #=> :cat
h     #=> {:a=>1, :b=>2}

h = Hash.new(:cat)使用h的默认值定义空哈希:cat。这意味着，如果h没有密钥k，则h[k]将返回:cat，仅返回。如上所示，当h[k]为k或:c时，执行:d不会更改哈希值。

另一方面，

h[:c] = h[:c]
  #=> :c
h #=> {:a=>1, :b=>2, :c=>:cat}

困惑？让我在没有语法糖的情况下写这个：

h.[]=(:d, h.[](:d))
  #=> :cat
h #=> {:a=>1, :b=>2, :d=>:cat}

默认值由h.[](:d)返回（即h[:d]），而Hash#[]=是一个赋值方法（带有两个参数，一个键和一个值），默认值为不适用。

此默认设置的常见用法是创建计算哈希：

a = [1,3,1,4,2,5,4,4]
h = Hash.new(0)
a.each { |x| h[x] = h[x] + 1 }
h #=> {1=>2, 3=>1, 4=>3, 2=>1, 5=>1}

最初，当h为空且x #=> 1时，h[1] = h[1] + 1将评估为h[1] = 0 + 1，因为（因为h没有密钥1 ）等式右侧的h[1]设置为等于默认值零。下次1传递给块x #=> 1），x[1] = x[1] + 1，等于x[1] = 1 + 1。这次没有使用默认值，因为h现在有一个键1。

通常会写（顺便说一句）：

a.each_with_object(Hash.new(0)) { |x,h| h[x] += 1 }
  #=> {1=>2, 3=>1, 4=>3, 2=>1, 5=>1}

通常不希望默认值是集合，例如数组或散列。请考虑以下事项：

h = Hash.new([])
[1,2,3].map { |n| h[n] = h[n] }
h #=> {1=>[], 2=>[], 3=>[]}

现在观察：

h[1] << 2
h #=> {1=>[2], 2=>[2], 3=>[2]}

这通常不是理想的行为。它发生了，因为

h.map { |k,v| v.object_id }
  #=> [25886508, 25886508, 25886508]

也就是说，所有值都是同一个对象，因此如果更改了一个键的值，则所有其他键的值也会更改。

解决这个问题的方法是在定义哈希时使用块：

h = Hash.new { |h,k| h[k]=[] }
[1,2,3].each { |n| h[n] = h[n] }
h #=> {1=>[], 2=>[], 3=>[]}
h[1] << 2
h #=> {1=>[2], 2=>[], 3=>[]}
h.map { |k,v| v.object_id }
  #=> [24172884, 24172872, 24172848]

当散列h没有键k时，块{ |h,k| h[k]=[] }被执行并返回一个特定于该键的空数组。

Answer 2

声明：

foo = Hash.new([])

creates a new Hash，其数组为空（[]为默认值）。默认值是Hash::[]在其参数不是散列中存在的键时返回的值。

声明：

foo[123]

调用Hash::[]，因为哈希是空的（哈希中不存在键123），它返回对默认值的引用，该默认值是{{3}类型的对象}。 上面的语句不会在哈希中创建123键。

Ruby对象总是通过引用传递和返回。这意味着上面的语句不会返回散列的默认值的副本，而是返回对它的引用。

声明：

foo[123].push("hi")

修改上面提到的数组。现在，foo哈希的默认值不再是空数组;它是数组["hi"]。但是仍然是空的;以上所有语句都没有添加一些（键，值）对。

  

foo [123]如何具有值

foo[123]没有任何值，哈希中不存在键123（哈希为空）。随后对foo[123]的调用会再次返回对默认值的引用，现在返回默认值["hi"]。对foo[456]或foo['abc']的调用也会返回对相同默认值的引用。

Answer 3

您实际上并未更改密钥123的值，您只是访问初始化期间提供的默认值[]。如果您检查foo[0]等其他值，则可以确认这一点。

如果你这样做：

foo[123] = ["hi"]

您可以看到新条目，因为您已在密钥123下创建了一个新数组。

修改的

• 当您致电foo[123].push("hi")时，您改变（默认）值，而不是添加新条目。

• 调用foo[123] += ["hi"] 会在给定密钥下创建一个新数组，替换之前存在的数组，这将显示您想要的行为。

Answer 4

打印哈希：

p foo

仅打印存储在哈希中的值。它不显示默认值（或添加到默认数组的任何内容）。

执行时：

p foo[123]

因为123不存在，所以它访问默认值。

如果您将两个值添加到默认值：

foo[123].push("hi")
foo[456].push("hello")

您的输出将是：

p foo       # => {}
p foo[123]  # => ["hi","hello"]
p foo       # => {}

这里，poo [123]再次不存在，所以它打印出默认值的内容。