YAML to XML
Převod YAML do formátu XML
Vstup YAML
Výstup XML
Co je převod YAML na XML?
Převod YAML na XML transformuje data zapsaná ve formátu YAML (YAML Ain't Markup Language) do formátu XML (Extensible Markup Language). YAML používá odsazení a minimální interpunkci k reprezentaci strukturovaných dat, zatímco XML používá otevírací a zavírací tagy s explicitní hierarchií. Převod mezi oběma formáty je běžný úkol, když systémy konzumující XML potřebují přijímat data původně zapsaná v YAML.
YAML byl navržen pro čitelnost člověkem. Konfigurační soubory nástrojů jako Kubernetes, Ansible, Docker Compose a GitHub Actions jsou psány v YAML, protože je kompaktní a snadno editovatelný ručně. XML, definované specifikací W3C XML 1.0, bylo po desetiletí výchozím formátem pro výměnu dat v podnikových systémech, webových službách SOAP a dokumentově orientovaných pracovních postupech. Pokud konfigurace psaná v YAML musí vstupovat do pipeline založené na XML, je převod nezbytný.
Mapování mezi YAML a XML není přímočaré. YAML nativně podporuje datové typy jako logické hodnoty, celá čísla, čísla s plovoucí řádovou čárkou a null, zatímco XML zachází se vším obsahem jako s textem, pokud schéma (XSD nebo DTD) nedefinuje typy externě. Sekvence YAML (seznamy) nemají přímý ekvivalent v XML a musejí být reprezentovány jako opakující se elementy. Znalost těchto rozdílů pomáhá předvídat výstup a vyhnout se překvapením.
Proč použít tento převodník YAML na XML?
Ruční přepisování YAML do XML je zdlouhavé a náchylné k chybám, zejména u hluboce vnořených struktur. Tento převodník zvládne strukturální překlad okamžitě.
Případy použití YAML na XML
Referenční tabulka mapování typů YAML na XML
Datové typy YAML se nemapují přímo do XML. Tato tabulka ukazuje, jak se každý konstrukt YAML překládá do XML ekvivalentu. Pochopení těchto pravidel pomáhá předvídat výstup a odstraňovat neočekávané výsledky.
| Typ YAML | Příklad YAML | Výstup XML |
|---|---|---|
| Mapping (key: value) | { name: Alice } | <name>Alice</name> |
| Sequence (- item) | - apple\n- banana | <item>apple</item><item>banana</item> |
| Nested mapping | user:\n name: Alice | <user><name>Alice</name></user> |
| Scalar (string) | greeting: hello world | <greeting>hello world</greeting> |
| Scalar (number) | count: 42 | <count>42</count> |
| Scalar (boolean) | active: true | <active>true</active> |
| Null | value: null | <value/> |
| Multiline string | bio: |\n Line one\n Line two | <bio>Line one\nLine two</bio> |
YAML vs XML: rozdíly formátů
YAML a XML řeší stejný problém — reprezentaci strukturovaných dat — s různými kompromisy. Ani jeden formát není univerzálně lepší; správná volba závisí na tom, kdo nebo co data konzumuje.
| Vlastnost | YAML | XML |
|---|---|---|
| Syntaxe | Na základě odsazení | Tagová (<tag>...</tag>) |
| Datové typy | Nativní (string, int, bool, null, float) | Pouze text (schéma přidává typy) |
| Komentáře | # inline komentáře | <!-- blokové komentáře --> |
| Atributy | Bez nativní podpory | Ano (<tag attr="val">) |
| Jmenné prostory | Nepodporovány | Ano (xmlns:prefix) |
| Velikost souboru | Menší (bez zavíracích tagů) | Větší (výřečné tagy) |
Příklady kódu
Jak převést YAML na XML programově v různých jazycích a prostředích:
import { parseDocument } from 'yaml'
import { js2xml } from 'xml-js'
const yamlStr = `
server:
host: localhost
port: 8080
ssl: true
`
const data = parseDocument(yamlStr).toJSON()
const xml = js2xml({ root: data }, { compact: true, spaces: 2 })
console.log(xml)
// → <root>
// → <server>
// → <host>localhost</host>
// → <port>8080</port>
// → <ssl>true</ssl>
// → </server>
// → </root>import yaml
import xml.etree.ElementTree as ET
yaml_str = """
database:
host: db.example.com
port: 5432
credentials:
user: admin
password: secret
"""
data = yaml.safe_load(yaml_str)
def dict_to_xml(tag, d):
elem = ET.Element(tag)
for key, val in d.items():
child = ET.SubElement(elem, key)
if isinstance(val, dict):
child.extend(dict_to_xml(key, val))
elem.remove(child)
elem.append(dict_to_xml(key, val))
else:
child.text = str(val)
return elem
root = dict_to_xml('root', data)
ET.indent(root, space=' ')
print(ET.tostring(root, encoding='unicode'))
# → <root>
# → <database>
# → <host>db.example.com</host>
# → <port>5432</port>
# → ...
# → </database>
# → </root>package main
import (
"encoding/xml"
"fmt"
"gopkg.in/yaml.v3"
)
type Server struct {
XMLName xml.Name `xml:"server"`
Host string `yaml:"host" xml:"host"`
Port int `yaml:"port" xml:"port"`
SSL bool `yaml:"ssl" xml:"ssl"`
}
func main() {
yamlData := []byte("host: localhost\nport: 8080\nssl: true")
var s Server
yaml.Unmarshal(yamlData, &s)
xmlBytes, _ := xml.MarshalIndent(s, "", " ")
fmt.Println(xml.Header + string(xmlBytes))
// → <?xml version="1.0" encoding="UTF-8"?>
// → <server>
// → <host>localhost</host>
// → <port>8080</port>
// → <ssl>true</ssl>
// → </server>
}# Using yq (YAML processor) with xq (XML wrapper around jq) # Install: pip install yq # Convert YAML file to XML yq -x . config.yaml # → <host>localhost</host><port>8080</port> # Pipe inline YAML through conversion echo "name: Alice" | yq -x . # → <name>Alice</name>