Validatore XML

Cos'è la validazione XML?

Un validatore XML verifica se un documento XML rispetta le regole strutturali definite dalla specifica XML 1.0 (W3C Recommendation, quinta edizione). Come minimo, questo validatore XML conferma che un documento è ben formato: ha un singolo elemento radice, tutti i tag sono correttamente annidati e chiusi, i valori degli attributi sono tra virgolette e i caratteri riservati utilizzano le entità predefinite. Un documento che non supera uno di questi controlli causerà errori nei parser XML anziché produrre silenziosamente un output errato.

La distinzione tra ben-formazione e validità è importante. Un documento XML ben formato soddisfa le regole sintattiche della specifica XML stessa. Un documento XML valido va oltre: è anche conforme ai vincoli definiti in uno schema esterno, come un DTD (Document Type Definition), un XSD (XML Schema Definition) o uno schema Relax NG. Questo strumento verifica la ben-formazione, il primo e più comune passo di validazione. Senza di essa, nessun processo a valle può procedere.

La validazione XML intercetta gli errori prima che raggiungano la produzione. Tag non chiusi, nomi di elementi non corrispondenti, ampersand senza escape e attributi duplicati sono tra gli errori più comuni nell'XML modificato a mano. I parser nei diversi linguaggi gestiscono questi errori in modi diversi: alcuni falliscono silenziosamente, altri restituiscono risultati parziali e altri ancora lanciano eccezioni. Eseguire prima l'XML attraverso un validatore elimina questa ambiguità e fornisce una risposta chiara di successo o fallimento con i dettagli sulla posizione dell'errore.

Perché usare un validatore XML online?

Rilevare tempestivamente gli errori di sintassi XML previene i guasti a cascata nelle applicazioni che consumano dati XML. Un validatore basato su browser fornisce un feedback immediato senza dover installare strumenti da riga di comando o configurare plugin per l'IDE.

Casi d'uso del Validatore XML

Regole di ben-formazione XML

La specifica XML 1.0 definisce un insieme rigoroso di regole sintattiche. Un documento deve soddisfarle tutte per essere considerato ben formato. La tabella seguente elenca ciascuna regola, i suoi requisiti e un esempio corretto. La maggior parte degli errori di validazione riconduce a una di queste regole.

Ben-formato vs. DTD-valido vs. Schema-valido

La validazione XML ha tre livelli. Questo strumento verifica il primo (ben-formazione), che è un prerequisito per gli altri due.

Esempi di codice

Valida XML a livello programmatico in diversi linguaggi. Ogni esempio verifica la ben-formazione e restituisce il messaggio di errore se il documento non è valido.

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

Domande frequenti