Comment convertir un objet String en objet Hash?

J'ai une chaîne qui ressemble à un hachage:

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

Comment puis-je en obtenir un Hash? comme:

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

La chaîne peut avoir n'importe quelle profondeur d'imbrication. Il possède toutes les propriétés permettant de saisir un hachage valide dans Ruby.

La chaîne créée par appel Hash#inspectpeut être reconvertie en hachage en appelanteval . Cependant, cela nécessite que la même chose soit vraie pour tous les objets du hachage.

Si je commence par le hachage {:a => Object.new}, alors sa représentation sous forme de chaîne est "{:a=>#<Object:0x7f66b65cf4d0>}", et je ne peux pas l'utiliser evalpour le transformer en hachage car la #<Object:0x7f66b65cf4d0>syntaxe Ruby n'est pas valide.

Cependant, si tout ce qui est dans le hachage est constitué de chaînes, de symboles, de nombres et de tableaux, cela devrait fonctionner, car ceux-ci ont des représentations de chaîne qui sont une syntaxe Ruby valide.

Pour une chaîne différente, vous pouvez le faire sans utiliser de evalméthode dangereuse :

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

Une méthode rapide et sale serait

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

Mais cela a de graves implications pour la sécurité.
Il exécute tout ce qu'il est passé, vous devez être sûr à 110% (comme dans, au moins aucune entrée utilisateur n'importe où en cours de route), il ne contiendrait que des hachages correctement formés ou des bugs inattendus / horribles créatures de l'espace pourraient commencer à apparaître.

Peut-être YAML.load?

Ce petit extrait de code le fera, mais je ne peux pas le voir fonctionner avec un hachage imbriqué. Je pense que c'est plutôt mignon

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

Étapes 1. J'élimine les '{', '}' et les ':' 2. Je divise sur la chaîne partout où elle trouve un ',' 3. Je divise chacune des sous-chaînes qui ont été créées avec le fractionnement, chaque fois qu'il trouve a '=>'. Ensuite, je crée un hachage avec les deux côtés du hachage que je viens de séparer. 4. Il me reste un tableau de hachages que je fusionne ensuite.

EXEMPLE D'ENTREE: "{: user_id => 11,: blog_id => 2,: comment_id => 1}" RESULT OUTPUT: {"user_id" => "11", "blog_id" => "2", "comment_id" = > "1"}

Les solutions jusqu'à présent couvrent certains cas, mais en manquent (voir ci-dessous). Voici ma tentative de conversion plus approfondie (sûre). Je connais un cas d'angle que cette solution ne gère pas, à savoir les symboles à un seul caractère composés de caractères impairs, mais autorisés. Par exemple, {:> => :<}un hachage ruby ​​valide.

J'ai également mis ce code sur github . Ce code commence par une chaîne de test pour exercer toutes les conversions

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)

Voici quelques notes sur les autres solutions ici

• Les solutions de @Ken Bloom et @Toms Mikoss utilisent evalce qui est trop effrayant pour moi (comme le souligne à juste titre Toms).
• La solution de @zolter fonctionne si votre hachage n'a pas de symboles ou de touches numériques.
• La solution de @jackquack fonctionne s'il n'y a pas de chaînes entre guillemets mélangées aux symboles.
• La solution de @Eugene fonctionne si vos symboles n'utilisent pas tous les caractères autorisés (les littéraux de symbole ont un ensemble plus large de caractères autorisés ).
• La solution de @Pablo fonctionne tant que vous n'avez pas un mélange de symboles et de chaînes entre guillemets.

J'ai eu le même problème. Je stockais un hash dans Redis. Lors de la récupération de ce hachage, il s'agissait d'une chaîne. Je ne voulais pas appeler pour des eval(str)raisons de sécurité. Ma solution était d'enregistrer le hachage sous forme de chaîne json au lieu d'une chaîne de hachage ruby. Si vous en avez la possibilité, utiliser json est plus simple.

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

TL; DR: utiliser to_jsonetJSON.parse

Je préfère abuser d'ActiveSupport :: JSON. Leur approche consiste à convertir le hachage en yaml, puis à le charger. Malheureusement, la conversion en yaml n'est pas simple et vous voudrez probablement l'emprunter à AS si vous n'avez pas déjà AS dans votre projet.

Nous devons également convertir tous les symboles en clés de chaîne régulières car les symboles ne sont pas appropriés dans JSON.

Cependant, il est incapable de gérer les hachages contenant une chaîne de date (nos chaînes de date finissent par ne pas être entourées de chaînes, c'est là que le gros problème entre en jeu):

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

Se traduirait par une erreur de chaîne JSON non valide lorsqu'il essaie d'analyser la valeur de date.

J'adorerais des suggestions sur la façon de gérer cette affaire

fonctionne dans les rails 4.1 et prend en charge les symboles sans guillemets {: a => 'b'}

ajoutez simplement ceci au dossier des initialiseurs:

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

J'ai construit un hash_parser gem qui vérifie d'abord si un hachage est sûr ou n'utilise pas de ruby_parsergem. Seulement alors, il applique le eval.

Vous pouvez l'utiliser comme

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)

Les tests de https://github.com/bibstha/ruby_hash_parser/blob/master/test/test_hash_parser.rb vous donnent plus d'exemples des choses que j'ai testées pour m'assurer que eval est sûr.

Veuillez considérer cette solution. Bibliothèque + spécifications:

Fichier 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

Fichier 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

Je suis venu à cette question après avoir écrit une ligne à cet effet, donc je partage mon code au cas où cela aiderait quelqu'un. Fonctionne pour une chaîne avec un seul niveau de profondeur et des valeurs vides possibles (mais pas nulles), comme:

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

Le code est:

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

Ran sur un problème similaire nécessitant l'utilisation de eval ().

Ma situation, je tirais des données d'une API et les écrivais dans un fichier localement. Puis être en mesure d'extraire les données du fichier et d'utiliser le Hash.

J'ai utilisé IO.read () pour lire le contenu du fichier dans une variable. Dans ce cas, IO.read () le crée en tant que String.

Puis utilisé eval () pour convertir la chaîne 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

Aussi juste pour mentionner que IO est un ancêtre de File. Vous pouvez donc également utiliser File.read à la place si vous le souhaitez.