Skip to content

XML Шпаргалка

Расширяемый язык разметки для обмена структурированными данными.

01

Начало работы

Структура XML-документа

XML-документы начинаются с XML-объявления. Элементы должны быть правильно вложены и закрыты. Атрибуты дают дополнительные метаданные. xmlns объявляет пространства имён XML, чтобы избежать конфликтов имён.

xml
<?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>

XML-объявление

XML-объявление — первая строка пролога. 'version' обязателен (1.0 или 1.1). 'encoding' по умолчанию UTF-8. 'standalone' говорит парсерам, нужны ли внешние объявления DTD.

xml
<?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>

Комментарии и инструкции обработки

Комментарии используют <!-- --> и не могут вкладываться или содержать '--'. Инструкции обработки (PI) вроде xml-stylesheet передают парсеру информацию приложения. PI имеют вид <?target data?>.

xml
<?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

Корректность означает: один корневой элемент, правильная вложенность, все теги закрыты, атрибуты в кавычках, нет дублирующихся атрибутов. Документ ОБЯЗАН быть корректным, чтобы парситься; валидность (по DTD/схеме) необязательна.

xml
<!-- 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"/>

Пролог и пробелы

Пролог включает XML-объявление и необязательный DOCTYPE. xml:space='preserve' велит парсерам сохранять пробелы; 'default' допускает обычную обработку. Пробелы между элементами обычно незначимы.

xml
<?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>

Обзор CDATA

Секции CDATA помечают текст, который парсер не должен толковать как разметку. Внутри CDATA символы <, > и & не нужно экранировать. CDATA нельзя вкладывать, и она не может содержать литерал ']]>'.

xml
<?xml version="1.0"?>
<root>
  <code><![CDATA[
    if (a < b && c > d) {
      console.log("no escaping needed: < > & ");
    }
  ]]></code>
</root>
02

Элементы и атрибуты

Элементы против атрибутов

Атрибуты подходят для метаданных (id, типы, флаги); элементы — для данных со структурой или повторяющимися значениями. Атрибут встречается у элемента один раз и не может хранить вложенную структуру. Строгих правил нет: важнее последовательность.

xml
<!-- 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 -->

Пустые элементы

У пустого элемента нет содержимого. Самозакрывающаяся форма <tag/> — сокращение для <tag></tag>. Пробел перед '/>' — стилистическое соглашение для читаемости и совместимости с XHTML.

xml
<!-- 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"/>

Вложенные элементы

Элементы вкладываются иерархически и должны закрываться в обратном порядке — пересекаться они не могут. Вложенность выражает структуру. Глубоко вложенные деревья валидны, но снижают читаемость и производительность разбора.

xml
<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> -->

Значения атрибутов и кавычки

Значения атрибутов должны быть в одинарных или двойных кавычках. Двойные кавычки внутри значения в двойных кавычках нужно экранировать как &quot;. Атрибут может встречаться у элемента только один раз: для повторяющихся значений используйте дочерние элементы.

xml
<!-- Both single and double quotes are allowed -->
<item id="q1" name='quick'/>
<msg text="He said &quot;hi&quot;"/>
<msg text='She said &apos;hi&apos;'/>

<!-- 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"/>

Атрибуты по умолчанию и фиксированные

Объявления атрибутов в DTD поддерживают #REQUIRED (обязателен), #IMPLIED (необязателен), #FIXED (постоянное значение) и буквальное значение по умолчанию. Атрибут #FIXED должен всегда равняться объявленному значению, иначе документ невалиден.

xml
<!-- 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) -->

Правила именования элементов

Имена элементов должны начинаться с буквы или подчёркивания и могут содержать буквы, цифры, дефисы, подчёркивания и точки. Имена не могут начинаться с 'xml' (в любом регистре). XML чувствителен к регистру: <Tag> и <tag> различаются.

xml
<!-- 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) -->
03

Пространства имён

Пространство имён по умолчанию

Пространство имён по умолчанию (xmlns=URI) действует на элемент, где объявлено, и всех потомков без префикса. Дочерние элементы наследуют его, если не переопределено. Атрибуты никогда не используют пространство имён по умолчанию.

xml
<?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 -->

Префикс пространства имён

Префикс пространства имён объявляется как xmlns:prefix=URI и используется как prefix:element. Префикс — лишь псевдоним: для идентичности важен только URI. Префиксы чувствительны к регистру.

xml
<?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>

Несколько пространств имён

Один документ может смешивать много пространств имён. Объявляйте каждый префикс один раз (обычно на корне) и переиспользуйте. Объявление пространства имён на элементе действует на этот элемент и его потомков.

xml
<?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>

Область видимости пространства имён

Объявления пространств имён ограничены элементом, где они стоят, и его потомками. Переобъявление внутри ребёнка переопределяет отображение префикса родителя для этого поддерева. После закрытия ребёнка исходное отображение восстанавливается.

xml
<?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>

Частые пространства имён

Эти URI — известные идентификаторы, а не URL, которые нужно загружать. Пространство xsi даёт атрибуты экземпляра схемы (type, nil, schemaLocation). У XSD, XSL, SVG, SOAP, Atom и Dublin Core (dc) есть свои стандартные URI.

xml
<!-- 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 в XSD

targetNamespace схемы — пространство имён элементов, которые она определяет. elementFormDefault='qualified' означает, что локально объявленные элементы входят в целевое пространство имён. Префикс tns — соглашение для «этого пространства имён».

xml
<?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>
04

CDATA и сущности

Предопределённые сущности

XML предопределяет пять сущностей: &lt; (<), &gt; (>), &amp; (&), &apos; ('), &quot; ("). & нужно экранировать ВСЕГДА (даже в тексте без CDATA); < нужно экранировать везде, кроме начала тега; кавычки важны в основном в атрибутах.

xml
<?xml version="1.0"?>
<root>
  <lt>less than: &lt;</lt>
  <gt>greater than: &gt;</gt>
  <amp>ampersand: &amp;</amp>
  <apos>apostrophe: &apos;</apos>
  <quot>quote: &quot;</quot>
  <!-- &lt; &gt; &amp; &apos; &quot; are the 5 built-in entities -->
</root>

Ссылки на символы

Ссылки на символы используют кодовую точку Unicode: &#169; (десятичная) или &#xA9; (шестнадцатеричная) для ©. Они работают в тексте элементов и значениях атрибутов и не зависят от кодировки. Так можно представить любой символ Unicode.

xml
<?xml version="1.0" encoding="UTF-8"?>
<root>
  <decimal>&#169; 2024 Company</decimal>
  <hex>&#xA9; 2024 Company</hex>
  <euro>Price: &#x20AC;10</euro>
  <emoji>Smile: &#x1F600;</emoji>
</root>
<!-- &#NNN;  decimal code point -->
<!-- &#xHHH; hexadecimal code point -->

Секции CDATA

Секции CDATA позволяют включать <, > и & без экранирования — удобно для кода и разметки. CDATA не может содержать литерал ']]>'; чтобы вставить его, разделите секцию, как показано. CDATA — символьные данные, а не разбираемые элементы.

xml
<?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>

Свои сущности (DTD)

Внутренние сущности объявляются в DTD и раскрываются везде, где на них ссылаются. Они работают как текстовые макросы и могут ссылаться на другие сущности. Полезно для повторяющегося шаблонного текста. Осторожно: внешние и общие сущности создают риск XXE.

xml
<?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>&copyright;</footer>
</root>
<!-- Entities are expanded during parsing -->

Экранирование в атрибутах

Внутри значений атрибутов нужно экранировать & как &amp;, а также кавычку, ограничивающую значение (&quot; или &apos;). < тоже следует экранировать. Переводы строк и табуляция в атрибутах парсер нормализует в пробелы.

xml
<?xml version="1.0"?>
<root>
  <link url="https://example.com?a=1&amp;b=2"/>
  <msg text="Say &quot;hello&quot; &amp; smile"/>
  <path value='C:\Users\name'/>
  <data value="&lt;tagged&gt;"/>
</root>

Параметрические сущности

Параметрические сущности (объявляются через %) используются только внутри DTD для построения переиспользуемых моделей содержимого. На них ссылаются как %name; (с точкой с запятой). Общие сущности (&name;) используются в содержимом документа.

xml
<?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>
05

DTD (Document Type Definition)

Внутренний DTD

Внутренний DTD объявляется прямо в DOCTYPE в квадратных скобках. Он описывает структуру: какие элементы существуют, их модели содержимого и атрибуты. Внутренние DTD самодостаточны, но действуют только на один документ.

xml
<?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

Внешний DTD живёт в отдельном файле .dtd, на который ссылаются через SYSTEM (приватный) или PUBLIC (публичный идентификатор + URI). Внешние DTD позволяют многим документам делить одно определение. SYSTEM 'file.dtd' — самая частая форма.

xml
<!-- 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>

Объявления элементов

Модели содержимого используют , (последовательность), | (выбор), ? (0-1), * (0+), + (1+). #PCDATA — текст; смешанное содержимое допускает текст вперемешку с элементами. EMPTY означает отсутствие содержимого; ANY отключает проверку (избегайте в production).

xml
<!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 -->

Объявления атрибутов

ATTLIST объявляет тип атрибута и значение по умолчанию. ID — уникальный идентификатор; IDREF/IDREFS ссылаются на ID (для перекрёстных ссылок). NMTOKEN — токен имени. Перечислимые типы задают допустимые значения. Умолчания: #REQUIRED, #IMPLIED, #FIXED или литерал.

xml
<!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>

Объявления сущностей

Общие сущности (&name;) раскрываются в содержимом; параметрические (%name;) — в DTD. Внешние разбираемые сущности включают другой XML; неразбираемые (с NDATA) указывают на не-XML данные через NOTATION. Внешние сущности могут вызывать XXE-инъекции.

xml
<!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>

Валидация DTD

Валидация проверяет соответствие документа его DTD (порядок элементов, допустимые атрибуты, уникальность ID). Стандартные DOM-парсеры вроде minidom по умолчанию НЕ валидируют: используйте lxml (Python), xmllint (командная строка) или валидирующий парсер.

xml
<?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)) -->
06

XML Schema (XSD)

Структура схемы

XSD сам является XML-документом. Корень <schema> объявляет пространство имён XSD и целевое пространство имён для определяемых элементов. elementFormDefault='qualified' помещает локальные элементы в целевое пространство имён.

xml
<?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>

Простые типы

simpleType ограничивает базовый тип фасетами (pattern, minInclusive, enumeration, length и др.). У простых типов только текстовое содержимое и атрибуты — без дочерних элементов. Они переиспользуемы в схеме.

xml
<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"/>

Сложные типы

complexType может содержать дочерние элементы и атрибуты. sequence задаёт порядок; choice допускает один из нескольких; all разрешает любой порядок (каждый не более раза). Композиторы вкладываются, выражая богатые структуры.

xml
<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>

Встроенные типы

XSD даёт богатую иерархию типов: строки, числа (integer, decimal, float), даты и время, boolean, anyURI, ID/IDREF и QName. Каждый поддерживает фасеты вроде length, pattern и enumeration для дальнейшего ограничения.

xml
<!-- 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"/>

Ограничения (фасеты)

Фасеты ограничивают простые типы: enumeration (допустимые значения), pattern (regex), length/minLength/maxLength, min/maxInclusive/Exclusive, totalDigits, fractionDigits и whiteSpace (preserve/replace/collapse).

xml
<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>

Элементы и атрибуты в XSD

minOccurs/maxOccurs задают кратность (по умолчанию 1); maxOccurs='unbounded' допускает любое число. Атрибут 'use' может быть required/optional/prohibited с необязательным значением default или fixed. Анонимные сложные типы встраивают определение.

xml
<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>
07

XPath

Путевые выражения

XPath использует выражения, похожие на пути. '/' выбирает от корня; '//' выбирает потомков на любой глубине. '*' — подстановочный знак для любого элемента; '@' выбирает атрибуты. Выражение, начинающееся с '/', абсолютно.

xml
<!-- 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 -->

Предикаты

Предикаты в [ ] фильтруют набор узлов. Индексация с 1. last() и position() относятся к позиции узла в его контексте. Предикаты могут проверять текст элемента, атрибуты (@name) или вычисленные значения.

xml
//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 -->

Оси

Оси задают направления навигации: child (по умолчанию), descendant, parent (..), ancestor, following-sibling, preceding-sibling, attribute (@), self (.), descendant-or-self (//). У большинства есть сокращённые формы, используемые на практике.

xml
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: .) -->

Функции

В XPath 1.0 есть встроенные функции: count, sum, string-length, contains, starts-with, normalize-space, name, concat, substring, round и другие. XPath 2.0+ сильно расширяет библиотеку функций и добавляет типизацию.

xml
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 -->

Операторы

XPath использует = для равенства (один =, не ==), а операторы 'and'/'or' для логики (не && / ||). 'div' — деление, 'mod' — остаток, так как '/' зарезервирован для путей. '|' вычисляет объединение наборов узлов.

xml
<!-- 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 | //magazine

Примеры XPath

Эти шаблоны сочетают пути, предикаты и функции для реальных запросов. text() выбирает текстовый узел; min() требует XPath 2.0+. Подстановочный знак //* с предикатом — частый способ найти элементы по атрибуту во всём дереве.

xml
<!-- 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']
08

Преобразования XSLT

Базовое преобразование

Стилевой лист XSLT — это XML. Шаблоны сопоставляют узлы через XPath; apply-templates рекурсивно обрабатывает выбранные узлы. value-of извлекает текст. Шаблон match='/' выполняется первым, на корне документа.

xml
<?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 и apply-templates

Шаблоны match срабатывают, когда процессор посещает подходящие узлы; именованные шаблоны вызываются явно через call-template. apply-templates без select обрабатывает всех детей, обеспечивая рекурсивные преобразования на правилах.

xml
<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 и xsl:for-each

xsl:for-each перебирает набор узлов, меняя контекстный узел. Для плоского вывода это часто проще шаблонов, но злоупотребление делает стилевые листы процедурными. Для рекурсивных структур предпочитайте шаблоны и apply-templates.

xml
<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 и xsl:choose

У xsl:if нет else: для многоветвевления используйте xsl:choose. Выражение 'test' следует булевым правилам XPath: непустой набор узлов истинен, пустой ложен, ненулевые числа истинны.

xml
<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 и xsl:variable

xsl:sort переупорядочивает текущий набор узлов по одному или нескольким ключам; data-type — 'text' или 'number'. Переменные (xsl:variable) неизменяемы и имеют область видимости. Не забудьте экранировать < как &lt; в значениях атрибутов стилевого листа.

xml
<xsl:variable name="max-price" select="50"/>

<xsl:for-each select="bookstore/book[price &lt; $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 &lt; inside test attributes -->

xsl:apply-templates и режимы

Режимы позволяют обрабатывать один набор исходных узлов по-разному (например, оглавление и полные записи). Атрибут mode у template и apply-templates должен совпадать. Без режима применяются только шаблоны без режима.

xml
<!-- 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"/>
09

XQuery

Выражения FLWOR

FLWOR — основная конструкция XQuery: for связывает переменные с элементами последовательности, let связывает вычисленные значения, where фильтрует, order by сортирует, return формирует вывод. Похоже на SELECT-FROM-WHERE в SQL.

xml
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 -->

Путевые выражения

XQuery встраивает XPath напрямую. doc('file.xml') загружает документ; collection('uri') запрашивает несколько документов. Путевые выражения возвращают последовательности узлов, по которым могут перебирать выражения FLWOR.

xml
(: 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')//title

Предикаты и соединения

Несколько предложений 'for' образуют соединение (как JOIN в SQL). XQuery выполняет соединения перебором комбинаций и фильтрацией через where. Для больших данных явные соединения через предикаты или ключи эффективнее вложенных циклов.

xml
(: 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>

Условия и квантификация

В XQuery есть if-then-else (else обязателен), квантифицированные выражения (some/every ... satisfies) и typeswitch для ветвления по типу узла. Условия используют булеву семантику XPath.

xml
(: 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"

Функции

XQuery переиспользует функции XPath и добавляет многие (string-join, distinct-values, avg, min, max). Пользовательские функции объявляются в модуле с типами параметров и возврата, по соглашению в пространстве имён local:.

xml
(: 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)

Построение XML

XQuery строит XML прямыми конструкторами (литеральные теги с { } для встроенных выражений) или вычисляемыми (element name { ... }). Фигурные скобки вычисляют вложенные выражения; атрибуты могут встраивать значения прямо.

xml
(: 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 -->
10

Разбор DOM

Загрузка XML (JavaScript)

DOMParser превращает строку XML в DOM-дерево в браузере; ошибки разбора появляются как элемент <parsererror>, а не исключение. В Node.js нет встроенного XML DOM — используйте xmldom, @xmldom/xmldom или потоковый парсер.

xml
// 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 instead

Обход DOM

DOM API даёт documentElement, children, childNodes и nextSibling для обхода. nodeType 1 — элемент, 3 — текст, 8 — комментарий. document.evaluate выполняет XPath в браузерах (Node требует библиотек xpath).

xml
// 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();

Изменение DOM

createElement/setAttribute/appendChild создают и присоединяют узлы; textContent задаёт текст. XMLSerializer превращает DOM обратно в строку. DOM живой: изменения сразу видны во всех ссылках.

xml
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);

Создание элементов

minidom позволяет строить документ с нуля: createDocument для корня, createElement/setAttribute/createTextNode для содержимого, appendChild для связывания. toprettyxml сериализует с отступами. minidom прост, но медленен на больших деревьях.

xml
// 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())

Разбор DOM в Java

DOM JAXP в Java загружает весь документ в память через DocumentBuilder. setNamespaceAware(true) сохраняет префиксы пространств имён. DOM удобен для произвольного доступа, но требователен к памяти на больших файлах — тогда предпочитайте StAX/SAX.

xml
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 — быстрая и функциональная привязка Python к libxml2. Поддерживает полный XPath, XSLT, валидацию (DTD/XSD/RelaxNG) и инкрементальный разбор. Его ElementPath (find/findall) — подмножество XPath; для полного XPath используйте xpath().

xml
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"))
11

Разбор SAX

Обработчик SAX (Python)

SAX событийный и потоковый: парсер вызывает startElement, characters и endElement по мере чтения, не строя полное дерево. Экономичен по памяти для огромных файлов. Состояние (например, текущий элемент) нужно отслеживать самостоятельно.

xml
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())

Методы событий SAX

Колбэки ContentHandler отмечают границы документа и элементов. characters() может разбить один текстовый узел на несколько вызовов — накапливайте в буфер. startPrefixMapping/endPrefixMapping сообщают объявления пространств имён.

xml
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

Отслеживание пути элементов (стеком) — стандартный способ знать своё положение при потоковом разборе. Буферизуйте вывод characters() и сбрасывайте его в endElement, так как characters может срабатывать несколько раз на текстовый узел.

xml
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)

SAX-парсер Java

SAX в Java наследует DefaultHandler. startElement получает URI пространства имён, локальное имя, квалифицированное имя и объект Attributes. characters(ch, start, len) даёт срез символов — буферизуйте его, так как текстовый узел может занимать несколько вызовов.

xml
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 против DOM

SAX передаёт события с постоянной памятью — идеально для огромных файлов и извлечения за один проход. DOM загружает всё дерево, позволяя XPath и произвольные изменения, но память пропорциональна размеру файла. Выбирайте по характеру доступа и размеру.

xml
<!-- 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 -->

Обработка ошибок (SAX)

ErrorHandler получает предупреждения, восстановимые и фатальные ошибки. По умолчанию фатальные ошибки бросают исключение и останавливают разбор. Реализация error() позволяет логировать некритичные проблемы валидации, не прерывая весь разбор.

xml
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")
12

StAX (pull-разбор)

Курсорный API StAX

StAX — pull-парсер: ваш код вытягивает следующее событие через next(), поэтому циклом управляете вы. Курсорный API (XMLStreamReader) движется по событиям по одному. Он быстрее и экономнее DOM и гибче push-модели SAX.

xml
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();

События XMLStreamReader

Типы событий включают START_ELEMENT, END_ELEMENT, CHARACTERS, COMMENT, PROCESSING_INSTRUCTION и START/END_DOCUMENT. getText() возвращает текущий текст; isWhiteSpace() отфильтровывает отступы. Курсор продвигается на одно событие за вызов next().

xml
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;
    }
}

Чтение элементов и атрибутов

getAttributeValue(namespaceURI, localName) читает атрибуты по имени (передайте null для отсутствия пространства имён). getElementText() удобно читает текст элемента только с текстом и проходит мимо его END_ELEMENT — чище ручной буферизации символов.

xml
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);
    }
}

Писатель StAX

XMLStreamWriter строит XML последовательно. writeStartDocument, writeStartElement/writeEndElement, writeAttribute, writeCharacters и writeNamespace должны быть сбалансированы. В конце вызовите flush/close, чтобы вывод был завершён.

xml
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 против SAX

SAX проталкивает события в ваш обработчик; StAX позволяет вытягивать события по требованию. Pull-модель StAX упрощает пропуск поддеревьев и управление состоянием, а также добавляет API писателя. Оба избегают полного DOM-дерева и подходят для больших документов.

xml
<!-- 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)

Итераторный API (XMLEventReader) возвращает объекты XMLEvent, которые можно просматривать и потреблять. Он объектнее курсорного API и удобнее для фильтрации и разбиения, но чуть тяжелее из-за создания объектов событий.

xml
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();
13

Конвертация XML и JSON

XML в JSON (JavaScript)

fast-xml-parser конвертирует XML в JSON в Node.js. Атрибуты получают префикс (по умолчанию @_), повторяющиеся элементы становятся массивами. Библиотека на чистом JavaScript и быстра, с опциями управления массивами, числами и boolean.

xml
// 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.99

JSON в XML (JavaScript)

XMLBuilder выполняет обратное преобразование. Префикс @_ помечает атрибуты, вложенные объекты становятся дочерними элементами. Массивы дают повторяющиеся элементы. Правило одного корня в XML означает, что верхний объект JSON должен отображаться в один корневой элемент.

xml
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>

Python xmltodict

xmltodict представляет XML структурами dict/list: атрибуты используют '@name', текст — '#text'. parse() читает XML, unparse() пишет. Отлично для быстрых круговых преобразований, но теряет порядок и некоторые крайние случаи сложных схем.

xml
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)

Атрибуты и текст

Конвертация XML в JSON требует решений по атрибутам (префикс @_), тексту (#text) и смешанному содержимому. Смешанное содержимое — текст вперемешку с дочерними элементами — не отображается в JSON чисто и часто теряет точность. Выберите соглашения и держитесь их.

xml
<!-- 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 -->

Сложности конвертации

Частые подводные камни: один или несколько детей (строка против массива), порядок элементов, префиксы пространств имён (которые суть псевдонимы), ограничение одного корня и примитивная типизация (в XML нет нативных чисел и boolean). Документируйте свои соглашения.

xml
<!-- 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 -->

Пример кругового преобразования

Круговое преобразование (XML -> JSON -> XML) работает для хорошо структурированных данных, но может потерять комментарии, инструкции обработки, границы CDATA и точные пробелы. Для редактирования без потерь используйте DOM/tree API, а не конвертацию в JSON.

xml
// 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);
14

Ленты RSS и Atom

Структура RSS 2.0

В RSS 2.0 корень <rss> с одним <channel>. Обязательные поля канала: title, link, description. У каждого <item> есть title, link, description, guid, pubDate. Даты следуют RFC 822 (например, 'Wed, 02 Oct 2024 13:00:00 GMT').

xml
<?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>

Канал и элементы RSS

Поля уровня канала описывают ленту (title, link, description, language, ttl, image). Поля элемента описывают запись; enclosure поддерживает подкасты и медиа с URL, длиной в байтах и MIME-типом. category может нести атрибут domain.

xml
<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>

Лента Atom

Atom (RFC 4287) использует корень <feed> в пространстве имён Atom. Обязательны: id, title, updated. Записям нужны id, title, updated. ID должны быть глобально уникальны (URN или tag: URI). Даты используют RFC 3339 (ISO 8601) с часовым поясом.

xml
<?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">&lt;p&gt;Full post body&lt;/p&gt;</content>
  </entry>
</feed>

Детали записи Atom

Записи Atom поддерживают богатое содержимое: текст, html или xhtml через атрибут type. link использует атрибуты rel (alternate, self, enclosure, related). category имеет term/scheme/label. published — исходная дата; updated — последнее изменение.

xml
<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>

Частые пространства имён лент

RSS часто расширяют модулями: Dublin Core (dc:creator, dc:date), content (content:encoded для полного HTML), Media RSS (media:content) и atom:link rel='self', помогающий читалкам найти URL ленты. Пространства имён позволяют лентам смешивать словари.

xml
<?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>

Валидация лент

Проверяйте RSS/Atom в W3C Feed Validator. Частые ошибки: отсутствие обязательных полей, неверные форматы дат, неуникальные ID, невалидный XML (неэкранированный &) и отсутствие self-ссылки. Валидные ленты обеспечивают надёжный разбор агрегаторами.

xml
<!-- 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 -->
15

SVG и XML

Структура документа SVG

SVG — словарь XML для векторной графики. Корень <svg> объявляет пространство имён SVG и viewBox для системы координат. Все графические элементы (rect, circle, text) — XML-элементы с атрибутами представления.

xml
<?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 -->

Пространство имён и импорты SVG

Элементы SVG живут в пространстве http://www.w3.org/2000/svg. xlink используется для ссылок href (в SVG 1.1); SVG 2 предпочитает обычный href. defs хранят переиспользуемые градиенты, шаблоны и символы, на которые ссылаются по id через url(#id).

xml
<?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>

Фигуры SVG

Элементы фигур SVG: rect (с rx/ry для скругления), circle, ellipse, line, polyline (открытая) и polygon (закрытая). Координаты в пользовательских единицах, заданных viewBox. stroke и fill — частые атрибуты представления.

xml
<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>

Текст и пути SVG

Текст SVG использует font-family, font-size, font-weight, font-style. tspan позволяет смешивать стили внутри элемента text. Атрибут 'd' элемента path использует команды: M (перемещение), L (линия), C (кубическая безье), Q (квадратичная), A (дуга), Z (замкнуть путь).

xml
<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 -->

Группировка и переиспользование SVG

Элемент <g> группирует фигуры для общих стилей и преобразований. <use> ссылается на элемент по id (href='#id' в SVG 2, xlink:href в 1.1) и клонирует его в новой позиции. <symbol> определяет переиспользуемую графику, отображаемую только через <use>.

xml
<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>

Валидация SVG

Документы SVG можно валидировать по DTD или XSD W3C. Частые проблемы: забытое пространство имён SVG, необъявленные префиксы, атрибуты не в том пространстве имён и некорректные данные path. xmllint — стандартный валидатор командной строки.

xml
<?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 -->
16

SOAP и WSDL

Конверт SOAP

Сообщение SOAP — XML-документ с корнем <Envelope> в пространстве имён SOAP. Необязательный <Header> несёт метаданные (аутентификация, маршрутизация); обязательный <Body> содержит полезную нагрузку. SOAP 1.1 и 1.2 используют разные пространства имён.

xml
<?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 -->

Заголовок SOAP

Заголовки несут внешнюю информацию: аутентификацию, адресацию (WS-Addressing) и транзакции. soap:mustUnderstand='1' говорит получателю, что он ОБЯЗАН обработать этот заголовок или вернуть SOAP fault, — это обеспечивает соблюдение контракта.

xml
<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 и Fault SOAP

Body несёт запрос или ответ. При ошибке Body содержит <Fault> с faultcode (Client/Server), человекочитаемым faultstring и необязательным detail. SOAP 1.2 переименовывает эти элементы и добавляет структуру Code/Reason.

xml
<!-- 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>

Структура WSDL

WSDL описывает веб-сервис: <types> (схемы XSD), <message> (входные и выходные payload), <portType> (интерфейс — операции и их сообщения), <binding> (протокол и кодирование) и <service> (URL endpoint). WSDL 2.0 упрощает это до интерфейсов и привязок.

xml
<?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 и service в WSDL

Binding отображает portType на конкретный протокол (SOAP поверх HTTP) и стиль (document/literal — современное умолчание). Элемент service перечисляет endpoint (soap:address). Document/literal оборачивает payload в элемент, определённый схемой.

xml
<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 против REST

SOAP — протокол со строгим XML-конвертом, контрактом WSDL и стандартами WS-* (безопасность, транзакции); лучший выбор для корпоративных интеграций, где нужны надёжность и формальные контракты. REST — лёгкий стиль на HTTP, обычно с JSON, доминирующий в публичных API.

xml
<!-- 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 -->
17

Цифровая подпись XML

Структура подписи

Корень <Signature> подписи XML содержит <SignedInfo> (что и как подписано), <SignatureValue> (криптографическую подпись над канонизированным SignedInfo), необязательный <KeyInfo> и <Object> с данными, на которые есть ссылки.

xml
<?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 задаёт канонизацию (чтобы побайтово идентичная подпись пережила повторную сериализацию XML), алгоритм подписи и одну или несколько References. Каждая Reference указывает на данные через URI, перечисляет Transforms и даёт DigestValue этих данных.

xml
<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 и transforms

Каждая Reference определяет, что подписывать (URI), применяет Transforms (канонизация, XPath-фильтрация, удаление enveloped-signature), затем хеширует через DigestMethod. Преобразование enveloped-signature исключает сам элемент Signature из его собственного дайджеста.

xml
<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 и KeyInfo

SignatureValue — base64-результат подписи канонизированного SignedInfo приватным ключом подписанта. KeyInfo НЕОБЯЗАТЕЛЕН и лишь подсказывает, как найти ключ проверки (сертификат X.509, публичный ключ RSA, имя ключа или URL получения), — его нужно проверять по независимому каналу.

xml
<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 -->

Канонизация

Канонизация превращает набор XML-узлов в стабильные байты, чтобы подпись воспроизводилась несмотря на незначимые различия (порядок атрибутов, CDATA). Для подписей предпочтительна эксклюзивная c14n (xml-exc-c14n): она ограничивает пространства имён подписанным поддеревом.

xml
<!-- 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. -->

Enveloped-подпись

Enveloped-подпись встраивается в документ, который подписывает (самый частый случай для XML). Преобразование enveloped-signature удаляет элемент <Signature> перед хешированием, чтобы подпись не входила в свой же дайджест. Существуют также detached и enveloping варианты.

xml
<?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 -->
19

Соглашения об именовании

Именование элементов

Выберите стиль и применяйте последовательно. Нижний регистр с дефисами обычен для словарей XML (HTML, SVG). Имена должны быть достаточно описательными, чтобы быть однозначными, но краткими. Избегайте загадочных сокращений и излишне длинных имён.

xml
<!-- 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 -->

Именование атрибутов

Атрибуты подходят для метаданных (id, type, href, status). Согласуйте их с стилем элементов. Булевы несут явные значения. Не добавляйте к атрибуту имя его элемента (user-id на <user> избыточен). Для уникальных идентификаторов используйте 'id'.

xml
<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 -->

URI и префиксы пространств имён

URI пространств имён — идентификаторы, а не загружаемые URL, но они должны быть стабильными и принадлежать вам (используйте HTTPS на своём домене). Префиксы — локальные псевдонимы: держите их короткими и обычными. Версионируйте URI при несовместимом изменении схемы.

xml
<!-- 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 -->

Стили регистра

Частые стили регистра в XML: PascalCase (XSD/WSDL, .NET), camelCase (из JSON, Java), нижний регистр с дефисами (HTML/SVG, дружелюбен к REST), snake_case (редко). Главное правило — последовательность внутри словаря: смешение стилей путает.

xml
<!-- 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>

Версионирование

Версионируйте словари XML явно: атрибут version на корне проще всего; версионированный URI пространства имён строже всего (несовместимые изменения получают новый URI). Решите, что считается минорным (аддитивным) и мажорным (ломающим) изменением, и документируйте это.

xml
<!-- 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" -->

Соглашения о файлах и расширениях

Используйте признанные расширения, чтобы инструменты и люди определяли типы файлов. Атрибут encoding в XML-объявлении должен соответствовать фактической байтовой кодировке; UTF-8 — безопасное умолчание. BOM для UTF-8 XML не рекомендуется.

xml
<!-- 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"?> -->
20

Лучшие практики

Сначала корректность

Документ должен быть корректным, прежде чем его обработает любой инструмент. Проверяйте парсером рано: xmllint --noout file.xml сообщает первую ошибку. Корректность обязательна; валидность по схеме — дополнительный, необязательный слой.

xml
<?xml version="1.0" encoding="UTF-8"?>
<root>
  <child>properly nested &amp; 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 -->

Валидация и схемы

Валидируйте по схеме, чтобы ловить структурные ошибки. XSD — самый частый выбор для типизированных словарей с пространствами имён; Schematron дополняет его бизнес-правилами. xsi:noNamespaceSchemaLocation связывает документ с его XSD; для схем с пространствами имён используйте xsi:schemaLocation.

xml
<!-- 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. -->

Кодировка (UTF-8)

UTF-8 — кодировка по умолчанию и рекомендуемая для XML: она покрывает весь Unicode без сущностей. Всегда объявляйте кодировку и сохраняйте файл в ней. Избегайте BOM; для спецсимволов можно также использовать числовые ссылки на символы.

xml
<?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. -->

Читаемость и отступы

Последовательные отступы (обычно 2 пробела) делают XML читаемым, а диффы — чистыми. Избегайте длинных однострочных записей. Инструменты вроде 'xmllint --format' или форматтер XML нормализуют пробелы, но области xml:space='preserve' переформатировать нельзя.

xml
<?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. -->

Производительность

Для больших файлов предпочитайте потоковые парсеры (SAX/StAX) DOM, чтобы экономить память. Отключайте загрузку DTD и внешние сущности, если они не нужны. Компилируйте XPath-выражения один раз и переиспользуйте. Для внутренних систем рассмотрите компактные бинарные форматы, снижающие размер и время разбора.

xml
<!-- 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 -->

Безопасность (XXE)

Атаки XML External Entity (XXE) злоупотребляют внешними сущностями DTD для чтения файлов, SSRF и отказа в обслуживании (billion laughs, раздувание сущностей). Самая сильная защита — полностью отключить DTD и разрешение внешних сущностей, если ваш сценарий их не требует.

xml
<?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) -->

Was this helpful?

Learning path

Learn from scratch

Learn this language from the ground up with structured lessons.