Convertitore JSON in XML

Cos'è la Conversione JSON-in-XML e Come Funziona?

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

Funzionalità Principali

Esempi

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

Come Usarlo

1. 1

   Incolla il tuo JSON

   Inserisci o incolla i tuoi dati JSON nel campo di input qui sopra. Puoi anche cliccare 'Carica esempio' per provare un campione — un oggetto risposta API, un payload array o un oggetto che usa attributi @_ e #text.

2. 2

   Vedi l'Output XML in Tempo Reale

   L'XML appare istantaneamente nel pannello di output. Gli oggetti con una sola chiave usano la loro chiave come radice; gli oggetti con più chiavi si avvolgono in ; le chiavi con prefisso @_ diventano attributi; gli array diventano elementi figlio ripetuti. Regola il rientro (2 o 4 spazi) secondo necessità.

3. 3

   Copia o Scarica

   Clicca Copia per portare l'XML negli appunti, o Scarica per salvarlo come file .xml. Per validare o riformattare il risultato, incollalo nel Formattatore XML.

Errori Comuni di Conversione

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

Casi d'Uso Comuni

Chiamata a Servizi Web SOAP e XML Legacy

Costruisci il payload JSON nella tua applicazione, convertilo in XML e invialo via POST all'endpoint SOAP. Questo evita di costruire manualmente stringhe XML e ti permette di lavorare con i dati in una struttura JSON nativa fino al momento in cui devi serializzarli per il servizio legacy.

Generazione di File di Configurazione XML

Spring, Maven, Ant, Tomcat e Android usano tutti formati di configurazione XML. Genera o trasforma i dati di configurazione come JSON — più facile da confrontare e versionare — poi converti in XML per il deployment.

Produzione di Sitemap e Feed RSS XML

I sistemi di gestione dei contenuti e i generatori di siti statici spesso archiviano i metadati delle pagine come JSON. Converti quei metadati in XML sitemap.xml o RSS feed per inviarli ai motori di ricerca o sindacare i contenuti ai lettori di feed.

Integrazione Dati Enterprise (EDI / ERP / CRM)

I sistemi ERP (SAP, Oracle), le piattaforme CRM e le reti EDI scambiano comunemente dati in XML. Converti le esportazioni JSON dalle API REST moderne in XML per alimentare questi sistemi senza costruire un serializzatore XML personalizzato.

File di Risorse Android

Le risorse stringa Android, i vincoli di layout e le voci del manifest sono tutti XML. Genera o aggiorna i file di risorse programmaticamente da sorgenti dati JSON e converti nel formato XML richiesto dal sistema di build Android.

Generazione di SVG e Grafica Vettoriale

SVG è XML. Costruisci la struttura SVG come dati JSON — path, forme, colori, trasformazioni — poi converti in XML per produrre file SVG validi per il web, la stampa o gli strumenti di editing vettoriale.

Dettagli Tecnici

Analisi JSON Conforme a RFC 8259

L'input JSON viene analizzato usando il JSON.parse() nativo del browser, pienamente conforme a RFC 8259. Fornisce messaggi di errore di sintassi accurati con informazioni di posizione (riga e colonna al meglio) e gestisce tutti i tipi di dati JSON: stringhe, numeri, booleani, null, array e oggetti.

Serializzatore JSON-in-XML Ricorsivo Personalizzato

Dopo l'analisi, un serializzatore ricorsivo personalizzato attraversa l'albero JSON. Le chiavi oggetto che iniziano con @_ vengono emesse come attributi XML sull'elemento genitore. La chiave #text viene emessa come contenuto testuale dell'elemento. Le chiavi oggetto semplici diventano elementi figlio. I valori array producono elementi fratelli con lo stesso nome ripetuto. I caratteri speciali (<, >, &, ", ') nel contenuto testuale e nei valori degli attributi vengono codificati come riferimenti a entità XML.

Normalizzazione della Radice

Poiché XML richiede esattamente un elemento radice, il serializzatore applica la normalizzazione della radice prima di costruire il documento: gli oggetti con una sola chiave usano quella chiave come radice; gli oggetti con più chiavi e gli array di primo livello ricevono un wrapper sintetico . Questo garantisce che l'output sia sempre XML ben formato indipendentemente dalla forma dell'input.

100% Basato su Browser — Nessun Upload, Nessun Server

Tutta l'elaborazione avviene nel motore JavaScript del browser. Nessun dato viene trasmesso in rete in nessun momento. Gli input superiori a 200 KB passano automaticamente dalla modalità in tempo reale alla modalità manuale (richiedendo un clic esplicito su Converti) per mantenere il browser reattivo durante la serializzazione pesante.

Buone Pratiche

Controlla l'Elemento Radice con un Oggetto a Chiave Singola

Il modo più pulito per produrre XML significativo è assicurarsi che il tuo JSON di primo livello sia un oggetto con una sola chiave il cui nome è l'elemento radice desiderato. Avvolgere i dati multi-chiave sotto un'unica chiave con nome ti dà una radice semanticamente significativa invece del generico wrapper .

Usa @_ e #text per XML con Molti Attributi

Se lo schema XML target usa molti attributi (comune nei file di configurazione, SVG e envelope SOAP), rimodella il tuo JSON per usare chiavi con prefisso @_ e #text prima di convertire. L'XML risultante corrisponderà esattamente allo schema target senza post-elaborazione.

Avvolgi gli Array in Oggetti con Nome per Nomi di Tag Significativi

Un array di primo livello produce il pattern generico ..., dove è un nome letterale fisso. Avvolgere l'array sotto una chiave con nome — { "products": [...] } — produce elementi ripetuti (il nome della chiave viene riutilizzato per ogni elemento dell'array) sotto un wrapper . Questo ti dà un nome di tag significativo per il dominio ed è quasi sempre preferibile per XML che sarà analizzato o validato da uno schema.

Valida l'Output con il Formattatore XML

Dopo la conversione, incolla l'output XML nel Formattatore XML per validare la correttezza formale, verificare l'indentazione e identificare eventuali problemi strutturali prima di inviare l'XML a un servizio a valle o eseguirne il commit nel controllo versione.

Sanifica le Chiavi JSON Prima di Convertire

I nomi degli elementi XML devono iniziare con una lettera o un underscore e non possono contenere spazi o la maggior parte dei caratteri speciali. Se le tue chiavi JSON provengono da una fonte esterna (un nome di colonna di database, un nome di campo API o input dell'utente), verificane la validità come nomi XML prima di convertire per evitare output non valido.

Domande Frequenti