Comment convertir un hachage Ruby pour que toutes ses clés soient des symboles ?

Question

J'ai un hachage Ruby qui ressemble à:

 { "id" => "123", "name" => "test" }

Je voudrais le convertir en :

 { :id => "123", :name => "test" }

Answer 1

hash = {"apple" => "banana", "coconut" => "domino"}
Hash[hash.map{ |k, v| [k.to_sym, v] }]
#=> {:apple=>"banana", :coconut=>"domino"}

@mu est trop court : je n'ai pas vu le mot "récursif", mais si vous insistez (avec une protection contre les to_sym inexistants, je veux juste rappeler que dans Ruby 1.8 1.to_sym == nil , donc jouer avec certains types de touches peut être trompeur) :

 hash = {"a" => {"b" => "c"}, "d" => "e", Object.new => "g"}

s2s = 
  lambda do |h| 
    Hash === h ? 
      Hash[
        h.map do |k, v| 
          [k.respond_to?(:to_sym) ? k.to_sym : k, s2s[v]] 
        end 
      ] : h 
  end

s2s[hash] #=> {:d=>"e", #<Object:0x100396ee8>=>"g", :a=>{:b=>"c"}}

Answer 2

Si vous utilisez Rails >= 4, vous pouvez utiliser :

 hash.deep_symbolize_keys
hash.deep_symbolize_keys!

ou

 hash.deep_stringify_keys
hash.deep_stringify_keys!

voir http://apidock.com/rails/v4.2.1/Hash/deep_symbolize_keys

Answer 3

Juste au cas où vous analysez JSON, à partir de la documentation JSON, vous pouvez ajouter l'option pour symboliser les clés lors de l'analyse :

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

Answer 4

Victor Moroz a fourni une belle réponse pour le cas récursif simple, mais il ne traitera pas les hachages imbriqués dans des tableaux imbriqués :

 hash = { "a" => [{ "b" => "c" }] }
s2s[hash] #=> {:a=>[{"b"=>"c"}]}

Si vous devez prendre en charge les hachages dans les tableaux au sein des hachages, vous voudrez quelque chose comme ceci :

 def recursive_symbolize_keys(h)
  case h
  when Hash
    Hash[
      h.map do |k, v|
        [ k.respond_to?(:to_sym) ? k.to_sym : k, recursive_symbolize_keys(v) ]
      end
    ]
  when Enumerable
    h.map { |v| recursive_symbolize_keys(v) }
  else
    h
  end
end