JSON vs XML: Vollständiger Vergleich der Datenformate

# JSON vs XML: Vollständiger Vergleich

Ein umfassender Vergleich zwischen den zwei beliebtesten Datenaustauschformaten.

Überblick

JSON (JavaScript Object Notation)

{
  "benutzer": {
    "name": "Max Mustermann",
    "alter": 30,
    "email": "max@example.de",
    "aktiv": true
  }
}

Hauptmerkmale:

• 🚀 Leichtgewichtig und kompakt
• 📖 Einfach zu lesen
• ⚡ Schnelles Parsen
• 🌐 Native JavaScript-Unterstützung

XML (eXtensible Markup Language)

<?xml version="1.0" encoding="UTF-8"?>
<benutzer>
  <name>Max Mustermann</name>
  <alter>30</alter>
  <email>max@example.de</email>
  <aktiv>true</aktiv>
</benutzer>

Hauptmerkmale:

• 📝 Erweiterbar und flexibel
• 🏷️ Unterstützt Attribute
• ✅ Strenge Validierung möglich
• 📚 Selbstdokumentierend

Detaillierter Syntax-Vergleich

1. Grundlegende Struktur

JSON - Minimalistisch:

{
  "buch": {
    "titel": "Python Programmierung",
    "autor": "Anna Schmidt",
    "jahr": 2026,
    "seiten": 350,
    "verfuegbar": true
  }
}

XML - Ausführlich:

<?xml version="1.0" encoding="UTF-8"?>
<buch>
  <titel>Python Programmierung</titel>
  <autor>Anna Schmidt</autor>
  <jahr>2026</jahr>
  <seiten>350</seiten>
  <verfuegbar>true</verfuegbar>
</buch>

2. Arrays/Listen

JSON - Native Array-Unterstützung:

{
  "buecher": [
    {
      "titel": "Buch 1",
      "isbn": "978-3-16-148410-0"
    },
    {
      "titel": "Buch 2",
      "isbn": "978-3-16-148411-7"
    },
    {
      "titel": "Buch 3",
      "isbn": "978-3-16-148412-4"
    }
  ]
}

XML - Wiederholende Elemente:

<buecher>
  <buch>
    <titel>Buch 1</titel>
    <isbn>978-3-16-148410-0</isbn>
  </buch>
  <buch>
    <titel>Buch 2</titel>
    <isbn>978-3-16-148411-7</isbn>
  </buch>
  <buch>
    <titel>Buch 3</titel>
    <isbn>978-3-16-148412-4</isbn>
  </buch>
</buecher>

3. Attribute vs. Eigenschaften

JSON - Nur Eigenschaften:

{
  "buch": {
    "id": "B001",
    "sprache": "de",
    "titel": "Mein Buch",
    "preis": {
      "wert": 29.99,
      "waehrung": "EUR"
    }
  }
}

XML - Attribute und Elemente:

<buch id="b001" sprache="de">
  <titel>Mein Buch</titel>
  <preis waehrung="EUR">29.99</preis>
</buch>

4. Datentypen

JSON - Typisierte Werte:

{
  "string": "Text",
  "zahl": 42,
  "dezimal": 3.14,
  "boolean": true,
  "null": null,
  "array": [1, 2, 3],
  "objekt": {"schluessel": "wert"}
}

XML - Alles ist Text:

<daten>
  <string>Text</string>
  <zahl>42</zahl>
  <dezimal>3.14</dezimal>
  <boolean>true</boolean>
  <null />
  <array>
    <item>1</item>
    <item>2</item>
    <item>3</item>
  </array>
</daten>

Leistungsvergleich

Dateigröße

Beispieldaten - JSON (143 Bytes):

{"benutzer":{"id":1,"name":"Max Mustermann","email":"max@example.de","alter":30,"aktiv":true}}

Beispieldaten - XML (198 Bytes):

<?xml version="1.0"?><benutzer><id>1</id><name>Max Mustermann</name><email>max@example.de</email><alter>30</alter><aktiv>true</aktiv></benutzer>

Ergebnis: JSON ist etwa 28% kleiner

Parse-Geschwindigkeit

JSON - JavaScript:

// Sehr schnell - native Funktion
const start = performance.now();
const daten = JSON.parse(jsonString);
const zeit = performance.now() - start;
console.log(JSON Parse: \\${zeit}ms);
// Typisch: 0.1-1ms für mittelgroße Dateien

XML - JavaScript:

// Langsamer - benötigt DOM-Parser
const start = performance.now();
const parser = new DOMParser();
const doc = parser.parseFromString(xmlString, "text/xml");
const zeit = performance.now() - start;
console.log(XML Parse: \\${zeit}ms);
// Typisch: 1-10ms für mittelgroße Dateien

Ergebnis: JSON ist 3-10x schneller

Speicherverbrauch

// JSON - Direktes Objekt
const jsonDaten = JSON.parse(jsonString);
// Geringer Speicherverbrauch

// XML - DOM-Baum
const xmlDoc = parser.parseFromString(xmlString, "text/xml");
// Höherer Speicherverbrauch durch DOM-Struktur

Vor- und Nachteile

JSON Vorteile ✅

Kompaktheit

- Weniger Zeichen für gleiche Daten

- Kleinere Dateigrößen

- Schnellere Übertragung

Einfachheit

- Leicht zu lesen und schreiben

- Intuitive Syntax

- Weniger Boilerplate

Performance

- Schnelles Parsen

- Native Browser-Unterstützung

- Geringer Speicherverbrauch

JavaScript-Integration

- Direkte Objektkonvertierung

- Keine zusätzlichen Libraries nötig

- Perfekt für Web-APIs

JSON Nachteile ❌

Keine Attribute

- Nur Schlüssel-Wert-Paare

- Keine Metadaten an Elementen

Keine Kommentare

- Dokumentation nur in Daten selbst

- Keine nativen Kommentare

Begrenzte Datentypen

- Nur 6 Grundtypen

- Keine Datums-, Binär- oder Custom-Typen

Keine Namespaces

- Keine Schema-Trennung

- Potenzielle Namenskonflikte

XML Vorteile ✅

Attribute

- Metadaten an Elementen

- Flexible Datenstrukturierung

- Trennung von Daten und Metadaten

Validierung

- XSD (XML Schema)

- DTD (Document Type Definition)

- Strenge Strukturprüfung

Namespaces

- Schema-Trennung

- Vermeidung von Namenskonflikten

- Modulare Strukturen

Transformationen

- XSLT für Transformationen

- XPath für Abfragen

- Mächtige Verarbeitungswerkzeuge

XML Nachteile ❌

Verbose

- Viel Boilerplate

- Große Dateien

- Redundante Schließtags

Komplexität

- Steilere Lernkurve

- Mehr Syntax-Regeln

- Kompliziertere APIs

Langsamer

- Langsameres Parsen

- Mehr Speicherverbrauch

- Höhere CPU-Last

Schlechtere Lesbarkeit

- Mehr visuelle Unordnung

- Schwerer zu scannen

Verwendungsszenarien

Wann JSON verwenden? 🎯

1. Web-APIs und REST-Services

// GET /api/benutzer/123
{
  "id": 123,
  "name": "Max Mustermann",
  "email": "max@example.de",
  "profil": {
    "avatar": "https://example.de/avatar.jpg",
    "bio": "Softwareentwickler"
  }
}

2. Frontend-Konfiguration

{
  "app": {
    "name": "MeineApp",
    "version": "1.0.0",
    "theme": {
      "farbe": "#3498db",
      "dunkelModus": true
    }
  }
}

3. NoSQL-Datenbanken

// MongoDB Dokument
{
  "_id": ObjectId("507f1f77bcf86cd799439011"),
  "name": "Max Mustermann",
  "alter": 30,
  "tags": ["entwickler", "javascript"]
}

4. Echtzeit-Kommunikation

// WebSocket-Nachricht
{
  "typ": "nachricht",
  "von": "benutzer123",
  "text": "Hallo!",
  "zeitstempel": "2026-01-26T12:00:00Z"
}

Wann XML verwenden? 🎯

1. Dokumentenformate

<?xml version="1.0" encoding="UTF-8"?>
<dokument xmlns="http://example.de/doc">
  <kopfzeile>
    <titel>Geschäftsbericht 2026</titel>
    <autor>Max Mustermann</autor>
  </kopfzeile>
  <inhalt>
    <absatz id="p1">Erster Absatz...</absatz>
    <absatz id="p2">Zweiter Absatz...</absatz>
  </inhalt>
</dokument>

2. Konfiguration mit Validierung

<?xml version="1.0" encoding="UTF-8"?>
<konfiguration xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
               xsi:schemaLocation="http://example.de config.xsd">
  <server host="localhost" port="8080">
    <ssl enabled="true" />
  </server>
</konfiguration>

3. SOAP-Web-Services

<?xml version="1.0"?>
<soap:Envelope xmlns:soap="http://www.w3.org/2003/05/soap-envelope">
  <soap:Body>
    <GetBenutzer xmlns="http://example.de/api">
      <BenutzerId>123</BenutzerId>
    </GetBenutzer>
  </soap:Body>
</soap:Envelope>

4. Legacy-Systeme

<!-- Kompatibilität mit älteren Systemen -->
<bestellung>
  <kunde id="k123">
    <name>Firma GmbH</name>
  </kunde>
  <positionen>
    <position nr="1" menge="10" />
  </positionen>
</bestellung>

Praktische Code-Beispiele

JSON Verarbeitung

JavaScript:

// JSON zu Objekt
const benutzer = JSON.parse('{"name":"Max","alter":30}');
console.log(benutzer.name); // "Max"

// Objekt zu JSON
const daten = { name: "Anna", alter: 28 };
const json = JSON.stringify(daten, null, 2);

// API-Aufruf
fetch('/api/benutzer')
  .then(response => response.json())
  .then(daten => console.log(daten));

Python:

import json
import requests

# JSON zu Dictionary
benutzer = json.loads('{"name":"Max","alter":30}')
print(benutzer['name'])  # "Max"

# Dictionary zu JSON
daten = {"name": "Anna", "alter": 28}
json_string = json.dumps(daten, indent=2, ensure_ascii=False)

# API-Aufruf
response = requests.get('/api/benutzer')
daten = response.json()

XML Verarbeitung

JavaScript:

// XML parsen
const parser = new DOMParser();
const xmlDoc = parser.parseFromString(xmlString, "text/xml");

// Daten extrahieren
const name = xmlDoc.getElementsByTagName("name")[0].textContent;
console.log(name);

// XPath verwenden
const xpath = "//benutzer/name";
const result = xmlDoc.evaluate(xpath, xmlDoc, null, 
  XPathResult.STRING_TYPE, null);
console.log(result.stringValue);

Python:

import xml.etree.ElementTree as ET

# XML parsen
baum = ET.parse('daten.xml')
wurzel = baum.getroot()

# Daten extrahieren
for benutzer in wurzel.findall('benutzer'):
    name = benutzer.find('name').text
    print(name)

# Mit lxml und XPath
from lxml import etree
baum = etree.parse('daten.xml')
namen = baum.xpath('//benutzer/name/text()')

Migration zwischen Formaten

JSON zu XML

function jsonZuXml(obj, rootName = 'root') {
  function konvertieren(obj, name) {
    if (typeof obj !== 'object' || obj === null) {
      return <\\${name}>\\${obj}</\\${name}>;
    }

    if (Array.isArray(obj)) {
      return obj.map(item => konvertieren(item, name)).join('');
    }

    let xml = <\\${name}>;
    for (const [key, value] of Object.entries(obj)) {
      xml += konvertieren(value, key);
    }
    xml += </\\${name}>;
    return xml;
  }

  return '<?xml version="1.0" encoding="UTF-8"?>' + konvertieren(obj, rootName);
}

const json = { name: "Max", alter: 30 };
console.log(jsonZuXml(json, 'benutzer'));

XML zu JSON

function xmlZuJson(xmlString) {
  const parser = new DOMParser();
  const xmlDoc = parser.parseFromString(xmlString, "text/xml");

  function konvertieren(node) {
    if (node.nodeType === 3) { // Text-Node
      return node.nodeValue.trim();
    }

    const obj = {};

    // Attribute
    if (node.attributes && node.attributes.length > 0) {
      for (let i = 0; i < node.attributes.length; i++) {
        const attr = node.attributes[i];
        obj['@' + attr.name] = attr.value;
      }
    }

    // Kind-Elemente
    if (node.childNodes && node.childNodes.length > 0) {
      for (let i = 0; i < node.childNodes.length; i++) {
        const child = node.childNodes[i];
        if (child.nodeType === 1) { // Element-Node
          const childName = child.nodeName;
          const childValue = konvertieren(child);

          if (obj[childName]) {
            if (!Array.isArray(obj[childName])) {
              obj[childName] = [obj[childName]];
            }
            obj[childName].push(childValue);
          } else {
            obj[childName] = childValue;
          }
        }
      }
    }

    return obj;
  }

  return konvertieren(xmlDoc.documentElement);
}

Entscheidungsmatrix

| Kriterium | JSON | XML | Empfehlung |

|-----------|------|-----|------------|

| Web-APIs | ⭐⭐⭐⭐⭐ | ⭐⭐ | JSON |

| Dateigröße | ⭐⭐⭐⭐⭐ | ⭐⭐ | JSON |

| Geschwindigkeit | ⭐⭐⭐⭐⭐ | ⭐⭐⭐ | JSON |

| Lesbarkeit | ⭐⭐⭐⭐⭐ | ⭐⭐⭐ | JSON |

| Validierung | ⭐⭐ | ⭐⭐⭐⭐⭐ | XML |

| Metadaten | ⭐⭐ | ⭐⭐⭐⭐⭐ | XML |

| Dokumente | ⭐⭐ | ⭐⭐⭐⭐⭐ | XML |

| Legacy-Support | ⭐⭐⭐ | ⭐⭐⭐⭐⭐ | XML |

| JavaScript | ⭐⭐⭐⭐⭐ | ⭐⭐⭐ | JSON |

| Enterprise | ⭐⭐⭐ | ⭐⭐⭐⭐⭐ | XML |

Zusammenfassung

JSON ist besser für:

✅ Moderne Web-APIs und REST-Services

✅ JavaScript/Frontend-Anwendungen

✅ Mobile Apps

✅ NoSQL-Datenbanken

✅ Echtzeit-Kommunikation

✅ Konfigurationsdateien (einfache Struktur)

XML ist besser für:

✅ Komplexe Dokumentenformate

✅ Enterprise-Systeme mit strenger Validierung

✅ SOAP-Web-Services

✅ Legacy-System-Integration

✅ Systeme mit Namespace-Anforderungen

✅ Daten mit vielen Metadaten

Fazit

Für moderne Webanwendungen ist JSON die klare Wahl aufgrund seiner Einfachheit, Geschwindigkeit und nativen JavaScript-Unterstützung.

Für Enterprise-Systeme mit strengen Validierungsanforderungen oder Legacy-Integrationen kann XML die bessere Wahl sein.

Die Entscheidung sollte basieren auf:

• Ihren spezifischen Anforderungen
• Dem bestehenden Ökosystem
• Performance-Anforderungen
• Validierungsbedarf
• Team-Expertise

Weiterführende Ressourcen

• Was ist JSON?
• JSON vs YAML
• JSON-Dateien erklärt
• JSON APIs und REST-Dienste