JSON para XML

O que é a Conversão de JSON para XML?

JSON (JavaScript Object Notation) e XML (eXtensible Markup Language) são os dois formatos de troca de dados mais usados no desenvolvimento de software. O JSON usa pares chave-valor e arrays em uma sintaxe compacta, enquanto o XML envolve os dados em tags de abertura e fechamento com atributos opcionais. Converter JSON para XML significa traduzir os primitivos estruturais do JSON — objetos, arrays, strings, números, booleanos e null — em um documento XML bem formado com o aninhamento de elementos correspondente.

O XML continua sendo o formato obrigatório em muitos sistemas corporativos, APIs governamentais, web services SOAP e padrões setoriais como HL7 (saúde), FpML (finanças) e XBRL (relatórios financeiros). Quando sua aplicação produz JSON, mas o sistema consumidor espera XML, um conversor de JSON para XML realiza a tradução sem reestruturação manual. A conversão segue regras de mapeamento previsíveis: objetos JSON tornam-se elementos XML, itens de array tornam-se elementos irmãos repetidos, e valores primitivos tornam-se nós de texto.

Não existe um único RFC ou padrão W3C que defina como JSON se mapeia para XML. Bibliotecas diferentes produzem saídas diferentes para a mesma entrada. A convenção mais comum (usada por esta ferramenta) envolve todo o documento em um elemento raiz configurável, converte cada chave JSON em um elemento filho XML e representa itens de array como elementos repetidos com o mesmo nome de tag. Entender essas regras de mapeamento é importante quando o sistema receptor exige um esquema XML específico (XSD).

Por que Usar um Conversor Online de JSON para XML?

Escrever XML manualmente a partir de uma fonte JSON é tedioso e sujeito a erros. Tags sem correspondência, elementos de fechamento esquecidos e aninhamento incorreto produzem documentos que falham na validação de esquema. Um conversor lida com a tradução estrutural automaticamente.

Casos de Uso: JSON para XML

Regras de Mapeamento de JSON para XML

Como não existe um padrão universal para conversão de JSON para XML, ferramentas diferentes produzem saídas diferentes. A tabela abaixo mostra as convenções de mapeamento usadas por este conversor e pelas bibliotecas mais populares (js2xmlparser, xmlbuilder, fast-xml-parser). A convenção de irmãos repetidos para arrays tornou-se dominante porque espelha como esquemas XML modelam coleções naturalmente — cada item é um elemento de primeira classe, não um filho envolvido — e integra-se bem com consultas XPath e transformações XSLT.

Exemplos de Código

Abaixo estão trechos de código executáveis para converter JSON para XML em três ambientes. Cada exemplo produz XML bem formado a partir de um objeto JSON de amostra.

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

Perguntas Frequentes