JSON naar XML Omzetter

Wat is JSON-naar-XML-conversie en hoe werkt het?

// 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>

Kernfuncties

Voorbeelden

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

Zo gebruik je het

1. 1

   Plak je JSON

   Voer je JSON-data in of plak deze in het invoerveld hierboven. Je kunt ook op 'Voorbeeld laden' klikken om een voorbeeld te proberen — een API-responsobject, een array-payload of een object met @_-attributen en #text.

2. 2

   Bekijk de live XML-uitvoer

   XML verschijnt direct in het uitvoerpaneel. Objecten met één sleutel gebruiken hun sleutel als root; objecten met meerdere sleutels worden omsloten in ; @_-prefixed sleutels worden attributen; arrays worden herhaalde kindelementen. Pas de inspringing (2 of 4 spaties) naar wens aan.

3. 3

   Kopieer of download

   Klik op Kopiëren om de XML naar je klembord te halen, of op Downloaden om het op te slaan als .xml-bestand. Om het resultaat te valideren of te herformatteren, plak het in de XML Formatter.

Veelgemaakte fouten bij conversie

// 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'

Veelvoorkomende gebruiksscenario's

SOAP en oudere XML-webservices aanroepen

Bouw de JSON-payload in je toepassing, converteer die naar XML en POST het naar het SOAP-eindpunt. Dit vermijdt het handmatig opbouwen van XML-strings en laat je werken met de data in een native JSON-structuur tot het moment dat je het moet serialiseren voor de oudere service.

XML-configuratiebestanden genereren

Spring, Maven, Ant, Tomcat en Android gebruiken allemaal XML-configuratieformaten. Genereer of transformeer configuratiedata als JSON — makkelijker te vergelijken en te versiebeheren — en converteer naar XML voor implementatie.

Sitemap- en RSS-feed-XML produceren

Contentmanagementsystemen en statische sitegeneratoren slaan pagina-meta-data vaak op als JSON. Converteer die meta-data naar sitemap.xml of RSS-feed-XML om in te dienen bij zoekmachines of inhoud te syndiceren naar feedlezers.

Bedrijfsdataintegratie (EDI / ERP / CRM)

ERP-systemen (SAP, Oracle), CRM-platformen en EDI-netwerken wisselen data vaak uit in XML. Converteer JSON-exports van moderne REST API's naar XML om deze systemen te voeden zonder een aangepaste XML-serializer te bouwen.

Android-resourcebestanden

Android-stringresources, layoutbeperkingen en manifest-vermeldingen zijn allemaal XML. Genereer of update resourcebestanden programmatisch vanuit JSON-databronnen en converteer naar het vereiste XML-formaat voor het Android-buildsysteem.

SVG en vectorgraphics genereren

SVG is XML. Bouw SVG-structuur als JSON-data — paden, vormen, kleuren, transformaties — en converteer naar XML om geldige SVG-bestanden te produceren voor web, druk of vectorbewerkingstools.

Technische details

RFC 8259-conforme JSON-verwerking

JSON-invoer wordt verwerkt via de ingebouwde JSON.parse() van de browser, die volledig voldoet aan RFC 8259. Het geeft nauwkeurige syntaxisfoutmeldingen met beste-schatting positie-informatie (regel en kolom) en verwerkt alle JSON-gegevenstypen: strings, getallen, booleans, null, arrays en objecten.

Aangepaste recursieve JSON-naar-XML-serializer

Na het verwerken doorloopt een aangepaste recursieve serializer de JSON-boom. Objectsleutels die beginnen met @_ worden uitgegeven als XML-attributen op het ouderelement. De sleutel #text wordt uitgegeven als de tekstinhoud van het element. Gewone objectsleutels worden kindelementen. Arraywaarden produceren herhaalde gelijknamige nevengeschikte elementen. Speciale tekens (<, >, &, ", ') in tekstinhoud en attribuutwaarden worden geschreven naar hun XML-entiteitsreferenties.

Rootnormalisatie

Omdat XML precies één rootelement vereist, past de serializer rootnormalisatie toe vóór het opbouwen van het document: objecten met één sleutel gebruiken de sleutel als root; objecten met meerdere sleutels en arrays op het hoogste niveau krijgen een synthetische -wrapper. Dit zorgt ervoor dat de uitvoer altijd welgevormde XML is ongeacht de invoervorm.

100% browsergebaseerd — geen upload, geen server

Alle verwerking draait in de JavaScript-engine van je browser. Er worden geen gegevens via het netwerk verzonden. Invoer groter dan 200 KB schakelt automatisch over van live-modus naar handmatige modus (waarbij een expliciete klik op Omzetten nodig is) om de browser responsief te houden tijdens zware serialisatie.

Aanbevolen aanpak

Beheer het rootelement met een object met één sleutel

De schoonste manier om betekenisvolle XML te produceren is ervoor te zorgen dat je JSON op het hoogste niveau een object met één sleutel is waarvan de sleutel de gewenste rootelementnaam is. Data met meerdere sleutels insluiten onder één benoemde sleutel geeft je een semantisch betekenisvolle root in plaats van de generieke -wrapper.

Gebruik @_ en #text voor attribuutrijke XML

Als je doel-XML-schema veel attributen gebruikt (gangbaar in configuratiebestanden, SVG en SOAP-envelopes), herstructureer dan je JSON om @_-prefixed sleutels en #text te gebruiken vóór het converteren. De resulterende XML past dan exact bij het doelschema zonder naverwerking.

Wikkel arrays in benoemde objecten voor betekenisvolle tagnamen

Een array op het hoogste niveau produceert het generieke ...-patroon, waarbij een vaste letterlijke naam is. De array insluiten onder een benoemde sleutel — { "products": [...] } — produceert herhaalde -elementen (de sleutelnaam wordt hergebruikt voor elk array-element) onder een -wrapper. Dit geeft je een domein-betekenisvolle tagnaam en is bijna altijd te verkiezen voor XML die wordt verwerkt of gevalideerd door een schema.

Valideer de uitvoer met de XML Formatter

Na het converteren, plak de XML-uitvoer in de XML Formatter om de welgevormdheid te valideren, de inspringing te controleren en eventuele structurele problemen te identificeren vóór het versturen van de XML naar een vervolgservice of het committen naar versiebeheer.

Saneer JSON-sleutels vóór het converteren

XML-elementnamen moeten beginnen met een letter of underscore en mogen geen spaties of de meeste speciale tekens bevatten. Als je JSON-sleutels afkomstig zijn van een externe bron (een databasekolomnaam, een API-veldnaam of gebruikersinvoer), controleer ze dan op XML-naamgeldigheid vóór het converteren om ongeldige uitvoer te voorkomen.

Veelgestelde vragen