Comment puis-je convertir un Rubis de hachage, de sorte que l'ensemble de ses touches sont des symboles?

Si vous arrive d'être dans les Rails, alors vous aurez symbolize_keys:

Retour une nouvelle table de hachage avec toutes les clés convertis en symboles, tant qu'ils répondent à to_sym.

et symbolize_keys! qui fait la même chose, mais opère en place. Donc, si vous êtes dans les Rails, vous pouvez:

hash.symbolize_keys!

Si vous souhaitez de manière récursive symbolisent intérieure hachages alors je pense que vous avez à faire vous-même, mais avec quelque chose comme ceci:

def symbolize_keys_deep!(h)
  h.keys.each do |k|
    ks    = k.to_sym
    h[ks] = h.delete k
    symbolize_keys_deep! h[ks] if h[ks].kind_of? Hash
  end
end

Vous pourriez vouloir jouer avec le kind_of? Hash pour correspondre à votre situation spécifique; l'utilisation de respond_to? :keys pourrait faire plus de sens. Et si vous souhaitez autoriser pour les touches qui ne comprennent pas to_sym, puis:

def symbolize_keys_deep!(h)
  h.keys.each do |k|
    ks    = k.respond_to?(:to_sym) ? k.to_sym : k
    h[ks] = h.delete k # Preserve order even when k == ks
    symbolize_keys_deep! h[ks] if h[ks].kind_of? Hash
  end
end

Noter que h[ks] = h.delete k ne change pas le contenu de la table de Hachage lors de k == ks mais il permettra de préserver l'ordre lorsque vous êtes à l'aide de Ruby 1.9+. Vous pouvez également utiliser la [(key.to_sym rescue key) || key] approche Rails utilise dans leur symbolize_keys! mais je pense que c'est un abus du système de gestion des exceptions.

La deuxième symbolize_keys_deep! transforme ce:

{ 'a' => 'b', 'c' => { 'd' => { 'e' => 'f' }, 'g' => 'h' }, ['i'] => 'j' }

dans cette:

{ :a => 'b', :c => { :d => { :e => 'f' }, :g => 'h' }, ['i'] => 'j' }

Vous pourriez monkey patch soit la version de symbolize_keys_deep! dans Hachage si tu le voulais vraiment, mais j'ai généralement de rester loin de monkey patching, à moins que j'ai de très bonnes raisons de le faire.

Juste au cas où vous êtes parsing JSON, de la json docs vous pouvez ajouter l'option pour symboliser les clés lors de l'analyse:

hash = JSON.parse(json_data, symbolize_names: true)

Essayez ceci:

hash = {"apple" => "banana", "coconut" => "domino"}
 # => {"apple"=>"banana", "coconut"=>"domino"} 

hash.tap do |h|
  h.keys.each { |k| h[k.to_sym] = h.delete(k) }
end
 # => {:apple=>"banana", :coconut=>"domino"} 

Ce itère sur les touches, et pour chacun, il supprime le stringified touche et affecte sa valeur à la symbolisé clé.

Ruby one-liner qui est plus rapide que la réponse choisie

hash = {"apple" => "banana", "coconut" => "domino"}
#=> {"apple"=>"banana", "coconut"=>"domino"}

hash.inject({}){|h,(k,v)| h[k.intern] = v; h}
#=> {:apple=>"banana", :coconut=>"domino"}

Les résultats d'un Benchmark

n = 100000

Benchmark.bm do |bm|
  bm.report { n.times { hash.inject({}){|h,(k,v)| h[k.intern] = v; h} } }
  bm.report { n.times { Hash[hash.map{ |k, v| [k.to_sym, v] }] } }
end

# =>       user     system      total        real
# =>   0.100000   0.000000   0.100000 (  0.107940)
# =>   0.120000   0.010000   0.130000 (  0.137966)

Je suis partie à l':

irb
ruby-1.9.2-p290 :001 > hash = {"apple" => "banana", "coconut" => "domino"}
{
      "apple" => "banana",
    "coconut" => "domino"
}
ruby-1.9.2-p290 :002 > hash.inject({}){ |h, (n,v)| h[n.to_sym] = v; h }
{
      :apple => "banana",
    :coconut => "domino"
}

Cela fonctionne parce que nous sommes une itération sur les valeurs de hachage et en construire un nouveau à la volée. Il n'est pas récursive, mais vous pouvez comprendre cela de regarder quelques-unes des autres réponses.

hash.inject({}){ |h, (n,v)| h[n.to_sym] = v; h }

def symbolize_keys(hash)
   new={}
   hash.map do |key,value|
        if value.is_a?(Hash)
          value = symbolize_keys(value) 
        end
        new[key.to_sym]=value
   end        
   return new

end  
puts symbolize_keys("c"=>{"a"=>2,"k"=>{"e"=>9}})
#{:c=>{:a=>2, :k=>{:e=>9}}}

Facettes' Hash#remise à la clé est également digne de mention.

Exemple:

require 'facets/hash/rekey'
{ "id" => "123", "name" => "test" }.deep_rekey
=> {:id=>"123", :name=>"test"}

Il y a aussi une version récursive:

require 'facets/hash/deep_rekey'
{ "id" => "123", "name" => {"first" => "John", "last" => "Doe" } }.deep_rekey
=> {:id=>"123", :name=>{:first=>"John", :last=>"Doe"}}