JSON vs XML: Confronto completo tra formati di dati

# JSON vs XML: Confronto completo tra formati di dati

Quando si tratta di scambio e memorizzazione di dati strutturati, JSON e XML sono i due formati più diffusi. Questa guida completa confronta JSON e XML per aiutarti a scegliere il formato giusto per il tuo progetto.

Panoramica rapida

JSON (JavaScript Object Notation)

• Anno di introduzione: 2001
• Creatore: Douglas Crockford
• Tipo: Formato di dati leggero
• Uso principale: API web, configurazioni

XML (eXtensible Markup Language)

• Anno di introduzione: 1998
• Creatore: W3C
• Tipo: Linguaggio di markup
• Uso principale: Documenti strutturati, sistemi legacy

Confronto della sintassi

Esempio JSON

{
  "libreria": {
    "nome": "Biblioteca Comunale",
    "indirizzo": {
      "via": "Via Roma 123",
      "città": "Milano",
      "cap": "20100"
    },
    "libri": [
      {
        "id": 1,
        "titolo": "Il Nome della Rosa",
        "autore": "Umberto Eco",
        "anno": 1980,
        "disponibile": true,
        "generi": ["Romanzo", "Giallo", "Storico"]
      },
      {
        "id": 2,
        "titolo": "Se questo è un uomo",
        "autore": "Primo Levi",
        "anno": 1947,
        "disponibile": false,
        "generi": ["Testimonianza", "Storico"]
      }
    ]
  }
}

Stesso esempio in XML

<?xml version="1.0" encoding="UTF-8"?>
<libreria>
  <nome>Biblioteca Comunale</nome>
  <indirizzo>
    <via>Via Roma 123</via>
    <città>Milano</città>
    <cap>20100</cap>
  </indirizzo>
  <libri>
    <libro>
      <id>1</id>
      <titolo>Il Nome della Rosa</titolo>
      <autore>Umberto Eco</autore>
      <anno>1980</anno>
      <disponibile>true</disponibile>
      <generi>
        <genere>Romanzo</genere>
        <genere>Giallo</genere>
        <genere>Storico</genere>
      </generi>
    </libro>
    <libro>
      <id>2</id>
      <titolo>Se questo è un uomo</titolo>
      <autore>Primo Levi</autore>
      <anno>1947</anno>
      <disponibile>false</disponibile>
      <generi>
        <genere>Testimonianza</genere>
        <genere>Storico</genere>
      </generi>
    </libro>
  </libri>
</libreria>

Dimensione: JSON = 420 byte, XML = 650 byte (~55% più grande)

Confronto dettagliato

1. Leggibilità

JSON: 9/10

• Sintassi pulita e minimale
• Facile da leggere per gli umani
• Struttura chiara con parentesi graffe e quadre

XML: 7/10

• Più verboso con tag di apertura e chiusura
• Può diventare difficile da leggere con annidamenti profondi
• Tag descrittivi possono migliorare la comprensione

2. Dimensione del file

JSON: Più compatto

{"nome": "Mario", "età": 30}

Dimensione: 28 byte

XML: Più grande

<persona><nome>Mario</nome><età>30</età></persona>

Dimensione: 51 byte (82% più grande)

3. Performance di parsing

Benchmark (analisi di 1000 record):

// Test JSON
console.time('JSON Parse');
const jsonData = JSON.parse(jsonString);
console.timeEnd('JSON Parse');
// JSON Parse: ~15ms

// Test XML
console.time('XML Parse');
const xmlData = new DOMParser().parseFromString(xmlString, 'text/xml');
console.timeEnd('XML Parse');
// XML Parse: ~45ms

Risultato: JSON è tipicamente 2-3x più veloce nel parsing.

4. Tipi di dati

JSON - Tipi nativi:

{
  "stringa": "testo",
  "numero": 42,
  "decimale": 3.14,
  "booleano": true,
  "nullo": null,
  "array": [1, 2, 3],
  "oggetto": {"chiave": "valore"}
}

XML - Solo testo:

<dati>
  <stringa>testo</stringa>
  <numero>42</numero>
  <decimale>3.14</decimale>
  <booleano>true</booleano>
  <nullo></nullo>
  <!-- Tutti i valori sono stringhe -->
</dati>

In XML, tutto è testo e richiede conversione manuale dei tipi.

5. Array e liste

JSON - Supporto nativo per array:

{
  "frutti": ["mela", "banana", "arancia"],
  "numeri": [1, 2, 3, 4, 5]
}

XML - Richiede strutture ripetute:

<dati>
  <frutti>
    <frutto>mela</frutto>
    <frutto>banana</frutto>
    <frutto>arancia</frutto>
  </frutti>
</dati>

6. Metadati e attributi

JSON - Solo dati:

{
  "utente": {
    "nome": "Marco",
    "id": "123"
  }
}

XML - Attributi disponibili:

<utente id="123" tipo="premium">
  <nome>Marco</nome>
</utente>

XML può memorizzare metadati come attributi, JSON no.

7. Namespace

JSON - Non supportati:

{
  "prodotto": {
    "nome": "Laptop"
  }
}

XML - Supporto completo:

<prod:prodotto xmlns:prod="http://example.com/prodotti">
  <prod:nome>Laptop</prod:nome>
</prod:prodotto>

I namespace XML permettono di evitare conflitti di nomi in documenti complessi.

8. Commenti

JSON - Non permessi:

{
  "nome": "Marco"
}

XML - Supportati:

<!-- Questo è un commento -->
<persona>
  <nome>Marco</nome> <!-- nome dell'utente -->
</persona>

Vantaggi di JSON

✅ Pro

Più compatto: Meno verboso, file più piccoli

Più veloce: Parsing e serializzazione più rapidi

Supporto nativo nei browser: JSON.parse() e JSON.stringify()

Tipi di dati nativi: Numeri, booleani, null, array

Più semplice da leggere: Sintassi minimale

Ideale per API REST: Standard de facto

Mappatura diretta a oggetti: Struttura simile agli oggetti in molti linguaggi

❌ Contro

Nessun supporto per commenti: Impossibile documentare inline

Nessun namespace: Può causare conflitti di nomi

Nessun attributo: Solo coppie chiave-valore

Meno espressivo: Per documenti complessi

Nessuna validazione standard integrata: Richiede JSON Schema

Vantaggi di XML

✅ Pro

Molto espressivo: Tag descrittivi e attributi

Namespace: Prevenzione conflitti di nomi

Schema validation: XSD per validazione rigorosa

Commenti: Documentazione inline

XSLT: Trasformazioni potenti

XPath: Query complesse sui dati

Standard maturo: Ampia documentazione e tooling

Metadata rico: Attributi per informazioni aggiuntive

❌ Contro

Verboso: File più grandi

Più lento: Parsing più complesso

Più complesso: Curva di apprendimento più ripida

Tutti i dati sono stringhe: Richiede conversione dei tipi

Overhead: Tag di apertura e chiusura

Quando usare JSON

✅ Usa JSON per:

API REST moderne

// API Endpoint
fetch('https://api.example.com/utenti/123')
  .then(response => response.json())
  .then(utente => {
    console.log(utente.nome); // Accesso diretto
  });

Configurazioni applicazioni

{
  "app": {
    "nome": "MyApp",
    "versione": "1.0.0",
    "database": {
      "host": "localhost",
      "porta": 5432
    }
  }
}

Comunicazione frontend-backend

// Invia dati al server
const dati = {
  nome: "Marco",
  email: "marco@example.com"
};

fetch('/api/registrazione', {
  method: 'POST',
  headers: { 'Content-Type': 'application/json' },
  body: JSON.stringify(dati)
});

Storage browser (localStorage)

// Salva in localStorage
const preferenze = {
  tema: "scuro",
  lingua: "it"
};
localStorage.setItem('preferenze', JSON.stringify(preferenze));

// Recupera
const salvate = JSON.parse(localStorage.getItem('preferenze'));

Database NoSQL (MongoDB)

// Documento MongoDB
db.utenti.insertOne({
  nome: "Marco",
  età: 30,
  interessi: ["programmazione", "viaggi"]
});

Quando usare XML

✅ Usa XML per:

Documenti complessi con metadata

<documento tipo="fattura" versione="2.0" xmlns="http://fattura.it">
  <intestazione data="2026-01-26" numero="INV-001">
    <cliente id="c123" tipo="azienda">
      <ragione_sociale>ACME S.r.l.</ragione_sociale>
    </cliente>
  </intestazione>
</documento>

Sistemi legacy

<!-- Integrazione con sistema bancario legacy -->
<transazione xmlns:bank="http://bank.example.com">
  <bank:conto_origine>IT60X0542811101000000123456</bank:conto_origine>
  <bank:importo valuta="EUR">1000.00</bank:importo>
</transazione>

Feed RSS/Atom

<?xml version="1.0" encoding="UTF-8"?>
<rss version="2.0">
  <channel>
    <title>Notizie Tech</title>
    <item>
      <title>Nuovo framework JavaScript</title>
      <pubDate>Mon, 26 Jan 2026 10:00:00 GMT</pubDate>
    </item>
  </channel>
</rss>

File di configurazione complessi (Spring, Maven)

<project xmlns="http://maven.apache.org/POM/4.0.0">
  <modelVersion>4.0.0</modelVersion>
  <groupId>com.example</groupId>
  <artifactId>myapp</artifactId>
  <version>1.0.0</version>
  <dependencies>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-core</artifactId>
      <version>6.0.0</version>
    </dependency>
  </dependencies>
</project>

SOAP Web Services

<soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/">
  <soap:Body>
    <getUtente>
      <id>123</id>
    </getUtente>
  </soap:Body>
</soap:Envelope>

Esempi di conversione

Da JSON a XML

JSON:

{
  "ordine": {
    "id": "ORD-001",
    "cliente": "Marco Rossi",
    "totale": 150.50,
    "articoli": [
      {"nome": "Libro", "quantità": 2},
      {"nome": "Penna", "quantità": 5}
    ]
  }
}

XML equivalente:

<ordine>
  <id>ORD-001</id>
  <cliente>Marco Rossi</cliente>
  <totale>150.50</totale>
  <articoli>
    <articolo>
      <nome>Libro</nome>
      <quantità>2</quantità>
    </articolo>
    <articolo>
      <nome>Penna</nome>
      <quantità>5</quantità>
    </articolo>
  </articoli>
</ordine>

Conversione programmatica

JavaScript: JSON to XML

function jsonToXml(obj, rootName = 'root') {
  let xml = <?xml version="1.0" encoding="UTF-8"?>;

  function convertNode(obj, nodeName) {
    let node = <${nodeName}>;

    for (const [key, value] of Object.entries(obj)) {
      if (Array.isArray(value)) {
        value.forEach(item => {
          node += convertNode(item, key.slice(0, -1)); // singolare
        });
      } else if (typeof value === 'object' && value !== null) {
        node += convertNode(value, key);
      } else {
        node += <${key}>${value}</${key}>;
      }
    }

    node += </${nodeName}>;
    return node;
  }

  return xml + convertNode(obj, rootName);
}

// Uso
const dati = {
  nome: "Marco",
  età: 30
};
const xml = jsonToXml(dati, 'persona');
// <persona><nome>Marco</nome><età>30</età></persona>

Python: XML to JSON

import json
import xml.etree.ElementTree as ET

def xml_to_json(xml_string):
    """Converte XML in JSON"""
    root = ET.fromstring(xml_string)

    def element_to_dict(element):
        result = {}

        # Attributi
        if element.attrib:
            result['@attributes'] = element.attrib

        # Testo
        if element.text and element.text.strip():
            if len(element) == 0:
                return element.text.strip()
            result['#text'] = element.text.strip()

        # Figli
        for child in element:
            child_data = element_to_dict(child)
            if child.tag in result:
                if not isinstance(result[child.tag], list):
                    result[child.tag] = [result[child.tag]]
                result[child.tag].append(child_data)
            else:
                result[child.tag] = child_data

        return result

    return json.dumps({root.tag: element_to_dict(root)}, indent=2)

# Uso
xml = '''
<persona>
  <nome>Marco</nome>
  <età>30</età>
</persona>
'''

json_result = xml_to_json(xml)
print(json_result)

Prestazioni: Benchmark reali

Test: Parsing di 10,000 record

JSON:

const start = performance.now();
const data = JSON.parse(largeJsonString);
const end = performance.now();
console.log(JSON: ${end - start}ms);
// Risultato: ~50ms

XML:

const start = performance.now();
const parser = new DOMParser();
const xmlDoc = parser.parseFromString(largeXmlString, 'text/xml');
const end = performance.now();
console.log(XML: ${end - start}ms);
// Risultato: ~180ms

JSON è ~3.6x più veloce nel parsing.

Test: Dimensione trasferimento dati

Stesso dataset (1000 prodotti):
JSON:  245 KB
JSON compresso (gzip): 45 KB
XML:   420 KB
XML compresso (gzip):  68 KB

JSON è ~42% più piccolo
JSON compresso è ~34% più piccolo

Riepilogo: Tabella di confronto

| Caratteristica | JSON | XML |

|----------------|------|-----|

| Leggibilità | ⭐⭐⭐⭐⭐ | ⭐⭐⭐⭐ |

| Dimensione | Compatto | Verboso |

| Velocità parsing | Veloce | Lento |

| Tipi di dati | Nativi | Solo testo |

| Array | Nativi | Simulati |

| Commenti | ❌ | ✅ |

| Namespace | ❌ | ✅ |

| Attributi | ❌ | ✅ |

| Validazione | JSON Schema | XSD |

| Uso in API moderne | ✅ Dominante | ❌ Raro |

| Sistemi legacy | ❌ | ✅ |

| Curva apprendimento | Facile | Media |

Conclusione

Scegli JSON se:

• Stai costruendo API REST moderne
• Vuoi performance e dimensioni ottimali
• Lavori con JavaScript/Node.js
• Hai bisogno di semplicità
• I dati sono principalmente strutturati come oggetti e array

Scegli XML se:

• Lavori con sistemi legacy
• Hai bisogno di namespace e validazione rigorosa
• I documenti richiedono metadata complessi
• Usi SOAP o altri protocolli basati su XML
• Hai bisogno di commenti nei file di dati

Nel 2026, JSON è la scelta preferita per la maggior parte delle applicazioni web moderne, mentre XML rimane importante per sistemi legacy, documenti complessi e specifici casi d'uso enterprise.

La tendenza è chiara: JSON ha vinto la battaglia per le API web e continuerà a dominare nel futuro prossimo.