XML vers YAML

Qu'est-ce que la conversion XML vers YAML ?

La conversion XML vers YAML transforme des données depuis le langage de balisage extensible (XML) vers YAML Ain't Markup Language (YAML). XML utilise des balises entre chevrons avec des attributs pour décrire des données hiérarchiques, tandis que YAML représente les mêmes structures via l'indentation et des paires clé-valeur en texte brut. Convertir XML vers YAML en ligne est une tâche courante lors de la migration de configurations depuis des systèmes fortement XML comme Java Spring, Maven ou .NET vers des plateformes qui préfèrent YAML, telles que Kubernetes, Ansible, GitHub Actions et Docker Compose.

Les deux formats diffèrent dans leurs modèles de données. XML traite tout comme du texte par défaut et s'appuie sur des définitions de schéma (XSD, DTD) pour l'application des types. YAML dispose de types natifs : chaînes, entiers, flottants, booléens, nulls, séquences (tableaux) et mappings (objets). Lors de la conversion, des valeurs comme "true", "5432" et "3.14" peuvent être interprétées comme des types natifs YAML au lieu de rester des chaînes. Un convertisseur soigneux met ces valeurs entre guillemets pour préserver la représentation textuelle d'origine de la source XML.

XML prend également en charge des constructs sans équivalent YAML : attributs, espaces de noms, instructions de traitement, sections CDATA et commentaires. La conversion doit choisir une convention pour représenter les attributs (généralement des clés préfixées par un underscore, comme _attr) et décider de rejeter ou d'aplatir le reste. Comprendre ces compromis avant de convertir vous aide à choisir le bon outil, à le configurer correctement et à vérifier que la sortie YAML correspond à l'intention originale du 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

Pourquoi utiliser un convertisseur XML vers YAML en ligne ?

Écrire un script de conversion manuellement implique de gérer le mapping des attributs, la détection des tableaux pour les éléments répétés et les cas limites de coercition de types YAML. Un convertisseur dans le navigateur gère tout cela en une seule étape, vous permettant d'inspecter la sortie YAML et de la copier directement dans vos fichiers de configuration.

Cas d'utilisation de la conversion XML vers YAML

Référence de correspondance XML vers YAML

XML et YAML ont des modèles de données différents. Le tableau ci-dessous montre comment chaque construct XML correspond à un équivalent YAML. Les attributs sont généralement convertis en clés préfixées par un underscore, et les éléments répétés deviennent des séquences YAML. Certains constructs comme les commentaires et les instructions de traitement n'ont pas de représentation YAML et sont écartés lors de la conversion.

XML vs YAML : différences de modèles de données

Convertir entre XML et YAML n'est pas un simple changement de syntaxe. Les formats ont des différences structurelles fondamentales qui affectent la représentation des données après conversion.

Exemples de code

Voici des exemples fonctionnels pour convertir XML en YAML en JavaScript, Python, Go et en ligne de commande. Chaque exemple gère les éléments imbriqués, les attributs et les balises frères répétées.

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
}

Questions fréquemment posées