JSON a XML

¿Qué es la conversión de JSON a XML?

JSON (JavaScript Object Notation) y XML (eXtensible Markup Language) son los dos formatos de intercambio de datos dominantes en el desarrollo de software. JSON usa pares clave-valor y matrices con una sintaxis compacta, mientras que XML envuelve los datos en etiquetas de apertura y cierre con atributos opcionales. Convertir JSON a XML implica traducir los primitivos estructurales de JSON — objetos, matrices, cadenas, números, booleanos y null — en un documento XML bien formado con el anidamiento de elementos correspondiente.

XML sigue siendo el formato obligatorio en muchos sistemas empresariales, APIs gubernamentales, servicios web SOAP y estándares sectoriales como HL7 (sanidad), FpML (finanzas) y XBRL (información financiera). Cuando tu aplicación produce JSON pero el sistema receptor espera XML, un conversor de JSON a XML se encarga de la traducción sin necesidad de reestructuración manual. La conversión sigue reglas de correspondencia predecibles: los objetos JSON se convierten en elementos XML, los elementos de las matrices se convierten en elementos hermanos repetidos y los valores primitivos se convierten en nodos de texto.

No existe ningún RFC ni estándar del W3C que defina cómo se corresponde JSON con XML. Distintas bibliotecas producen salidas diferentes para la misma entrada. La convención más habitual (utilizada por esta herramienta) envuelve el documento completo en un elemento raíz configurable, convierte cada clave JSON en un elemento hijo XML y representa los elementos de las matrices como elementos repetidos con el mismo nombre de etiqueta. Conocer estas reglas de correspondencia es importante cuando el sistema receptor impone un esquema XML (XSD) específico.

¿Por qué usar un conversor de JSON a XML online?

Escribir XML a mano a partir de una fuente JSON es tedioso y propenso a errores. Las etiquetas sin cerrar, los elementos de cierre olvidados y el anidamiento incorrecto producen documentos que no superan la validación de esquema. Un conversor gestiona la traducción estructural de forma automática.

Casos de uso de JSON a XML

Reglas de correspondencia de JSON a XML

Dado que no existe un estándar universal que rija la conversión de JSON a XML, distintas herramientas producen salidas diferentes. La tabla siguiente muestra las convenciones de correspondencia utilizadas por este conversor y las bibliotecas más populares (js2xmlparser, xmlbuilder, fast-xml-parser). La convención de elementos hermanos repetidos para las matrices se impuso como la dominante porque refleja cómo los esquemas XML modelan naturalmente las colecciones — cada elemento es un elemento de primer nivel en lugar de un hijo envuelto — y se integra limpiamente con consultas XPath y transformaciones XSLT.

Ejemplos de código

A continuación hay fragmentos ejecutables para convertir JSON a XML en tres entornos. Cada ejemplo produce XML bien formado a partir de un objeto JSON de muestra.

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>
	// →   ...
}

Preguntas frecuentes