XML vs JSON: Datenformate für APIs und Konfigurationsdateien verstehen

Jede Anwendung, die mit der Außenwelt kommuniziert, tauscht Daten in einem strukturierten Format aus. XML dominierte die 2000er Jahre. JSON übernahm in den 2010ern. Doch XML ist nicht verschwunden – es treibt SOAP APIs, RSS-Feeds, SVG-Grafiken, Android-Layouts und unzählige Unternehmenssysteme an. Beide Formate zu verstehen macht dich zu einem vielseitigeren Entwickler.

JSON auf einen Blick

JSON (JavaScript Object Notation) ist die Lingua franca moderner Web-APIs. Es bildet die Datentypen der meisten Programmiersprachen direkt ab:

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

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

JSON ist kompakt, menschenlesbar und lässt sich in jeder Sprache problemlos parsen. Es ist der Standard für REST APIs, Konfigurationsdateien und Browser-Speicher.

XML auf einen Blick

XML (eXtensible Markup Language) stellt Daten als Baum aus getaggten Elementen dar:

<?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 ist ausführlich, aber ausdrucksstark. Es unterstützt Attribute (wie id="42" oben), Namespaces (zum Mischen von Vokabularen), Kommentare, Verarbeitungsanweisungen und Schemas zur strikten Validierung.

Direkter Vergleich

Merkmal	JSON	XML
Ausführlichkeit	Kompakt	Ausführlich
Datentypen	6 native Typen	Alles ist Text
Kommentare	❌ Nicht unterstützt	✅ <!-- -->
Attribute	❌ Kein Konzept	✅ Ja
Namespaces	❌ Kein Konzept	✅ Ja
Schemas	JSON Schema	XSD, DTD, RelaxNG
Abfragesprache	JSONPath, jq	XPath, XQuery
XSLT-Transformationen	❌	✅
Menschenlesbarkeit	Hoch	Mittel
Parse-Komplexität	Niedrig	Höher

Wann JSON verwenden

• REST APIs (nahezu universell)
• Browser localStorage / sessionStorage
• Konfigurationsdateien (package.json, tsconfig.json)
• NoSQL-Dokumentenspeicher (MongoDB, Firestore)
• Kommunikation zwischen Diensten in Microservices
• Überall dort, wo ein schneller, schlanker Datenaustausch benötigt wird

Wann XML verwenden

• SOAP-Webdienste (Finanzen, Gesundheitswesen, Behörden)
• RSS- und Atom-Feeds
• SVG-Grafiken
• Android-Ressourcendateien (Layouts, Strings, Manifests)
• Office-Dokumentformate (.docx, .xlsx sind ZIP-Dateien mit XML-Inhalt)
• Wenn gemischter Inhalt benötigt wird (Text mit eingebettetem Markup)
• Unternehmenssysteme, die noch nicht auf JSON migriert sind

Zwischen Formaten konvertieren

Die Konvertierung von XML nach JSON ist selten eine 1:1-Zuordnung – XML kennt Konzepte (Attribute, Textknoten, Namespaces), die in JSON nicht existieren. Gängige Strategien:

Attribute werden zu Eigenschaften

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

Könnte werden:

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

Oder vereinfacht:

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

Der richtige Ansatz hängt vom jeweiligen Anwendungsfall ab. Nutze unseren XML to JSON Converter, um die Konvertierung mit Optionen zur Attributbehandlung durchzuführen.

JSON mit JSON Schema validieren

JSON Schema ermöglicht es, die erwartete Struktur eines JSON-Dokuments zu definieren:

{
  "$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" }
    }
  }
}

Validiere deine JSON-Dokumente gegen Schemas mit unserem JSON Schema Validator – erkenne Strukturfehler, bevor sie in die Produktion gelangen.

JSONPath: Verschachtelte Daten abfragen

JSONPath verhält sich zu JSON wie XPath zu XML. Abfragesyntax:

$.store.book[*].author          — alle Autoren
$.store.book[0].title           — Titel des ersten Buchs
$.store.book[?(@.price < 10)]   — Bücher unter 10 $
$..price                        — alle Preiswerte überall

XPath-Entsprechungen für XML:

/store/book/author               — alle Autoren
/store/book[1]/title             — Titel des ersten Buchs
/store/book[@price < 10]         — Bücher unter 10 $
//price                          — alle Preiswerte überall

Formatieren und Pretty-Printing

Beide Formate werden nach der Minimierung unleserlich. Immer pretty-printen für Debugging und manuelle Überprüfung.

Minimiertes JSON:

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

Pretty-gedrucktes JSON (2-Leerzeichen-Einrückung):

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

Nutze unseren JSON Formatter, um JSON sofort zu formatieren, zu minimieren und zu validieren. Zum Vergleichen zweier JSON-Dokumente zeigt JSON Diff genau an, was sich geändert hat.

Häufige Fallstricke

JSON

• Nachgestellte Kommas — in JSON nicht gültig (aber in JavaScript erlaubt)
• Einfache Anführungszeichen — JSON erfordert doppelte Anführungszeichen für Strings
• Zahlen als Strings — "42" ≠ 42; konsequent bleiben
• Tiefe Verschachtelung — schwer zu lesen und abzufragen; wenn möglich vereinfachen

XML

• Nicht escapte Zeichen — <, >, &, ", ' müssen als Entities escapt werden
• BOM am Anfang — manche Parser haben Probleme mit UTF-8 BOM
• Namespace-Verwirrung — in Dokumenten mit gemischtem Vokabular leicht falsch gemacht

Beide Formate sind gut verstanden, gut unterstützt und werden bleiben. Wer weiß, wann welches einzusetzen ist, und seine Daten validiert, wird deutlich zuverlässigere Integrationen erreichen.