Bir String nesnesini Hash nesnesine nasıl dönüştürebilirim?

Bir karma gibi görünüyor bir dize var:

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

Nasıl bir karma elde edebilirim? sevmek:

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

Dize herhangi bir yuvalama derinliğine sahip olabilir. Ruby'de geçerli bir Hash'in nasıl yazıldığı tüm özelliklere sahiptir.

Çağırarak oluşturulan dize, çağırarak Hash#inspectbir karmaya dönüştürülebilir eval. Ancak bu, karmadaki tüm nesneler için aynı şeyi gerektirir.

Karma ile başlarsam {:a => Object.new}, dize temsili olur "{:a=>#<Object:0x7f66b65cf4d0>}"ve geçerli Ruby sözdizimi olmadığı evaliçin tekrar karma haline dönüştürmek için #<Object:0x7f66b65cf4d0>kullanamam.

Bununla birlikte, karmadaki her şey dizeler, semboller, sayılar ve dizilerse işe yaramalıdır, çünkü bunların geçerli Ruby sözdizimi olan dize gösterimleri vardır.

Farklı dize için, tehlikeli evalyöntemi kullanmadan yapabilirsiniz :

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

Hızlı ve kirli yöntem olurdu

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

Ancak ciddi güvenlik etkileri vardır.
Geçtiği her şeyi yürütür,% 110 emin olmalısınız (olduğu gibi, yol boyunca hiçbir yerde en az kullanıcı girişi yok), sadece düzgün bir şekilde oluşturulmuş karmaları veya dış alandan beklenmedik böcekleri / korkunç yaratıkların ortaya çıkmaya başlayabileceğinden emin olmalısınız.

Belki de YAML.load?

Bu kısa küçük snippet bunu yapacak, ancak iç içe bir karma ile çalıştığını göremiyorum. Bence oldukça sevimli

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

Adımlar 1. '{', '}' ve ':' 2'yi elimine ediyorum. 2. ',' bulduğu yerde dizgiye ayrıldım. 3. Bölme ile oluşturulan alt dizelerin her birini, a '=>'. Sonra, sadece ayırdığım karma iki tarafı ile bir karma oluşturun. 4. Sonra bir araya karma bir dizi kaldı.

ÖRNEK GİRİŞ: "{: user_id => 11,: blog_id => 2,: comment_id => 1}" SONUÇ ÇIKIŞI: {"user_id" => "11", "blog_id" => "2", "comment_id" = > "1"}

Şimdiye kadarki çözümler bazı vakaları kapsamakta ancak bazılarını kaçırmaktadır (aşağıya bakınız). İşte daha kapsamlı (güvenli) dönüşüm denemem. Garip ama izin verilen karakterlerden oluşan tek karakter sembolleri olan bu çözümün işlemediği bir köşe durumunu biliyorum. Örneğin {:> => :<}geçerli bir yakut karmasıdır.

Bu kodu da github üzerine koydum . Bu kod, tüm dönüşümleri uygulamak için bir test dizesiyle başlar

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)

İşte buradaki diğer çözümlerle ilgili bazı notlar

• @Ken Bloom ve @Toms Mikoss'uneval benim için çok korkutucu çözümler kullanması ( Toms'in haklı olarak belirttiği gibi).
• @zolter 'ın çözüm için karma hiçbir semboller veya sayısal tuşlar varsa çalışır.
• @jackquack 'ın çözüm sembollerle karışık hiçbir alıntı dizeleri varsa çalışır.
• @Eugene 'ın çözüm için semboller (tüm izin karakterler kullanmayın çalışır sembol değişmezleri izin verilen karakter daha geniş bir set var ).
• @Pablo 'ın çözüm sürece semboller ve alıntı dizeleri bir karışımını yok gibi çalışır.

Ben de aynı problemi yaşadım. Redis'te bir karma saklıyordum. Bu karmayı alırken, bir dize idi. eval(str)Güvenlik kaygısı yüzünden aramak istemedim . Benim çözüm hash bir yakut karma dizesi yerine json dizesi olarak kaydetmek oldu. Seçeneğiniz varsa, json kullanmak daha kolaydır.

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

TL; DR: kullanın to_jsonveJSON.parse

ActiveSupport :: JSON'u kötüye kullanmayı tercih ederim. Yaklaşımları hash'i yaml'ye dönüştürmek ve sonra yüklemek. Ne yazık ki yaml'ye dönüştürme basit değildir ve projenizde AS yoksa AS'den ödünç almak istersiniz.

Ayrıca JSON'da semboller uygun olmadığından herhangi bir sembolü normal dize anahtarlarına dönüştürmeliyiz.

Ancak, içinde bir tarih dizesi olan karmaları işleyemiyor (tarih dizelerimiz, büyük sorunun geldiği dizelerle çevrili değil):

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

Tarih değerini ayrıştırmaya çalıştığında geçersiz bir JSON dizesi hatasıyla sonuçlanır.

Bu davanın nasıl ele alınacağına dair herhangi bir öneri isterim

raylar 4.1'de çalışır ve tırnak işaretleri olmadan destek sembolleri {: a => 'b'}

sadece başlatıcılar klasörüne ekleyin:

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

İlk önce bir karma güvenli olup olmadığını kontrol eden bir mücevher hash_parser inşa etti ruby_parser. Ancak o zaman eval.

Olarak kullanabilirsiniz

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)

Https://github.com/bibstha/ruby_hash_parser/blob/master/test/test_hash_parser.rb'deki testler eval'ün güvenli olduğundan emin olmak için test ettiğim şeylere daha fazla örnek veriyor.

Lütfen bu çözümü düşünün. Kütüphane + Spec:

Dosya 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

Dosya 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

Bu amaçla bir astar yazdıktan sonra bu soruya geldim, bu yüzden birine yardım etmesi durumunda kodumu paylaşıyorum. Yalnızca bir düzey derinliğine ve olası boş değerlere (nil değil) sahip bir dize için çalışır, örneğin:

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

Kod:

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

Eval () kullanmak için gereken benzer bir sorun koştu.

Benim durumum, bir API bazı veri çekmek ve yerel olarak bir dosyaya yazıyordu. Sonra verileri dosyadan alıp Karma'yı kullanabilme.

Dosyanın içeriğini bir değişkene okumak için IO.read () kullandım. Bu durumda IO.read () yöntemi bir String olarak oluşturur.

Sonra dizeyi Hash'e dönüştürmek için eval () kullanılır.

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

Ayrıca, IO'nun Dosya'nın atası olduğunu da belirtmek gerekir. İsterseniz bunun yerine File.read'i de kullanabilirsiniz.