Convertisseur XML vers JSON

Parse le XML en un objet JSON selon les conventions de fast-xml-parser : les éléments enfants deviennent des propriétés d'objet, les enfants répétés deviennent des tableaux, les attributs sont préservés avec le préfixe `@_` sur l'objet parent, et le contenu textuel des nœuds mixtes atterrit sur une clé `#text`. Les valeurs numériques et booléennes d'attribut sont auto-typées via `parseAttributeValue: true` — un XML `count="42"` fait un aller-retour comme `"@_count": 42`, pas la chaîne `"42"`.

Exemple

Entrée XML :

<root version="1">
  <name>Ada</name>
  <tags>math</tags>
  <tags>logic</tags>
</root>

Sortie JSON :

{
  "root": {
    "@_version": 1,
    "name": "Ada",
    "tags": ["math", "logic"]
  }
}

Pièges XML courants et comment les gérer

XML a des cas limites que JSON n'a pas. Voici les motifs qui produisent des sorties surprenantes.

• Enfant unique vs. enfants multiples. `<a><b/></a>` produit `{"a":{"b":""}}` (enfant unique en tant que propriété d'objet), mais `<a><b/><b/></a>` produit `{"a":{"b":["",""]}}` (multiple en tableau). Si votre code aval attend toujours un tableau, normalisez après conversion.
• Attributs vs. éléments enfants. Les attributs apparaissent avec préfixe `@_` au même niveau que les enfants. `<user id="1"><name>Ada</name></user>` devient `{"user":{"@_id":1,"name":"Ada"}}`. Certains outils fusionnent les attributs avec les propriétés — c'est une convention différente de celle utilisée ici.
• Contenu mixte (texte + éléments enfants). `<p>Hello <b>world</b></p>` produit `{"p":{"#text":"Hello ","b":"world"}}`. Le texte est capturé mais sa position relative aux enfants est perdue — JSON n'a pas de moyen de représenter du contenu mixte ordonné. La plupart des XML de configuration ne tombent pas sur ce cas.
• Espaces de noms. Les namespaces (`<x:foo xmlns:x="...">`) sont préservés dans le nom de l'élément (`x:foo`). Beaucoup de consommateurs XML retirent le préfixe ; si vous en avez besoin, faites-le en post-traitement.
• Sections CDATA. `<![CDATA[some text]]>` est parsé comme texte simple et rejoint le `#text` de son parent. L'encadrement CDATA est perdu — convient à la plupart des cas mais à noter si l'encadrement avait un sens sémantique.
• Auto-fermant vs. vide. `<x/>` et `<x></x>` sont équivalents en XML et produisent la même sortie JSON (`""` pour la valeur). L'encadrement original n'est pas récupérable depuis le JSON.

Pourquoi ma sortie a-t-elle un préfixe `@_` sur les attributs ?

Cela distingue les attributs XML des éléments enfants. Sans préfixe, `<user id="1"><id>foo</id></user>` aurait deux clés `id` — un objet JSON ne peut en avoir qu'une. Le préfixe rend les deux aller-retournables. Si vous n'en avez pas besoin, remplacez `"@_"` par `""` en post-traitement (et acceptez le risque de collision).

Puis-je obtenir le JSON sans la clé racine englobante ?

XML a toujours un élément racine unique. Le JSON garde cette enveloppe pour l'aller-retour. Retirez-la après conversion si vous voulez l'objet interne — `result.root` plutôt que `result`.

Les commentaires XML sont-ils préservés ?

Non. JSON n'a pas de syntaxe de commentaires, et le parser est configuré pour ignorer les commentaires XML. Pour préserver des commentaires, il faudrait utiliser une représentation intermédiaire différente qui les supporte.

Les valeurs d'attributs sont-elles typées ?

Oui — `parseAttributeValue: true` est activé, donc `count="42"` devient `"@_count": 42` (nombre) et `enabled="true"` devient `"@_enabled": true` (booléen). Si vous avez besoin d'attributs en chaînes, post-traitez ou modifiez la config.

Mon XML est-il téléchargé ?

Non. Tout s'exécute dans votre navigateur — votre XML est parsé par le JavaScript de cette page et n'est jamais envoyé à un serveur. Vérifiez dans les outils développeur.

Peut-il gérer de très gros fichiers XML ?

Jusqu'à environ 30 Mo avant que le textarea ne ralentisse. Le parser scale linéairement. Pour des entrées plus grosses, lancez fast-xml-parser en ligne de commande — même bibliothèque.