Premiers pas
Structure de document XML
Les documents XML commencent par une déclaration XML. Les éléments doivent être correctement imbriqués et fermés. Les attributs fournissent des métadonnées supplémentaires. xmlns déclare les namespaces XML pour éviter les conflits de noms.
<?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>Déclaration XML
La déclaration XML est la première ligne du prologue. 'version' est requise (1.0 ou 1.1). 'encoding' passe par défaut à UTF-8. 'standalone' dit aux parseurs si des déclarations DTD externes sont nécessaires.
<?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>Commentaires et instructions de traitement
Les commentaires utilisent <!-- --> et ne peuvent ni s'imbriquer ni contenir '--' à l'intérieur. Les instructions de traitement (PI) comme xml-stylesheet passent des infos propres à l'app au parseur. Les PI utilisent <?cible donnees?>.
<?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 bien formé
Bien formé signifie : un élément racine unique, un bon imbriquement, tous les tags fermés, attributs quotés, pas d'attributs dupliqués. Un document DOIT être bien formé pour être parseable ; la validité (face à une DTD/Schema) est optionnelle.
<!-- 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"/>Prologue XML et espaces
Le prologue inclut la déclaration XML et un DOCTYPE optionnel. xml:space='preserve' dit aux parseurs de garder les espaces ; 'default' autorise le traitement normal. Les espaces entre éléments sont généralement non significatifs.
<?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>Aperçu de CDATA
Les sections CDATA marquent du texte que le parseur ne doit pas interpréter comme balisage. À l'intérieur de CDATA, des caractères comme <, > et & n'exigent pas d'échappement. CDATA ne peut pas s'imbriquer et ne peut pas contenir le littéral ']]>'.
<?xml version="1.0"?>
<root>
<code><![CDATA[
if (a < b && c > d) {
console.log("no escaping needed: < > & ");
}
]]></code>
</root>Éléments et attributs
Éléments vs attributs
Les attributs conviennent aux métadonnées (ids, types, flags) ; les éléments aux données avec structure ou valeurs répétées. Un attribut apparaît une fois par élément et ne peut pas tenir de structure imbriquée. Pas de règle stricte — la cohérence compte le plus.
<!-- 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 -->Éléments vides
Un élément vide n'a pas de contenu. La forme auto-fermante <tag/> est un raccourci de <tag></tag>. L'espace avant '/>' est une convention de style pour la lisibilité et la compatibilité 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"/>Éléments imbriqués
Les éléments s'imbriquent hiérarchiquement et doivent se fermer en ordre inverse — ils ne peuvent pas se chevaucher. L'imbrication exprime la structure. Les arbres profondément imbriqués sont valides mais peuvent nuire à la lisibilité et à la performance de parsing.
<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> -->Valeurs d'attributs et guillemets
Les valeurs d'attributs doivent être quotées avec guillemets simples ou doubles. Les doubles guillemets dans des valeurs double-quotées doivent s'échapper en ". Un attribut ne peut apparaître qu'une fois par élément — utilisez des éléments enfants pour les valeurs répétées.
<!-- 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"/>Attributs par défaut et fixes
Les déclarations d'attributs DTD supportent #REQUIRED (doit apparaître), #IMPLIED (optionnel), #FIXED (valeur constante) et un défaut littéral. Un attribut #FIXED doit toujours égaler sa valeur déclarée sinon le document est invalide.
<!-- 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) -->Règles de nommage des éléments
Les noms d'éléments doivent commencer par une lettre ou underscore et peuvent contenir lettres, chiffres, tirets, underscores et points. Les noms ne peuvent pas commencer par 'xml' (toute casse). XML est sensible à la casse, donc <Tag> et <tag> diffèrent.
<!-- 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 par défaut
Un namespace par défaut (xmlns=URI) s'applique à l'élément où il se déclare et à tous les descendants sans préfixe. Les éléments enfants l'héritent sauf surcharge. Les attributs n'utilisent jamais le namespace par défaut.
<?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 -->Préfixe de namespace
Un préfixe de namespace se déclare avec xmlns:prefixe=URI et s'utilise comme prefixe:element. Le préfixe n'est qu'un alias — seul l'URI compte pour l'identité. Les préfixes sont sensibles à la casse.
<?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>Namespaces multiples
Un seul document peut mêler beaucoup de namespaces. Déclarez chaque préfixe une fois (généralement à la racine) et réutilisez-le. Déclarer un namespace sur un élément s'applique à cet élément et ses descendants.
<?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>Portée de namespace
Les déclarations de namespace se délimitent à l'élément où elles apparaissent et ses descendants. Une redéclaration dans un enfant surcharge le mapping de préfixe du parent pour ce sous-arbre. Le mapping d'origine se restaure après fermeture de l'enfant.
<?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 courants
Ces URIs sont des identifiants bien connus, pas des URLs à fetcher. Le namespace xsi fournit les attributs schema-instance (type, nil, schemaLocation). XSD, XSL, SVG, SOAP, Atom et Dublin Core (dc) ont chacun des URIs standard.
<!-- 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 en XSD
Le targetNamespace d'un schéma est le namespace des éléments qu'il définit. elementFormDefault='qualified' signifie que les éléments localement déclarés sont dans le namespace cible. Le préfixe tns est une convention pour « ce 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 et entités
Entités prédéfinies
XML prédéfinit cinq entités : < (<), > (>), & (&), ' ('), " ("). & doit TOUJOURS s'échapper (même dans du texte sans CDATA) ; < doit s'échapper sauf comme début de tag ; les guillemets comptent surtout dans les attributs.
<?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>Références de caractères
Les références de caractères utilisent un point de code Unicode : © (décimal) ou © (hex) pour ©. Elles marchent dans le texte d'élément et les valeurs d'attributs et ne sont pas affectées par l'encodage. Elles peuvent représenter tout caractère 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 -->Sections CDATA
Les sections CDATA permettent d'inclure <, > et & sans échappement — utiles pour code et balisage. CDATA ne peut pas contenir ']]>' littéralement ; pour l'embarquer, scindez la section comme montré. CDATA est de la donnée caractère, pas parsée en éléments.
<?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>Entités personnalisées (DTD)
Les entités internes se déclarent dans une DTD et s'expansent là où elles sont référencées. Elles agissent comme des macros de texte et peuvent référencer d'autres entités. Utiles pour du boilerplate répété. Attention : les entités externes/générales peuvent être un risque de sécurité 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 -->Échappement dans les attributs
Dans les valeurs d'attributs, il faut échapper & en &, et échapper le caractère de guillemet utilisé pour délimiter la valeur (" ou '). < devrait aussi s'échapper. Les retours à la ligne et tabulations dans les attributs se normalisent en espaces par le parseur.
<?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>Entités paramètres
Les entités paramètres (déclarées avec %) servent seulement dans les DTD à bâtir des modèles de contenu réutilisables. Elles se référencent %nom; (avec point-virgule). Les entités générales (&nom;) s'utilisent dans le contenu du document.
<?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 interne
Une DTD interne se déclare en ligne dans le DOCTYPE entre crochets. Elle définit la structure : quels éléments existent, leurs modèles de contenu et attributs. Les DTD internes sont autonomes mais ne s'appliquent qu'à ce seul document.
<?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 externe
Une DTD externe vit dans un fichier .dtd séparé référencé par SYSTEM (privé) ou PUBLIC (identifiant public + URI). Les DTD externes laissent beaucoup de documents partager une définition. SYSTEM 'fichier.dtd' est la forme la plus courante.
<!-- 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>Déclarations d'éléments
Les modèles de contenu utilisent , (séquence), | (choix), ? (0-1), * (0+), + (1+). #PCDATA est du texte ; le contenu mixte autorise du texte entrecoupé d'éléments. EMPTY signifie pas de contenu ; ANY désactive la vérification (à éviter en production).
<!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 -->Déclarations d'attributs
ATTLIST déclare le type et le défaut d'un attribut. ID est un identifiant unique ; IDREF/IDREFS référencent des IDs (pour les liens croisés). NMTOKEN est un token de nom. Les types énumérés listent les valeurs autorisées. Défauts : #REQUIRED, #IMPLIED, #FIXED, ou un littéral.
<!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>Déclarations d'entités
Les entités générales (&nom;) s'expansent dans le contenu ; les entités paramètres (%nom;) dans la DTD. Les entités parsées externes incluent d'autres XML ; les entités non parsées (avec NDATA) pointent vers des données non XML référencées via NOTATION. Les entités externes peuvent causer l'injection 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>Validation DTD
La validation vérifie qu'un document matche sa DTD (ordre des éléments, attributs autorisés, unicité des IDs). Les parseurs DOM standard comme minidom ne valident PAS par défaut — utilisez lxml (Python), xmllint (ligne de commande) ou un parseur validant.
<?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)
Structure de schéma
Un XSD est lui-même un document XML. La racine <schema> déclare le namespace XSD et un namespace cible pour les éléments qu'il définit. elementFormDefault='qualified' met les éléments locaux dans le namespace cible.
<?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>Types simples
Un simpleType restreint un type de base avec des facets (pattern, minInclusive, enumeration, length, etc.). Les types simples n'ont que du contenu texte et des attributs — pas d'éléments enfants. Ils sont réutilisables dans tout le schéma.
<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"/>Types complexes
Un complexType peut tenir des éléments enfants et attributs. sequence impose l'ordre ; choice autorise un parmi plusieurs ; all autorise n'importe quel ordre (chacun au plus une fois). Les compositors peuvent s'imbriquer pour exprimer des structures riches.
<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>Types intégrés
XSD fournit une hiérarchie de types riche : chaînes, nombres (integer, decimal, float), dates/heures, boolean, anyURI, ID/IDREF et QName. Chacun supporte des facets comme length, pattern et enumeration pour une restriction supplémentaire.
<!-- 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"/>Restrictions (facets)
Les facets contraignent les types simples : enumeration (valeurs autorisées), pattern (regex), length/minLength/maxLength, min/maxInclusive/Exclusive, totalDigits, fractionDigits et 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>Éléments et attributs en XSD
minOccurs/maxOccurs contrôlent la cardinalité (défaut 1) ; maxOccurs='unbounded' autorise n'importe quel nombre. L'attribut 'use' est required/optional/prohibited, avec un défaut ou une valeur fixe optionnelle. Les complexTypes anonymes inline la définition.
<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
Expressions de chemin
XPath utilise des expressions façon chemin. '/' sélectionne depuis la racine ; '//' les descendants à toute profondeur. '*' est un wildcard pour tout élément ; '@' sélectionne les attributs. Une expression commençant par '/' est absolue.
<!-- 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 -->Prédicats
Les prédicats dans [ ] filtrent un ensemble de nœuds. L'indexation commence à 1. last() et position() désignent la position du nœud dans son contexte. Les prédicats peuvent tester le texte d'élément, les attributs (@nom) ou des valeurs calculées.
//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 -->Axes
Les axes définissent les directions de navigation : child (défaut), descendant, parent (..), ancestor, following-sibling, preceding-sibling, attribute (@), self (.), descendant-or-self (//). La plupart ont des formes raccourcies utilisées en pratique.
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: .) -->Fonctions
XPath 1.0 a des fonctions intégrées : count, sum, string-length, contains, starts-with, normalize-space, name, concat, substring, round et plus. XPath 2.0+ élargit considérablement la bibliothèque de fonctions et ajoute le typage.
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 -->Opérateurs
XPath utilise = pour l'égalité (un seul =, pas ==), et les opérateurs 'and'/'or' pour la logique (pas && / ||). 'div' est la division et 'mod' le modulo, puisque '/' est réservé aux chemins. '|' calcule l'union d'ensembles de nœuds.
<!-- 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 | //magazineExemples XPath
Ces patterns combinent chemins, prédicats et fonctions pour de vraies requêtes. text() sélectionne le nœud texte ; min() exige XPath 2.0+. Le wildcard //* avec un prédicat est un moyen courant de trouver des éléments par attribut dans tout l'arbre.
<!-- 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']Transformations XSLT
Transformation de base
Une feuille de style XSLT est du XML. Les templates matchent les nœuds avec XPath ; apply-templates traite récursivement les nœuds sélectionnés. value-of extrait le texte. Le template match='/' tourne en premier, sur la racine du document.
<?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 et apply-templates
Les templates match se déclenchent quand le processeur visite les nœuds correspondants ; les templates nommés s'appellent explicitement avec call-template. apply-templates sans select traite tous les enfants, permettant des transformations récursives pilotées par règles.
<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 et xsl:for-each
xsl:for-each itère un ensemble de nœuds, changeant le nœud de contexte. Souvent plus simple que les templates pour une sortie plate, mais l'abus rend les feuilles de style procédurales. Préférez templates et apply-templates pour les structures récursives.
<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 et xsl:choose
xsl:if n'a pas de else — utilisez xsl:choose pour les branchements multiples. L'expression 'test' suit les règles booléennes XPath : un ensemble de nœuds non vide est vrai, un vide faux, les nombres non nuls vrais.
<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 et xsl:variable
xsl:sort réordonne l'ensemble de nœuds courant par une ou plusieurs clés ; data-type est 'text' ou 'number'. Les variables (xsl:variable) sont immuables et délimitées. Rappelez-vous d'échapper < en < dans les valeurs d'attributs du XML de la feuille de style.
<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 et modes
Les modes laissent un même ensemble de nœuds sources se traiter de différentes façons (ex. une table des matières vs les entrées complètes). L'attribut mode sur template et apply-templates doit correspondre. Sans mode, seuls les templates sans mode s'appliquent.
<!-- 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
Expressions FLWOR
FLWOR est la construction cœur de XQuery : for lie des variables aux éléments de séquence, let lie des valeurs calculées, where filtre, order by trie et return façonne la sortie. Cela rappelle le SELECT-FROM-WHERE de 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 -->Expressions de chemin
XQuery embarque XPath directement. doc('fichier.xml') charge un document ; collection('uri') interroge plusieurs documents. Les expressions de chemin retournent des séquences de nœuds, que les expressions FLWOR peuvent itérer.
(: 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')//titlePrédicats et jointures
Plusieurs clauses 'for' forment une jointure (comme SQL JOIN). XQuery fait les jointures en itérant les combinaisons et filtrant avec where. Pour les grands jeux de données, les jointures explicites via prédicats ou clés sont plus efficaces que les boucles imbriquées.
(: 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>Conditionnel et quantifié
XQuery a if-then-else (le else est obligatoire), des expressions quantifiées (some/every ... satisfies) et typeswitch pour brancher sur le type de nœud. Les conditions utilisent une sémantique booléenne style 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"Fonctions
XQuery réutilise les fonctions XPath et en ajoute beaucoup (string-join, distinct-values, avg, min, max). Les fonctions utilisateur se déclarent dans le module avec types de paramètres et de retour, dans le namespace local: par convention.
(: 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)Construire du XML
XQuery bâtit du XML avec des constructeurs directs (tags littéraux avec { } pour les expressions embarquées) ou calculés (element name { ... }). Les accolades évaluent les expressions encloses ; les attributs peuvent embarquer des valeurs 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 -->Parsing DOM
Charger du XML (JavaScript)
DOMParser transforme une chaîne XML en arbre DOM dans le navigateur ; les erreurs de parsing apparaissent comme un élément <parsererror> plutôt qu'une exception. Node.js n'a pas de DOM XML intégré — utilisez xmldom, @xmldom/xmldom ou un parseur en 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 insteadTraversée DOM
L'API DOM expose documentElement, children, childNodes et nextSibling pour la traversée. nodeType 1 est un élément, 3 du texte, 8 un commentaire. document.evaluate exécute XPath dans les navigateurs (Node exige des bibliothèques 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();Modifier le DOM
createElement/setAttribute/appendChild bâtissent et attachent des nœuds ; textContent règle le texte. XMLSerializer reconvertit un DOM en chaîne. Le DOM est vivant — les mutations se reflètent immédiatement dans toute référence.
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);Créer des éléments
minidom permet de bâtir un document from scratch : createDocument pour la racine, createElement/setAttribute/createTextNode pour le contenu, appendChild pour lier. toprettyxml sérialise avec indentation. minidom est simple mais lent pour les grands arbres.
// 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())Parsing DOM Java
Le DOM JAXP de Java charge tout le document en mémoire via DocumentBuilder. setNamespaceAware(true) garde les préfixes de namespace. Le DOM est pratique pour l'accès aléatoire mais lourd en mémoire pour les gros fichiers — préférez alors StAX/SAX.
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 est un binding Python rapide et riche pour libxml2. Il supporte XPath complet, XSLT, validation (DTD/XSD/RelaxNG) et parsing incrémental. Son ElementPath (find/findall) est un sous-ensemble d'XPath ; utilisez xpath() pour le XPath complet.
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"))Parsing SAX
Handler SAX (Python)
SAX est piloté par événements et streame : le parseur appelle startElement, characters et endElement à la lecture, ne bâtissant jamais un arbre complet. Économe en mémoire pour les fichiers énormes. Il faut suivre l'état (ex. élément courant) soi-même.
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())Méthodes d'événements SAX
Les callbacks ContentHandler marquent les frontières de document et d'élément. characters() peut scinder un seul nœud texte en plusieurs appels — accumulez dans un buffer. startPrefixMapping/endPrefixMapping rapportent les déclarations 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
Suivre un chemin d'élément (une pile) est la façon standard de savoir où on en est pendant le streaming. Bufférisez la sortie de characters() et flush-la dans endElement, car characters peut se déclencher plus d'une fois par nœud texte.
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)Parseur SAX Java
Le SAX Java étend DefaultHandler. startElement reçoit l'URI de namespace, le nom local, le nom qualifié et un objet Attributes. characters(ch, start, len) fournit une tranche de chars — bufférisez-la car un nœud texte peut s'étendre sur plusieurs appels.
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 streame des événements avec mémoire constante, idéal pour les fichiers énormes et l'extraction en une passe. DOM charge tout l'arbre, permettant XPath et la mutation aléatoire mais utilisant une mémoire proportionnelle à la taille du fichier. Choisissez selon le pattern d'accès et la taille du fichier.
<!-- 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 -->Gestion des erreurs (SAX)
Un ErrorHandler reçoit avertissements, erreurs récupérables et erreurs fatales. Par défaut, les erreurs fatales lèvent une exception et arrêtent le parsing. Implémenter error() permet de logger les soucis de validation non fatals sans avorter tout le parsing.
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 (parsing pull)
API curseur StAX
StAX est un parseur pull : votre code tire l'événement suivant avec next(), contrôlant la boucle. L'API curseur (XMLStreamReader) avance dans les événements un à la fois. Plus rapide et moins gourmand que le DOM, et plus flexible que le modèle push de 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();Événements XMLStreamReader
Les types d'événements incluent START_ELEMENT, END_ELEMENT, CHARACTERS, COMMENT, PROCESSING_INSTRUCTION et START/END_DOCUMENT. getText() retourne le texte courant ; isWhiteSpace() filtre l'indentation. Le curseur avance d'un événement par appel 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;
}
}Lire éléments et attributs
getAttributeValue(namespaceURI, localName) lit les attributs par nom (passez null pour sans namespace). getElementText() est une commodité qui lit le texte d'un élément uniquement-texte et avance au-delà de son END_ELEMENT — plus propre que buffériser les characters soi-même.
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 StAX
XMLStreamWriter bâtit du XML séquentiellement. writeStartDocument, writeStartElement/writeEndElement, writeAttribute, writeCharacters et writeNamespace doivent s'équilibrer. Flush/close à la fin pour garantir la complétude de la sortie.
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 pousse les événements vers votre handler ; StAX laisse tirer les événements à la demande. Le modèle pull de StAX facilite sauter des sous-arbres et gérer l'état, et il ajoute une API d'écriture. Les deux évitent de bâtir un arbre DOM complet, convenant donc aux grands documents.
<!-- 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 itérateur)
L'API itérateur (XMLEventReader) retourne des objets XMLEvent qu'on peut sonder et consommer. Plus orientée objet que l'API curseur et plus facile pour filtrer ou scinder, mais légèrement plus lourde à cause de l'allocation des objets d'événement.
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();Conversion XML et JSON
XML vers JSON (JavaScript)
fast-xml-parser convertit XML en JSON dans Node.js. Les attributs se préfixent (défaut @_) et les éléments répétés deviennent des tableaux. La bibliothèque est en pur JavaScript et rapide, avec des options pour contrôler tableaux, nombres et booléens.
// 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 vers XML (JavaScript)
XMLBuilder inverse la conversion. Le préfixe @_ marque les attributs et les objets imbriqués deviennent des éléments enfants. Les tableaux produisent des éléments répétés. La règle de racine unique du XML signifie que l'objet JSON de premier niveau doit mapper à un seul élément racine.
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 (Python)
xmltodict traite le XML comme des structures dict/list : les attributs utilisent '@nom', le texte '#text'. parse() lit le XML, unparse() l'écrit. Parfait pour des aller-retours rapides mais perd l'ordre et certains cas limites des schémas complexes.
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)Gestion des attributs et du texte
Convertir XML en JSON force des décisions sur les attributs (@_préfixe), le texte (#text) et le contenu mixte. Le contenu mixte — texte entrecoupé d'éléments enfants — ne mappe pas proprement au JSON et perd souvent de la fidélité. Choisissez des conventions et restez cohérent.
<!-- 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 -->Défis de conversion
Pièges de conversion courants : enfant unique vs multiples (chaîne vs tableau), ordre des éléments, préfixes de namespace (qui sont des alias), la contrainte de racine unique et le typage primitif (le XML n'a pas de nombres ni booléens natifs). Documentez vos conventions.
<!-- 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 -->Exemple d'aller-retour
L'aller-retour (XML -> JSON -> XML) marche pour des données bien structurées mais peut perdre commentaires, instructions de traitement, frontières CDATA et espaces exacts. Pour une édition sans perte, utilisez une API DOM/arbre au lieu d'une conversion 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);Flux RSS et Atom
Structure RSS 2.0
RSS 2.0 a une racine <rss> avec un seul <channel>. Champs de canal requis : title, link, description. Chaque <item> porte title, link, description, guid, pubDate. Les dates suivent 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 et item RSS
Les champs au niveau du canal décrivent le flux (title, link, description, language, ttl, image). Les champs d'item décrivent chaque entrée ; enclosure supporte podcasts/médias avec URL, longueur en octets et type MIME. category peut porter un attribut 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>Flux Atom
Atom (RFC 4287) utilise une racine <feed> dans le namespace Atom. Requis : id, title, updated. Les entrées exigent id, title, updated. Les IDs devraient être globalement uniques (URN ou URIs tag:). Les dates utilisent RFC 3339 (ISO 8601) avec fuseau.
<?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>Détails des entrées Atom
Les entrées Atom supportent du contenu riche : text, html ou xhtml via l'attribut type. link utilise les attributs rel (alternate, self, enclosure, related). category a term/scheme/label. published est la date d'origine ; updated le dernier changement.
<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 de flux courants
RSS s'étend souvent avec des modules : Dublin Core (dc:creator, dc:date), content (content:encoded pour le HTML complet), Media RSS (media:content) et le atom:link rel='self' qui aide les lecteurs à trouver l'URL du flux. Les namespaces laissent les flux mêler vocabulaires.
<?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>Validation des flux
Utilisez le W3C Feed Validator pour vérifier RSS/Atom. Erreurs courantes : champs requis manquants, mauvais formats de dates, IDs non uniques, XML invalide (& non échappé) et self link manquant. Des flux valides garantissent que les agrégateurs les parsent fiablement.
<!-- 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 et XML
Structure de document SVG
SVG est un vocabulaire XML pour les graphiques vectoriels. La racine <svg> déclare le namespace SVG et un viewBox pour le système de coordonnées. Tous les éléments graphiques (rect, circle, text) sont des éléments XML avec attributs de présentation.
<?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 et imports
Les éléments SVG vivent dans le namespace http://www.w3.org/2000/svg. xlink sert aux références href (en SVG 1.1) ; SVG 2 préfère le href simple. defs héberge les dégradés, patterns et symbols réutilisables référencés par 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>Formes SVG
Éléments de forme SVG : rect (avec rx/ry pour les coins arrondis), circle, ellipse, line, polyline (ouverte) et polygon (fermée). Les coordonnées sont en unités utilisateur définies par le viewBox. stroke et fill sont des attributs de présentation courants.
<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>Texte et chemins SVG
Le texte SVG utilise font-family, font-size, font-weight, font-style. tspan permet des styles mixtes dans un élément text. L'attribut 'd' de l'élément path utilise des commandes : M (déplacer), L (ligne), C (bezier cubique), Q (quadratique), A (arc), Z (fermer le chemin).
<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 -->Groupement et réutilisation SVG
L'élément <g> groupe les formes pour un style et des transforms partagés. <use> référence un élément par id (href='#id' en SVG 2, xlink:href en 1.1) et le clone à une nouvelle position. <symbol> définit des graphiques réutilisables qui ne se rendent que 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>Validation SVG
Les documents SVG peuvent se valider contre la DTD ou le XSD du W3C. Soucis courants : namespace SVG oublié, préfixes non déclarés, attributs dans le mauvais namespace et données de path mal formées. xmllint est le validateur en ligne de commande standard.
<?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 et WSDL
Enveloppe SOAP
Un message SOAP est un document XML avec une racine <Envelope> dans le namespace SOAP. L'<Header> optionnel porte des métadonnées (auth, routage) ; le <Body> requis détient le payload réel du message. SOAP 1.1 et 1.2 utilisent des namespaces différents.
<?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 -->En-tête SOAP
Les en-têtes portent des infos hors bande comme l'authentification, l'adressage (WS-Addressing) et les transactions. soap:mustUnderstand='1' dit au récepteur qu'il DOIT traiter cet en-tête ou retourner un fault SOAP — cela impose le respect du contrat.
<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 -->Corps SOAP et Fault
Le Body porte le payload de requête ou réponse. En erreur, le Body contient un <Fault> avec faultcode (Client/Server), une faultstring lisible humain et un detail optionnel. SOAP 1.2 renomme ces éléments et ajoute une structure 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>Structure WSDL
WSDL décrit un service web : <types> (schémas XSD), <message> (payloads d'entrée/sortie), <portType> (l'interface — opérations et leurs messages), <binding> (protocole/encodage) et <service> (URL d'endpoint). WSDL 2.0 simplifie cela en interfaces et 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 et service WSDL
Le binding mappe un portType vers un protocole concret (SOAP sur HTTP) et un style (document/literal est le défaut moderne). L'élément service liste les endpoints (soap:address). Document/literal enveloppe le payload dans un élément défini par le schéma.
<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 est un protocole avec une enveloppe XML stricte, un contrat WSDL et des standards WS-* (sécurité, transactions) ; le mieux pour les intégrations d'entreprise exigeant fiabilité et contrats formels. REST est un style léger basé HTTP, habituellement en JSON, qui domine les API publiques.
<!-- 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 -->Signature numérique XML
Structure de signature
La racine <Signature> d'une signature XML contient <SignedInfo> (ce qui est signé et comment), <SignatureValue> (la signature cryptographique sur le SignedInfo canonisé), un <KeyInfo> optionnel et des <Object> détenant les données référencées.
<?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 spécifie la canonicalisation (pour que la signature identique aux octets survive à la re-sérialisation XML), l'algorithme de signature et une ou plusieurs References. Chaque Reference pointe des données via URI, liste des Transforms et donne un DigestValue de ces données.
<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 et Transforms
Chaque Reference identifie quoi signer (URI), applique des Transforms (canonicalisation, filtrage XPath, retrait de signature enveloppée), puis hache avec DigestMethod. Le transform enveloped-signature exclut l'élément Signature lui-même de son propre 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 et KeyInfo
SignatureValue est le résultat base64 de signer le SignedInfo canonisé avec la clé privée du signataire. KeyInfo est OPTIONNEL et ne fait que suggérer comment trouver la clé de vérification (cert X.509, clé publique RSA, nom de clé ou URL de récupération) — il faut la valider hors bande.
<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 -->Canonicalisation
La canonicalisation convertit un ensemble de nœuds XML en octets stables pour qu'une signature soit reproductible malgré des différences non pertinentes (ordre des attributs, CDATA). La c14n exclusive (xml-exc-c14n) est préférée pour les signatures car elle délimite les namespaces au sous-arbre signé.
<!-- 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. -->Signature enveloppée
Une signature enveloppée s'embarque dans le document qu'elle signe (le plus courant pour le XML). Le transform enveloped-signature retire l'élément <Signature> avant le hachage, pour que la signature ne fasse pas partie de son propre digest. Des variantes détachées et enveloppantes existent aussi.
<?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 et XPointer
Lien simple XLink
Les liens simples XLink imitent les ancres HTML dans du XML arbitraire. xlink:type='simple' fait un lien unidirectionnel basique ; xlink:href est la cible. show contrôle l'affichage (new/replace/embed) ; actuate le timing (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> -->Lien étendu XLink
Les liens étendus connectent plusieurs ressources (locators) via des arcs. Chaque locator a un label ; les arcs définissent la traversée entre labels (from/to). Les liens hors ligne peuvent vivre dans un document séparé, permettant du liage multidirectionnel entre ressources tierces.
<?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 -->Attributs XLink
Les attributs XLink se répartissent par type. href vise un locator/ressource ; label nomme un participant pour les arcs ; from/to câblent les arcs ; role/arcrole sont des URIs sémantiques (souvent Dublin Core ou termes RELAX NG). show/actuate pilotent présentation et comportement de chargement.
<!-- 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 -->Bases de XPointer
XPointer adresse des positions dans un document XML via des fragments d'URI. La forme raccourcie (#id) sélectionne par ID. Les formes par schéma (#xpointer(...)) utilisent XPath, et element() des chemins d'enfants positionnels. Le fragment s'interprète après le fetch du document.
<?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
Le framework XPointer laisse plusieurs schémas s'enchaîner, un suivant étant essayé si le précédent échoue. Le schéma xmlns() lie des préfixes pour l'usage dans les expressions xpointer() suivantes. element() donne un chemin positionnel robuste indépendant des 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() -->Schéma element()
Le schéma element() adresse un nœud par une séquence de positions d'enfants à partir de 1, optionnellement depuis un élément avec ID. Plus robuste que xpointer() face aux changements de schéma car il ne dépend pas des noms d'éléments — seulement de la structure.
<!-- 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 -->Conventions de nommage
Nommer les éléments
Choisissez un style et appliquez-le de façon cohérente. Le minuscules-avec-tirets est courant pour les vocabulaires XML (HTML, SVG). Les noms devraient être assez descriptifs pour être sans ambiguïté mais concis. Évitez les abréviations cryptiques et les noms trop verbeux.
<!-- 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 -->Nommer les attributs
Les attributs conviennent aux métadonnées (id, type, href, status). Matchez le style de nommage des éléments. Les booléens portent des valeurs explicites. Ne préfixez pas un attribut du nom de son élément (user-id sur <user> est redondant). Utilisez 'id' pour les identifiants uniques.
<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 et préfixes de namespace
Les URIs de namespace sont des identifiants, pas des URLs fetchables, mais devraient être stables et détenus (utilisez HTTPS sur un domaine que vous contrôlez). Les préfixes sont des alias locaux — gardez-les courts et conventionnels. Versionnez l'URI quand le sch éma change de façon incompatible.
<!-- 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 -->Styles de casse
Styles de casse XML courants : PascalCase (XSD/WSDL, .NET), camelCase (dérivé JSON, Java), minuscules-tirets (HTML/SVG, friendly REST), snake_case (rare). La règle cruciale est la cohérence au sein d'un vocabulaire — mélanger les styles troublerait.
<!-- 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>Versioning
Versionnez explicitement les vocabulaires XML : un attribut version à la racine est le plus simple ; un URI de namespace versionné est le plus rigoureux (les changements incompatibles reçoivent un nouvel URI). Décidez ce qui compte comme changement mineur (additif) vs majeur (cassant) et documentez-le.
<!-- 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" -->Conventions de fichiers et extensions
Utilisez des extensions reconnues pour que les outils et humains identifient les types de fichiers. L'attribut encoding de la déclaration XML devrait matcher l'encodage réel des octets ; UTF-8 est le défaut sûr. Les BOM sont déconseillés pour le 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"?> -->Bonnes pratiques
La bien-formation d'abord
Un document doit être bien formé avant que tout outil le traite. Validez avec un parseur tôt : xmllint --noout fichier.xml rapporte la première erreur. La bien-formation est non négociable ; la validité face à un schéma est une couche additionnelle, optionnelle.
<?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 -->Validation et schémas
Validez contre un schéma pour attraper les erreurs structurelles. XSD est le choix le plus courant pour les vocabulaires typés et namespacés ; Schematron le complète avec des règles métier. xsi:noNamespaceSchemaLocation lie un document à son XSD ; utilisez xsi:schemaLocation pour les schémas namespacés.
<!-- 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. -->Encodage (UTF-8)
UTF-8 est l'encodage par défaut et recommandé pour le XML — il gère tout l'Unicode sans entités. Déclarez toujours l'encodage et sauvegardez le fichier dans cet encodage. Évitez les BOM ; pour des caractères spéciaux on peut aussi utiliser des références de caractères numériques.
<?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. -->Lisibilité et indentation
Une indentation cohérente (2 espaces est courant) rend le XML lisible et les diffs propres. Évitez les longues lignes uniques. Des outils comme 'xmllint --format' ou un formateur XML peuvent normaliser les espaces — mais sachez que les régions xml:space='preserve' ne doivent pas se reformater.
<?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. -->Performance
Pour les gros fichiers, préférez les parseurs en streaming (SAX/StAX) au DOM pour garder la mémoire basse. Désactivez le chargement de DTD et les entités externes sauf besoin. Compilez les expressions XPath une fois et réutilisez-les. Pour les systèmes internes, considérez des formats binaires compacts pour réduire taille et temps de parsing.
<!-- 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 -->Sécurité (XXE)
Les attaques XML External Entity (XXE) abusent des entités externes de DTD pour lire des fichiers, déclencher du SSRF ou causer un déni de service (billion laughs/expansion d'entités). La défense la plus forte est de désactiver entièrement les DTD et la résolution d'entités externes sauf si votre cas d'usage les exige.
<?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 XML associés
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?