Jak przekonwertować obiekt String na obiekt Hash?

Mam ciąg, który wygląda jak hash:

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

Jak uzyskać z tego hash? lubić:

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

Ciąg może mieć dowolną głębokość zagnieżdżenia. Ma wszystkie właściwości wpisywania prawidłowego skrótu w Rubim.

Ciąg utworzony przez wywołanie Hash#inspectmożna przekształcić z powrotem w hash, wywołując evalgo. Jednak wymaga to tego samego dla wszystkich obiektów w skrócie.

Jeśli zacznę od skrótu {:a => Object.new}, to jego reprezentacja w postaci ciągu to "{:a=>#<Object:0x7f66b65cf4d0>}"i nie mogę użyć go, evalaby zmienić go z powrotem w hash, ponieważ #<Object:0x7f66b65cf4d0>nie jest poprawna składnia Ruby.

Jeśli jednak wszystko, co znajduje się w haszu, to łańcuchy, symbole, liczby i tablice, powinno to działać, ponieważ mają one reprezentacje ciągów, które są poprawną składnią Rubiego.

Dla innego ciągu możesz to zrobić bez użycia niebezpiecznej evalmetody:

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

Byłaby to szybka i brudna metoda

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

Ale ma to poważne konsekwencje dla bezpieczeństwa.
Wykonuje wszystko, co zostanie przekazane, musisz mieć 110% pewności (tak jak w przypadku, gdy nigdzie nie ma żadnych danych wejściowych użytkownika), że zawierałyby tylko poprawnie uformowane skróty lub nieoczekiwane błędy / straszne stworzenia z kosmosu mogą zacząć pojawiać się.

Może YAML.load?

Ten krótki fragment wystarczy, ale nie widzę, żeby działał z zagnieżdżonym hashem. Myślę, że to całkiem urocze

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

Kroki 1. Eliminuję „{”, „}” i „:” 2. Dzielę łańcuch wszędzie tam, gdzie znajdzie „,” 3. Dzielę każdy z podciągów, które zostały utworzone za pomocą podziału, gdy tylko znajdzie a '=>'. Następnie tworzę hash z dwiema stronami haszyszu, które właśnie rozdzieliłem. 4. Zostaje mi tablica skrótów, które następnie łączę.

PRZYKŁADOWE WPROWADZENIE: "{: user_id => 11,: blog_id => 2,: comment_id => 1}" WYNIKI WYNIKÓW: {"user_id" => "11", "blog_id" => "2", "comment_id" = > „1”}

Dotychczasowe rozwiązania obejmują niektóre przypadki, ale niektóre pomijają (patrz poniżej). Oto moja próba dokładniejszej (bezpieczniejszej) konwersji. Znam jeden przypadek narożny, którego to rozwiązanie nie obsługuje, czyli symbole jednoznakowe złożone z dziwnych, ale dozwolonych znaków. Na przykład{:> => :<} jest to poprawny hash ruby.

Umieściłem ten kod również na githubie . Ten kod zaczyna się od ciągu testowego, aby wykonać wszystkie konwersje

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)

Oto kilka uwag na temat innych rozwiązań tutaj

• Rozwiązania @Ken Bloom i @Toms Mikoss używają, evalco jest dla mnie zbyt przerażające (jak słusznie zauważa Toms).
• @zolter „s rozwiązanie działa, jeśli hash nie ma symboli lub klawiszy numerycznych.
• @jackquack „s rozwiązanie działa, jeśli nie istnieją notowane ciągi zmieszane z symbolami.
• @Eugene „s rozwiązanie działa, jeśli symbole nie korzystać ze wszystkich dozwolonych znaków ( literały symbol mieć szerszy zestaw dozwolonych znaków ).
• @Pablo „s rozwiązanie działa tak długo, jak nie masz mieszankę symboli i cudzysłowami.

Miałem ten sam problem. Przechowywałem haszysz w Redis. Podczas pobierania tego skrótu był to ciąg. Nie chciałem dzwonić eval(str)ze względów bezpieczeństwa. Moim rozwiązaniem było zapisanie skrótu jako łańcucha json zamiast ruby. Jeśli masz taką opcję, używanie json jest łatwiejsze.

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

TL; DR: użyj to_jsoniJSON.parse

Wolę nadużywać ActiveSupport :: JSON. Ich podejście polega na zamianie haszyszu na yaml, a następnie załadowaniu go. Niestety konwersja do yaml nie jest prosta i prawdopodobnie chciałbyś pożyczyć ją od AS, jeśli nie masz jeszcze AS w swoim projekcie.

Musimy także przekonwertować wszystkie symbole na zwykłe klucze łańcuchowe, ponieważ symbole nie są odpowiednie w JSON.

Jednak nie jest w stanie obsłużyć skrótów, które zawierają ciąg daty (nasze ciągi daty nie są otoczone ciągami, co jest przyczyną dużego problemu):

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

Spowoduje to błąd nieprawidłowego ciągu JSON podczas próby przeanalizowania wartości daty.

Chciałbym mieć jakiekolwiek sugestie, jak sobie z tym poradzić

działa w railsach 4.1 i obsługuje symbole bez cudzysłowów {: a => 'b'}

po prostu dodaj to do folderu inicjalizatorów:

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

Zbudowałem gem hash_parser, który najpierw sprawdza, czy hash jest bezpieczny, czy nie używa ruby_parsergem. Dopiero wtedy stosuje eval.

Możesz go używać jako

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)

Testy na https://github.com/bibstha/ruby_hash_parser/blob/master/test/test_hash_parser.rb dają więcej przykładów rzeczy, które przetestowałem, aby upewnić się, że eval jest bezpieczny.

Prosimy o rozważenie tego rozwiązania. Biblioteka + specyfikacja:

Plik 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

Plik 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

Doszedłem do tego pytania po napisaniu w tym celu jednej linijki, więc udostępniam swój kod na wypadek, gdyby to komuś pomogło. Działa dla łańcucha z tylko jedną głębokością poziomu i możliwymi wartościami pustymi (ale nie zerowymi), na przykład:

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

Kod to:

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

Natrafiłem na podobny problem, który wymagał użycia funkcji eval ().

W mojej sytuacji pobierałem pewne dane z API i zapisywałem je lokalnie do pliku. Następnie można pobrać dane z pliku i użyć skrótu.

Użyłem IO.read () do wczytania zawartości pliku do zmiennej. W tym przypadku IO.read () tworzy go jako ciąg.

Następnie użył eval () do konwersji ciągu znaków na 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

Wystarczy wspomnieć, że IO jest przodkiem File. Możesz więc zamiast tego użyć File.read, jeśli chcesz.