В предыдущей главе был представлен обзор XSLT. В этой главе мы начинаем детальную работу с ним. Мы собираемся научиться рассматривать документы в терминах XSLT, структурировать таблицу стилей XSLT и встраивать в документы таблицы стилей, В этой главе будет дано введение в шаблоны таблиц стилей, которые образуют основу таблиц стилей XSLT. Шаблоны реализуют фактические правила, которые вам требуется применить к данным; более подробно мы рассмотрим их в следующей главе.
Глава открывается систематическим рассмотрением таблиц стилей, и, несомненно, начинать следует с представления документа XML с точки зрения таблицы стилей.
При работе с XSLT следует перестать мыслить в терминах документов и начать — в терминах деревьев. Дерево представляет данные в документе в виде множества узлов — элементы, атрибуты, комментарии и т.д. трактуются как узлы — в иерархии, и в XSLT структура дерева соответствует рекомендации XPath W3C (www.w3.org/TR/xpath). В данной главе мы рассмотрим деревья и узлы концептуально, а в главах 3 и 4 я дам формальное введение в XPath и его связь с XSLT. Выражения XPath, записываемые в терминах деревьев и узлов, используются для поиска данных в XML-документах.
В действительности, в соответствии с рекомендацией XSLT процессоры XSLT не обязаны уметь работать с документами; формально XSLT-преобразования принимают в качестве ввода исходное дерево и производят в качестве вывода результирующее дерево. В большинстве процессоров, тем не менее, существует дополнительная поддержка работы с документами.
Таким образом, с точки зрения XSLT документы представляют собой образованные из узлов деревья; XSLT распознает семь типов узлов:
• Корневой узел. Это самое начало документа. Этот узел представляет для процессора XSLT весь документ. Важно: не путайте корневой узел с корневым элементом, который также называется элементом документа (подробнее об этом мы поговорим позже в этой главе);
• Узел атрибута. Содержит значение атрибута после того, как были раскрыты ссылки на сущности и отброшены окружающие символы-разделители;
• Узел комментария. Содержит текст комментария, не содержащий символов
>• Узел элемента. Состоит из части документа, заключенной в открывающий и соответствующий ему завершающий теги, или единственный пустой элемент-тег, например
• Узел пространства имен. Представляет объявление пространства имен. Обратите внимание: этот узел добавляется к каждому элементу, к которому применяется это пространство имен;
• Узел инструкции обработки. Содержит текст инструкции обработки, не содержащий символов
?>• Текстовый узел. Текстовые узлы содержат последовательности символов, То есть текст PCDATA. Текстовые узлы по умолчанию в XSLT подвергаются нормализации, то есть смежные текстовые узлы объединяются.
Как мы увидим в главе 7, для работы с деревьями и узлами используются выражения XPath. Выражение XPath возвращает единственный удовлетворяющий выражению узел, или множество узлов, если таких узлов несколько. XPath проектировался как средство навигации по деревьям — и, разобравшись с XPath, вы разберетесь с большей частью XSLT.
Важно помнить следующее: корневой узел дерева XSLT представляет весь документ. Это не то же самое, что корневой элемент. Взгляните, например, на следующий документ — в терминах XSLT корневой узел представляет документ целиком, а корневым элементом является
</code></pre></p>
<p><pre><code> Earthquakes for Lunch</code></pre></p>
<p><pre><code> </code></pre></p>
<p><pre><code> Volcanoes for Dinner</code></pre></p>
<p><pre><code> Термин корневой элемент (root element) пришёл из рекомендации XML, и, поскольку его легко спутать с корневым узлом (root node) XSLT, пришедшим из рекомендации XPath, некоторые авторы, пишущие на тему XSLT, называют корневой элемент элементом документа. Очень жаль, что существует такое перекрытие терминов.
Вам следует также знать, что процессоры XSLT нормализуют текстовые узлы дерева, то есть объединяют два соседних текстовых узла в один большой текстовый узел для упрощения работы со структурой дерева документа. Поэтому, например, между двумя смежными узлами элементов никогда не будет более одного текстового узла, если изначально между этими узлами элементов располагался только текст.
В XSLT узлы могут иметь имена — так же, как дочерние узлы (child node) и родительские узлы (parent node). Иными словами, узлы элементов, атрибутов, пространств имен и инструкций обработки могут иметь имена; каждый узел элемента и корневой узел могут иметь дочерние узлы; и все узлы, за исключением корневого, имеют родителей.
Например, вот как выглядит рассмотренный нами ранее XML-документ в процессоре XSLT в виде дерева, состоящего из узлов:
root | element: | element: | |-------------------------------| | | element: element: <title></code></pre></p>
<p><pre><code> | |</code></pre></p>
<p><pre><code>text: "Earthquakes for Lunch" text: "Volcanoes for Dinner"</code></pre></p>
<p>Как видим, корневой узел расположен на самом верху дерева, за которым следует узел корневого элемента, ему соответствует элемент <pre><code><library></code></pre>. За ним следует узел <pre><code><book></code></pre>, у которого есть два дочерних узла <pre><code><title></code></pre>. Эти два узла <pre><code><title></code></pre> являются внуками элемента <pre><code><library></code></pre>. Родители, дедушки и прадедушки узла, назад до и включая корневой узел, являются<i> предками</i> (ancestor) элемента. Узлы, производные от узла (дети, внуки, правнуки и т.д.), называются его<i> потомками </i>(descendant). Узлы одного уровня называются<i> братьями</i> (sibling).</p>
<p>При помощи этой модели в виде дерева можно представить любой хорошо сформированный XML-документ. Но XSLT не ограничивается работой только с такими документами. В хорошо сформированных документах должен существовать один элемент, содержащий все остальные, но в соответствии с рекомендацией XSLT это не обязательно. В XSLT корневой узел может иметь столько детей, сколько их может иметь элемент, — например, несколько узлов элементов или текстовых узлов. Таким образом, XSLT может работать с фрагментами документа, а не только с хорошо сформированными документами.</p>
<div class='cite'>
<p>ФРАГМЕНТЫ РЕЗУЛЬТИРУЮЩЕГО ДЕРЕВА </p>
<p>Помимо работы с фрагментами входного дерева, процессоры могут включать в вывод специальный тип данных, в XSLT 1.0 называемый фрагментом результирующего дерева (result tree fragment). Этот тип данных, однако, не был включен в рабочий проект XSLT 1.1 (см. главу 7), поэтому он, скорее всего, не будет входить в состав XSLT 2.0.</p>
</div>
<p>В действительности, рассмотренная только что диаграмма дерева не дает полной картины того, как она выглядит с точки зрения процессора XSLT. Я исключил один тип узлов, который вызывает большую путаницу при изучении XSLT — текстовые узлы, содержащие только символ-разделитель (whitespace). Теперь самое время заняться ими.</p>
</section>
<section>
<h3 id='46'>
<span>Символ-разделитель</span>
</h3>
<p>Пример XML-документа, с которым мы до сих пор работали, выровнен так, чтобы показать иерархическую структуру его элементов:</p>
<p><pre><code><?xml version="1.0"?></code></pre></p>
<p><pre><code> <library></code></pre></p>
<p><pre><code> <book></code></pre></p>
<p><pre><code> <title></code></pre></p>
<p><pre><code> Earthquakes for Lunch</code></pre></p>
<p><pre><code> </code></pre></p>
<p><pre><code> Volcanoes for Dinner</code></pre></p>
<p><pre><code> Однако, с точки зрения XSLT, символы-разделители, используемые для выравнивания элементов, в действительности являются текстовыми узлами. Это означает, что по умолчанию эти пробелы будут скопированы в выходной документ. Понимание принципов работы XSLT с разделителями всегда вызывает большую путаницу, поэтому мы кратко рассмотрим здесь, как обрабатывать символы-разделители, и подробно займемся этим в следующей главе.
В XSLT существует четыре символа-разделителя: пробел, возврат каретки, перевод строки и табуляция. Все эти символы трактуются как разделители. Таким образом, с точки зрения процессора XSLT, входной документ выглядит так:
...</code></pre></p>
<p><pre><code>...Earthquakes for Lunch</code></pre></p>
<p><pre><code>.. ..</code></pre></p>
<p><pre><code>...Volcanoes for Dinner</code></pre></p>
<p><pre><code>.. .Все разделители между элементами трактуются в XSLT как текстовые узлы, содержащие символ-разделитель. Это означает, что в нашу диаграмму нам нужно добавить пять текстовых узлов с символом-разделителем: один перед элементом
</code></pre>, один после и один между элементами:</p>
<p><pre><code> root</code></pre></p>
<p><pre><code> |</code></pre></p>
<p><pre><code> element: <library></code></pre></p>
<p><pre><code> |</code></pre></p>
<p><pre><code> |-------------------|------------|</code></pre></p>
<p><pre><code> | | |</code></pre></p>
<p><pre><code> text: whitespace element: <book> text: whitespace</code></pre></p>
<p><pre><code> |</code></pre></p>
<p><pre><code> |-------------------|-------------|-------------------|-------------|</code></pre></p>
<p><pre><code> | | | | |</code></pre></p>
<p><pre><code>text: whitespace element: <title> text: whitespace element: <title> text: whitespace</code></pre></p>
<p><pre><code> | |</code></pre></p>
<p><pre><code> text: "Earthquakes for Lunch" text: "Volcanoes for Dinner"</code></pre></p>
<p>Такие узлы-разделители, как эти, представляют собой текстовые узлы, не содержащие ничего, кроме символа-разделителя. Поскольку процессоры XSLT по умолчанию сохраняют эти разделители, вас не должно удивлять их появление в результирующих документах. Такие дополнительные разделители обычно не представляют проблемы в документах HTML, XML и XHTML, и здесь в тексте результирующих документов я их не отображаю — для того, чтобы правильно показать выравниванием структуру документа. Мы рассмотрим, как процессоры XSLT могут удалять узлы-разделители из документов, а также как процессоры могут выравнивать результирующие документы. Заметьте, что текстовые узлы, содержащие символы, отличные от символов-разделителей, не считаются узлами-разделителями, поэтому они никогда не будут удалены из документов.</p>
<p>Следует отметить еще один момент: сами атрибуты трактуются как узлы. Хотя узлы-атрибуты не считаются дочерними узлами тех элементов, в которых они появляются, элемент считается их родительским узлом. (В этом отличие данной модели от модели XML DOM, в которой атрибуты не являются детьми и не имеют родителей.) Если я добавлю атрибут в такой элемент:</p>
<p><pre><code><?xml version="1.0"?></code></pre></p>
<p><pre><code><library></code></pre></p>
<p><pre><code> <book></code></pre></p>
<p><pre><code> <title></code></pre></p>
<p><pre><code> Earthquakes for Lunch</code></pre></p>
<p><pre><code> </code></pre></p>
<p><pre><code> Volcanoes for Dinner</code></pre></p>
<p><pre><code> то в дереве документа он отобразится следующим образом:
root | element: | |-------------------|------------| | | | text: whitespace element: text: whitespace | |-------------------|-------------|-------------------|-------------| | | | | |text: whitespace element: text: whitespace element: <title> text: whitespace</code></pre></p>
<p><pre><code> | |</code></pre></p>
<p><pre><code> text: Earthquakes for Lunch |--------------------------|</code></pre></p>
<p><pre><code> | |</code></pre></p>
<p><pre><code> text: Volcanoes for Dinner attribute: pub_date="2001"</code></pre></p>
<p>У каждого узла есть ряд установленных свойств, связанных с ним в XSLT. В следующем списке перечислены виды свойств, которые создатели процессоров XSLT отслеживают для каждого узла:</p>
<p>• <b>Имя</b>. Имя узла;</p>
<p><b>• Строка-значение</b>. Текст узла;</p>
<p>• <b>Базовый URI</b>. Базовый URI узла (XML-вариант URL);</p>
<p>• <b>Дети</b>. Список дочерних узлов; ноль, если детей нет;</p>
<p>• <b>Родитель</b>. Узел-родитель данного узла;</p>
<p>• <b>Имеет атрибут</b>. Определяет атрибуты узла элемента, если таковые имеются;</p>
<p>• <b>Имеет пространство имен</b>. Определяет узлы пространства имен узла-элемента.</p>
<p>При работе с деревьями следует принять во внимание еще одно соображение; процессоры XSLT работают поверх разборщиков XML, и так как правила для разборщиков XML и процессоров XSLT слегка различаются, это может привести к проблемам. В некоторых случаях данный аспект может быть важен, поэтому в следующем разделе он кратко рассмотрен.</p>
</section>
</section>
<section>
<h3 id='47'>
<span>Модель информационного множества против модели дерева XSLT</span>
</h2>
<p>Разборщики XML передают только определенную информацию: как задается основной спецификацией информационного множества (Information Set) XML — которую можно найти по адресу www.w3.org/TR/xml-infoset, в то время как процессоры XSLT придерживаются модели дерева XSLT. Эти модели, а также элементы, считающиеся в них важными, различны, что может привести к проблемам.</p>
<p>Вот, например, два элемента XML, входящие в основное информационное множество, но невозможные в XSLT: примечания и пропущенные ссылки на сущности (ссылки на сущности, которые разборщик XML предпочел не раскрывать). На практике это означает, что даже если разборщик XML передал информацию для этих пунктов, процессор XSLT ничего не сможет с ней сделать. Однако примечания используются редко, и только отдельные разборщики XML генерируют пропущенные ссылки на сущности, поэтому это не является значимой проблемой.</p>
<p>С другой стороны, разборщики XML <i>могут</i> удалить из XML-документов комментарии, о чем вам следует знать, так как в модели XSLT комментарии включаются. </p>
<p>Кроме того, информация об объявлениях DTD <i>не</i> передается от разборщика XML в процессор XSLT (возможно, потому, что W3C планирует более широко использовать схемы XML в XSLT 2.0, хотя пока еще нет официального механизма связывания схем XML с документами XML). Как правило, это не образует проблемы, поскольку проверка документа XML входит в задачи разборщика XML, за исключением одного случая: когда атрибут объявлен с типом ID. В XML с типом ID можно объявить атрибут с любым именем, поэтому процессор XSLT не знает, какие атрибуты принадлежат к этому типу, если только у процессора нет доступа к DTD. Это важно при использовании таблиц стилей, встроенных в документы XML, поскольку в этом случае процессор XSLT должен быть способен распознать, в каком элементе документа содержится таблица стилей, нужная для преобразования документа. В этом случае некоторые процессоры XSLT, например, Saxon, идут дальше рекомендации XSLT и проверяют DTD, если они есть, чтобы узнать, какие атрибуты принадлежат к типу ID.</p>
<p>Еще несколько моментов могут представлять для вас интерес. Например, модель обработки XSLT открывает доступ к префиксам пространств имен во входном дереве, но предоставляет очень небольшие возможности управления ими в выходном дереве, где они обрабатываются автоматически. К тому же, в модели обработки XSLT для каждого узла в дереве определяется базовый URI, представляющий собой URI внешней сущности, от которой был произведен узел. (В рабочем проекте XSLT 1.1 эти возможности были расширены для поддержки спецификации XML Base, как вы увидите ближе к концу этой главы.) Однако в информационном множестве XML базовые URI считаются второстепенными, а это означает, что разборщик XML может не передать эту информацию в процессор XSL.</p>
<p>В общем, вам следует знать, что процессоры XSLT читают документы XML при помощи разборщиков XML, и что совместная работа этих программных единиц не бесшовна. Если вы обнаружите, что некоторая необходимая информация при преобразовании XSLT пропала, следует вспомнить этот момент. Фактически различие между информационным множеством XML и моделью дерева XSLT — это одна из проблем, которую призван исправить XSLT 2.0. Помимо прочего, в XSLT 2.0 должно быть проще восстанавливать ID и ключевую информацию из исходного документа, а также восстанавливать информацию из объявления XML исходного документа — например, версию XML и кодировку.</p>
</section>
<section>
<h3 id='48'>
<span>Работа с элементами XSLT</span>
</h2>
<p>Для того чтобы создавать таблицы стилей XSLT, вы должны хорошо знать элементы XSLT, такие как <pre><code><xsl:template></code></pre> и <pre><code><xsl:stylesheet></code></pre>. Эти элементы поддерживают большое число атрибутов, и W3C выработал ряд формальных определений типов данных, которые можно присваивать этим атрибутам. Вот ряд определений XSLT; их необходимо знать:</p>
<p>• <pre><code>NCNameChar</code></pre>. Буква, цифра, точка, дефис или символ подчеркивания;</p>
<p>• <pre><code>NCName</code></pre>. Буква или символ подчеркивания, за которым (не обязательно) следуют данные типа <pre><code>NCNameChars</code></pre>. То есть это имя XML, не содержащее двоеточий (определение имен XML приводится в главе 1); </p>
<p>• <pre><code>QName</code></pre>. Полностью определенное (qualified) имя. Оно формируется из префикса (должен принадлежать к типу <pre><code>NCName</code></pre>), за которым следуют двоеточие и локальная часть (которая также должна быть типа <pre><code>NCName</code></pre>);</p>
<p>• <pre><code>NameTest</code></pre>. Имя (например, «book») или обобщенное имя с символами подстановки (как, например, «book*» или «*»).</p>
<p>Теперь можно начать создавать таблицы стилей XSLT. Первым элементом будет элемент для связывания таблиц стилей с документами XML <pre><code><?xsl:stylesheet?></code></pre>.</p>
</section>
<section>
<h3 id='49'>
<span>Инструкция обработки <?xsl:stylesheet?></span>
</h2>
<p>Когда у нас есть таблица стилей XSL, которую нужно применить к документу XML, требуется каким-то образом связать эту таблицу стилей с документом, — для чего часто используется инструкция обработки <pre><code><?xsl:stylesheet?></code></pre>. У этой инструкции есть несколько возможных атрибутов:</p>
<p>• <pre><code>href</code></pre> (обязательный). URI таблицы стилей. Может быть полный URI, либо фрагмент из <pre><code>#new_style</code></pre>. Устанавливается в URI;</p>
<p>• <pre><code>type</code></pre> (обязательный). Тип MIME таблицы стилей. Обычно «text/xml» или «application/xml». Для Internet Explorer используйте «text/xsl». Устанавливается в допустимый тип MIME;</p>
<p>• <pre><code>title</code></pre> (необязательный). Заголовок позволяет различить несколько различных элементов <pre><code><?xsl:stylesheet?></code></pre>. Некоторые разборщики XML позволяют задать, какой из них использовать. Устанавливается в строковое значение;</p>
<p>• <pre><code>media</code></pre> (необязательный). Описание средств вывода, например «print» или «aural» (звуковой). Устанавливается в одно из значений, перечисленных в спецификации W3C HTML 4.0;</p>
<p>• <pre><code>charset</code></pre> (необязательный). Устанавливает кодировку символов. Заметьте, что таблицы стилей XSLT устанавливают свои собственные кодировки, поскольку они являются документами XML, так что практической пользы этот атрибут не имеет. Устанавливается в кодировку символов — например в «UTF-8»;</p>
<p>• <pre><code>alternate</code></pre> (необязательный). Принимает либо значение «yes» (да), которое является признаком альтернативной таблицы стилей, либо «no» (нет), означающее предпочитаемую таблицу стилей.</p>
<p>Инструкция обработки <pre><code><?xsl:stylesheet?></code></pre> добавляется в документ XML, а не в таблицу стилей, и указывает процессору XSLT, какую таблицу стилей применять к данному документу.</p>
<p>На практике <pre><code><?xsl:stylesheet?></code></pre> используется главным образом с браузерами, поскольку для отдельных процессоров таблица стилей, как правило, задается непосредственно — как, например, при использовании процессора XSLT Oracle:</p>
<p><pre><code>C:\planets>java oracle.xml.parser.v2.oraxsl planets.xml planets.xsi planets.html</code></pre> </p>
<p>Возможно, вас это удивит, но <pre><code><?xsl:stylesheet?></code></pre> не является частью рекомендации XSLT. У этой инструкции обработки существует своя собственная рекомендация только для нее одной, которую можно найти по адресу www.w3c.org/TR/xml-stylesheet. Помимо прочего, это означает, что процессоры XSLT не обязаны поддерживать данную инструкцию обработки, и большинство отдельных процессоров не поддерживают ее.</p>
<p>Ниже приведен пример. В главе 1 мы рассмотрели файл <pre><code>planets.xml</code></pre> — хорошо сформированный документ XML, содержащий данные о трех планетах: Меркурии, Венере и Земле. Можно применить инструкцию обработки <pre><code><?xml-stylesheet?></code></pre> к <pre><code>planets.xml</code></pre> для задания используемой таблицы стилей XSLT. В инструкции следует установить тип атрибута в «text/xml» (W3C также позволяет «application/xml», a Internet Explorer требует «text/xsl») и атрибут href — в URI таблицы стилей XSLT, например <pre><code>planets.xsl</code></pre>:</p>
<div class='subtitle'>Листинг 2.1. planets.xml</div>
<p><pre><code><?xml version="1.0"?></code></pre></p>
<p><pre><code><b><?xml-stylesheet type="text/xml" href="planets.xsl"?></b></code></pre></p>
<p><pre><code><PLANETS></code></pre></p>
<p><pre><code> <PLANET></code></pre></p>
<p><pre><code> <NAME>Mercury</NAME></code></pre></p>
<p><pre><code> <MASS UNITS="(Earth = 1)">.0553</MASS></code></pre></p>
<p><pre><code> <DAY UNITS="days">58.65</DAY></code></pre></p>
<p><pre><code> <RADIUS UNITS="miles">1516</RADIUS></code></pre></p>
<p><pre><code> <DENSITY UNITS="(Earth = 1)">.983</DENSITY></code></pre></p>
<p><pre><code> <DISTANCE UNITS="million miles">43.4</DISTANCE><!--B перигелии--></code></pre></p>
<p><pre><code> </PLANET></code></pre></p>
<p><pre><code> <PLANET></code></pre></p>
<p><pre><code> <NAME>Venus</NAME></code></pre></p>
<p><pre><code> <MASS UNITS="(Earth = 1)">.815</MASS></code></pre></p>
<p><pre><code> <DAY UNITS="days">116.75</DAY></code></pre></p>
<p><pre><code> <RADIUS UNITS="miles">3716</RADIUS></code></pre></p>
<p><pre><code> <DENSITY UNITS="(Earth = 1)">.943</DENSITY></code></pre></p>
<p><pre><code> <DISTANCE UNITS="million miles">66.8</DISTANCE><!--B перигелии--></code></pre></p>
<p><pre><code> </PLANET></code></pre></p>
<p><pre><code> <PLANET></code></pre></p>
<p><pre><code> <NAME>Earth</NAME></code></pre></p>
<p><pre><code> <MASS UNITS="(Earth = 1)">1</MASS></code></pre></p>
<p><pre><code> <DAY UNITS="days">1</DAY></code></pre></p>
<p><pre><code> <RADIUS UNITS="miles">2107</RADIUS></code></pre></p>
<p><pre><code> <DENSITY UNITS="(Earth = 1)">1</DENSITY></code></pre></p>
<p><pre><code> <DISTANCE UNITS="million miles">128.4</DISTANCE><!--B перигелии--></code></pre></p>
<p><pre><code> </PLANET></code></pre></p>
<p><pre><code></PLANETS></code></pre></p>
<p>Вот как следует работать с элементом <pre><code><?xml-stylesheet?></code></pre>; теперь можно начинать писать саму таблицу стилей. Я сделаю это, создав файл <pre><code>planets.xsl</code></pre>.</p>
</section>
<section>
<h3 id='50'>
<span>Элемент <xsl:stylesheet></span>
</h2>
<section>
<p>Таблицы стилей XSL начинаются с объявления XML, так как они являются хорошо сформированными документами XML, — поэтому <pre><code>planets.xsl</code></pre> начинается с такого же объявления:</p>
<p><pre><code><?xml version="1.0"?></code></pre></p>
<p><pre><code>.</code></pre></p>
<p><pre><code>.</code></pre></p>
<p><pre><code>.</code></pre></p>
<p>Однако объявление XML немедленно исключается процессором XSLT, и мы не будем на нем останавливаться в нашем обсуждении XSLT. Первый только XSL-элемент таблицы стилей XSL — это элемент <pre><code><xsl:stylesheet></code></pre> (не путайте его с инструкцией обработки <pre><code><?xml-stylesheet?></code></pre> из XML документа). Встречались и возражения против такого названия элемента: обычно он используется в преобразованиях XSLT, поэтому W3C позволяет в то же время ссылаться на этот элемент как на <pre><code><xsl:transform></code></pre>.</p>
<p>Вот пример использования этого элемента:</p>
<p><pre><code><?xml version="1.0"?></code></pre></p>
<p><pre><code><b><xsl:stylesheet version="1.0"</b></code></pre></p>
<p><pre><code><b> xmlns:xsl="http://www.w3.org/1999/XSL/Transform"></b></code></pre></p>
<p><pre><code> .</code></pre></p>
<p><pre><code> .</code></pre></p>
<p><pre><code> .</code></pre></p>
<p>В следующем списке перечислены атрибуты элемента <pre><code><xsl:stylesheet></code></pre>:</p>
<p>• <pre><code>id</code></pre> (необязательный). Идентифицирует таблицу стилей. Устанавливается в имя XML;</p>
<p>• <pre><code>version</code></pre> (обязательный). Определяет версию XSLT, необходимую для работы с таблицей стилей. Сейчас это значение обычно равно «1.0». Хотя можно установить это значение и в «1.1»; так как XSLT 1.1 не выйдет из стадии рабочего проекта, это значение, вероятно, не будет «корректным» значением с точки зрения W3C;</p>
<p>• <pre><code>extension-element-prefixes</code></pre> (необязательный). Задает расширения в таблице стилей, используемые для идентификации элементов расширения. Принимает значение списка имен <pre><code>NCName</code></pre>, разделенных символами-разделителями;</p>
<p>• <pre><code>exclude-result-prefixes</code></pre> (необязательный). Задает пространства имен таблицы стилей, которые не будут копироваться в выходные данные (если только они явно не используются в выходном документе). Принимает значение списка имен NCName, разделенных символами-разделителями.</p>
<p>Содержимое этого элемента может содержать любой из следующих элементов XSL высокого уровня: <pre><code><xsl:attribute-set></code></pre>, <pre><code><xsl:decimal-format></code></pre>, <pre><code><xsl:import></code></pre>, <pre><code><xsl:include></code></pre>, <pre><code><xsl:key></code></pre>, <pre><code><xsl:namespace-alias></code></pre>, <pre><code><xsl:output></code></pre>, <pre><code><xsl:param></code></pre>, <pre><code><xsl:preserve-space></code></pre>, <pre><code><xsl:strip-space></code></pre>, <pre><code><xsl:template></code></pre> или <pre><code><xsl:variable></code></pre>. XSLT добавляет к списку <pre><code><xsl:script></code></pre>.</p>
<p>Заметьте, что атрибут <pre><code>id</code></pre> этого элемента можно использовать в том случае, когда требуется сослаться на определенную таблицу стилей (заметьте также, что в этом случае необходим процессор XSLT, который умеет читать объявления DTD или схемы XML).</p>
<p>Атрибут задания версии обязателен, в данный момент его можно установить в «1.0». Можно также установить его в «1.1», определяя рабочий проект XSLT 1.1; однако, так как XSLT 1.1 не собирается выходить из стадии рабочего проекта, значение «1.1», скорее всего, не будет считаться корректным значением этого атрибута в долгосрочной перспективе. Везде в книге я буду устанавливать этот атрибут в значение «1.0», поскольку это текущая рекомендация XSLT W3C, а версия 1.1, видимо, останется только на стадии рабочего проекта. Как говорилось в главе 1, W3C также выпустил требования для XSLT 2.0, которая и будет следующей версией.</p>
<div class='cite'>
<p>ПРОЦЕССОРЫ XSLT И СОВМЕСТИМОСТЬ ВПЕРЕД </p>
<p>Если процессор XSLT не распознает версию XSLT, то, в соответствии с утверждениями W3C, процессор должен считать, что все новые элементы входят в новую версию XSLT, и не завершать работу, — это W3C называет совместимостью вперед (forward compatibility). Все нераспознанные элементы не должны отвергаться процессором, если только таблица стилей не попытается создать экземпляр этого элемента и не найдет дочернего элемента <xsl:fallback> (см. главу 5). Таким образом, вы можете установить версию XSLT в 2.0 даже в процессорах XSLT, написанных для XSLT 1.0, и это не приведет к проблемам, если вы не будете использовать возможности, существующие только в XSLT 2.0. (Исключением является MSXML3, который в данный момент генерирует ошибки, если установить значение версии, отличное от 1.0.)</p>
</div>
</section>
<section>
<h3 id='51'>
<span>Пространство имен XSL</span>
</h3>
<p>Заметьте, что элементы XSLT, такие как <pre><code><xsl:stylesheet></code></pre>, используют префикс пространства имен (namespace) <pre><code>xsl</code></pre>, который теперь, после стандартизации XSLT, всегда установлен в «http://www.w3.org/1999/XSL/Transform». Это пространство имен обычно устанавливается с атрибутом <pre><code>xmlns</code></pre> (это не атрибут XSL, а, скорее, атрибут любого элемента XML) в корневом элементе таблицы стилей, <pre><code><xsl:stylesheet></code></pre>:</p>
<p><pre><code><xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform"></code></pre></p>
<p><pre><code> .</code></pre></p>
<p><pre><code> .</code></pre></p>
<p><pre><code> .</code></pre></p>
<p>Таблицы стилей XSL используют свое собственное пространство имен, чтобы избежать конфликта с другими используемыми в таблице элементами. Например, вам может потребоваться указать, какая таблица стилей использовалась для преобразования документа; в таком случае вы можете создать свой собственный элемент <pre><code><stylesheet></code></pre> — это не создает проблемы, поскольку новый элемент не будет конфликтовать с элементом XSL <pre><code><xsl:stylesheet></code></pre>.</p>
<p>В таблицах стилей для элементов XSLT обычно используется префикс пространства имен <pre><code>xsl</code></pre>. Формально можно использовать для элементов XSLT любой префикс пространства имен (или даже вообще никакого), но практически повсюду применяется <pre><code>xsl</code></pre>, поскольку это пространство имен фигурирует в рекомендации XSLT.</p>
<p>На практике это означает, что все элементы XSLT, с которыми мы станем работать, будут начинаться с префикса пространства имен xsl, как в <pre><code><xsl:stylesheet></code></pre>. Следовательно, надо начинать таблицу стилей XSLT с элемента <pre><code><xsl:stylesheet></code></pre>. (Есть одно исключение: в «упрощенных» таблицах стилей этот элемент опускается, как мы увидим позже в этой главе.)</p>
<p>Как и любое другое приложение XML, XSLT имеет хорошо разработанный набор правил допустимости таблицы стилей XSLT. W3C даже определил для XSLT псевдо-DTD, где перечислены все правила синтаксиса, — эти объявления DTD приведены в приложении А, которое послужит вам хорошим справочником в случае затруднений с синтаксисом XSLT. Как показано в приложении А, элемент <pre><code><xsl:stylesheet></code></pre> может содержать несколько других элементов XSLT, называемых элементами верхнего уровня.</p>
<div class='cite'>
<p>ОБРАБОТКА ПРОСТРАНСТВ ИМЕН ПО УМОЛЧАНИЮ </p>
<p>Работа с пространствами имен может оказаться не слишком простой. Например, иногда присваивают пространство имен по умолчанию всему элементу <xsl:stylesheet>, как в <xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform" xmlns="mydefault">, ожидая, что <xsl:template match="mysymbol"> выберет mysymbol в пространстве имен "mydefault" исходного документа. Однако это не будет работать. Обработка пространств имен по умолчанию, как в таком случае, — одна из проблем, которую призван решить XSLT 2.0.</p>
</div>
</section>
</section>
<section>
<h3 id='52'>
<span>Элементы таблиц стилей высокого уровня</span>
</h2>
<p>В XSL определен ряд элементов высокого уровня, которые могут быть прямыми дочерними элементами <pre><code><xsl:stylesheet></code></pre>:</p>
<p>• <pre><code><xsl:attribute-set></code></pre>;</p>
<p>• <pre><code><xst:decimal-format></code></pre>;</p>
<p>• <pre><code><xsl:import></code></pre>;</p>
<p>• <pre><code><xsl:include></code></pre>;</p>
<p>• <pre><code><xsl:key></code></pre>;</p>
<p>• <pre><code><xsl:namespace-alias></code></pre>;</p>
<p>• <pre><code><xsl:output></code></pre>;</p>
<p>• <pre><code><xsl:param></code></pre>;</p>
<p>• <pre><code><xsl:preserve-space></code></pre>;</p>
<p>• <pre><code><xsl:strip-space></code></pre>;</p>
<p>• <pre><code><xsl:template></code></pre>;</p>
<p>• <pre><code><xsl:variable></code></pre>.</p>
<p>Рабочий проект XSLT 1.1 добавляет еще один элемент высокого уровня:</p>
<p>• <pre><code><xsl:script></code></pre> </p>
<p>В книге мы поработаем со всеми этими официальными элементами XSLT высокого уровня.</p>
<p>Заметьте, что, в дополнение ко всем элементам высокого уровня, вы можете также повсюду использовать обычные комментарии XML, поскольку таблицы стилей XSLT являются также документами XML:</p>
<p><pre><code><?xml version="1.0"?></code></pre></p>
<p><pre><code><xsl:stylesheet version="1.0"</code></pre></p>
<p><pre><code> xmlns:xsl="http://www.w3.org/1999/XSL/Transform"></code></pre></p>
<p><pre><code><b> <!-- Этот шаблон содержит все элементы PLANETS --></b></code></pre></p>
<p><pre><code> <xsl:template match="/PLANETS"></code></pre></p>
<p><pre><code> <HTML></code></pre></p>
<p><pre><code> <HEAD></code></pre></p>
<p><pre><code> .</code></pre></p>
<p><pre><code> .</code></pre></p>
<p><pre><code> .</code></pre></p>
<p>В дополнение к официальным элементам высокого уровня, некоторые процессоры XSLT определяют свои собственные элементы высокого уровня, использующие пространства имен, отличающиеся от пространства имен XSL. Функциональность таких элементов полностью определяется разработчиком процессора XSLT.</p>
<p>Вы также можете определять собственные элементы высокого уровня, называемые «элементами высокого уровня, определенными пользователем». Эти элементы должны иметь пространство имен, отличное от XSL и элементов, определенных разработчиком процессора. Процессор XSLT игнорирует определенные пользователем элементы высокого уровня; но, поскольку вы способны сами получить доступ ко всему документу при помощи функции документа (как мы увидим в главе 8), вы можете самостоятельно работать с этими элементами.</p>
<p>Из всех элементов высокого уровня самым популярным является элемент <pre><code><xsl:template></code></pre>:</p>
<p><pre><code><?xml version="1.0"></code></pre></p>
<p><pre><code> <xsl:stylesheet version="1.0"</code></pre></p>
<p><pre><code> xmlns:xsl="http://www.w3.org/1999/XSL/Transform"></code></pre></p>
<p><pre><code><b> <xsl:template></b></code></pre></p>
<p><pre><code><b> .</b></code></pre></p>
<p><pre><code><b> .</b></code></pre></p>
<p><pre><code><b> .</b></code></pre></p>
<p><pre><code><b> </xsl:template></b></code></pre></p>
<p><pre><code> .</code></pre></p>
<p><pre><code> .</code></pre></p>
<p><pre><code> .</code></pre></p>
<p>Создание шаблонов и работа с ними — суть XSLT, и сейчас мы рассмотрим этот элемент, продолжая создавать таблицу <pre><code>planets.xsl</code></pre>.</p>
</section>
<section>
<h3 id='53'>
<span>Элемент <xsl:template></span>
</h2>
<p>Шаблоны XSL позволяют задать способ выполнения вашего преобразования. Каждый элемент <pre><code><xsl:template></code></pre> устанавливается для выбора одного узла (который может содержать другие узлы) или ряда узлов в исходном документе, а также точного указания способа преобразования этого узла. В следующем списке перечислены атрибуты <pre><code><xsl:template></code></pre>:</p>
<p>• <pre><code>match</code></pre> (необязательный). Задает шаблон, выбирающий обрабатываемые узлы. Устанавливается в допустимый шаблон;</p>
<p>• <pre><code>name</code></pre> (необязательный). Содержит имя шаблона, что разрешает его вызов. Если вы не используете этот атрибут, вы должны использовать атрибут <pre><code>match</code></pre>. Принимает значение типа <pre><code>QName</code></pre>;</p>
<p>• <pre><code>priority</code></pre> (необязательный). Положительное или отрицательное целое или действительное число, задающее приоритет шаблона. Используется, когда один и тот же узел удовлетворяет нескольким шаблонам. Устанавливается в число;</p>
<p>• <pre><code>mode</code></pre> (необязательный). Если вы применяете <pre><code><xsl:apply-templates></code></pre> к множеству узлов, будут использоваться только шаблоны с совпадающим режимом (mode). Принимает значение типа <pre><code>QName</code></pre>.</p>
<p>Каждый такой элемент <pre><code><xsl:template></code></pre> называется правилом (rule). В общем случае элемент <pre><code><xsl:template></code></pre> может содержать ноль или более элементов <pre><code><xsl:param></code></pre> (как мы увидим в главе 9), за которыми следует тело шаблона, задающего способ осуществления преобразования.</p>
</section>
<section>
<h3 id='54'>
<span>Тела шаблонов</span>
</h2>
<section>
<p>Шаблоны формируются по жестко заданным правилам. Они способны содержать элементы <pre><code><xsl:param></code></pre>, за которыми следует тело шаблона; в последнем могут содержаться данные <pre><code>PCDATA</code></pre>, инструкции XSLT, элементы расширения и элементы буквального результата.</p>
</section>
<section>
<h3 id='55'>
<span>Инструкции XSLT</span>
</h3>
<p>В теле шаблона может присутствовать ряд элементов XSLT, называемых инструкциями:</p>
<p>• <pre><code><xsl:apply-imports></code></pre>;</p>
<p>• <pre><code><xsl:apply-templates></code></pre>;</p>
<p>• <pre><code><xsl:attribute></code></pre>;</p>
<p>• <pre><code><xsl:call-template></code></pre>;</p>
<p>• <pre><code><xsl:choose></code></pre>;</p>
<p>• <pre><code><xsl:comment></code></pre>;</p>
<p>• <pre><code><xsl:copy></code></pre>;</p>
<p>• <pre><code><xsl:copy-of></code></pre>;</p>
<p>• <pre><code><xsl:element></code></pre>;</p>
<p>• <pre><code><xsl:fallback></code></pre>;</p>
<p>• <pre><code><xsl:for-each></code></pre>;</p>
<p>• <pre><code><xsl:if></code></pre>;</p>
<p>• <pre><code><xsl:message></code></pre>;</p>
<p>• <pre><code><xsl:number></code></pre>;</p>
<p>• <pre><code><xsl:processing-instruction></code></pre>;</p>
<p>• <pre><code><xsl:text></code></pre>;</p>
<p>• <pre><code><xsl:value-of></code></pre>;</p>
<p>• <pre><code><xsl:variable></code></pre>.</p>
<p>В теле шаблона больше никакие элементы XSLT непосредственно появиться не могут. Как вы увидите в главе 9, элемент <pre><code><xsl:param></code></pre> может появиться в шаблоне перед телом, но он не называется инструкцией XSLT. В шаблонах могут также появляться и другие элементы XSLT, такие как <pre><code><xsl:sort></code></pre>, <pre><code><xsl:otherwise></code></pre> и <pre><code><xsl:with-param></code></pre>, но только в определенных местах, поэтому W3C не называет их инструкциями. Далее в книге мы рассмотрим, как использовать каждую из этих инструкций.</p>
</section>
<section>
<h3 id='56'>
<span>Элементы расширения</span>
</h3>
<p>Элементы расширения рассматриваются в главе 5; эти элементы, расширяющие XSLT, определяются пользователем или процессором XSLT. Во многих процессорах XSLT были определены собственные расширения — и это стало одной из причин, по которым W3C представил рабочий проект XSLT 1.1, где механизм расширений был более регламентирован. Вероятно, эта функциональность будет включена в XSLT 2.0.</p>
</section>
<section>
<h3 id='57'>
<span>Элементы буквального результата</span>
</h3>
<p>Если элемент в теле шаблона не является инструкцией XSL или элементом расширения, процессор XSLT должен рассматривать его в качестве элемента буквального результата. Это означает, что элемент должен трактоваться буквально и копироваться в результирующее дерево (то есть копироваться в выходное дерево, созданное процессором XSLT).</p>
<p>Например, в следующем теле шаблона элемент <pre><code><TD></code></pre> является элементом буквального результата, который будет скопирован в выходной документ:</p>
<p><pre><code><xsl:template match="RADIUS"></code></pre></p>
<p><pre><code> <TD>RADIUS</TD></code></pre></p>
<p><pre><code></xsl:template></code></pre></p>
<p>Элементы буквального результата могут сами по себе иметь содержимое, которое затем трактуется как еще одно тело шаблона и разбирается процессором XSLT. Позже в настоящей главе мы посмотрим, как работает этот механизм.</p>
<p>Элементы буквального результата могут также обладать атрибутами, которые интерпретируются процессором XSLT. Например, при помощи атрибута <pre><code>version</code></pre> можно указать, что все элементы XSLT внутри элемента буквального результата должны быть элементами XSLT версии 1.0:</p>
<p><pre><code><xsl:template match="RADIUS"></code></pre></p>
<p><pre><code> <TD xsl:version="1.0">RADIUS</TD></code></pre></p>
<p><pre><code></xsl:template></code></pre></p>
<p>В следующем списке перечислены все возможные атрибуты элемента буквального результата:</p>
<p>• Attribute Value Templates, шаблон значений атрибута (необязательный). Любые выражения XPath в фигурных скобках вычисляются, и результат в виде строкового значения копируется в атрибут в результирующем дереве. Устанавливается в шаблон значений атрибута (см. главу 3);</p>
<p>• <pre><code>xsl:exclude-result-prefixes</code></pre> (необязательный). Определяет, какие пространства имен не будут скопированы в результирующее дерево. Принимает значения списка префиксов пространств имен, разделенных символами- разделителями;</p>
<p>• <pre><code>xsl:extension-element-prefixes</code></pre> (необязательный). Заставляет процессор XSLT трактовать дочерние элементы элемента буквального результата в перечисленных пространствах имен как элементы расширения, а не элементы буквального результата;</p>
<p>• <pre><code>xsl:use-attribute-sets</code></pre> (необязательный). Атрибуты в перечисленных наборах атрибутов добавляются в элемент буквального результата и копируются в результирующее дерево. Принимает значение списка <pre><code>QName</code></pre>, идентифицирующих поименованные элементы <pre><code><xsl:attribute-set></code></pre>;</p>
<p>• <pre><code>xsl:version</code></pre> (необязательный). Устанавливает версию элементов XSL в элементе буквального результата. Принимает численное значение.</p>
<p>Теперь можно начать работать с этой информацией<b>.</b></p>
</section>
<section>
<h3 id='58'>
<span>Совпадающие элементы в шаблонах</span>
</h3>
<p>Для указания того, с каким узлом или узлами вы хотите работать в шаблоне, в XSLT имеются разнообразные способы поиска или выбора узлов. Следует установить атрибут <pre><code>match</code></pre> элемента <pre><code><xsl:template></code></pre> в<i> образец</i> (pattern), определяющий имя узла или узлов, с которыми вы хотите работать. В главе 3, посвященной шаблонам, будет показано, как создавать образцы. Например, образец «/» соответствует корневому узлу; образец «*» задает любой узел элемента; образцу «PLANET» удовлетворяют все узлы элемента <pre><code><PLANET></code></pre> и т.д.</p>
<p>Для начала я создал короткий пример, заменяющий корневой узел, — а следовательно, и весь документ — на HTML-странице. Первое, что я сделал, — создал шаблон с элементом <pre><code><xsl:template></code></pre>, установив атрибут <pre><code>match</code></pre> в образец для совпадения</p>
<p><pre><code><?xml version="1.0"></code></pre></p>
<p><pre><code><xsl:stylesheet version="1.0"</code></pre></p>
<p><pre><code> xmlns:xsl="http://www.w3.org/1999/XSL/Transform"></code></pre></p>
<p><pre><code><b> <xsl:template match="/"></b></code></pre></p>
<p><pre><code><b> .</b></code></pre></p>
<p><pre><code><b> .</b></code></pre></p>
<p><pre><code><b> .</b></code></pre></p>
<p><pre><code><b> </xsl:template></b></code></pre></p>
<p><pre><code></xsl:stylesheet></code></pre></p>
<p>Когда устанавливается соответствие с корневым узлом, шаблон применяется к самому узлу. В данном случае (листинг 2.2) я хочу заменить корневой узел документом HTML, поэтому я только включу этот документ HTML непосредственно в качестве содержимого элемента <pre><code><xsl:template></code></pre>.</p>
<div class='subtitle'>Листинг 2.2. Простейшее преобразование</div>
<p><pre><code><?xml version="1..0"?></code></pre></p>
<p><pre><code><xsl:stylesheet version="1.0"</code></pre></p>
<p><pre><code> xmlns:xsl="http://www.w3.org/1999/XSL/Transform"></code></pre></p>
<p><pre><code> <xsl:template match="/"></code></pre></p>
<p><pre><code><b> <HTML></b></code></pre></p>
<p><pre><code><b> <HEAD></b></code></pre></p>
<p><pre><code><b> <TITLE></b></code></pre></p>
<p><pre><code><b> A trivial transformation</b></code></pre></p>
<p><pre><code><b> This transformation has replaced the entire document.