blocks|key|497859|text|hash+=+{"apple"+=>+"banana",+"coconut"+=>+"domino"}
Hash[hash.map{+%7Ck,+v%7C+[k.to_sym,+v]+}]
#=>+{:apple=>"banana",+:coconut=>"domino"}|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|497860|@mu太短了:我没有看到“递归”这个词，但如果你坚持(以及对不存在的to_sym的保护，只想提醒一下在Ruby1.8的1.to_sym+==+nil中，使用一些键类型可能会产生误导)：|unstyled|offset|length|style|CODE|497861|hash+=+{"a"+=>+{"b"+=>+"c"},+"d"+=>+"e",+Object.new+=>+"g"}

s2s+=+
++lambda+do+%7Ch%7C+
++++Hash+===+h+?+
++++++Hash[
++++++++h.map+do+%7Ck,+v%7C+
++++++++++[k.respond_to?(:to_sym)+?+k.to_sym+:+k,+s2s[v]]+
++++++++end+
++++++]+:+h+
++end

s2s[hash]+#=>+{:d=>"e",+#<Object:0x100396ee8>=>"g",+:a=>{:b=>"c"}}|497862|entityMap^0|0|Y|6|1N|F|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$B|C]]|$1|D|3|E|5|F|7|P|8|@$G|Q|H|R|I|J]|$G|S|H|T|I|J]]|9|@]|A|$]]|$1|K|3|L|5|6|7|U|8|@]|9|@]|A|$B|C]]|$1|M|3|-4|5|F|7|V|8|@]|9|@]|A|$]]]|N|$]]

<pre><code>hash = {"apple" =&gt; "banana", "coconut" =&gt; "domino"}
Hash[hash.map{ |k, v| [k.to_sym, v] }]
#=&gt; {:apple=&gt;"banana", :coconut=&gt;"domino"}
</code></pre>

@mu is too short: Didn't see word "recursive", but if you insist (along with protection against non-existent <code>to_sym</code>, just want to remind that in Ruby 1.8 <code>1.to_sym == nil</code>, so playing with some key types can be misleading):

<pre><code>hash = {"a" =&gt; {"b" =&gt; "c"}, "d" =&gt; "e", Object.new =&gt; "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] #=&gt; {:d=&gt;"e", #&lt;Object:0x100396ee8&gt;=&gt;"g", :a=&gt;{:b=&gt;"c"}}
</code></pre>

blocks|key|498248|text|如果您使用的是Rails+>=+4，则可以使用：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|498249|hash.deep_symbolize_keys
hash.deep_symbolize_keys!|code-block|syntax|javascript|498250|或|498251|hash.deep_stringify_keys
hash.deep_stringify_keys!|498252|请参阅http://apidock.com/rails/v4.2.1/Hash/deep_symbolize_keys|offset|length|498253|entityMap|0|LINK|mutability|MUTABLE|url|http://apidock.com/rails/v4.2.1/Hash/deep_symbolize_keys^0|0|0|0|0|3|1K|0|0^^$0|@$1|2|3|4|5|6|7|W|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|X|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Y|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|Z|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|10|8|@]|9|@$M|11|N|12|1|13]]|A|$]]|$1|O|3|-4|5|6|7|14|8|@]|9|@]|A|$]]]|P|$Q|$5|R|S|T|A|$U|V]]]]

If you are using Rails >= 4 you can use:

<pre><code>hash.deep_symbolize_keys
hash.deep_symbolize_keys!
</code></pre>

or

<pre><code>hash.deep_stringify_keys
hash.deep_stringify_keys!
</code></pre>

see <a href="http://apidock.com/rails/v4.2.1/Hash/deep_symbolize_keys" rel="noreferrer">http://apidock.com/rails/v4.2.1/Hash/deep_symbolize_keys</a>

blocks|key|498169|text|如果您正在解析JSON，您可以在JSON+docs中添加在解析时符号化键值的选项：|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|498170|hash+=+JSON.parse(json_data,+symbolize_names:+true)|code-block|syntax|javascript|498171|entityMap|0|LINK|mutability|MUTABLE|url|http://www.ruby-doc.org/stdlib-2.1.3/libdoc/json/rdoc/JSON.html#method-i-parse^0|G|9|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@$A|R|B|S|1|T]]|C|$]]|$1|D|3|E|5|F|7|U|8|@]|9|@]|C|$G|H]]|$1|I|3|-4|5|6|7|V|8|@]|9|@]|C|$]]]|J|$K|$5|L|M|N|C|$O|P]]]]

Just in case you are parsing JSON, from the <a href="http://www.ruby-doc.org/stdlib-2.1.3/libdoc/json/rdoc/JSON.html#method-i-parse" rel="nofollow noreferrer">JSON docs</a> you can add the option to symbolize the keys upon parsing:

<pre><code>hash = JSON.parse(json_data, symbolize_names: true)
</code></pre>

blocks|key|713467|text|对于简单的递归情况，Victor+Moroz提供了一个很好的答案，但它不会处理嵌套在嵌套数组中的散列：|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|713468|hash+=+{+"a"+=>+[{+"b"+=>+"c"+}]+}
s2s[hash]+#=>+{:a=>[{"b"=>"c"}]}|code-block|syntax|javascript|713469|如果你需要在哈希表中支持数组中的哈希表，你会想要更像这样的东西：|713470|def+recursive_symbolize_keys(h)
++case+h
++when+Hash
++++Hash[
++++++h.map+do+%7Ck,+v%7C
++++++++[+k.respond_to?(:to_sym)+?+k.to_sym+:+k,+recursive_symbolize_keys(v)+]
++++++end
++++]
++when+Enumerable
++++h.map+{+%7Cv%7C+recursive_symbolize_keys(v)+}
++else
++++h
++end
end|713471|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/users/561382/victor-moroz^0|A|C|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@]|9|@$A|V|B|W|1|X]]|C|$]]|$1|D|3|E|5|F|7|Y|8|@]|9|@]|C|$G|H]]|$1|I|3|J|5|6|7|Z|8|@]|9|@]|C|$]]|$1|K|3|L|5|F|7|10|8|@]|9|@]|C|$G|H]]|$1|M|3|-4|5|6|7|11|8|@]|9|@]|C|$]]]|N|$O|$5|P|Q|R|C|$S|T]]]]

<a href="https://stackoverflow.com/users/561382/victor-moroz">Victor Moroz</a> provided a lovely answer for the simple recursive case, but it won't process hashes that are nested within nested arrays:

<pre><code>hash = { "a" =&gt; [{ "b" =&gt; "c" }] }
s2s[hash] #=&gt; {:a=&gt;[{"b"=&gt;"c"}]}
</code></pre>

If you need to support hashes within arrays within hashes, you'll want something more like this:

<pre><code>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
</code></pre>

blocks|key|497788|text|试试这个：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|497789|hash+=+{"apple"+=>+"banana",+"coconut"+=>+"domino"}
+#+=>+{"apple"=>"banana",+"coconut"=>"domino"}+

hash.tap+do+%7Ch%7C
++h.keys.each+{+%7Ck%7C+h[k.to_sym]+=+h.delete(k)+}
end
+#+=>+{:apple=>"banana",+:coconut=>"domino"}+|code-block|syntax|javascript|497790|这将对键进行迭代，对于每个键，它将删除字符串化键并将其值分配给符号化键。|497791|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

Try this:

<pre><code>hash = {"apple" =&gt; "banana", "coconut" =&gt; "domino"}
 # =&gt; {"apple"=&gt;"banana", "coconut"=&gt;"domino"} 

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

This iterates over the keys, and for each one, it deletes the stringified key and assigns its value to the symbolized key.

blocks|key|498013|text|如果你正在使用Rails+(或者仅仅是主动支持)：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|498014|{+"id"+=>+"123",+"name"+=>+"test"+}.symbolize_keys|code-block|syntax|javascript|498015|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

If you're using Rails (or just Active Support):

<pre><code>{ "id" =&gt; "123", "name" =&gt; "test" }.symbolize_keys
</code></pre>

blocks|key|713710|text|下面是一个比所选答案更快的Ruby一行程序：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|713711|hash+=+{"apple"+=>+"banana",+"coconut"+=>+"domino"}
#=>+{"apple"=>"banana",+"coconut"=>"domino"}

hash.inject({}){%7Ch,(k,v)%7C+h[k.intern]+=+v;+h}
#=>+{:apple=>"banana",+:coconut=>"domino"}|code-block|syntax|javascript|713712|基准测试结果：|713713|n+=+100000

Benchmark.bm+do+%7Cbm%7C
++bm.report+{+n.times+{+hash.inject({}){%7Ch,(k,v)%7C+h[k.intern]+=+v;+h}+}+}
++bm.report+{+n.times+{+Hash[hash.map{+%7Ck,+v%7C+[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)|713714|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

Here's a Ruby one-liner that is faster than the chosen answer:

<pre><code>hash = {"apple" =&gt; "banana", "coconut" =&gt; "domino"}
#=&gt; {"apple"=&gt;"banana", "coconut"=&gt;"domino"}

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

Benchmark results:

<pre><code>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

# =&gt; user system total real
# =&gt; 0.100000 0.000000 0.100000 ( 0.107940)
# =&gt; 0.120000 0.010000 0.130000 ( 0.137966)
</code></pre>

blocks|key|498354|text|从Ruby2.5开始，您可以使用transform_key方法。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|498355|因此在您的情况下，它将是：|498356|h+=+{+"id"+=>+"123",+"name"+=>+"test"+}
h.transform_keys!(&:to_sym)++++++#=>+{:id=>"123",+:name=>"test"}|code-block|syntax|javascript|498357|注意:同样的方法也可以在Ruby+on+Rails上使用。|498358|entityMap|0|LINK|mutability|MUTABLE|url|https://docs.ruby-lang.org/en/trunk/Hash.html#method-i-transform_keys^0|G|D|G|D|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|W|8|@$9|X|A|Y|B|C]]|D|@$9|Z|A|10|1|11]]|E|$]]|$1|F|3|G|5|6|7|12|8|@]|D|@]|E|$]]|$1|H|3|I|5|J|7|13|8|@]|D|@]|E|$K|L]]|$1|M|3|N|5|6|7|14|8|@]|D|@]|E|$]]|$1|O|3|-4|5|6|7|15|8|@]|D|@]|E|$]]]|P|$Q|$5|R|S|T|E|$U|V]]]]

Starting with Ruby 2.5 you can use the <a href="https://docs.ruby-lang.org/en/trunk/Hash.html#method-i-transform_keys" rel="nofollow noreferrer"><code>transform_key</code></a> method. 

So in your case it would be:

<pre><code>h = { "id" =&gt; "123", "name" =&gt; "test" }
h.transform_keys!(&amp;:to_sym) #=&gt; {:id=&gt;"123", :name=&gt;"test"}
</code></pre>

Note: the same methods are also available on Ruby on Rails.

blocks|key|713405|text|我倾向于：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|713406|irb
ruby-1.9.2-p290+:001+>+hash+=+{"apple"+=>+"banana",+"coconut"+=>+"domino"}
{
++++++"apple"+=>+"banana",
++++"coconut"+=>+"domino"
}
ruby-1.9.2-p290+:002+>+hash.inject({}){+%7Ch,+(n,v)%7C+h[n.to_sym]+=+v;+h+}
{
++++++:apple+=>+"banana",
++++:coconut+=>+"domino"
}|code-block|syntax|javascript|713407|这之所以有效，是因为我们迭代了散列并动态地构建了一个新的散列。它不是递归的，但您可以通过查看其他一些答案来了解这一点。|713408|hash.inject({}){+%7Ch,+(n,v)%7C+h[n.to_sym]+=+v;+h+}|713409|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

I'm partial to:

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

This works because we're iterating over the hash and building a new one on the fly. It isn't recursive, but you could figure that out from looking at some of the other answers.

<pre><code>hash.inject({}){ |h, (n,v)| h[n.to_sym] = v; h }
</code></pre>

blocks|key|713633|text|您还可以通过放置/lib/hash.rb文件来扩展核心Hash+ruby类：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|713634|class+Hash
++def+symbolize_keys_deep!
++++new_hash+=+{}
++++keys.each+do+%7Ck%7C
++++++ks++++=+k.respond_to?(:to_sym)+?+k.to_sym+:+k
++++++if+values_at(k).first.kind_of?+Hash+or+values_at(k).first.kind_of?+Array
++++++++new_hash[ks]+=+values_at(k).first.send(:symbolize_keys_deep!)
++++++else
++++++++new_hash[ks]+=+values_at(k).first
++++++end
++++end

++++new_hash
++end
end|code-block|syntax|javascript|713635|如果您希望确保包装到父散列中的数组中的任何散列的键都是符号化的，则还需要扩展数组类，使用该代码创建一个"array.rb“文件：|713636|class+Array
++def+symbolize_keys_deep!
++++new_ar+=+[]
++++self.each+do+%7Cvalue%7C
++++++new_value+=+value
++++++if+value.is_a?+Hash+or+value.is_a?+Array
++++++++new_value+=+value.symbolize_keys_deep!
++++++end
++++++new_ar+<<+new_value
++++end
++++new_ar
++end
end|713637|这允许调用"symbolize_keys_deep!“在任何类似以下的散列变量上：|713638|myhash.symbolize_keys_deep!|713639|entityMap^0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|R|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|S|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|T|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|U|8|@]|9|@]|A|$]]|$1|M|3|N|5|D|7|V|8|@]|9|@]|A|$E|F]]|$1|O|3|-4|5|6|7|W|8|@]|9|@]|A|$]]]|P|$]]

You can also extend core Hash ruby class placing a /lib/hash.rb file :

<pre><code>class Hash
 def symbolize_keys_deep!
 new_hash = {}
 keys.each do |k|
 ks = k.respond_to?(:to_sym) ? k.to_sym : k
 if values_at(k).first.kind_of? Hash or values_at(k).first.kind_of? Array
 new_hash[ks] = values_at(k).first.send(:symbolize_keys_deep!)
 else
 new_hash[ks] = values_at(k).first
 end
 end

 new_hash
 end
end
</code></pre>

If you want to make sure keys of any hash wrapped into arrays inside your parent hash are symbolized, you need to extend also array class creating a "array.rb" file with that code :

<pre><code>class Array
 def symbolize_keys_deep!
 new_ar = []
 self.each do |value|
 new_value = value
 if value.is_a? Hash or value.is_a? Array
 new_value = value.symbolize_keys_deep!
 end
 new_ar &lt;&lt; new_value
 end
 new_ar
 end
end
</code></pre>

This allows to call "symbolize_keys_deep!" on any hash variable like this : 

<pre><code>myhash.symbolize_keys_deep!
</code></pre>

blocks|key|713522|text|def+symbolize_keys(hash)
+++new={}
+++hash.map+do+%7Ckey,value%7C
++++++++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}}}|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|713523|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>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"=&gt;{"a"=&gt;2,"k"=&gt;{"e"=&gt;9}})
#{:c=&gt;{:a=&gt;2, :k=&gt;{:e=&gt;9}}}
</code></pre>

blocks|key|498090|text|这是我的两点意见|type|unstyled|depth|inlineStyleRanges|entityRanges|data|498091|我的symbolize_keys_deep!版本使用了原始的symbolize_keys！它是由rails提供的，只是进行一个简单的递归调用来符号化子哈希表。|offset|length|style|CODE|498092|++def+symbolize_keys_deep!(h)
++++h.symbolize_keys!
++++h.each+do+%7Ck,+v%7C
++++++symbolize_keys_deep!(v)+if+v.is_a?+Hash
++++end
++end|code-block|syntax|javascript|498093|entityMap^0|0|2|K|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|P|8|@$D|Q|E|R|F|G]]|9|@]|A|$]]|$1|H|3|I|5|J|7|S|8|@]|9|@]|A|$K|L]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

Here's my two cents, 

my version of <code>symbolize_keys_deep!</code> uses the original symbolize_keys! provided by rails and just makes a simple recursive call to Symbolize sub hashes.

<pre><code> def symbolize_keys_deep!(h)
 h.symbolize_keys!
 h.each do |k, v|
 symbolize_keys_deep!(v) if v.is_a? Hash
 end
 end
</code></pre>

blocks|key|498285|text|Facets'+Hash#rekey也是值得一提的是。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|498286|示例：|498287|require+'facets/hash/rekey'
{+"id"+=>+"123",+"name"+=>+"test"+}.deep_rekey
=>+{:id=>"123",+:name=>"test"}|code-block|syntax|javascript|498288|还有一个递归版本：|498289|require+'facets/hash/deep_rekey'
{+"id"+=>+"123",+"name"+=>+{"first"+=>+"John",+"last"+=>+"Doe"+}+}.deep_rekey
=>+{:id=>"123",+:name=>{:first=>"John",+:last=>"Doe"}}|498290|entityMap|0|LINK|mutability|MUTABLE|url|http://www.rubydoc.info/github/rubyworks/facets/Hash#rekey-instance_method^0|0|I|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|W|8|@]|9|@$A|X|B|Y|1|Z]]|C|$]]|$1|D|3|E|5|6|7|10|8|@]|9|@]|C|$]]|$1|F|3|G|5|H|7|11|8|@]|9|@]|C|$I|J]]|$1|K|3|L|5|6|7|12|8|@]|9|@]|C|$]]|$1|M|3|N|5|H|7|13|8|@]|9|@]|C|$I|J]]|$1|O|3|-4|5|6|7|14|8|@]|9|@]|C|$]]]|P|$Q|$5|R|S|T|C|$U|V]]]]

<a href="http://www.rubydoc.info/github/rubyworks/facets/Hash#rekey-instance_method" rel="nofollow noreferrer">Facets' Hash#rekey</a> is also a worth mentioning.

Sample:

<pre><code>require 'facets/hash/rekey'
{ "id" =&gt; "123", "name" =&gt; "test" }.deep_rekey
=&gt; {:id=&gt;"123", :name=&gt;"test"}
</code></pre>

There is also a recursive version:

<pre><code>require 'facets/hash/deep_rekey'
{ "id" =&gt; "123", "name" =&gt; {"first" =&gt; "John", "last" =&gt; "Doe" } }.deep_rekey
=&gt; {:id=&gt;"123", :name=&gt;{:first=&gt;"John", :last=&gt;"Doe"}}
</code></pre>

blocks|key|713682|text|下面是一个小的递归函数，用于对键进行深度符号化：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|713683|def+symbolize_keys(hash)
++Hash[hash.map{%7Ck,v%7C+v.is_a?(Hash)+?+[k.to_sym,+symbolize_keys(v)]+:+[k.to_sym,+v]+}]
end|code-block|syntax|javascript|713684|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Here's a little recursive function to do a deep symbolization of the keys:

<pre><code>def symbolize_keys(hash)
 Hash[hash.map{|k,v| v.is_a?(Hash) ? [k.to_sym, symbolize_keys(v)] : [k.to_sym, v] }]
end
</code></pre>

I have a Ruby hash which looks like:

<pre><code>{ "id" =&gt; "123", "name" =&gt; "test" }
</code></pre>

I would like to convert it to:

<pre><code>{ :id =&gt; "123", :name =&gt; "test" }
</code></pre>

How do I convert a Ruby hash so that all of its keys are symbols?

JSON

我有一个Ruby散列，它看起来像这样：{ "id" => "123", "name" => "test" }我想将其转换为：{ :id => "123", :name => "test" }

问如何转换Ruby散列，使其所有键都是符号？
EN

回答 14

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问如何转换Ruby散列，使其所有键都是符号？EN

回答 14

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问如何转换Ruby散列，使其所有键都是符号？
EN