如何将String对象转换为Hash对象？

我有一个看起来像哈希的字符串：

"{ :key_a => { :key_1a => 'value_1a', :key_2a => 'value_2a' }, :key_b => { :key_1b => 'value_1b' } }"

如何获得哈希值？喜欢：

{ :key_a => { :key_1a => 'value_1a', :key_2a => 'value_2a' }, :key_b => { :key_1b => 'value_1b' } }

字符串可以具有任何嵌套深度。它具有在Ruby中键入有效哈希的所有属性。

通过调用创建的字符串Hash#inspect可以通过调用转换回哈希eval。但是，这要求散列中的所有对象都相同。

如果我以hash开头{:a => Object.new}，则其字符串表示形式为"{:a=>#<Object:0x7f66b65cf4d0>}"，eval由于#<Object:0x7f66b65cf4d0>无效的Ruby语法，我不能使用它将其转换回hash 。

但是，如果哈希中仅包含字符串，符号，数字和数组，则它应该起作用，因为它们具有有效的Ruby语法的字符串表示形式。

对于不同的字符串，您可以不使用危险的eval方法来执行此操作：

hash_as_string = "{\"0\"=>{\"answer\"=>\"1\", \"value\"=>\"No\"}, \"1\"=>{\"answer\"=>\"2\", \"value\"=>\"Yes\"}, \"2\"=>{\"answer\"=>\"3\", \"value\"=>\"No\"}, \"3\"=>{\"answer\"=>\"4\", \"value\"=>\"1\"}, \"4\"=>{\"value\"=>\"2\"}, \"5\"=>{\"value\"=>\"3\"}, \"6\"=>{\"value\"=>\"4\"}}"
JSON.parse hash_as_string.gsub('=>', ':')

快速而肮脏的方法是

eval("{ :key_a => { :key_1a => 'value_1a', :key_2a => 'value_2a' }, :key_b => { :key_1b => 'value_1b' } }") 

但这具有严重的安全隐患。
它执行所传递的任何内容，您必须确保110％确信（例如，至少在此过程中没有任何用户输入），它将仅包含正确形成的哈希值或来自外层空间的意外错误/可怕的生物可能开始弹出。

也许YAML.load吗？

这个简短的小片段可以做到，但我看不到它可以与嵌套哈希一起使用。我觉得虽然很可爱

STRING.gsub(/[{}:]/,'').split(', ').map{|h| h1,h2 = h.split('=>'); {h1 => h2}}.reduce(:merge)

步骤1.消除'{'，'}'和'：'2.在字符串中找到'，'的位置均进行拆分一个'=>'。然后，我创建一个哈希，将哈希的两个侧面分开。4.我剩下一系列哈希，然后将它们合并在一起。

示例输入：“ {：user_id => 11，：blog_id => 2，：comment_id => 1}”结果输出：{“ user_id” =>“ 11”，“ blog_id” =>“ 2”，“ comment_id” = >“ 1”}

到目前为止，解决方案涵盖了某些情况，但错过了一些情况（请参阅下文）。这是我尝试进行更彻底（安全）的转换的尝试。我知道这种解决方案无法处理的一个特殊情况是由奇数但允许的字符组成的单个字符符号。例如{:> => :<}是有效的红宝石哈希。

我也将此代码放在github上。此代码以测试字符串开头，以执行所有转换

require 'json'

# Example ruby hash string which exercises all of the permutations of position and type
# See http://json.org/
ruby_hash_text='{"alpha"=>{"first second > third"=>"first second > third", "after comma > foo"=>:symbolvalue, "another after comma > foo"=>10}, "bravo"=>{:symbol=>:symbolvalue, :aftercomma=>10, :anotheraftercomma=>"first second > third"}, "charlie"=>{1=>10, 2=>"first second > third", 3=>:symbolvalue}, "delta"=>["first second > third", "after comma > foo"], "echo"=>[:symbol, :aftercomma], "foxtrot"=>[1, 2]}'

puts ruby_hash_text

# Transform object string symbols to quoted strings
ruby_hash_text.gsub!(/([{,]\s*):([^>\s]+)\s*=>/, '\1"\2"=>')

# Transform object string numbers to quoted strings
ruby_hash_text.gsub!(/([{,]\s*)([0-9]+\.?[0-9]*)\s*=>/, '\1"\2"=>')

# Transform object value symbols to quotes strings
ruby_hash_text.gsub!(/([{,]\s*)(".+?"|[0-9]+\.?[0-9]*)\s*=>\s*:([^,}\s]+\s*)/, '\1\2=>"\3"')

# Transform array value symbols to quotes strings
ruby_hash_text.gsub!(/([\[,]\s*):([^,\]\s]+)/, '\1"\2"')

# Transform object string object value delimiter to colon delimiter
ruby_hash_text.gsub!(/([{,]\s*)(".+?"|[0-9]+\.?[0-9]*)\s*=>/, '\1\2:')

puts ruby_hash_text

puts JSON.parse(ruby_hash_text)

这是这里其他解决方案的一些注意事项

• @Ken Bloom和@Toms Mikoss的解决方案使用eval对我来说太可怕了（正如Toms正确指出的那样）。
• 如果您的哈希没有符号或数字键，则@zolter的解决方案有效。
• 如果没有带引号的字符串与符号混合，则@jackquack的解决方案有效。
• 如果您的符号未使用所有允许的字符（符号文字具有更大范围的允许的字符），则@Eugene的解决方案有效。
• 只要您没有混合使用符号和带引号的字符串，@ Pablo的解决方案就可以使用。

我有同样的问题。我在Redis中存储了一个哈希。检索该哈希时，它是一个字符串。eval(str)由于安全方面的考虑，我不想打电话。我的解决方案是将哈希另存为json字符串，而不是ruby哈希字符串。如果可以的话，使用json更容易。

  redis.set(key, ruby_hash.to_json)
  JSON.parse(redis.get(key))

TL; DR：使用to_json和JSON.parse

我更喜欢滥用ActiveSupport :: JSON。他们的方法是将哈希转换为yaml，然后加载它。不幸的是，转换为yaml并不简单，如果您的项目中还没有AS，您可能想从AS借用。

我们还必须将任何符号转换为常规的字符串键，因为JSON中不适合使用这些符号。

但是，它无法处理包含日期字符串的哈希（我们的日期字符串最终没有被字符串包围，这是大问题所在）：

字符串='{'last_request_at'：2011-12-28 23:00:00 UTC}' ActiveSupport::JSON.decode(string.gsub(/:([a-zA-z])/,'\\1').gsub('=>', ' : '))

尝试解析日期值时，将导致无效的JSON字符串错误。

希望对如何处理此案有任何建议

在rails 4.1上工作并且支持不带引号的符号{：a =>'b'}

只需将其添加到初始化文件夹：

class String
  def to_hash_object
    JSON.parse(self.gsub(/:([a-zA-z]+)/,'"\\1"').gsub('=>', ': ')).symbolize_keys
  end
end

我建立了一个gem hash_parser，它首先检查哈希是否安全或不使用ruby_parsergem。只有这样，它才会应用eval。

您可以将其用作

require 'hash_parser'

# this executes successfully
a = "{ :key_a => { :key_1a => 'value_1a', :key_2a => 'value_2a' }, 
       :key_b => { :key_1b => 'value_1b' } }"
p HashParser.new.safe_load(a)

# this throws a HashParser::BadHash exception
a = "{ :key_a => system('ls') }"
p HashParser.new.safe_load(a)

https://github.com/bibstha/ruby_hash_parser/blob/master/test/test_hash_parser.rb中的测试为您提供了我为确保eval安全而进行了测试的更多示例。

请考虑此解决方案。库+规格：

文件lib/ext/hash/from_string.rb：

require "json"

module Ext
  module Hash
    module ClassMethods
      # Build a new object from string representation.
      #
      #   from_string('{"name"=>"Joe"}')
      #
      # @param s [String]
      # @return [Hash]
      def from_string(s)
        s.gsub!(/(?<!\\)"=>nil/, '":null')
        s.gsub!(/(?<!\\)"=>/, '":')
        JSON.parse(s)
      end
    end
  end
end

class Hash    #:nodoc:
  extend Ext::Hash::ClassMethods
end

文件spec/lib/ext/hash/from_string_spec.rb：

require "ext/hash/from_string"

describe "Hash.from_string" do
  it "generally works" do
    [
      # Basic cases.
      ['{"x"=>"y"}', {"x" => "y"}],
      ['{"is"=>true}', {"is" => true}],
      ['{"is"=>false}', {"is" => false}],
      ['{"is"=>nil}', {"is" => nil}],
      ['{"a"=>{"b"=>"c","ar":[1,2]}}', {"a" => {"b" => "c", "ar" => [1, 2]}}],
      ['{"id"=>34030, "users"=>[14105]}', {"id" => 34030, "users" => [14105]}],

      # Tricky cases.
      ['{"data"=>"{\"x\"=>\"y\"}"}', {"data" => "{\"x\"=>\"y\"}"}],   # Value is a `Hash#inspect` string which must be preserved.
    ].each do |input, expected|
      output = Hash.from_string(input)
      expect([input, output]).to eq [input, expected]
    end
  end # it
end

我为此写了一个单行代码后遇到了这个问题，所以我分享了我的代码，以防它对某人有所帮助。适用于只有一个级别深度且可能为空值（但不是nil）的字符串，例如：

"{ :key_a => 'value_a', :key_b => 'value_b', :key_c => '' }"

代码是：

the_string = '...'
the_hash = Hash.new
the_string[1..-2].split(/, /).each {|entry| entryMap=entry.split(/=>/); value_str = entryMap[1]; the_hash[entryMap[0].strip[1..-1].to_sym] = value_str.nil? ? "" : value_str.strip[1..-2]}

遇到需要使用eval（）的类似问题。

我的情况是，我从API中提取了一些数据并将其写入本地文件中。然后能够从文件中提取数据并使用哈希。

我使用IO.read（）将文件的内容读取到一个变量中。在这种情况下，IO.read（）将其创建为String。

然后使用eval（）将字符串转换为哈希。

read_handler = IO.read("Path/To/File.json")

puts read_handler.kind_of?(String) # Returns TRUE

a = eval(read_handler)

puts a.kind_of?(Hash) # Returns TRUE

puts a["Enter Hash Here"] # Returns Key => Values

puts a["Enter Hash Here"].length # Returns number of key value pairs

puts a["Enter Hash Here"]["Enter Key Here"] # Returns associated value

还仅提及IO是File的祖先。因此，您也可以根据需要使用File.read。