XML Validator

Wat is XML-validatie?

Een XML-validator controleert of een XML-document voldoet aan de structuurregels uit de XML 1.0-specificatie (W3C Recommendation, vijfde editie). Op zijn minst bevestigt deze xml-validator dat een document welgevormd is: het heeft één rootelement, alle tags zijn correct genest en afgesloten, attribuutwaarden staan tussen aanhalingstekens, en gereserveerde tekens gebruiken voorgedefinieerde entities. Een document dat een van deze controles niet doorstaat, laat XML-parsers fouten gooien in plaats van stilletjes onjuiste uitvoer te produceren.

Het onderscheid tussen welgevormdheid en geldigheid is belangrijk. Een welgevormd XML-document voldoet aan de syntaxisregels van de XML-specificatie zelf. Een geldig XML-document gaat verder: het voldoet ook aan beperkingen uit een extern schema, zoals een DTD (Document Type Definition), XSD (XML Schema Definition) of Relax NG-schema. Dit hulpmiddel controleert welgevormdheid — de eerste en meest voorkomende validatiestap. Zonder welgevormdheid kan niets daarna verdergaan.

XML-validatie pakt fouten op voordat ze de productie bereiken. Niet-afgesloten tags, niet-overeenkomende elementnamen, niet-geëscapete ampersands en dubbele attributen horen bij de meest voorkomende fouten in handmatig bewerkte XML. Parsers in verschillende talen gaan hier anders mee om: sommige falen stilletjes, sommige geven gedeeltelijke resultaten terug en sommige gooien uitzonderingen. Uw XML eerst door een validator halen elimineert deze onduidelijkheid en geeft u een duidelijk geslaagd of mislukt antwoord met informatie over de foutlocatie.

Waarom een online XML-validator gebruiken?

XML-syntaxisfouten vroeg opsporen voorkomt kettingreacties in applicaties die XML-data verwerken. Een browsergebaseerde validator geeft directe feedback zonder opdrachtregeltools te installeren of IDE-plugins te configureren.

Gebruiksscenario's voor XML Validator

XML-welgevormdheidsregels

De XML 1.0-specificatie definieert een strikte set syntaxisregels. Een document moet aan al deze regels voldoen om als welgevormd te worden beschouwd. De onderstaande tabel geeft elke regel, de vereiste en een correct voorbeeld. De meeste validatiefouten zijn terug te voeren op een van deze regels.

Welgevormd vs. DTD-geldig vs. schema-geldig

XML-validatie kent drie niveaus. Dit hulpmiddel controleert het eerste (welgevormdheid), wat een vereiste is voor de andere twee.

Codevoorbeelden

Valideer XML programmatisch in verschillende talen. Elk voorbeeld controleert welgevormdheid en geeft de foutmelding terug als het document misvormd is.

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

Veelgestelde vragen