Validador XML

O que é Validação de XML?

Um validador de XML verifica se um documento XML segue as regras estruturais definidas pela especificação XML 1.0 (Recomendação W3C, quinta edição). No mínimo, este validador confirma que um documento é bem-formado: possui um único elemento raiz, todas as tags estão corretamente aninhadas e fechadas, os valores de atributo estão entre aspas e os caracteres reservados utilizam entidades predefinidas. Um documento que falhe em qualquer uma dessas verificações fará com que os parsers de XML gerem erros em vez de produzir silenciosamente uma saída incorreta.

A distinção entre bem-formação e validade é importante. Um documento XML bem-formado satisfaz as regras de sintaxe da própria especificação XML. Um documento XML válido vai além: também está em conformidade com as restrições definidas em um esquema externo, como um DTD (Document Type Definition), XSD (XML Schema Definition) ou esquema Relax NG. Esta ferramenta verifica a bem-formação, a primeira e mais comum etapa de validação. Sem ela, nada no processo subsequente pode prosseguir.

A validação de XML detecta erros antes que eles cheguem à produção. Tags não fechadas, nomes de elementos incompatíveis, e comerciais sem escape e atributos duplicados estão entre os erros mais comuns em XML editado manualmente. Parsers em diferentes linguagens tratam esses erros de formas distintas: alguns falham silenciosamente, alguns retornam resultados parciais e outros lançam exceções. Passar seu XML por um validador elimina essa ambiguidade e fornece uma resposta clara de aprovação ou reprovação com detalhes sobre a localização do erro.

Por que Usar um Validador de XML Online?

Detectar erros de sintaxe XML cedo evita falhas em cascata em aplicações que consomem dados XML. Um validador no navegador oferece feedback imediato sem precisar instalar ferramentas de linha de comando ou configurar plugins de IDE.

Casos de Uso do Validador de XML

Regras de Bem-Formação do XML

A especificação XML 1.0 define um conjunto rígido de regras de sintaxe. Um documento deve satisfazer todas elas para ser considerado bem-formado. A tabela abaixo lista cada regra, o que ela exige e um exemplo correto. A maioria dos erros de validação remonta a uma dessas regras.

Bem-Formado vs. Válido por DTD vs. Válido por Esquema

A validação de XML tem três níveis. Esta ferramenta verifica o primeiro (bem-formação), que é um pré-requisito para os outros dois.

Exemplos de Código

Valide XML programaticamente em diferentes linguagens. Cada exemplo verifica a bem-formação e retorna a mensagem de erro se o documento estiver malformado.

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

Perguntas Frequentes