Установка рубинового хэша .default в список

Hash.default используется для установки значения по умолчанию вернулся, когда вы запрашиваете ключ, который не существует. Запись в коллекции не создается для вас только потому, что ее запросили.

Кроме того, значение, которое вы установили для default, является экземпляром объекта (в вашем случае - массивом), поэтому, когда он возвращается, им можно управлять.

a = {}
a.default = []     # set default to a new empty Array
a[8] << 9          # a[8] doesn't exist, so the Array instance is returned, and 9 appended to it
a.default          # => [9]
a[9]               # a[9] doesn't exist, so default is returned

irb(main):002:0> a.default = []
=> []
irb(main):003:0> a[8] << 9
=> [9]                          # great!

С помощью этого оператора вы изменили значение по умолчанию; вы не создали новый массив и не добавили «9». На этом этапе это идентично тому, если бы вы сделали это вместо этого:

irb(main):002:0> a.default = [9]
=> [9]

Поэтому неудивительно, что теперь вы получаете это:

irb(main):006:0> a[9]
=> [9]                          # unawesome! shouldn't this be [] ??

Кроме того, «<<» добавляет к массиву цифру «9»; он не добавил его в хеш, что объясняет это:

irb(main):004:0> a
=> {}                           # ?! would have expected {8=>[9]}

Вместо использования .default вы, вероятно, захотите сделать в своей программе что-то вроде этого:

# Time to add a new entry to the hash table; this might be 
# the first entry for this key..
myhash[key] ||= []
myhash[key] << value

Это очень полезная идиома:

(myhash[key] ||= []) << value

Он даже может быть вложенным:

((myhash[key1] ||= {})[key2] ||= []) << value

Другой способ - сделать:

myhash = Hash.new {|hash,key| hash[key] = []}

Но у этого есть значительный побочный эффект, заключающийся в том, что спрашивая о ключе создаст его, который отображает has_key? довольно бесполезно, поэтому я избегаю этого метода.

Я не уверен, что это то, что вы хотите, но вы можете сделать это, чтобы всегда возвращать пустой массив при запросе отсутствующего хеш-ключа.

h = Hash.new { [] }
h[:missing]
   => []

#But, you should never modify the empty array because it isn't stored anywhere
#A new, empty array is returned every time
h[:missing] << 'entry'
h[:missing]
   => []

Я думаю, что это именно то поведение, которое вы ищете. Это автоматически инициализирует любые новые ключи в хэше массивом:

irb(main):001:0> h = Hash.new{|h, k| h[k] = []}
=> {}
irb(main):002:0> h[1] << "ABC"
=> ["ABC"]
irb(main):003:0> h[3]
=> []
irb(main):004:0> h
=> {1=>["ABC"], 3=>[]}

Гленн Макдональд говорит:

"Другой способ:

myhash = Hash.new {| хеш, ключ | хэш [ключ] = []}

Но у этого есть существенный побочный эффект: запрос о ключе создаст его, который отображает has_key? довольно бесполезно, поэтому я избегаю этого метода ".

на самом деле это не кажется правдой.

irb(main):004:0> a = Hash.new {|hash,key| hash[key] = []}
=> {}
irb(main):005:0> a.has_key?(:key)
=> false
irb(main):006:0> a[:key]
=> []
irb(main):007:0> a.has_key?(:key)
=> true

Доступ ключ создаст его, как я и ожидал. Просто спросите has_key? не.

Если вы действительно хотите иметь бесконечно глубокий хеш:

endless = Hash.new { |h, k| h[k] = Hash.new(&h.default_proc) }
endless["deep"]["in"]["here"] = "hello"

Конечно, как указывает Гленн выше, если вы это сделаете, has_key? теряет смысл, так как всегда будет возвращать истину. Спасибо jbarnette за это.