cách tốt nhất để chuyển đổi cặp giá trị khóa được định dạng json thành hàm băm ruby ​​với biểu tượng là khóa là gì?

Tôi đang tự hỏi đâu là cách tốt nhất để chuyển đổi cặp giá trị khóa được định dạng json thành băm ruby ​​với biểu tượng là khóa: ví dụ:

{ 'user': { 'name': 'foo', 'age': 40, 'location': { 'city' : 'bar', 'state': 'ca' } } }
==> 
{ :user=>{ :name => 'foo', :age =>'40', :location=>{ :city => 'bar', :state=>'ca' } } }

Có một phương pháp trợ giúp có thể làm điều này?

bằng cách sử dụng đá quý json khi phân tích chuỗi json mà bạn có thể chuyển vào tùy chọn Symbolize_names. Xem tại đây: http://flori.github.com/json/doc/index.html (xem dưới phân tích cú pháp)

ví dụ:

>> s ="{\"akey\":\"one\",\"bkey\":\"two\"}"
>> JSON.parse(s,:symbolize_names => true)
=> {:akey=>"one", :bkey=>"two"} 

Leventix, cảm ơn bạn đã trả lời.

Phương thức Marshal.load (Marshal.dump (h)) có lẽ có tính toàn vẹn nhất trong số các phương thức khác nhau vì nó bảo toàn các kiểu khóa ban đầu một cách đệ quy .

Điều này quan trọng trong trường hợp bạn có một băm lồng nhau với hỗn hợp các khóa chuỗi và ký hiệu và bạn muốn bảo toàn hỗn hợp đó khi giải mã (ví dụ: điều này có thể xảy ra nếu băm của bạn chứa các đối tượng tùy chỉnh của riêng bạn ngoài thứ ba có độ phức tạp cao / lồng nhau -đối tượng bên có khóa mà bạn không thể thao tác / chuyển đổi vì bất kỳ lý do gì, như giới hạn thời gian của dự án).

Ví dụ:

h = {
      :youtube => {
                    :search   => 'daffy',                 # nested symbol key
                    'history' => ['goofy', 'mickey']      # nested string key
                  }
    }

Phương pháp 1 : JSON.parse - tượng trưng cho tất cả các khóa một cách đệ quy => Không bảo toàn hỗn hợp gốc

JSON.parse( h.to_json, {:symbolize_names => true} )
  => { :youtube => { :search=> "daffy", :history => ["goofy", "mickey"] } } 

Phương pháp 2 : ActiveSupport :: JSON.decode - chỉ tượng trưng cho các khóa cấp cao nhất => Không bảo toàn hỗn hợp gốc

ActiveSupport::JSON.decode( ActiveSupport::JSON.encode(h) ).symbolize_keys
  => { :youtube => { "search" => "daffy", "history" => ["goofy", "mickey"] } }

Phương pháp 3 : Marshal.load - bảo tồn hỗn hợp chuỗi / ký hiệu ban đầu trong các khóa lồng nhau. HOÀN HẢO!

Marshal.load( Marshal.dump(h) )
  => { :youtube => { :search => "daffy", "history" => ["goofy", "mickey"] } }

Trừ khi có một nhược điểm mà tôi không biết, tôi nghĩ Phương pháp 3 là cách để đi.

Chúc mừng

Không có bất kỳ thứ gì được tích hợp sẵn để thực hiện thủ thuật này, nhưng không quá khó để viết mã để thực hiện nó bằng cách sử dụng đá quý JSON. Có một symbolize_keysphương thức được tích hợp trong Rails nếu bạn đang sử dụng phương thức đó, nhưng điều đó không tượng trưng cho các khóa đệ quy như bạn cần.

require 'json'

def json_to_sym_hash(json)
  json.gsub!('\'', '"')
  parsed = JSON.parse(json)
  symbolize_keys(parsed)
end

def symbolize_keys(hash)
  hash.inject({}){|new_hash, key_value|
    key, value = key_value
    value = symbolize_keys(value) if value.is_a?(Hash)
    new_hash[key.to_sym] = value
    new_hash
  }
end

Như Leventix đã nói, đá quý JSON chỉ xử lý các chuỗi được trích dẫn kép (điều này đúng về mặt kỹ thuật - JSON nên được định dạng bằng dấu ngoặc kép). Đoạn mã này sẽ làm sạch nó trước khi cố gắng phân tích cú pháp.

Phương pháp đệ quy:

require 'json'

def JSON.parse(source, opts = {})
  r = JSON.parser.new(source, opts).parse
  r = keys_to_symbol(r) if opts[:symbolize_names]
  return r
end

def keys_to_symbol(h)
  new_hash = {}
  h.each do |k,v|
    if v.class == String || v.class == Fixnum || v.class == Float
      new_hash[k.to_sym] = v
    elsif v.class == Hash
      new_hash[k.to_sym] = keys_to_symbol(v)
    elsif v.class == Array
      new_hash[k.to_sym] = keys_to_symbol_array(v)
    else
      raise ArgumentError, "Type not supported: #{v.class}"
    end
  end
  return new_hash
end

def keys_to_symbol_array(array)
  new_array = []
  array.each do |i|
    if i.class == Hash
      new_array << keys_to_symbol(i)
    elsif i.class == Array
      new_array << keys_to_symbol_array(i)
    else
      new_array << i
    end
  end
  return new_array
end

Tất nhiên, có một đá quý json , nhưng chỉ xử lý dấu ngoặc kép.

Một cách khác để xử lý điều này là sử dụng tuần tự hóa / giải mã hóa YAML, cũng giữ nguyên định dạng của khóa:

YAML.load({test: {'test' => { ':test' => 5}}}.to_yaml) 
=> {:test=>{"test"=>{":test"=>5}}}

Lợi ích của cách tiếp cận này có vẻ như là một định dạng phù hợp hơn với các dịch vụ REST ...

Cách thuận tiện nhất là sử dụng đá quý nice_hash: https://github.com/MarioRuiz/nice_hash

require 'nice_hash'
my_str = "{ 'user': { 'name': 'foo', 'age': 40, 'location': { 'city' : 'bar', 'state': 'ca' } } }"

# on my_hash will have the json as a hash
my_hash = my_str.json

# or you can filter and get what you want
vals = my_str.json(:age, :city)

# even you can access the keys like this:
puts my_hash._user._location._city
puts my_hash.user.location.city
puts my_hash[:user][:location][:city]