Validateur XML

Qu'est-ce que la validation XML ?

Un validateur XML vérifie si un document XML respecte les règles structurelles définies par la spécification XML 1.0 (recommandation W3C, cinquième édition). Au minimum, ce validateur XML confirme qu'un document est bien formé : il possède un unique élément racine, toutes les balises sont correctement imbriquées et fermées, les valeurs d'attributs sont entre guillemets, et les caractères réservés utilisent des entités prédéfinies. Un document qui ne satisfait pas l'une de ces règles provoquera des erreurs dans les parseurs XML, plutôt qu'une sortie silencieusement incorrecte.

La distinction entre bien-formé et valide est importante. Un document XML bien formé respecte les règles syntaxiques de la spécification XML elle-même. Un document XML valide va plus loin : il est également conforme aux contraintes définies dans un schéma externe, tel qu'un DTD (Document Type Definition), un XSD (XML Schema Definition) ou un schéma Relax NG. Cet outil vérifie le bien-formé, la première étape de validation et la plus courante. Sans elle, rien en aval ne peut fonctionner.

La validation XML détecte les erreurs avant qu'elles n'atteignent la production. Les balises non fermées, les noms d'éléments mal assortis, les esperluettes non échappées et les attributs en double figurent parmi les erreurs les plus fréquentes dans un XML édité à la main. Les parseurs de différents langages gèrent ces erreurs différemment : certains échouent silencieusement, d'autres retournent des résultats partiels, d'autres encore lèvent des exceptions. Passer votre XML dans un validateur en amont élimine cette ambiguïté et vous donne une réponse claire avec la localisation précise de l'erreur.

Pourquoi utiliser un validateur XML en ligne ?

Détecter les erreurs de syntaxe XML tôt évite les cascades de pannes dans les applications qui consomment des données XML. Un validateur dans le navigateur vous donne un retour immédiat sans avoir à installer des outils en ligne de commande ni à configurer des plugins d'IDE.

Cas d'utilisation du validateur XML

Règles de bien-formé XML

La spécification XML 1.0 définit un ensemble strict de règles syntaxiques. Un document doit les respecter toutes pour être considéré comme bien formé. Le tableau ci-dessous liste chaque règle, ses exigences et un exemple correct. La plupart des erreurs de validation se ramènent à l'une de ces règles.

Bien formé vs. valide selon DTD vs. valide selon schéma

La validation XML comporte trois niveaux. Cet outil vérifie le premier (le bien-formé), qui est un prérequis pour les deux autres.

Exemples de code

Validez du XML par programmation dans différents langages. Chaque exemple vérifie le bien-formé et retourne le message d'erreur si le document est malformé.

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

Questions fréquemment posées