Convertidor de XML a JSON

Parsea XML en un objeto JSON usando las convenciones de fast-xml-parser: los elementos hijos se convierten en propiedades de objeto, los hijos repetidos se convierten en arrays, los atributos se preservan con el prefijo `@_` en el objeto padre, y el contenido de texto de nodos mixtos cae en una clave `#text`. Los valores numéricos y booleanos de atributo se auto-tipan vía `parseAttributeValue: true` — un XML `count="42"` round-trippea como `"@_count": 42`, no como la cadena `"42"`.

Ejemplo

Entrada XML:

<root version="1">
  <name>Ada</name>
  <tags>math</tags>
  <tags>logic</tags>
</root>

Salida JSON:

{
  "root": {
    "@_version": 1,
    "name": "Ada",
    "tags": ["math", "logic"]
  }
}

Trampas comunes de XML y cómo manejarlas

XML tiene casos extremos que JSON no. Estos son los patrones que producen salidas sorprendentes.

• Hijo único vs. hijos múltiples. `<a><b/></a>` produce `{"a":{"b":""}}` (hijo único como propiedad de objeto), pero `<a><b/><b/></a>` produce `{"a":{"b":["",""]}}` (múltiples como array). Si tu código aguas abajo siempre espera un array, normaliza tras la conversión.
• Atributos vs. elementos hijos. Los atributos aparecen con prefijo `@_` al mismo nivel que los hijos. `<user id="1"><name>Ada</name></user>` se vuelve `{"user":{"@_id":1,"name":"Ada"}}`. Algunas herramientas mezclan atributos en propiedades — esa es una convención diferente a la usada aquí.
• Contenido mixto (texto + elementos hijos). `<p>Hello <b>world</b></p>` produce `{"p":{"#text":"Hello ","b":"world"}}`. El texto se captura pero su posición relativa a los hijos se pierde — JSON no tiene forma de representar contenido mixto ordenado. La mayoría de XML estilo config no cae en este caso.
• Espacios de nombres. Los namespaces (`<x:foo xmlns:x="...">`) se preservan como parte del nombre del elemento (`x:foo`). Muchos consumidores XML quitan el prefijo; si lo necesitas, hazlo como paso de post-procesamiento.
• Secciones CDATA. `<![CDATA[some text]]>` se parsea como texto plano y se une al `#text` de su padre. La envoltura CDATA se pierde — está bien para la mayoría de casos pero vale la pena notarlo si la envoltura tenía significado semántico.
• Auto-cerrado vs. vacío. `<x/>` y `<x></x>` son equivalentes en XML y producen la misma salida JSON (`""` para el valor). La envoltura original no es recuperable desde el JSON.

¿Por qué mi salida tiene un prefijo `@_` en los atributos?

Distingue atributos XML de elementos hijos. Sin un prefijo, `<user id="1"><id>foo</id></user>` tendría dos claves `id` — un objeto JSON solo puede tener una. El prefijo mantiene ambos round-trippables. Si no necesitas el prefijo, reemplaza `"@_"` con `""` en un paso de post-procesamiento (y acepta el riesgo de colisión).

¿Puedo obtener el JSON sin la clave raíz envolvente?

XML siempre tiene un único elemento raíz. El JSON mantiene esa envoltura para round-trippability. Quítala tras la conversión si quieres el objeto interno — `result.root` en vez de `result`.

¿Se preservan los comentarios XML?

No. JSON no tiene sintaxis de comentarios, y el parser está configurado para ignorar comentarios XML. Si necesitas preservar comentarios, tendrías que usar una representación intermedia diferente que los soporte.

¿Los valores de atributo están tipados?

Sí — `parseAttributeValue: true` está activado, así que `count="42"` se vuelve `"@_count": 42` (número) y `enabled="true"` se vuelve `"@_enabled": true` (booleano). Si necesitas atributos como cadenas, post-procesa o forka la configuración.

¿Mi XML se sube?

No. Todo se ejecuta en tu navegador — tu XML se parsea por JavaScript en esta página y nunca se envía a un servidor. Verifícalo en las herramientas de desarrollador.

¿Puede manejar archivos XML muy grandes?

Hasta unos 30 MB antes de que el textarea se ralentice. El parser escala linealmente. Para entradas mayores, ejecuta fast-xml-parser en línea de comandos — misma biblioteca.