ToolActToolAct

Convertisseur XML en JSON

Entrée XML
Sortie JSON
Lignes: 1Caractères: 0Octets: 0
Lignes: 1Caractères: 0Octets: 0

Qu'est-ce que la conversion XML en JSON ?

XML to JSON convertit un balisage XML en structure JSON afin de manipuler les données plus facilement dans JavaScript, des API, outils no-code ou pipelines modernes. Le mapping n’est pas toujours évident, car XML possède éléments, attributs, nœuds texte, espaces de noms, ordre et nœuds répétés, tandis que JSON utilise objets, tableaux et valeurs simples. L’outil sert aux intégrations legacy, réponses SOAP, sitemaps, flux RSS, configurations et données de test. En production, il faut examiner gestion des attributs, éléments vides, contenu mixte, namespaces et détection des tableaux. Un JSON parsé correctement ne garantit pas que toute l’information métier est préservée comme prévu.

Comment utiliser

Comment utiliser

  1. Collez ou saisissez des données XML dans la zone de saisie de gauche
  2. Sélectionnez la taille d'indentation (2 espaces, 4 espaces ou Tab)
  3. Le JSON converti s'affiche à droite avec coloration syntaxique
  4. Vérifiez le résultat de la conversion et corrigez les éventuelles erreurs XML
  5. Cliquez sur Copier ou sur Télécharger pour enregistrer le résultat

Notes sur la structure des données

  • Les attributs XML, nœuds répétés, espaces de noms et texte mixte peuvent se mapper en JSON de plusieurs façons valides ; inspectez la structure générée avant de l'utiliser.
  • Pour la migration d'API, définissez une règle de correspondance des champs plutôt que de vous fier à une seule conversion d'exemple.

Cas d’utilisation

Transformer une charge XML en JSON lisible pour inspectionCollez du XML SOAP, RSS, d’appareil ou de partenaire et le DOMParser du navigateur convertit le document en objet JSON qui conserve l’élément racine, imbrique les éléments enfants et regroupe les noms d’enfants répétés en tableaux. Le texte numérique et les valeurs true ou false sont convertis quand ils sont suffisamment simples à reconnaître. Le parseur suit la spécification W3C DOM Level 3 Core, toute entrée XML 1.0 bien formée acceptée par DOMParser produit un arbre parcourable, et l’étape JSON parcourt simplement cet arbre en profondeur, comptant les doublons frères pour décider entre un objet unique et un tableau JSON.
Préparer des données d’exemple avant de remplacer une intégration XMLUtilisez l’éditeur à deux panneaux pour comparer le XML d’origine avec le JSON formaté, puis copiez ou téléchargez output.json pour une note de migration, une fixture de test ou une discussion API. L’indentation peut basculer entre 2 espaces, 4 espaces et tabulations pour correspondre au code cible.
Détecter du XML malformé avant qu’il n’atteigne un processus gourmand en parsingLe convertisseur affiche les erreurs de parsing du parseur XML du navigateur au lieu de produire silencieusement une sortie partielle. Il se concentre sur les éléments et le contenu texte, les attributs, espaces de noms, commentaires, instructions de traitement et la validation de schéma nécessitent encore un outil XML dédié lorsque ces détails comptent.
Décider comment les attributs deviennent des clés JSONLorsqu’un élément mélange attributs et éléments enfants, les attributs sont généralement préfixés par @ pour éviter les collisions avec le contenu texte ou les enfants nommés. Inspectez le JSON généré pour les champs comme @id ou @type et renommez-les dans le code consommateur si une structure de clés plates est préférée. Le mapping conventionnel est `@attribute` pour les attributs XML, `#text` pour les données texte adjacentes aux éléments enfants, et le nom local de chaque enfant, reflétant la convention Badgerfish utilisée par de nombreuses bibliothèques JSON-XML.
Repérer les fichiers XML que le convertisseur simplifie volontairementLes documents qui reposent sur les attributs, espaces de noms, instructions de traitement, commentaires ou blocs CDATA perdront des détails dans la sortie JSON. Considérez le résultat comme une vue rapide et lisible, pas une cible de migration sans perte, lorsque ces fonctionnalités XML portent les données métier. La détection de tableaux ne se déclenche que sur les noms d’éléments enfants répétés, un seul `<item>` et deux `<product>` frères se réduisent donc en un objet à deux clés plutôt qu’en liste, et la notation Clark d’espace de noms `{http://example.com/ns}user` est supprimée du nom local `user`, ce qui peut entrer en collision avec un autre élément sans espace de noms portant le même nom.

Principe technique

La conversion commence par l'analyseur XML intégré au navigateur. `new DOMParser().parseFromString(xmlString, 'application/xml')` renvoie un `Document` conforme au W3C DOM Level 3 Core, qui valide la conformité syntaxique par rapport à XML 1.0 (Cinquième édition) et expose le résultat sous forme d'un arbre de nœuds `Element`, `Attr`, `Text`, `CDATASection` et `Comment`. Si l'entrée est mal formée, l'analyseur ne lance pas d'exception — il renvoie un document dont l'élément racine est `<parsererror>` contenant l'emplacement et la raison, de sorte que le convertisseur vérifie d'abord `doc.querySelector('parsererror')` et affiche ce message au lieu de produire un JSON partiel. Le mapping arbre-vers-JSON parcourt le document en profondeur selon une convention de type Badgerfish. Chaque élément devient une propriété dont la clé est le nom local ; les éléments enfants deviennent des objets imbriqués ; les attributs d'élément sont aplanis avec un préfixe `@` (ex. `<user id="7">` → `{ "user": { "@id": "7" } }`) ; le contenu textuel adjacent aux éléments enfants est stocké sous `#text`. Les éléments frères répétés portant le même nom se replient en tableau JSON : deux nœuds `<item>` deviennent `"item": [ ... ]`, mais un seul `<item>` reste un objet simple — c'est l'ambiguïté bien connue « unique versus multiple », car XML ne peut pas distinguer une liste à un élément d'une valeur scalaire tandis que JSON traite `"item": {...}` et `"item": [{...}]` comme des formes différentes. Plusieurs fonctionnalités XML n'ont pas d'équivalent JSON propre et sont volontairement avec perte. L'ordre des éléments est préservé par XML mais non garanti par l'ordre des clés d'objet JSON chez tous les consommateurs (bien qu'ES2015 spécifie l'ordre d'insertion pour les clés de type chaîne, les schémas comme JSON Schema ne le contraignent pas). Le contenu mixte comme `<p>Hello <b>world</b>!</p>` entrelace du texte avec des éléments et ne peut pas faire un aller-retour dans le modèle simple clé-valeur. Les espaces de noms XML en notation Clark (`{http://example.com/ns}user`) se réduisent au nom local `user`, ce qui peut entrer en collision avec un élément sans rapport portant le même nom. Les blocs CDATA comme `<![CDATA[<raw>]]>` sont déballés en texte brut. Les instructions de traitement (`<?xml-stylesheet ...?>`), les commentaires (`<!-- ... -->`) et la déclaration XML sont supprimés car JSON n'a pas de syntaxe pour eux. L'indentation est appliquée via `JSON.stringify(value, null, indent)` avec 2 espaces, 4 espaces ou `'\t'`.

  • Analyseur : `new DOMParser().parseFromString(xml, 'application/xml')` selon W3C DOM Level 3 Core ; les erreurs apparaissent sous forme d'un élément racine `<parsererror>`, pas d'une exception levée.
  • Conventions de mapping : `@attr` de style Badgerfish pour les attributs, `#text` pour le texte mixte, nom local de l'élément pour les enfants ; Parker supprime les attributs, Spark les conserve dans `$`.
  • Les enfants répétés portant le même nom se replient en tableau JSON ; un enfant unique reste un objet — l'ambiguïté classique « unique versus multiple » n'a pas de côté solution XML.
  • Fonctionnalités avec perte : attributs (sans préfixe `@`), espaces de noms (`xmlns:foo`), instructions de traitement, commentaires, déclaration XML et enveloppes CDATA.
  • Le contenu mixte (`<p>Hello <b>world</b>!</p>`) ne peut pas faire un aller-retour dans un JSON clé-valeur ; l'ordre des éléments peut être perdu chez les consommateurs qui ne préservent pas l'ordre des clés.
  • La conversion nombre/booléen est un choix délibéré : `<age>30</age>` peut devenir `30` (nombre) ou `"30"` (chaîne) ; les zéros en tête (`007`) doivent rester des chaînes.
  • Le formatage de sortie utilise `JSON.stringify(value, null, indent)` avec une indentation de 2 espaces, 4 espaces ou `'\t'` ; le résultat est en UTF-8 sans BOM.

Exemples

Élément simple

&lt;root>
  &lt;name>John&lt;/name>
&lt;/root>
→
{"root": {"name": "John"}}

Éléments répétés

&lt;root>
  &lt;item>A&lt;/item>
  &lt;item>B&lt;/item>
&lt;/root>
→
{"root": {"item": ["A", "B"]}}

Structure imbriquée

&lt;root>
  &lt;user>
    &lt;name>John&lt;/name>
    &lt;age>30&lt;/age>
  &lt;/user>
&lt;/root>
→
{"root": {"user": {"name": "John", "age": 30}}}

FAQ

Comment les éléments XML sont-ils mappés en JSON ?

Chaque élément devient une propriété JSON dont la valeur est le contenu de l'élément (chaîne ou objet imbriqué). Les éléments répétés portant le même nom deviennent des tableaux. Les attributs sont généralement préfixés par '@' ou stockés sous une clé spéciale comme '$'. La convention exacte varie et est configurable sur la plupart des pages.

Pourquoi la conversion XML vers JSON est-elle parfois lossy ?

XML distingue les éléments, les attributs, le contenu textuel, le contenu mixte (texte et éléments), les espaces de noms, les instructions de traitement et les commentaires. JSON ne possède que des objets, des tableaux, des chaînes, des nombres, des booléens et null. Mapper l'arbre XML plus riche vers JSON fait perdre des informations sur l'ordre et la distinction élément/attribut.

Comment les éléments à contenu mixte (texte + enfants) sont-ils gérés ?

Le contenu mixte est délicat :

Hello world!

n'a pas de représentation JSON propre. La page utilise généralement une clé spéciale (par exemple '#text' ou '$') pour capturer le texte libre, mais l'ordre entre texte et éléments n'est pas toujours préservé. Évitez le contenu mixte si vous prévoyez un aller-retour.

Et les espaces de noms XML ?

Les éléments préfixés (<ns:foo>) deviennent des clés de chaîne 'ns:foo' ou sont scindés en propriétés ns/local-name. Les déclarations xmlns peuvent être préservées comme des propriétés de type attribut ou supprimées, selon la configuration de la page.

Puis-je revenir du JSON à un XML identique ?

L'aller-retour n'est pas sans perte en général, en particulier pour le contenu mixte, les commentaires, les instructions de traitement et l'ordre des attributs. Pour du XML purement données (configuration, enregistrements simples), l'aller-retour fonctionne généralement. Pour du XML de type document (DocBook, HTML, RSS), utilisez un véritable analyseur XML.

Un élément XML vide <foo/> est-il identique à <foo></foo> ?

Oui pour l'analyseur. Les deux produisent une propriété foo avec une chaîne vide ou la valeur null. La syntaxe auto-fermante n'est qu'une question de présentation en XML.

La conversion est-elle locale ?

Oui. L'analyse XML et la génération JSON ont lieu dans votre navigateur. La page ne téléverse pas vos données.

Outils associés

Convertisseur JSON vers XML

Convertisseur gratuit JSON vers XML en ligne avec élément racine personnalisable et indentation. Convertissez instantanément les données JSON en XML formaté dans votre navigateur.

Outil de Formatage XML

Formateur XML en ligne gratuit avec auto-indentation, validation et minification. Personnalisez les paramètres d'indentation, détectez rapidement les erreurs de format XML.

Outil de Formatage JSON

Formateur JSON en ligne gratuit avec coloration syntaxique, détection d'erreurs et minification. Formatez les données JSON instantanément, détectez les erreurs de format, améliorez votre flux de développement.

Convertisseur CSV vers JSON

Convertisseur gratuit CSV vers JSON en ligne avec support de délimiteur personnalisé et option d'en-tête première ligne. Convertissez rapidement les données tabulaires en format JSON.

Outil de Formatage YAML

Formateur YAML en ligne gratuit avec vérification de syntaxe, auto-indentation et conversion de format. Gérez facilement les fichiers de configuration, repérez instantanément les problèmes de syntaxe.

Convertisseur Excel vers JSON

Convertisseur Excel vers JSON en ligne. Prend en charge les formats .xlsx et .xls avec sélection multiple de feuilles. Convertissez les données de feuille de calcul en format JSON localement.