Convertitore XML in JSON

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

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

const xml = `<catalog>
  <product id="P01">
    <name>Wireless Headphones</name>
    <price currency="USD">79.99</price>
  </product>
</catalog>`;

const parser = new XMLParser({
  ignoreAttributes: false,      // preserve attributes
  attributeNamePrefix: '@_',    // @_ prefix for attributes
  textNodeName: '#text',        // #text for mixed element content
  parseAttributeValue: false,   // no type coercion on attributes
  parseTagValue: false,         // no type coercion on element text
});

const result = parser.parse(xml);
console.log(JSON.stringify(result, null, 2));
// {
//   "catalog": {
//     "product": {
//       "@_id": "P01",
//       "name": "Wireless Headphones",
//       "price": {
//         "@_currency": "USD",
//         "#text": "79.99"
//       }
//     }
//   }
// }

Funzionalità Principali

Esempi

<?xml version="1.0" encoding="UTF-8"?>
<appConfig version="2.1" env="production">
  <database>
    <host>db.example.com</host>
    <port>5432</port>
    <name>myapp_prod</name>
    <pool max="10" min="2"/>
  </database>
  <cache enabled="true">
    <ttl>3600</ttl>
    <driver>redis</driver>
  </cache>
</appConfig>

<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">
  <url>
    <loc>https://go-tools.org/tools/xml-to-json</loc>
    <lastmod>2026-05-29</lastmod>
    <changefreq>weekly</changefreq>
    <priority>0.8</priority>
  </url>
  <url>
    <loc>https://go-tools.org/tools/json-to-xml</loc>
    <lastmod>2026-05-29</lastmod>
    <changefreq>weekly</changefreq>
    <priority>0.8</priority>
  </url>
</urlset>

<item>
  <title>XML to JSON: A Practical Guide</title>
  <link>https://go-tools.org/blog/xml-to-json-guide</link>
  <pubDate>Thu, 29 May 2026 00:00:00 GMT</pubDate>
  <category>Developer Tools</category>
  <description>Learn how XML attributes map to @_ keys, how repeated elements become arrays, and why values stay strings in any XML-to-JSON conversion.</description>
  <guid isPermaLink="true">https://go-tools.org/blog/xml-to-json-guide</guid>
</item>

Come Usarlo

1. 1

   Incolla il tuo XML

   Inserisci o incolla il tuo XML nel campo di input qui sopra. Puoi anche cliccare 'Carica esempio' per provare un campione — un file di configurazione, un frammento di sitemap o un elemento RSS.

2. 2

   Vedi l'output JSON in tempo reale

   Il JSON appare istantaneamente nel pannello di output. Gli attributi diventano chiavi con prefisso @_, il contenuto testuale degli elementi misti diventa #text e gli elementi fratelli ripetuti diventano array. Regola il rientro (2 o 4 spazi) secondo necessità.

3. 3

   Copia o Scarica

   Clicca Copia per portare il JSON negli appunti, o Scarica per salvarlo come file .json pronto per la tua applicazione, API o pipeline di dati.

Errori Comuni di Conversione

// XML: <timeout>30</timeout>
// JSON output: { "timeout": "30" }  ← string, not number
// Dangerous: comparing as-is
if (config.timeout > 25) { ... }  // "30" > 25 coerces, but fragile

// XML: <timeout>30</timeout>
// JSON output: { "timeout": "30" }
// Safe: explicit coercion where you know the type
if (parseInt(config.timeout, 10) > 25) { ... }

// XML with one item: <root><item>a</item></root>
// JSON: { "root": { "item": "a" } }  ← string, not array
result.root.item.forEach(i => console.log(i));  // TypeError: not a function

// Normalize to array regardless of count
const items = [].concat(result.root?.item ?? []);
items.forEach(i => console.log(i));  // safe for 0, 1, or many

// XML: <price currency="USD">29.99</price>
// JSON: { "price": { "@_currency": "USD", "#text": "29.99" } }
const amount = result.price;  // { "@_currency": "USD", "#text": "29.99" }, not "29.99"

// Handle both plain string and @_/#text object
const raw = result.price;
const amount = typeof raw === 'object' ? raw['#text'] : raw;  // "29.99"

<!-- Unescaped & — well-formedness error -->
<query>name = 'Alice' & role = 'admin'</query>

<!-- Escaped & — valid XML -->
<query>name = 'Alice' &amp; role = 'admin'</query>

// XML: <zipCode>01234</zipCode>
// This tool outputs: { "zipCode": "01234" }  ← correct
// But if a downstream schema coerces:
// { zipCode: z.number() }  → 1234  ← leading zero lost

// Declare ZIP codes and other padded identifiers as strings
// { zipCode: z.string() }  → "01234"  ← correct

Casi d'Uso Comuni

Consumo di API SOAP / XML Legacy

I servizi enterprise legacy (bancari, assicurativi, logistici) espongono spesso API SOAP che restituiscono XML. Converti la risposta in JSON per lavorare con i dati usando tooling JavaScript moderno, archiviarla in un database documentale o inoltrarla a un consumatore di API REST.

Elaborazione di Feed RSS e Atom

I feed RSS 2.0 e Atom 1.0 sono XML. Converti l'XML del feed in JSON per estrarre titoli, link, date di pubblicazione e descrizioni per aggregatori di feed, pipeline di contenuti e sistemi di notifica senza dipendere da una libreria di parsing XML.

Parsing di File Sitemap

I file sitemap.xml enumerano gli URL di un sito con metadati. Converti una sitemap in JSON per analizzare la copertura degli URL, costruire code di crawling, confrontare sitemap tra ambienti o alimentare URL in un link checker o strumento di audit SEO.

Trasformazione di File di Configurazione

Molti sistemi enterprise (Spring, Maven, Ant, JBoss, Tomcat) usano file di configurazione XML. Convertili in JSON per analisi, script di migrazione, generazione di documentazione o importazione in strumenti che parlano nativamente JSON.

Sviluppo Mobile e Android

Le risorse Android, i file di layout e AndroidManifest.xml sono tutti XML. Convertili in JSON per script di analisi, audit automatici o generazione di documentazione sulle autorizzazioni dichiarate, le activity e i valori delle risorse.

Migrazione Dati ed ETL

Le esportazioni di dati da sistemi enterprise (ERP, CRM, buste paga) arrivano spesso come XML. Converti in JSON come primo passo in una pipeline ETL per caricare i dati in un data store nativo JSON come MongoDB, Firestore o un'API REST.

Dettagli Tecnici

DOMParser del Browser per l'Analisi XML

L'input XML viene analizzato usando il DOMParser nativo del browser con il tipo MIME 'text/xml' — lo stesso motore usato per il rendering di SVG e XHTML. È completamente conforme a XML 1.0 e segnala gli errori di correttezza formale con informazioni di riga e colonna. Questo approccio gestisce correttamente namespace, sezioni CDATA, istruzioni di elaborazione e riferimenti a entità senza alcuna dipendenza da terze parti.

Serializzazione DOM-in-JSON Ricorsiva

Dopo l'analisi, lo strumento attraversa l'albero DOM ricorsivamente. I nodi elemento diventano oggetti JSON; i loro attributi diventano chiavi con prefisso @_; gli elementi solo-testo diventano valori stringa semplici; gli elementi con sia attributi che contenuto testuale ottengono una chiave #text per il contenuto testuale. Gli elementi fratelli con lo stesso nome vengono raccolti e restituiti come array JSON. I nodi di testo contenenti solo spazi bianchi tra gli elementi vengono scartati.

Nessuna Coercizione di Tipo — Preservazione delle Stringhe

Tutti i valori degli attributi e il contenuto testuale vengono scritti nell'output JSON come stringhe. Non viene applicato nessun parseInt, parseFloat o parsing booleano. Questa è una scelta di design deliberata per prevenire la corruzione silenziosa dei dati per valori con zero iniziale, decimali sensibili alla precisione e stringhe dall'aspetto booleano. La coercizione di tipo, dove necessaria, dovrebbe essere applicata esplicitamente nel codice a valle.

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 e prevenire il blocco del thread principale durante l'attraversamento pesante del DOM.

Buone Pratiche

Valida Prima la Correttezza Formale dell'XML

Se la tua sorgente XML è scritta a mano o generata da un sistema che occasionalmente produce output non valido, validala prima di convertire. Usa il pulsante Valida del Formattatore XML per confermare che l'XML sia ben formato e ottenere posizioni di errore precise per eventuali problemi.

Normalizza i Campi Uno-o-Molti in Array

Quando il tuo schema XML ammette uno o molti elementi figlio con lo stesso nome, l'output JSON sarà un oggetto per un elemento e un array per molti. Normalizza sempre questi campi nel codice del consumatore: const items = [].concat(result.items ?? []) — questo è sicuro per zero, uno o molti e previene TypeError.

Applica la Coercizione di Tipo Esplicitamente e Selettivamente

Poiché questo strumento preserva tutti i valori come stringhe, applica la coercizione di tipo deliberatamente nel tuo codice per i campi specifici che ne hanno bisogno. Usare parseInt(val, 10) per un campo intero noto è sicuro. Applicare la coercizione in modo ampio con Number(val) rischia di corrompere valori con zero iniziale, stringhe vuote e decimali sensibili alla precisione.

Controlla #text quando Accedi ai Valori degli Elementi

Se un elemento può avere attributi in alcuni payload e non in altri, il suo valore JSON sarà o una stringa semplice (nessun attributo) o un oggetto con chiavi @_ e una chiave #text (con attributi). Scrivi accessor robusti: const val = typeof node === 'object' ? node['#text'] : node. Questo pattern gestisce entrambe le forme ed evita valori undefined silenziosi.

Per Lavoro XML Senza Perdite, Usa il Formattatore XML

La conversione XML-in-JSON elimina commenti, istruzioni di elaborazione e semantica dei namespace. Se hai bisogno di preservare tutto il contenuto XML esattamente, usa il Formattatore XML per abbellire, minificare e validare senza alcuna perdita. Converti in JSON solo quando hai bisogno di lavorare con i dati in un contesto nativo JSON.

Domande Frequenti