¿Cómo convierto un objeto String en un objeto Hash?

Tengo una cadena que parece un hash:

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

¿Cómo obtengo un Hash? me gusta:

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

La cadena puede tener cualquier profundidad de anidamiento. Tiene todas las propiedades de cómo se escribe un Hash válido en Ruby.

La cadena creada al llamar Hash#inspectse puede volver a convertir en un hash llamandoeval . Sin embargo, esto requiere que lo mismo sea cierto para todos los objetos en el hash.

Si empiezo con el hash {:a => Object.new}, entonces su representación de cadena es "{:a=>#<Object:0x7f66b65cf4d0>}", y no puedo usar evalpara volver a convertirlo en un hash porque #<Object:0x7f66b65cf4d0>no es válida la sintaxis de Ruby.

Sin embargo, si todo lo que está en el hash son cadenas, símbolos, números y matrices, debería funcionar, porque tienen representaciones de cadenas que son válidas para la sintaxis de Ruby.

Para diferentes cadenas, puede hacerlo sin usar un evalmétodo peligroso :

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

El método rápido y sucio sería

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

Pero tiene graves implicaciones de seguridad.
Ejecuta lo que se pasa, debe estar 110% seguro (como en, al menos, ninguna entrada del usuario en ningún lugar del camino) contendría solo hashes formados correctamente o errores inesperados / criaturas horribles del espacio exterior podrían comenzar a aparecer.

Quizás YAML.load?

Este pequeño fragmento lo hará, pero no puedo verlo trabajando con un hash anidado. Aunque creo que es bastante lindo

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

Pasos 1. Elimino el '{', '}' y el ':' 2. Me divido en la cadena donde encuentre un ',' 3. Divido cada una de las subcadenas que se crearon con la división, cada vez que encuentra a '=>'. Luego, creo un hash con los dos lados del hash que acabo de separar. 4. Me queda una serie de hashes que luego combino.

EJEMPLO DE ENTRADA: "{: user_id => 11,: blog_id => 2,: comment_id => 1}" RESULTADO DE SALIDA: {"user_id" => "11", "blog_id" => "2", "comment_id" = > "1"}

Las soluciones hasta ahora cubren algunos casos pero fallan algunos (ver más abajo). Aquí está mi intento de una conversión más completa (segura). Sé de un caso de esquina que esta solución no maneja, que son símbolos de un solo carácter compuestos de caracteres extraños pero permitidos. Por ejemplo{:> => :<} es un hash de rubí válido.

También puse este código en github . Este código comienza con una cadena de prueba para ejercitar todas las conversiones.

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)

Aquí hay algunas notas sobre las otras soluciones aquí.

• El uso de las soluciones de @Ken Bloom y @Toms Mikosseval es demasiado aterrador para mí (como señala correctamente Toms).
• La solución de @zolter funciona si su hash no tiene símbolos o teclas numéricas.
• La solución de @jackquack funciona si no hay cadenas entre comillas mezcladas con los símbolos.
• La solución de @Eugene funciona si sus símbolos no usan todos los caracteres permitidos (los literales de símbolos tienen un conjunto más amplio de caracteres permitidos ).
• La solución de @Pablo funciona siempre que no tenga una combinación de símbolos y cadenas entre comillas.

Yo tuve el mismo problema. Estaba almacenando un hash en Redis. Al recuperar ese hash, era una cadena. No quería llamar eval(str)por motivos de seguridad. Mi solución fue guardar el hash como una cadena json en lugar de una cadena ruby ​​hash. Si tiene la opción, usar json es más fácil.

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

TL; DR: uso to_jsonyJSON.parse

Prefiero abusar de ActiveSupport :: JSON. Su enfoque es convertir el hash a yaml y luego cargarlo. Desafortunadamente, la conversión a yaml no es simple y probablemente quieras pedirla prestada a AS si aún no tienes AS en tu proyecto.

También tenemos que convertir cualquier símbolo en teclas de cadena normales ya que los símbolos no son apropiados en JSON.

Sin embargo, es incapaz de manejar los hashes que tienen una cadena de fecha (nuestras cadenas de fecha terminan no rodeadas de cadenas, que es donde entra el gran problema):

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

Resultaría en un error de cadena JSON no válido cuando intenta analizar el valor de la fecha.

Me encantaría cualquier sugerencia sobre cómo manejar este caso

funciona en rails 4.1 y admite símbolos sin comillas {: a => 'b'}

simplemente agregue esto a la carpeta de inicializadores:

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

Creé una gema hash_parser que primero comprueba si un hash es seguro o no usa ruby_parsergema. Solo entonces, aplica el eval.

Puedes usarlo 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)

Las pruebas en https://github.com/bibstha/ruby_hash_parser/blob/master/test/test_hash_parser.rb le dan más ejemplos de las cosas que he probado para garantizar que eval sea seguro.

Por favor considere esta solución. Biblioteca + especificaciones:

Archivo 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

Archivo 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

Llegué a esta pregunta después de escribir una línea para este propósito, así que comparto mi código en caso de que ayude a alguien. Funciona para una cadena con solo un nivel de profundidad y posibles valores vacíos (pero no nulos), como:

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

El codigo es:

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

Se encontró con un problema similar que necesitaba usar eval ().

Mi situación, estaba extrayendo algunos datos de una API y escribiéndolos en un archivo localmente. Luego poder extraer los datos del archivo y usar Hash.

Usé IO.read () para leer el contenido del archivo en una variable. En este caso, IO.read () lo crea como una cadena.

Luego usé eval () para convertir la cadena en un 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

También solo para mencionar que IO es un antepasado de File. Por lo tanto, también puede usar File.read en su lugar si lo desea.