ToolActToolAct

Conversor de XML para JSON

Entrada XML
Saída JSON
Linhas: 1Caracteres: 0Bytes: 0
Linhas: 1Caracteres: 0Bytes: 0

O que é conversão de XML para JSON?

XML to JSON converte marcação XML em uma estrutura JSON para que dados sejam tratados com mais facilidade em JavaScript, APIs, ferramentas no-code ou pipelines modernos. O mapeamento nem sempre é óbvio porque XML tem elementos, atributos, nós de texto, namespaces, ordem e nós repetidos, enquanto JSON usa objetos, arrays e valores simples. A ferramenta é útil para integrações legadas, respostas SOAP, sitemaps, feeds RSS, configurações e dados de teste. Em interfaces de produção, atributos, elementos vazios, conteúdo misto, namespaces e detecção de arrays devem ser revisados. JSON parseado corretamente não garante que toda informação de negócio foi preservada no formato pretendido.

Como Usar

Como usar

  1. Cole ou insira dados XML na caixa de entrada à esquerda
  2. Selecione o tamanho da indentação (2 espaços, 4 espaços ou Tab)
  3. O JSON convertido é exibido à direita com destaque de sintaxe
  4. Revise o resultado da conversão e corrija quaisquer erros do XML
  5. Clique em Copy ou Download para salvar o resultado

Notas sobre Estrutura de Dados

  • Atributos XML, nós repetidos, namespaces e conteúdo misto podem ser convertidos para JSON de várias formas válidas; analise a estrutura gerada antes de utilizá-la.
  • Para migração de API, defina uma regra de mapeamento de campos em vez de confiar em uma única conversão de exemplo.

Casos de uso

Transforme um payload XML em JSON legível para inspeçãoCole XML de SOAP, RSS, dispositivo ou parceiro e o DOMParser do navegador converte o documento em um objeto JSON que mantém o elemento raiz, aninha elementos filhos e agrupa nomes de filhos repetidos em arrays. Texto numérico e valores true ou false são convertidos quando são simples o suficiente para reconhecer. O parser segue a especificação W3C DOM Level 3 Core, então qualquer entrada XML 1.0 bem formada que o DOMParser aceita produzirá uma árvore navegável, e a etapa JSON simplesmente percorre essa árvore em profundidade, contando duplicatas de irmãos para decidir entre um objeto único e um array JSON.
Prepare dados de exemplo antes de substituir uma integração XMLUse o editor de dois painéis para comparar o XML original com o JSON formatado, depois copie ou baixe output.json para uma nota de migração, fixture de teste ou discussão de API. A indentação pode ser alternada entre 2 espaços, 4 espaços e tabs para corresponder ao código consumidor.
Detecte XML malformado antes que ele chegue a um fluxo de parserO conversor exibe erros de parse do parser XML do navegador em vez de produzir silenciosamente saída parcial. Ele foca em elementos e conteúdo de texto, então atributos, namespaces, comentários, instruções de processamento e validação de schema ainda exigem uma ferramenta XML dedicada quando esses detalhes importam.
Decida como atributos se tornam chaves JSONQuando um elemento mistura atributos com elementos filhos, os atributos geralmente recebem o prefixo @ para não colidir com o conteúdo de texto ou filhos nomeados. Revise o JSON gerado em busca de campos como @id ou @type e renomeie-os no código consumidor se uma estrutura de chave plana for preferida. O mapeamento convencional é `@attribute` para atributos XML, `#text` para dados de texto ao lado de elementos filhos, e o nome local de cada filho, espelhando a convenção Badgerfish usada por muitas bibliotecas JSON-XML.
Identifique arquivos XML que o conversor simplifica intencionalmenteDocumentos que dependem de atributos, namespaces, instruções de processamento, comentários ou blocos CDATA perderão detalhes na saída JSON. Trate o resultado como uma visualização rápida e legível, não como um destino de migração sem perdas, quando esses recursos XML carregam os dados de negócio. A detecção de arrays só é acionada para nomes de elementos filhos repetidos, então um único `<item>` e dois `<product>` irmãos se colapsam em um objeto com duas chaves em vez de uma lista. O namespace em notação Clark `{http://example.com/ns}user` é removido do nome local `user`, o que pode colidir com outro elemento sem namespace de mesmo nome.

Princípio técnico

A conversão começa com o parser XML integrado do navegador. `new DOMParser().parseFromString(xmlString, 'application/xml')` retorna um `Document` que segue o W3C DOM Level 3 Core, valida a formação correta conforme XML 1.0 (Quinta Edição) e expõe o resultado como uma árvore de nós `Element`, `Attr`, `Text`, `CDATASection` e `Comment`. Se a entrada for malformada, o parser não lança exceção — ele retorna um documento cujo elemento raiz é `<parsererror>` contendo a localização e o motivo, então o conversor verifica `doc.querySelector('parsererror')` primeiro e exibe essa mensagem em vez de produzir JSON parcial. O mapeamento da árvore para JSON percorre o documento em profundidade e segue uma convenção no estilo Badgerfish. Cada elemento torna-se uma propriedade cuja chave é o nome local; elementos filhos tornam-se objetos aninhados; atributos de elementos são achatados com o prefixo `@` (ex. `<user id="7">` → `{ "user": { "@id": "7" } }`); conteúdo de texto ao lado de elementos filhos é armazenado sob `#text`. Elementos irmãos repetidos com o mesmo nome são agrupados em um array JSON: dois nós `<item>` tornam-se `"item": [ ... ]`, mas um único `<item>` permanece como objeto simples — esta é a conhecida ambiguidade de "único vs. múltiplo", porque XML não consegue distinguir uma lista de um elemento de um valor escalar enquanto JSON trata `"item": {...}` e `"item": [{...}]` como estruturas diferentes. Vários recursos do XML não possuem equivalente limpo em JSON e são intencionalmente com perdas. A ordem dos elementos é preservada pelo XML, mas não é garantida pela ordem de chaves de objetos JSON em todos os consumidores (embora o ES2015 especifique ordem de inserção para chaves de string, esquemas como JSON Schema não restringem isso). Conteúdo misto como `<p>Hello <b>world</b>!</p>` intercala texto com elementos e não pode ser convertido de volta para o modelo simples de chave-valor. Namespaces XML em notação Clark (`{http://example.com/ns}user`) são reduzidos ao nome local `user`, que pode colidir com um elemento sem namespace de mesmo nome. Blocos CDATA como `<![CDATA[<raw>]]>` são expandidos em texto simples. Instruções de processamento (`<?xml-stylesheet ...?>`), comentários (`<!-- ... -->`) e a declaração XML são descartados porque JSON não possui sintaxe para eles. A indentação é aplicada via `JSON.stringify(value, null, indent)` com 2 espaços, 4 espaços ou `'\t'`.

  • Parser: `new DOMParser().parseFromString(xml, 'application/xml')` conforme W3C DOM Level 3 Core; erros aparecem como um elemento raiz `<parsererror>`, não uma exceção lançada.
  • Convenções de mapeamento: estilo Badgerfish com `@attr` para atributos, `#text` para texto misto, nome local do elemento para filhos; Parker descarta atributos, Spark os mantém em `$`.
  • Filhos repetidos com o mesmo nome são agrupados em um array JSON; um único filho permanece como objeto — a ambiguidade clássica de "único vs. múltiplo" não possui solução do lado XML.
  • Recursos com perdas: atributos (sem prefixo `@`), namespaces (`xmlns:foo`), instruções de processamento, comentários, declaração XML e blocos CDATA.
  • Conteúdo misto (`<p>Hello <b>world</b>!</p>`) não pode ser convertido de volta para JSON chave-valor; a ordem dos elementos pode ser perdida em consumidores que não preservam a ordem das chaves.
  • Conversão de número/booleano é uma escolha deliberada: `<age>30</age>` pode se tornar `30` (número) ou `"30"` (string); zeros à esquerda (`007`) devem permanecer como strings.
  • A formatação de saída usa `JSON.stringify(value, null, indent)` com indentação de 2 espaços, 4 espaços ou `'\t'`; o resultado é UTF-8 sem BOM.

Exemplos

Elemento simples

&lt;root>
  &lt;name>John&lt;/name>
&lt;/root>
→
{"root": {"name": "John"}}

Elementos repetidos

&lt;root>
  &lt;item>A&lt;/item>
  &lt;item>B&lt;/item>
&lt;/root>
→
{"root": {"item": ["A", "B"]}}

Estrutura aninhada

&lt;root>
  &lt;user>
    &lt;name>John&lt;/name>
    &lt;age>30&lt;/age>
  &lt;/user>
&lt;/root>
→
{"root": {"user": {"name": "John", "age": 30}}}

Perguntas frequentes

Como os elementos XML são mapeados para JSON?

Cada elemento vira uma propriedade JSON cujo valor é o conteúdo do elemento (string ou objeto aninhado). Elementos repetidos com o mesmo nome viram arrays. Os atributos costumam ser prefixados com '@' ou armazenados em uma chave especial como '$'. A convenção exata varia e é configurável na maioria das páginas.

Por que a conversão de XML para JSON às vezes perde informação?

O XML distingue elementos, atributos, conteúdo de texto, conteúdo misto (texto e elementos), namespaces, instruções de processamento e comentários. O JSON tem só objetos, arrays, strings, números, booleanos e null. Mapear a árvore mais rica do XML para JSON faz perder informações sobre ordem e a distinção entre elemento e atributo.

Como elementos com conteúdo misto (texto + elementos filhos) são tratados?

Conteúdo misto é complicado:

Olá mundo!

não tem uma representação JSON limpa. A página normalmente usa uma chave especial (por exemplo, '#text' ou '$') para capturar o texto solto, mas a ordem entre texto e elementos nem sempre é preservada. Evite conteúdo misto se você pretende fazer ida e volta.

E os namespaces XML?

Elementos com prefixo (<ns:foo>) viram chaves de string 'ns:foo' ou são divididos em propriedades de ns/local-name. Declarações xmlns podem ser preservadas como propriedades semelhantes a atributos ou descartadas, dependendo da configuração da página.

Consigo voltar do JSON para um XML idêntico?

O ida e volta não é, em geral, sem perdas, principalmente para conteúdo misto, comentários, instruções de processamento e ordem dos atributos. Para XML somente de dados (configuração, registros simples), o ida e volta costuma funcionar. Para XML estilo documento (DocBook, HTML, RSS), use um parser XML de verdade.

Um elemento XML vazio <foo/> é igual a <foo></foo>?

Sim, para o parser. Os dois produzem uma propriedade foo com string vazia ou valor null. A sintaxe autofechada é puramente cosmética em XML.

A conversão é local?

Sim. A análise do XML e a geração do JSON acontecem no seu navegador. A página não envia seus dados.

Ferramentas relacionadas

Conversor de JSON para XML

Conversor gratuito de JSON para XML online com elemento raiz personalizável e recuo. Converta dados JSON em XML formatado instantaneamente no seu navegador.

Ferramenta de Formatação XML

Formatador XML online gratuito com recuo automático, validação e minificação. Personalize configurações de recuo, detecte rapidamente erros de formato XML.

Ferramenta de Formatação JSON

Formatador JSON online gratuito com destaque de sintaxe, detecção de erros e minificação. Embeleze dados JSON instantaneamente, detecte erros de formato, acelere seu fluxo de desenvolvimento.

Conversor de CSV para JSON

Conversor gratuito de CSV para JSON online com suporte a delimitador personalizado e opção de primeira linha como cabeçalho. Converta rapidamente dados tabulares para formato JSON.

Ferramenta de Formatação YAML

Formatador YAML online gratuito com verificação de sintaxe, recuo automático e conversão de formato. Gerencie arquivos de configuração facilmente, identifique problemas de sintaxe instantaneamente.

Conversor de Excel para JSON

Conversor online de Excel para JSON. Suporta formatos .xlsx e .xls com seleção múltipla de planilhas. Converta dados de planilha para formato JSON localmente.