XML Validator

Was ist XML-Validierung?

Ein XML-Validator prüft, ob ein XML-Dokument den strukturellen Regeln der XML-1.0-Spezifikation (W3C-Empfehlung, fünfte Ausgabe) entspricht. Im Mindestfall bestätigt dieser XML Validator, dass ein Dokument wohlgeformt ist: Es hat genau ein Root-Element, alle Tags sind korrekt verschachtelt und geschlossen, Attributwerte stehen in Anführungszeichen, und reservierte Zeichen verwenden vordefinierte Entities. Ein Dokument, das eine dieser Regeln verletzt, veranlasst XML-Parser, Fehler zu werfen — anstatt stillschweigend falsche Ergebnisse zu liefern.

Der Unterschied zwischen Wohlgeformtheit und Gültigkeit ist wichtig. Ein wohlgeformtes XML-Dokument erfüllt die Syntaxregeln der XML-Spezifikation selbst. Ein gültiges XML-Dokument geht weiter: Es entspricht zusätzlich den Einschränkungen eines externen Schemas, etwa eines DTD (Document Type Definition), XSD (XML Schema Definition) oder Relax NG Schemas. Dieses Tool prüft die Wohlgeformtheit — den ersten und häufigsten Validierungsschritt. Ohne diese Grundlage kann kein nachgelagerter Prozess fortfahren.

XML-Validierung erkennt Fehler, bevor sie in der Produktion ankommen. Nicht geschlossene Tags, nicht übereinstimmende Elementnamen, nicht maskierte Kaufmanns-Und-Zeichen und doppelte Attribute gehören zu den häufigsten Fehlern in manuell bearbeitetem XML. Parser in verschiedenen Sprachen behandeln diese Fehler unterschiedlich: Manche schlagen stillschweigend fehl, manche liefern Teilergebnisse, manche werfen Exceptions. XML zuerst durch einen Validator zu schicken beseitigt diese Unklarheit und liefert ein klares Ja-oder-Nein-Ergebnis mit genauen Fehlerdetails.

Warum einen Online-XML-Validator verwenden?

XML-Syntaxfehler frühzeitig zu erkennen verhindert Folgefehler in Anwendungen, die XML-Daten verarbeiten. Ein browserbasiierter Validator liefert sofortiges Feedback, ohne dass Command-Line-Tools installiert oder IDE-Plugins konfiguriert werden müssen.

Anwendungsfälle für den XML Validator

XML-Wohlgeformtheitsregeln

Die XML-1.0-Spezifikation definiert einen strengen Satz von Syntaxregeln. Ein Dokument muss alle davon erfüllen, um als wohlgeformt zu gelten. Die Tabelle unten listet jede Regel auf, was sie erfordert und ein korrektes Beispiel. Die meisten Validierungsfehler lassen sich auf eine dieser Regeln zurückführen.

Wohlgeformt vs. DTD-gültig vs. Schema-gültig

XML-Validierung hat drei Ebenen. Dieses Tool prüft die erste (Wohlgeformtheit), die eine Voraussetzung für die anderen beiden ist.

Code-Beispiele

XML programmatisch in verschiedenen Sprachen validieren. Jedes Beispiel prüft die Wohlgeformtheit und gibt die Fehlermeldung zurück, wenn das Dokument fehlerhaft ist.

function validateXML(xmlString) {
  const parser = new DOMParser()
  const doc = parser.parseFromString(xmlString, 'application/xml')
  const error = doc.querySelector('parsererror')
  if (error) {
    return { valid: false, message: error.textContent }
  }
  return { valid: true, message: 'Well-formed XML' }
}

validateXML('<root><item>hello</item></root>')
// → { valid: true, message: "Well-formed XML" }

validateXML('<root><item>hello</root>')
// → { valid: false, message: "Opening and ending tag mismatch..." }

import xml.etree.ElementTree as ET

def validate_xml(xml_string):
    try:
        ET.fromstring(xml_string)
        return True, "Well-formed XML"
    except ET.ParseError as e:
        return False, str(e)

valid, msg = validate_xml('<root><item>hello</item></root>')
# → (True, "Well-formed XML")

valid, msg = validate_xml('<root><item>hello</root>')
# → (False, "mismatched tag: line 1, column 27")

# With lxml — also supports XSD schema validation
from lxml import etree
schema = etree.XMLSchema(etree.parse('schema.xsd'))
doc = etree.fromstring(b'<root><item>hello</item></root>')
schema.validate(doc)  # → True or False

package main

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

func validateXML(raw string) error {
    decoder := xml.NewDecoder(strings.NewReader(raw))
    for {
        _, err := decoder.Token()
        if err != nil {
            if err.Error() == "EOF" {
                return nil
            }
            return err
        }
    }
}

func main() {
    err := validateXML("<root><item>hello</item></root>")
    fmt.Println(err) // → <nil>

    err = validateXML("<root><item>hello</root>")
    fmt.Println(err) // → XML syntax error: unexpected end element </root>
}

# Check well-formedness (part of libxml2, pre-installed on macOS/Linux)
xmllint --noout document.xml
# Exit code 0 = valid, non-zero = errors printed to stderr

# Validate against an XSD schema
xmllint --noout --schema schema.xsd document.xml

# Validate against a DTD
xmllint --noout --dtdvalid schema.dtd document.xml

# Validate from stdin
echo '<root><unclosed>' | xmllint --noout -
# → :1: parser error : Premature end of data in tag unclosed line 1

Häufig gestellte Fragen