← Alle Artikel
Aktualisiert am May 29, 20268 min read

XML-zu-JSON-Konvertierung: Attribute, Textknoten, Arrays und Namespaces

XML richtig in JSON konvertieren: Wie Attribute, Textknoten, wiederholte Elemente und Namespaces auf JSON abgebildet werden — mit Konventionen, Sonderfällen und JS/Python-Code.

XML in JSON zu konvertieren klingt mechanisch, bis Sie auf XML-Teile stoßen, für die JSON kein direktes Äquivalent hat: Attribute, gemischter Inhalt aus Text und Elementen, Elemente, die ein- oder mehrfach erscheinen, und Namespaces. Es gibt kein einziges „richtiges“ Mapping —— nur Konventionen. Dieser Guide erklärt die Standardkonventionen, die Entscheidungen, die Sie treffen müssen, und wie Sie XML in JavaScript, Python und im Browser in JSON konvertieren.

Das Mapping auf einen Blick

Die meisten XML-zu-JSON-Konverter (xmltodict, fast-xml-parser und das Tool dieser Seite) folgen derselben Form: jedes Element wird zu einem Objekt, Attribute zu Schlüsseln mit Sonderpräfix und Text zum Wert oder zu einem reservierten Schlüssel.

<!-- XML -->
<note id="1" priority="high">
  <to>Ada</to>
  <from>Bob</from>
  <body>Hello &amp; welcome</body>
</note>
// JSON
{
  "note": {
    "@id": "1",
    "@priority": "high",
    "to": "Ada",
    "from": "Bob",
    "body": "Hello & welcome"
  }
}

Attribute → Schlüssel mit @-Präfix

JSON-Objekte haben kein Konzept von Attributen, daher ist die nahezu universelle Konvention, @ den Attributnamen voranzustellen. Das unterscheidet sie von Kindelementen und macht das Mapping reversibel.

<book id="b1" lang="en"/>
→ { "book": { "@id": "b1", "@lang": "en" } }

Einige Werkzeuge verwenden ein anderes Präfix ($, _) oder ein verschachteltes "@attributes"-Objekt. Wählen Sie eines und wenden Sie es konsistent an —— der Code, der es konsumiert, muss wissen, wo die Attribute sind.

Textknoten und gemischter Inhalt

Wenn ein Element nur Text enthält, wird es auf einen String-Wert reduziert. Aber wenn ein Element Attribute und Text hat, braucht der Text einen Platz —— per Konvention den Schlüssel #text.

<price currency="USD">9.99</price>
→ { "price": { "@currency": "USD", "#text": "9.99" } }

<title>Effective TypeScript</title>
→ { "title": "Effective TypeScript" }

Wirklich gemischter Inhalt (Text durchsetzt mit Kindelementen, wie in HTML-artigem Markup) ist der schwierigste Fall —— die meisten datenorientierten Konverter konkatenieren oder verwerfen den freien Text. Wenn Ihr XML eher Dokument- als Datenstil hat, rechnen Sie hier mit Verlust.

Das Eins-vs-Array-Problem

Das ist die Falle, die mehr Code als jede andere bricht. Ein Element, das einmal erscheint, wird zum Objekt; dasselbe Element, das zweimal erscheint, wird zum Array. Die JSON-Form hängt von den Daten ab, nicht vom Schema:

<tags><tag>a</tag></tags>
→ { "tags": { "tag": "a" } }          // Objekt

<tags><tag>a</tag><tag>b</tag></tags>
→ { "tags": { "tag": ["a", "b"] } }   // Array

Konsumenten, die tags.tag als Array erwarten, werden bei einem einzelnen Element immer brechen. Zwei Lösungen: Konfigurieren Sie den Parser so, dass bekannte wiederholbare Elemente immer als Arrays behandelt werden, oder normalisieren Sie nach dem Parsen (const arr = [].concat(node.tag ?? [])).

Namespaces

XML-Namespaces verwenden Präfixe (soap:Envelope), die durch xmlns-Deklarationen gebunden sind. JSON kennt keinen Namespace-Begriff, daher entscheiden sich Konverter meist für eine dieser Strategien:

  • Präfix im Schlüssel behalten —— "soap:Envelope". Einfach und reversibel, aber der Schlüssel enthält Doppelpunkte und Sie benötigen Bracket-Zugriff (obj["soap:Envelope"]).
  • Präfix entfernen —— "Envelope". Sauberere Schlüssel, aber Sie verlieren den Namespace und riskieren Kollisionen zwischen zwei Namespaces mit gleichem Local Name.
  • xmlns als Attribute behalten —— Deklarationen werden zu "@xmlns:soap"-Schlüsseln, damit die Bindung den Round-Trip überlebt.

Für die meisten Datenaufgaben ist „Präfix im Schlüssel behalten“ die sicherste Voreinstellung —— sie verliert nie Informationen.

Entities und CDATA

Ein korrekter Konverter dekodiert die fünf vordefinierten Entities (&lt;, &gt;, &amp;, &quot;, &apos;) und numerische Referenzen (&#169;) in ihre Zeichen und behandelt <![CDATA[...]]>-Blöcke als wörtlichen Text.

Namentliche Konventionen: BadgerFish, GData, Parker

Die Zuordnung „@ für Attribute / #text für Text“ ist nicht die einzige im Umlauf. Drei namentlich bekannte Konventionen, die Sie beim Lesen von XML→JSON-Ausgaben anderer Systeme sehen:

  • BadgerFish —— Attribute unter @-präfigiertem Schlüssel; Text unter $; Namespace-Deklarationen unter @xmlns. Ausführlich, aber verlustfrei.
  • GData —— Googles Variante: Attribute mit $-Präfix; Text unter $t; wiederholte Elemente immer als Arrays. Verlustfrei und vorhersehbare Form.
  • Parker —— verwirft Attribute komplett; das einfachste und verlustreichste Mapping. Nützlich, wenn Sie beide Seiten kontrollieren und nur Elementwerte interessieren.

Wenn Sie ein System integrieren, das bereits JSON-aus-XML produziert, identifizieren Sie zuerst die verwendete Konvention, bevor Sie Parsing-Code schreiben.

Das Ergebnis mit JSONPath abfragen

Nach der XML-Konvertierung können Sie Werte mit JSONPath referenzieren. Zwei kleine Anpassungen gegenüber XPath-Gewohnheiten:

  • Attributschlüssel tragen das @-Präfix aus dem Mapping, sodass XPaths @id in JSONPath zu $..['@id'] wird.
  • Das Eins-vs-Array-Problem bedeutet, dass ein XPath, der wie book/title funktioniert, in JSONPath als $..book[*].title geschrieben werden muss, um beide Formen zu behandeln.

XML in JSON im Code konvertieren

// JavaScript (Browser) —— DOMParser + kleiner Durchlauf oder eine Bibliothek:
import { XMLParser } from 'fast-xml-parser';
const parser = new XMLParser({ ignoreAttributes: false, attributeNamePrefix: '@' });
const obj = parser.parse(xmlString);

# Python —— xmltodict mappt Attribute auf "@name" und Text auf "#text"
import xmltodict, json
doc = xmltodict.parse(xml_string)
print(json.dumps(doc, indent=2))

XML in JSON online konvertieren

Für eine schnelle Konvertierung fügen Sie Ihr XML in den JSON-⇄-XML-Konverter ein und klicken Sie auf To JSON. Er wendet die obigen Konventionen an —— @ für Attribute, #text für gemischten Inhalt, Arrays für wiederholte Elemente —— und läuft komplett im Browser, sodass interne Feeds und API-Payloads Ihren Rechner nie verlassen.

Häufig gestellte Fragen

Wie werden XML-Attribute in JSON dargestellt?

Per Konvention werden sie zu Schlüsseln mit @-Präfix (z. B. @id), die sich von Kindelementen unterscheiden, damit das Mapping umkehrbar ist.

Warum wird dasselbe Element manchmal zum Objekt und manchmal zum Array?

Weil die Form den Daten folgt: ein Vorkommen wird zum Objekt, mehrere zum Array. Konfigurieren Sie Ihren Parser, bekannte wiederholbare Elemente als Arrays zu behandeln, oder normalisieren Sie nach dem Parsen mit [].concat(value).

Was passiert mit Text in einem Element mit Attributen?

Er wird unter dem reservierten Schlüssel #text gespeichert, da das Objekt bereits die Attribute enthält. Ein Element mit nur Text reduziert sich auf einen einfachen String.

Wie werden XML-Namespaces behandelt?

JSON hat keine Namespaces. Der sicherste Ansatz behält das Präfix im Schlüssel ("soap:Envelope") und die xmlns-Deklarationen als @xmlns:*-Attribute, damit nichts verloren geht.

Verwandte Werkzeuge und Guides