Convertir JSON en Ruby en Ligne
Convertis du JSON en Hash, Struct ou OpenStruct Ruby. Gratuit, dans ton navigateur, sans envoi de fichiers.
{
name: "John",
age: 30,
active: true,
tags: [
"ruby",
"rails"
],
address: {
city: "Tokyo",
zip: "100-0001"
}
}Ce que tu peux faire
JSON en Ruby : Hash, Struct et OpenStruct idiomatiques
Formats multiples
Hash avec symboles, Hash avec strings, Struct.new ou OpenStruct selon ton schema d'utilisation en Ruby ou Rails.
100% prive
La conversion se fait dans ton navigateur avec JavaScript. Ton code ne quitte jamais ton appareil.
Ruby idiomatique
Code genere suivant les conventions Ruby 3.x et le guide de style RuboCop.
Instantane
Conversion en temps reel pendant que tu ecris. Pas de bouton, pas d'attente.
Comment ça marche
Trois étapes, sans complications
Colle ton JSON
Saisis n'importe quel objet JSON valide : simple, imbrique, avec des tableaux ou des champs complexes. La validation se fait en temps reel dans ton navigateur.
Choisis le type de sortie
Selectionne Hash avec cles symbol, Hash avec cles string, Struct.new ou OpenStruct selon ton schema d'utilisation dans ton code Ruby ou Rails.
Copie le code Ruby
Obtiens du code Ruby idiomatique pret a coller dans ton projet, avec la syntaxe correcte pour la version de Ruby que tu utilises (2.7+ ou 3.x).
FAQ
Des questions ?
Cela depend du contexte d'utilisation dans ton code Ruby. Les cles symbol (:name, :age) sont le schema dominant en Ruby idiomatique pour plusieurs raisons : les symboles sont immuables et uniques en memoire (Ruby maintient une table globale de symboles, de sorte que :name est toujours le meme objet tout au long de la session), ce qui les rend plus efficaces pour les cles de Hash utilisees de facon repetee. La syntaxe moderne de Ruby (depuis 1.9) avec { name: value } (syntaxe colon) est plus propre et lisible que la hashrocket { :name => value }. Les frameworks comme Rails utilisent des symboles dans toutes leurs API internes (params[:user_id], session[:user], flash[:notice]). D'un autre cote, les cles string ('name', 'age') sont utiles quand les donnees viennent d'un JSON externe et sont manipulees sans conversion, quand les cles contiennent des caracteres invalides pour les symboles (tirets, espaces, points), ou quand on utilise HashWithIndifferentAccess d'ActiveSupport qui accepte les deux types de cle indifferemment.
Hash est la structure de donnees la plus flexible et le choix par defaut pour les donnees JSON en Ruby. Un Hash n'a pas de schema fixe : tu peux ajouter et supprimer des cles dynamiquement. Il est ideal pour les donnees de configuration, les reponses API a structure variable, et toute donnee qui varie en structure. Struct.new(:field1, :field2) cree une classe avec des attributs fixes et un acces via des methodes (object.field1 au lieu de object[:field1]). Les Struct sont plus rapides qu'OpenStruct, consomment moins de memoire, sont comparables par valeur (deux Struct avec les memes valeurs sont egaux), et sont un bon choix quand tu connais exactement la structure des donnees au moment de la conception. OpenStruct (de la bibliotheque standard ostruct) accepte des attributs dynamiques comme un Hash mais avec un acces par methode. C'est pratique pour un prototypage rapide mais a des penalites de performance significatives : dans les benchmarks, OpenStruct est 10-50 fois plus lent que Hash pour l'acces aux attributs en Ruby 2.x, bien que Ruby 3.x ait significativement ameliore son implementation.
Ruby inclut la bibliotheque json dans sa bibliotheque standard depuis Ruby 1.9 (2007). Aucune installation de gem supplementaire n'est necessaire. Usage de base : require 'json'; data = JSON.parse(json_string). Par defaut, JSON.parse retourne un Hash avec des cles string (les memes que dans le JSON original). Pour obtenir des cles symbol, utilise JSON.parse(json_string, symbolize_names: true). L'option symbolize_names convertit recursivement toutes les cles string en symboles, y compris les cles dans les objets imbriques. Pour generer du JSON depuis Ruby : JSON.generate(object) ou object.to_json (methode ajoutee par la bibliotheque json a Hash, Array et les types primitifs). La gem json_pure est l'implementation pure en Ruby ; la gem json (incluse par defaut dans MRI Ruby/CRuby) utilise une extension C pour de meilleures performances. Dans JRuby et TruffleRuby, l'implementation JSON utilise le runtime Java sous-jacent.
Oui, et elles sont importantes pour le code de production. OpenStruct a trois penalites de performance principales : (1) Creation : creer une instance OpenStruct est plus couteux que creer un Hash car il definit des methodes d'acces dynamiquement pour chaque attribut en utilisant define_method. (2) Acces : acceder a un attribut OpenStruct (object.name) est plus lent qu'acceder a un Hash (hash[:name]) car cela passe par method_missing ou les methodes definies dynamiquement, ajoutant un overhead de dispatch de methodes. (3) Memoire : chaque instance OpenStruct a un overhead supplementaire par rapport a Hash. En Ruby 2.7 et anterieures, les benchmarks montraient OpenStruct 10-50 fois plus lent que Hash. Ruby 3.0 a introduit des ameliorations significatives d'OpenStruct (implementation reecrite en C plutot qu'en Ruby pur) reduisant l'ecart, mais OpenStruct reste plus lent que Hash et Struct pour les acces intensifs. La recommandation officielle de Ruby 3.x est : preferer Struct a OpenStruct quand le schema est connu. Si tu as besoin d'un acces par methode avec un schema fixe et de bonnes performances, utilise Struct ; si tu as besoin de flexibilite pour le prototypage, utilise OpenStruct en ayant pleinement conscience du cout en performance.
ActiveSupport::HashWithIndifferentAccess (HWIA) est une sous-classe de Hash incluse dans Rails (et disponible comme gem activesupport sans Rails complet) qui permet d'acceder aux cles indifferemment par string ou symbole. C'est le type que Rails utilise pour params : params[:user_id] et params['user_id'] retournent la meme valeur. Pour charger du JSON externe dans Rails avec acces indifferent : json_data = JSON.parse(response_body).with_indifferent_access. La methode with_indifferent_access est disponible sur Hash via ActiveSupport. La conversion est recursive pour les hashes imbriques quand on utilise HashWithIndifferentAccess.new(hash) mais pas quand on utilise .with_indifferent_access directement sur des hashes imbriques (tu dois utiliser deep_symbolize_keys ou similaire pour une conversion profonde). Dans Rails 7.x, ActionController::Parameters (l'objet params) implemente une semantique similaire a HWIA mais avec des contraintes de securite supplementaires (requires et permits pour les Strong Parameters).
Ruby 2.3 a introduit le pragma # frozen_string_literal: true qui gele tous les string literals du fichier, les rendant immuables et partages en memoire (similaire a la facon dont les symboles sont uniques). Ruby 3.x continue de promouvoir cette pratique et dans la feuille de route de Ruby 4.0, son activation par defaut est discutee. L'impact sur le code genere avec des cles string pour Hash est : avec frozen_string_literal actif, les cles string sont automatiquement gelees, ce qui est efficace pour la memoire (le meme string 'name' dans plusieurs hashes peut pointer vers le meme objet s'il s'agit d'un string literal). Cependant, si le code tente de muter une cle string (concatener, gsub!, etc.) dans un fichier avec frozen_string_literal, une FrozenError sera levee au moment de l'execution. Pour le code traitant du JSON avec des cles string dans des fichiers avec frozen_string_literal, c'est rarement un probleme car les cles de Hash ne sont generalement pas mutees. La recommandation pour les projets modernes en Ruby 3.x est d'inclure # frozen_string_literal: true dans tous les fichiers et d'utiliser des cles symbol dans les Hash de son propre code pour une efficacite maximale.
Convertir JSON en Hash, Struct et OpenStruct Ruby : guide technique
La conversion de JSON en structures de donnees Ruby est une operation fondamentale dans le developpement backend avec Ruby et Ruby on Rails. JSON (JavaScript Object Notation, RFC 7159, mis a jour dans RFC 8259 en 2017) utilise un modele de donnees qui se mappe directement aux types primitifs de Ruby : les objets JSON se convertissent en Hash, les tableaux JSON en Array, les strings en String, les nombres en Integer ou Float, les booleens en true/false, et null en nil. Cependant, la decision sur le type de Hash a utiliser (avec des cles symbol ou string) et si l'on doit utiliser Hash, Struct ou OpenStruct a des implications importantes pour les performances, la lisibilite et la maintenabilite du code Ruby resultant. La syntaxe Hash en Ruby a evolue significativement au fil des versions du langage. Ruby 1.8 et les versions anterieures ne supportaient que la syntaxe hashrocket : { :key => value }. Ruby 1.9 (2007) a introduit la syntaxe colon pour les cles symbol : { key: value }, equivalente a { :key => value } mais plus concise. Ruby 3.1 (2021) a etendu la syntaxe colon pour permettre des cles string et des variables : { 'key': value } et le raccourci de valeur ou le nom de la variable correspond a la cle ({ x:, y: } au lieu de { x: x, y: y }). RuboCop, l'analyseur statique de code Ruby de reference, recommande dans son guide de style d'utiliser la syntaxe colon ({ key: value }) quand toutes les cles sont des symboles, et hashrocket ({ 'key' => value }) quand il y a des cles string ou des types de cle melanges.
Struct en Ruby est une classe generatrice de classes : Struct.new(:name, :age) cree une nouvelle classe anonyme (ou nommee si assignee a une constante) avec des attributs definis, des methodes d'acces (getters et setters), une comparaison par valeur (==), et des methodes de conversion comme to_a et to_h. Depuis Ruby 2.5, Struct.new accepte un bloc ou des methodes supplementaires peuvent etre definies. Depuis Ruby 3.2, Struct.new avec keyword_init: true permet l'initialisation avec des kwargs : Person.new(name: 'Ana', age: 30) au lieu de Person.new('Ana', 30). Les Struct en Ruby sont largement utilises pour les Value Objects (objets representant une valeur conceptuelle sans identite propre, comme un point geometrique, une plage de dates, ou une adresse postale) et pour les Data Transfer Objects (DTO) dans les applications suivant des schemas d'architecture propre. OpenStruct (bibliotheque standard ostruct, require 'ostruct') est une classe qui permet de creer des objets avec des attributs dynamiques definis dans le constructeur : person = OpenStruct.new(name: 'Ana', age: 30); person.name #=> 'Ana'. De plus, des attributs peuvent etre ajoutes apres la creation : person.email = 'ana@example.com'. OpenStruct repond correctement a respond_to? pour les attributs definis. Il est particulierement populaire pour ecrire des test doubles, stubs et fixtures dans les tests RSpec et Minitest : OpenStruct.new(id: 1, name: 'Test') est un moyen rapide de creer des objets fictifs pour les tests sans implementer des classes completes.
Dans le contexte de Ruby on Rails, l'integration JSON est omnipresente. Les reponses des API externes (REST ou GraphQL) sont parsees avec JSON.parse, les params des requetes POST avec Content-Type application/json sont automatiquement parses par ActionDispatch et disponibles sous forme d'ActionController::Parameters (qui fonctionne comme HashWithIndifferentAccess avec Strong Parameters). Pour la serialisation des modeles ActiveRecord en JSON, Rails inclut la methode as_json qui accepte des options comme only:, except:, include: pour les associations, et methods: pour les methodes virtuelles. La gem jbuilder (incluse par defaut dans Rails) permet de construire des reponses JSON avec un DSL Ruby. La gem ActiveModelSerializers et la plus recente jsonapi-serializer (basee sur fast_jsonapi de Netflix) offrent la serialisation de modeles en JSON:API, le standard API REST le plus utilise dans l'ecosysteme Rails. Pour la conversion de JSON en objets Ruby avec validation des types et coercition dans les projets Ruby modernes (2022-2025), les gems les plus utilisees sont : dry-struct (de la famille dry-rb) qui definit des types avec coercition automatique et validation de schema ; Sorbet avec T::Struct pour le typage statique au moment de l'execution ; et ActiveModel::Attributes dans Rails qui permet de definir des attributs types dans des modeles non-ActiveRecord. L'outil presente ici genere le code de base qui peut servir de point de depart pour n'importe lequel de ces schemas plus avances, ou etre utilise directement quand la simplicite est la priorite.