Como converter um objeto String em um objeto Hash?

Eu tenho uma string que se parece com um hash:

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

Como faço para obter um Hash? gostar:

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

A cadeia pode ter qualquer profundidade de aninhamento. Possui todas as propriedades de como um Hash válido é digitado no Ruby.

A cadeia criada pela chamada Hash#inspectpode ser transformada novamente em um hash chamando eval-a. No entanto, isso exige o mesmo para todos os objetos no hash.

Se eu começar com o hash {:a => Object.new}, sua representação de string será "{:a=>#<Object:0x7f66b65cf4d0>}"e não posso usá eval-lo para transformá-lo novamente em um hash, porque #<Object:0x7f66b65cf4d0>não é uma sintaxe válida do Ruby.

No entanto, se tudo o que estiver no hash for seqüências de caracteres, símbolos, números e matrizes, deve funcionar, porque elas possuem representações de sequência de caracteres que são válidas na sintaxe Ruby.

Para cadeias diferentes, você pode fazer isso sem usar o evalmétodo perigoso :

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('=>', ':')

O método rápido e sujo seria

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

Mas tem implicações graves de segurança.
Ele executa o que quer que seja passado, você deve ter 110% de certeza (como, pelo menos, nenhuma entrada do usuário em qualquer lugar do caminho) que conteria apenas hashes adequadamente formados ou bugs inesperados / criaturas horríveis do espaço sideral podem começar a aparecer.

Talvez YAML.load?

Este pequeno trecho curto fará isso, mas não consigo vê-lo trabalhando com um hash aninhado. Eu acho que é bem fofo

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

Etapas 1. Eu elimino o '{', '}' e o ':' 2. Divido a string onde quer que encontre um ',' 3. Divido cada uma das substrings criadas com a divisão, sempre que encontrar a '=>'. Em seguida, crio um hash com os dois lados do hash que acabei de separar. 4. Fico com uma série de hashes que depois mesclo.

EXEMPLO DE ENTRADA: "{: user_id => 11,: blog_id => 2,: comment_id => 1}" RESULTADO DA SAÍDA: {"user_id" => "11", "blog_id" => "2", "comment_id" = > "1"}

Até agora, as soluções abrangem alguns casos, mas faltam alguns (veja abaixo). Aqui está minha tentativa de uma conversão mais completa (segura). Conheço um caso de canto que esta solução não lida com símbolos de caracteres únicos compostos por caracteres ímpares, mas permitidos. Por exemplo, {:> => :<}é um hash ruby ​​válido.

Eu coloquei esse código no github também . Esse código começa com uma sequência de teste para exercitar todas as conversões

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)

Aqui estão algumas notas sobre as outras soluções aqui

• As soluções de @Ken Bloom e @Toms Mikoss usam o evalque é assustador demais para mim (como Toms corretamente aponta).
• A solução do @zolter funciona se o seu hash não tiver símbolos ou teclas numéricas.
• A solução do @jackquack funciona se não houver seqüências de caracteres entre aspas misturadas aos símbolos.
• A solução da @Eugene funcionará se seus símbolos não usarem todos os caracteres permitidos (os literais de símbolos têm um conjunto mais amplo de caracteres permitidos ).
• A solução do @Pablo funciona desde que você não tenha uma mistura de símbolos e seqüências de caracteres citadas.

Eu tive o mesmo problema. Eu estava armazenando um hash em Redis. Ao recuperar esse hash, era uma string. Não quis ligar eval(str)por questões de segurança. Minha solução foi salvar o hash como uma string json, em vez de uma string ruby ​​hash. Se você tiver a opção, usar o json é mais fácil.

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

TL; DR: uso to_jsoneJSON.parse

Eu prefiro abusar do ActiveSupport :: JSON. A abordagem deles é converter o hash em yaml e carregá-lo. Infelizmente, a conversão para yaml não é simples e você provavelmente deseja emprestá-la do AS se ainda não o tiver no seu projeto.

Também precisamos converter quaisquer símbolos em chaves de string regulares, pois os símbolos não são apropriados no JSON.

No entanto, é incapaz de lidar com hashes que contenham uma string de data (nossas strings de data acabam não sendo cercadas por strings, que é onde entra o grande problema):

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

Resultaria em um erro de cadeia JSON inválido ao tentar analisar o valor da data.

Gostaria de sugestões sobre como lidar com este caso

trabalha nos trilhos 4.1 e suporta símbolos sem aspas {: a => 'b'}

basta adicionar isso à pasta inicializadores:

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

Criei uma gema hash_parser que primeiro verifica se um hash é seguro ou não está usando ruby_parsergemas. Só então, aplica-se oeval .

Você pode usá-lo como

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)

Os testes em https://github.com/bibstha/ruby_hash_parser/blob/master/test/test_hash_parser.rb oferecem mais exemplos das coisas que testei para garantir que a avaliação seja segura.

Por favor, considere esta solução. Biblioteca + especificações:

Arquivo 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

Arquivo 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

Cheguei a essa pergunta depois de escrever uma linha para esse fim, então compartilho meu código para o caso de ajudar alguém. Funciona para uma string com apenas um nível de profundidade e possíveis valores vazios (mas não nulos), como:

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

O código é:

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]}

Deparamos com um problema semelhante que precisava usar o eval ().

Minha situação, eu estava puxando alguns dados de uma API e gravando-os em um arquivo localmente. Em seguida, é possível extrair os dados do arquivo e usar o Hash.

Eu usei IO.read () para ler o conteúdo do arquivo em uma variável. Nesse caso, IO.read () o cria como uma String.

Em seguida, use eval () para converter a string em um Hash.

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

Apenas para mencionar que o IO é um ancestral do File. Portanto, você também pode usar o File.read, se desejar.