JSON a XML

Cos'è la conversione da JSON a XML?

JSON (JavaScript Object Notation) e XML (eXtensible Markup Language) sono i due formati di scambio dati dominanti nello sviluppo software. JSON usa coppie chiave-valore e array in una sintassi compatta, mentre XML racchiude i dati in tag di apertura e chiusura con attributi opzionali. Convertire JSON in XML significa tradurre i primitivi strutturali di JSON — oggetti, array, stringhe, numeri, booleani e null — in un documento XML ben formato con annidamento degli elementi corrispondente.

XML rimane il formato richiesto in molti sistemi enterprise, API governative, servizi web SOAP e standard di settore come HL7 (sanità), FpML (finanza) e XBRL (rendicontazione finanziaria). Quando la tua applicazione produce JSON ma il sistema di destinazione si aspetta XML, un convertitore da JSON a XML gestisce la traduzione senza ristrutturazione manuale. La conversione segue regole di mappatura prevedibili: gli oggetti JSON diventano elementi XML, gli elementi degli array diventano elementi fratelli ripetuti, e i valori primitivi diventano nodi di testo.

Non esiste un unico RFC o standard W3C che definisca come JSON si mappa su XML. Librerie diverse producono output diversi per lo stesso input. La convenzione più comune (usata da questo strumento) racchiude l'intero documento in un elemento radice configurabile, converte ogni chiave JSON in un elemento figlio XML, e rappresenta gli elementi degli array come elementi ripetuti con lo stesso nome di tag. Comprendere queste regole di mappatura è importante quando il sistema destinatario applica uno schema XML specifico (XSD).

Perché usare un convertitore online da JSON a XML?

Scrivere XML a mano a partire da una sorgente JSON è tedioso e soggetto a errori. Tag non corrispondenti, elementi di chiusura dimenticati e annidamenti errati producono documenti che falliscono la validazione dello schema. Un convertitore gestisce la traduzione strutturale automaticamente.

Casi d'uso della conversione da JSON a XML

Regole di mappatura da JSON a XML

Poiché non esiste uno standard universale che regoli la conversione da JSON a XML, strumenti diversi producono output diversi. La tabella seguente mostra le convenzioni di mappatura usate da questo convertitore e dalle librerie più popolari (js2xmlparser, xmlbuilder, fast-xml-parser). La convenzione degli elementi fratelli ripetuti per gli array è diventata dominante perché rispecchia il modo naturale in cui gli schemi XML modellano le collezioni — ogni elemento è un'entità di primo livello piuttosto che un figlio racchiuso — e si integra con le query XPath e le trasformazioni XSLT.

Esempi di codice

Di seguito trovi snippet eseguibili per convertire JSON in XML in tre ambienti. Ogni esempio produce XML ben formato da un oggetto JSON di esempio.

import { create } from 'xmlbuilder2';

const json = {
  order: {
    id: 1024,
    items: [
      { sku: "A1", qty: 2 },
      { sku: "B3", qty: 1 }
    ],
    shipped: false
  }
};

const xml = create({ version: '1.0' })
  .ele(json)
  .end({ prettyPrint: true });

console.log(xml);
// → <?xml version="1.0"?>
// → <order>
// →   <id>1024</id>
// →   <items>
// →     <sku>A1</sku>
// →     <qty>2</qty>
// →   </items>
// →   <items>
// →     <sku>B3</sku>
// →     <qty>1</qty>
// →   </items>
// →   <shipped>false</shipped>
// → </order>

import json
import xmltodict

data = {
    "order": {
        "id": 1024,
        "items": [
            {"sku": "A1", "qty": 2},
            {"sku": "B3", "qty": 1}
        ],
        "shipped": False
    }
}

# xmltodict.unparse expects a single root key
xml = xmltodict.unparse(data, pretty=True)
print(xml)
# → <?xml version="1.0" encoding="utf-8"?>
# → <order>
# →   <id>1024</id>
# →   <items>
# →     <sku>A1</sku>
# →     <qty>2</qty>
# →   </items>
# →   <items>
# →     <sku>B3</sku>
# →     <qty>1</qty>
# →   </items>
# →   <shipped>false</shipped>
# → </order>

package main

import (
	"encoding/json"
	"encoding/xml"
	"fmt"
)

type Item struct {
	SKU string `json:"sku" xml:"sku"`
	Qty int    `json:"qty" xml:"qty"`
}

type Order struct {
	XMLName xml.Name `xml:"order"`
	ID      int      `json:"id" xml:"id"`
	Items   []Item   `json:"items" xml:"items"`
	Shipped bool     `json:"shipped" xml:"shipped"`
}

func main() {
	raw := `{"id":1024,"items":[{"sku":"A1","qty":2},{"sku":"B3","qty":1}],"shipped":false}`

	var order Order
	json.Unmarshal([]byte(raw), &order)

	out, _ := xml.MarshalIndent(order, "", "  ")
	fmt.Println(xml.Header + string(out))
	// → <?xml version="1.0" encoding="UTF-8"?>
	// → <order>
	// →   <id>1024</id>
	// →   <items>
	// →     <sku>A1</sku>
	// →     <qty>2</qty>
	// →   </items>
	// →   ...
}

Domande frequenti