XML a YAML

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

La conversión de XML a YAML transforma datos del Lenguaje de Marcado Extensible (XML) a YAML Ain't Markup Language (YAML). XML usa etiquetas con corchetes angulares y atributos para describir datos jerárquicos, mientras que YAML representa las mismas estructuras mediante indentación y pares clave-valor en texto plano. Convertir XML a YAML online es una tarea habitual al migrar configuración de sistemas basados en XML, como Java Spring, Maven o .NET, a plataformas que prefieren YAML, como Kubernetes, Ansible, GitHub Actions o Docker Compose.

Los dos formatos difieren en sus modelos de datos. XML trata todo como texto por defecto y depende de definiciones de esquema (XSD, DTD) para la aplicación de tipos. YAML tiene tipos nativos: cadenas, enteros, flotantes, booleanos, nulos, secuencias (matrices) y mapeos (objetos). Durante la conversión, valores como "true", "5432" y "3.14" pueden interpretarse como tipos nativos de YAML en lugar de permanecer como cadenas. Un conversor cuidadoso entrecomilla estos valores para preservar la representación textual original del XML.

XML también admite construcciones sin equivalente en YAML: atributos, espacios de nombres, instrucciones de procesamiento, secciones CDATA y comentarios. La conversión debe elegir una convención para representar los atributos (habitualmente claves con prefijo de guion bajo, como _attr) y decidir si descartar o aplanar el resto. Entender estos compromisos antes de convertir te ayuda a elegir la herramienta adecuada, configurarla correctamente y verificar que la salida YAML refleja la intención original del XML.

<server>
  <host>db.example.com</host>
  <port>5432</port>
  <credentials admin="true">
    <username>deploy</username>
    <password>s3cret</password>
  </credentials>
  <options>
    <option>ssl=true</option>
    <option>timeout=30</option>
  </options>
</server>

server:
  host: db.example.com
  port: "5432"
  credentials:
    _admin: "true"
    username: deploy
    password: s3cret
  options:
    option:
      - ssl=true
      - timeout=30

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

Escribir un script de conversión a mano implica gestionar el mapeo de atributos, la detección de matrices en elementos repetidos y los casos límite de coerción de tipos en YAML. Un conversor en el navegador resuelve todo eso en un solo paso, permitiéndote inspeccionar la salida YAML y copiarla directamente en tus archivos de configuración.

Casos de uso de XML a YAML

Referencia de correspondencia XML a YAML

XML y YAML tienen modelos de datos distintos. La tabla siguiente muestra cómo se corresponde cada construcción XML con su equivalente YAML. Los atributos se convierten habitualmente a claves con prefijo de guion bajo, y los elementos repetidos se convierten en secuencias YAML. Algunas construcciones, como los comentarios e instrucciones de procesamiento, no tienen representación en YAML y se descartan durante la conversión.

XML vs YAML: diferencias en el modelo de datos

Convertir entre XML y YAML no es un simple cambio de sintaxis. Los formatos tienen diferencias estructurales fundamentales que afectan a cómo se representan los datos tras la conversión.

Ejemplos de código

A continuación se muestran ejemplos funcionales para convertir XML a YAML en JavaScript, Python, Go y la línea de comandos. Cada ejemplo gestiona elementos anidados, atributos y etiquetas hermanas repetidas.

import { parseStringPromise } from 'xml2js'
import YAML from 'yaml'

const xml = `
<config>
  <database host="localhost" port="5432">
    <name>mydb</name>
  </database>
  <features>
    <feature>auth</feature>
    <feature>logging</feature>
  </features>
</config>`

const obj = await parseStringPromise(xml, { explicitArray: false })
console.log(YAML.stringify(obj))
// → config:
// →   database:
// →     $:
// →       host: localhost
// →       port: "5432"
// →     name: mydb
// →   features:
// →     feature:
// →       - auth
// →       - logging

import xmltodict
import yaml

xml = """
<server>
  <host>db.example.com</host>
  <port>5432</port>
  <replicas>
    <replica>node-1</replica>
    <replica>node-2</replica>
  </replicas>
</server>
"""

# Step 1: XML → Python dict
data = xmltodict.parse(xml)

# Step 2: Python dict → YAML
print(yaml.dump(data, default_flow_style=False))
# → server:
# →   host: db.example.com
# →   port: '5432'
# →   replicas:
# →     replica:
# →     - node-1
# →     - node-2

# With the standard library only (no xmltodict)
import xml.etree.ElementTree as ET

def elem_to_dict(elem):
    d = {}
    if elem.attrib:
        d.update({f"_{k}": v for k, v in elem.attrib.items()})
    for child in elem:
        val = elem_to_dict(child)
        if child.tag in d:
            if not isinstance(d[child.tag], list):
                d[child.tag] = [d[child.tag]]
            d[child.tag].append(val)
        else:
            d[child.tag] = val
    if elem.text and elem.text.strip():
        text = elem.text.strip()
        return text if not d else {**d, "_text": text}
    return d

root = ET.fromstring(xml)
print(yaml.dump({root.tag: elem_to_dict(root)}, default_flow_style=False))

# xq is part of the yq package (pip install yq)
# It parses XML via xq and outputs JSON, then pipe to yq for YAML

echo '<config><host>localhost</host><port>8080</port></config>' | xq . | yq -y .
# → config:
# →   host: localhost
# →   port: "8080"

# Using xmlstarlet + yq (Go version: https://github.com/mikefarah/yq)
xmlstarlet sel -t -c '/' input.xml | yq -p=xml -o=yaml
# Reads XML from file and outputs YAML directly

package main

import (
	"encoding/xml"
	"fmt"
	"strings"

	"gopkg.in/yaml.v3"
)

type Server struct {
	XMLName xml.Name `xml:"server"`
	Host    string   `xml:"host" yaml:"host"`
	Port    int      `xml:"port" yaml:"port"`
	Options []string `xml:"options>option" yaml:"options"`
}

func main() {
	data := `<server>
		<host>db.example.com</host>
		<port>5432</port>
		<options><option>ssl=true</option><option>timeout=30</option></options>
	</server>`

	var srv Server
	xml.NewDecoder(strings.NewReader(data)).Decode(&srv)

	out, _ := yaml.Marshal(srv)
	fmt.Println(string(out))
	// → host: db.example.com
	// → port: 5432
	// → options:
	// →   - ssl=true
	// →   - timeout=30
}

Preguntas frecuentes