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

Question

que tienen una cadena que se parece a un hash:

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

¿Cómo consigo un hash de ella? como:

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

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

Answer 1

La cadena creada llamando al Hash#inspect se puede volver a convertir en hash llamando al eval. Sin embargo, esto requiere que lo mismo sea cierto para todos los objetos en el hash.

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

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

Answer 2

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 implicaciones de seguridad graves.
Ejecuta todo lo que pasa, debe estar seguro al 110% (como en, al menos, no hay entrada de usuario en el camino) que solo contendría hashes formados correctamente o bichos inesperados/criaturas horribles del espacio exterior podrían comenzar a aparecer.

Answer 3

Quizás YAML.load?

Answer 4

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. Trabaja para una cadena con sólo un nivel de profundidad y los posibles valores vacíos (pero no cero), como:

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

El código 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]} 

Answer 5

prefiero abusar ActiveSupport :: JSON. Su enfoque es convertir el hash a yaml y luego cargarlo. Lamentablemente, la conversión a yaml no es simple y es probable que desee tomarla prestada de AS si ya no tiene AS en su proyecto.

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

Sin embargo, su incapaces de manejar los hashes que tienen una cadena de fecha en ellos (nuestros cadenas de fecha terminan por no estar rodeado de cuerdas, que es donde entra en juego el gran problema):

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

Ocasionaría un error de cadena JSON no válido cuando intente analizar el valor de la fecha.

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

Answer 6

Este breve pequeño fragmento lo hará, pero no puedo ver su funcionamiento con un resumen anidada.Creo que es muy lindo, aunque

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

Pasos 1. eliminar el '{', '}' y la ':' 2. divididos sobre la cuerda donde quiera que encuentre un '' 3. Divido cada una de las subcadenas que se crearon con la división, cada vez que encuentra un '=>'. Luego, creo un hash con los dos lados del hash. Simplemente me separé. 4. Me quedan una serie de hash que luego fusiono.

Ejemplo de entrada: "{: user_id => 11,: blog_id => 2,: comment_id => 1}" resultado de salida: { "user_id" => "11", "blog_id" => "2" "comment_id" => "1"}

Answer 7

Para cadena diferente, puede hacerlo sin necesidad de utilizar peligrosa eval método:

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

Answer 8

obras en los carriles 4.1 y símbolos de apoyo 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 

Answer 9

Las soluciones cubren hasta ahora algunos casos pero fallan algunos (ver a continuación). 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 es símbolos de un solo carácter compuestos de caracteres extraños, pero permitidos. Por ejemplo, {:> => :<} es un hash ruby ​​válido.

Puse este code up on github as well. Este código se inicia con una cadena de prueba para ejercer 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í

• @Ken Bloom y soluciones @Toms Mikoss 's utilizar eval que es demasiado miedo para mí (como se Toms señala acertadamente).
• @zoltersolution funciona si su hash no tiene símbolos ni teclas numéricas.
• @jackquacksolution funciona si no hay cadenas entrecomilladas mezcladas con los símbolos.
• @Eugenesolution funciona si los símbolos no usan todos los caracteres permitidos (symbol literals have a broader set of allowed characters).
• @Pablosolution funciona siempre que no tenga una combinación de símbolos y cadenas entre comillas.

Answer 10

Considere esta solución. Biblioteca + especificaciones:

del 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"}') 
     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 

del archivo: spec/lib/ext/hash/from_string_spec.rb:

require "ext/hash/from_string" 
require "rspec/match_result" # Get from https://github.com/dadooda/rspec_match_result. 

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| 
     match_result(input, expected) {|input| Hash.from_string(input)} 
    end 
    end # it 
end 

Answer 11

que tenían el mismo problema. Estaba almacenando un hash en Redis. Al recuperar ese hash, era una cadena. No quise llamar al eval(str) por cuestiones de seguridad. Mi solución fue guardar el hash como una cadena json en lugar de una cadena de hash de rubí.Si tienes la opción, usar json es más fácil.

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

TL; DR: to_json uso y JSON.parse

Answer 12

he construido una joya hash_parser que primero comprueba si un hash es seguro o no usando ruby_parser joya. Solo entonces, aplica el eval.

Se puede utilizar 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 asegurarse de que es seguro eval.