Convertisseur JSON vers XML

Qu'est-ce que la Conversion JSON vers XML et Comment Fonctionne-t-elle ?

// Convert JSON to XML in Node.js using fast-xml-parser
import { XMLBuilder } from 'fast-xml-parser';

const data = {
  catalog: {
    product: {
      '@_id': 'P01',
      '@_category': 'electronics',
      name: 'Wireless Headphones',
      price: {
        '@_currency': 'USD',
        '#text': '79.99'
      }
    }
  }
};

const builder = new XMLBuilder({
  attributeNamePrefix: '@_',   // @_ keys become XML attributes
  textNodeName: '#text',       // #text key becomes element text content
  ignoreAttributes: false,     // process @_ attribute keys
  format: true,                // pretty-print with indentation
  indentBy: '  ',              // 2-space indent
});

const xml = builder.build(data);
console.log(xml);
// <catalog>
//   <product id="P01" category="electronics">
//     <name>Wireless Headphones</name>
//     <price currency="USD">79.99</price>
//   </product>
// </catalog>

Fonctionnalités clés

Exemples

{"user":{"id":42,"name":"Alice Kim","email":"alice@example.com","role":"admin","address":{"city":"Seoul","country":"KR"}}}

[{"id":1,"name":"Widget A","price":9.99},{"id":2,"name":"Widget B","price":14.99},{"id":3,"name":"Widget C","price":4.49}]

{"catalog":{"product":{"@_id":"P01","@_category":"electronics","name":"Wireless Headphones","price":{"@_currency":"USD","#text":"79.99"}}}}

Comment utiliser

1. 1

   Collez votre JSON

   Saisissez ou collez vos données JSON dans le champ de saisie ci-dessus. Vous pouvez aussi cliquer sur « Charger un exemple » pour essayer un échantillon — un objet de réponse API, une charge utile tableau ou un objet utilisant des attributs @_ et #text.

2. 2

   Consultez la sortie XML en direct

   Le XML apparaît instantanément dans le panneau de sortie. Les objets à clé unique utilisent leur clé comme racine ; les objets à plusieurs clés sont enveloppés dans ; les clés préfixées par @_ deviennent des attributs ; les tableaux deviennent des éléments enfants répétés. Ajustez l'indentation (2 ou 4 espaces) selon vos besoins.

3. 3

   Copiez ou téléchargez

   Cliquez sur Copier pour récupérer le XML dans votre presse-papiers, ou sur Télécharger pour le sauvegarder en fichier .xml. Pour valider ou reformater le résultat, collez-le dans le Formateur XML.

Pièges courants de conversion

// Input: { "status": 200, "data": { "id": 1 } }
// Output: <root><status>200</status><data><id>1</id></data></root>
// Root is <root> — may not match your schema

// Wrap in a named key to control the root element
// Input: { "response": { "status": 200, "data": { "id": 1 } } }
// Output: <response><status>200</status><data><id>1</id></data></response>

// Input: [{ "id": 1 }, { "id": 2 }]
// Output: <root><item><id>1</id></item><item><id>2</id></item></root>
// Tag names are generic

// Wrap in a named key for meaningful tag names
// Input: { "products": [{ "id": 1 }, { "id": 2 }] }
// Output: <root><products><id>1</id></products><products><id>2</id></products></root>
// Each array element reuses the key name "products" as its tag

// Input: { "tag": { "id": "42", "name": "Alice" } }
// Output: <tag><id>42</id><name>Alice</name></tag>  ← id is a child element

// Use @_ prefix for attributes
// Input: { "tag": { "@_id": "42", "name": "Alice" } }
// Output: <tag id="42"><name>Alice</name></tag>  ← id is an attribute

// Input: { "price": { "@_currency": "USD", "value": "29.99" } }
// Output: <price currency="USD"><value>29.99</value></price>
// Text is a child element, not text content

// Use #text for element text content
// Input: { "price": { "@_currency": "USD", "#text": "29.99" } }
// Output: <price currency="USD">29.99</price>  ← text content

// JSON key starts with digit — invalid XML element name
// Input: { "1stItem": "value" }
// Output: <1stItem>value</1stItem>  ← invalid XML

// Use a valid XML element name
// Input: { "firstItem": "value" }
// Output: <firstItem>value</firstItem>  ← valid XML

// JSON: { "query": "name = 'Alice' & role = 'admin'" }
// Converter outputs: <query>name = 'Alice' &amp; role = 'admin'</query>
// If double-processed: &amp;amp; — consumer is re-escaping

// Converter output is correct — consume it as XML, not as a raw string
// <query>name = 'Alice' &amp; role = 'admin'</query>
// XML parser decodes to: name = 'Alice' & role = 'admin'

Cas d'utilisation courants

Appel de services web SOAP et XML hérités

Construisez la charge utile JSON dans votre application, convertissez-la en XML et envoyez-la en POST au point de terminaison SOAP. Cela évite la construction manuelle de chaînes XML et vous permet de travailler avec les données dans une structure JSON native jusqu'au moment où vous devez la sérialiser pour le service hérité.

Génération de fichiers de configuration XML

Spring, Maven, Ant, Tomcat et Android utilisent tous des formats de configuration XML. Générez ou transformez les données de configuration en JSON — plus facile à comparer et versionner — puis convertissez en XML pour le déploiement.

Production de Sitemap et flux RSS en XML

Les systèmes de gestion de contenu et les générateurs de sites statiques stockent souvent les métadonnées de pages en JSON. Convertissez ces métadonnées en XML sitemap.xml ou flux RSS pour les soumettre aux moteurs de recherche ou syndiquer le contenu vers des lecteurs de flux.

Intégration de données d'entreprise (EDI / ERP / CRM)

Les systèmes ERP (SAP, Oracle), les plateformes CRM et les réseaux EDI échangent couramment des données en XML. Convertissez les exports JSON des APIs REST modernes en XML pour alimenter ces systèmes sans construire un sérialiseur XML personnalisé.

Fichiers de ressources Android

Les ressources de chaînes Android, les contraintes de mise en page et les entrées de manifeste sont tous du XML. Générez ou mettez à jour les fichiers de ressources programmatiquement depuis des sources de données JSON et convertissez au format XML requis par le système de build Android.

Génération de SVG et de graphiques vectoriels

SVG est du XML. Construisez la structure SVG comme données JSON — chemins, formes, couleurs, transformations — puis convertissez en XML pour produire des fichiers SVG valides pour le web, l'impression ou les outils d'édition vectorielle.

Détails techniques

Analyse JSON conforme à RFC 8259

L'entrée JSON est analysée avec le JSON.parse() natif du navigateur, entièrement conforme à RFC 8259. Cela fournit des messages d'erreur de syntaxe précis avec des informations de position au mieux (numéros de ligne et de colonne) et gère tous les types de données JSON : chaînes, nombres, booléens, null, tableaux et objets.

Sérialiseur JSON vers XML récursif personnalisé

Après l'analyse, un sérialiseur récursif personnalisé parcourt l'arborescence JSON. Les clés d'objets commençant par @_ sont émises comme attributs XML sur l'élément parent. La clé #text est émise comme contenu textuel de l'élément. Les clés d'objets ordinaires deviennent des éléments enfants. Les valeurs de tableaux produisent des éléments frères répétés du même nom. Les caractères spéciaux (<, >, &, ", ') dans le contenu textuel et les valeurs d'attributs sont échappés en leurs références d'entité XML.

Normalisation de la racine

XML requérant exactement un élément racine, le sérialiseur applique la normalisation de la racine avant de construire le document : les objets à clé unique utilisent la clé comme racine ; les objets à plusieurs clés et les tableaux de niveau supérieur reçoivent un wrapper synthétique . Cela garantit que la sortie est toujours du XML bien formé quelle que soit la forme de l'entrée.

100 % basé sur le navigateur — Aucun envoi, aucun serveur

Tout le traitement s'exécute dans le moteur JavaScript de votre navigateur. Aucune donnée n'est transmise sur le réseau à aucun moment. Les entrées de plus de 200 Ko passent automatiquement du mode en direct au mode manuel (nécessitant un clic explicite sur Convertir) pour maintenir la réactivité du navigateur lors d'une sérialisation intensive.

Bonnes pratiques

Contrôlez l'élément racine avec un objet à clé unique

La façon la plus propre de produire du XML significatif est de s'assurer que votre JSON de niveau supérieur est un objet à clé unique dont la clé est le nom de l'élément racine souhaité. Envelopper les données à plusieurs clés sous une clé nommée vous donne une racine sémantiquement significative au lieu du wrapper générique .

Utilisez @_ et #text pour du XML à attributs nombreux

Si votre schéma XML cible utilise de nombreux attributs (courant dans les fichiers de configuration, SVG et les enveloppes SOAP), restructurez votre JSON pour utiliser des clés préfixées par @_ et #text avant de convertir. Le XML résultant correspondra exactement au schéma cible sans post-traitement.

Enveloppez les tableaux dans des objets nommés pour des noms de balises significatifs

Un tableau de niveau supérieur produit le motif générique ..., où est un nom littéral fixe. Envelopper le tableau sous une clé nommée — { "products": [...] } — produit des éléments répétés (le nom de la clé est réutilisé pour chaque élément du tableau) sous un wrapper . Cela donne un nom de balise significatif pour le domaine et est presque toujours préférable pour du XML qui sera analysé ou validé par un schéma.

Validez la sortie avec le Formateur XML

Après la conversion, collez la sortie XML dans le Formateur XML pour valider la bonne formation, vérifier l'indentation et identifier tout problème structurel avant d'envoyer le XML à un service en aval ou de le committer dans le contrôle de version.

Nettoyez les clés JSON avant de convertir

Les noms d'éléments XML doivent commencer par une lettre ou un trait de soulignement et ne peuvent pas contenir d'espaces ni la plupart des caractères spéciaux. Si vos clés JSON proviennent d'une source externe (un nom de colonne de base de données, un nom de champ d'API ou une saisie utilisateur), vérifiez leur validité pour les noms XML avant de convertir pour éviter une sortie malformée.

Questions fréquentes