XML zu JSON Konverter

Q: Wie werden gemischte Inhalte (Text + Kindelemente) behandelt?

Gemischter Inhalt ist heikel: Hello world ! hat keine saubere JSON-Repräsentation. Die Seite verwendet typischerweise einen speziellen Schlüssel (z. B. '#text' oder '$'), um losen Text einzufangen, aber die Reihenfolge zwischen Text und Elementen bleibt nicht immer erhalten. Vermeide gemischten Inhalt, wenn du Round-Trip planst.

XML-Eingabe

JSON-Ausgabe

Einrückungsgröße

Zeilen: 1Zeichen: 0Bytes: 0

Was ist XML zu JSON Konvertierung?

XML zu JSON konvertiert XML-Markup in eine JSON-Struktur, damit Daten leichter in JavaScript, APIs, No-Code-Tools oder modernen Datenpipelines verarbeitet werden können. Die Umwandlung ist nicht immer eindeutig, weil XML Elemente, Attribute, Textknoten, Namespaces, Reihenfolge und wiederholte Knoten kennt, während JSON mit Objekten, Arrays und einfachen Werten arbeitet. Das Werkzeug ist hilfreich für Legacy-Integrationen, SOAP-Antworten, Sitemaps, RSS-Feeds, Konfigurationen und Testdaten. Bei produktiven Schnittstellen muss geprüft werden, wie Attribute, leere Elemente, gemischter Text und Arrays abgebildet werden. Korrekt geparstes JSON bedeutet nicht automatisch, dass alle fachlichen Informationen verlustfrei übernommen wurden. Bei großen Dateien oder fachlichen Schnittstellen sollte die erzeugte Struktur zusätzlich mit Beispielantworten und Verbrauchercode getestet werden, damit Feldnamen, Arraybildung und Sonderfälle nicht erst später auffallen.

Verwendung

So verwenden Sie

Fügen Sie XML-Daten in das linke Eingabefeld ein oder geben Sie sie ein
Wählen Sie die Einrückungsgröße (2 Leerzeichen, 4 Leerzeichen oder Tabulator)
Umgewandeltes JSON wird rechts mit Syntaxhervorhebung angezeigt
Überprüfen Sie das Umwandlungsergebnis und beheben Sie eventuelle XML-Fehler
Klicken Sie auf Kopieren oder Herunterladen, um das Ergebnis zu speichern

Datenstrukturhinweise

XML-Attribute, wiederholte Knoten, Namespaces und gemischter Text können auf mehrere gültige Weisen in JSON abgebildet werden; überprüfen Sie die generierte Struktur, bevor Sie sie verwenden.
Für API-Migration definieren Sie eine Feldzuordnungsregel, anstatt sich auf eine einzelne Beispielumwandlung zu verlassen.

Anwendungsfälle

XML-Payload in lesbares JSON zur Prüfung umwandelnFügen Sie SOAP-, RSS-, Geräte- oder Partner-XML ein und der Browser-DOMParser konvertiert das Dokument in ein JSON-Objekt, das das Wurzelement beibehält, Kindelemente verschachtelt und wiederholte Kindnamen zu Arrays zusammenfasst. Numerische Texte sowie true- und false-Werte werden konvertiert, sofern sie einfach genug erkennbar sind. Der Parser folgt der W3C DOM Level 3 Core-Spezifikation, sodass jede wohlgeformte XML-1.0-Eingabe, die DOMParser akzeptiert, einen durchlaufbaren Baum erzeugt – der JSON-Schritt durchläuft diesen Baum in die Tiefe und zählt Geschwister-Duplikate, um zwischen einem einzelnen Objekt und einem JSON-Array zu unterscheiden.

Beispieldaten vor dem Ersetzen einer XML-Integration vorbereitenNutzen Sie den Zwei-Panel-Editor, um das Original-XML mit dem formatierten JSON zu vergleichen, und kopieren oder laden Sie anschließend output.json für eine Migrationsnotiz, Testdaten oder API-Besprechung herunter. Die Einrückung lässt sich zwischen 2 Leerzeichen, 4 Leerzeichen und Tabulatoren umschalten, um dem verwendenden Codeprojekt zu entsprechen.

Fehlerhaftes XML erkennen, bevor es einen parser-lastigen Workflow erreichtDer Konverter zeigt Parsing-Fehler des Browser-XML-Parsers an, anstatt stillschweigend eine teilweise Ausgabe zu erzeugen. Der Fokus liegt auf Elementen und Textinhalt – Attribute, Namespaces, Kommentare, Processing Instructions und Schema-Validierung erfordern bei Bedarf weiterhin ein spezialisiertes XML-Werkzeug.

Entscheiden, wie Attribute zu JSON-Schlüsseln werdenWenn ein Element Attribute mit Kindelementen mischt, werden Attribute üblicherweise mit @-Präfix versehen, damit sie nicht mit dem Textinhalt oder benannten Kindern kollidieren. Prüfen Sie das erzeugte JSON auf Felder wie @id oder @type und benennen Sie sie im verwendenden Code um, wenn eine flache Schlüsselstruktur bevorzugt wird. Die gängige Zuordnung ist `@attribut` für XML-Attribute, `#text` für Zeichendaten neben Kindelementen und der lokale Name jedes Kinds – vergleichbar mit der Badgerfish-Konvention vieler JSON-XML-Bibliotheken.

XML-Dateien erkennen, die der Konverter bewusst vereinfachtDokumente, die auf Attributen, Namespaces, Processing Instructions, Kommentaren oder CDATA-Blöcken basieren, verlieren im JSON-Output Details. Betrachten Sie das Ergebnis als schnelle lesefreundliche Ansicht, nicht als verlustfreies Migrationsziel, wenn diese XML-Features die fachlichen Daten tragen. Die Array-Erkennung greift nur bei wiederholten Kindelementnamen – ein einzelnes `<item>` und zwei `<product>`-Geschwister werden zu einem Objekt mit zwei Schlüsseln statt zu einer Liste, und die Clark-Notation `{http://example.com/ns}user` wird vom lokalen Namen `user` entfernt, was mit einem anderen namenlosen Element gleichen Namens kollidieren kann.

Technisches Prinzip

Die Konvertierung beginnt mit dem eingebauten XML-Parser des Browsers. `new DOMParser().parseFromString(xmlString, 'application/xml')` gibt ein `Document` zurück, das dem W3C DOM Level 3 Core folgt, die Wohlgeformtheit gegen XML 1.0 (Fünfte Ausgabe) validiert und das Ergebnis als Baum aus `Element`, `Attr`, `Text`, `CDATASection` und `Comment`-Knoten bereitstellt. Wenn die Eingabe fehlerhaft ist, wirft der Parser keine Exception – er gibt ein Dokument zurück, dessen Wurzelelement `<parsererror>` mit Position und Grund enthält, sodass der Konverter zuerst `doc.querySelector('parsererror')` prüft und diese Meldung anzeigt, anstatt teilweise JSON zu erzeugen. Die Baum-zu-JSON-Abbildung durchläuft das Dokument in die Tiefe und folgt einer Badgerfish-ähnlichen Konvention. Jedes Element wird zu einer Eigenschaft, deren Schlüssel der lokale Name ist; Kindelemente werden zu verschachtelten Objekten; Elementattribute werden mit einem `@`-Präfix abgeflacht (z. B. `<user id="7">` → `{ "user": { "@id": "7" } }`); Textinhalt neben Kindelementen wird unter `#text` gespeichert. Wiederholte Geschwisterelemente mit demselben Namen werden zu einem JSON-Array zusammengefasst: Zwei `<item>`-Knoten werden zu `"item": [ ... ]`, aber ein einzelnes `<item>` bleibt ein einfaches Objekt – dies ist die bekannte Ambiguität zwischen einzelnen und mehreren Elementen, da XML eine ein-elementige Liste nicht von einem skalaren Wert unterscheiden kann, während JSON `"item": {...}` und `"item": [{...}]` als verschiedene Strukturen behandelt. Mehrere XML-Features haben kein sauberes JSON-Äquivalent und sind bewusst verlustbehaftet. Die Elementreihenfolge wird von XML beibehalten, ist aber bei JSON-Objektschlüsseln nicht über alle Konsumenten garantiert (obwohl ES2015 die Einfügereihenfolge für Zeichenketten-Schlüssel spezifiziert, schränken Schemata wie JSON Schema dies nicht ein). Gemischter Inhalt wie `Hello world!` verschachtelt Text mit Elementen und kann nicht verlustfrei in das einfache Schlüssel-Wert-Modell überführt werden. XML-Namespaces in Clark-Notation (`{http://example.com/ns}user`) werden auf den lokalen Namen `user` reduziert, der mit einem anderen Element gleichen Namens kollidieren kann. CDATA-Blöcke wie `<![CDATA[<raw>]]>` werden in reinen Text entpackt. Processing Instructions (`<?xml-stylesheet ...?>`), Kommentare (``) und die XML-Deklaration werden verworfen, da JSON keine Syntax dafür besitzt. Die Einrückung erfolgt über `JSON.stringify(value, null, indent)` mit 2 Leerzeichen, 4 Leerzeichen oder `'\t'`.

Parser: `new DOMParser().parseFromString(xml, 'application/xml')` gemäß W3C DOM Level 3 Core; Fehler werden als `<parsererror>`-Wurzelelement ausgegeben, nicht als geworfene Exception.
Abbildungskonventionen: Badgerfish-Stil `@attr` für Attribute, `#text` für gemischten Text, lokaler Name des Elements für Kinder; Parker verwirft Attribute, Spark behält sie in `$`.
Wiederholte Kinder mit demselben Namen werden zu einem JSON-Array zusammengefasst; ein einzelnes Kind bleibt ein Objekt – die klassische Ambiguität zwischen einzelnen und mehreren Elementen hat keine XML-seitige Lösung.
Verlustbehaftete Features: Attribute (ohne `@`-Präfix), Namespaces (`xmlns:foo`), Processing Instructions, Kommentare, die XML-Deklaration und CDATA-Wrapper.
Gemischter Inhalt (`Hello world!`) kann nicht verlustfrei in Schlüssel-Wert-JSON überführt werden; die Elementreihenfolge kann bei Konsumenten verloren gehen, die die Schlüsselreihenfolge nicht beibehalten.
Zahlen-/Boolean-Koerzierung ist eine bewusste Entscheidung: `<age>30</age>` kann zu `30` (Zahl) oder `"30"` (Zeichenkette) werden; führende Nullen (`007`) sollten als Zeichenketten bleiben.
Die Ausgabeformatierung verwendet `JSON.stringify(value, null, indent)` mit Einrückung von 2 Leerzeichen, 4 Leerzeichen oder `'\t'`; das Ergebnis ist UTF-8 ohne BOM.

Beispiele

Einfaches Element

&lt;root>
  &lt;name>John&lt;/name>
&lt;/root>
→
{"root": {"name": "John"}}

Wiederholte Elemente

&lt;root>
  &lt;item>A&lt;/item>
  &lt;item>B&lt;/item>
&lt;/root>
→
{"root": {"item": ["A", "B"]}}

Verschachtelte Struktur

&lt;root>
  &lt;user>
    &lt;name>John&lt;/name>
    &lt;age>30&lt;/age>
  &lt;/user>
&lt;/root>
→
{"root": {"user": {"name": "John", "age": 30}}}

FAQ

Wie werden XML-Elemente auf JSON abgebildet?

Jedes Element wird zu einer JSON-Property, deren Wert der Inhalt des Elements ist (String oder verschachteltes Objekt). Wiederholte Elemente mit demselben Namen werden zu Arrays. Attribute werden meist mit '@' präfixiert oder unter einem speziellen Schlüssel wie '$' abgelegt. Die genaue Konvention variiert und ist auf den meisten Seiten konfigurierbar.

Warum ist XML-zu-JSON manchmal verlustbehaftet?

XML unterscheidet zwischen Elementen, Attributen, Textinhalten, gemischtem Inhalt (Text und Elemente), Namespaces, Processing Instructions und Kommentaren. JSON kennt nur Objekte, Arrays, Strings, Zahlen, Booleans und null. Die reichere XML-Struktur auf JSON abzubilden, geht zu Lasten von Reihenfolgen und der Unterscheidung zwischen Element und Attribut.

Wie werden gemischte Inhalte (Text + Kindelemente) behandelt?

Gemischter Inhalt ist heikel:

Hello world!

hat keine saubere JSON-Repräsentation. Die Seite verwendet typischerweise einen speziellen Schlüssel (z. B. '#text' oder '$'), um losen Text einzufangen, aber die Reihenfolge zwischen Text und Elementen bleibt nicht immer erhalten. Vermeide gemischten Inhalt, wenn du Round-Trip planst.

Was ist mit XML-Namespaces?

Elemente mit Präfix (<ns:foo>) werden zu String-Schlüsseln 'ns:foo' oder in ns/local-name-Properties aufgeteilt. xmlns-Deklarationen können je nach Konfiguration als attributähnliche Properties erhalten bleiben oder weggelassen werden.

Komme ich vom JSON wieder zu identischem XML?

Round-Trip ist im Allgemeinen nicht verlustfrei, besonders bei gemischtem Inhalt, Kommentaren, Processing Instructions und Attributreihenfolge. Für reines Daten-XML (Konfiguration, einfache Datensätze) klappt der Round-Trip meist. Für Dokument-XML (DocBook, HTML, RSS) nimm einen echten XML-Parser.

Ist ein leeres XML-Element <foo/> dasselbe wie <foo></foo>?

Für den Parser ja. Beide ergeben eine Property foo mit leerem String oder null als Wert. Die selbstschließende Syntax ist in XML rein kosmetisch.

Läuft die Konvertierung lokal?

Ja. XML-Parsing und JSON-Erzeugung passieren in deinem Browser. Die Seite lädt deine Daten nicht hoch.