quel est le meilleur moyen de convertir un format json valeur de la clé de la paire de rubis de hachage avec le symbole de clé?

Je me demande quel est le meilleur moyen de convertir un format json valeur de la clé de la paire de rubis de hachage avec le symbole de la clé:
exemple:

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

Est là une méthode d'assistance peuvent faire cela?

essayez cette http://stackoverflow.com/a/43773159/1297435 pour les rails 4.1

InformationsquelleAutor ez. | 2009-11-13

241

à l'aide de l'json gem lors de l'analyse de la chaîne json, vous pouvez passer dans le symbolize_names option. Voir ici: http://flori.github.com/json/doc/index.html (voir sous parse)

par exemple:
```
>> s ="{\"akey\":\"one\",\"bkey\":\"two\"}"
>> JSON.parse(s,:symbolize_names => true)
=> {:akey=>"one", :bkey=>"two"} 
```
- Ruby 1.9 comprend cette bibliothèque, par la manière.
- na pas cette habitude d'être :symbolize_keys ? pourquoi est-ce changement de nom?
- est un Rails de chose.
- C'est génial! Merci beaucoup.
- :symbolize_names est un Rubis chose
InformationsquelleAutor jai
19

Leventix, je vous remercie pour votre réponse.

La Maréchal.la charge(le Maréchal.dump(h)) méthode a probablement le plus de l'intégrité des différentes méthodes, car elle préserve la clé d'original de types de manière récursive.

Ce qui est important dans le cas où vous avez un imbriquée de hachage avec un mélange de chaîne et de touches de symbole et que vous souhaitez conserver ce mélange à décoder (par exemple, cela pourrait se produire si votre hash contient vos propres objets personnalisés, en plus de très complexe/imbriquée tiers des objets dont les clés vous ne pouvez pas manipuler/convertir pour quelque raison que ce soit, comme un projet de contrainte de temps).

E. g.:
```
h = {
      :youtube => {
                    :search   => 'daffy',                 # nested symbol key
                    'history' => ['goofy', 'mickey']      # nested string key
                  }
    }
```
Méthode 1: JSON.analyser symbolise toutes les clés de manière récursive => Ne pas conserver original mix
```
JSON.parse( h.to_json, {:symbolize_names => true} )
  => { :youtube => { :search=> "daffy", :history => ["goofy", "mickey"] } } 
```
Méthode 2: ActiveSupport::JSON.décoder symbolise haut-niveau des clés => Ne pas conserver original mix
```
ActiveSupport::JSON.decode( ActiveSupport::JSON.encode(h) ).symbolize_keys
  => { :youtube => { "search" => "daffy", "history" => ["goofy", "mickey"] } }
```
Méthode 3: Le Maréchal.charge préserve chaîne d'origine/symbole mélange dans le imbriqués les touches. PARFAIT!
```
Marshal.load( Marshal.dump(h) )
  => { :youtube => { :search => "daffy", "history" => ["goofy", "mickey"] } }
```
Sauf si il ya un inconvénient que je le sache, je pense Méthode 3 est le chemin à parcourir.

Acclamations
- Il n'y a pas de garantie que vous avez ici le contrôle de l'autre côté, donc, je crois que vous devez coller à JSON mise en forme. Si vous avez le plein contrôle sur les deux côtés, puis Maréchal est en effet un bon format, mais il n'est pas convenable pour une utilisation générale de la sérialisation.
InformationsquelleAutor frank
5

Il n'y a pas quelque chose de construit en faire le tour, mais il n'est pas trop dur à écrire le code pour le faire en utilisant le JSON gem. Il y a un symbolize_keys méthode intégrée dans les Rails si vous l'utilisez, mais cela ne veut pas symboliser les touches de manière récursive comme vous avez besoin.
```
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
```
Comme Leventix dit, le JSON gem ne gère que les chaînes entre guillemets doubles (ce qui est techniquement correcte - JSON doit être formaté avec les guillemets). Ce morceau de code n'est propre qu'avant d'essayer de l'analyser.

InformationsquelleAutor madlep

Méthode récursive:

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

InformationsquelleAutor Oel Roc

1

Bien sûr, il y a un json gem, mais qui ne gère que des guillemets doubles.
- Comme madlep dit ci-dessous - c'est tout ce dont vous avez besoin si vous savez que le JSON sera valable (par exemple en vous rendant vous-même!)
- Cela ne fonctionne pas. JSON.parse(JSON.generate([:a])) # => ["a"]
- C'est parce que JSON ne peut pas représenter des symboles. Vous pouvez utiliser: Marshal.load(Marshal.dump([:a])) à la place.
InformationsquelleAutor Leventix
1

Une autre façon de gérer cela est d'utiliser YAML de sérialisation/désérialisation, qui préserve également le format de la clé:
```
YAML.load({test: {'test' => { ':test' => 5}}}.to_yaml) 
=> {:test=>{"test"=>{":test"=>5}}}
```
Avantage de cette approche, il semble comme un format qui est mieux adapté pour des services REST...
- Ne laissez jamais la saisie de l'utilisateur d'obtenir en YAML.charge: tenderlovemaking.com/2013/02/06/yaml-f7u12.html
- voulez-vous dire ce trou de sécurité de 2013 n'est toujours pas résolu aujourd'hui?
- Les symboles sont GC ed depuis Ruby 2.2. YAML.load est destinée à sérialiser des objets arbitraires (par exemple, pour le cache). Le projet de YAML.safe_load a été introduit quelques mois après ce billet de blog, c'est une question de droit chose: github.com/ruby/psych/commit/...
InformationsquelleAutor bert bruynooghe

Le moyen le plus pratique est d'utiliser le nice_hash gem: 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]

InformationsquelleAutor Mario Ruiz

Vous devez vous connecter pour publier un commentaire.