Wie konvertiere ich ein String-Objekt in ein Hash-Objekt?

Ich habe eine Zeichenfolge, die wie ein Hash aussieht:

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

Wie bekomme ich einen Hash daraus? mögen:

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

Die Zeichenfolge kann eine beliebige Verschachtelungstiefe aufweisen. Es hat alle Eigenschaften, wie ein gültiger Hash in Ruby eingegeben wird.

Die durch Aufrufen erstellte Zeichenfolge kann durch Aufrufen Hash#inspectwieder in einen Hash umgewandelt werden eval. Dies setzt jedoch voraus, dass dies für alle Objekte im Hash gilt.

Wenn ich mit dem Hash beginne {:a => Object.new}, ist seine Zeichenfolgendarstellung "{:a=>#<Object:0x7f66b65cf4d0>}"und ich kann ihn nicht evalwieder in einen Hash umwandeln, da #<Object:0x7f66b65cf4d0>die Ruby-Syntax nicht gültig ist.

Wenn der Hash jedoch nur Zeichenfolgen, Symbole, Zahlen und Arrays enthält, sollte dies funktionieren, da diese Zeichenfolgendarstellungen mit gültiger Ruby-Syntax enthalten.

Für verschiedene Zeichenfolgen können Sie dies tun, ohne eine gefährliche evalMethode anzuwenden:

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

Schnelle und schmutzige Methode wäre

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

Dies hat jedoch schwerwiegende Auswirkungen auf die Sicherheit.
Es führt alles aus, was übergeben wird. Sie müssen zu 110% sicher sein (wie in, zumindest keine Benutzereingaben irgendwo auf dem Weg), dass es nur richtig geformte Hashes enthält oder unerwartete Fehler / schreckliche Kreaturen aus dem Weltraum auftauchen könnten.

Vielleicht YAML.load?

Dieses kurze kleine Snippet wird es tun, aber ich kann nicht sehen, dass es mit einem verschachtelten Hash funktioniert. Ich finde es aber ziemlich süß

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

Schritte 1. Ich eliminiere das '{', '}' und das ':' 2. Ich teile die Zeichenfolge überall dort auf, wo sie ein ',' findet. 3. Ich teile jede der Teilzeichenfolgen, die mit der Teilung erstellt wurden, wann immer sie gefunden wird a '=>'. Dann erstelle ich einen Hash mit den beiden Seiten des Hash, die ich gerade getrennt habe. 4. Ich habe eine Reihe von Hashes, die ich dann zusammenführe.

BEISPIELEINGABE: "{: user_id => 11 ,: blog_id => 2 ,: comment_id => 1}" ERGEBNISAUSGABE: {"user_id" => "11", "blog_id" => "2", "comment_id" = > "1"}

Die bisherigen Lösungen decken einige Fälle ab, übersehen jedoch einige (siehe unten). Hier ist mein Versuch einer gründlicheren (sicheren) Konvertierung. Ich kenne einen Eckfall, den diese Lösung nicht behandelt, nämlich einzelne Zeichensymbole, die aus ungeraden, aber erlaubten Zeichen bestehen. Zum Beispiel {:> => :<}ist ein gültiger Ruby-Hash.

Ich habe diesen Code auch auf Github veröffentlicht . Dieser Code beginnt mit einer Testzeichenfolge, um alle Konvertierungen durchzuführen

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)

Hier einige Hinweise zu den anderen Lösungen

• Die Lösungen von @Ken Bloom und @Toms Mikoss verwenden, evalwas mir zu beängstigend ist (wie Toms zu Recht betont ).
• Die Lösung von @zolter funktioniert, wenn Ihr Hash keine Symbole oder Zifferntasten enthält.
• Die Lösung von @jackquack funktioniert, wenn keine Zeichenfolgen in Anführungszeichen mit den Symbolen gemischt sind.
• Die Lösung von @Eugene funktioniert, wenn Ihre Symbole nicht alle zulässigen Zeichen verwenden ( Symbolliterale enthalten einen größeren Satz zulässiger Zeichen ).
• Die Lösung von @Pablo funktioniert, solange Sie keine Mischung aus Symbolen und Zeichenfolgen in Anführungszeichen haben.

Ich hatte das gleiche Problem. Ich habe einen Hash in Redis gespeichert. Beim Abrufen dieses Hashs war es eine Zeichenfolge. Ich wollte eval(str)aus Sicherheitsgründen nicht anrufen . Meine Lösung bestand darin, den Hash als JSON-String anstelle eines Ruby-Hash-Strings zu speichern. Wenn Sie die Option haben, ist die Verwendung von json einfacher.

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

TL; DR: verwenden to_jsonundJSON.parse

Ich bevorzuge es, ActiveSupport :: JSON zu missbrauchen. Ihr Ansatz besteht darin, den Hash in Yaml umzuwandeln und ihn dann zu laden. Leider ist die Konvertierung in yaml nicht einfach und Sie möchten sie wahrscheinlich von AS ausleihen, wenn Sie AS noch nicht in Ihrem Projekt haben.

Wir müssen auch alle Symbole in reguläre String-Schlüssel konvertieren, da Symbole in JSON nicht geeignet sind.

Es ist jedoch nicht in der Lage, Hashes zu verarbeiten, die eine Datumszeichenfolge enthalten (unsere Datumszeichenfolgen werden letztendlich nicht von Zeichenfolgen umgeben, weshalb das große Problem auftritt):

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

Würde zu einem ungültigen JSON-Zeichenfolgenfehler führen, wenn versucht wird, den Datumswert zu analysieren.

Würde mich über Vorschläge zur Behandlung dieses Falls freuen

funktioniert in Rails 4.1 und unterstützt Symbole ohne Anführungszeichen {: a => 'b'}

Fügen Sie dies einfach dem Initialisierungsordner hinzu:

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

Ich habe einen gem hash_parser erstellt , der zuerst prüft, ob ein Hash sicher ist oder nicht ruby_parsergem. Nur dann gilt das eval.

Sie können es als verwenden

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)

Die Tests in https://github.com/bibstha/ruby_hash_parser/blob/master/test/test_hash_parser.rb geben Ihnen weitere Beispiele für die Dinge, die ich getestet habe, um sicherzustellen, dass die Bewertung sicher ist.

Bitte beachten Sie diese Lösung. Bibliothek + Spezifikation:

Datei: 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

Datei: 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

Ich bin auf diese Frage gekommen, nachdem ich zu diesem Zweck einen Einzeiler geschrieben habe, und teile meinen Code, falls er jemandem hilft. Funktioniert für einen String mit nur einer Ebenentiefe und möglichen leeren Werten (aber nicht Null) wie:

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

Der Code lautet:

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

Ist auf ein ähnliches Problem gestoßen, bei dem eval () verwendet werden musste.

In meiner Situation habe ich einige Daten aus einer API abgerufen und lokal in eine Datei geschrieben. Dann können Sie die Daten aus der Datei ziehen und den Hash verwenden.

Ich habe IO.read () verwendet, um den Inhalt der Datei in eine Variable einzulesen. In diesem Fall erstellt IO.read () es als String.

Verwenden Sie dann eval (), um den String in einen Hash zu konvertieren.

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

Auch nur um zu erwähnen, dass IO ein Vorfahr von File ist. Sie können also auch File.read verwenden, wenn Sie möchten.