我有一个Ruby散列,看起来像:
{ "id" => "123", "name" => "test" }
我想把它转换成:
{ :id => "123", :name => "test" }
hash = {"apple" => "banana", "coconut" => "domino"}
Hash[hash.map{ |k, v| [k.to_sym, v] }]
#=> {:apple=>"banana", :coconut=>"domino"}
@mu太短:没有看到"递归"这个词,但是如果你坚持(以及对不存在的to_sym
的保护,只是想提醒在Ruby 1.8 1.to_sym == nil
中,所以玩一些键类型可能会误导):
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"}}
如果你碰巧在Rails中,那么你将有symbolize_keys
:
返回一个新的散列,其中所有键都转换为符号,只要它们响应
to_sym
。
和symbolize_keys!
,它们做同样的事情,但在原地操作。如果你在Rails中,你可以:
hash.symbolize_keys!
如果你想递归地表示内部哈希那么我认为你必须自己做,但是像这样:
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
你可能想玩kind_of? Hash
来匹配你的具体情况;使用respond_to? :keys
可能更有意义。如果您想允许不理解to_sym
的键,则:
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
注意h[ks] = h.delete k
不会在k == ks
的时候改变哈希的内容,但是当你使用Ruby 1.9+时,它会保留哈希的顺序。你也可以使用Rails在symbolize_keys!
中使用的[(key.to_sym rescue key) || key]
方法,但我认为这是对异常处理系统的滥用。
第二个symbolize_keys_deep!
转过来:
{ 'a' => 'b', 'c' => { 'd' => { 'e' => 'f' }, 'g' => 'h' }, ['i'] => 'j' }
这:
{ :a => 'b', :c => { :d => { :e => 'f' }, :g => 'h' }, ['i'] => 'j' }
如果你真的想的话,你可以给symbolize_keys_deep!
的任何一个版本打猴式补丁,但我通常不会打猴式补丁,除非我有很好的理由这么做。
如果你正在使用Rails>= 4,你可以使用:
hash.deep_symbolize_keys
hash.deep_symbolize_keys!
或
hash.deep_stringify_keys
hash.deep_stringify_keys!
见http://apidock.com/rails/v4.2.1/Hash/deep_symbolize_keys
如果您正在解析JSON,您可以从JSON文档中添加选项,以便在解析时将键符号化:
hash = JSON.parse(json_data, symbolize_names: true)
Victor Moroz为简单的递归情况提供了一个可爱的答案,但它不会处理嵌套数组内嵌套的哈希值:
hash = { "a" => [{ "b" => "c" }] }
s2s[hash] #=> {:a=>[{"b"=>"c"}]}
如果你需要在数组中支持哈希,你需要这样做:
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
试试这个:
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"}
这遍历键,对于每个键,它删除字符串化键并将其值赋给符号化键。
如果你正在使用Rails(或者只是Active Support):
{ "id" => "123", "name" => "test" }.symbolize_keys
从Ruby 2.5开始,可以使用transform_key
方法。
在你的例子中应该是:
h = { "id" => "123", "name" => "test" }
h.transform_keys!(&:to_sym) #=> {:id=>"123", :name=>"test"}
注意:同样的方法也可以在Ruby on Rails上使用。
下面是比选择的答案更快的Ruby一行代码:
hash = {"apple" => "banana", "coconut" => "domino"}
#=> {"apple"=>"banana", "coconut"=>"domino"}
hash.inject({}){|h,(k,v)| h[k.intern] = v; h}
#=> {:apple=>"banana", :coconut=>"domino"}
基准测试结果:
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)
我偏爱:
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"
}
之所以有效,是因为我们正在遍历哈希并动态构建一个新哈希。它不是递归的,但你可以从其他答案中找出答案。
hash.inject({}){ |h, (n,v)| h[n.to_sym] = v; h }
你也可以扩展核心哈希ruby类放置一个/lib/Hash。Rb文件:
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
如果您想确保在父散列中包装到数组中的任何散列的键都有符号,则需要扩展数组类以创建"数组"。
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 << new_value
end
new_ar
end
end
这允许在任何散列变量上调用"symbolize_keys_deep!",如下所示:
myhash.symbolize_keys_deep!
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}}}
我的两分话,
我的symbolize_keys_deep!
版本使用原始的symbolize_keys!由rails提供,只是对symbol子哈希进行简单的递归调用。
def symbolize_keys_deep!(h)
h.symbolize_keys!
h.each do |k, v|
symbolize_keys_deep!(v) if v.is_a? Hash
end
end
Facets的hash# rekey也是值得一提的。
示例:require 'facets/hash/rekey'
{ "id" => "123", "name" => "test" }.deep_rekey
=> {:id=>"123", :name=>"test"}
还有一个递归版本:
require 'facets/hash/deep_rekey'
{ "id" => "123", "name" => {"first" => "John", "last" => "Doe" } }.deep_rekey
=> {:id=>"123", :name=>{:first=>"John", :last=>"Doe"}}
这里有一个小递归函数,用于对键进行深度符号化:
def symbolize_keys(hash)
Hash[hash.map{|k,v| v.is_a?(Hash) ? [k.to_sym, symbolize_keys(v)] : [k.to_sym, v] }]
end