XML vs JSON : Comprendre les formats de données pour les APIs et les fichiers de configuration

Visualisation de données sur un moniteur

Toute application qui communique avec l'extérieur échange des données dans un format structuré. XML a dominé les années 2000. JSON a pris le dessus dans les années 2010. Mais XML n'a pas disparu — il est au cœur des APIs SOAP, des flux RSS, des graphiques SVG, des interfaces Android et d'innombrables systèmes d'entreprise. Maîtriser ces deux formats fait de vous un développeur plus polyvalent.

JSON en bref

JSON (JavaScript Object Notation) est la lingua franca des APIs web modernes. Il correspond directement aux types de données présents dans la plupart des langages de programmation :

{
  "user": {
    "id": 42,
    "name": "Alice Chen",
    "roles": ["admin", "editor"],
    "active": true,
    "score": 98.6,
    "avatar": null
  }
}

Types : string, number, boolean, null, array, object.

JSON est concis, lisible par l'humain et analysé sans difficulté dans tous les langages. C'est le format par défaut pour les APIs REST, les fichiers de configuration et le stockage navigateur.

XML en bref

XML (eXtensible Markup Language) représente les données sous forme d'arbre d'éléments balisés :

<?xml version="1.0" encoding="UTF-8"?>
<user id="42">
  <name>Alice Chen</name>
  <roles>
    <role>admin</role>
    <role>editor</role>
  </roles>
  <active>true</active>
  <score>98.6</score>
</user>

XML est verbeux mais expressif. Il prend en charge les attributs (comme id="42" ci-dessus), les espaces de noms (pour mélanger des vocabulaires), les commentaires, les instructions de traitement et les schémas pour une validation stricte.

Comparaison côte à côte

Fonctionnalité	JSON	XML
Verbosité	Compact	Verbeux
Types de données	6 types natifs	Tout est texte
Commentaires	❌ Non supporté	✅ `<!-- -->`
Attributs	❌ Pas de concept	✅ Oui
Espaces de noms	❌ Pas de concept	✅ Oui
Schémas	JSON Schema	XSD, DTD, RelaxNG
Langage de requête	JSONPath, jq	XPath, XQuery
Transformations XSLT	❌	✅
Lisibilité humaine	Élevée	Moyenne
Complexité d'analyse	Faible	Plus élevée

Quand utiliser JSON

Les APIs REST (pratiquement universel)
Le localStorage / sessionStorage du navigateur
Les fichiers de configuration (package.json, tsconfig.json)
Les bases de données NoSQL orientées documents (MongoDB, Firestore)
La communication inter-services dans les microservices
Partout où vous avez besoin d'un échange de données rapide et léger

Quand utiliser XML

Les services web SOAP (finance, santé, administration)
Les flux RSS et Atom
Les graphiques SVG
Les fichiers de ressources Android (layouts, strings, manifests)
Les formats de documents Office (.docx, .xlsx sont des fichiers ZIP contenant du XML)
Lorsque vous avez besoin de contenu mixte (texte avec balises inline)
Les systèmes d'entreprise qui n'ont pas encore migré vers JSON

Conversion entre les formats

La conversion de XML vers JSON est rarement un mapping 1:1 — XML possède des concepts (attributs, nœuds texte, espaces de noms) qui n'existent pas en JSON. Stratégies courantes :

Les attributs deviennent des propriétés

<user id="42" active="true">Alice</user>

Peut devenir :

{ "@id": "42", "@active": "true", "#text": "Alice" }

Ou aplati :

{ "id": 42, "active": true, "name": "Alice" }

La bonne approche dépend de votre cas d'usage. Utilisez notre Convertisseur XML vers JSON pour effectuer la conversion avec des options de gestion des attributs.

Validation de JSON avec JSON Schema

JSON Schema vous permet de définir la structure attendue d'un document JSON :

{
  "$schema": "http://json-schema.org/draft-07/schema#",
  "type": "object",
  "required": ["id", "name", "email"],
  "properties": {
    "id": { "type": "integer", "minimum": 1 },
    "name": { "type": "string", "minLength": 1 },
    "email": { "type": "string", "format": "email" },
    "roles": {
      "type": "array",
      "items": { "type": "string" }
    }
  }
}

Validez vos documents JSON par rapport à des schémas avec notre Validateur JSON Schema — détectez les erreurs structurelles avant qu'elles n'atteignent la production.

JSONPath : interroger des données imbriquées

JSONPath est à JSON ce que XPath est à XML. Syntaxe de requête :

$.store.book[*].author          — tous les auteurs
$.store.book[0].title           — titre du premier livre
$.store.book[?(@.price < 10)]   — livres à moins de 10 $
$..price                        — toutes les valeurs de prix où qu'elles soient

Équivalents XPath pour XML :

/store/book/author               — tous les auteurs
/store/book[1]/title             — titre du premier livre
/store/book[@price < 10]         — livres à moins de 10 $
//price                          — toutes les valeurs de prix où qu'elles soient

Mise en forme et pretty-printing

Les deux formats deviennent illisibles lorsqu'ils sont minifiés. Utilisez toujours le pretty-print pour le débogage et la relecture humaine.

JSON minifié :

{"user":{"id":42,"name":"Alice Chen","roles":["admin","editor"]}}

JSON formaté (indentation de 2 espaces) :

{
  "user": {
    "id": 42,
    "name": "Alice Chen",
    "roles": [
      "admin",
      "editor"
    ]
  }
}

Utilisez notre Formateur JSON pour formater, minifier et valider du JSON instantanément. Pour comparer deux blocs JSON, JSON Diff met en évidence exactement ce qui a changé.

Pièges courants

JSON

Les virgules finales — invalides en JSON (mais valides en JavaScript)
Les guillemets simples — JSON exige des guillemets doubles pour les chaînes
Les nombres sous forme de chaînes — "42" ≠ 42 ; soyez cohérent
L'imbrication profonde — difficile à lire et à interroger ; aplatissez si possible

XML

Les caractères non échappés — <, >, &, ", ' doivent être échappés en entités
Le BOM en début de fichier — certains parseurs échouent sur un BOM UTF-8
La confusion des espaces de noms — facile de se tromper dans les documents à vocabulaires mixtes

Les deux formats sont bien compris, bien outillés et là pour durer. Sachez quand utiliser chacun d'eux, validez vos données, et vos intégrations seront bien plus fiables.