L'initialisation de hachages

J'ai souvent écrire quelque chose comme ceci:

a_hash['x'] ? a_hash['x'] += ' some more text' : a_hash['x'] = 'first text'

Il devrait y avoir une meilleure façon de faire cela, mais je ne le trouve pas.

OriginalL'auteur Paul | 2010-06-07

  1. 28

    Il y a deux façons de créer des valeurs initiales pour une Hash.

    L'une est de faire passer un objet unique à Hash.new. Cela fonctionne bien dans de nombreuses situations, en particulier si l'objet est une valeur figée, mais si l'objet a un état interne, ce qui peut avoir des effets secondaires inattendus. Depuis le même objet est partagé entre tous clés sans valeur attribuée à l', la modification de l'état interne de l'un s'affichera dans tous les.

    a_hash = Hash.new "initial value"
a_hash['a'] #=> "initial value"
# op= methods don't modify internal state (usually), since they assign a new
# value for the key.
a_hash['b'] += ' owned by b' #=> "initial value owned by b"
# other methods, like #<< and #gsub modify the state of the string
a_hash['c'].gsub!(/initial/, "c's")
a_hash['d'] << " modified by d"
a_hash['e'] #=> "c's value modified by d"

    Une autre méthode d'initialisation est de passer Hash.new un bloc, qui est appelée à chaque fois qu'une valeur est requise pour une clé qui n'a pas de valeur. Cela vous permet d'utiliser une valeur distincte pour chaque touche. 

    another_hash = Hash.new { "new initial value" }
another_hash['a'] #=> "new initial value" 
# op= methods still work as expected
another_hash['b'] += ' owned by b'
# however, if you don't assign the modified value, it's lost,
# since the hash rechecks the block every time an unassigned key's value is asked for
another_hash['c'] << " owned by c" #=> "new initial value owned by c"
another_hash['c'] #=> "new initial value"

    Le bloc est passé de deux arguments: le hachage être demandé pour une valeur, et la clé utilisée. Cela vous donne la possibilité d'assigner une valeur pour la clé, de sorte que le même objet sera présenté à chaque fois une touche particulière est donnée.

    yet_another_hash = Hash.new { |hash, key| hash[key] = "#{key}'s initial value" }
yet_another_hash['a'] #=> "a's initial value"
yet_another_hash['b'] #=> "b's initial value"
yet_another_hash['c'].gsub!('initial', 'awesome')
yet_another_hash['c'] #=> "c's awesome value"
yet_another_hash #=> { "a" => "a's initial value", "b" => "b's initial value", "c" => "c's awesome value" }

    Cette dernière méthode est celle que j'ai utiliser le plus souvent. Il est également utile pour la mise en cache le résultat d'un calcul fastidieux.

    initialiser avec un bloc est celui que je vais commencer à l'utiliser. Bon!
    il serait bien de mentionner que le dernier cas, l'aide d'un bloc, peut également être utilisé pour définir une valeur par défaut lors de la récupération d'une valeur avec la valeur de Hachage#méthode de récupération, car de nombreuses fois, vous pouvez recevoir une valeur de Hachage qui a été créé ailleurs.
    Ne pas savoir sur Hash#fetch, merci! Intéressant de noter que le bloc transmis à #fetch est un peu différent, il n'est pas obtenir la table de hachage en tant que paramètre au cours d'une miss.

    OriginalL'auteur rampion

  2. 5

    Vous pouvez spécifier la valeur initiale lorsque vous créez votre hash:

    a_hash = { 'x' => 'first text' }
// ...
a_hash['x'] << ' some more text'

    OriginalL'auteur Daniel Vandersluis

  3. 1

    Puisque vous êtes à l'aide de la table de hachage pour recueillir des cordes, je suppose que vous voulez simplement vous assurer que vous n'obtenez pas une erreur lors de l'ajout. Donc, je ferais le hachage par défaut la chaîne vide. Ensuite, vous pouvez ajouter sans erreur, peu importe la clé de hachage.

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

texts = ['first text', ' some more text']

texts.each do |text|
  a_hash['x'] << text
end

puts a_hash['x'] #=> 'first text some more text'
    vous êtes correct. La forme du bloc de Hachage.nouveau glissé mon esprit. Corrigés.

    OriginalL'auteur Mark Thomas

  4. 0

    Le constructeur de Hachage, dans son premier argument, ont une valeur par défaut pour les clés. De cette façon,

    >> a_hash = Hash.new "first text"
=> {}
>> a_hash['a']
=> "first text"
>> a_hash['b'] += ", edit"
=> "first text, edit"
    Ce danger est que le objet string est utilisé pour toutes les touches. Donc modicications à cette chaîne sera vu à travers eux tous. C'est si nous utilisons << : a_hash['c'] << " by c" #=> "first text by c", puis a_hash['d'] #=> "first text by c"
    Cela devient à ce que je veux faire si j'initialise a_hash w/ une chaîne vide: a_hash = Hash.de nouveaux "le", alors je peux ajouter un texte arbitraire arbitraire touches à l'aide de +=

    OriginalL'auteur pablorc

  5. 0

    Dans le cas où vous ne voulez pas salir avec le default= valeur (hash), vous pouvez raccourcir votre code à l'aide de fetch(key [, default]) comme avec une valeur par défaut:

    a_hash['x'] = a_hash.fetch('x', 'first_text') + ' some more text'

    OriginalL'auteur Christopher Oezbek