Comment parsingr JSON avec Ruby on Rails?

Je cherche un moyen simple d’parsingr JSON, d’extraire une valeur et de l’écrire dans une firebase database dans Rails.

Plus précisément, ce que je recherche, c’est un moyen d’extraire shortUrl du JSON renvoyé par l’API bit.ly:

 { "errorCode": 0, "errorMessage": "", "results": { "http://www.foo.com": { "hash": "e5TEd", "shortKeywordUrl": "", "shortUrl": "http://bit.ly/1a0p8G", "userHash": "1a0p8G" } }, "statusCode": "OK" } 

Et puis prenez cette shortUrl et écrivez-la dans un object ActiveRecord associé à la longue URL.

C’est une de ces choses que je peux imaginer entièrement et quand je m’assieds pour exécuter, je réalise que j’ai beaucoup à apprendre.

Ces réponses sont un peu datées. Je vous donne donc:

 hash = JSON.parse ssortingng 

Rails doit charger automatiquement le module json pour vous, vous n’avez donc pas besoin d’append require 'json' .

Analyser JSON dans Rails est assez simple:

 parsed_json = ActiveSupport::JSON.decode(your_json_ssortingng) 

Supposons que l’object avec lequel vous voulez associer shortUrl est un object Site, qui a deux atsortingbuts: short_url et long_url. Ensuite, pour obtenir le shortUrl et l’associer à l’object Site approprié, vous pouvez faire quelque chose comme:

 parsed_json["results"].each do |longUrl, convertedUrl| site = Site.find_by_long_url(longUrl) site.short_url = convertedUrl["shortUrl"] site.save end 

Cette réponse est assez ancienne. pguardiario l’a compris.

Un site à vérifier est l’ implémentation JSON pour Ruby . Ce site propose un bijou que vous pouvez installer pour une variante d’extension C beaucoup plus rapide.

Avec les tests de ActiveSupport::JSON.decode donnés dans leur page de documentation, ils affirment qu’il est 21.500x plus rapide que ActiveSupport::JSON.decode

Le code serait le même que la réponse de Milan Novota avec ce joyau, mais l’parsing serait juste:

 parsed_json = JSON(your_json_ssortingng) 

Voici une mise à jour pour 2013.

Rubis

Ruby 1.9 possède une gemme JSON par défaut avec des extensions C. Vous pouvez l’utiliser avec

 require 'json' JSON.parse ''{ "x": "y" }' # => {"x"=>"y"} 

La parse! la variante peut être utilisée pour des sources sûres . Il y a aussi d’autres gemmes, qui peuvent être plus rapides que l’implémentation par défaut. Veuillez vous référer à multi_json pour la liste.

Des rails

Les versions modernes de Rails utilisent multi_json , un joyau qui utilise automatiquement la gemme JSON la plus rapide disponible. Ainsi, la manière recommandée est d’utiliser

 object = ActiveSupport::JSON.decode json_ssortingng 

Veuillez vous référer à ActiveSupport :: JSON pour plus d’informations. En particulier, la ligne importante dans la source de la méthode est

 data = MultiJson.load(json, options) 

Ensuite, dans votre Gemfile, incluez les gemmes que vous voulez utiliser. Par exemple,

 group :production do gem 'oj' end 

Le JSON groupé de Ruby est capable d’exposer un peu de magie à lui seul.

Si vous avez une chaîne contenant des données sérialisées JSON que vous souhaitez parsingr:

 JSON[ssortingng_to_parse] 

JSON va regarder le paramètre, voir c’est une chaîne et essayez de le décoder.

De même, si vous souhaitez sérialiser un tableau de bord ou un tableau, utilisez:

 JSON[array_of_values] 

Ou:

 JSON[hash_of_values] 

Et JSON va le sérialiser. Vous pouvez également utiliser la méthode to_json si vous souhaitez éviter la similitude visuelle de la méthode [] .

Voici quelques exemples:

 hash_of_values = {'foo' => 1, 'bar' => 2} array_of_values = [hash_of_values] JSON[hash_of_values] # => "{\"foo\":1,\"bar\":2}" JSON[array_of_values] # => "[{\"foo\":1,\"bar\":2}]" ssortingng_to_parse = array_of_values.to_json JSON[ssortingng_to_parse] # => [{"foo"=>1, "bar"=>2}] 

Si vous vous enracinez en JSON, vous remarquerez peut-être qu’il s’agit d’un sous-ensemble de YAML. En fait, l’parsingur YAML est ce qui gère le JSON. Vous pouvez le faire aussi:

 require 'yaml' YAML.load(ssortingng_to_parse) # => [{"foo"=>1, "bar"=>2}] 

Si votre application parsing à la fois YAML et JSON, vous pouvez laisser YAML gérer les deux types de données sérialisées.

 require 'json' out=JSON.parse(input) 

Cela retournera un hachage

 require 'json' hash = JSON.parse ssortingng 

travaillez avec le hash et faites ce que vous voulez faire.

Le bijou Oj ( https://github.com/ohler55/oj ) devrait fonctionner. C’est simple et rapide.

http://www.ohler.com/oj/#Simple_JSON_Writing_and_Parsing_Example

 require 'oj' h = { 'one' => 1, 'array' => [ true, false ] } json = Oj.dump(h) # json = # { # "one":1, # "array":[ # true, # false # ] # } h2 = Oj.load(json) puts "Same? #{h == h2}" # true 

Le bijou Oj ne fonctionnera pas pour JRuby. Pour JRuby, ceci ( https://github.com/ralfstx/minimal-json ) ou ceci ( https://github.com/clojure/data.json ) peut être une bonne option.

RUBY est sensible à la casse.

 require 'json' # json must be lower case JSON.parse() 

par exemple

 JSON.parse(response.body) # JSON must be all upper-case 

Voici ce que je ferais:

 json = "{\"errorCode\":0,\"errorMessage\":\"\",\"results\":{\"http://www.foo.com\":{\"hash\":\"e5TEd\",\"shortKeywordUrl\":\"\",\"shortUrl\":\"http://bitly/1a0p8G\",\"userHash\":\"1a0p8G\"}},\"statusCode\":\"OK\"}" hash = JSON.parse(json) results = hash[:results] 

Si vous connaissez l’url source, vous pouvez utiliser:

 source_url = "http://www.foo.com".to_sym results.fetch(source_url)[:shortUrl] => "http://bitly/1a0p8G" 

Si vous ne connaissez pas la clé de l’URL source, vous pouvez procéder comme suit:

 results.fetch(results.keys[0])[:shortUrl] => "http://bitly/1a0p8G" 

Si vous ne souhaitez pas rechercher des clés à l’aide de symboles, vous pouvez convertir les clés du hachage en chaînes:

 results = json[:results].ssortingngify_keys results.fetch(results.keys[0])["shortUrl"] => "http://bitly/1a0p8G" 

Si vous craignez que la structure JSON ne change, vous pouvez créer un schéma JSON simple et valider le JSON avant d’accéder aux clés. Cela fournirait un garde.

REMARQUE: Vous devez modifier l’URL bit.ly en raison de règles de publication.

Cela peut être fait comme ci-dessous, il suffit juste d’utiliser JSON.parse , vous pouvez alors le parcourir normalement avec des index.

 #ideally not really needed, but in case if JSON.parse is not identifiable in your module require 'json' #Assuming data from bitly api is stored in json_data here json_data = '{ "errorCode": 0, "errorMessage": "", "results": { "http://www.foo.com": { "hash": "e5TEd", "shortKeywordUrl": "", "shortUrl": "http://whateverurl", "userHash": "1a0p8G" } }, "statusCode": "OK" }' final_data = JSON.parse(json_data) puts final_data["results"]["http://www.foo.com"]["shortUrl"] 

Ruby a un parsingur JSON:

 require 'json' 

Vous pouvez essayer quelque chose comme ça:

 def details_to_json { :id => self.id, :credit_period_type => self.credit_period_type, :credit_payment_period => self.credit_payment_period, }.to_json end