Conversor JSON para XML

O que é a Conversão JSON para XML e Como Funciona?

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

const data = {
  catalog: {
    product: {
      '@_id': 'P01',
      '@_category': 'electronics',
      name: 'Wireless Headphones',
      price: {
        '@_currency': 'USD',
        '#text': '79.99'
      }
    }
  }
};

const builder = new XMLBuilder({
  attributeNamePrefix: '@_',   // @_ keys become XML attributes
  textNodeName: '#text',       // #text key becomes element text content
  ignoreAttributes: false,     // process @_ attribute keys
  format: true,                // pretty-print with indentation
  indentBy: '  ',              // 2-space indent
});

const xml = builder.build(data);
console.log(xml);
// <catalog>
//   <product id="P01" category="electronics">
//     <name>Wireless Headphones</name>
//     <price currency="USD">79.99</price>
//   </product>
// </catalog>

Recursos Principais

Exemplos

{"user":{"id":42,"name":"Alice Kim","email":"alice@example.com","role":"admin","address":{"city":"Seoul","country":"KR"}}}

[{"id":1,"name":"Widget A","price":9.99},{"id":2,"name":"Widget B","price":14.99},{"id":3,"name":"Widget C","price":4.49}]

{"catalog":{"product":{"@_id":"P01","@_category":"electronics","name":"Wireless Headphones","price":{"@_currency":"USD","#text":"79.99"}}}}

Como Usar

1. 1

   Cole seu JSON

   Insira ou cole seus dados JSON no campo de entrada acima. Você também pode clicar em 'Carregar exemplo' para experimentar uma amostra — um objeto de resposta de API, um payload de array ou um objeto usando atributos @_ e #text.

2. 2

   Veja a Saída XML ao Vivo

   O XML aparece instantaneamente no painel de saída. Objetos de chave única usam sua chave como raiz; objetos de múltiplas chaves envolvem em ; chaves com prefixo @_ tornam-se atributos; arrays tornam-se elementos filhos repetidos. Ajuste a indentação (2 ou 4 espaços) conforme necessário.

3. 3

   Copie ou Baixe

   Clique em Copiar para pegar o XML para a área de transferência ou em Baixar para salvá-lo como arquivo .xml. Para validar ou reformatar o resultado, cole-o no Formatador XML.

Armadilhas Comuns de Conversão

// Input: { "status": 200, "data": { "id": 1 } }
// Output: <root><status>200</status><data><id>1</id></data></root>
// Root is <root> — may not match your schema

// Wrap in a named key to control the root element
// Input: { "response": { "status": 200, "data": { "id": 1 } } }
// Output: <response><status>200</status><data><id>1</id></data></response>

// Input: [{ "id": 1 }, { "id": 2 }]
// Output: <root><item><id>1</id></item><item><id>2</id></item></root>
// Tag names are generic

// Wrap in a named key for meaningful tag names
// Input: { "products": [{ "id": 1 }, { "id": 2 }] }
// Output: <root><products><id>1</id></products><products><id>2</id></products></root>
// Each array element reuses the key name "products" as its tag

// Input: { "tag": { "id": "42", "name": "Alice" } }
// Output: <tag><id>42</id><name>Alice</name></tag>  ← id is a child element

// Use @_ prefix for attributes
// Input: { "tag": { "@_id": "42", "name": "Alice" } }
// Output: <tag id="42"><name>Alice</name></tag>  ← id is an attribute

// Input: { "price": { "@_currency": "USD", "value": "29.99" } }
// Output: <price currency="USD"><value>29.99</value></price>
// Text is a child element, not text content

// Use #text for element text content
// Input: { "price": { "@_currency": "USD", "#text": "29.99" } }
// Output: <price currency="USD">29.99</price>  ← text content

// JSON key starts with digit — invalid XML element name
// Input: { "1stItem": "value" }
// Output: <1stItem>value</1stItem>  ← invalid XML

// Use a valid XML element name
// Input: { "firstItem": "value" }
// Output: <firstItem>value</firstItem>  ← valid XML

// JSON: { "query": "name = 'Alice' & role = 'admin'" }
// Converter outputs: <query>name = 'Alice' &amp; role = 'admin'</query>
// If double-processed: &amp;amp; — consumer is re-escaping

// Converter output is correct — consume it as XML, not as a raw string
// <query>name = 'Alice' &amp; role = 'admin'</query>
// XML parser decodes to: name = 'Alice' & role = 'admin'

Casos de Uso Comuns

Chamando Serviços Web SOAP e XML Legados

Construa o payload JSON na sua aplicação, converta para XML e faça POST no endpoint SOAP. Isso evita a construção manual de strings XML e permite que você trabalhe com os dados em uma estrutura JSON nativa até o momento em que precisar serializá-los para o serviço legado.

Gerando Arquivos de Configuração XML

Spring, Maven, Ant, Tomcat e Android usam formatos de configuração XML. Gere ou transforme dados de configuração como JSON — mais fácil de comparar e controlar versão — depois converta para XML para implantação.

Produzindo XML de Sitemap e Feed RSS

Sistemas de gerenciamento de conteúdo e geradores de sites estáticos frequentemente armazenam metadados de página como JSON. Converta esses metadados para XML de sitemap.xml ou feed RSS para enviar a mecanismos de busca ou sindicalizar conteúdo para leitores de feed.

Integração de Dados Corporativos (EDI / ERP / CRM)

Sistemas ERP (SAP, Oracle), plataformas CRM e redes EDI comumente trocam dados em XML. Converta exportações JSON de APIs REST modernas para XML para alimentar esses sistemas sem construir um serializador XML personalizado.

Arquivos de Recursos Android

Recursos de string Android, restrições de layout e entradas de manifesto são todos XML. Gere ou atualize arquivos de recursos programaticamente a partir de fontes de dados JSON e converta para o formato XML exigido pelo sistema de build Android.

Geração de SVG e Gráficos Vetoriais

SVG é XML. Construa a estrutura SVG como dados JSON — caminhos, formas, cores, transformações — depois converta para XML para produzir arquivos SVG válidos para web, impressão ou ferramentas de edição vetorial.

Detalhes Técnicos

Análise JSON Compatível com RFC 8259

A entrada JSON é analisada usando o JSON.parse() nativo do navegador, que é totalmente compatível com RFC 8259. Ele fornece mensagens de erro de sintaxe precisas com informações de posição de melhor esforço (linha e coluna) e lida com todos os tipos de dados JSON: strings, números, booleanos, null, arrays e objetos.

Serializador JSON para XML Recursivo Personalizado

Após a análise, um serializador recursivo personalizado percorre a árvore JSON. Chaves de objeto que começam com @_ são emitidas como atributos XML no elemento pai. A chave #text é emitida como conteúdo de texto do elemento. Chaves de objeto simples tornam-se elementos filhos. Valores de array produzem elementos irmãos repetidos com o mesmo nome. Caracteres especiais (<, >, &, ", ') no conteúdo de texto e valores de atributo são escapados para suas referências de entidade XML.

Normalização de Raiz

Como o XML requer exatamente um elemento raiz, o serializador aplica normalização de raiz antes de construir o documento: objetos de chave única usam a chave como raiz; objetos de múltiplas chaves e arrays de nível superior recebem um wrapper sintético . Isso garante que a saída seja sempre XML bem formado independentemente da forma da entrada.

100% Baseado no Navegador — Sem Upload, Sem Servidor

Todo o processamento é executado no mecanismo JavaScript do seu navegador. Nenhum dado é transmitido pela rede em nenhum momento. Entradas maiores que 200KB mudam automaticamente do modo ao vivo para o modo manual (exigindo um clique explícito em Converter) para manter o navegador responsivo durante a serialização pesada.

Melhores Práticas

Controle o Elemento Raiz com um Objeto de Chave Única

A maneira mais limpa de produzir XML significativo é garantir que o seu JSON de nível superior seja um objeto de chave única cuja chave seja o nome do elemento raiz desejado. Envolver dados de múltiplas chaves sob uma chave nomeada lhe dá uma raiz semanticamente significativa em vez do wrapper genérico .

Use @_ e #text para XML com Muitos Atributos

Se o seu esquema XML alvo usa muitos atributos (comum em arquivos de configuração, SVG e envelopes SOAP), reformule seu JSON para usar chaves com prefixo @_ e #text antes de converter. O XML resultante corresponderá ao esquema alvo exatamente sem pós-processamento.

Envolva Arrays em Objetos Nomeados para Nomes de Tag Significativos

Um array de nível superior produz o padrão genérico ..., onde é um nome literal fixo. Envolver o array sob uma chave nomeada — { "products": [...] } — produz elementos repetidos (o nome da chave é reutilizado para cada elemento do array) sob um wrapper . Isso lhe dá um nome de tag com significado no domínio e é quase sempre preferível para XML que será analisado ou validado por um esquema.

Valide a Saída com o Formatador XML

Após a conversão, cole a saída XML no Formatador XML para validar a boa formação, verificar a indentação e identificar quaisquer problemas estruturais antes de enviar o XML para um serviço downstream ou fazer commit no controle de versão.

Sanitize as Chaves JSON Antes de Converter

Nomes de elementos XML devem começar com uma letra ou sublinhado e não podem conter espaços ou a maioria dos caracteres especiais. Se suas chaves JSON vierem de uma fonte externa (nome de coluna de banco de dados, nome de campo de API ou entrada do usuário), audite-as para validade de nome XML antes de converter para evitar saída malformada.

Perguntas Frequentes