Primeiros Passos
Estrutura de Documento XML
Documentos XML começam com uma declaração XML. Os elementos devem estar corretamente aninhados e fechados. Atributos fornecem metadados adicionais. xmlns declara namespaces XML para evitar conflitos de nomes.
<?xml version="1.0" encoding="UTF-8"?>
<!-- This is a comment -->
<bookstore xmlns="https://example.com/books">
<book id="b1" category="fiction">
<title lang="en">The Great Gatsby</title>
<author>F. Scott Fitzgerald</author>
<price currency="USD">12.99</price>
</book>
<book id="b2" category="programming">
<title lang="en">XML Guide</title>
<author>John Doe</author>
<price currency="USD">29.99</price>
</book>
</bookstore>Declaração XML
A declaração XML é a primeira linha do prólogo. 'version' é obrigatória (1.0 ou 1.1). 'encoding' tem padrão UTF-8. 'standalone' diz aos parsers se declarações DTD externas são necessárias.
<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<!-- version is required; encoding and standalone are optional -->
<!-- encoding defaults to UTF-8 -->
<!-- standalone="yes" means no external markup declarations -->
<root>
<child>text</child>
</root>Comentários e Instruções de Processamento
Comentários usam <!-- --> e não podem aninhar nem conter '--' dentro. Instruções de Processamento (PIs) como xml-stylesheet passam informações específicas da aplicação ao parser. PIs usam <?target data?>.
<?xml version="1.0"?>
<!-- a comment: ignored by the parser, cannot contain -- -->
<?xml-stylesheet type="text/xsl" href="style.xsl"?>
<root>
<!-- comments can span
multiple lines -->
<item>data</item>
</root>XML Bem Formado
Bem formado significa: um único elemento raiz, aninhamento correto, todas as tags fechadas, atributos entre aspas, sem atributos duplicados. Um documento PRECISA estar bem formado para ser analisável; validade (contra DTD/Schema) é opcional.
<!-- WELL-FORMED: single root, properly nested, closed -->
<root>
<a>
<b>text</b>
</a>
</root>
<!-- NOT well-formed: two roots, overlapping tags -->
<!-- <a><b></a></b> -->
<!-- <x></x><y></y> (no single root) -->
<!-- All attributes must be quoted -->
<item id='1' type="x"/>Prólogo XML e Espaços em Branco
O prólogo inclui a declaração XML e um DOCTYPE opcional. xml:space='preserve' diz aos parsers para manter os espaços em branco; 'default' permite o tratamento normal. Espaços entre elementos geralmente são insignificantes.
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE root SYSTEM "root.dtd">
<root xml:space="preserve">
<item> spaced text </item>
<item xml:space="default"> trimmed </item>
</root>Visão Geral de CDATA
Seções CDATA marcam texto que o parser não deve interpretar como marcação. Dentro de CDATA, caracteres como <, > e & não precisam de escape. CDATA não pode ser aninhada nem conter o literal ']]>'.
<?xml version="1.0"?>
<root>
<code><![CDATA[
if (a < b && c > d) {
console.log("no escaping needed: < > & ");
}
]]></code>
</root>Elementos e Atributos
Elementos vs Atributos
Atributos servem para metadados (ids, tipos, flags); elementos servem para dados com estrutura ou valores repetidos. Um atributo aparece uma vez por elemento e não pode conter estrutura aninhada. Não há regra estrita—consistência é o que mais importa.
<!-- Attributes: metadata/identifiers; Elements: data -->
<person id="p1">
<name>Alice</name>
<age>30</age>
</person>
<!-- vs. putting everything in attributes -->
<person id="p1" name="Alice" age="30"/>
<!-- Rule of thumb: use elements for data you display,
attributes for IDs, types, and metadata -->Elementos Vazios
Um elemento vazio não tem conteúdo. A forma auto-fechada <tag/> é abreviação de <tag></tag>. O espaço antes de '/>' é uma convenção de estilo, por legibilidade e compatibilidade com XHTML.
<!-- Three equivalent empty-element forms -->
<br></br>
<br/>
<br />
<!-- empty element with attributes -->
<img src="logo.png" alt="Logo" width="200" height="100"/>
<!-- self-closing with namespace -->
<xlink:link xmlns:xlink="http://www.w3.org/1999/xlink" href="#sec1"/>Elementos Aninhados
Elementos se aninham hierarquicamente e devem fechar em ordem inversa—não podem se sobrepor. O aninhamento expressa estrutura. Árvores profundamente aninhadas são válidas, mas podem prejudicar a leitura e o desempenho de análise.
<library>
<section name="fiction">
<book>
<title>Book A</title>
<authors>
<author>Author 1</author>
<author>Author 2</author>
</authors>
</book>
</section>
</library>
<!-- WRONG: tags must not overlap -->
<!-- <a><b></a></b> -->Valores de Atributos e Aspas
Valores de atributos devem estar entre aspas simples ou duplas. Aspas duplas dentro de valores com aspas duplas devem ser escapadas como ". Um atributo pode aparecer apenas uma vez por elemento—use elementos filhos para valores repetidos.
<!-- Both single and double quotes are allowed -->
<item id="q1" name='quick'/>
<msg text="He said "hi""/>
<msg text='She said 'hi''/>
<!-- attribute values MUST be quoted -->
<!-- <item id=q1/> is NOT well-formed -->
<!-- an attribute can appear at most once per element -->
<point x="1" y="2" z="3"/>Atributos Default e Fixed
Declarações de atributos em DTD suportam #REQUIRED (deve aparecer), #IMPLIED (opcional), #FIXED (valor constante) e um literal padrão. Um atributo #FIXED deve sempre igualar seu valor declarado ou o documento é inválido.
<!-- In a DTD, attributes can have defaults -->
<!ATTLIST item
type CDATA "standard"
status CDATA #REQUIRED
version CDATA #FIXED "1.0"
note CDATA #IMPLIED>
<item status="active"/>
<!-- 'type' defaults to "standard", 'version' is fixed,
'note' is optional (#IMPLIED) -->Regras de Nomeação de Elementos
Nomes de elementos devem começar com letra ou underscore e podem conter letras, dígitos, hífens, underscores e pontos. Nomes não podem começar com 'xml' (qualquer caixa). XML diferencia maiúsculas, então <Tag> e <tag> são diferentes.
<!-- Names: start with a letter or underscore,
continue with letters, digits, hyphens, underscores, dots -->
<my-element>ok</my-element>
<my.element>ok</my.element>
<my_element>ok</my_element>
<_private>ok</_private>
<x-1>ok</x-1>
<!-- NOT allowed: starting with a digit or 'xml', containing spaces -->
<!-- <2way/> -->
<!-- <my element/> -->
<!-- <XmlTag/> (names are case-sensitive; 'xml' prefix is reserved) -->Namespaces
Namespace Padrão
Um namespace padrão (xmlns=URI) vale para o elemento em que é declarado e cada um dos descendentes sem prefixo. Elementos filhos o herdam, a menos que seja sobrescrito. Atributos nunca usam o namespace padrão.
<?xml version="1.0"?>
<table xmlns="http://www.w3.org/1999/xhtml">
<tr>
<td>Cell content</td>
<td>More content</td>
</tr>
</table>
<!-- All elements without a prefix use the default namespace -->Prefixo de Namespace
Um prefixo de namespace é declarado com xmlns:prefixo=URI e usado como prefixo:elemento. O prefixo é só um apelido—apenas a URI importa para a identidade. Prefixos diferenciam maiúsculas.
<?xml version="1.0"?>
<root xmlns:bk="https://example.com/books"
xmlns:au="https://example.com/authors">
<bk:book bk:id="b1">
<au:author au:name="Jane Doe"/>
<bk:title>XML Guide</bk:title>
</bk:book>
</root>Múltiplos Namespaces
Um único documento pode misturar muitos namespaces. Declare cada prefixo uma vez (geralmente na raiz) e reutilize-o. Declarar um namespace num elemento vale para esse elemento e seus descendentes.
<?xml version="1.0"?>
<soap:Envelope
xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:xsd="http://www.w3.org/2001/XMLSchema">
<soap:Body>
<m:GetPrice xsi:type="xsd:string"
xmlns:m="https://example.com/pricing">
<m:Item>Apples</m:Item>
</m:GetPrice>
</soap:Body>
</soap:Envelope>Escopo de Namespace
Declarações de namespace têm escopo no elemento em que aparecem e em seus descendentes. Uma redeclaração dentro de um filho sobrescreve o mapeamento de prefixo do pai naquela subárvore. O mapeamento original é restaurado depois que o filho fecha.
<?xml version="1.0"?>
<root xmlns:a="http://a.example">
<a:item>A</a:item>
<child xmlns:a="http://b.example">
<!-- here 'a' is REBOUND to the b.example URI -->
<a:item>B</a:item>
</child>
<!-- outside child, 'a' is back to a.example -->
<a:item>A again</a:item>
</root>Namespaces Comuns
Essas URIs são identificadores conhecidos, não URLs que precisam ser baixadas. O namespace xsi fornece atributos de schema-instance (type, nil, schemaLocation). XSD, XSL, SVG, SOAP, Atom e Dublin Core (dc) têm URIs padrão.
<!-- Frequently used namespace URIs -->
xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
xmlns:xsd = "http://www.w3.org/2001/XMLSchema"
xmlns:xsl = "http://www.w3.org/1999/XSL/Transform"
xmlns:svg = "http://www.w3.org/2000/svg"
xmlns:html = "http://www.w3.org/1999/xhtml"
xmlns:soap = "http://schemas.xmlsoap.org/soap/envelope/"
xmlns:atom = "http://www.w3.org/2005/Atom"
xmlns:dc = "http://purl.org/dc/elements/1.1/"Target Namespace em XSD
O targetNamespace de um schema é o namespace dos elementos que ele define. elementFormDefault='qualified' significa que elementos declarados localmente estão no namespace alvo. O prefixo tns é uma convenção para 'este namespace'.
<?xml version="1.0"?>
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema"
targetNamespace="https://example.com/orders"
xmlns:tns="https://example.com/orders"
elementFormDefault="qualified">
<xs:element name="order" type="tns:OrderType"/>
<xs:complexType name="OrderType">
<xs:sequence>
<xs:element name="item" type="xs:string"/>
</xs:sequence>
</xs:complexType>
</xs:schema>CDATA e Entidades
Entidades Predefinidas
XML predefine cinco entidades: < (<), > (>), & (&), ' ('), " ("). & deve SEMPRE ser escapado (mesmo em texto sem CDATA); < deve ser escapado, exceto como início de tag; aspas importam principalmente em atributos.
<?xml version="1.0"?>
<root>
<lt>less than: <</lt>
<gt>greater than: ></gt>
<amp>ampersand: &</amp>
<apos>apostrophe: '</apos>
<quot>quote: "</quot>
<!-- < > & ' " are the 5 built-in entities -->
</root>Referências de Caracteres
Referências de caracteres usam um ponto de código Unicode: © (decimal) ou © (hex) para ©. Funcionam no texto de elementos e em valores de atributos e não são afetadas pela codificação. Podem representar qualquer caractere Unicode.
<?xml version="1.0" encoding="UTF-8"?>
<root>
<decimal>© 2024 Company</decimal>
<hex>© 2024 Company</hex>
<euro>Price: €10</euro>
<emoji>Smile: 😀</emoji>
</root>
<!-- &#NNN; decimal code point -->
<!-- &#xHHH; hexadecimal code point -->Seções CDATA
Seções CDATA permitem incluir <, > e & sem escape—úteis para código e marcação. CDATA não pode conter ']]>' literalmente; para embuti-lo, divida a seção como mostrado. CDATA é dado de caracteres, não analisado como elementos.
<?xml version="1.0"?>
<root>
<script><![CDATA[
function check(a, b) {
if (a < b && b > 0) {
return a & b;
}
}
]]></script>
<!-- to include ]]> inside CDATA, split it -->
<data><![CDATA[foo]]]]><![CDATA[>bar]]></data>
</root>Entidades Personalizadas (DTD)
Entidades internas são declaradas numa DTD e expandidas onde forem referenciadas. Funcionam como macros de texto e podem referenciar outras entidades. Úteis para textos repetidos. Cuidado: entidades externas/gerais podem ser um risco de segurança XXE.
<?xml version="1.0"?>
<!DOCTYPE root [
<!ENTITY company "Acme Corp.">
<!ENTITY version "2.0">
<!ENTITY copyright "Copyright © 2024 &company;">
]>
<root>
<product>&company; Toolkit v&version;</product>
<footer>©right;</footer>
</root>
<!-- Entities are expanded during parsing -->Escape em Atributos
Dentro de valores de atributos você deve escapar & como & e escapar o caractere de aspas usado para delimitar o valor (" ou '). < também deve ser escapado. Quebras de linha e tabs em atributos são normalizadas para espaços pelo parser.
<?xml version="1.0"?>
<root>
<link url="https://example.com?a=1&b=2"/>
<msg text="Say "hello" & smile"/>
<path value='C:\Users\name'/>
<data value="<tagged>"/>
</root>Entidades de Parâmetro
Entidades de parâmetro (declaradas com %) são usadas apenas dentro de DTDs para construir modelos de conteúdo reutilizáveis. São referenciadas como %nome; (com ponto e vírgula). Entidades gerais (&nome;) são usadas no conteúdo do documento.
<?xml version="1.0"?>
<!DOCTYPE root [
<!ENTITY % inline " (#PCDATA | em | strong)* ">
<!ELEMENT p %inline;>
<!ELEMENT em %inline;>
<!ELEMENT strong %inline;>
<!ELEMENT root (p)*>
]>
<root>
<p>Hello <em>world</em> and <strong>XML</strong>.</p>
</root>DTD (Document Type Definition)
DTD Interna
Uma DTD interna é declarada inline no DOCTYPE, entre colchetes. Ela define a estrutura: quais elementos existem, seus modelos de conteúdo e atributos. DTDs internas são autocontidas, mas valem só para aquele documento.
<?xml version="1.0"?>
<!DOCTYPE note [
<!ELEMENT note (to, from, heading, body)>
<!ELEMENT to (#PCDATA)>
<!ELEMENT from (#PCDATA)>
<!ELEMENT heading (#PCDATA)>
<!ELEMENT body (#PCDATA)>
]>
<note>
<to>Alice</to>
<from>Bob</from>
<heading>Reminder</heading>
<body>Don't forget the meeting</body>
</note>DTD Externa
Uma DTD externa vive num arquivo .dtd separado, referenciado por SYSTEM (privado) ou PUBLIC (identificador público + URI). DTDs externas permitem que muitos documentos compartilhem uma definição. SYSTEM 'file.dtd' é a forma mais comum.
<!-- File: note.dtd -->
<!ELEMENT note (to, from, body)>
<!ELEMENT to (#PCDATA)>
<!ELEMENT from (#PCDATA)>
<!ELEMENT body (#PCDATA)>
<!-- File: note.xml -->
<?xml version="1.0"?>
<!DOCTYPE note SYSTEM "note.dtd">
<note>
<to>Alice</to>
<from>Bob</from>
<body>Hello</body>
</note>Declarações de Elementos
Modelos de conteúdo usam , (sequência), | (escolha), ? (0-1), * (0+), + (1+). #PCDATA é texto; conteúdo misto permite texto intercalado com elementos. EMPTY significa sem conteúdo; ANY desativa a verificação (evite em produção).
<!ELEMENT root (child1, child2*)>
<!-- content model operators -->
<!ELEMENT list (item+)> <!-- one or more item -->
<!ELEMENT opt (item?)> <!-- zero or one item -->
<!ELEMENT any (item1 | item2)*> <!-- choice, any number -->
<!ELEMENT text (#PCDATA)> <!-- parsed character data -->
<!ELEMENT mixed (#PCDATA | em)*> <!-- mixed content -->
<!ELEMENT empty EMPTY> <!-- no content -->
<!ELEMENT any ANY> <!-- any content -->Declarações de Atributos
ATTLIST declara o tipo e o padrão de um atributo. ID é um identificador único; IDREF/IDREFS referenciam IDs (para links cruzados). NMTOKEN é um token de nome. Tipos enumerados listam valores permitidos. Padrões: #REQUIRED, #IMPLIED, #FIXED ou um literal.
<!ATTLIST book
id ID #REQUIRED
category CDATA #IMPLIED
lang NMTOKEN "en"
status (draft|final) "draft"
version CDATA #FIXED "1.0">
<!-- Types: CDATA, ID, IDREF, IDREFS, NMTOKEN, NMTOKENS,
NOTATION, enumerated (a|b|c) -->
<!ATTLIST link ref IDREF #REQUIRED>Declarações de Entidades
Entidades gerais (&nome;) expandem no conteúdo; entidades de parâmetro (%nome;) expandem na DTD. Entidades externas analisadas incluem outros XML; entidades não analisadas (com NDATA) apontam para dados não XML referenciados via NOTATION. Entidades externas podem causar injeção XXE.
<!DOCTYPE root [
<!-- internal general entity -->
<!ENTITY name "Alice">
<!-- external parsed entity -->
<!ENTITY chap1 SYSTEM "chapter1.xml">
<!-- unparsed entity (binary, e.g. image) -->
<!ENTITY logo SYSTEM "logo.png" NDATA image>
<!-- notation declaration for unparsed entities -->
<!NOTATION image SYSTEM "image/png">
<!-- parameter entity (DTD-only) -->
<!ENTITY % block "(p | list)+">
]>
<root>&name;</root>Validação de DTD
A validação verifica se um documento corresponde à sua DTD (ordem de elementos, atributos permitidos, unicidade de IDs). Parsers DOM padrão como o minidom NÃO validam por padrão—use lxml (Python), xmllint (linha de comando) ou um parser validador.
<?xml version="1.0"?>
<!DOCTYPE root SYSTEM "schema.dtd">
<root>
<item id="x1">valid</item>
</root>
<!-- Validate with Python: -->
<!-- import xml.dom.minidom as m
dom = m.parse("file.xml")
# minidom does NOT validate; use lxml: -->
<!-- from lxml import etree
dtd = etree.DTD("schema.dtd")
tree = etree.parse("file.xml")
print(dtd.validate(tree)) -->XML Schema (XSD)
Estrutura do Schema
Um XSD é ele próprio um documento XML. A raiz <schema> declara o namespace XSD e um namespace alvo para os elementos que define. elementFormDefault='qualified' coloca os elementos locais no namespace alvo.
<?xml version="1.0"?>
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema"
targetNamespace="https://example.com/order"
xmlns:tns="https://example.com/order"
elementFormDefault="qualified">
<xs:element name="order" type="tns:OrderType"/>
<xs:complexType name="OrderType">
<xs:sequence>
<xs:element name="customer" type="xs:string"/>
<xs:element name="total" type="xs:decimal"/>
</xs:sequence>
<xs:attribute name="id" type="xs:ID" use="required"/>
</xs:complexType>
</xs:schema>Tipos Simples
Um simpleType restringe um tipo base com facets (pattern, minInclusive, enumeration, length, etc.). Tipos simples têm apenas conteúdo de texto e atributos—sem elementos filhos. São reutilizáveis em o schema inteiro.
<xs:simpleType name="emailType">
<xs:restriction base="xs:string">
<xs:pattern value="[^@]+@[^@]+.[^@]+"/>
</xs:restriction>
</xs:simpleType>
<xs:simpleType name="ageType">
<xs:restriction base="xs:integer">
<xs:minInclusive value="0"/>
<xs:maxInclusive value="120"/>
</xs:restriction>
</xs:simpleType>
<xs:element name="email" type="tns:emailType"/>
<xs:element name="age" type="tns:ageType"/>Tipos Complexos
Um complexType pode conter elementos filhos e atributos. sequence impõe ordem; choice permite um de vários; all permite qualquer ordem (cada um no máximo uma vez). Compositores podem se aninhar para expressar estruturas ricas.
<xs:complexType name="AddressType">
<xs:sequence>
<xs:element name="street" type="xs:string"/>
<xs:element name="city" type="xs:string"/>
<xs:element name="zip" type="xs:string"/>
</xs:sequence>
<xs:attribute name="country" type="xs:string" default="US"/>
</xs:complexType>
<!-- Content model indicators: sequence, choice, all -->
<xs:complexType name="ContactType">
<xs:choice>
<xs:element name="phone" type="xs:string"/>
<xs:element name="email" type="xs:string"/>
</xs:choice>
</xs:complexType>Tipos Embutidos
XSD fornece uma rica hierarquia de tipos: strings, números (integer, decimal, float), datas/horas, boolean, anyURI, ID/IDREF e QName. Cada um suporta facets como length, pattern e enumeration para restrições adicionais.
<!-- Common XSD built-in types -->
<xs:element name="count" type="xs:integer"/>
<xs:element name="price" type="xs:decimal"/>
<xs:element name="flag" type="xs:boolean"/>
<xs:element name="name" type="xs:string"/>
<xs:element name="date" type="xs:date"/> <!-- 2024-01-15 -->
<xs:element name="time" type="xs:time"/> <!-- 13:45:00 -->
<xs:element name="dt" type="xs:dateTime"/> <!-- 2024-01-15T13:45:00 -->
<xs:element name="id" type="xs:ID"/>
<xs:element name="ref" type="xs:IDREF"/>
<xs:element name="uri" type="xs:anyURI"/>Restrições (Facets)
Facets restringem tipos simples: enumeration (valores permitidos), pattern (regex), length/minLength/maxLength, min/maxInclusive/Exclusive, totalDigits, fractionDigits e whiteSpace (preserve/replace/collapse).
<xs:simpleType name="ColorType">
<xs:restriction base="xs:string">
<xs:enumeration value="red"/>
<xs:enumeration value="green"/>
<xs:enumeration value="blue"/>
</xs:restriction>
</xs:simpleType>
<xs:simpleType name="PasswordType">
<xs:restriction base="xs:string">
<xs:minLength value="8"/>
<xs:maxLength value="32"/>
<xs:pattern value="[A-Za-z0-9!@#]+"/>
</xs:restriction>
</xs:simpleType>Elementos e Atributos em XSD
minOccurs/maxOccurs controlam a cardinalidade (padrão 1); maxOccurs='unbounded' permite qualquer quantidade. O 'use' do atributo é required/optional/prohibited, com valor default ou fixed opcional. Tipos complexos anônimos embutem a definição.
<xs:element name="product">
<xs:complexType>
<xs:sequence>
<xs:element name="name" type="xs:string"
minOccurs="1" maxOccurs="1"/>
<xs:element name="tag" type="xs:string"
minOccurs="0" maxOccurs="unbounded"/>
</xs:sequence>
<xs:attribute name="sku" type="xs:string" use="required"/>
<xs:attribute name="weight" type="xs:decimal" use="optional"
default="0.0"/>
</xs:complexType>
</xs:element>XPath
Expressões de Caminho
XPath usa expressões semelhantes a caminhos. '/' seleciona a partir da raiz; '//' seleciona descendentes em qualquer profundidade. '*' é um curinga para qualquer elemento; '@' seleciona atributos. Uma expressão que começa com '/' é absoluta.
<!-- Sample: <bookstore><book><title>..</title></book></bookstore> -->
/bookstore/book/title <!-- absolute path -->
bookstore/book/title <!-- relative path -->
//title <!-- any title, anywhere -->
/bookstore//title <!-- title anywhere under bookstore -->
bookstore/* <!-- all children of bookstore -->
//@lang <!-- all lang attributes -->
//@* <!-- all attributes -->Predicados
Predicados entre [ ] filtram um conjunto de nós. A indexação começa em 1. last() e position() referem-se à posição do nó em seu contexto. Predicados podem testar texto de elementos, atributos (@nome) ou valores calculados.
//book[1] <!-- first book -->
//book[last()] <!-- last book -->
//book[position() <= 3] <!-- first three books -->
//book[price > 25] <!-- books with price > 25 -->
//book[@category='web'] <!-- books in the web category -->
//book[author='Smith'] <!-- books authored by Smith -->
//book[@lang][2] <!-- 2nd book that has a lang attr -->Eixos
Eixos definem direções de navegação: child (padrão), descendant, parent (..), ancestor, following-sibling, preceding-sibling, attribute (@), self (.), descendant-or-self (//). A maioria tem formas abreviadas usadas na prática.
child::book <!-- default axis: children named book -->
descendant::title <!-- all title descendants -->
parent::* <!-- the parent element (shorthand: ..) -->
ancestor::section <!-- all section ancestors -->
following-sibling::p <!-- p elements after this one -->
preceding::item <!-- items before this in document order -->
attribute::id <!-- the id attribute (shorthand: @id) -->
self::node() <!-- the current node (shorthand: .) -->Funções
XPath 1.0 tem funções embutidas: count, sum, string-length, contains, starts-with, normalize-space, name, concat, substring, round e mais. XPath 2.0+ expande muito a biblioteca de funções e adiciona tipagem.
count(//book) <!-- number of book elements -->
string-length(//title) <!-- length of first title's text -->
contains(//name, 'Ali') <!-- true if name contains 'Ali' -->
starts-with(@id, 'b') <!-- true if id starts with 'b' -->
normalize-space(//summary) <!-- collapse whitespace -->
name(//*[1]) <!-- name of the first element -->
concat(/a, /b) <!-- concatenate strings -->
sum(//price) <!-- sum of all price values -->Operadores
XPath usa = para igualdade (= único, não ==) e os operadores 'and'/'or' para lógica (não && / ||). 'div' é divisão e 'mod' é módulo, já que '/' é reservado para caminhos. '|' calcula a união de conjuntos de nós.
<!-- Comparison: =, !=, <, >, <=, >= -->
//book[price = 29.99]
//book[price < 20]
<!-- Logical: and, or -->
//book[price > 10 and price < 30]
//book[@cat='a' or @cat='b']
<!-- Arithmetic: + - * div mod -->
//item[price * quantity > 100]
5 div 2 <!-- 2.5 -->
5 mod 2 <!-- 1 -->
<!-- Union: | -->
//book | //magazineExemplos de XPath
Esses padrões combinam caminhos, predicados e funções para consultas reais. text() seleciona o nó de texto; min() exige XPath 2.0+. O curinga //* com predicado é uma forma comum de achar elementos por atributo em toda a árvore.
<!-- Select all book titles priced over 20 -->
//book[price > 20]/title/text()
<!-- The category of the cheapest book -->
//book[price = min(//book/price)]/@category
<!-- Authors of books in the 'programming' category -->
//book[@category='programming']/author
<!-- Every 2nd item in each list -->
//list/item[position() mod 2 = 0]
<!-- Elements with a specific attribute value -->
//*[@lang='fr']Transformações XSLT
Transformação Básica
Uma folha de estilo XSLT é XML. Templates casam nós com XPath; apply-templates processa recursivamente os nós selecionados. value-of extrai texto. O template match='/' roda primeiro, na raiz do documento.
<?xml version="1.0"?>
<xsl:stylesheet version="1.0"
xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
<xsl:template match="/">
<html>
<body>
<h2>Book List</h2>
<xsl:apply-templates select="bookstore/book"/>
</body>
</html>
</xsl:template>
<xsl:template match="book">
<p><xsl:value-of select="title"/> - <xsl:value-of select="price"/></p>
</xsl:template>
</xsl:stylesheet>xsl:template e apply-templates
Templates com match disparam quando o processador visita nós que casam; templates nomeados são chamados explicitamente com call-template. apply-templates sem select processa cada um dos filhos, permitindo transformações recursivas dirigidas por regras.
<xsl:template match="book">
<div class="book">
<xsl:apply-templates select="title"/>
<xsl:apply-templates select="author"/>
</div>
</xsl:template>
<xsl:template match="title">
<h3><xsl:apply-templates/></h3>
</xsl:template>
<!-- named template (like a function) -->
<xsl:template name="divider">
<hr/>
</xsl:template>xsl:value-of e xsl:for-each
xsl:for-each itera um conjunto de nós, mudando o nó de contexto. Costuma ser mais simples que templates para saída plana, mas o excesso torna a folha de estilo procedural. Prefira templates e apply-templates para estruturas recursivas.
<xsl:template match="/">
<ul>
<xsl:for-each select="bookstore/book">
<li>
<xsl:value-of select="title"/>
(<xsl:value-of select="@category"/>)
</li>
</xsl:for-each>
</ul>
</xsl:template>
<!-- value-of outputs the string value of an expression -->xsl:if e xsl:choose
xsl:if não tem else—use xsl:choose para ramificações múltiplas. A expressão 'test' segue as regras booleanas do XPath: um conjunto de nós não vazio é verdadeiro, vazio é falso, números diferentes de zero são verdadeiros.
<xsl:for-each select="bookstore/book">
<xsl:if test="price > 25">
<premium><xsl:value-of select="title"/></premium>
</xsl:if>
<xsl:choose>
<xsl:when test="@category='fiction'">F</xsl:when>
<xsl:when test="@category='programming'">P</xsl:when>
<xsl:otherwise>?</xsl:otherwise>
</xsl:choose>
</xsl:for-each>
<!-- test uses XPath; non-empty node-sets and non-zero numbers are true -->xsl:sort e xsl:variable
xsl:sort reordena o conjunto de nós atual por uma ou mais chaves; data-type é 'text' ou 'number'. Variáveis (xsl:variable) são imutáveis e têm escopo. Lembre de escapar < como < dentro de valores de atributos no XML da folha de estilo.
<xsl:variable name="max-price" select="50"/>
<xsl:for-each select="bookstore/book[price < $max-price]">
<xsl:sort select="price" data-type="number" order="descending"/>
<xsl:sort select="title" order="ascending"/>
<p>
<xsl:value-of select="title"/>: <xsl:value-of select="price"/>
</p>
</xsl:for-each>
<!-- Note: in XSLT, < must be written < inside test attributes -->xsl:apply-templates e modes
Modes permitem que um mesmo conjunto de nós de origem seja processado de formas diferentes (ex.: um sumário vs entradas completas). O atributo mode deve casar tanto no template quanto no apply-templates. Sem mode, apenas templates sem modo se aplicam.
<!-- A template can have a 'mode' for different outputs -->
<xsl:template match="book" mode="list">
<li><xsl:value-of select="title"/></li>
</xsl:template>
<xsl:template match="book" mode="detail">
<div><h3><xsl:value-of select="title"/></h3>
<p><xsl:value-of select="author"/></p></div>
</xsl:template>
<!-- Invoke a specific mode -->
<xsl:apply-templates select="bookstore/book" mode="list"/>
<xsl:apply-templates select="bookstore/book" mode="detail"/>XQuery
Expressões FLWOR
FLWOR é a construção central do XQuery: for vincula variáveis a itens de sequência, let vincula valores calculados, where filtra, order by ordena e return molda a saída. Lembra o SELECT-FROM-WHERE do SQL.
for $b in /bookstore/book
let $discount := $b/price * 0.9
where $b/price > 20
order by $b/price descending
return
<book>
<title>{ $b/title/text() }</title>
<salePrice>{ $discount }</salePrice>
</book>
<!-- FLWOR = For, Let, Where, Order by, Return -->Expressões de Caminho
XQuery embute XPath diretamente. doc('file.xml') carrega um documento; collection('uri') consulta múltiplos documentos. Expressões de caminho retornam sequências de nós, que expressões FLWOR podem iterar.
(: XQuery uses XPath for navigation :)
/bookstore/book/title/text()
/bookstore/book[@category='web']
//author[contains(., 'Smith')]
(: Use doc() to open an external document :)
doc('catalog.xml')//book[price < 30]
(: collection() queries a set of documents :)
collection('/db/books')//titlePredicados e Joins
Múltiplas cláusulas 'for' formam um join (como o JOIN do SQL). XQuery faz joins iterando combinações e filtrando com where. Para bases grandes, joins explícitos via predicados ou chaves são mais eficientes que loops aninhados.
(: Join books to authors by id :)
for $b in doc('books.xml')//book
for $a in doc('authors.xml')//author
where $b/@author-id = $a/@id
return
<entry>
<title>{ $b/title/text() }</title>
<author>{ $a/name/text() }</author>
</entry>
(: Equivalent join with a predicate :)
for $b in doc('books.xml')//book
return
<entry>{ $b/title, $b/@author-id }</entry>Condicional e Quantificado
XQuery tem if-then-else (o else é obrigatório), expressões quantificadas (some/every ... satisfies) e typeswitch para ramificar por tipo de nó. As condições usam semântica booleana estilo XPath.
(: if-then-else :)
for $b in //book
return
if ($b/price > 30) then <expensive>{ $b/title }</expensive>
else <cheap>{ $b/title }</cheap>
(: quantified expressions :)
some $a in //author satisfies contains($a, 'Smith')
every $p in //price satisfies $p > 0
(: typeswitch for type-based dispatch :)
typeswitch($node)
case element(book) return "book"
case element(author) return "author"
default return "other"Funções
XQuery reutiliza funções XPath e adiciona muitas (string-join, distinct-values, avg, min, max). Funções do usuário são declaradas no módulo com tipos de parâmetro e de retorno, no namespace local: por convenção.
(: Built-in functions :)
concat('a', 'b', 'c')
string-join(//title, ', ')
count(//book)
distinct-values(//book/@category)
avg(//book/price)
max(//book/price)
(: User-defined function :)
declare function local:discount($price as xs:decimal)
as xs:decimal {
$price * 0.9
};
local:discount(29.99)Construindo XML
XQuery constrói XML com construtores diretos (tags literais com { } para expressões embutidas) ou construtores computados (element name { ... }). Chaves avaliam as expressões envolvidas; atributos podem embutir valores inline.
(: Direct element construction :)
<result>
<count>{ count(//book) }</count>
<books>
{ for $b in //book return <book title="{ $b/title/text() }"/> }
</books>
</result>
(: Computed constructors :)
element result {
attribute total { count(//book) },
for $b in //book
return element book { $b/title/text() }
}
(: Enclosed expressions use { } to embed values -->Análise com DOM
Carregando XML (JavaScript)
DOMParser transforma uma string XML numa árvore DOM no navegador; erros de análise aparecem como um elemento <parsererror> em vez de exceção. Node.js não tem XML DOM embutido—use xmldom, @xmldom/xmldom ou um parser de streaming.
// Browser: parse an XML string
const parser = new DOMParser();
const doc = parser.parseFromString(xmlString, "application/xml");
const errorNode = doc.querySelector("parsererror");
if (errorNode) {
console.error("Parse error:", errorNode.textContent);
}
const books = doc.getElementsByTagName("book");
for (const book of books) {
console.log(book.getAttribute("id"));
}
// Node.js: use xmldom or fast-xml-parser insteadTravessia do DOM
A API DOM expõe documentElement, children, childNodes e nextSibling para travessia. nodeType 1 é elemento, 3 é texto, 8 é comentário. document.evaluate roda XPath nos navegadores (Node precisa de bibliotecas xpath).
// JavaScript DOM API (also works for XML documents)
const root = doc.documentElement; // <bookstore>
const firstBook = root.children[0]; // first <book>
const titles = doc.getElementsByTagName("title");
// walk children
let node = root.firstChild;
while (node) {
if (node.nodeType === 1) { // Element node
console.log(node.tagName);
}
node = node.nextSibling;
}
// XPath against the DOM
const it = doc.evaluate("//book[@id='b1']", doc, null,
XPathResult.ANY_TYPE, null);
const found = it.iterateNext();Modificando o DOM
createElement/setAttribute/appendChild constroem e anexam nós; textContent define texto. XMLSerializer converte o DOM de volta em string. O DOM é vivo—mutações refletem imediatamente em qualquer referência.
const book = doc.createElement("book");
book.setAttribute("id", "b3");
const title = doc.createElement("title");
title.textContent = "New Book";
book.appendChild(title);
root.appendChild(book); // add to tree
// change an existing element
const price = doc.querySelector("book:nth-child(2) price");
price.textContent = "19.99";
price.setAttribute("currency", "EUR");
// serialize back to a string
const xml = new XMLSerializer().serializeToString(doc);Criando Elementos
minidom permite construir um documento do zero: createDocument para a raiz, createElement/setAttribute/createTextNode para o conteúdo, appendChild para ligar. toprettyxml serializa com indentação. minidom é simples, mas lento para árvores grandes.
// Python: xml.dom.minidom
from xml.dom import minidom
impl = minidom.getDOMImplementation()
doc = impl.createDocument(None, "root", None)
root = doc.documentElement
item = doc.createElement("item")
item.setAttribute("id", "1")
item.appendChild(doc.createTextNode("Hello"))
root.appendChild(item)
print(doc.toprettyxml(encoding="UTF-8").decode())Análise DOM em Java
O DOM do JAXP em Java carrega o documento inteiro na memória via DocumentBuilder. setNamespaceAware(true) mantém os prefixos de namespace. O DOM é conveniente para acesso aleatório, mas pesado em memória para arquivos grandes—prefira StAX/SAX nesses casos.
import javax.xml.parsers.DocumentBuilderFactory;
import org.w3c.dom.*;
DocumentBuilderFactory f = DocumentBuilderFactory.newInstance();
f.setNamespaceAware(true);
Document doc = f.newDocumentBuilder().parse(new File("data.xml"));
Element root = doc.getDocumentElement();
NodeList books = root.getElementsByTagName("book");
for (int i = 0; i < books.getLength(); i++) {
Element b = (Element) books.item(i);
String id = b.getAttribute("id");
String title = b.getElementsByTagName("title")
.item(0).getTextContent();
System.out.println(id + ": " + title);
}lxml (Python)
lxml é um binding Python rápido e rico para libxml2. Suporta XPath completo, XSLT, validação (DTD/XSD/RelaxNG) e análise incremental. Seu ElementPath (find/findall) é um subconjunto do XPath; use xpath() para XPath completo.
from lxml import etree
# parse and validate against a schema
tree = etree.parse("data.xml")
root = tree.getroot()
# XPath with namespaces
ns = {"bk": "https://example.com/books"}
for book in root.xpath("//bk:book", namespaces=ns):
print(book.get("id"), book.find("bk:title", namespaces=ns).text)
# build an element tree
root = etree.Element("root")
child = etree.SubElement(root, "item", id="1")
child.text = "Hello"
print(etree.tostring(root, pretty_print=True, encoding="unicode"))Análise com SAX
Handler SAX (Python)
SAX é orientado a eventos e em streaming: o parser chama startElement, characters e endElement conforme lê, nunca construindo uma árvore completa. É eficiente em memória para arquivos enormes. Você mesmo deve acompanhar o estado (ex.: elemento atual).
import xml.sax
class BookHandler(xml.sax.ContentHandler):
def startElement(self, name, attrs):
if name == "book":
print("Book id:", attrs.getValue("id"))
self.current = name
def characters(self, content):
if self.current == "title":
print("Title:", content.strip())
def endElement(self, name):
self.current = None
xml.sax.parse("books.xml", BookHandler())Handlers de Evento SAX
Os callbacks do ContentHandler marcam os limites de documento e elemento. characters() pode dividir um único nó de texto em várias chamadas—acumule num buffer. startPrefixMapping/endPrefixMapping reportam declarações de namespace.
class Handler(xml.sax.ContentHandler):
def startDocument(self):
print("parsing started")
def endDocument(self):
print("parsing done")
def startElement(self, name, attrs):
# attrs: get via attrs.getValue('id') or attrs['id']
pass
def endElement(self, name):
pass
def characters(self, text):
# may be called multiple times for one text node
pass
def startPrefixMapping(self, prefix, uri):
print("namespace:", prefix, uri)startElement / endElement
Acompanhar o caminho de elementos (uma pilha) é a forma padrão de saber sua posição durante o streaming. Bufferize a saída de characters() e descarregue no endElement, porque characters pode disparar mais de uma vez por nó de texto.
class Handler(xml.sax.ContentHandler):
def __init__(self):
self.path = []
self.text = []
def startElement(self, name, attrs):
self.path.append(name)
self.text = []
if "id" in attrs:
print("/".join(self.path), "id =", attrs["id"])
def endElement(self, name):
if self.path[-1] == "title":
print("title:", "".join(self.text).strip())
self.path.pop()
def characters(self, content):
self.text.append(content)Parser SAX em Java
SAX em Java estende DefaultHandler. startElement recebe URI de namespace, nome local, nome qualificado e um objeto Attributes. characters(ch, start, len) fornece uma fatia de chars—bufferize, pois um nó de texto pode se estender por várias chamadas.
import org.xml.sax.helpers.DefaultHandler;
import org.xml.sax.*;
import javax.xml.parsers.*;
class BookHandler extends DefaultHandler {
private StringBuilder buf = new StringBuilder();
public void startElement(String uri, String local,
String qName, Attributes attrs) {
buf.setLength(0);
if ("book".equals(qName))
System.out.println("id=" + attrs.getValue("id"));
}
public void characters(char[] ch, int start, int len) {
buf.append(ch, start, len);
}
public void endElement(String uri, String local, String qName) {
if ("title".equals(qName))
System.out.println("title=" + buf);
}
}
// SAXParserFactory.newInstance().newSAXParser().parse(file, new BookHandler());SAX vs DOM
SAX transmite eventos com memória constante, ideal para arquivos enormes e extração em uma passada. DOM carrega a árvore inteira, permitindo XPath e mutação aleatória, mas usando memória proporcional ao tamanho do arquivo. Escolha pelo padrão de acesso e pelo tamanho do arquivo.
<!-- SAX: event-driven, streaming, low memory
DOM: full tree in memory, random access
SAX is best for:
- large files that won't fit in memory
- read-only filtering / extraction
- simple state machines over the document
DOM is best for:
- random access to many parts of the tree
- repeated queries / XPath
- editing and re-serializing -->
<!-- Memory: SAX ~ O(1); DOM ~ O(file size) -->
<!-- Speed: SAX often faster for one-pass scans -->Tratamento de Erros (SAX)
Um ErrorHandler recebe avisos, erros recuperáveis e erros fatais. Por padrão, erros fatais lançam exceção e param a análise. Implementar error() permite registrar problemas de validação não fatais sem abortar toda a análise.
import xml.sax
class Handler(xml.sax.ContentHandler):
pass
# ErrorHandler: warning, error, fatalError
class ErrHandler(xml.sax.ErrorHandler):
def error(self, exception):
print("ERROR:", exception)
def fatalError(self, exception):
print("FATAL:", exception)
raise exception
def warning(self, exception):
print("WARN:", exception)
parser = xml.sax.make_parser()
parser.setContentHandler(Handler())
parser.setErrorHandler(ErrHandler())
parser.parse("data.xml")StAX (Análise Pull)
API Cursor do StAX
StAX é um parser pull: seu código puxa o próximo evento com next(), então você controla o loop. A API de cursor (XMLStreamReader) avança pelos eventos um a um. É mais rápido e usa menos memória que DOM, e mais flexível que o modelo push do SAX.
import javax.xml.stream.*;
import java.io.*;
XMLInputFactory factory = XMLInputFactory.newInstance();
// defend against XXE
factory.setProperty(XMLInputFactory.IS_SUPPORTING_EXTERNAL_ENTITIES, false);
factory.setProperty(XMLInputFactory.SUPPORT_DTD, false);
XMLStreamReader r = factory.createXMLStreamReader(new FileInputStream("data.xml"));
while (r.hasNext()) {
int event = r.next();
if (event == XMLStreamConstants.START_ELEMENT) {
System.out.println("start: " + r.getLocalName());
} else if (event == XMLStreamConstants.END_ELEMENT) {
System.out.println("end: " + r.getLocalName());
}
}
r.close();Eventos do XMLStreamReader
Os tipos de evento incluem START_ELEMENT, END_ELEMENT, CHARACTERS, COMMENT, PROCESSING_INSTRUCTION e START/END_DOCUMENT. getText() retorna o texto atual; isWhiteSpace() filtra indentação. O cursor avança um evento por chamada de next().
XMLStreamReader r = factory.createXMLStreamReader(in);
while (r.hasNext()) {
switch (r.next()) {
case XMLStreamConstants.START_ELEMENT:
// r.getLocalName(), r.getAttributeValue(i), r.getNamespaceURI()
break;
case XMLStreamConstants.END_ELEMENT:
break;
case XMLStreamConstants.CHARACTERS:
if (!r.isWhiteSpace()) {
String text = r.getText();
}
break;
case XMLStreamConstants.START_DOCUMENT:
break;
case XMLStreamConstants.END_DOCUMENT:
break;
case XMLStreamConstants.PROCESSING_INSTRUCTION:
break;
}
}Lendo Elementos e Atributos
getAttributeValue(namespaceURI, localName) lê atributos pelo nome (passe null para sem namespace). getElementText() é uma conveniência que lê o texto de um elemento só de texto e avança além do seu END_ELEMENT—mais limpo que bufferizar characters você mesmo.
while (r.hasNext()) {
int event = r.next();
if (event == XMLStreamConstants.START_ELEMENT
&& "book".equals(r.getLocalName())) {
String id = r.getAttributeValue(null, "id");
String category = r.getAttributeValue(null, "category");
System.out.println("Book " + id + " (" + category + ")");
}
if (event == XMLStreamConstants.START_ELEMENT
&& "title".equals(r.getLocalName())) {
String title = r.getElementText(); // consumes until END_ELEMENT
System.out.println("Title: " + title);
}
}Writer do StAX
XMLStreamWriter constrói XML sequencialmente. writeStartDocument, writeStartElement/writeEndElement, writeAttribute, writeCharacters e writeNamespace devem ficar balanceados. Faça flush/close no fim para garantir a saída completa.
XMLOutputFactory out = XMLOutputFactory.newInstance();
XMLStreamWriter w = out.createXMLStreamWriter(System.out, "UTF-8");
w.writeStartDocument("UTF-8", "1.0");
w.writeStartElement("books");
w.writeNamespace("bk", "https://example.com/books");
w.writeStartElement("bk", "book", "https://example.com/books");
w.writeAttribute("id", "b1");
w.writeStartElement("bk", "title", "https://example.com/books");
w.writeCharacters("XML Guide");
w.writeEndElement(); // title
w.writeEndElement(); // book
w.writeEndElement(); // books
w.writeEndDocument();
w.close();StAX vs SAX
SAX empurra eventos ao seu handler; StAX deixa você puxar eventos sob demanda. O modelo pull do StAX facilita pular subárvores e gerenciar estado, e adiciona uma API de escrita. Ambos evitam construir uma árvore DOM completa, então servem para documentos grandes.
<!-- StAX: PULL model (client calls next())
SAX: PUSH model (parser calls your handlers)
StAX advantages:
- client controls parsing (easy to skip sections)
- simpler state management for many tasks
- supports both reading and writing
- can pause/resume naturally
SAX advantages:
- slightly lower overhead in pure streaming
- mature, widely available
- filters/chains via XMLFilter
Both are streaming and memory-efficient. -->Event Reader (API Iterator)
A API de iterator (XMLEventReader) retorna objetos XMLEvent que você pode espiar e consumir. É mais orientada a objetos que a API de cursor e mais fácil para filtrar ou dividir, mas um pouco mais pesada pela alocação de objetos de evento.
import javax.xml.stream.*;
import javax.xml.stream.events.*;
XMLEventReader reader = XMLInputFactory.newInstance()
.createXMLEventReader(in);
while (reader.hasNext()) {
XMLEvent e = reader.peek(); // look without consuming
if (e.isStartElement()) {
StartElement se = e.asStartElement();
System.out.println(se.getName());
}
XMLEvent consumed = reader.nextEvent(); // consume it
if (consumed.isEndElement()) {
System.out.println("closed");
}
}
reader.close();Conversão XML e JSON
XML para JSON (JavaScript)
fast-xml-parser converte XML para JSON em Node.js. Atributos recebem prefixo (padrão @_) e elementos repetidos viram arrays. A biblioteca é JavaScript puro e rápida, com opções para controlar arrays, números e booleanos.
// Node.js with fast-xml-parser
const { XMLParser } = require("fast-xml-parser");
const xml = "<book id='b1'><title>XML</title><price>29.99</price></book>";
const parser = new XMLParser({
ignoreAttributes: false,
attributeNamePrefix: "@_",
});
const json = parser.parse(xml);
console.log(json.book["@_id"]); // b1
console.log(json.book.title); // XML
console.log(json.book.price); // 29.99JSON para XML (JavaScript)
XMLBuilder reverte a conversão. O prefixo @_ marca atributos e objetos aninhados viram elementos filhos. Arrays produzem elementos repetidos. A regra de raiz única do XML significa que o objeto JSON de nível superior deve mapear para um elemento raiz.
const { XMLBuilder } = require("fast-xml-parser");
const json = {
book: {
"@_id": "b1",
title: "XML Guide",
price: 29.99,
},
};
const builder = new XMLBuilder({
format: true,
attributeNamePrefix: "@_",
ignoreAttributes: false,
});
const xml = builder.build(json);
console.log(xml);
// <book id="b1">
// <title>XML Guide</title>
// <price>29.99</price>
// </book>xmltodict em Python
xmltodict trata XML como estruturas dict/list: atributos usam '@nome', texto usa '#text'. parse() lê XML, unparse() escreve. Ótimo para idas e voltas rápidas, mas perde ordem e alguns casos extremos de schemas complexos.
import xmltodict, json
xml = """<book id="b1"><title>XML</title><price>29.99</price></book>"""
# XML -> dict
data = xmltodict.parse(xml)
print(data["book"]["@id"]) # b1
print(data["book"]["title"]) # XML
# dict -> JSON
print(json.dumps(data, indent=2))
# dict -> XML
xml_out = xmltodict.unparse({"book": {"@id": "b2", "title": "New"}})
print(xml_out)Tratamento de Atributos e Texto
Converter XML para JSON força decisões sobre atributos (prefixo @_), texto (#text) e conteúdo misto. Conteúdo misto—texto intercalado com elementos filhos—não mapeia limpo para JSON e com frequência perde fidelidade. Escolha convenções e mantenha-as consistentes.
<!-- XML with mixed attributes and text -->
<product sku="A1" stock="5">Widget<note>sale</note></product>
// fast-xml-parser output:
// {
// product: {
// "@_sku": "A1",
// "@_stock": "5",
// "#text": "Widget",
// note: "sale"
// }
// }
// Round-trip carefully: mixed content (text + elements)
// is hard to represent losslessly in JSON -->Desafios da Conversão
Armadilhas comuns de conversão: filho único vs múltiplos (array vs string), ordem de elementos, prefixos de namespace (que são apelidos), a restrição de raiz única e a tipagem primitiva (XML não tem números nem booleanos nativos). Documente suas convenções.
<!-- 1. Repeated elements -> array -->
<list><item>a</item><item>b</item></list>
// { list: { item: ["a", "b"] } } (or single string if only one)
<!-- 2. Order is significant in XML but not in JSON objects -->
<a><x/><y/></a> vs <a><y/><x/></a> // may differ
<!-- 3. Namespaces -->
<ns:elem xmlns:ns="http://x"/> // prefixes are aliases
<!-- 4. Single root: JSON top-level must be one object -->
<!-- 5. Numbers/booleans: XML is all text; typing is heuristic -->Exemplo de Ida e Volta
Ida e volta (XML -> JSON -> XML) funciona para dados bem estruturados, mas pode descartar comentários, instruções de processamento, limites de CDATA e espaços exatos. Para edição sem perdas, use uma API de DOM/árvore em vez de conversão via JSON.
// Parse, modify, and re-serialize with fast-xml-parser
const { XMLParser, XMLBuilder } = require("fast-xml-parser");
const opts = { ignoreAttributes: false, attributeNamePrefix: "@_" };
const parser = new XMLParser(opts);
const builder = new XMLBuilder({ ...opts, format: true });
const obj = parser.parse(xmlString);
// mutate
obj.book.price = 19.99;
obj.book["@_onSale"] = "true";
const newXml = builder.build(obj);
console.log(newXml);Feeds RSS e Atom
Estrutura do RSS 2.0
RSS 2.0 tem uma raiz <rss> com um <channel>. Campos obrigatórios do canal: title, link, description. Cada <item> tem title, link, description, guid, pubDate. As datas seguem RFC 822 (ex.: 'Wed, 02 Oct 2024 13:00:00 GMT').
<?xml version="1.0" encoding="UTF-8"?>
<rss version="2.0">
<channel>
<title>My Blog</title>
<link>https://example.com</link>
<description>Recent posts</description>
<language>en-us</language>
<pubDate>Wed, 02 Oct 2024 13:00:00 GMT</pubDate>
<item>
<title>First Post</title>
<link>https://example.com/1</link>
<description>A short summary</description>
<pubDate>Wed, 02 Oct 2024 12:00:00 GMT</pubDate>
<guid>https://example.com/1</guid>
</item>
</channel>
</rss>Canal e Item do RSS
Campos no nível do canal descrevem o feed (title, link, description, language, ttl, image). Campos do item descrevem cada entrada; enclosure suporta podcasts/mídia com URL, tamanho em bytes e tipo MIME. category pode carregar um atributo domain.
<channel>
<title>Site Title</title>
<link>https://example.com</link>
<description>What the feed is about</description>
<category>Technology</category>
<ttl>60</ttl> <!-- cache minutes -->
<image>
<url>https://example.com/logo.png</url>
<title>Site Title</title>
<link>https://example.com</link>
</image>
<item>
<title>Post Title</title>
<link>https://example.com/post</link>
<description>Summary text</description>
<author>[email protected]</author>
<category domain="https://example.com/tags">xml</category>
<enclosure url="https://example.com/p.mp3" length="12345"
type="audio/mpeg"/>
</item>
</channel>Feed Atom
Atom (RFC 4287) usa uma raiz <feed> no namespace Atom. Obrigatórios: id, title, updated. Entradas precisam de id, title, updated. IDs devem ser globalmente únicos (URNs ou URIs tag:). As datas usam RFC 3339 (ISO 8601) com fuso horário.
<?xml version="1.0" encoding="utf-8"?>
<feed xmlns="http://www.w3.org/2005/Atom">
<title>Example Feed</title>
<link href="https://example.com/feed.atom" rel="self"/>
<link href="https://example.com"/>
<id>urn:uuid:60a76c80-d399-11d9-b93C-0003939e0af6</id>
<updated>2024-10-02T13:00:00Z</updated>
<author><name>Jane Doe</name></author>
<entry>
<title>Atom Entry</title>
<id>tag:example.com,2024:/post/1</id>
<updated>2024-10-02T12:00:00Z</updated>
<summary>A short summary</summary>
<content type="html"><p>Full post body</p></content>
</entry>
</feed>Detalhes das Entradas Atom
Entradas Atom suportam conteúdo rico: texto, html ou xhtml via o atributo type. link usa atributos rel (alternate, self, enclosure, related). category tem term/scheme/label. published é a data original; updated é a última alteração.
<entry>
<title type="text">Post Title</title>
<id>tag:example.com,2024:/posts/42</id>
<updated>2024-10-02T12:00:00Z</updated>
<published>2024-10-01T09:00:00Z</published>
<author>
<name>Jane Doe</name>
<email>[email protected]</email>
<uri>https://example.com/jane</uri>
</author>
<link href="https://example.com/posts/42" rel="alternate"/>
<category term="xml" scheme="https://example.com/tags" label="XML"/>
<summary type="text">A teaser.</summary>
<content type="xhtml">
<div xmlns="http://www.w3.org/1999/xhtml"><p>Body</p></div>
</content>
</entry>Namespaces Comuns de Feeds
RSS costuma ser estendido com módulos: Dublin Core (dc:creator, dc:date), content (content:encoded para HTML completo), Media RSS (media:content) e o atom:link rel='self' que ajuda leitores a achar a URL do feed. Namespaces permitem que feeds misturem vocabulários.
<?xml version="1.0"?>
<rss version="2.0"
xmlns:content="http://purl.org/rss/1.0/modules/content/"
xmlns:dc="http://purl.org/dc/elements/1.1/"
xmlns:media="http://search.yahoo.com/mrss/"
xmlns:atom="http://www.w3.org/2005/Atom">
<channel>
<title>Feed</title>
<link>https://example.com</link>
<description>desc</description>
<atom:link href="https://example.com/feed.xml" rel="self"
type="application/rss+xml"/>
<item>
<title>Post</title>
<dc:creator>Jane Doe</dc:creator>
<content:encoded><![CDATA[<p>HTML body</p>]]></content:encoded>
<media:content url="https://example.com/img.png" medium="image"/>
</item>
</channel>
</rss>Validação de Feeds
Use o W3C Feed Validator para checar RSS/Atom. Erros comuns: campos obrigatórios faltando, formatos de data ruins, IDs não únicos, XML inválido (& não escapado) e self link ausente. Feeds válidos garantem que agregadores os analisem com confiabilidade.
<!-- RSS: dates must be RFC 822, e.g. -->
<pubDate>Wed, 02 Oct 2024 13:00:00 GMT</pubDate>
<!-- Atom: dates must be RFC 3339, e.g. -->
<updated>2024-10-02T13:00:00Z</updated>
<!-- Validate online with https://validator.w3.org/feed/ -->
<!-- Required RSS channel fields: title, link, description -->
<!-- Required Atom feed fields: id, title, updated -->
<!-- GUIDs/IDs should be unique and permanent -->SVG e XML
Estrutura de Documento SVG
SVG é um vocabulário XML para gráficos vetoriais. A raiz <svg> declara o namespace SVG e um viewBox para o sistema de coordenadas. Cada um dos elementos gráficos (rect, circle, text) são elementos XML com atributos de apresentação.
<?xml version="1.0" encoding="UTF-8"?>
<svg xmlns="http://www.w3.org/2000/svg"
xmlns:xlink="http://www.w3.org/1999/xlink"
width="200" height="200" viewBox="0 0 200 200">
<rect x="10" y="10" width="180" height="180"
fill="#005FAD" stroke="black" stroke-width="2"/>
<circle cx="100" cy="100" r="40" fill="white"/>
<text x="100" y="105" text-anchor="middle">SVG</text>
</svg>
<!-- SVG is an XML application; it must be well-formed -->Namespace SVG e Imports
Elementos SVG vivem no namespace http://www.w3.org/2000/svg. xlink é usado para referências href (no SVG 1.1); o SVG 2 prefere href puro. defs guardam gradientes, patterns e symbols reutilizáveis, referenciados por id via url(#id).
<?xml version="1.0"?>
<svg xmlns="http://www.w3.org/2000/svg"
xmlns:xlink="http://www.w3.org/1999/xlink"
version="1.1">
<defs>
<linearGradient id="g1">
<stop offset="0%" stop-color="red"/>
<stop offset="100%" stop-color="blue"/>
</linearGradient>
</defs>
<rect width="100" height="100" fill="url(#g1)"/>
</svg>Formas SVG
Elementos de forma SVG: rect (com rx/ry para cantos arredondados), circle, ellipse, line, polyline (aberta) e polygon (fechada). As coordenadas estão nas unidades do usuário definidas pelo viewBox. stroke e fill são atributos de apresentação comuns.
<svg xmlns="http://www.w3.org/2000/svg" width="300" height="200">
<rect x="10" y="10" width="80" height="50" rx="10" fill="teal"/>
<circle cx="150" cy="60" r="40" fill="orange"/>
<ellipse cx="220" cy="60" rx="50" ry="20" fill="purple"/>
<line x1="10" y1="120" x2="290" y2="120" stroke="black"/>
<polyline points="10,180 50,140 90,180 130,140" fill="none" stroke="red"/>
<polygon points="200,180 250,140 280,200" fill="green"/>
</svg>Texto e Paths SVG
Texto SVG usa font-family, font-size, font-weight, font-style. tspan permite estilos mistos dentro de um elemento text. O atributo 'd' do elemento path usa comandos: M (mover), L (linha), C (Bézier cúbica), Q (quadrática), A (arco), Z (fechar caminho).
<svg xmlns="http://www.w3.org/2000/svg" width="300" height="150">
<text x="10" y="40" font-family="Arial" font-size="24"
font-weight="bold" fill="navy">Hello SVG</text>
<text x="10" y="80">
<tspan font-size="16">Normal</tspan>
<tspan font-size="16" font-style="italic"> italic</tspan>
</text>
<path d="M10 100 L 100 100 L 55 140 Z"
fill="none" stroke="black" stroke-width="2"/>
</svg>
<!-- Path commands: M=move, L=line, H/V, C=cubic, Q=quad, A=arc, Z=close -->Agrupamento e Reuso SVG
O elemento <g> agrupa formas para estilo e transformações compartilhados. <use> referencia um elemento por id (href='#id' no SVG 2, xlink:href no 1.1) e o clona numa nova posição. <symbol> define gráficos reutilizáveis que só são renderizados via <use>.
<svg xmlns="http://www.w3.org/2000/svg" width="200" height="200">
<g id="node" stroke="black" fill="lightblue">
<circle cx="50" cy="50" r="20"/>
<circle cx="100" cy="50" r="20"/>
</g>
<use href="#node" x="0" y="100"/>
<use href="#node" x="0" y="150" opacity="0.5"/>
<symbol id="star" viewBox="0 0 24 24">
<polygon points="12,2 15,9 22,9 17,14 19,21 12,17 5,21 7,14 2,9 9,9"/>
</symbol>
<use href="#star" width="24" height="24"/>
</svg>Validação de SVG
Documentos SVG podem ser validados contra a DTD ou XSD do W3C. Problemas comuns: esquecer o namespace SVG, prefixos não declarados, atributos no namespace errado e dados de path malformados. xmllint é o validador padrão de linha de comando.
<?xml version="1.0"?>
<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN"
"http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd">
<svg xmlns="http://www.w3.org/2000/svg" version="1.1">
<rect width="100" height="100"/>
</svg>
<!-- Validate with xmllint: -->
<!-- xmllint --noout --valid file.svg (DTD) -->
<!-- xmllint --noout --schema svg11.xsd file.svg (XSD) -->
<!-- Common errors: wrong namespace, undeclared prefixes,
text outside a text element, invalid path data -->SOAP e WSDL
Envelope SOAP
Uma mensagem SOAP é um documento XML com raiz <Envelope> no namespace SOAP. O <Header> opcional carrega metadados (auth, roteamento); o <Body> obrigatório guarda o payload real da mensagem. SOAP 1.1 e 1.2 usam namespaces diferentes.
<?xml version="1.0"?>
<soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/">
<soap:Header>
<auth xmlns="https://example.com/auth">
<token>abc123</token>
</auth>
</soap:Header>
<soap:Body>
<m:GetPrice xmlns:m="https://example.com/pricing">
<m:Item>Apples</m:Item>
</m:GetPrice>
</soap:Body>
</soap:Envelope>
<!-- Envelope is the root; Header is optional, Body is required -->Header SOAP
Headers carregam informações fora da banda, como autenticação, endereçamento (WS-Addressing) e transações. soap:mustUnderstand='1' diz ao receptor que ele DEVE processar este header ou retornar uma SOAP fault—isso garante aderência ao contrato.
<soap:Header xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/">
<wsa:Action xmlns:wsa="http://www.w3.org/2005/08/addressing">
http://example.com/GetPrice
</wsa:Action>
<wsa:MessageID>urn:uuid:1234</wsa:MessageID>
<auth xmlns="https://example.com/auth"
soap:mustUnderstand="1">
<token>secret</token>
</auth>
</soap:Header>
<!-- mustUnderstand="1" forces the receiver to process the header -->Body e Fault SOAP
O Body carrega o payload da requisição ou resposta. Em erro, o Body contém um <Fault> com faultcode (Client/Server), um faultstring legível e detail opcional. SOAP 1.2 renomeia esses elementos e adiciona uma estrutura Code/Reason.
<!-- Request body -->
<soap:Body>
<m:GetPrice xmlns:m="https://example.com/pricing">
<m:Item>Apples</m:Item>
</m:GetPrice>
</soap:Body>
<!-- Fault (error response) -->
<soap:Body>
<soap:Fault>
<faultcode>soap:Client</faultcode>
<faultstring>Unknown item: Apples</faultstring>
<detail>
<m:Error xmlns:m="https://example.com/pricing">
<code>404</code>
</m:Error>
</detail>
</soap:Fault>
</soap:Body>Estrutura do WSDL
WSDL descreve um serviço web: <types> (schemas XSD), <message> (payloads de entrada/saída), <portType> (a interface—operações e suas mensagens), <binding> (protocolo/codificação) e <service> (URL do endpoint). WSDL 2.0 simplifica isso em interfaces e bindings.
<?xml version="1.0"?>
<definitions xmlns="http://schemas.xmlsoap.org/wsdl/"
xmlns:xs="http://www.w3.org/2001/XMLSchema"
targetNamespace="https://example.com/pricing">
<types>
<xs:schema targetNamespace="https://example.com/pricing">
<xs:element name="GetPriceRequest" type="xs:string"/>
<xs:element name="GetPriceResponse" type="xs:decimal"/>
</xs:schema>
</types>
<message name="GetPriceInput">
<part name="item" element="tns:GetPriceRequest"/>
</message>
<portType name="PricingPort">
<operation name="GetPrice">
<input message="tns:GetPriceInput"/>
<output message="tns:GetPriceOutput"/>
</operation>
</portType>
</definitions>Binding e Service do WSDL
O binding mapeia um portType para um protocolo concreto (SOAP sobre HTTP) e um estilo (document/literal é o padrão moderno). O elemento service lista endpoints (soap:address). Document/literal envolve o payload num elemento definido pelo schema.
<binding name="PricingSOAP" type="tns:PricingPort">
<soap:binding style="document"
transport="http://schemas.xmlsoap.org/soap/http"/>
<operation name="GetPrice">
<soap:operation soapAction="http://example.com/GetPrice"/>
<input><soap:body use="literal"/></input>
<output><soap:body use="literal"/></output>
</operation>
</binding>
<service name="PricingService">
<port name="PricingPort" binding="tns:PricingSOAP">
<soap:address location="https://example.com/pricing"/>
</port>
</service>
<!-- style: rpc or document; use: encoded or literal -->SOAP vs REST
SOAP é um protocolo com envelope XML estrito, contrato WSDL e padrões WS-* (segurança, transações); melhor para integrações corporativas que exigem confiabilidade e contratos formais. REST é um estilo leve baseado em HTTP, geralmente com JSON, que domina as APIs públicas.
<!-- SOAP: protocol with envelope, strict contract (WSDL),
built-in error model (Fault), WS-* extensions.
Heavier, XML-only, common in enterprise/B2B. -->
<!-- REST: architectural style using HTTP verbs (GET/POST/...),
flexible payloads (often JSON), no built-in contract.
Lighter, browser-friendly, dominant on the web. -->
<!-- When to use SOAP:
- you need strict contracts and tooling
- transactional reliability (WS-ReliableMessaging)
- standardized security (WS-Security)
- existing SOAP-based infrastructure -->
<!-- When to use REST:
- public APIs, mobile/web clients
- JSON payloads, HTTP caching
- simpler, faster iteration -->Assinatura Digital XML
Estrutura da Assinatura
A raiz <Signature> de uma XML Signature contém <SignedInfo> (o que é assinado e como), <SignatureValue> (a assinatura criptográfica sobre o SignedInfo canonizado), <KeyInfo> opcional e <Object>s com os dados referenciados.
<?xml version="1.0"?>
<Signature xmlns="http://www.w3.org/2000/09/xmldsig#">
<SignedInfo>
<CanonicalizationMethod Algorithm="..."/>
<SignatureMethod Algorithm="..."/>
<Reference URI="#data">
<DigestMethod Algorithm="..."/>
<DigestValue>...</DigestValue>
</Reference>
</SignedInfo>
<SignatureValue>...</SignatureValue>
<KeyInfo>...</KeyInfo>
<Object Id="data">signed content</Object>
</Signature>
<!-- A signature = SignedInfo + SignatureValue + optional KeyInfo -->SignedInfo
SignedInfo especifica a canonicalização (para que a assinatura byte a byte sobreviva à re-serialização do XML), o algoritmo de assinatura e uma ou mais References. Cada Reference aponta para dados via URI, lista Transforms e dá um DigestValue desses dados.
<SignedInfo xmlns="http://www.w3.org/2000/09/xmldsig#">
<CanonicalizationMethod
Algorithm="http://www.w3.org/TR/2001/REC-xml-c14n-20010315"/>
<SignatureMethod
Algorithm="http://www.w3.org/2000/09/xmldsig#rsa-sha1"/>
<Reference URI="">
<Transforms>
<Transform Algorithm="...enveloped-signature"/>
</Transforms>
<DigestMethod Algorithm="http://www.w3.org/2000/09/xmldsig#sha1"/>
<DigestValue>base64digest==</DigestValue>
</Reference>
</SignedInfo>Reference e Transforms
Cada Reference identifica o que assinar (URI), aplica Transforms (canonicalização, filtragem XPath, remoção de enveloped-signature) e então gera o hash com DigestMethod. A transform enveloped-signature exclui o próprio elemento Signature do seu próprio hash.
<Reference URI="#order">
<Transforms>
<Transform Algorithm="http://www.w3.org/TR/2001/REC-xml-c14n-20010315"/>
<Transform Algorithm="http://www.w3.org/2000/09/xmldsig#enveloped-signature"/>
<XPath xmlns="...">not(ancestor-or-self::ds:Signature)</XPath>
</Transforms>
<DigestMethod Algorithm="http://www.w3.org/2001/04/xmlenc#sha256"/>
<DigestValue>abc123base64==</DigestValue>
</Reference>
<!-- Reference types:
- same-document (URI="#id")
- external (URI="https://...")
- detached (URI pointing elsewhere) -->SignatureValue e KeyInfo
SignatureValue é o resultado base64 de assinar o SignedInfo canonizado com a chave privada do assinante. KeyInfo é OPCIONAL e só dá uma dica de como achar a chave de verificação (certificado X.509, chave pública RSA, nome da chave ou URL de recuperação)—precisa ser validada fora da banda.
<SignatureValue>base64encodedSignature==</SignatureValue>
<KeyInfo>
<X509Data>
<X509SubjectName>CN=Example,O=Example Inc</X509SubjectName>
<X509Certificate>MIID...base64...==</X509Certificate>
</X509Data>
</KeyInfo>
<!-- Other KeyInfo options: -->
<!-- <KeyName>key-id</KeyName> -->
<!-- <KeyValue><RSAKeyValue>...</RSAKeyValue></KeyValue> -->
<!-- <RetrievalMethod URI="..."/> -->
<!-- KeyInfo is optional and unverified by itself -->Canonicalização
A canonicalização converte um conjunto de nós XML em bytes estáveis, para que a assinatura seja reproduzível apesar de diferenças irrelevantes (ordem de atributos, CDATA). Exclusive c14n (xml-exc-c14n) é preferido em assinaturas porque delimita os namespaces à subárvore assinada.
<!-- Two documents that are logically identical may differ in bytes:
- attribute order
- namespace declarations
- CDATA vs escaping
- whitespace outside elements
Canonical XML (c14n) produces a canonical byte form. -->
<CanonicalizationMethod
Algorithm="http://www.w3.org/TR/2001/REC-xml-c14n-20010315"/>
<!-- Exclusive c14n (recommended for signatures): -->
<CanonicalizationMethod
Algorithm="http://www.w3.org/2001/10/xml-exc-c14n#"/>
<!-- Exclusive form avoids leaking inherited namespace declarations
into the signed digest, preventing wrapping attacks. -->Assinatura Enveloped
Uma assinatura enveloped fica embutida no documento que assina (o mais comum para XML). A transform enveloped-signature remove o elemento <Signature> antes do hash, para que a assinatura não faça parte do próprio digest. Também existem as variantes detached e enveloping.
<?xml version="1.0"?>
<order Id="order">
<item>Widget</item>
<Signature xmlns="http://www.w3.org/2000/09/xmldsig#">
<SignedInfo>
<CanonicalizationMethod Algorithm="...exc-c14n#"/>
<SignatureMethod Algorithm="...rsa-sha256"/>
<Reference URI="#order">
<Transforms>
<Transform Algorithm="...enveloped-signature"/>
</Transforms>
<DigestMethod Algorithm="...sha256"/>
<DigestValue>...</DigestValue>
</Reference>
</SignedInfo>
<SignatureValue>...</SignatureValue>
</Signature>
</order>
<!-- The signature lives INSIDE the signed element -->XLink e XPointer
Link Simples XLink
Links simples XLink imitam âncoras HTML em XML arbitrário. xlink:type='simple' faz um link básico unidirecional; xlink:href é o alvo. show controla a exibição (new/replace/embed); actuate controla o momento (onRequest/onLoad).
<?xml version="1.0"?>
<root xmlns:xlink="http://www.w3.org/1999/xlink">
<web xlink:type="simple"
xlink:href="https://example.com"
xlink:role="https://example.com/roles/home"
xlink:title="Example Site"
xlink:show="new"
xlink:actuate="onRequest">
Visit Example
</web>
</root>
<!-- A simple link is a one-way hyperlink, similar to HTML <a> -->Link Estendido XLink
Links estendidos conectam múltiplos recursos (locators) via arcs. Cada locator tem um label; os arcs definem a travessia entre labels (from/to). Links out-of-line podem viver num documento separado, permitindo vinculação multidirecional entre recursos de terceiros.
<?xml version="1.0"?>
<root xmlns:xlink="http://www.w3.org/1999/xlink">
<link xlink:type="extended" xlink:role="https://example.com/mapping">
<loc xlink:type="locator" xlink:label="src"
xlink:href="https://a.example/doc1" xlink:title="Doc A"/>
<loc xlink:type="locator" xlink:label="dst"
xlink:href="https://b.example/doc2" xlink:title="Doc B"/>
<go xlink:type="arc" xlink:from="src" xlink:to="dst"
xlink:show="new" xlink:actuate="onRequest"/>
</link>
</root>
<!-- Extended links can connect multiple resources and be out-of-line -->Atributos XLink
Atributos XLink se dividem por tipo. href mira um locator/recurso; label nomeia um participante para os arcs; from/to ligam os arcs; role/arcrole são URIs semânticas (frequentemente termos Dublin Core ou RELAX NG). show/actuate comandam apresentação e comportamento de carregamento.
<!-- xlink:type: simple | extended | locator | arc | resource | title | none -->
<!-- Common attributes by type -->
<el xlink:type="simple" xlink:href="..." xlink:role="..." xlink:title="..."
xlink:show="new|replace|embed|other|none"
xlink:actuate="onRequest|onLoad|other|none"/>
<el xlink:type="locator" xlink:href="..." xlink:label="..." xlink:role="..."/>
<el xlink:type="arc" xlink:from="..." xlink:to="..." xlink:show="..."/>
<el xlink:type="resource" xlink:label="..." xlink:role="..."/>
<!-- xlink:role is a URI identifying the resource's meaning -->
<!-- xlink:arcrole describes the arc (relationship) itself -->Básico de XPointer
XPointer endereça posições num documento XML via fragmentos URI. A forma curta (#id) seleciona por ID. Formas com scheme (#xpointer(...)) usam XPath, e element() usa caminhos posicionais de filhos. O fragmento é interpretado depois de baixar o documento.
<?xml version="1.0"?>
<root xmlns:xlink="http://www.w3.org/1999/xlink">
<!-- XPointer extends a URI fragment to address XML parts -->
<link xlink:type="simple"
xlink:href="doc.xml#xpointer(//book[@id='b1'])"/>
<link xlink:href="doc.xml#xpointer(/root/section[2]/p[1])"/>
<link xlink:href="doc.xml#b1"/>
</root>
<!-- Fragment forms:
- shorthand: #id
- scheme-based: #xpointer(expr)
- element(): #element(/1/2/3) -->Framework XPointer
O Framework XPointer permite encadear múltiplos schemes, para que um posterior seja tentado se o anterior falhar. O scheme xmlns() vincula prefixos para uso em expressões xpointer() seguintes. element() dá um caminho posicional robusto, independente de IDs.
<!-- The XPointer Framework defines how fragment schemes compose -->
<ref xlink:href="doc.xml#element(/1/2)"/>
<ref xlink:href="doc.xml#xpointer(//section[@id='s1']/p[2])"/>
<ref xlink:href="doc.xml#xmlns(bk=https://example.com/b)xpointer(//bk:book)"/>
<!-- Multiple schemes can be tried in order: -->
<ref xlink:href="doc.xml#element(/1/2)xpointer(//book[@id='b1'])"/>
<!-- If element() fails, the next scheme is attempted -->
<!-- Common schemes: element(), xpointer(), xmlns(), xpath1() -->Scheme element()
O scheme element() endereça um nó por uma sequência de posições de filhos baseadas em 1, opcionalmente a partir de um elemento com ID. É mais robusto que xpointer() diante de mudanças de schema, pois não depende de nomes de elementos—apenas da estrutura.
<!-- element() addresses by child positions from the root -->
<ref xlink:href="doc.xml#element(/1/2/3)"/>
<!-- selects the 1st child of root, its 2nd child, then 3rd child -->
<!-- or relative to an ID -->
<ref xlink:href="doc.xml#element(b1/2)"/>
<!-- the 2nd child of the element with id="b1" -->
<!-- child positions are 1-based and skip text/attribute nodes;
only element children are counted -->Convenções de Nomeação
Nomeação de Elementos
Escolha um estilo e aplique-o consistentemente. Minúsculas com hífens são comuns em vocabulários XML (HTML, SVG). Nomes devem ser descritivos o bastante para não serem ambíguos, mas concisos. Evite abreviações crípticas e nomes verbosos demais.
<!-- Good: lowercase, hyphen-separated, descriptive -->
<customer-address>
<street>123 Main St</street>
<postal-code>12345</postal-code>
</customer-address>
<!-- Avoid: abbreviations that are unclear -->
<!-- <cust-addr><pc>...</pc></cust-addr> -->
<!-- Avoid: too long -->
<!-- <customerMailingPostalAddressCode> -->
<!-- Be consistent across the whole vocabulary -->Nomeação de Atributos
Atributos servem para metadados (id, type, href, status). Siga o estilo de nomeação dos elementos. Booleanos carregam valores explícitos. Não prefixe um atributo com o nome do elemento (user-id em <user> é redundante). Use 'id' para identificadores únicos.
<product sku="A1" unit-price="9.99" in-stock="true">
<name>Widget</name>
</product>
<!-- Conventions:
- attributes are metadata: id, type, href, status
- use lowercase-hyphen style to match elements
- boolean attributes still carry a value ("true"/"false")
- avoid repeating the element name: <user user-id="..."/>
prefer <user id="..."/> -->
<!-- IDs: use 'id' or '<element>-id' for clarity -->URIs e Prefixos de Namespace
URIs de namespace são identificadores, não URLs para baixar, mas devem ser estáveis e sob sua posse (use HTTPS num domínio que você controla). Prefixos são apelidos locais—mantenha-os curtos e convencionais. Versione a URI quando o schema mudar de forma incompatível.
<!-- Namespace URIs should be stable, owned, and permanent -->
xmlns:bk = "https://example.com/ns/books/2024"
xmlns:auth= "https://example.com/ns/auth"
<!-- Prefix conventions:
- short and mnemonic: xs, xsi, xsl, svg, html, dc
- lowercase, no punctuation beyond letters
- 'tns' commonly means 'this namespace' in XSD
- avoid 'xml' (reserved) -->
<!-- Version the URI when the vocabulary changes incompatibly:
.../ns/books/2024 vs .../ns/books/2025 -->Estilos de Caixa
Estilos de caixa comuns em XML: PascalCase (XSD/WSDL, .NET), camelCase (derivado de JSON, Java), minúsculas-com-hífens (HTML/SVG, amigável a REST), snake_case (raro). A regra crucial é a consistência dentro de um vocabulário—misturar estilos confunde.
<!-- PascalCase (UpperCamelCase): common in XSD/WSDL, .NET -->
<OrderRequest>
<CustomerId>123</CustomerId>
</OrderRequest>
<!-- camelCase: common in JSON-derived XML, Java ecosystems -->
<orderRequest>
<customerId>123</customerId>
</orderRequest>
<!-- lowercase-with-hyphens: HTML5, SVG, REST-friendly -->
<order-request>
<customer-id>123</customer-id>
</order-request>
<!-- snake_case: rare in XML, used in some Python/SQL ecosystems -->
<order_request><customer_id>123</customer_id></order_request>Versionamento
Versione vocabulários XML explicitamente: um atributo version na raiz é o mais simples; uma URI de namespace versionada é o mais rigoroso (mudanças incompatíveis ganham URI nova). Decida o que conta como mudança menor (aditiva) vs maior (quebradora) e documente.
<!-- Versioning strategies -->
<!-- 1. Attribute on the root -->
<catalog version="2.0">...</catalog>
<!-- 2. Versioned namespace URI -->
<catalog xmlns="https://example.com/ns/catalog/v2">...</catalog>
<!-- 3. Versioned root element name -->
<catalog-v2>...</catalog-v2>
<!-- Backward-compatible changes: add optional elements/attributes
Incompatible changes: bump the version (and/or namespace) -->
<!-- Document the policy: which changes are "minor" vs "major" -->Convenções de Arquivo e Extensão
Use extensões reconhecidas para que ferramentas e pessoas identifiquem os tipos de arquivo. O atributo encoding da declaração XML deve corresponder à codificação real dos bytes; UTF-8 é o padrão seguro. BOMs são desencorajados para XML UTF-8.
<!-- Common file extensions:
.xml generic XML
.xsd XML Schema
.xsl XSLT stylesheet
.xslt XSLT (alternate)
.dtd Document Type Definition
.rss RSS feed
.atom Atom feed
.svg SVG graphic
.wsdl WSDL service description
.xhtml XHTML document
.plist Apple property list -->
<!-- XML files are UTF-8 by default; declare encoding if different:
<?xml version="1.0" encoding="UTF-8"?> -->Boas Práticas
Boa Formação Primeiro
Um documento precisa estar bem formado antes que qualquer ferramenta o processe. Valide com um parser cedo: xmllint --noout file.xml reporta o primeiro erro. Boa formação é inegociável; validade contra um schema é uma camada adicional e opcional.
<?xml version="1.0" encoding="UTF-8"?>
<root>
<child>properly nested & escaped</child>
</root>
<!-- Always ensure well-formedness before worrying about validity:
- exactly one root element
- all tags closed and properly nested
- attributes quoted and unique per element
- & < escaped (and > in some contexts)
- valid encoding declaration -->Validação e Schemas
Valide contra um schema para capturar erros estruturais. XSD é a escolha mais comum para vocabulários tipados e com namespaces; Schematron o complementa com regras de negócio. xsi:noNamespaceSchemaLocation liga um doc ao seu XSD; use xsi:schemaLocation para schemas com namespace.
<!-- Choose a schema language:
- DTD: simple, built-in, limited types
- XSD: rich types, namespaces, industry standard
- RelaxNG: compact syntax, flexible patterns
- Schematron: rule-based business constraints -->
<?xml version="1.0"?>
<root xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:noNamespaceSchemaLocation="schema.xsd">
<item>valid</item>
</root>
<!-- Validate during development; consider it at runtime for
untrusted input. -->Codificação (UTF-8)
UTF-8 é a codificação padrão e recomendada para XML—trata o Unicode inteiro sem entidades. Sempre declare a codificação e salve o arquivo nessa codificação. Evite BOMs; para caracteres especiais você também pode usar referências numéricas de caracteres.
<?xml version="1.0" encoding="UTF-8"?>
<root>
<msg>Café — résumé — 中文 — emoji 🙂</msg>
</root>
<!-- Always declare UTF-8 and save the file as UTF-8.
Avoid legacy encodings (ISO-8859-1) unless required.
Do not add a UTF-8 BOM (some parsers mishandle it).
For non-UTF-8 encodings, declare them accurately. -->Legibilidade e Indentação
Indentação consistente (2 espaços é comum) torna o XML legível e os diffs limpos. Evite linhas únicas longas. Ferramentas como 'xmllint --format' ou um formatador XML podem normalizar espaços—mas lembre de que regiões com xml:space='preserve' não devem ser reformatadas.
<?xml version="1.0"?>
<catalog>
<book id="b1">
<title>XML Guide</title>
<author>Jane Doe</author>
</book>
<book id="b2">
<title>Advanced XML</title>
<author>John Smith</author>
</book>
</catalog>
<!-- Use 2-space indentation; one element per line for mixed
or deep structures. Tools: xmllint --format, prettier. -->Desempenho
Para arquivos grandes, prefira parsers de streaming (SAX/StAX) a DOM para manter a memória baixa. Desative o carregamento de DTDs e entidades externas, a menos que precise. Compile expressões XPath uma vez e reutilize-as. Para sistemas internos, considere formatos binários compactos para cortar tamanho e tempo de análise.
<!-- Parsing large XML efficiently:
- use SAX/StAX (streaming) instead of DOM for big files
- disable DTD/external entities if you don't need them
- validate once, not on every read
- reuse parser instances (factory creation is costly)
- consider binary formats (protobuf, CBOR) for internal traffic -->
<!-- Java StAX with XXE disabled:
factory.setProperty(XMLInputFactory.SUPPORT_DTD, false); -->
<!-- For repeated XPath, compile once and reuse the expression -->Segurança (XXE)
Ataques XML External Entity (XXE) abusam de entidades externas de DTD para ler arquivos, disparar SSRF ou causar negação de serviço (billion laughs/expansão de entidades). A defesa mais forte é desativar completamente DTDs e resolução de entidades externas, a menos que seu caso de uso exija.
<?xml version="1.0"?>
<!DOCTYPE root [
<!-- XXE: attacker forces the parser to read a local file -->
<!ENTITY xxe SYSTEM "file:///etc/passwd">
]>
<root>&xxe;</root>
<!-- Defenses (do ALL that apply):
1. Disable DTDs entirely if you don't need them.
2. Disable external entity resolution.
3. Disable XInclude.
4. Validate input; limit entity expansion (billion laughs). -->
<!-- Python: defusedxml
Java: XMLInputFactory.IS_SUPPORTING_EXTERNAL_ENTITIES = false
PHP: libxml_disable_entity_loader(true) -->Snippets de XML relacionados
Copy-paste ready code for common tasks.
Namespaces
Declare and use XML namespaces.
XPath
Path expressions for selecting nodes.
DTD and Schema
Document Type Definition for validation.
DOM and SAX Parsing
Two models for reading XML.
Attributes
Name-value pairs on elements.
CDATA Sections
Escape blocks of literal text.
XSLT
Transform XML into other formats.
Well-Formed XML
Rules every parser enforces.
Was this helpful?