JSON zu XML Konverter

Was ist JSON-zu-XML-Konvertierung und wie funktioniert sie?

// Convert JSON to XML in Node.js using fast-xml-parser
import { XMLBuilder } from 'fast-xml-parser';

const data = {
  catalog: {
    product: {
      '@_id': 'P01',
      '@_category': 'electronics',
      name: 'Wireless Headphones',
      price: {
        '@_currency': 'USD',
        '#text': '79.99'
      }
    }
  }
};

const builder = new XMLBuilder({
  attributeNamePrefix: '@_',   // @_ keys become XML attributes
  textNodeName: '#text',       // #text key becomes element text content
  ignoreAttributes: false,     // process @_ attribute keys
  format: true,                // pretty-print with indentation
  indentBy: '  ',              // 2-space indent
});

const xml = builder.build(data);
console.log(xml);
// <catalog>
//   <product id="P01" category="electronics">
//     <name>Wireless Headphones</name>
//     <price currency="USD">79.99</price>
//   </product>
// </catalog>

Hauptfunktionen

Beispiele

{"user":{"id":42,"name":"Alice Kim","email":"alice@example.com","role":"admin","address":{"city":"Seoul","country":"KR"}}}

[{"id":1,"name":"Widget A","price":9.99},{"id":2,"name":"Widget B","price":14.99},{"id":3,"name":"Widget C","price":4.49}]

{"catalog":{"product":{"@_id":"P01","@_category":"electronics","name":"Wireless Headphones","price":{"@_currency":"USD","#text":"79.99"}}}}

Anleitung

1. 1

   JSON einfügen

   Geben Sie Ihre JSON-Daten in das Eingabefeld oben ein oder fügen Sie sie ein. Sie können auch auf „Beispiel laden” klicken, um ein Beispiel auszuprobieren — ein API-Antwortobjekt, einen Array-Payload oder ein Objekt mit @_-Attributen und #text.

2. 2

   Live-XML-Ausgabe ansehen

   XML erscheint sofort im Ausgabebereich. Objekte mit einem Schlüssel verwenden ihren Schlüssel als Wurzel; Objekte mit mehreren Schlüsseln werden in eingeschlossen; @_-präfixierte Schlüssel werden zu Attributen; Arrays werden zu wiederholten Kindelementen. Passen Sie die Einrückung (2 oder 4 Leerzeichen) nach Bedarf an.

3. 3

   Kopieren oder Herunterladen

   Klicken Sie auf „Kopieren”, um das XML in die Zwischenablage zu übernehmen, oder auf „Herunterladen”, um es als .xml-Datei zu speichern. Um das Ergebnis zu validieren oder neu zu formatieren, fügen Sie es in den XML-Formatierer ein.

Häufige Konvertierungsfehler

// Input: { "status": 200, "data": { "id": 1 } }
// Output: <root><status>200</status><data><id>1</id></data></root>
// Root is <root> — may not match your schema

// Wrap in a named key to control the root element
// Input: { "response": { "status": 200, "data": { "id": 1 } } }
// Output: <response><status>200</status><data><id>1</id></data></response>

// Input: [{ "id": 1 }, { "id": 2 }]
// Output: <root><item><id>1</id></item><item><id>2</id></item></root>
// Tag names are generic

// Wrap in a named key for meaningful tag names
// Input: { "products": [{ "id": 1 }, { "id": 2 }] }
// Output: <root><products><id>1</id></products><products><id>2</id></products></root>
// Each array element reuses the key name "products" as its tag

// Input: { "tag": { "id": "42", "name": "Alice" } }
// Output: <tag><id>42</id><name>Alice</name></tag>  ← id is a child element

// Use @_ prefix for attributes
// Input: { "tag": { "@_id": "42", "name": "Alice" } }
// Output: <tag id="42"><name>Alice</name></tag>  ← id is an attribute

// Input: { "price": { "@_currency": "USD", "value": "29.99" } }
// Output: <price currency="USD"><value>29.99</value></price>
// Text is a child element, not text content

// Use #text for element text content
// Input: { "price": { "@_currency": "USD", "#text": "29.99" } }
// Output: <price currency="USD">29.99</price>  ← text content

// JSON key starts with digit — invalid XML element name
// Input: { "1stItem": "value" }
// Output: <1stItem>value</1stItem>  ← invalid XML

// Use a valid XML element name
// Input: { "firstItem": "value" }
// Output: <firstItem>value</firstItem>  ← valid XML

// JSON: { "query": "name = 'Alice' & role = 'admin'" }
// Converter outputs: <query>name = 'Alice' &amp; role = 'admin'</query>
// If double-processed: &amp;amp; — consumer is re-escaping

// Converter output is correct — consume it as XML, not as a raw string
// <query>name = 'Alice' &amp; role = 'admin'</query>
// XML parser decodes to: name = 'Alice' & role = 'admin'

Häufige Anwendungsfälle

SOAP- und Legacy-XML-Webdienste aufrufen

Erstellen Sie den JSON-Payload in Ihrer Anwendung, konvertieren Sie ihn zu XML und senden Sie ihn per POST an den SOAP-Endpunkt. Das vermeidet das manuelle Aufbauen von XML-Zeichenketten und ermöglicht die Arbeit mit den Daten in einer nativen JSON-Struktur bis zu dem Moment, in dem Sie sie für den Legacy-Dienst serialisieren müssen.

XML-Konfigurationsdateien generieren

Spring, Maven, Ant, Tomcat und Android verwenden alle XML-Konfigurationsformate. Generieren oder transformieren Sie Konfigurationsdaten als JSON — einfacher zu vergleichen und versionieren — und konvertieren Sie dann für die Bereitstellung zu XML.

Sitemap- und RSS-Feed-XML erzeugen

Content-Management-Systeme und statische Site-Generatoren speichern Seiten-Metadaten oft als JSON. Konvertieren Sie diese Metadaten zu sitemap.xml oder RSS-Feed-XML, um sie an Suchmaschinen zu übermitteln oder Inhalte an Feed-Reader zu syndizieren.

Enterprise-Datenintegration (EDI / ERP / CRM)

ERP-Systeme (SAP, Oracle), CRM-Plattformen und EDI-Netzwerke tauschen häufig Daten in XML aus. Konvertieren Sie JSON-Exporte aus modernen REST-APIs zu XML, um diese Systeme ohne den Aufbau eines eigenen XML-Serialisierers zu versorgen.

Android-Ressourcendateien

Android-Zeichenkettenressourcen, Layout-Constraints und Manifest-Einträge sind allesamt XML. Generieren oder aktualisieren Sie Ressourcendateien programmatisch aus JSON-Datenquellen und konvertieren Sie zum erforderlichen XML-Format für das Android-Build-System.

SVG- und Vektorgrafik-Generierung

SVG ist XML. Erstellen Sie SVG-Strukturen als JSON-Daten — Pfade, Formen, Farben, Transformationen — und konvertieren Sie dann zu XML, um gültige SVG-Dateien für Web, Druck oder Vektorbearbeitungswerkzeuge zu erzeugen.

Technische Details

RFC-8259-konformes JSON-Parsing

JSON-Eingaben werden mit dem nativen JSON.parse() des Browsers geparst, der vollständig RFC-8259-konform ist. Er liefert genaue Syntaxfehlermeldungen mit Best-Effort-Positionsinformationen (Zeile und Spalte) und verarbeitet alle JSON-Datentypen: Zeichenketten, Zahlen, boolesche Werte, null, Arrays und Objekte.

Benutzerdefinierter rekursiver JSON-zu-XML-Serialisierer

Nach dem Parsen durchläuft ein benutzerdefinierter rekursiver Serialisierer den JSON-Baum. Objektschlüssel, die mit @_ beginnen, werden als XML-Attribute am Elternelement ausgegeben. Der #text-Schlüssel wird als Textinhalt des Elements ausgegeben. Einfache Objektschlüssel werden zu Kindelementen. Array-Werte erzeugen wiederholte gleichnamige Geschwisterelemente. Sonderzeichen (<, >, &, ", ') in Textinhalten und Attributwerten werden zu ihren XML-Entity-Referenzen maskiert.

Wurzelnormalisierung

Da XML genau ein Wurzelelement erfordert, wendet der Serialisierer vor dem Aufbau des Dokuments eine Wurzelnormalisierung an: Objekte mit einem Schlüssel verwenden den Schlüssel als Wurzel; Objekte mit mehreren Schlüsseln und Arrays auf oberster Ebene erhalten einen synthetischen -Wrapper. Dies stellt sicher, dass die Ausgabe unabhängig von der Eingabeform immer wohlgeformtes XML ist.

100 % browserbasiert — kein Upload, kein Server

Alle Verarbeitung läuft in der JavaScript-Engine Ihres Browsers. Zu keinem Zeitpunkt werden Daten über das Netzwerk übertragen. Eingaben größer als 200 KB schalten automatisch vom Live-Modus in den manuellen Modus um (erfordert einen expliziten Klick auf „Konvertieren”), um den Browser reaktionsfähig zu halten und ein Blockieren des Hauptthreads bei intensiver Serialisierung zu verhindern.

Best Practices

Wurzelelement mit einem Objekt mit einem einzigen Schlüssel kontrollieren

Der sauberste Weg, sinnvolles XML zu erzeugen, ist sicherzustellen, dass Ihr oberstes JSON ein Objekt mit einem einzigen Schlüssel ist, dessen Schlüssel der gewünschte Wurzel-Elementname ist. Mehrschlüsselige Daten unter einem benannten Schlüssel einzuschließen gibt Ihnen ein semantisch bedeutungsvolles Wurzel statt des generischen -Wrappers.

@_ und #text für attributlastiges XML verwenden

Wenn Ihr Ziel-XML-Schema viele Attribute verwendet (häufig in Konfigurationsdateien, SVG und SOAP-Envelopes), formen Sie Ihr JSON vor der Konvertierung so um, dass es @_-präfixierte Schlüssel und #text verwendet. Das resultierende XML entspricht dann genau dem Zielschema ohne Nachbearbeitung.

Arrays für sinnvolle Tag-Namen in benannten Objekten einschließen

Ein Array auf oberster Ebene erzeugt das generische ...-Muster, bei dem ein fester literaler Name ist. Das Array unter einem benannten Schlüssel einzuschließen — { "products": [...] } — erzeugt wiederholte -Elemente (der Schlüsselname wird für jedes Array-Element wiederverwendet) unter einem -Wrapper. Das gibt einen domainbedeutsamen Tag-Namen und ist für XML, das von einem Schema geparst oder validiert wird, fast immer vorzuziehen.

Ausgabe mit dem XML-Formatierer validieren

Fügen Sie nach der Konvertierung die XML-Ausgabe in den XML-Formatierer ein, um die Wohlgeformtheit zu validieren, die Einrückung zu prüfen und strukturelle Probleme zu identifizieren, bevor das XML an einen nachgelagerten Dienst gesendet oder in die Versionskontrolle eingecheckt wird.

JSON-Schlüssel vor der Konvertierung bereinigen

XML-Elementnamen müssen mit einem Buchstaben oder Unterstrich beginnen und dürfen keine Leerzeichen oder die meisten Sonderzeichen enthalten. Wenn Ihre JSON-Schlüssel aus einer externen Quelle stammen (einem Datenbankspaltennamen, einem API-Feldnamen oder Benutzereingaben), prüfen Sie sie auf XML-Namens-Gültigkeit vor der Konvertierung, um fehlerhafte Ausgabe zu vermeiden.

Häufig gestellte Fragen