Технология XSLT [Алексей Н Валиков] (fb2) читать онлайн

Технология XSLT

Посвящается моей жене

Предисловие

О чем эта книга?

Сложно переоценить влияние, которое за последнюю пару-тройку лет оказало на информационные технологии появление и распространение расширяемого языка разметки XML (от англ. extensible Markup Language). XML-технологии нашли применение во множестве областей и стали незаменимыми инструментами для многих решений.

Вместе с тем, сам язык XML — это не более чем текстовый формат представления данных. XML не имеет особого смысла вне практических приложений и сила XML — прежде всего в прикладных технологиях, которые связаны с этим языком.

Эта книга посвящена одной из таких технологий, языку XSLT. XSLT — это расширяемый язык стилей для преобразований (от англ. extensible Stylesheet Language for Transformations), который используется для описания преобразований структуры документов. XSLT позволяет трансформировать одни документы в другие, пользуясь простыми наборами правил преобразования.

Одной из сильнейших сторон языка XML является возможность отделять данные от их представления, хранить информацию в простом и понятном формате, стандарт которого четко оговорен. Такой подход имеет целый ряд достоинств: универсальность решений, снижение времени и стоимости разработки систем, широкие возможности по интеграции и обмену данными, многоцелевое использование информации и тому подобное.

Перечисляя преимущества этого метода, не следует забывать и о самом представлении, реализация которого, как правило, является довольно сложным делом. Например, в классических Web-решениях для визуализации информации, хранящейся в базе данных, применяется множество непростых технологий и языков программирования.

Другая распространенная проблема, которая часто сопутствует использованию языка XML, является проблема несоответствия логических схем. Поскольку при создании XML-документов автор может изобрести свой собственный язык разметки, рано или поздно возникает ситуация, когда одни и те же данные описываются разными языками. Соответственно, эти разные логические схемы нужно каким-то образом приводить к общему знаменателю.

Заметим, что эти две разные на первый взгляд задачи — представление данных и конвертация ХМL-документов различных логических схем — имеют общий корень. В обоих случаях для достижения результата документы должны быть преобразованы. В первом случае из исходного документа нужно получить документ, который может быть визуализирован (например — сгенерировать HTML). Во втором случае один из документов должен быть преобразован так, чтобы его схема соответствовала схеме другого документа.

Вместе с тем, преобразование древовидно структурированных XML-документов при помощи обычных языков программирования (таких, например, как Java, С или Pascal) является очень трудоемкой задачей. Такие программы громоздки, сложны и дорогостоящи в поддержке, поскольку они крайне чувствительны к малейшим изменениям в формате преобразуемого документа.

Для того чтобы просто, удобно и эффективно решить описанные выше проблемы и был создан расширяемый язык стилей для преобразований — XSLT. XSLT представляет собой мощную прикладную XML-технологию, которая может применяться везде, где есть два документа разной структуры. XSLT предоставляет высокоуровневые средства для манипуляции данными, которые хранятся в виде XML. Хотя XSLT не позиционируется, как язык запросов для XML, можно смело сравнить его с языком SQL, в котором определяются запросы к реляционным базам данных.

В этой книге XSLT рассматривается совместно с языком XPath (от англ. XML Path Language — язык путей в XML-документах), который используется для обращения к частям XML-документов. XPath играет в XSLT крайне важную роль, предоставляя средства для вычисления выражений на XML-документах, но кроме XSLT он используется в таких XML-технологиях, как XPointer и XQuery.

Использование XSLT позволяет сделать разработку преобразований действительно несложным занятием. Преобразования в XSLT — это не более чем наборы правил вида "если обнаружен узел определенного типа, то выполнить следующие действия". Во многих случаях преобразования, для записи которых понадобилась бы не одна страница на процедурном языке программирования, определяются в XSLT буквально в трех строчках.

Естественно, столь простой язык (а XSLT, безусловно, несложный язык как в изучении, так и в использовании) имеет свои границы. Встречаются задачи, решения которых с помощью XSLT либо не существуют вообще, либо они неудобны. В этих случаях можно прибегнуть к расширениям языка, которые позволяют использовать в XSLT-преобразованиях подпрограммы, написанные на более традиционных языках программирования, например — Java или С++.

Все это делает XSLT простым, понятным, удобным, но при этом чрезвычайно мощным и гибким языком. Ко всему этому автору хотелось бы добавить то субъективное мнение, что работать с XSLT просто интересно. Во многих случаях люди, столкнувшиеся с XSLT, становились энтузиастами и профессионалами этого языка.

Таким образом, на вопрос "о чем эта книга?" можно ответить так: она написана о прикладных XML-технологиях преобразования, которые призваны облегчить использование структурированных данных в пользовательских приложениях, открывая новые возможности проектам самого различного масштаба. Изучая языки XSLT и XPath, мы на примерах увидим, как заставить XML-технологии работать — просто, удобно и эффективно.

Для кого эта книга?

Эта книга адресована всем разработчикам программного обеспечения, которые используют или собираются использовать в своей работе XML, Web-программистам и Web-дизайнерам, создающим технологичные Web-сайты, а также всем, кто интересуется языком XML и прикладными XML-технологиями.

Поскольку XSLT и XPath являются уникальными языками, мало похожими на что-либо еще, знание других языков программирования для их изучения, в принципе, не обязательно, однако знакомство с основами алгоритмизации и базовыми концепциями программирования, конечно же, приветствуется.

Из обычных языков программирования XSLT ближе всего к декларативным языкам типа Lisp и Prolog. Как показывает практика, разработчики, имеющие опыт функционального программирования, вникают в тонкости XSLT немного быстрее остальных. Но это ни в коем случае не означает, что XSLT — сложный язык, доступный лишь избранным, совсем нет. Скорее даже наоборот: XSLT — это простой и понятный язык, работать с которым очень легко и интересно.

Многие из приводимых примеров будут ориентированы на web-решения — в этих случаях хорошую службу может сослужить знание основ web- технологий и языка HTML в частности.

Одна из глав посвящена вопросам использования XSLT совместно с другими языками программирования. Эта информация будет полезна читателям, работающим с такими языками программирования, как Object Pascal, С или С++, Java, JavaScript, VBScript, Python и PL/SQL.

В десятой главе рассматриваются основные принципы создания расширений языка XSLT. Основным языком для создания расширений является Java, потому желательно иметь представление о программировании на этом языке.

Как работать с книгой?

Книга одновременно является практическим руководством, созданным в помощь изучающим языки XSLT и XPath, и справочником, в котором изложены и подкреплены примерами многие особенности и нюансы этих языков.

Сложность материала книги скомпонована по нарастающей. Повествование начинается с разбора основных идей, стоящих за XML и XSLT, продолжается рассказом об архитектуре и элементах преобразований и заканчивается такими чисто практическими аспектами, как использование XSLT в других языках, создание расширений и решение основных классов задач.

Как и любая другая книга по программированию, эта книга не может обойтись без множества примеров, которые сопровождают текст, иллюстрируя и поясняя практический смысл сказанного. Пожалуй, будет очень полезно загрузить файлы примеров по адресу http://xpath.info и самостоятельно их опробовать.

Приложение 1 содержит обзор наиболее популярных XSLT-процессоров с подробным перечислением их характеристик. Этот раздел ориентирован, прежде всего, на читателя, который оказался перед выбором процессора для практического применения. Однако, для того чтобы изучать XSLT и выполнять приведенные в книге примеры, мы настоятельно рекомендуем процессор Saxon и его облегченную версию для Windows — Instant Saxon.

Причин тому несколько. Прежде всего, этот процессор, пожалуй, является наиболее стандартным в том смысле, что его поведение с точки зрения спецификации языка является практически идеальным. Вторая причина — переносимость. Поскольку Saxon написан на Java, работает он на любых Java- совместимых платформах. Наконец, Saxon почти идеален с точки зрения расширяемости.

Загрузить Saxon можно по адресу http://saxon.sourceforge.net. Пользователям Windows мы рекомендуем воспользоваться версией Instant Saxon, архив которой состоит из единственного файла saxon.exe. Для того чтобы выполнить пример при помощи Instant Saxon, следует запустить команду:

saxon -о result.xml source.xml stylesheet.xsl,

где result.xml — имя выходящего документа, source.xml — имя входящего документа, a stylesheet.xsl — имя файла преобразования.

Справочная информация книги сосредоточена в развернутом виде в главах 6, 7 и 8, а также в краткой форме в приложениях 2 и 3. Книга также содержит подробный глоссарий.

Структура книги

Книга состоит из двенадцати глав и четырех приложений, содержание которых мы кратко опишем ниже.

Глава 1. Введение в XML

Первая глава книги об XSLT не случайно посвящена языку XML (от англ. extensible Markup Language — расширяемый язык разметки). XML — это фундаментальная концепция, по отношению к которой XSLT является прикладной технологией и поэтому для эффективного применения XSLT нужно хорошо понимать основы XML.

Мы разделяем мнение множества экспертов о том, что лучшая документация по XML — это спецификация языка, снабженная внятными аннотациями, комментариями и примерами. Первая глава описывает синтаксис и конструкции языка XML именно в том виде, в каком они приведены в технической рекомендации Консорциума W3, акцентируя внимание на важных с точки зрения XSLT моментах.

Помимо синтаксиса и физической модели ХМL-документа, в первой главе раскрывается концепция XML, идея, которая за всем этим стоит. Краткий обзор практических аспектов использования XML подкреплен описаниями архитектуры типовых проектов, основанных на XML-технологиях.

Завершающая часть первой главы посвящена истории языка XML.

Глава 2. Введение в XSLT

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

Особое внимание уделяется практическому использованию XSLT в составе информационных систем. Во второй главе рассматриваются наиболее естественные области применения технологии XSLT.

Глава заканчивается краткой справкой об истории языка XSLT.

Глава 3. Идея и модель языка XSLT

Третья глава посвящена моделям, которые используются в языке XSLT. В ней рассматривается древовидная модель XML-документа, модель данных, используемая в языках XSLT и XPath, переменные, выражения, а также модель самого процесса преобразования. Можно сказать, что третья глава представляет взгляд на XSLT "изнутри". Эта информация важна для понимания того, как работают преобразования и почему это работает именно так.

Глава 4. Структура преобразования

Четвертая глава рассказывает о том, что представляет собой программа на языке XSLT, как она строится и из каких частей состоит. Кроме этого, рассматривается упрощенная форма преобразований, модульная организация преобразований и способы объединения преобразования и преобразуемого документа. В четвертой главе также освещаются такие чисто практические аспекты, как литеральные элементы результата и шаблоны значений атрибутов.

Глава 5. Шаблонные правила

В пятой главе рассматриваются основные структурные единицы преобразования, называемые шаблонными правилами, а также множество особенностей их использования: способы вызова, режимы выполнения, типы, приоритет, конфликты и так далее. Дополнительно разбирается использование в шаблонах переменных и параметров.

Глава 6. XPath-выражения

Шестая глава посвящена языку XPath, который используется в XSLT для выборок и вычислений на ХМL-документах. В этой главе рассматривается синтаксис и семантика XPath-выражений и паттернов XSLT и детально описываются функции базовой библиотеки XPath.

Глава 7. Основные элементы XSLT

В этой главе описываются основные элементы XSLT — элементы, которые непосредственно создают части выходящего документа, вычисляют выражения, производят копирование, обеспечивают условную и циклическую обработку. Основные элементы предоставляют "базовый набор услуг", без которых, как правило, не обходится ни одно преобразование.

Глава 8. Дополнительные элементы и функции языка XSLT

В восьмой главе разбираются возможности, которые предоставляются дополнительными элементами и функциями языка XSLT. Эти элементы и функции предоставляют сервисные возможности, которые не связаны непосредственно с созданием выходящего документа, но имеют значение для построения сложных преобразований. К этим возможностям относятся создание и обработка ключей, манипуляции с пробельным пространством, обращение ко внешним XML-документам, сортировка и многое другое.

Глава 9. Использование XSLT совместно с другими языками программирования

Эта глава поможет сделать первые шаги разработчикам, которым необходимо использовать XSLT совместно с другими языками программирования. В ней приведены простые примеры вызова преобразований из программ на таких языках программирования, как Object Pascal, C/C++, VBScript, JavaScript, Java и некоторых других.

Глава 10. Расширения языка XSLT

Десятая глава посвящена вопросам создания и использования функций и элементов расширения. В этой главе разбирается процесс написания и подключения функций и элементов расширения на примере интерфейсов таких процессоров, как Saxon, Xalan и Oracle XSLT Processor, а также вопросы, связанные с обеспечением переносимости и отработкой исключительных ситуаций в преобразованиях, использующих расширения.

Глава 11. Готовые решения

Одиннадцатая глава написана для тех, кто не любит изобретать лишний раз велосипед. В ней описываются решения некоторых наиболее распространенных проблем, как-то: группировка, циклические и рекурсивные вычисления, операции над множествами и так далее.

Глава 12. Развитие технологий

Последняя глава книги позволяет забежать немного вперед и предугадать, что будет с языком XSLT в следующих его версиях. Выводы, которые делаются в этой главе, основаны на изменениях, предложенных в черновой версии XSLT 1.1, а также на требованиях, которые были сформированы ко второй версии языка. Анализ этой информации в будущем позволит безболезненно перейти на новую версию XSLT.

Приложение 1. Обзор XSLT-процессоров

В первом приложении произведен обзор наиболее распространенных XSLT- процессоров с тем, чтобы помочь читателю выбрать наиболее подходящий инструмент. Помимо этого, в начале приложения приводятся статистические сведения о производительности и популярности различных XSLT-процессоров.

Приложение 2. Краткий справочник элементов и атрибутов XSLT

Второе приложение содержит справочную информацию об элементах и атрибутах языка XSLT. В одну таблицу сведены синтаксис элементов и атрибутов и краткое описание их семантики.

Приложение 3. Краткий справочник функций XSLT и XPath

Третье приложение содержит справочную информацию о функциях базовой библиотеки языка XPath и функциях языка XSLT, которые дополняют эту библиотеку.

Приложение 4. Интернет-ресурсы, посвященные XSLT

В четвертом приложении приведен небольшой список полезных интернет-ресурсов, так или иначе связанных с XSLT. Сюда относятся списки часто задаваемых вопросов, уроки по XSLT, архивы библиотек и инструментов, официальные спецификации Консорциума W3 и так далее.

Соглашения

Расширенная форма Бэкуса-Наура

Несмотря на то, что эта книга главным образом посвящена языку XSLT, в ней также описываются расширяемый язык разметки XML и язык обращения к частям ХМL-документов, называемый XPath. Подробное и точное описание этих языков невозможно без четких определений синтаксических конструкций.

Для описания синтаксиса рассматриваемых языков мы будем использовать расширенные формы Бэкуса-Наура (РФБН, или, по-английски, Extended Backus-Naur Form, EBNF). EBNF — это современная модификация методологии, которая впервые была использована для описания языка программирования Алгол-60. За прошедшие десятилетия формы Бэкуса-Наура были доработаны множеством авторов и сейчас в расширенном виде используются для описания ряда языков программирования различной степени сложности. EBNF-нотация также широко используется в технических рекомендациях Консорциума W3, которые фактически и являются стандартами рассматриваемых нами языков.

Нотация EBNF определяет язык как набор синтаксических правил, определяющих нетерминалы (конструкции языка) через терминалы (символы языка), а также другие нетерминалы. Правило состоит из двух частей, разделенных символами "::=":

конструкция ::= определение конструкции

В левой части правила стоит терминал определяемой конструкции, в правой — выражение, определяющее эту конструкцию. Правила EBNF также иногда называют продукциями, и мы тоже часто будем использовать этот термин, чтобы не путать эти правила с шаблонными правилами преобразований, которые главным образом и составляют преобразования в языке XSLT.

Терминалы, которые могут быть как отдельными символами, так и их последовательностями, определяются в нотации EBNF следующим образом:

□ #xN, где N — шестнадцатеричный код, соответствует символу Unicode с кодом N. Например, #х410 соответствует символу А кириллического алфавита (см. раздел "Использование Unicode" главы 1).

□ [a-zA-z], [#xN-#xN] — соответствует символу указанного интервала. К примеру, [a-f] соответствует любому из символов а, b, с, d, e, f.

□ [abc], [#xN#xN#xN] — соответствует любому из перечисленных символов. Например, [#х410#х411#х412] соответствует любому из символов А, Б, В. Символьные интервалы и перечисления могут использоваться совместно в одних квадратных скобках.

□ [^a-z], [^#хN-#xN] — соответствует любому символу, кроме символов указанного интервала. К примеру, [^#х410-#x42F] соответствует любому символу, кроме заглавных букв русского алфавита.

□ [^abc], [^#xN#xN#xN] — соответствует любому, кроме перечисленных символов. Например, [^xyz] соответствует любому символу, кроме символов x, y и z. Аналогично разрешенным интервалам и последовательностям символов, запрещенные интервалы и последовательности также могут использоваться совместно.

□ "строка" — соответствует строке, которая приведена в двойных кавычках. Например, "stylesheet" соответствует строке stylesheet.

□ 'строка' — соответствует строке, которая приведена в одинарных кавычках. Например, 'template' соответствует строке template.

Терминалы могут использоваться совместно с нетерминальными конструкциями в более сложных выражениях.

□ A? означает, что выражение A необязательно и может быть пропущено.

□ A | B соответствует либо выражению A, либо выражению B, но не им обоим одновременно (строгое "или"). Выражения такого вида называют иначе выбором.

□ A B означает, что за выражением A следует выражение B. Последовательность имеет приоритет по сравнению с выбором — A B | C D означает последовательность выражений A и B или последовательность выражений C и D.

□ A - B соответствует строке, которая соответствует выражению A, но не выражению B.

□ A+ означает последовательность из одного или более выражения A. Оператор "+" в EBNF старше оператора выбора, A+ | B+ означает последовательность из одного или более выражения A или последовательность из одного или более выражения B.

□ A* означает последовательность из нуля или более выражений A. Аналогично оператору "+", оператор "*" старше оператора выбора

□ (выражение) — круглые скобки используются для группировки выражений. Выражения, заключенные в скобки, рассматриваются, как отдельная единица, которая может быть свободно использована в приведенных выше конструкциях. Например, выражение A B C | B C | A D C | D C | C можно переписать в виде (A? (B | D) ) C.

Нотация расширенных форм Бэкуса-Наура может с первого взгляда показаться очень сложной, однако, на самом деле это не так. Достаточно разобрать несколько примеров, как все встанет на свои места.

Пример

Рассмотрим реальную продукцию Digits языка XPath. Digits — это последовательность из нескольких цифр от 0 до 9 и определяется она следующим образом:

Digits ::= [0-9] +

Как правило, продукции в спецификациях языков пронумерованы для того, чтобы было легче на них ссылаться. Мы будем по возможности приводить эти номера так, как они указаны в технических рекомендациях — в квадратных скобках, например:

[31] Digits ::= [0-9]+

При помощи продукции Digits определяется такая продукция, как Number, которая соответствует числу. Число — это последовательность цифр, разделенная точкой на целую и дробную части:

[30] Number ::= Digits ('.' Digits?)?

                | '.' Digits

Чтобы лучше понять EBNF, попробуем немного упростить эту продукцию. Выражение Digits? внутри круглых скобок означает, что Digits может как присутствовать, так и быть опущенным, то есть ('.' Digits?) ? равносильно '.' ? | ('.' Digits)?. Повторяя еще раз подобное упрощение с каждым из полученных выражений, в итоге преобразуем правило Number к виду:

Number ::= Digits

           | Digits '.' Digits

           | Digits '.'

           | '.' Digits

Следовательно, число имеет четыре варианта синтаксиса:

□ последовательность цифр, например 12345;

□ последовательность цифр, разделенная точкой на целую и дробную части, например 3.14;

□ последовательность цифр, заканчивающаяся точкой, например 6. — что эквивалентно 6.0;

□ последовательность цифр, начинающаяся точкой, например .5, что эквивалентно 0.5.

Разберем еще одну продукцию языка XPath — определение литерала. Литерал в XPath — это последовательность символов, заключаемая в одинарные или двойные кавычки, которая используется в качестве строкового параметра в функциях и т.д. Единственным и вполне логичным ограничением на синтаксис литерала является то, что он не может содержать символ собственных кавычек — в этом случае непонятно, где же на самом деле литерал кончается, а где начинается (например, 'ab'cd').

Конструкция Literal задается следующим образом:

[29] Literal ::= '"' [^"]* '"'

                 | "'" [^']* "'"

В первом случае синтаксис литерала начинается двойными кавычками ('"'), затем идет последовательность, состоящая из любых символов, кроме двойных кавычек ([^"]*), затем закрывающие двойные кавычки ('"'). Во втором случае синтаксис имеет точно такой же вид с точностью до замены одинарных кавычек двойными и наоборот.

Другим очень часто используемым правилом является правило, определяющее пробельное пространство (англ. space или whitespace). Пробельными символами в XML-языках считаются такие символы, как табуляция, перевод строки, возврат каретки и сам пробел. Продукция S пробельного пространства задается, как последовательность из одного или более пробельного символа:

[3] S ::= (#х20 | #х9 | #xD | #хА)+

Как правило, EBNF-продукции языков XML-группы составлены довольно просто, но в некоторых случаях они разбиты на несколько правил, которые определены в разных частях спецификации. В таких случаях мы будем по возможности упрощать продукции, записывая их в раскрытом виде.

Обозначения

Для того чтобы текст книги был более понятен, мы будем использовать некоторые соглашения.

Прежде всего, код программ и текст XML-документов будет выделяться моноширинным шрифтом Courier. Листингам многих примеров будут предшествовать заголовки вида

Листинг 2.1. Входящий документ

<!-- Текст входящего документа -->

Для того чтобы текст XML-документов был более наглядным, в листингах он будет форматироваться с пробельными отступами, например:

<foo bar="1">

 <FOO/>

</foo>

Еще раз повторим, что это форматирование применяется только в целях наглядности исходного кода, когда это не противоречит смыслу документа. В предыдущем случае документ на самом деле мог выглядеть как:

<?xml version="1.0" encoding="UTF-8"?><foo bar="1"><FOO></foo>

В тех случаях, когда позиции пробельных символов документа важны для повествования, они будут особым образом выделяться. Для обозначения пробела мы будем использовать символ "□", а для обозначения символа переноса строки — символ "¶", например:

<а xmlns:d="urn:d">¶

□□<d:b>¶

□□□□<с>¶

□□□□□□<e>¶

□□□□□□</e>¶

□□□□</с>¶

□□</d:b>¶

</а>

Базовые понятия или моменты, на которые следует обратить повышенное внимание, выделяются в тексте курсивом. Иностранные аббревиатуры и термины расшифровываются и переводятся в скобках, например: XSLT (от англ. extensible Stylesheet Language for Transformations — расширяемый язык стилей для преобразований). Ссылки на другие книги берутся в квадратные скобки с указанием года издания, например, [Кнут 2001]. Более точные библиографические данные можно найти в списке литературы.

Благодарности

Прежде всего, хотелось бы выразить признательность группе Систем Баз Данных (DBS) Исследовательского Центра Информатики (Forschungszentrum Informatik, FZI) при университете г. Карлсруэ, где мне посчастливилось работать. Эта книга написана главным образом благодаря практическому опыту, полученному во множестве проектов Европейской Комиссии, которыми занимается наш центр.

Эта книга не состоялась бы без участия Майкла Кея (разработчика XSLT-процессора Saxon и редактора новой версии языка XSLT), Стива Мюнха (руководителя XML-проектов Oracle), Кена Холлмана (Crane Softwrights Ltd.), Олега Ткаченко (MultiConn International Ltd.) и многих других людей, которые советами и конкретными примерами помогали готовить этот непростой материал.

Отдельной благодарностью хочется упомянуть всех участников конференций fido7.ru.xml, comp.text.xml и списка рассылки XSL List, которые своими вопросами подсказывали, какие проблемы интересуют XSLT-разработчиков на практике. Большинство примеров, которые приводятся в этой книге, были ответами на вопросы участников конференций.

Большое спасибо моим научным руководителям — профессору Н.И. Юсуповой и профессору П.X. Локеману, за мудрые слова и внимание, которое они мне уделяли.

Выражаю признательность также сотрудникам издательства "БХВ-Петербург": Евгению Рыбакову, Анне Кузьминой и Леониду Кочину — за помощь при подготовке книги к печати.

И, наконец, большое спасибо моей семье и моим добрым друзьям — Юре Лотнику, Антону Кузнецову и Юле Кирилловой за поддержку, которая чувствовалась за несколько тысяч километров.

Глава 1 Введение в XML

Что такое XML?

За последние несколько десятков лет, прошедших с создания первых электронных устройств, в игру с природой человеком была введена третья сторона — вычислительные машины. Человек постепенно доверил им свою память, переложил на них сложные алгоритмические задачи, вычисления, принятие решений, и вообще все то, с чем плохо справлялся сам в информационном мире.

Но на всем пути становления информационных систем человек неизбежно сталкивался с одной и той же проблемой — с проблемой понимания. Если два человека, говорящие на разных языках, попробуют объяснить что- нибудь друг другу, то это легко может получиться, когда проблема проста, например, "как пройти к большому зданию с куполом наверху?". Однако же, в случае, если объяснить нужно что-нибудь более сложное, то, не зная языка собеседника, сделать это будет очень трудно.

Проблема понимания между человеком и машиной усугубляется еще и тем, что машина — это цифровое устройство, и все данные в ней состоят из атомов информации — битов, принимающих только два значения — "0" (что иногда понимается, как "нет" или "ложь") и "1" ("да", "истина"). Изначально цифровые устройства вообще использовались только для решения математических задач — расчета баллистики, шифрации и тому подобного.

Для машинной записи естественных языков люди ставили в соответствие символам числа, организуя, таким образом, текстовую информацию в машинном представлении. Это был первый шаг на пути взаимопонимания между машинами и человеком — отпала необходимость писать программы в двоичных кодах. В течение короткого времени было создано множество языков программирования, одновременно понятных как человеку, поскольку они использовали синтаксические конструкции естественных языков, так и машине, потому как могли быть переведены (транслированы) в машинные коды.

Затем произошел взрыв. Программирование, которое во времена машинных кодов было уделом энтузиастов, стало массовым, идеи и вложения полились рекой, и дальнейшее развитие информационных технологий можно сравнить с распространением ударной волны.

В жизни современного общества сложно переоценить эффект, произведенный появлением и повсеместным распространением нового глобального пространства обмена информации — сетью Интернет. То, что начиналось как военная разработка для доставки электронных сообщений и депеш, вылилось в новое информационное измерение пространства, не знающее географических границ. Интернет позволил обмениваться информацией в электронном виде, объемы которой к тому времени уже были огромны.

Однако, Интернет, в свою очередь, возродил старую проблему понимания — вопрос "как ты поймешь то, что я тебе скажу?" был заменен проблемой "как система В сможет переработать информацию, которую предоставит ей система A?". Пытаясь ответить на это, люди стали создавать стандарты и протоколы, которые позволили бы системам общаться на одних языках. Вместе с тем, по мере глобализации Интернета и увеличения числа систем, обменивающихся информацией (от рабочих станций обычных пользователей — до суперсерверов с огромными базами данных), объем информации, требовавшей стандартного выражения, прогрессировал экспоненциально.

Расширяемый язык разметки XML (extensible Mark-up Language) — это результат довольно успешной попытки создать язык для текстового выражения структурированной информации в стандартном виде. XML — это метаязык в том смысле, что сам по себе он не имеет операторов, не определяет никакую алгоритмическую последовательность действий и не выполняет никаких вычислений, его цель — описывать новые языки документов.

Разметка документов

Идею разметки документов будет проще всего проиллюстрировать на примере. Представим себе следующий рекламный текст:

Предлагаем Вашему вниманию новый 3-х камерный холодильник "Горск" объемом 250 л. и стоимостью всего 4500 рублей! Новый дизайн, быстрое охлаждение и низкое энергопотребление, 3-х годовая гарантия на все узлы и агрегаты, а также бесплатная доставка по городу! Заказывайте прямо сейчас по телефону 091-12-15. Фирма "Горск-Холод".

Размещая это объявление где-нибудь на Web-сайте, нам может понадобиться выделить некоторые части, чтобы получить представление вида:

Предлагаем Вашему вниманию новый 3-х камерный холодильник "Горск" объемом 250 л. и стоимостью всего 4500 рублей! Новый дизайн, быстрое охлаждение и низкое энергопотребление, 3-х годовая гарантия на все узлы и агрегаты, а также бесплатная доставка по городу! Заказывайте прямо сейчас по телефону 091-12-15.

Фирма "Горск-Холод".

Идея разметки состоит в том, чтобы использовать для выделения частей документа простые текстовые метки, называемые тегами. Теги разграничивают документ, выделяя в нем части и присваивая им некоторые особенности (например, указывая на то, что часть текста надо подчеркнуть).

Простым примером языка разметки является уже, скорее всего, знакомый читателю HTML — язык разметки гипертекста. В HTML задан набор тегов для визуального форматирования документа, например:

□ <P>содержимое</P> — выделяет содержимое, как параграф;

□ <BR> — задает перенос строки;

□ <B>содержимое</B> — выделяет содержимое полужирным шрифтом;

□ <I>содержимое</I> — выделяет содержимое курсивом;

□ <U>содержимое</U> — подчеркивает содержимое.

Теги могут быть парными и одиночными. Парные теги (например, <B>содержимое</B>) выделяют часть документа, одиночные (например, <BR>) задают некую инструкцию.

В предыдущем примере текст может быть размечен следующим образом.

Листинг 1.1. HTML-разметка рекламного объявления

<Р>Предлагаем Вашему вниманию новый 3-х камерный холодильник <В>"Горск"</В> объемом 250 л. и стоимостью всего <В>4500</В> рублей! Новый дизайн, <I>быстрое охлаждение</I> и <I>низкое энергопотребление</I>, <В>3-х годовая гарантия</В> на все узлы и агрегаты, а также <I>бесплатная доставка по городу</I>! Заказывайте прямо сейчас по телефону <U>091-12- 15<U>. <BR><BR>Фирма "Горск-Холод".</Р>

Теперь этот документ несет в себе не только данные о коммерческом предложении, но и примитивную информацию о том, как он должен выглядеть визуально. Это делает документ более понятным, но понятным для человека, а не для машины. Словосочетания "быстрое охлаждение" и "бесплатная доставка по городу", выделенные в тексте одинаковыми тегами, на самом деле описывают совершенно разные вещи. Первое — свойство продукта, второе — сервис, предоставляемый фирмой. Иначе говоря, одни и те же теги в этом документе имеют разный смысл — один и тот же синтаксис выражает разную семантику.

Для решения этой проблемы несоответствия, XML предлагает очень простой и весьма эффективный способ — расширить множество используемых тегов так, чтобы они могли полностью выразить всю семантику, которой только может обладать документ. Например.

Листинг 1.2 XML-разметка рекламного объявления

<advert>

 Предлагаем Вашему вниманию новый <room>3</room>-x камерный

 <product>холодильник</product> <product-title>"Горск"</product-title>

 объемом <volume>250 л.</volume> и стоимостью всего <price>4500</price>

 рублей!

 Новый дизайн, <feature>быстрое охлаждение</feature> и

 <feature>низкое энергопотребление</feature>,

 <guarantee>3-x годовая гарантия</guarantee> на все узлы и агрегаты, а

 также <service>бесплатная доставка по городу</service>!

 <order>

  Заказывайте прямо сейчас по телефону <phone>0-91-12-15</phone>.

 </order>

 <company>Фирма "Горск-Холод".</company>

</advert>

В таком виде этот документ содержит гораздо более подробную информацию о своей структуре: внутри тега <product-title> указано наименование продукта, внутри тега <price> — цена, внутри тега <service> — какой сервис предоставляет фирма и так далее. Такой текст уже можно обработать программно. Если понадобится составить таблицу, содержащую названия холодильников, объем, цену, название фирмы и телефон, все, что потребуется сделать — это получить содержимое тегов <product-title>, <volume>, <price>, <company> и <phone>. При этом совершенно не теряется возможность визуального представления документа: нужно лишь определить, как будет выглядеть содержимое того или иного тега.

Таким образом, просто расширив множество тегов, мы убили сразу двух зайцев.

□ Явным образом выделили в документе структуру данных. Это делает возможной дальнейшую машинную обработку документа, который при этом все еще остается понятным человеку.

□ Отделили данные, содержащиеся в документе, от того, каким образом документ будет представлен визуально. Это дает широкие возможности для публикации документов на различных носителях — на бумаге, в Интернет, на мобильных устройствах.

В этих двух положениях и есть смысл XML (англ. extensible Mark-up Language, расширяемый язык разметки) — отделять данные от представления и создавать в текстовом виде документы со структурой, указанной явным образом.

Синтаксически в XML, по сравнению с HTML, нет ничего нового. Это такой же текст, размеченный тегами, но с той лишь разницей, что в HTML существует ограниченный набор тегов, которые можно использовать в документах, в то время как XML позволяет создавать и использовать любую разметку, которая только может понадобиться для подробного описания данных.

XML снаружи и изнутри

Несомненным достоинством XML является также и то, что это чрезвычайно простой язык. Основных конструкций в XML очень мало, но, несмотря на это, с их помощью можно создавать разметку документов практически любой сложности.

Для того чтобы познакомиться с устройством XML-документов, рассмотрим простой пример:

<?xml version="1.0"?>

<advert>

 <product title="Слон">

  Покупайте наших слонов!

 </product>

</advert>

Первая строка документа определяет его как XML-документ, построенный в соответствии с первой версией языка. Следующая строка содержит открывающий тег <advert>. Далее находится открывающий тег <product>, который имеет атрибут title со значением "Слон". Четвертая строка в документе — рекламный лозунг "Покупайте наших слонов!". Затем следует закрывающий тег </product> и, наконец, закрывающий тег </advert>.

XML использует ту же теговую разметку, что и HTML, но при этом теги в XML не просто ограничивают часть текста документа — они выделяют в документе один элемент. В предыдущем примере документ имел два элемента — advert:

<advert>

 <product title="Слон">

  Покупайте наших слонов!

 </product>

</advert>

и product:

<product title="Слон">

 Покупайте наших слонов!

</product>

Как видно, элемент product включен в элемент advert. Точно так же, как в HTML одни теги могли находиться внутри других тегов, в XML элементы могут содержать другие элементы, а также иметь атрибуты и содержать текст. В следующем разделе мы подробно рассмотрим основные конструкции XML, которые понадобятся нам в дальнейшем.

Конструкции XML

Помимо элементов, атрибутов и текста, документы могут также содержать другие конструкции, такие как комментарии, инструкции по обработке и секции символьных данных. Эти базовые составляющие используются для того, чтобы гибко, но в четком соответствии со стандартом, размечать документы любой сложности. Далее мы подробно разберем каждую из основных конструкций XML-документа.

Элемент

Теги в XML-документе не просто размечают текст — они выделяют объект, который и называется элементом. Элементы являются основными структурными единицами XML — именно они иерархически организуют информацию, содержащуюся в документе.

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

Пустой элемент имеет следующий вид:

<имя атрибут1="значение1" атрибут2="значение2" и т.д./>

Примеры

<img src="image.gif"/>

<br/>

<answer question="To be or not to be?" value="Perhaps"/>

Непустые элементы имеют вид:

<имя атрибут1="значение1" атрибут2="значение2" и т.д.>

 ...

 содержимое элемента

...

 </имя>

Пример

<myelement myattribute="myvalue">

 <mysubnode>

  sometext

 </mysubnode>

</myelement>

И в том, и в другом случае, имя задает имя элемента, а конструкции вида атрибутX="значениеХ" — определяют значения его атрибутов. Имена в XML являются регистро-зависимыми, то есть имена MyElement, myelement и MYELEMENT различаются. Кроме того, имена в XML могут принадлежать различным пространствам имен, о которых мы поговорим чуть позже.

Элементы являются основной конструкцией языка XML. Организуя содержимое в элементах, можно явно выделить иерархическую структуру документа. Легко заметить, что документ, состоящий из вложенных друг в друга элементов, устроен подобно дереву: родительский элемент является корнем, в то время как дочерние элементы, которые включаются в него, являются ветками, а если они не содержат ничего более, то и листьями. Следующий пример (рис. 1.1) иллюстрирует эту концепцию.

Рис. 1.1. Документ и соответствующее ему дерево элементов

Очень важно понять, что XML-документ логическиорганизован в виде дерева. Дерево является довольно простой структурой для обработки, но при этом выразительная сложность его весьма велика. Древовидная структура является одной из наиболее подходящих абстракций для описания объектов и отношений в реальном мире — возможно именно древовидное устройство наряду с простотой использования обеспечили XML такой потрясающий успех.

Обратимся теперь к синтаксису элементов. EBNF-правило, определяющее элемент, выглядит следующим образом:

[39] element ::= EmptyElemTag

                 | STag content ETag

Пустому элементу соответствует нетерминал EmptyElemTag. Непустой элемент начинается открывающим тегом (нетерминал STag), включает некоторое содержимое (content) и заканчивается закрывающим тегом (ETag).

Открывающий тег состоит из имени (Name) и последовательности определений атрибутов (Attribute), которые разделены пробельными символами:

[40] STag ::= '<' Name (S Attribute)* S? '>'

В ряде случаев атрибуты тега могут отсутствовать.

Перед закрывающей угловой скобкой тега могут также стоять пробельные символы, поэтому вполне корректной будет следующая запись:

<а

 href="http://www.xsltdev.ru"

>

В закрывающем теге имени предшествует косая черта ("/") и перед закрывающей угловой скобкой тоже могут стоять пробелы:

[42] ETag ::= '</' Name S? '>'

Имена в открывающем и закрывающем тегах должны совпадать.

Содержимое элемента может состоять из элементов (нетерминал element), сущностей (Reference), секций символьных данных (CDSect), инструкций по обработке (PI) и комментариев (Comment), перемешанных с символьными данными (CharData):

[43] content ::= CharData?

                 ((element

                 | Reference

                 | CDSect

                 | PI

                 | Comment) CharData?)*

Пустой элемент не имеет содержимого и задается продукцией EmptyElemTag в следующем виде:

[44] EmptyElemTag ::= '<' Name (S Attribute)* S? '/>'

Тег пустого элемента выглядит точно так же, как и тег непустого элемента с той лишь разницей, что перед закрывающей угловой скобкой стоит символ косой черты ("/"). В этом, кстати, одно из главных отличий синтаксиса языка XML от HTML. Например, вместо <HR> в XML следует писать <HR/>.

Замечание

Для того чтобы привести синтаксис HTML в соответствие со стандартом XML, был создан язык XHTML. Этот язык полностью соответствует синтаксису XML, что делает возможным обработку XHTML-документов XML-средствами, но при этом набор тегов XHTML идентичен набору тегов языка HTML. К сожалению, далеко не все браузеры поддерживают XHTML. Чаще всего проблемы возникают именно с пустыми элементами (или одиночными тегами в терминах HTML): например, браузеры могут некорректно воспринимать запись вида <br/>. В большинстве случаев проблема решается использованием перед косой чертой пробела: запись вида <br />, скорее всего, будет обработана корректно.

Атрибут

В элементах можно использовать атрибуты с присвоенными им значениями. Атрибут задается в следующем виде:

атрибут="значение"

Например, в записи гипертекстовой ссылки

<а href="http://www.xsltdev.ru">Заходите к нам!</а>

элемент а имеет атрибут href, которому присвоено значение "http://www.xsltdev.ru".

В языке XML атрибуты всегда должны иметь значения. Например, атрибут selected в записи элемента

<option selected>

 выбранный элемент

</option>

будет задан с точки зрения XML некорректно, поскольку ему не присвоено значение. Заметим, что в HTML такое определение является вполне нормальным. Такую ошибку легко исправить следующим образом:

<option selected="selected">

 выбранный элемент

</option>

Значения атрибутов заключаются в кавычки — одинарные или двойные, например, в предыдущем случае можно написать:

<option selected='selected'>

 выбранный элемент

</option>

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

<auth login='"scott"' password="'tiger'"/>

Атрибуту login присвоено значение "scott" (включая двойные кавычки), атрибуту password — значение 'tiger' (включая одинарные кавычки).

В XML один элемент не может иметь атрибуты с одинаковыми именами.

Определение атрибута состоит из имени, за которым следует знак равенства, а затем, значение атрибута:

[41] Attribute ::= Name Eq Attribute

[25] Eq ::= S? '=' S?

[10] AttValue ::= '"' ([^<&"] | Reference)* '"'

                  | "'" ([^<&'] | Reference)* "'"

Значение атрибута записывается в одинарных или двойных кавычках, причем оно не может содержать символов '<' и '&', которые используются в XML как управляющие символы (< открывает тег элемента, а & — сущность). Вместе с тем, значение атрибута может содержать сущность (нетерминал Reference) — специальную конструкцию, о которой мы поговорим чуть позже.

Инструкция по обработке

В XML-документы могут быть включены не относящиеся к содержимому документа инструкции, несущие информацию для приложения, которое будет этот документ обрабатывать. Инструкции по обработке имеют вид:

<?приложение содержимое?>

Инструкция по обработке всегда заключается в угловые скобки со знаками вопроса. Первая часть инструкции, приложение, определяет программу или систему, которой предназначена вторая часть, ее содержимое.

Примером инструкции по обработке может послужить следующая запись:

<?serv cache-document?>

В данном случае целевое приложение имеет имя 'serv', а сама инструкция может быть интерпретирована как указание серверу на то, что документ нужно сохранить в кэше. Естественно, инструкции по обработке имеют смысл только для тех приложений, которым они адресуются.

Продукции инструкций по обработке имеют следующий вид:

[16] PI ::= '<?' PITarget

            (S (Char* - (Char* '?>' Char*)))? '?>'

В этом правиле выражение (S (Char* - (Char* '?>' Char*)))? означает, что приложение и содержимое инструкции по обработке разделены пробельными символами, причем содержимое состоит из любых символов, кроме последовательности '?>', которая обозначает конец инструкции.

Целевое приложение может иметь любое имя (кроме "xml" в любом регистре символов). Имя целевого приложения определяется EBNF-правилом PITarget:

[17] PITarget ::= Name - (('X' | 'х') ('М' | 'm') ('L' | 'l'))

В XML определена особая конструкция, называемая ХМL-декларацией (XML declaration). Она имеет вид:

<?xml version="версия" encoding="кодировка" standalone="yes | no"/>

Несмотря на то, что XML-декларация очень похожа на инструкцию по обработке, с точки зрения стандарта она таковой не является. Если же подходить менее строго, то смысл XML-декларации полностью соответствует смыслу инструкции по обработке: она сообщает обрабатывающему данный документ программному обеспечению информацию о некоторых свойствах этого документа. XML-декларация может содержать псевдоатрибуты version, encoding и standalone, которые мы рассмотрим ниже.

Замечание

В отличие от элементов, XML-декларация, как и инструкции по обработке не могут иметь атрибутов. Однако их содержимое очень часто образуется в форме имя="значение" — такие объявления и называются псевдоатрибутами.

Псевдоатрибут version содержит информацию о версии XML, в соответствии с которой был создан этот документ. Текущей версией языка XML является 1.0, поэтому в большинстве случаев указывается version="1.0".

Пример

<?xml version="1.0"?>

Псевдоатрибут encoding сообщает, в какой кодировке создан данный документ. По умолчанию выбрана Unicode-кодировка UTF-8 (подробнее см. "Использование Unicode"), но точно так же может быть использована и любая другая кодировка, лишь бы только ее поддерживало программное обеспечение, обрабатывающее документ.

Пример

Большинство документов, созданных на русском языке, используют кириллические кодировки windows-1251 и KOI8-R; XML-декларации для этих документов будут иметь вид:

<?xml version="1.0" encoding="windows-1251"?>

и

<?xml version="1.0" encoding="KOI8-R"?>

соответственно.

Для документов, в которых использовались только нижние 127 символов ASCII, то есть, символы с кодами, не превышающими #x7F, псевдоатрибут encoding указывать необязательно. В этой области символов кодировка UTF-8 совпадает с ASCII.

Псевдоатрибут standalone говорит о том, использует ли этот документ какие-либо внешние объявления или нет. Как мы узнаем чуть позже, XML-документы могут использовать информацию, которая находится во внешних документах. Опция standalone, имеющая значение "yes", означает, что документ не содержит таких объявлений, и, значит, может быть обработан без обращения к внешним источникам.

Декларации XML соответствует продукция XMLDecl, которая, в свою очередь, использует несколько дочерних правил:

[23] XMLDecl ::= '<?xml' VersionInfo EncodingDecl?

                  SDDecl? S? '?>'

Продукция VersionInfo определяет синтаксис псевдоатрибута version:

[24] VersionInfo ::= S? 'version' Eq

                     ("'" VersionNum "'"

                     | "" VersionNum "")

Значение версии документа может состоять из латинских букв и цифр, а также символов "_", ".", ":" и "-":

[26] VersionNum ::= ([a-zA-Z0-9_.:] | '-')+

Кодировка объявляется продукцией EncodingDecl, которая синтаксически похожа на VersionInfo:

[80] EncodingDecl ::= S? 'encoding' Eq

                      ("'" EncName "'"

                      | '"' EncName '"')

Имя кодировки, EncName, может состоять только из латинских букв, цифр и символов ".", "_" и "-", причем первым символом названия кодировки всегда должна быть буква:

[81] EncName [A-Za-z] ([A-Za-z0-9.-] | '-')*

Используемое в документе название кодировки должно быть известно программному обеспечению, которое этот документ обрабатывает. В противном случае могут возникнуть ошибки и несоответствия. В спецификации рекомендуется использовать названия кодировок, одобренные IANA (Internet Assigned Numbers Authority — Комитет присвоенных кодов Интернет). Кириллице, которая используется в русском языке, в списках IANA присваивается около десятка кодировок. Самыми распространенными из них являются следующие:

□ Windows-1251;

□ KOI8-R;

□ Cp866;

□ ISO-8859-5.

Техническая рекомендация XML оговаривает, что. в тех случаях, когда имя использованной кодировки не является стандартным, оно должно указываться с префиксом "x-", например:

<?xml version="1.0" encoding="x-BK-CYR"?>

Псевдоатрибуту standalone соответствует EBNF-правило SDDecl:

[32] SDDecl ::= S 'standalone' Eq

                (("'" ('yes' | 'no') "'")

                | ( '"' ('yes' | 'no') '"' ) )

Расшифровывается это правило очень просто: псевдоатрибут standalone может иметь значение yes или no, заключенное в одинарные или двойные кавычки.

Секции СDATA

Секции CDATA выделяют части документа, внутри которых текст не должен восприниматься как разметка. CDATA означает буквально "character data" — символьные данные. Секции CDATA задаются следующим образом:

<![CDATA[содержимое]]>

Поскольку синтаксис разметки документов в XML имеет текстовую форму, часто бывает, что само содержимое документа может быть воспринято как разметка. В том случае, когда этого желательно избежать, самым простым выходом будет поместить такие данные внутрь секции CDATA.

Пример

Следующий текст в документе

<slogan>Покупайте наших слонов!</slogan>

будет воспринят как разметка. Для того чтобы избежать этого, достаточно написать

<![СDАТА[<slogan>Покупайте наших слонов!</slogan>]]>

Такая конструкция уже будет воспринята как символьные данные. Другим примером может быть использование символов "<" и "&":

<![CDATA[ if ( а < b && b < с ) {...} ]]>

Секции символьных данных задаются четырьмя довольно простыми правилами:

[18] CDSect  ::= CDStart CData CDEnd

[19] CDStart ::= '<![CDATA['

[20] CData   ::= Char* - (Char* ']]>' Char*))

[21] CDEnd   ::= ']]>'

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

Комментарии (comments)

XML-документ может содержать комментарии, которые записываются следующим образом:

<!-- текст комментария -->

Текст комментария может состоять из любых символов, кроме двух минусов

подряд ("--"). Кроме этого, комментарий не должен заканчиваться символом "-" .

Пример комментария:

...

<!-- product title="Слон">

 Покупайте наших слонов!

</product-->

...

Продукция комментария называется в XML Comment и имеет следующий вид:

[15] Comment ::= '<!--' ((Char - '-') | ('-' (Char- '-')))* '-->'

Выражение ((Char - '-') | ('-' (Char - '-')))* означает, что содержимое комментария не должно оканчиваться на знак "-" или содержать два таких знака последовательно.

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

XML позволяет создавать наборы элементов с любыми синтаксически допустимыми именами и определять с их помощью логическую структуру документов практически произвольной сложности.

За время существования XML была создана разметка для большого числа задач. На таких Web-сайтах, как http://www.xml.org, http://www.schema.net и http://www.ebxml.org можно с большой вероятностью найти определения структуры документов для огромного количества предметных областей. Во многих случаях уже созданные схемы помогут сократить этап концептуального моделирования документов.

Часто случается, что различные логические схемы документов используют одни и те же имена элементов в различных смыслах. Это не является проблемой, если в документе используется только одна схема. Но представьте себе ситуацию, когда в одном и том же документе необходимо использовать элементы нескольких различных схем — будет попросту невозможно определить, какой элемент относится к какой схеме, и, вообще, какие схемы были использованы в документе. Для решения этих проблем в XML используются пространства имен (англ. namespaces).

Чтобы различать схемы документов, каждой из них ставится в соответствие уникальный идентификатор ресурса (URI). Две схемы будут считаться тождественными тогда и только тогда, когда их уникальные идентификаторы будут совпадать, поэтому нужно осторожно выбирать URI для создаваемой схемы документа. Очень часто в качестве URI используются URL различных Web-сайтов. Это совсем не означает, что по указанному адресу должно что-либо находиться, просто такой способ практически гарантирует уникальность — вряд ли кому придет в голову использовать адрес чужого сервера в качестве идентификатора своей схемы.

Пример

Уникальный идентификатор языка XSLT, которому посвящена эта книга, имеет вид:

http://www.w3.org/1999/XSL/Transform

Для того чтобы определить, какой схеме принадлежит тот или иной элемент в документе, можно использовать механизм префиксов. Префиксы пространств имен задаются как атрибуты с именами, начинающимися последовательностью xmlns, и имеют следующий вид:

<префикс:элемент xmlns:префикс="URI">

 ...

</префикс:элемент>

Пример

В XSLT чаще всего используется префикс xsl, который задается, как правило, следующим образом:

<xsl:stylesheet

 xmlns:xsl="http://www.w3.org/1999/XSL/Transform"

 version="1.0">

 ...

</xsl:stylesheet>

При этом ничто не мешает использовать любой другой префикс. Например, следующий фрагмент документа будет совершенно идентичен предыдущему:

<www:stylesheet

 xmlns:www="http://www.w3.org/1999/XSL/Transform"

 version="1.0">

 ...

</www:stylesheet>

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

Пример

<!-- Здесь еще нельзя использовать префикс aaa -->

<aaa:element xmlns:aaa="http://www.aaa.com">

 <!-- Здесь уже можно использовать префикс aaa -->

 <ааа:anotherelement/>

 ...

</aaa:element>

<!-- А здесь снова нельзя -->

Принадлежность элементов той или иной схеме определяется не префиксами, а тем, какие уникальные идентификаторы поставлены этим префиксам в соответствие. То есть два элемента с разными префиксами, заданными одинаковыми идентификаторами, будут считаться принадлежащими одной схеме.

Пример

В следующем фрагменте

<xslt:stylesheet

 xmlns:xslt="http://www.w3.org/1999/XSL/Transform"

 version="1.0">

 <xsl:template xmlns:xsl="http://www.w3.org/1999/XSL/Transform"/>

 ...

</xslt:stylesheet>

элементы stylesheet и template имеют различные префиксы, но, несмотря на это, принадлежат одной и той же схеме.

В одном элементе можно определять несколько префиксов пространств имен. Как правило, при использовании множества префиксов, все они определяются в корневом элементе, а затем используются по всему документу.

Пример

<aaa:element

 xmlns:aaa="http://www.ааа.com"

 xmlns:bbb="http://www.bbb.com"

 xmlns:ccc="http://www.ccc.com">

 <aaa:anotherelement/>

 <ccc:element/>

 <bbb:anotherelement/>

 ...

</aaa:element>

Весьма удобной является возможность использования пространства имен по умолчанию. Определение пространства имен в виде

<элемент xmlns="URI">

 ...

</элемент>

позволяет опускать префиксы в именах элементов.

Пример

Документ в предыдущем примере может быть переписан следующим образом:

<element xmlns="http://www.aaa.com">

 <anotherelement/>

 <ссс:element xmlns:ccc="http://www.ccc.com"/>

 <anotherelement xmlns="http://www.bbb.com"/>

 ...

</element>

Обратим внимание, что пространство имен по умолчанию может быть изменено повторным использованием атрибута xmlns в дочерних элементах.

Пример

Документ

<element xmlns="http://www.ааа.com">

 <element/>

 <element xmlns="http://www.bbb.com">

  <element/>

  <element xmlns="http://www.ccc.com"/>

 </element>

</element>

эквивалентен документу

<aaa:element

 xmlns:aaa="http://www.aaa.com"

 xmlns:bbb="http://www.bbb.com"

 xmlns:ccc="http://www.ccc.com">

 <aaa:element/>

 <bbb:element>

  <bbb:element/>

  <ccc:element/>

 </bbb:element>

</aaa:element>

Таким образом, пространства имен — это механизм выделения в тексте XML-документа элементов и атрибутов, принадлежащих различным логическим схемам документов. Более того, термин "пространство имен" часто используется как эквивалент логической схеме документа, например, когда говорят "элемент template принадлежит пространству имен XSLT", подразумевается, что элемент template определен в языке XSLT и описывается в соответствующей схеме.

Синтаксические правила, которые описывают определения пространств имен, задаются не в спецификации XML, а в другом документе — в технической рекомендации "Namespaces in XML" (пространства имен в XML), которая доступна по адресу http://www.w3.org/TR/REC-xml-names. Для того чтобы отличать эти продукции от продукций языка XML, мы будет давать им номера вида [NS1], [NS2] и так далее.

Продукция NSAttName описывает имена атрибутов, декларирующих пространства имен:

[NS1] NSAttName       ::= PrefixedAttName | DefaultAttName

[NS2] PrefixedAttName ::= 'xmlns:' NCName

[NS3] DefaultAttName  ::= 'xmlns'

Имя NCName, которое использовалось в правиле PrefixedAttName, — это имя префикса, который будет использоваться для обозначения принадлежности элементов определенному пространству имен. Это имя отличается от имен, которые отвечают продукции Name тем, что оно не может содержать двоеточия:

[NS4] NCName     ::= (Letter | '_') (NCNameChar)*

[NS5] NCNameChar ::= Letter | Digit | '.' | '-' | '_'

                     | CombiningChar | Extender

Расширенные имена

Использование пространств имен значительно изменяет понятие имени. Действительно, если www:template, xsl:template или просто template могут быть одинаковыми именами, то именем в таком случае должна считаться не просто символьная последовательность, которая его составляет, а нечто большее.

Вследствие этого в спецификациях группы XML-языков вводится такое понятие, как расширенное имя, которое состоит из двух частей: локальной части и идентификатора пространства имен, которое соответствует префиксу имени.

Пример

Представим себе элемент вида

<xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform"/>

Расширенное имя этого элемента будет состоять из локальной, части stylesheet и идентификатора пространств имен http://www.w3.org/1999/XSL/Transform.

Расширенные имена считаются совпадающими, если их локальные части равны и, при этом, они относятся к одному пространству имен.

Префикс в расширенном имени может быть опущен. В таком случае идентификатор пространства имен будет либо выбран по умолчанию (если имеется соответствующее объявление), либо будет нулевым.

Для описания имен элементов и атрибутов, которые должны иметь расширенное представление, используется продукция QName:

[NS6] QName ::= (Prefix ':')? LocalPart

Нетерминалу Prefix соответствует префикс имени, который может быть опущен вместе со следующим за ним разделяющим двоеточием, LocalPart соответствует локальной части имени.

[NS7] Prefix    ::= NCName

[NS8] LocalPart ::= NCName

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

В погоне за выразительной мощностью XML не следует забывать один из основополагающих принципов — нужно не просто выражать информацию, нужно выражать ее стандартным образом. Это включает в себя не только синтаксические принципы разметки текста, изложенные выше, но и ограничения, накладываемые на логическую структуру документов. Изобретая свой собственный набор элементов и атрибутов, мы вместе с этим набором изобретаем логический формат, а именно то, каким образом элементы и атрибуты должны формировать документ, какая информация должна присутствовать обязательно, а какая является опциональной, какие данные должны содержать те или иные атрибуты и элементы.

В первой версии XML для определения логической структуры документов использовался набор формальных правил, называемый DTD — декларацией типа документа (document type declaration). Помимо этого, в начале мая 2001 года была принята новая техническая рекомендация языка под названием XML-схема (XML Schema), которая также формально задает логическую структуру документа, определяет используемые типы данных, количество повторений и многое другое.

В этой главе мы разберем основы логического построения ХМL-документов с использованием DTD.

Декларация типа документа (DTD)

Декларация типа документа состоит из одного или нескольких правил-ограничений структуры документа. В частности, DTD позволяет задавать следующие правила:

□ ELEMENT — определение элемента;

□ ATTLIST — определение списка атрибутов элемента;

□ ENTITY — определение сущности;

□ NOTATION — определение нотации.

Эти определения могут быть заданы с использованием конструкции DOCTYPE непосредственно в документе:

<!DOCTYPE advert [

<!-- определение -->

<!-- определение -->

и т.д.

]>

Другой возможностью определения декларации документа является использование внешнего файла:

<!DOCTYPE advert SYSTEM "advert.dtd">

В этом случае можно также дополнять внешние определения внутренними:

<!DOCTYPE advert SYSTEM "advert.dtd" [

<!-- определение -->

<!-- определение -->

и т.д.

]>

Декларация типа документа определяется следующей EBNF-продукцией:

[28] doctypedecl ::= '<!DOCTYPE' S Name (S ExternalID)? S?

                     ('[' (markupdecl | DeclSep)* ']' S?)? '>'

Имя, соответствующее продукции Name, которая идет следом за ключевым словом DOCTYPE, определяет имя корневого элемента ХМL-документа. В предыдущем примере в корне документа должен стоять элемент advert.

Выражение (S ExternalID) ? указывает на то, что декларация типа документа может указываться во внешнем источнике (например, в файле), который описывается внешним идентификатором ExternalID.

[75] ExternalID ::= 'SYSTEM' S SystemLiteral

                    | 'PUBLIC' S PubidLiteral S SystemLiteral

В случае системного идентификатора ("SYSTEM"), SystemLiteral определяет URI определения типа документа. В случае публичного идентификатора, к этому параметру добавляется PubidLiteral, сообщающий дополнительную информацию о ресурсе. Обрабатывающее программное обеспечение может включать в себя DTD для заданного публичного идентификатора. Например, документы, написанные на языке XHTML, должны начинаться следующим объявлением:

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML Basic 1.0//EN"

 "http://www.w3.org/TR/xhtml-basic/xhtml-basic10.dtd">

Программа, обрабатывающая документ с таким заголовком, сможет по публичному идентификатору понять, что документ создан на языке XHTML, а значит, обрабатывать его нужно в соответствии со стандартом этого языка. Если же обрабатывающая программа не в курсе определений XHTML, она сможет загрузить декларацию типа по адресу http://www.w3.org/TR/xhtml-basic/xhtml-basic10.dtd. Публичные идентификаторы, как правило, используются в языках, получающих широкое распространение, поскольку в этом случае формат логической структуры будет известен и без загрузки DTD.

Выражение ('[' (markupdecl | DeclSep) * ']' S?) ? в продукции doctypedecl означает, что в декларации типа документа в квадратных скобках может содержаться последовательность нетерминалов markupdecl и DeclSep.

Первый из этих нетерминалов, markupdecl, показывает, определения какого вида содержатся в DTD:

[29] markupdecl ::= elementdecl

                    | AttlistDecl

                    | EntityDecl

                    | NotationDecl

                    | PI

                    | Comment

С правилами PI и Comment мы уже знакомы — в данной продукции они показывают, что в DTD также можно использовать инструкции по обработке и комментарии.

Нетерминалы elementdecl, AttlistDecl, EntityDecl и NotationDecl соответствуют определениям элемента, списка атрибутов, сущности и нотации. Они будут подробно разобраны в следующих четырех разделах.

Нетерминал DeclSep соответствует разделителю объявлений, которые перечисляются в DTD. Этот разделитель может быть либо пробельным пространством, либо параметризованной сущностью:

[28а] DeclSep ::= PEReference | S

В случае, если определения в DTD разделяются сущностью-параметром, ее содержимое интерпретируется как обычные определения вида markupdecl.

Определение элемента

Определение элемента задает имя и тип содержимого элемента в следующем виде:

<!ELEMENT имя содержимое>

Имя элемента должно начинаться с буквы, подчеркивания ("_") или двоеточия (":") и содержать буквы, цифры, некоторые знаки пунктуации (такие, как "_" — подчеркивание, ":" — двоеточие, "." — точка, "-" — тире или знак минуса) и модифицирующие символы (см. разд. "Базовые продукции ХМL" данной главы).

Примером имени элемента может быть "A", "B:12", "MyEasyName", "doc.xml".

В качестве содержимого элемента может быть указано:

□ EMPTY, в случае, когда элемент обязан быть пустым;

□ ANY, в случае, когда элемент может содержать что угодно;

□ формальное правило, определяющее элементы, и данные, которые может содержать элемент, а также порядок их следования.

Первые два случая определения элемента довольно просты. Их использование может быть продемонстрировано на следующем примере:

Декларация

<!DOCTYPE advert [

<!ELEMENT advert ANY>

<!ELEMENT product ANY>

<!ELEMENT classified EMPTY>

]>

определяет документ с корневым элементом advert, в котором могут встречаться также элементы product и classified, причем элементы advert и product могут содержать любые данные и любые из объявленных элементов, а элемент classified всегда должен быть пустым.

Приведем пример документа, построенного в соответствии с этой декларацией.

Листинг 1.3. Документ с декларацией типа

<?xml version="1.0" encoding="UTF-8"?>

<!DOCTYPE advert [

<!ELEMENT advert ANY>

<!ELEMENT product ANY>

<!ELEMENT classified EMPTY>

]>

<advert>

 <product>

  Покупайте наших слонов!

 </product>

 <classified/>

</advert>

В третьем случае содержимое элемента определяется при помощи формальных правил, которые очень похожи на те, которые используются в расширенных формах Бэкуса-Наура. Подобно тому, как в EBNF формальные правила используются для того, чтобы стандартизировать последовательность символов, составляющую конструкции некоторого языка, в определениях элементов они используются для описания содержимого элемента — последовательности из символьных данных и дочерних элементов.

Количество, с которым элемент может появляться в этой последовательности, формально записывается с использованием символов-модификаторов "*", "?", "+", которые имеют следующие значения:

□ а? — означает, что элемент а может быть пропущен в последовательности;

□ а — означает, что элемент а должен присутствовать в последовательности на этом месте ровно один раз;

□ а* — задает последовательность из нуля или более элементов а;

□ a+ — задает последовательность из одного или более элементов а.

Кроме того, содержимое может моделироваться как перечисление и выбор элементов.

Элементы перечисляются через запятую в круглых скобках, например (a, b, c) — это последовательность, состоящая из элементов a, b, c. Такая запись означает, что первым должен идти элемент a, затем сразу же за ним элемент b и элемент c.

Выбор элемента задается аналогично перечислению, только разделительным символом является не запятая, а знак '|'. Например, (a | b | c) задает выбор одного из трех элементов a, b или c.

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

Пример

(a* | b? | с | d+)

определяет содержимое, как последовательность, состоящую из нуля или более элементов a или одного элемента b, который может быть пропущен, или ровно одного элемента с, или последовательностью, состоящей из одного или более элементов d.

Помимо этого, формальные правила могут использовать при записи другие формальные правила.

Пример

((a | b), (с | d))

задает содержимое, первым элементом которого является a или b, вторым — элемент с или d.

Содержимое элементов может также включать символьные данные, которые обозначаются при помощи ключевого слова #PCDATA (parsable character data — разбираемые символьные данные).

Пример

<!ELEMENT product (#PCDATA)>

означает, что элемент product должен содержать только символьные данные.

Помимо текста элементы могут также включать в себя другие элементы. Содержимое такого типа называется смешанным. Формальные правила смешанного содержимого должны всегда иметь вид (#PCDATA | ... | ... ) *.

При помощи формальных правил можно точно и гибко задавать логическую структуру элементов документа. В качестве примера приведем определения элементов для нашего документа с рекламным объявлением.

Пример

Предположим, мы хотим определить документ со следующей логической структурой:

□ корневым элементом документа является элемент advert;

□ элемент advert содержит последовательность, состоящую из нескольких элементов product и одного элемента classified, который может быть пропущен;

□ элемент product может содержать текст и другие элементы product в любом порядке;

□ элемент classified не имеет содержимого.

Документ соответствующей логической структуры может быть задан следующим образом.

Листинг 1.4

<?xml version="1.0" encoding="UTF-8"?>

<!DOCTYPE advert [

<!ELEMENT advert (product+, classified*)>

<!ELEMENT product (#PCDATA | product)*>

<!ELEMENT classified EMPTY>

]>

<advert>

 <product>

  Покупайте наших слонов!

 </product>

 <classified/>

</advert>

Определению элемента соответствует EBNF-продукция elementdecl:

[45] elementdecl ::= '<!ELEMENT' S Name S contentspec S? '>'

Нетерминал contentspec, следующий через пробельное пространство за именем элемента, определяет тип содержимого, которое может иметь этот элемент:

[46] contentspec ::= 'EMPTY' | 'ANY' | Mixed | children

Строка "EMPTY" соответствует пустому элементу, "ANY" — любому содержимому, нетерминал Mixed — смешанному содержимому, children — содержимому, которое определяется формальными правилами.

[47] children ::= (choice | seq) ('?' | '*' | '+')?

[48] cp       ::= (Name | choice | seq) ('?' | '*' | '+')?

[49] choice   ::= '(' S? cp ( S? '|' S? cp )+ S? ')'

[50] seq      ::= '(' S? cp ( S? ',' S? cp )* S? ')'

[51] Mixed    ::= '(' S? '#PCDATA' (S? '|' S? Name)* S? ')*'

                  | '(' S? '#PCDATA' S? ')'

Определение списка атрибутов

Список атрибутов некоторого элемента задается следующим образом:

<!ATTLIST элемент

 атрибут1 тип1 значение1

 атрибут2 тип2 значение2

 и т. д...>

В этом определении элемент задает имя элемента, для которого определяется данный список атрибутов, атрибут — имя атрибута, тип — тип атрибута и значение — значение атрибута.

Имя атрибута отвечает в XML тем же самым требованиям, что и имя элемента — оно должно начинаться с буквы и может содержать другие буквы, цифры и некоторые знаки препинания.

Тип атрибута может быть одним из следующих:

□ CDATA — символьные данные;

□ ID — уникальный идентификатор;

□ IDREF — ссылка на уникальный идентификатор;

□ IDREFS — набор ссылок;

□ ENTITY — сущность;

□ ENTITIES — набор сущностей;

□ NMTOKEN — именной токен;

□ NMTOKENS — набор именных токенов;

□ NOTATION — нотация;

□ перечисление возможных значений атрибута.

Следует поподробнее остановиться на типе ID, поскольку атрибуты этого типа играют важную роль в повышении эффективности обработки XML-документов. Атрибуты типа ID могут содержать значения, которые однозначным образом идентифицируют элемент в документе. То есть, если тип атрибута объявлен как ID, его значение должно быть уникальным внутри документа. Это позволяет создавать для элементов с ID-атрибутами индексы по значению атрибута, для более быстрого доступа. Например, в языке XPath, имеется функция id, которая по данному строковому параметру возвращает множество, состоящее из элемента, ID-атрибут которого совпадает с этим параметром. Естественно, тип ID не гарантирует, что доступ к элементам в любом случае будет производиться быстрее — это зависит от реализации обрабатывающих программ. Однако большинство современных XML-процессоров при работе с ID-атрибутами используют механизмы оптимизации.

Тип ID может быть полезен и при создании кросс-ссылок между элементами в самих XML-документах, для описания информации, структура которой выходит за рамки обычных деревьев. Уникальные значения, заданные в атрибуте ID могут использоваться в атрибутах типов IDREF (ссылка на идентифицирующее значение) и IDREFS (набор таких ссылок).

Значение определяет, как и какие значения должны быть присвоены атрибуту. Значением может быть:

□ ключевое слово #REQUIRED, которое показывает, что этот атрибут должен всегда присутствовать в элементе и иметь некоторое значение;

□ ключевое слово #IMPLIED, которое показывает, что атрибут является необязательным и может отсутствовать в элементе;

□ ключевое слово #FIXED, за которым следует значение, заключенное в кавычки — это задает атрибут, который всегда должен иметь одно и то же фиксированное значение;

□ значение, заключенное в кавычки, определяет значение атрибута по умолчанию.

Примеры

Декларация

<!ATTLIST product

 title CDATA #REQUIRED

 id ID #IMPLIED

 quantity CDATA "1"

 value CDATA #FIXED "дорого"

 color (серый|белый) "серый">

определяет в элементе product следующие атрибуты:

□ обязательный атрибут title, содержащий символьные данные;

□ необязательный атрибут id, который может содержать уникальный идентификатор элемента внутри документа;

□ атрибут quantity, который может и не присутствовать в документе — в этом случае его значение будет равно 1;

□ атрибут value, который всегда должен иметь значение "дорого";

□ атрибут color, который может иметь одно из значений — "серый" или "белый", по умолчанию "серый".

Разберем синтаксис определения списка атрибутов более детально. Этому определению соответствует следующее правило:

[52] AttlistDecl ::= '<!ATTLIST' S Name AttDef* S? '>'

В этом правиле Name задает имя элемента, a AttDef* — набор определяемых атрибутов. Каждый атрибут задается правилом AttDef:

[53] AttDef ::= S Name S AttType S DefaultDecl

Здесь Name — имя, AttType — тип, a DefaultDecl — значение атрибута по умолчанию.

[54] AttType ::= StringType | TokenizedType | EnumeratedType

В соответствии со спецификацией, значения атрибутов бывают трех видов — строки (StringType), токены (TokenizedType) и тип перечисления (EnumeratedType).

[55] StringType    ::= 'CDATA'

[56] TokenizedType ::= 'ID' | 'IDREF' | 'IDREFS' | 'ENTITY'

                       | 'ENTITIES' | 'NMTOKEN' | 'NMTOKENS'

Тип перечисления (EnumeratedType) может задаваться нотациями (NotationType) и собственно перечислениями (Enumeration):

[57] EnumeratedType ::= NotationType | Enumeration

[58] NotationType   ::= 'NOTATION' S

                        '(' S? Name (S? '|' S? Name)* S? ')'

Перечисление — это один или несколько именных токенов, которые разделены пробелами и знаками "|". Перечисление задает несколько возможных вариантов значения атрибута, например (серый | белый).

[59] Enumeration ::= '(' S? Nmtoken (S? '|' S? Nmtoken)* S? ')'

Значение атрибута описывается продукцией DefaultDecl следующим образом:

[60] DefaultDecl ::= '#REQUIRED' | '#IMPLIED'

                     | (('#FIXED' S)? AttValue)

Определение сущности

Для того чтобы обеспечить достаточно выразительную мощность документов, XML позволяет разбивать их на отдельные поименованные объекты, называемые сущностями. Сущности в XML не имеют ничего общего с сущностями в методологии "сущность-связь". Самый близкий аналог в традиционных языках программирования — это макроподстановка.

Существует два способа определения сущности — внутреннее и внешнее.

Первый способ используется для того, чтобы определить именованный текстовый объект в самом документе, а затем использовать его содержимое посредством ссылки.

Внутреннее определение сущности имеет вид:

<!ENTITY имя "значение">

Ссылка на сущность записывается как &имя; (амперсант, затем имя сущности, затем точка с запятой).

Пример

В документе

<?xml version="1.0" encoding="UTF-8"?>

<!DOCTYPE advert [

 <!ENTITY animal "слон">

]>

<advert>

 <product title="&animal;">

  Продается настоящий &animal;!

 </product>

</advert>

сущность animal имеет значение "слон". Ссылка на сущность используется дважды — в атрибуте title и в тексте элемента product. Этот документ эквивалентен документу

<?xml version="1.0" encoding="UTF-8"?>

<advert>

 <product title="слон">

  Продается настоящий слон!

 </product>

</advert>

Если в будущем фирма переквалифицируется, и будет продавать, скажем, жирафов, можно будет, не изменяя всего документа, заменить только значение сущности:

<?xml version="1.0" encoding="UTF-8"?>

<!DOCTYPE advert [

 <!ENTITY animal "жираф">

]>

<advert>

 <product title="&animal;">

  Продается настоящий &animal;!

 </product>

</advert>

Спецификация XML определяет несколько встроенных сущностей, которые перечислены в табл 1.1.

Таблица 1.1. Встроенные сущности XML

Имя сущности	Значение	Описание
lt	<	знак "меньше"
>gt	>	знак "больше"
amp	&	амперсант
apos	'	апостроф или одинарные кавычки
quot	"	двойные кавычки

Встроенные сущности могут быть использованы для замены некоторых символов там, где они могут быть восприняты, как разметка. В частности, символы < (знак "меньше") и & (амперсант) вообще не могут появляться в тексте документа иначе, кроме как в виде сущностей.

Пример

<?xml version="1.0" encoding="UTF-8"?>

<advert>

 <product title="слон">

  Продается серый слон весом > 5 тонн!

  Компания "слон & Слон".

 </product>

</advert>

На самом же деле в элементе product заключен текст

Продается серый слон весом > 5 тонн!

Компания "Слон & Слон".

Довольно часто бывает необходимо использовать в документе символы набора Unicode, обращаясь к ним по десятичным или шестнадцатеричным кодам. В таких случаях можно использовать символьные сущности.

Символьная сущность (или, как ее еще называют, символьная ссылка) записывается в виде &#код; или &#xкод;, где код — десятеричный и шестнадцатеричный Unicode-код символа в первом и втором случае соответственно.

Пример

Фраза "Миру-мир!" может быть записана с использованием символьных сущностей следующим образом:

&#х41С;&#х438;&#х440;&#х443; - мир!

Первое слово, "Миру" записано с использованием шестнадцатеричных unicode-кодов кириллицы, второе слово, "мир", записано с использованием десятичных кодов.

Внешние сущности содержатся во внешних файлах. Если ссылка на внешнюю сущность появляется в документе, то на ее место копируется содержимое внешнего файла.

Определение внешней сущности имеет следующий синтаксис:

<!ENTITY имя SYSTEM "URI">

В этом определении имя точно так же, как и во внутренней сущности определяет имя сущности, в то время как URI определяет абсолютное или относительное местоположение файла.

Пример

Предположим, что мы создали файл animal.ent со следующим содержанием:

огромное серое животное

Для того чтобы использовать содержимое этого файла в документе, мы должны объявить внешнюю сущность следующим образом:

<!ENTITY animal SYSTEM "ent/animal.ent">

где ent/animal есть относительный путь до файла animal.ent. Если бы мы расположили файл на сервере, скажем, www.animalhost.com, сущность могла бы быть объявлена как

<!ENTITY animal SYSTEM "http://www.animalhost.com/animal.ent">

В документе ссылаться на объявленную внешнюю сущность мы будем точно так же, как ссылались бы на внутреннюю сущность:

<?xml version="1.0" encoding="UTF-8"?>

<!DOCTYPE advert [

 <!ENTITY animal SYSTEM "ent/animal.ent">

]>

<advert>

 <product title="слон">

  Продается &animal; весом > 5 тонн!

  Рождественские скидки!

 </product>

</advert>

В этом случае элемент product будет иметь текст

Продается огромное серое животное весом > 5 тонн!

Рождественские скидки!

Внешняя сущность может быть также объявлена при помощи так называемого публичного идентификатора. В этом случае, при объявлении указывается не только местоположение сущности, но еще и идентификатор, который предоставляет программному обеспечению, обрабатывающему документ, некоторую дополнительную информацию. Например, в некоторых случаях XML-процессор может уже включать в себя определение внешней сущности, и ему не нужно будет получать содержимое файла, находящегося на удаленном сервере.

Такой способ определения внешней сущности имеет следующий синтаксис:

<!ENTITY имя PUBLIC "идентификатор" "URL">

Например, сущность animal мы можем переопределить как

<!ENTITY animal PUBLIC "-//ZOO//Elephant//Description"

 "http://www.animalhost.com/animal.ent">

Специальный процессор зоологических XML-файлов, встретив публичный идентификатор -//ZOO//Elephant//Description поймет, что речь идет о слоне, и не станет загружать файл animal.ent с удаленного сервера, вставив собственное описание слона.

Подводя итог, можно выделить следующие случаи, когда следует использовать сущности:

□ замена часто повторяющихся частей документа;

□ разбивка одного XML-документа на отдельные модули;

□ замена некоторых символов, которые иначе были бы восприняты, как разметка;

□ использование символов с соответствующими кодами Unicode.

Синтаксис использования сущностей в тексте документа довольно прост. Символьная сущность определяется продукцией CharRef следующим образом:

[66] CharRef ::= '&#' [0-9]+ ';' | "&#x' [0-9a-fA-F]+ ';'

CharRef — это либо десятичная, либо шестнадцатеричная символьная сущность. В первом случае вместо имени сущности стоит набор, цифр от 0 до 9, во втором — к этому набору добавляются буквы a, b, c, d, e, f в любом регистре символов. Ведущие нули не имеют никакого значения, &#х0020; точно так же, как и &#х20; соответствует пробельному символу.

Обычной сущности, объявленной внутри или вне документа, соответствует продукция EntityRef:

[68] EntityRef ::= '&' Name

Символьная и обычная сущности объединяются в продукцию Reference:

[67] Reference ::= EntityRef | CharRef

Здесь следует сделать небольшое отступление и сказать о том, что конструкции вида &имя; или &#xкод;, о которых мы говорили как о сущностях, на самом деле являются не сущностями, а ссылками на сущности. &#xкод; — это ссылка на символьную, а &имя; — на обычную сущность. Сама сущность — это именованный объект, к которому обрабатывающая программа должна обращаться при обработке ссылки с соответствующим именем. Однако, поскольку связь между сущностью и ссылкой на нее однозначна (одно не существует без другого), сами ссылки очень часто называют сущностями. Название продукции Reference переводится с английского как "ссылка", но пониматься в данном контексте может, в том числе, и как сущность.

Определение обычной сущности соответствует следующей продукции:

[71] GEDecl ::= '<!ENTITY' S Name S EntityDef S? '>'

Name, как обычно, определяет имя, a EntityDef, соответственно, значение сущности. Это значение может быть задано как внутри документа (первый вариант выбора, EntityValue), так и вне его (второй вариант, ExternalID NDataDecl?).

[73] EntityDef ::= EntityValue | (ExternalID NDataDecl?)

EntityValue — это всего лишь символьное значение, взятое в кавычки.

Второй вариант синтаксиса EntityDef соответствует определению внешней сущности, то есть сущности, определение которой не содержится в самом документе.

Внешние сущности могут быть двух типов:

□ разбираемые внешние сущности (англ. parsed entity) — данные, которые воспринимаются и обрабатываются как XML;

□ неразбираемые внешние сущности (англ. unparsed entity) — данные не-XML типа (например, изображения или бинарные файлы, которые необходимо использовать в данном документе).

Неразбираемые сущности определяются наличием нетерминала NDataDecl в определении.

[76] NdataDecl ::= S 'NDATA' S Name

Мы до сих пор не упомянули еще один важный случай сущности — параметризованные сущности или сущности-параметры. Сущности этого типа используются в DTD для более гибкого описания логической структуры документа.

Синтаксически сущности-параметры очень похожи на обычные сущности. При объявлении и использовании сущности-параметра ее имени должен предшествовать символ '%'. Отличием сущностей-параметров является то, что они определяются и используются только внутри DTD.

Пример

В качестве примера объявим параметризованную сущность coords, которую впоследствии будем использовать в определениях элементов:

<!ENTITY % coords "x, y, z">

Используя объявленную сущность-параметр, элемент sphere, состоящий из элементов x, y, z (координаты сферы) и R (радиус), можно определить следующим образом:

<!ELEMENT sphere (%coords;, R)>

Такое определение равносильно определению <!ELEMENT sphere (x, y, z, r) >, но при этом оно является гораздо более гибким — если в новой версии создаваемого XML-языка вдруг произойдет смена регистра имен элементов x, y и z на X, Y и Z, декларацию типа документа изменять не придется.

Сущности-параметры широко используются в спецификациях Консорциума W3. Язык XSLT тоже имеет свою декларацию типа документа, но ее невозможно будет понять, не понимая механизма сущностей-параметров.

Синтаксис использования сущности-параметра (вернее, ссылки на нее) соответствует продукции PEReference, которая практически совпадает с продукцией EntityRef:

[69] PEReference ::= '%' Name ';'

Определение сущности-параметра также очень схоже с определением обычной сущности:

[72] PEDecl ::= '<!ENTITY' S '%' S Name S PEDef S? '>'

[74] PEDef  ::= EntityValue | ExternalID

Продукция EntityDecl, соответствующая определению сущности, как обычной, так и сущности-параметра, имеет следующий вид:

[70] EntityDecl ::= GEDecl | PEDecl

Напомним, что GEDecl соответствует объявлению обычной, a PEDecl — параметризованной сущности.

Определение нотации

С точки зрения физической модели, XML-документы являются не более чем текстом. Содержимое документов и их разметка имеет исключительно текстовый вид. Вместе с тем, во многих случаях документы должны включать данные других форматов, например, графические изображения или двоичные файлы. Несовместимость физической реализации XML и внешних данных такого типа не позволяет включать их в документ посредством обычных сущностей — для этих целей используются неразбираемые сущности и нотации.

Нотация — это ни что иное, как определение формата неразбираемой сущности. Нотация дает формату имя и предоставляет некоторую информацию о приложении, которое следует использовать для обработки этого формата.

Пример

Предположим, что мы используем графические изображения в формате GIF, для просмотра которых используется приложение gif-viewer.exe. Определение нотации будет иметь следующий вид:

<!NOTATION GIF SYSTEM "gif-viewer.ехе">

Эта запись определяет нотацию с именем GIF и указывает имя приложения, которое может быть использовано для обработки внешних сущностей этого формата.

Информация о вспомогательном приложении-обработчике (англ. helper application) указывается при определении нотации системным или публичным идентификатором. В отличие от определения внешней сущности, публичный идентификатор в нотации может указываться без системного идентификатора. Фактически, нотация имеет три варианта определения:

<!NOTATION имя SYSTEM "системный ид-р">

<!NOTATION имя PUBLIC "публичный ид-р" "системный ид-р">

<!NOTATION имя PUBLIC "публичный ид-р">

Если информация о вспомогательном приложении несущественна, можно воспользоваться определением следующего вида:

<!NOTATION имя SYSTEM "">

Существует два основных способа применения нотаций. Первый — объявление неразбираемых сущностей и использование их имен в атрибутах типа ENTITY или ENTITIES, второй — указание имени нотации в атрибуте типа NOTATION для того, чтобы задать формат данных, который содержит данный элемент.

Первый способ можно продемонстрировать простым документом, который задает меню (листинг 1.5).

Листинг 1.5. Использование неразбираемых сущностей в атрибутах элементов

<!DOCTYPE menu [

 <!ELEMENT menu (menuitem*)>

 <!ELEMENT menuitem EMPTY>

 <!ATTLIST menuitem

  image ENTITY #REQUIRED

  title CDATA #REQUIRED

  href CDATA #REQUIRED>

 <!NOTATION gif SYSTEM "gif-viewer.exe">

 <!NOTATION jpg SYSTEM "jpg-viewer.exe">

 <!ENTITY news SYSTEM "news.gif" NDATA gif>

 <!ENTITY products SYSTEM "prod.jpg" NDATA jpg>

 <!ENTITY support SYSTEM "support.gif" NDATA gif>

]>

<menu>

 <menuitem image="news" title="News" href="news.htm"/>

 <menuitem image="products" title="Products" href="prods.htm"/>

 <menuitem image="support" title="Support" href="support.htm"/>

</menu>

Проанализируем декларацию типа этого документа.

□ Декларация типа <!DOCTYPE menu [..] > говорит о том, что корневым элементом этого документа является элемент menu.

□ В соответствии с определением <!ELEMENT menu (menuitem* )> этот элемент состоит из нескольких субэлементов menuitem.

□ В соответствии с определением <!ELEMENT menuitem EMPTY> элемент menuitem должен быть пустым.

□ Запись <!ATTLIST menuitem ... > определяет в элементе menuitem следующие атрибуты:

 • обязательный атрибут image, в котором должно указываться имя сущности;

 • обязательный атрибут title, содержащий символьные данные;

 • обязательный атрибут href, содержащий символьные данные.

□ Запись <!NOTATION gif SYSTEM "gif-viewer.exe"> определяет нотацию с именем gif и закрепляет за ней приложение gif-viewer.exe.

□ Запись <!NOTATION jpg SYSTEM "jpg-viewer.ехе"> определяет нотацию с именем jpg и закрепляет за ней приложение jpg-viewer.exe.

□ Запись <!ENTITY news SYSTEM "news.gif" NDATA gif> определяет внешнюю неразбираемую сущность с именем news, которая имеет формат (нотацию) gif.

□ Запись <!ENTITY products SYSTEM "prod.jpg" NDATA jpg> определяет внешнюю неразбираемую сущность с именем products, которая имеет нотацию jpg.

□ Запись <!ENTITY support SYSTEM "support.gif" NDATA gif> определяет внешнюю неразбираемую сущность с именем support, которая имеет нотацию gif.

Посмотрим теперь, какую информацию нам дают такие громоздкие определения. Обратимся к записи одного из элементов menuitem:

<menuitem image="products" title="Products" href="prods.htm"/>

С атрибутами title и href все ясно: они содержат простые символьные данные. Атрибут image несколько сложнее, он предоставляет гораздо больше информации. Типом этого атрибута является ENTITY, значит текст, который он содержит, является не просто символьными данными: он задает имя сущности, связанной с данным атрибутом. Иначе говоря, с атрибутом image связывается сущность.

Анализируя определение сущности products, обрабатывающая программа может понять, что это — неразбираемая внешняя сущность формата jpg, которая хранится в файле prod.jpg и для обработки которой можно использовать приложение jpg-viewer.exe.

Вторым способом использования нотаций является присвоение определенного формата содержимому элемента. Один (но не более чем один) из атрибутов элемента может иметь тип NOTATION. Значением этого атрибута должно быть имя нотации, которое и будет задавать формат содержимого элемента.

Пример

Листинг 1.6. Использование нотаций для определения формата содержимого элемента

<!DOCTYPE root [

 <!ELEMENT root (#PCDATA)>

 <!ATTLIST root

  type NOTATION (rtf|htm|txt) #REQUIRED>

 <[NOTATION rtf SYSTEM "winword.exe">

 <!NOTATION htm SYSTEM "iexplore.exe">

 <!NOTATION txt SYSTEM "notepad.exe">

]>

<root type="htm">

 <![CDATA[

  <html>

   <head>

    ...

   </head>

   <body>

    ...

   </body>

  </html>]]>

</root>

В этом документе определяется три нотации, три формата данных: rtf, htm и txt. Атрибут type элемента root указывает формат данных, которые содержатся в этом элементе — в данном случае это "htm" (что, очевидно, соответствует HTML-документу).

Несмотря на то, что нотации являются довольно мощным механизмом, ввиду очевидной сложности, широкого распространения их использование не получило. Почти того же самого эффекта можно добиться более простыми способами, например, используя в элементах дополнительные атрибуты.

Символьные данные в XML-документах

Каковы бы ни были структура и синтаксис текстового документа, основой его всегда являются символы. Для хранения и обработки текста на компьютерах, которые по своей природе являются цифровыми устройствами, каждому символу нужно поставить в соответствие числовой код.

Проблема многих языков заключается в том, что для них существует несколько альтернативных кодировок символов. Например, для кириллицы существуют такие кодировки, как CP-866, KOI8-R, CP-1251, ISO-8859-5, кодовая страница Macintosh и другие, но вместе с тем не существует единого стандарта, принятого де-факто. В итоге, для того, чтобы быть уверенным, что документ будет прочтен, его нужно представлять в трех или четырех кодировках, что очень неудобно.

Для того чтобы решить эти и некоторые другие проблемы, был создан стандарт Unicode. Unicode присваивает уникальный код любому символу, независимо от платформы, независимо от программы, независимо от языка. Символам кириллицы Unicode присваивает коды в диапазоне от #x400 до #x4ff. Таблица кодов для кириллицы может быть найдена в формате PDF на Web-сайте Unicode:

http://www.unicode.org/charts/PDF/U0400.pdf.

Использование Unicode

Для описания символов сотен языков всего мира, а также других символьных обозначений (например, математических символов) Unicode позволяет использовать три формы кодирования — UTF-8, UTF-16 и UTF-32.

UTF-8

В UTF-8 символы разных диапазонов кодируются последовательностями, состоящими из разного количества байт в соответствии со следующими правилами.

□ Символы с кодами в интервале #x0–#x7F кодируются одним байтом, первый бит которого равен нулю.

□ Для остальных символов число байт определяется количеством ведущих единиц первого байта последовательности.

□ Два первые бита каждого последующего байта равны единице и нулю соответственно.

□ Все остальные биты используются для кодирования символа.

В табл. 1.2 для каждого интервала символов показано количество байт, нужных для кодирования символа, форма кодирования и количество бит, доступных для кода.

Таблица 1.2. Формы кодирования символов в UTF-8

Диапазон	Кол-во байт	Форма кодирования	Кол-во бит
#x0-#x7F	1	0xxxxxxx	7
#x80-#x7FF	2	110xxxxx 10xxxxxx	11
#x800-#xFFFF	3	1110xxxx 10xxxxxx 10xxxxxx	16
#x10000- #x1FFFFF	4	11110xxx 10xxxxxx 10xxxxxx 10xxxxxx	21

К примеру, символу "Э" (заглавной русской букве "Э") Unicode присваивает код #x42D или 10000101101 в двоичном представлении. Это значение входит в интервал #x80-#x7ff, значит, для кодирования нужно использовать двух-байтовую форму вида 110xxxxx 10xxxxxx, где символы "x" обозначают 11 бит, доступных для кодировки. Таким образом, данному символу будет соответствовать следующий двоичный код:

11010000 10101101

или #xD0AD в шестнадцатеричном представлении.

Полужирным шрифтом выделены управляющие биты UTF-8 (110 означает, что символ закодирован двухбайтной последовательностью, 10 определяет второй байт последовательности), курсивом — биты кода символа.

Удобство UTF-8 заключается в том, что кодировка первых 127 символов совпадает с широко распространенной 7-битной кодировкой ASCII. Это делает возможным использование уже существующего программного обеспечения для обработки текста в UTF-8, например текстовых редакторов.

UTF-16

Для записи наиболее часто используемых символов с кодами, меньшими #xFFFF, UTF-16 использует двухбайтные последовательности, в которых каждый бит соответствует биту кода. Помимо этого, в UTF-16 могут быть также представлены символы с кодами в диапазоне #10000-#FFFFF. Для кодирования этих символов в UTF-16 применяются пары 16-битных значений в интервале #xD800-#xDFFF (ранее зарезервированные Unicode), называемые суррогатными парами (surrogate pairs). Младшие 10 бит каждого значения отводятся на кодировку символа, что в итоге дает 20 бит, достаточных для записи любого кода, не превышающего #xFFFFF (табл. 1.3).

Таблица 1.3. Формы кодирования символов в UTF-16

Диапазон	Кол-во байт	Форма кодирования	Кол-во бит
#x0-#xD7FF	2	xxxxxxxx xxxxxxxx	16
#xD800-#xDFFF		Зарезервированы
#xE000-#xFFFF	2	xxxxxxxx xxxxxxxx	16
#x10000-#xFFFFF	4	110110xxxxxxxxxx 110110xxxxxxxxxx	20

Примеры

Символ "Э" с кодом #x42D будет записан в UTF-16 в виде последовательности из двух байт — #x042D.

Для символа с кодом #x153DC (в двоичном представлении — 10101001111011100) понадобится 4 байта. Он будет записан в виде

1101100001010100 1101101111011100

или #xD854DBDC в шестнадцатеричном исчислении.

Полужирным шрифтом выделены управляющие биты UTF-16, курсивом — биты кода символа.

UTF-32

UTF-32 является самой простой формой кодирования — для каждого символа, вне зависимости от диапазона, используются 4 байта. Такой способ, несомненно, не является самым экономичным с точки зрения объема хранимой информации, но во многих случаях предоставляет определенные преимущества при обработке текста, так как символы не нужно декодировать.

Коды некоторых символов Unicode

В таблицах символов Unicode кодируются не только символы и знаки различных языков, но также и некоторые управляющие символы, например, неразрываемый пробел (no-break space), табуляция, перенос строки и так далее. Коды некоторых из этих символов, часто использующихся в XML-технологиях, мы приводим в табл. 1.4.

Таблица 1.4. Unicode-коды некоторых символов

Код	Обозначение	Описание
#х9	[НТ]	Горизонтальная табуляция (horizontal tabulation)
#xA	[LF]	Перевод строки (line feed)
#xD	[CR]	Возврат каретки (carriage return)
#x20	[SP]	Пробел (space)
#x21	!	Восклицательный знак (exclamation sign)
#x22	"	Двойные кавычки (quotation mark)
#x26	&	Амперсант (ampersand)
#x27	'	Апостроф или одинарные кавычки (apostrophe)
#x3C	<	Знак "меньше" или левая угловая скобка (less-than sign)
#x3F	?	Вопросительный знак (question mark)
#xA0	[NBSP]	Неразрываемый пробел (no-break space)

Коды многих других символов можно найти на Web-сайте Unicode Consortium в разделе Code Charts: http://www.unicode.org/charts/.

Базовые продукции XML

Теперь, когда мы разобрали модель символов Unicode, которая используется в XML, можно дать EBNF-определения основных базовых конструкций языка — символов, имен, именных токенов и их последовательностей.

В XML можно использовать любые символы Unicode, кроме суррогатных блоков и символов с кодами #xFFFE и #xFFFF:

[2] Char ::= #x9 | #xA | #xD | [#x20 - #xD7FF]

             | [#хЕ000 - #xFFFD) | [#х10000 - #x10FFFF]

Для удобства все множество символов разделено на несколько категорий.

□ Буквы, которые соответствуют продукции Letter, в свою очередь, делятся на основные (BaseChar) и идеографические (Ideographic). Буквы относятся к алфавитам, из которых состоят слова различных языков. Продукции букв чрезвычайно просты, но громоздки, поскольку перечисляют символы различных алфавитов. Читатель может легко найти их в технической рекомендации XML по адресу http://www.w3.org/TR/REC-xml.html под номерами [84] (Letter), [85] (BaseChar) и [86] (Ideographic).

□ Цифры, которые составляют в различных культурах числа. Цифры определяются продукцией Digit с номером [88].

□ Модифицирующие символы (CombiningChar), которые изменяют написание или звучание символов, как, например, #x308 — двойная точка сверху символа, которая используется для обозначения умляута в немецком и для замены e на ё в русском языке. Продукция CombiningChar имеет номер [87].

□ Символы расширения (Extender). Продукция Extender имеет порядковый номер [89].

Следующей простейшей символьной конструкцией является пробельное пространство S. Приведем еще раз его продукцию:

[3] S ::= (#х9 | #хА | #xD | #x20)+

Во многих продукциях XML-языков используются имена. Например, имена даются элементам, атрибутам, переменным XPath и так далее. В основе определения имени лежат именные символы NameChar:

[4] NameChar ::= Letter | Digit | CombiningChar | Extender

                 | '.' | '-' | '_' | ':'

Имя начинается либо буквой, либо символами "_" или ":" и состоит из последовательности именных символов:

[5] Name ::= (Letter | '_' | ' :') (NameChar*)

В некоторых правилах XML используется последовательность имен, соответствующая продукции Names:

[6] Names ::= Name (S Name)*

Кроме того, техническая рекомендация определяет так называемый именной токен NmToken — строку, которая может состоять из одного или более именных символов и последовательности таких токенов, NmTokens.

[7] NmToken  ::= (NameChar)+

[8] NmTokens ::= NmToken (S NmToken)*

Символьные данные могут заключаться в кавычки для того, чтобы формировать литералы. В XML определены следующие литералы: значение сущности (EntityValue), значение атрибута (AttValue), системный литерал (SystemLiteral), а также PubidLiteral — литерал, определяющий публичный идентификатор ресурса (см. раздел "Определение сущности" данной главы):

[9] EntityValue    ::= '"' ([^%&"] | PEReference | Reference)* '"'

                       | "'" ([^%&'] | PEReference | Reference)* "'"

[10] AttValue      ::= '"' ([^<&"] | Reference)* '"'

                       | ([^<&"] | Reference)* "'"

[11] SystemLiteral ::= ('"' [^"]* '"')

                       | ("'" [^']* "'")

[12] PubidLiteral  ::= '"' PubidChar* '"'

                       | "'" (PubidChar - "'")*

[13] PubidChar     ::= #x20 | #xD | #xA

                       | [a-zA-Z0-9] | [-'()+,./:=?;!*#@$_%]

В литералах EntityValue и AttValue допустимо использовать продукции сущностей (PEReference, Reference). Это означает, что при определении значений сущностей и атрибутов можно использовать ссылки на сущности, например, в элементе заданном как:

<song title="Крейсер "Aвpopa" "/>

атрибут title имеет значение крейсер "Аврора". Двойные кавычки были определены посредством встроенных сущностей.

Символьные данные, которые задаются продукцией CharData, могут состоять из любых символов, кроме символов "<" и "&", которые используются в XML в качестве управляющих. CharData главным образом используется в секциях CDATA, и, соответственно, не может содержать терминирующую последовательность "]]>".

[14] CharData ::= [^<&]* - ([^<&]* ']]>' [^<&]*)

XML-документы с точки зрения спецификации

Теперь, когда мы разобрали практически все структурные единицы XML, осталось определить стандартным образом синтаксис для самих XML-документов. Им соответствует продукция document:

[1] document ::= prolog element Misc

Итак, XML-документ состоит из пролога, единственного корневого элемента и дополнительного нетерминала Misc, который может включать инструкции по обработке, комментарии и пробельные символы:

[27] Misc ::= Comment | PI | S

Остановимся отдельно на прологе XML-документа. Пролог состоит из необязательной декларации XML (XMLDecl), необязательной декларации типа документа (doctypedecl), инструкций, комментариев и пробельных символов:

[22] prolog ::= XMLDeci? Misc* (doctypedecl Misc*)?

В зависимости от того, насколько строго документы соответствуют спецификации XML и собственным DTD-объявлениям, они могут быть хорошо оформленными (well-formed) и правильными (valid).

Хорошо оформленный документ соответствует всем синтаксическим правилам XML и некоторым дополнительным ограничениям, например:

□ имя открывающего тега элемента должно совпадать с именем его закрывающего тега;

□ имена атрибутов элемента не должны повторяться;

□ в значении атрибута нельзя использовать символ "<". Этот символ должен обязательным образом заменяться на сущность;

□ сущности должны быть определены до использования;

□ сущности-параметры могут быть использованы только в блоках DTD;

□ документ должен иметь единственный корневой элемент, содержащий все остальные элементы и символьные данные этого документа. Вне корневого документа допускаются только комментарии, инструкции по обработке, декларация XML и блок DTD.

Правильные документы должны быть хорошо оформленными, и при этом их логическая структура должна удовлетворять объявлениям, которые содержатся в декларации типа документа (DTD).

Для того чтобы документ мог быть обработан различными приложениями стандартным образом, он должен как минимум быть хорошо оформленным. Выполнение этого требования означает, что документ корректен с точки зрения синтаксиса, и для его логического представления можно использовать любую из стандартных моделей. Например, если в элементе документа приведены два атрибута с одинаковыми именами, возможно, с точки зрения автора, это логично и корректно, однако, стандартными средствами такой документ обработать не удастся.

Требование правильности означает четкое соответствие выбранной логической схеме документа. Объявления декларации типа документа накладывают на логическую структуру документа определенные ограничения с тем, чтобы он мог быть стандартным образом обработан не только синтаксическими, но и семантическими процессорами, то есть программами, которые не только могут распознать синтаксис XML-документа, но и "понять" его смысл, переданный разметкой.

Использование технологии XML

Вряд ли удастся описать все множество приложений и задач, в которых можно успешно применять XML-технологии, однако существуют области, в которых использование XML стало уже классикой. Чуть ниже мы рассмотрим несколько наиболее типичных классов задач XML.

Пока же необходимо сказать следующее — несмотря на всю мощь XML, это далеко не панацея и не решение всех проблем, которые могут возникнуть. Нужно хорошо понимать, что XML — это всего лишь формат описания данных. Четкий, конкретный, независимый, мощный формат описания данных — но не более! XML-технологии могут решить проблемы представления, несоответствия синтаксиса семантике и многие другие проблемы организации данных в документе, но они не смогут решить чисто программистских задач — как обрабатывать эти документы. XML не имеет особого смысла вне прикладных задач.

В качестве типичного примера можно привести язык XSLT (язык расширяемых стилей для преобразований, extensible Stylesheet Language for Transformations), который находится в фокусе этой книги. Программы, написанные на XSLT, называются преобразованиями, и они являются в прямом смысле XML-документами, но при этом удовлетворяют логической схеме языка XSLT. При этом преобразования не имели бы смысла без XSLT-процессора, который может применять их к другим документам. Они были бы просто текстом.

Создание XML-документов без программного обеспечения, которое будет понимать их семантику — это все равно, что писать программы на языке программирования, для которого не существует трансляторов и интерпретаторов. Они могут быть безупречно корректными, но совершенно бесполезными.

Стандартизированный и совсем не сложный синтаксис XML позволил многим компаниям разработать средства для синтаксического разбора XML-документов. Программы такого рода называют XML-парсерами (англ. parse — разбирать, анализировать). В настоящее время существует два основных типа XML-парсеров: SAX-парсеры и DOM-парсеры. Оба типа широко используются в различных приложениях — парсеры избавляют от необходимости писать собственные синтаксические анализаторы, штудировать спецификации и так далее. Мы коротко опишем каждый из этих типов.

SAX-парсеры

SAX расшифровывается как Simple API for XML, что означает буквально "Простой прикладной интерфейс программирования для XML". Это так и есть — идеология SAX очень проста. Программист должен описать, как следует обрабатывать ту или иную конструкцию документа, а парсер при обработке документа уже сам будет выполнять соответствующие действия. Иными словами, обработка документа производится в виде реакции на события, которые возникают, когда парсер встречает в документе тот или иной элемент, атрибут, комментарий и так далее.

В отличие от DOM-парсеров, SAX-парсеры не создают никакого внутреннего представления документа, оставляя эту задачу на совести программиста. Вследствие этого SAX-парсеры менее требовательны к ресурсам, что часто бывает критичным. Однако это никак не сказывается на их функциональности, таким образом SAX-парсеры являются незаменимыми инструментами для синтаксического разбора XML-документов. Зачастую, более сложные DOM-парсеры используют SAX как составную часть.

DOM-парсеры

Как уже было упомянуто абзацем выше, легкие SAX-парсеры не создают внутреннего представления ХМL-документов, вполне справедливо считая, что этим придется заняться программисту.

Вместе с тем, древовидная организация данных в ХМL-документах настолько очевидна, что внутренние представления, которые использовались в совершенно разных приложениях, совпадали практически в точности. Такая ситуация привела к решению разработать единый интерфейс не для обработчика документа, как это было сделано в SAX, а для внутреннего представления XML-документа целиком.

Набор таких интерфейсов получил название DOM (document object model, объектная модель документа). DOM-парсер обрабатывает документ, создавая при этом его внутреннее объектное представление. При этом DOM содержит только определения интерфейсов, никоим образом не регулируя внутреннюю реализацию самой модели документа. Все обращения к данным и структуре, которыми обладает документ, происходят посредством вызова методов, определенных в соответствующих интерфейсах.

Объектную модель документа полезно использовать там, где требуется работать с документом целиком, как с деревом. Представление всего документа будет занимать в памяти значительный объем, поэтому DOM резонно считается моделью, очень требовательной к ресурсам.

При выборе парсера необходимо хорошо понимать задачи, которые нужно будет решать при обработке документа. Во многих случаях совершенно необязательно целиком представлять документ в памяти. Будет вполне достаточным создать обработчик документа, и затем, при помощи SAX-парсера, произвести обработку без особых затрат ресурсов. Если же, напротив, при обработке важно иметь модель всего документа целиком, лучше использовать готовое решение в виде DOM-парсера.

Основные классы задач XML

В этой главе мы разберем несколько основных типов задач, для решения которых целесообразно применять XML. Естественно, этот список даже близко не претендует на полноту, так же, как нельзя, например, перечислить все программы, которые можно написать на языке Java. Несколько примеров предметных областей, которые будут приведены, иллюстрируют классические проблемы, с успехом решенные XML-технологиями.

Создание новых языков

Хотя мы и говорим об XML, как о формате описания данных, на самом деле XML — это метаязык, язык, который описывает другие языки. Строго говоря, когда мы создаем XML-документ, мы создаем его не на XML, а в соответствии с XML-синтаксисом. XML — это всего лишь набор синтаксических правил, не более. Настоящим языком в этой ситуации является то, что мы понимаем под логической, семантической схемой создаваемого документа.

Таким образом, каждый раз, когда мы описываем логическую схему документа, мы создаем новый язык с придуманной нами семантикой и XML-синтаксисом. Достоинством XML в данном случае является стандартность этого синтаксиса, поскольку заботиться о создании модуля для синтаксического разбора (парсера) уже не нужно.

Что же касается семантики языка, то во многих случаях древовидные XML-структуры очень хорошо подходят для ее описания, будь это язык формата документа или язык программирования.

Главным недостатком XML является громоздкость синтаксиса. Например, арифметическое выражение 2*2 может быть выражено в XML приблизительно как:

<mul>

 <arg>2</arg>

 <arg>2</arg>

</mul>

Очевидно, что с человеческой точки зрения это не самый компактный и элегантный способ.

На данный момент существует великое множество языков, созданных на основе XML. Мы перечислим несколько наиболее известных из них:

□ WML (Wireless Markup Language) — язык разметки для беспроводных устройств, основной формат данных для беспроводного протокола WAP;

□ SVG (Scalable Vector Graphics) — язык описания масштабируемой векторной графики;

□ XHTML — XML-совместимая версия языка гипертекстовой разметки документов;

□ SOAP (Simple Object Access Protocol) — XML-протокол для обмена информацией в распределенных системах;

□ RDF (Resource Description Framework) — система описания ресурсов;

□ XML/EDI (XML/Electronic Data Interchange) — XML-язык для представления сообщений EDI в системах В2В и электронной коммерции;

□ OML (Ontology Markup Language) — язык для описания онтологий и тезаурусов;

□ VoxML (Voice Markup Language) — язык разметки для голосовых приложений;

□ MathML (Mathematical Markup Language) — язык для описания математических выражений;

□ CML (Chemical Markup Language) — язык для описания химических формул;

□ UML exchange Format — XML-выражения языка UML (Unified Modeling Language);

□ CDF (Channel Description Format) — язык для описания данных для автоматической доставки клиенту (технология push-каналов).

Несмотря на то, что XML это язык разметки, он вполне подходит для создания языков программирования. Самым лучшим примером является язык XSLT, которому посвящена эта книга. Кроме того, существует множество менее известных языков, например XML-версия функционального языка Lisp, язык HaXML и другие.

Хранение данных

Практические всегда, когда приложение должно хранить данные во внешних файлах, неизбежны два процесса: парсинг (синтаксический разбор) при считывании данных и сериализация (создание физического выражения состояния объектов) при сохранении (рис. 1.2).

Рис. 1.2. Стандартная схема хранения данных

Использование XML в приведенной выше схеме как формата хранения позволяет использовать вместо парсера и сериализатора стандартные XML-инструменты, так что необходимость писать что-то свое отпадает. Кроме того, поскольку сохраняемый в этом случае документ имеет XML-формат, приложение становится совершенно открытым для интеграции с другими системами, ведь обмен данными может быть осуществлен без каких-либо специальных конверторов (рис. 1.3).

Рис. 1.3. Схема хранения данных в формате XML

Помимо перечисленных выше достоинств предлагаемого способа следует упомянуть также и следующее:

□ хранимые в XML данные могут иметь практически любую сложность; она ограничена лишь концептуальной сложностью древовидных структур;

□ хранимые в XML данные можно снабжать метаинформацией (например, комментариями или инструкциями по обработке);

□ XML как формат пригоден даже для хранения двоичных данных, если они будут преобразованы в подходящую текстовую кодировку;

□ SAX и DOM/XPath-интерфейсы обеспечивают эффективный доступ к XML-данным.

Противопоказаний к использованию XML в качестве формата хранения данных очень мало. Во-первых, разработчик может посчитать нерациональным включение объемных XML-библиотек в приложение размером в 10 Кбайт. Во-вторых, XML-формат это не самый компактный способ хранения данных. В-третьих, открытость внешним приложениям также может быть лишней.

Обмен данными и проекты интеграции

Большое количество систем, стандартов и технологий, о которых мы говорили ранее, приводит к тому, что эффективно связать разные источники данных в одну систему не получается. Даже такие, казалось бы, однородные источники, как системы управления базами данных, применяют языки запросов и форматы представления выбираемой информации, которые редко полностью совместимы между собой. Как следствие, проекты интеграции в таких условиях требуют больших усилий — требуется вникать в детали различных баз данных, протоколов, операционных систем и так далее.

В результате интеграция нескольких приложений или систем реализуется по схеме, показанной на рис. 1.4.

Рис. 1.4. Типичная схемаинтеграции нескольких приложений

Несложно оценить трудозатраты подобного рода проекта. Заставить разные системы работать вместе — чрезвычайно трудоемкая задача.

Идея использования XML в интеграции информационных систем сводится к созданию общего XML-языка, которым могла бы пользоваться каждая из них.

Такое решение сразу же намного упрощает проект — ведь вместо реализации взаимодействия между каждой парой систем следует всего лишь научить каждую из них "говорить" на созданном XML-языке. Иначе говоря, все сводится к разработке нескольких врапперов (англ. wrapper — упаковщик, программное средство создания системной оболочки для стандартизации внешних обращений и изменения функциональной ориентации действующей системы), которые будут переводить со стандартного XML-языка интегрированной системы на язык, понятный каждой системе в отдельности.

В принципе, интеграция по XML-схеме (рис. 1.5) не отличается коренным образом от интеграции на основе любого другого общего стандарта. Вместе с тем, она имеет целый ряд весомых преимуществ:

□ XML-языки не зависят от аппаратных и программных платформ, что позволяет связывать разнородные системы;

□ выразительная мощность XML достаточно велика для того, чтобы описать данные практически любой сложности;

□ средства разработки и стандартные библиотеки для XML существуют практически на всех платформах и для большинства популярных языков программирования;

□ методы работы с XML достаточно стандартны для того, чтобы в разных системах можно было пользоваться одинаковыми приемами;

□ информация, оформленная в виде XML, может обрабатываться не только машинами, но и человеком (что намного облегчает отладку).

Рис. 1.5. Интеграция на основе XML

Краткая история XML

XML основывается на принципах и соглашениях двух существующих языков разметки, XML и SGML, каждый из которых получил широкое распространение и успешно использовался для решения своего круга задач.

Несмотря на то, что идеи обобщенной разметки начали появляться еще в 60-х годах, SGML (standard generalized markup language, стандартный язык обобщенной разметки) был ратифицирован Международной Организацией Стандартизации (ISO) только в 1986 году. Возможно, будет показательным тот факт, что SGML не требовал изменений в течение, практически, 10 лет — настолько мощным инструментом он был.

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

Примерно в то же время произошел квантовый скачок в другой области информационных технологий. Развитие сетевых технологий вывело инфраструктуру обмена информации на качественно новый уровень, произведя на свет глобальную сеть Интернет. Интернет, в свою очередь, стал платформой для обмена гипертекстовыми документами, которые также нуждались в простом стандартном языке разметки для базового форматирования текста, создания таблиц и гиперссылок. Для этих целей был разработан HTML — язык разметки гипертекста (hypertext markup language).

HTML основывался на синтаксисе SGML, принципы этой технологии были практически проигнорированы. Только намного позже HTML стал SGML- совместимым языком. Ограниченность и нерасширяемость HTML вела к тому, что производители браузеров (программ просмотра) вводили собственные, в большинстве случаев несовместимые, расширения, что в итоге привело к довольно плачевной ситуации в этой области.

Потребность в улучшении HTML совпала с потребностью в упрощении SGML. В 1996 году Консорциум W3 (World Wide Web Consortium, W3C) поддержал группу Web SGML Activity, задачей которой было создание нового языка разметки, более мощного, чем HTML, но более простого, чем SGML.

Разработка началась с определения десяти положений, которым должен был соответствовать новый язык. Хотя эти положения и не являются определяющими для уже созданного языка, они все еще включаются в официальную спецификацию XML (п. 1). Думается, будет довольно интересно сравнить первоначальные устремления с тем, что получилось на самом деле. Попытаемся подробнее рассмотреть десять положений XML.

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

2. XML должен поддерживать разнообразные приложения. Как уже было описано выше, XML можно использовать в самых разных областях — тут сказывается мощь абстракции, которую предоставляет древовидные представления данных.

3. XML должен быть совместим с SGML. XML был разработан, как подмножество языка SGML, и для его обработки можно использовать любые SGML-продукты.

4. Разработка программ для обработки XML-документов не должна быть сложной задачей. Конструктивный синтаксис XML намного проще, по сравнению с SGML, а значит, XML-инструменты также проще разрабатывать и использовать в своих решениях.

5. Количество необязательных особенностей XML должно быть как можно меньше, в идеале их не должно быть вовсе. Сложно сказать, насколько это положение было выполнено — ведь большинство особенностей в XML являются необязательными. С другой стороны, в XML, как правило, существует только один способ добиться желаемого эффекта — в этом смысле опций, действительно, немного.

6. XML-документы должны быть понятны человеку, и при этом достаточно ясны. Как мы уже могли убедиться, XML-документы имеют простую и понятную форму.

7. XML должен быть разработан быстро. Разработчикам понадобилось два года — с 1996 по 1998, чтобы создать XML — значительный срок для довольно простого языка.

8. Спецификация XML должна быть формальной и лаконичной. Синтаксис языка XML однозначно определяется EBNF-правилами, а сама спецификация не имеет двояких толкований.

9. XML-документы должны легко создаваться. Поскольку UTF-8, основная форма кодирования XML-документов, совместима с ASCII, для редактирования XML-документов можно использовать все множество инструментов для работы с обычными текстовыми файлами.

10. Лаконичность разметки XML-документов не является важной. Язык SGML позволял авторам документов опускать части разметки в случаях, когда из контекста ясно, что там должно быть. Подобный принцип был использован в HTML, где в некоторых случаях можно опускать закрывающие теги, например, </p>. Для того, чтобы облегчить обработку, XML не позволяет такой вольности.

Главную роль в создании XML приписывают техническому гуру из фирмы Sun, Йону Босаку (Jon Bosak). Босак и его команда сделали с SGML примерно то же, что когда-то сделала команда, создававшая язык Java с языком С++. Язык был упрощен, сложные и редко использующиеся его особенности были упразднены. Первая спецификация языка, редакторами который были Тим Брэй (Tim Bray) и С.М. Шперберг-МакКвин (С.М. Sperberg-McQueen), в общей сложности насчитывала 26 страниц, что примерно в 20 раз меньше по объему стандарта SGML.

В октябре 2000 года с небольшими изменениями была принята вторая редакция спецификации языка XML. Судя по всему, язык оказался настолько удачным, что пройдет довольно значительное время прежде, чем он будет изменен.

Будущее XML практически гарантировано. Несмотря на всю поднятую маркетинговую шумиху, в которой XML — не более чем "buzzword", расхожее словечко, нельзя игнорировать два следующих обстоятельства. Во-первых, без сомнения, существует огромная потребность в простом языке обобщенной разметки, и, во-вторых, у XML просто нет конкурентов. Большие компании уже приняли XML, как стандартное средство, в составе многих своих решений, и вряд ли какая другая технология сможет в скором времени вытеснить этот язык.

Вместе с тем, было бы ошибкой считать, что XML пришел на замену HTML и SGML. Совсем нет — XML занимает те ниши, которые ранее были недоступны этим двум языкам. В информационном мире всегда будет место для каждого из них, хотя, вполне закономерно ожидать, что XML-технологии получат со временем гораздо более широкое распространение, чем HTML и SGML вместе взятые.

Глава 2 Введение в XSLT

Документ = Данные + Структура

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

По большому счету, здесь XML заканчивается. Это не язык программирования, не язык операторов и функций, но язык структуры документа. Язык для простого и при этом очень четкого ее описания.

Важность роли, которую играет структура данных в программировании, сложно переоценить. В классической цитате Н. Вирта "Алгоритмы + Структуры данных = Программы", датированной 1976 годом, спустя четверть века "плюс" следует скорее трактовать, как знак умножения, но принцип остался верен: структура данных имеет ничуть не меньшее значение, чем алгоритм, который ее обрабатывает.

Успех XML можно, пожалуй, объяснить другим уравнением:

Документ = Данные + Структура

В примитивной трактовке это означает, что для того, чтобы получить программу, к документам остается только дописать алгоритмы — данные и структура уже имеются. Если присмотреться более внимательно, можно заметить, что структура данных в равенстве Вирта и структура, которая является одной из составляющих документа, на самом деле могут быть (и, как правило, бывают) очень разными. Положение усугубляется еще и тем, что для одних и тех же данных можно выдумать великое множество типов структур, мало совместимых между собой. Таким образом, для того, чтобы эффективно использовать XML, во многих случаях необходимо уметь преобразовывать структуру XML-документов.

Как оказалось, традиционные процедурные языки программирования плохо подходят для решения этой задачи: слишком громоздкими были в них программы для преобразования структуры. Объяснить это легко — большинство языков оперировали данными и к арифметике структур документов были мало приспособлены. Проблема требовала более гибкого и мощного решения, и этим решением стал язык XSLT.

XSLT означает extensible Stylesheet Language for Transformations, что на русский язык традиционно переводится как "расширяемый язык стилей для преобразований". Название это скорее историческое, нежели смысловое — работа над XSLT была инициирована проектом XSL — extensible Stylesheet Language (расширяемым языком стилей).

Спецификация XSLT гласит, что это язык для преобразования одних XML-документов в другие XML-документы. Вне всякого сомнения, таковой и была изначальная идея XSLT. Очевидно, в процессе разработки язык перерос ее и теперь уместнее согласиться с редактором новой версии языка, Майклом Кеем (Michael Kay) в том, что XSLT — это язык для преобразования структуры документов.

XSLT как язык

По большому счету, любое преобразование можно условно поделить на три составляющие:

□ обращение к преобразуемому объекту;

□ создание результата преобразования;

□ логика, связывающая первые два действия и направляющая процесс преобразования.

Применительно к преобразованию XML-документов первая подзадача означает получение информации, которую этот документ содержит — в том числе и информации о структуре, которая является неотъемлемой его частью. Обращение в данном случае имеет несколько смыслов, в том числе — опрашивать, делать запросы, вычислять, выбирать; в общем смысле — задавать о документе вопросы и получать на них ответы. Для этой цели в XSLT служит язык, называемый XPath — язык путей в ХМL-документах (от англ. XML Path Language). Как мы увидим, XPath является лаконичным, но при этом чрезвычайно мощным средством обращения к XML-документам (а также к их частям). Роль XPath в XSLT так велика, что их можно было бы считать единым целым, если бы только XPath не использовался также и в других языках, предназначенных для работы с XML.

Вторая и третья условные части преобразования являются прерогативой самого XSLT. XSLT — это XML-язык в полном смысле этого слова: программы на XSLT (мы будем называть их преобразованиями сообразно их предназначению) являются хорошо оформленными (well-formed) XML-документами. XSLT также использует пространства имен; практически все имена, встречающиеся в XSLT, как-то: имена переменных, шаблонов, форматов и так далее — рассматриваются как расширенные имена, характеризуемые локальной частью вкупе с URI — уникальным идентификатором пространства имен.

В отличие от традиционных императивных языков программирования, преобразование в XSLT не является последовательностью действий, которую необходимо выполнить для достижения результата. Преобразование — это набор шаблонных правил, каждое из которых определяет процедуру обработки определенной части документа. Иными словами, преобразование в XSLT объявляет, декларирует правила преобразования — правила, применяя которые к входящему документу, XSLT-процессор в конечном итоге генерирует выходящий документ, который и является целью преобразования.

В качестве первого примера XSLT-преобразования, который будет приведен в этой книге, мы рассмотрим классическую программу "Hello, world!". Листинг 2.1 показывает XSLT-интерпретацию "Hello, world!", когда мы преобразуем документ

<msg>Hello, world!</msg>

в документ вида:

<message>Hello, world!</message>

Листинг 2.1. Преобразование "Hello, world!"

<xsl:stylesheet

 version="1.0"

 xmlns:xsl="http://www.w3.org/1999/XSL/Transform">

 <xsl:template match="msg">

  <message>

   <xsl:value-of select="."/>

  </message>

 </xsl:template>

</xsl:stylesheet>

Исходный код, представленный выше, является хорошо оформленным XML-документом. Корневым его элементом является элемент xsl:stylesheet, который и обозначает преобразование. Атрибут version указывает на версию языка XSLT, в соответствии с которой был построен этот документ; помимо этого в элементе xsl:stylesheet объявляется пространство имен с префиксом xsl, которому соответствует URI "http://www.w3.org/1999/XSL/Transform". Все элементы преобразования, принадлежащие пространству имен с этим URI, будут восприняты процессором, как принадлежащие языку XSLT.

Элемент xsl:stylesheet имеет один-единственный дочерний элемент xsl:template, который и задает правило преобразования. Атрибут match указывает, что это правило должно обрабатывать элемент msg. Содержимое xsl:template является телом шаблона. Оно выполняется тогда, когда сам шаблон применяется к некоторой части документа. В данном случае тело шаблона будет выполнено, когда само правило будет применяться к элементу msg.

Телом шаблона является элемент message. В терминах XSLT, этот элемент является литеральным элементом результата: он не принадлежит пространству имен XSLT и поэтому при обработке будет просто скопирован в результирующий документ. Содержимое этого элемента будет также обработано и включено в его сгенерированную копию.

Содержимым элемента message является элемент xsl:value-of, который, в отличие от message принадлежит XSLT. Элемент xsl:value-of вычисляет XPath-выражение, заданное в его атрибуте select, и возвращает результат этого вычисления. XPath-выражение, ".", указанное в select, возвращает ту самую часть узла, которая обрабатывается в данный момент, иначе говоря — элемент msg.

Переводя на русский язык все вышеперечисленное, можно сказать, что приведенное преобразование содержит единственное правило: если в документе встретится элемент msg, создать в выходящем документе элемент message и включить в него содержимое элемента msg.

Синтаксис XSLT, являющийся чистым XML, может показаться для языка программирования не совсем обычным, однако, как показывает практика, вряд ли какой другой синтаксис был бы более удобным. В конце концов, XSLT — это, прежде всего преобразование XML-документов, и уж на чем, как не на XML описывать правила этого преобразования. Кроме того, XML- формат самого преобразования позволяет использовать для его представления те же модели данных, что и для преобразуемых документов.

Совсем иным является язык XPath, который представлен в нашем примере лаконичным выражением ".". XPath не придерживается XML-синтаксиса, напротив, он скорее похож на синтаксис путей в операционных системах — в главе 4 мы покажем, насколько верно это сравнение.

В приведенном преобразовании участвовала и третья синтаксическая конструкция, которая называется в XSLT паттерном (от англ. pattern — образец). Паттерн msg, заданный в атрибуте match элемента xsl:template указывает, какая именно часть XML-документа должна быть обработана этим правилом. Синтаксически паттерны являются XPath-выражениями (но не наоборот), однако смысл их различается. XPath-выражения вычисляются и возвращают результат, паттерны же просто устанавливают соответствие некоторому образцу. В нашем преобразовании паттерн msg указывает, что шаблон должен обрабатывать только элементы msg и никакие другие.

Каждое из шаблонных правил может вызывать другие шаблонные правила — в этом случае результат выполнения вызванных шаблонов включается в результат выполнения шаблона, который их вызывал. Для того чтобы продемонстрировать этот принцип мы немного перепишем шаблон "Hello, world!" с тем, чтобы он возвращал результат в виде HTML-документа.

Листинг 2.2. Преобразование "Hello, world!"' с результатом в HTML

<xsl:stylesheet

 version="1.0"

 xmlns:xsl="http://www.w3.org/1999/XSL/Transform">

 <xsl:template match="/">

  <html>

   <head>

    <title>Message</title>

   </head>

   <body>

    <xsl:apply-templates select="msg"/>

   </body>

  </html>

 </xsl:template>

 <xsl:template match="msg">

  <b>

   <xsl:value-of select="."/>

  </b>

 </xsl:template>

</xsl:stylesheet>

Результат применения этого преобразования к документу

<msg>Hello, world!</msg>

иллюстрирует листинг 2.3.

Листинг 2.3. Результат выполнения преобразования

<html>

 <head>

  <title>Message</title>

 </head>

 <body>

  <b>Hello, world!</b>

 </body>

</html>

В это преобразование мы добавили еще одно шаблонное правило:

<xsl:template match="/">

 <html>

  <head>

   <title>Message</title>

  </head>

  <body>

   <xsl:apply-templates select="msg"/>

  </body>

 </html>

</xsl:template>

Это правило определяет обработку корневого узла — в атрибуте match указан паттерн "/", что соответствует корню документа. Шаблон создает элементы html, head, title, body и в последний включает результат применения шаблонов к элементу msg. Сравнивая тело этого шаблона с результатом выполнения преобразования, можно заметить, что процессор скопировал все элементы, не принадлежащие XSLT, не изменяя их, а элемент xsl:apply-templates выполнил, применив шаблон к элементу msg и включив в body результат (он выделен в листинге полужирным шрифтом).

Продемонстрированная возможность вызова одних правил из других, а также наличие в XSLT таких управляющих конструкций, как xsl:if, xsl:choose и xsl:for-each позволяет простым набором правил реализовывать очень сложную логику преобразования. В XSLT применяется один из основных принципов эффективной разработки: для того чтобы решить задачу, нужно разбить ее на более мелкие части и решить каждую из них по отдельности. Проблемой в данном случае является преобразование, и вместо того, чтобы описывать его целиком, XSLT позволяет определить простые правила обработки каждой из частей, связав эти правила логикой взаимных вызовов и управляющих конструкций.

Отсутствие "побочных" эффектов

Одним из краеугольных принципов XSLT, с которым, увы, нелегко смириться разработчику, работавшему только с процедурными языками, — это отсутствие "побочных" эффектов. Под побочными эффектами в данном случае понимаются изменения в окружении преобразования, которые отражаются на дальнейшем его выполнении.

Концепция отсутствия побочных эффектов берет начало в функциональном программировании, а оно, в свою очередь, в "чистых" математических функциях, не изменяющих своего окружения в процессе вычисления. Например, функция

f(x, у) > вернуть x + у;

будет чистой функцией. Сколько бы раз мы ее не вызывали, ее результат все равно будет равен сумме аргументов. Кроме того, результат вычисления f(f(x₁, y₁), f(x₂, y₂)) будет равен x₁ + y₁ + x₂ + y₂, в каком бы порядке мы не вычисляли эти функции:

f(f(x₁, y₁), f(x₂, y₂)) = f(x₁ + y₁, f(x₂, y₂)) = x₁ + y₁ + f(x₂, y₂) = x₁ + y₁ + x₂ + y₂

f(f(x₁, y₁), f(x₂, y₂)) = f(f(x₁, y₁), x₂ + y₂) = f(x₁, y₁) + x₂ + y₂ = x₁ + y₁ + x₂ + y₂

f(f(x₁, y₁), f(x₂, y₂)) = f(x₁, y₁) + f(x₂, y₂) = x₁ + y₁ + f(x₂, y₂) = x₁ + y₁ + x₂ + y₂

и так далее.

Представим теперь похожую функцию, обладающую побочным эффектом:

f(x, у) → z присвоить x; увеличить z на у; вернуть z;

В данном случае побочный эффект состоит в изменении значения переменной z. В этом случае результат вычисления выражения f(z, f(x, у)) строго зависит от того, в каком порядке будут вычисляться функции — в одних случаях результатом будет x + у + z, в других 2∙x + 2∙у. Для того чтобы результат вычислений с побочными эффектами был детерминирован, требуется строгая определенность в порядке действий. В XSLT же эта строгая определенность отсутствует, преобразование — это набор правил, а не последовательность действий.

Таковы теоретические посылки отсутствия побочных эффектов. Главным практическим ограничением является то, что преобразования не могут во время выполнения изменять переменные — после того, как переменной присвоено некоторое начальное значение, измениться оно больше не может.

Сильнее всего это ограничение сказывается на стиле XSLT-программирования. Он становится ближе к функциональному стилю таких языков, как Lisp и Prolog. Научиться соответствовать этому стилю просто, хотя поначалу он и будет казаться неудобным.

Расширения

Слово extensible (англ. расширяемый) в расшифровке аббревиатуры XSLT исторически происходит из названия языка XSL, но оно вполне применимо и к самому XSLT: спецификация этого языка позволяет разрабатывать собственные функции и элементы и использовать их в преобразованиях.

Применительно к преобразованиям структуры, XSLT является чрезвычайно мощным языком, но в то же время вычислительная его часть страдает. В языке XPath, на который переложена задача вычислений в XSLT, есть основные арифметические и логические операторы, небольшая базовая библиотека функций для работы с различными типами данных — но не более. XPath мало подходит для действительно сложных вычислительных задач. Что касается самого XSLT, набор элементов этого языка можно назвать вполне достаточным для большинства задач. Но и тут встречаются приложения (и разработчики), которые требуют большего.

Следуя спецификации, большинство реализаций XSLT предоставляет интерфейсы для разработки собственных функций, немного реже — элементов. Расширения пишутся на обычных языках программирования, таких как Java или С, но используются в XSLT так же, как использовались бы обычные функции и элементы.

Технология расширений делает XSLT поистине универсальным языком, ведь получается, что в нем можно использовать любые вычисления, которые только могут быть описаны в классических языках программирования.

К сожалению, вследствие различий в интерфейсах расширений, их использования приводит к потере переносимости между платформами и процессорами. Если преобразования, созданные в соответствии со стандартом языка, будут, как правило, без проблем выполняться различными процессорами, использование расширений в большинстве случаев ограничивает переносимость преобразования.

Преобразования снаружи

В общем случае в преобразовании участвуют три документа:

□ входящий документ, который подвергается преобразованию;

□ документ, который описывает само преобразование;

□ выходящий документ, который является результатом преобразования.

Само по себе преобразование это всего лишь XML-документ, не более чем описание правил, в соответствии с которыми входящий документ должен трансформироваться в исходящий. Процесс преобразования входящего документа в соответствии с описанными правилами называется применением преобразования к входящему документу или просто выполнением данного преобразования.

Выполнением преобразований над документами занимаются специальные программы, которые называются XSLT-процессорами. В первом приближении схема преобразования приведена на рис. 2.1.

Рис. 2.1. Схема XSLT-преобразования

Процессор получает входящий документ и преобразование, и, применяя правила преобразования, генерирует выходящий документ — такова в общем случае внешняя картина. На самом деле процессор оперирует не самими документами, а древовидными моделями их структур (рис. 2.2.) — именно структурными преобразованиями занимается XSLT, оставляя за кадром синтаксис, который эти структуры выражает.

Рис. 2.2. Древовидные структуры в XSLT

Несмотря на то, что для XSLT как для языка совершенно неважно, в каком виде находятся документы изначально (главное — чтобы была структура, которую можно преобразовать), абсолютное большинство процессоров может работать с документами, которые физически записаны в файлах. В этом случае процесс обработки делится на три стадии.

□ XSLT-процессор разбирает входящий документ и документ преобразования, создавая для них древовидные структуры данных. Этот этап называется этапом парсинга документа (от англ. parse — разбирать).

□ К дереву входящего документа применяются правила, описанные в преобразовании. В итоге процессор создает дерево выходящего документа. Этот этап называется этапом преобразования.

□ Для созданного дерева генерируется физическая сущность. Этот этап называется этапом сериализации.

Хотя практически все процессоры выполняют каждый из этих трех этапов (получают входящие документы и выдают результат их трансформации), рабочей областью XSLT является только второй этап, этап преобразования. XSLT практически не контролирует парсинг входящего документа, как правило, этим занимается встроенный или внешний SAX- или DOM-парсер.

С сериализацией дела обстоят немного сложнее. С точки зрения преобразования, результирующее дерево — это все, что от него требуется, но вряд ли разработчику будет этого достаточно. Редко когда сгенерированная абстрактная древовидная структура — это то, что нужно. Гораздо чаще результат преобразования требуется получить в определенной физической форме.

Сериализация как раз и является процессом создания физической интерпретации результирующего дерева, и если и эта задача делегируется XSLT-процессору, то преобразованию под силу контролировать физический вывод генерируемого документа (рис. 2.3).

Рис. 2.3. Сериализация в XSLT

Текущая версия языка поддерживает три основных метода сериализации: XML, HTML и текст. Каждый из этих методов учитывает синтаксис целевого физического формата и позволяет получить документ требуемого вида. Кроме того, имплементации XSLT могут добавлять собственные методы сериализации, генерируя документы в других форматах (например, PDF или TeX), не предусмотренных стандартными методами.

Преобразования могут указывать метод сериализации, который должен использоваться для создания физической интерпретации генерируемой структуры, однако даже в случае стандартных методов непосредственный контроль над синтаксисом физического документа сильно ограничен. Можно сказать, что он практически отсутствует.

Преобразования отделены от синтаксической обработки совершенно сознательно, ведь их задачей являются структурные трансформации, а не работа с физическим синтаксисом. Благодаря этому разделению многие процессоры позволяют использовать для парсинга и сериализации внешние приложения, что в значительной степени повышает универсальность XSLT: для каждого этапа преобразования можно использовать наиболее подходящий инструмент.

Области применения XSLT

В отличие от языка XML, предметную область XSLT задать очень легко. XSLT следует применять там, где необходимо преобразование одного документа в другой.

Естественно, XSLT имеет также и некоторые ограничения:

□ XSLT не подходит для описания преобразований с очень сложной логикой;

□ XSLT не подходит для преобразований, которые требуют сложных вычислений.

Первое ограничение связано с тем, что преобразование в XSLT — это всего лишь набор элементарных правил. В подавляющем большинстве случаев этого достаточно для описания преобразования, однако, встречаются также и такие задачи, для которых данного набора правил будет недостаточно. Например, древовидные структуры могут описывать математические выражения, но при этом преобразование для упрощения или вычисления этого дерева выражений может быть чересчур сложным для XSLT.

Второе ограничение является следствием простоты языка XPath, который используется в XSLT для вычислений. XPath предоставляет только самые простейшие вычислительные конструкции, которых явно недостаточно для сложных задач. Кроме того, функциональный стиль XSLT и отсутствие изменяемых переменных делают очень затруднительными многошаговые и циклические вычисления.

Замечание

Оба этих ограничения можно с успехом обойти при помощи механизма расширений, который позволяет комбинировать XSLT с другими языками программирования. Умело используя расширения, можно совместить гибкость XSLT и мощь традиционных языков.

Ниже мы опишем наиболее классические области применения XSLT: Web-решения, использование в клиент-серверных приложениях и проекты интеграции.

XSLT в архитектуре клиент-сервер

Многие из систем, применяющих XSLT, так или иначе, сводятся к клиент- серверной архитектуре, в которой клиент делает запрос, а сервер в качестве ответа возвращает некоторые данные. XSLT в таких решениях может использоваться для приведения структуры данных из внутреннего формата сервера к некоторому внешнему формату, понятному клиенту. Примером подобной системы может быть Web-сервер, предоставляющий клиентам (фактически, Web-браузерам) информацию, которая динамически генерируется из базы данных.

Классическим и широко применяемым решением для такого рода задачи являются серверные компоненты, сервлеты и различные скриптовые языки, которые преобразуют запросы клиента в запросы к базе данных, а затем оформляют результаты выполнения в виде HTML и отсылают клиенту.

Очевидный минус этого решения в том, что оно слишком сильно зависит от презентации данных. Новая презентация (например, версия "для печати" или для мобильного устройства) или сравнительно серьезное исправление старой заставляют, чуть ли не полностью (в зависимости от качества проектирования) переписывать Web-приложение.

Практика показывает, что в подобных системах весьма и весьма эффективно применяется связка XML+XSLT. Вместо того чтобы генерировать по данным HTML-презентацию, можно создать XML-документ, и, применяя преобразования, возвращать клиенту именно тот результат, которого он ожидает.

Схема взаимодействия XML и XSLT в архитектуре клиент-сервер представлена на рис. 2.4. На этом рисунке нет четкой границы, которая отделяла бы клиента от сервера. Дело в том, что существует два принципиально различных способа использования XSLT в подобной архитектуре: преобразования могут выполняться как на стороне сервера, так и на стороне клиента. Рассмотрим подробнее оба способа.

Рис. 2.4. XML и XSLT в архитектуре клиент-сервер

XSLT на стороне сервера

Применение XSLT на стороне сервера (рис. 2.5) совершенно незаметно для клиента — он, как и раньше, в ответ на свой запрос получает HTML или документ в другом требуемом формате. В данном случае связка XML+XSLT является дополнительным звеном, дополнительным уровнем абстракции, который позволяет отделять данные от презентации, добиваясь простоты и универсальности. Создание преобразований для генерации HTML по имеющимся XML-документам — задача совершенно иного плана, чем написание серверных приложений и программ, которые непосредственно работают с результатами выполнения запросов к базе данных.

Рис. 2.5. XSLT на стороне сервера

Главным минусом этого способа является то, что мы все равно возвращаем клиенту представление данных, а не сами данные. Естественно, используя XSLT, множество доступных представлений расширить очень легко, но это множество в любом случае будет ограничено. Вне всякого сомнения, для большинства современных Web-систем этого более чем достаточно, но существующие Web-технологии больше ориентированы на представление данных, чем на сами данные — они стараются предвосхитить вопросы и заранее процедуры ответов. Возможно, в будущем эта ситуация изменится.

XSLT на стороне клиента

Идея использования XSLT на стороне клиента (рис. 2.6) заключается в том, чтобы отдавать клиенту отдельно нужные ему данные и отдельно преобразование, которое будет создавать для этих данных требуемое представление (например — HTML-страницу). Четкое разделение данных и их представления предоставит клиенту полную свободу распоряжаться полученной информацией. Преобразование в этом случае всего лишь предлагает возможную трактовку этой информации, ни к чему не обязывая.

Рис. 2.6. XSLT на стороне клиента

Еще одним (правда, чисто техническим) достоинством выполнения преобразований на стороне клиента является разгрузка сервера, ведь такой подход освобождает его от необходимости выполнять процедуру преобразования.

Основным ограничением этого способа является предположение, что программное обеспечение на стороне клиента сможет выполнять преобразования. К сожалению, текущая ситуация далека от идеальной, и решение такого вида может применяться только в очень ограниченном числе случаев — когда достоверно известно, что целевой клиент поддерживает XSLT.

XSLT в Web-решениях

Попытаемся теперь взглянуть на приложения архитектуры клиент-сервер под несколько иным углом и в более узкой области Web-решений.

Примем за основу наиболее реалистичную схему, в которой преобразования выполняются на стороне сервера. Типовой процесс доступа к данным в этом случае может быть описан следующим образом:

□ клиент запрашивает определенный документ;

□ сервер находит (или генерирует) этот документ;

□ сервер находит (или генерирует) преобразование, ассоциированное с этим документом, и применяет его к документу;

□ результат преобразования возвращается клиенту (например, в виде HTML-файла).

В подобной системе можно выделить три базовых компонента (рис. 2.7):

□ генератор — модуль, который создает документ на основе информации, хранящейся в базе данных или просто в файлах на сервере;

□ процессор преобразований — модуль, который применяет преобразования к сгенерированному документу;

□ сериализатор — модуль, создающий физическую репрезентацию результата преобразования.

Рис. 2.7. Декомпозиция системы Web-публикации

В таком виде XSLT создает сильную конкуренцию серверным скриптовым языкам типа ASP, JSP, PHP, Python и так далее. Web-системы, построенные на XML и XSLT, гораздо гибче и легче в реализации, а их масштабируемость нельзя даже сравнивать. В традиционных системах добавление еще одного представления данных (например, текстовой версии документа или версии "для печати") — это еще одна программа на сервере, в то время как в системах, использующих XSLT, — это всего лишь еще одно преобразование (рис. 2.8).

Рис. 2.8. Создание множественных представлений с использованием XSLT

XSLT является одной из основных технологий систем Web-публикации, как Cocoon от Apache XML Project и XSQL от Oracle. Решения на основе. Cocoon и XSQL отличаются мощностью, гибкостью и простотой; ожидается, что системы этого класса займут в скором времени лидирующие позиции.

XSLT при обмене данными

В предыдущей главе мы обсудили преимущества применения XML в проектах интеграции: определение общего XML-языка снижает трудозатраты по реализации обмена данными между различными системами. При этом экспорт данных в общем формате выполняется врапперами — оболочками для стандартизации внешних обращений.

Между тем, во многих случаях функции врапперов совершенно стандартны: от них требуется только экспортировать и импортировать данные. Более того, если приложение может производить экспорт и импорт в определенном XML-формате самостоятельно, потребность во врапперах попросту отпадает.

Действительно, предположим, что наши приложения уже имеют определенный XML-интерфейс (рис. 2.9):

Рис. 2.9. Приложение с XML-интерфейсом

Под XML-интерфейсом в данном случае подразумевается возможность экспортировать и импортировать данные в некотором XML-языке (пусть даже своем для каждого из приложений).

Таким образом, для интеграции этого приложения в общую схему потребуется лишь обеспечить "перевод" данных с XML-языка приложения на общий XML-язык и обратно (рис. 2.10).

Рис. 2.10. Интеграция приложения с XML-интерфейсом в общую схему

Упомянутая выше задача перевода, или, по-другому, преобразования, есть очевидная область применения языка XSLT. Общая схема интеграции на основе XML и XSLT показана на рис. 2.11.

Рис. 2.11. Схема интеграции приложений на основе XML/XSLT

Здесь XSLT исполняет роль связующего звена между XML-интерфейсами приложений и общим XML-языком. Эта схема легка в реализации (поскольку не требует знания внутреннего устройства приложений), масштабируема (задача добавления новых приложений и систем заключается в создании дополнительной пары преобразований) и концептуально целостна (так как основана только на XML-технологиях).

История XSLT

Одной из главных задач технологии XML было отделение данных от их презентации. XML прекрасно справляется с этой задачей, предоставляя широкие возможности для структурного оформления данных в текстовом виде. Вместе с тем, во многих случаях просто выделить данные было явно недостаточно, поскольку помимо машинной обработки они также должны были быть понятны человеку. В качестве примера, вспомним рекламное объявление, которое мы разметили в первой главе:

<advert>

 Предлагаем Вашему вниманию новый <room>3</room>-x камерный

 <product>Холодильник</product>

 <product-title>"Горск"</product-title>

 объемом <volume>250 л.</volume> и стоимостью всего <price>4500</price>

 рублей!

 <!-- И так далее -->

</advert>

Разметив документ, оформив семантически значимые данные при помощи элементов, мы добились явного выделения их структуры, что позволяет программно обрабатывать информацию, содержащуюся в документе (например, производить поиск или анализ данных). Но это только полдела: помимо программной обработки рекламных объявлений, не менее важной задачей является их презентация, ведь в большинстве случаев пользователь хочет увидеть объявление, а не получить соответствующую ему структуру данных.

Выделение данных, вне всякого сомнения, расширяет возможности презентации, поскольку они более не зависят от конкретного устройства или формата вывода. Единственное требование — это наличие программных средств, которые, принимая на вход структурированную информацию, смогут корректным образом представить ее в целевом формате или носителе. Если вернуться к примеру с рекламным объявлением, то для того, чтобы получить вывод этого объявления в формате HTML, нам потребуется программа, которая поймет формат документа объявления и создаст для него соответствующий гипертекстовый файл.

При всем многообразии возможных методов презентации данных, наиболее часто используемые из них весьма схожи между собой. Примером этому может служить визуальное представление информации в печатной форме или на экране.

Приведенные выше причины могут объяснить потребность в стандартной технологии для презентации XML-документов — технологии, подобной DSSSL (Document Style Semantics and Specification Language, язык семантики и спецификации стиля документа), которая существовала для SGML или CSS (Cascading Style Sheets — каскадные таблицы стилей) для HTML. Эта технология получила название XSL (extensible Stylesheet Language — расширяемый язык стилей), и именно ей обязан своим возникновением язык XSLT.

Первые идеи о создании отдельного языка для презентации документов были представлены на конференции WWW'94, где С.М. Шперберг-МакКвин и Роберт Гольдштейн выступили сдокладом об использовании возможностей SGML во всемирной паутине. В этом докладе были сформулированы основные принципы языка стилей. Мы перечислим некоторые из них:

□ язык стилей должен быть декларативным (а не процедурным);

□ язык стилей должен уметь оперировать структурой документа;

□ презентация элемента может изменяться в зависимости от расположения этого элемента в документе;

□ реализация интерпретатора языка стилей не должна быть сложной даже в процедурном языке программирования;

□ синтаксис языка должен быть как можно более примитивным, чтобы разбор его грамматических конструкций не составлял труда.

Спустя три года, когда Консорциум W3 уже всерьез занялся концепцией XML, эти идеи получили дальнейшее развитие: началась разработка XSL, языка для презентации XML-документов.

Язык XSL виделся тогда более простым и понятным, чем DSSSL и более мощным, чем CSS. Уже тогда разработчики понимали, что язык презентации XML-документов не сможет обойтись без преобразования их структуры, расширений и должен быть основан на множестве правил презентации.

В мае 1998 года требования к XSL были оформлены в едином документе. Помимо большого числа комментариев, касающихся визуальной презентации XML-документа, этот документ также упоминал необходимость определения вычислительных выражений, операций, типов данных, конструкций, которые позволяли бы обращаться к обрабатываемому документу, стандартных и пользовательских функций. Концептуально язык определялся как декларативный и не имеющий побочных эффектов.

После того, как требования к XSL были, наконец, сформулированы, разработка языка вылилась в создание целой серии черновых рабочих вариантов (в терминах W3C — working drafts, WD). Эти варианты зачастую сильно различались между собой, однако основные принципы XSL соблюдались в них неукоснительно.

С первых же рабочих версий XSL стало понятно, что задача презентации XML-документов состоит из двух главных подзадач: преобразование документа и описание внешнего вида результата этого преобразования. Разделение это было настолько четким, что спецификацию XSL более или менее независимо редактировали два человека: Джеймс Кларк (James Clark) и Стивен Дич (Stephen Deach). Кларк отвечал за преобразования (что в первых версиях называлось tree construction — конструирование дерева), Дич редактировал презентационную часть XSL (которую назвали formatting objects — форматирующие объекты).

Независимость и различия между двумя этими частями были настолько явными, что уже в третьей рабочей версии, которая вышла в свет 21 апреля 1999 года, технологию XSL разделили на два языка: XSL (расширяемый язык стилей) и XSLT (расширяемый язык стилей для преобразований). XSLT отвечал за преобразование входящего документа, XSL — за визуальное отображение результата этого преобразования. В дальнейшем эти два языка стали развиваться достаточно независимо (хотя они и были частями одной технологии).

Следующим важным моментом в истории XSLT было создание языка XPath (вернее, выделение этого языка, как самостоятельного). Как оказалось, XSLT имеет семантически общую часть с языком XPointer, который разрабатывался другой группой Консорциума W3. Результатом общих усилий был создан язык XPath, который позволял обращаться к частям XML-документов, а также производить выборки и основные вычисления. XPath также обладал базовой библиотекой функций, которую и XSLT и XPointer расширяли для собственных нужд.

Таким образом, технология XSL разделилась на три составные части: язык преобразований XSLT, язык обращений к XML-документам XPath и язык стилей XSL. На рис. 2.12 в графической форме показано развитие XSL с момента создания первой рабочей версии в августе 1998 года и до настоящего времени. Вершины графа соответствуют опубликованным версиям языков. WD означает working draft (рабочий черновой вариант), CR — candidate recommendation (кандидат в рекомендации), PR — proposed recommendation (предлагаемая рекомендация) и REC — рекомендация. Для тех, кто не знаком с деятельностью Консорциума W3 поясним, что любая технология, которой занимаются рабочие группы W3C, проходит ряд этапов: формирования требований, несколько рабочих версий, кандидат в рекомендации и предлагаемая рекомендация. Если все проходит успешно, технология становится технической рекомендацией Консорциума W3, что имеет статус стандарта де-факто (с тем лишь отличием, что стандарты могут принимать только организации, уполномоченные правительствами).

Рис. 2.12. История развития языка XSL в виде графа

Что касается XSLT и XPath, спецификации обоих этих языков стали техническими рекомендациями 16 ноября 1999 года. Сам же язык XSL, который теперь стали называть XSL-FO (аббревиатура FO означает formatting objects — форматирующие объекты), получил статус рекомендации не так быстро. Спустя год, в ноябре 2000, спецификация XSL получила статус кандидата в рекомендации, а еще через 9 месяцев с минимальными исправлениями — статус предлагаемой рекомендации. По всей видимости, к тому моменту, когда эта книга увидит свет, спецификация XSL уже будет официальной рекомендацией W3C.

Одного года было достаточно, чтобы XSLT стал широко использоваться во многих XSLT-задачах. Повышенное внимание разработчиков позволило выявить некоторые досадные огрехи, которые были допущены в первой версии XSLT, и потому в конце 2000 года была начата работа над версией 1.1. В новой версии рабочая группа XSL постаралась исправить большинство ошибок, допущенных в версии 1.0 и добавить некоторые возможности, которых не хватало в первой версии. Однако через некоторое время стало понятно, что разрабатываемый язык довольно сильно отличается от первой версии. К тому же, с учетом таких разработок, как XML Schema и XQuery возникла необходимость изменить модель данных и выражений XPath. В итоге, работу над версией 1.1 решено было прекратить и переключиться на создание вторых версий языков XSLT и XPath.

Вместо того чтобы разбирать в этой книге особенности версии 1.1, которая никогда не станет рекомендацией, в последней главе мы опишем то, что, согласно требованиям ко вторым версиям языков XSLT и XPath, ожидается в их спецификациях, и что, согласно XSLT 1.1 там точно будет. Работа над XSLT 2.0 и XPath 2.0 в самом разгаре: к сентябрю 2001 года были уже готовы три внутренних рабочих версии. К сожалению, открывать секреты рабочей группы XSL мы не в праве, хотя можно смело сказать, что процесс работы внушает оптимизм.

Глава 3 Идея и модель языка XSLT

Модель XML-документа

Описывая основы построения XML-документов, мы отмечали, что иерархическая организация информации в XML лучше всего описывается древовидными структурами. Дерево — это четкая, мощная и простая модель данных и именно она была на концептуальном уровне применена в языках XSLT и XPath. Как пишет Кнут [Кнут 2000], "деревья — это наиболее важные нелинейные структуры, которые встречаются при работе с компьютерными алгоритмами". Добавим, что это без сомнения самая важная структура из тех, которыми оперируют языки XSLT и XPath.

В этих языках документ моделируется как дерево, состоящее из узлов. Узлы дерева соответствуют структурным единицам XML — элементам, атрибутам, тексту и так далее, а дуги, ветки — отношениям между этими единицами. Простейшим примером является принадлежность одних элементов другим. Документ вида

<а>

 <b/>

 <с/>

</а>

может быть представлен деревом (рис. 3.1).

Рис. 3.1. Представление документа в виде дерева

Аналогия совершенно очевидна — элемент а содержит элементы b и с, в то время как в дереве вершина а является родительским узлом для вершин b и с.

Естественно, XML-документы состоят далеко не из одних только элементов и потому для того, чтобы дерево достоверно отражало структуру и содержание документа, в нем выделяются узлы следующих семи типов:

□ корневой узел;

□ узлы элементов;

□ узлы атрибутов;

□ текстовые узлы;

□ узлы пространств имен;

□ узлы инструкций по обработке;

□ узлы комментариев.

Каждый узел дерева имеет соответствующее ему строковое значение, которое вычисляется в зависимости от типа. Строковым значением корневого узла и узла элемента является конкатенация (строковое сложение) строковых значений всех их потомков, для остальных типов узлов строковое значение является частью самого узла. Порядок вычисления строковых значений узлов будет более детально определен в описании каждого из типов.

Мы подробно разберем каждый из типов узлов чуть позже, а пока отметим, что дерево в XSLT и XPath является чисто концептуальной моделью. Процессоры не обязаны внутренне представлять документы именно в этой структуре, концептуальная модель означает лишь то, что все операции преобразования над документами будут определяться в терминах деревьев. Для программиста же это означает, что вовсе необязательно вникать в тонкости реализации преобразований в том или ином процессоре. Все равно они должны работать, так, как будто они работают непосредственно с деревьями.

Отметим также и то, что на практике некоторые из процессоров вообще не воссоздают внутреннюю модель документа, экономя, таким образом, ресурсы. Документы могут быть слишком объемными, и это препятствует загрузке их в память в виде древовидной структуры.

Некоторые из процессоров, напротив, используют DOM-модель документа для внутреннего представления обрабатываемой информации. Несмотря на большие требования к ресурсам памяти, такое решение также может иметь свои плюсы, например, универсальность и легкая интеграция в существующие XML-решения на базе DOM.

Но, так или иначе, с воссозданием древовидной структуры документа в памяти или нет, процессоры все равно оперируют одной и той же концептуальной моделью, которой мы сейчас и займемся.

Деревья

Прежде, чем мы приступим к рассмотрению типов узлов и отношений между ними, необходимо определиться с самой структурой дерева. Древовидная структура задает для своих элементов отношение ветвления, очень похожее на строение обычного дерева — есть корневой узел (ствол), от которого происходят другие узлы (ветки).

Формально [Кнут 2000] дерево определяется, как конечное множество T, состоящее из одного или нескольких элементов (узлов), обладающих следующими свойствами:

□ во множестве T выделяется единственный узел, называемый корневым узлом или корнем;

□ все остальные узлы разделены на m≥0 непересекающихся множеств T₁, …, T_m, каждое из которых в свою очередь также является деревом.

Деревья T₁, …, T_m называются поддеревьями корня дерева T.

Это определение является рекурсивным, то есть в нем дерево определяется само через себя. Конечно, существуют нерекурсивные определения, но, пожалуй, следует согласиться с тем, что рекурсивное определение лучше всего отражает суть древовидной структуры: ветки дерева также являются деревьями.

В XSLT и XPath деревья являются упорядоченными, то есть для множеств T₁, …, T_m задается порядок следования, который называется порядком просмотра документа. В XSLT деревья упорядочиваются в порядке появления текстового представления их узлов в документах.

Существует множество способов графического изображения деревьев. Мы будем рисовать их так, что корень дерева будет находиться наверху, а поддеревья будут упорядочены слева направо. Такой способ является довольно стандартным для XML, хотя и здесь существует множество вариантов. Примером изображения дерева может быть следующий рисунок (рис. 3.2):

Рис. 3.2. Изображение дерева

Мы часто будем говорить о дочерних узлах, родительских узлах, братских узлах, узлах-предках и узлах-потомках. Дадим определения этим понятиям.

□ Дочерним узлом текущего узла называется любой из корней его поддеревьев. Например, в дереве на рис. 3.2 дочерними узлами узла а являются узлы b и с, а дочерними узлами узла b — узлы d и e. Узел с не имеет дочерних узлов — такие узлы иначе называются листьями.

□ Каждый узел называется родительским узлом корней своих поддеревьев. На рис. 3.2 узел а является родителем узлов b и с, а узел b — родителем узлов d и e.

□ Корни поддеревьев называются братскими узлами или узлами-братьями. На рис. 3.2 братьями являются узлы b и с, а также узлы d и e.

□ Предками текущего узла являются его родитель, а также родители его родителей и так далее. На рис. 3.2 предками узла d являются узлы b и а.

□ Потомками текущего узла являются его дочерние узлы, а также дочерние узлы его дочерних узлов и так далее. На рис. 3.2 потомками узла а являются узлы b, c, d и e.

Узлы дерева XML-документа

Корневой узел

Корневой узел XML-документа — это узел, который является корнем дерева документа. Не следует путать его с корневым элементом документа, поскольку помимо корневого элемента дочерними узлами корня также являются инструкции по обработке и комментарии, которые находятся вне корневого элемента.

Мы будем помечать корневой узел документа символом "/" и изображать следующим образом (рис. 3.3):

Рис. 3.3. Изображение корневого узла

На рис. 3.4 показано изображение документа,

<!--А-->

<В/>

<?С?>

корневой узел которого помимо корневого элемента содержит комментарии и инструкции по обработке.

Рис. 3.4. XML-документ и его изображение

Корневой элемент не имеет имени. Функция name(/) будет всегда возвращать пустую строку.

Строковым значением корневого узла является конкатенация строковых значений всех его текстовых потомков в порядке просмотра документа.

Узлы элементов

Каждому элементу XML-документа соответствует узел элемента. Дочерними узлами узла элемента могут быть узлы его дочерних элементов, а также узлы комментариев, инструкций по обработке и текстовые узлы, которые представляют его непосредственное содержимое. Следует обратить внимание на то, что узлы атрибутов не считаются дочерними узлами своего элемента, они лишь только ассоциируются с ними.

При изображении деревьев мы будем помечать узлы элементов их именами. Например, элемент A будет изображен следующим образом (рис. 3.5):

Рис. 3.5. Изображение элемента А

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

Подобно корневому узлу, строковым значением узла элемента будет конкатенация значений его текстовых потомков в порядке просмотра документа. В силу того, что атрибуты не являются потомками элементов, их текстовые значения учитываться не будут.

Узлы атрибутов

Атрибутам того или иного элемента соответствуют узлы атрибутов. Считается, что узел элемента является родителем узла своего атрибута, но вместе с тем узел атрибута не является дочерним узлом узла его элемента. Такая ситуация несколько отличает дерево документа в XSLT от классического дерева, как оно было определено ранее — отношение между узлом элемента и узлом атрибута является отношением ассоциации. Говорят, что узел атрибута ассоциируется с узлом элемента.

Между тем, отношения такого рода не сильно отличаются от отношений между родительскими и дочерними узлами — один атрибут ассоциируется ровно с одним элементом. Поэтому мы будем изображать узлы атрибутов точно так же, как если бы они были дочерними узлами элементов. Для того чтобы отличать узлы атрибутов от остальных узлов, мы будем помечать их именем, которому будет предшествовать символ "@". При необходимости, значение атрибута будет приводиться в нижней части изображения узла.

Пример

Рис. 3.6 показывает возможные варианты изображения элемента, определенного как <file name="a.txt"/>.

Рис. 3.6. Изображение элемента и принадлежащего ему атрибута

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

Каждый атрибут имеет расширенное имя, состоящее из локальной части и идентификатора пространства имен. Пространство имен атрибута будет нулевым, если оно не было определено по умолчанию и у имени атрибута нет префикса.

Строковым значением узла атрибута является значение атрибута, который ему соответствует.

Текстовые узлы

Символьные данные, содержащиеся в документе, организуются в виде текстовых узлов. Последовательности символов, встречающиеся в документах, в целях экономии никогда не разбиваются на два или более текстовых узла, а текстовые узлы никогда не бывают пустыми. Содержание секций CDATA обрабатываются так, как если бы их содержимое было просто включено в документ с заменой символов "<" и "&", на сущности < и &.

Текст, содержащийся в значениях атрибутов, а также в комментариях и инструкциях по обработке не оформляется в виде текстовых узлов — эти данные принадлежат соответствующим узлам атрибутов, комментариев и инструкций.

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

Пример

Элемент, заданный как <p>Welcome</p>, может быть изображен следующим образом (рис. 3.7):

Рис. 3.7. Варианты изображения текстового узла элемента

Текстовые узлы не имеют имен. Строковым значением текстового узла является последовательность символов, которую он содержит.

Узлы пространств имен

Каждому пространству имен, которое определено для данного элемента, соответствует узел пространства имен, ассоциируемый с узлом этого элемента. Множество узлов пространств имен, которое ассоциируется с данным элементом, включает в себя следующие узлы.

□ Узел, который соответствует пространству имен xml. Это пространство неявно определено в любом XML-документе.

□ Узел, который соответствует пространству имен, заданному по умолчанию, если такое есть.

□ По одному узлу на каждый префикс пространств имен, доступный в данном элементе.

Напомним, что пространства имен, доступные в данном элементе, и пространство имен по умолчанию могут быть определены в его предках.

Подобно узлам атрибутов, узлы пространств имен ассоциируются с узлом элемента. Узел элемента является их родительским узлом, но при этом они сами не являются дочерними узлами узла элемента.

Расширенные имена узлов пространств имен состоят из локальной части имени, которая равна префиксу, использованному для объявления этого пространства и нулевого идентификатора пространства имен. Локальная часть пространства, определенного по умолчанию, будет пустой.

Строковым значением узла пространства имен является уникальный идентификатор ресурса (URI), с которым оно связано.

Мы будем помечать узлы пространств имен метками вида xmlns:префикс для обычного пространства и xmlns для пространства имен по умолчанию. Мы не будем показывать в деревьях узлы пространства имен xml, поскольку они ассоциируются со всеми узлами элементов. При необходимости в нижней части изображения узла мы будем приводить URI пространства, которое ему соответствует.

Пример

Приведем изображение дерева (рис. 3.8) документа

<а xmlns="urn:a"><b:b xmlns:b="urn:b"/></a>

Рис. 3.8. Изображение дерева документа с узлами пространств имен

Узлы инструкций по обработке

Каждой инструкции по обработке соответствует свой узел. В дерево не включаются узлы инструкций, которые были приведены в декларации типа документа (DTD). Кроме этого, поскольку декларация XML не является инструкцией по обработке, ей не будет соответствовать никакой узел в дереве документа.

Локальной частью расширенного имени инструкции по обработке является имя целевого приложения инструкции. Пространство имен инструкции по обработке всегда нулевое.

Строковым значением инструкции по обработке является ее содержание — последовательность символов, которая начинается после имени приложения и следующего за ним пробела и заканчивается перед символами "?>", которые закрывают инструкцию. Напомним, что символьные данные инструкции по обработке не выделяются в отдельный текстовый узел.

Узел инструкции по обработке помечается именем целевого приложения, заключенным в символы "<?" и "?>". В нижней части изображения узла пространства имен может быть указано содержимое инструкции.

Пример

Узел инструкции по обработке <?xsql quit?> может быть изображен следующим образом (рис. 3.9):

Рис. 3.9. Изображение узла инструкции по обработке

Узел комментария

Узел комментария соответствует каждому из комментариев, которые присутствуют в документе кроме тех, которые находятся в декларации типа документа (DTD). Узлы комментариев не имеют имен; их строковым значением является текст комментария — последовательность символов после "<!--" и до "-->". В изображении дерева узлы комментариев будут помечаться символами "<!-- -->". В нижней части при необходимости будет указываться текст комментария.

Пример

Узел комментария <!-- To do... --> может быть изображен следующим образом (рис. 3.10):

Рис. 3.10. Изображение узла комментария

Сводная таблица характеристик узлов

Для удобства использования мы можем свести в одну таблицу (табл. 3.1) такие характеристики узлов, как строковое значение, локальная часть имени, пространство имен и так далее.

Таблица 3.1. Характеристики различных типов узлов

Тип узла	Характеристики
	Строковое значение	Расширенное имя		Дочерние узлы	Родительские узлы
		Локальная часть имени	Пространство имен
Корневой узел	Конкатенация текстовых потомков	Нет		Узлы элементов, комментариев, инструкций по обработке	Нет
Узел элемента	Конкатенация текстовых потомков	Имя элемента	Пространство имен элемента	Узлы элементов, комментариев, инструкций по обработке, текстовые узлы	Корневой узел или узел элемента
Узел атрибута	Значение атрибута	Имя атрибута	Пространство имен атрибута	Нет	Узел элемента
Текстовый узел	Символьные данные	Нет		Нет	Узел элемента
Узел пространства имен	URI пространства имен	Префикс пространства имен	Нулевое	Нет	Узел элемента
Узел инструкции по обработке	Содержимое инструкции	Имя целевого приложения	Нулевое	Нет	Корневой узел или узел элемента
Узел комментария	Текст комментария	Нет		Нет	Корневой узел или узел элемента

Ограничения модели XML-документа

Модель XML-документа, описанная выше, является вполне достаточной для того, чтобы манипулировать структурой документа и данными, которые он содержит. Между тем, эта модель имеет определенные ограничения, а именно:

□ Не учитывается информация, содержащаяся в блоке DTD. Как следствие, в XSLT невозможно манипулировать определениями сущностей, элементов, атрибутов и так далее.

□ Не учитываются некоторые синтаксические особенности входящего XML-документа. Например: использовались ли в определенном атрибуте одинарные или двойные кавычки; была ли определенная строка задана сущностью или просто текстом, был ли текст заключен в секции CDATA или нет.

□ Если атрибут элемента был определен в DTD со значением по умолчанию, то в преобразовании нельзя точно сказать, присутствовал ли он физически во входящем документе или нет.

□ Не учитывается, был ли пустой элемент определен как <b></b> или <b/>.

Одним словом, предложенная выше модель не учитывает информацию, которая не важна с точки зрения структуры документа. На практике помимо структуры бывает также важен и детальный синтаксис документа (например, необходимо вместо   выводить  ). К сожалению, применение XSLT для таких задач ограничено вследствие ограничений самой модели документа.

Порядок просмотра документа

Узлы дерева XML-документа находятся в определенном порядке, который называется порядком просмотра документа (англ. document order). Этот порядок важен для вычисления XPath-вырэжений, которые оперируют множествами узлов. Несмотря на то, что эти множества не имеют внутреннего порядка, при вычислении выражений узлы в них будут перебираться в прямом или обратном порядке просмотра документа в зависимости от того, какие оси навигации применяются в выражении.

Порядок просмотра документа — это порядок, который соответствует появлению в документе первого символа текстовой записи узла. Например, для элементов это будет порядок появления в документе открывающих тегов.

Более четко порядок просмотра документа определяется следующими правилами:

□ корневой узел является первым узлом в порядке просмотра документа;

□ узлы элементов предшествуют своим дочерним узлам, узлам пространств имен и узлам атрибутов;

□ узлы пространств имен предшествуют узлам атрибутов;

□ узлы атрибутов предшествуют другим дочерним узлам своего элемента;

□ остальные узлы упорядочиваются в последовательности их появления в документе.

Обратным порядком просмотра документа называется порядок, который в точности противоположен обычному порядку просмотра документа. Обычный порядок просмотра документа также называют прямым порядком или порядком документа.

Пример

В качестве примера приведем схему дерева и выясним порядок просмотра

следующего документа:

<!-- Start -->

<?арр open?>

<а level="0" xmlns:b="urn:b" xmlns="urn:a">

 alpha

 <b:bravo/><!-- To do... --><charlie/>

 delta

</a>

<?app close?>

Дерево этого документа показано на рис. 3.11. Порядок просмотра данного документа будет следующим:

□ корневой узел;

□ узел комментария <!-- start -->;

□ узел инструкции по обработке <?app open?>;

□ узел элемента a;

□ узел пространства имен "urn:а";

□ узел пространства имен "urn:b";

□ атрибут level;

□ текстовый узел "alpha";

□ узел элемента b:bravo;

□ узел пространства имен "urn:а";

□ узел пространства имен "urn:b";

□ комментарий с текстом "To do ...";

□ элемент charlie;

□ узел пространства имен "urn:а";

□ узел пространства имен "urn:b";

□ текстовый узел "delta";

□ узел инструкции по обработке <?арр close?>.

Рис. 3.11. Схема дерева XML-документа

Соответственно, обратный порядок просмотра документа будет начинаться с инструкции по обработке <?app close?> и заканчиваться корневым элементом.

Типы данных

Многие языки программирования при объявлении переменной требуют указывать, какой тип данных будет ей присваиваться. Например, в языке Java код

int i = 15;

объявит переменную целого типа int с именем i и присвоит ей значение 15. В этом случае тип данных ставится в соответствие переменной. XSLT относится к динамически типизируемым языкам, в которых тип данных ассоциируется не с переменными, а со значениями.

В XSLT выделяется пять типов данных:

□ булевый тип (boolean);

□ численный тип (number);

□ строковый тип (string);

□ множество узлов (node-set);

□ результирующий фрагмент дерева (result tree fragment).

Ниже мы подробно рассмотрим особенности работы со всеми пятью типами данных.

Булевый тип (boolean)

Булевый тип данных в XSLT может принимать два значения — true ("истина") и false ("ложь"). В XSLT нет констант для выражения тождественной "истины" или "лжи", как во многих других языках программирования, для этих целей следует использовать функции true и false.

Значение булевого типа могут быть получены путем сравнения других типов данных при помощи операторов сравнения (таких как "=", ">", "<") или как результат вычисления более сложных логических выражений с использованием операторов "and", "or" и функции not.

Булевый тип может быть неявно преобразован в число (0 для false и 1 для true) или в строку ("false" и "true" соответственно).

Примеры:

1=2 → 0 (число)

not((2>1) and (2>3)) → "true" (строка)

Численный тип (number)

Численный тип в XSLT определяется как 64-битное значение с плавающей точкой, двойной точности, соответствующее стандарту IEEE 754-1985. Этот стандарт используется во многих других языках программирования, и потому можно сказать, что арифметика в XSLT работает "как обычно". Вместе с тем, стандарт IEEE 754 имеет свои нюансы, которые обязательно надо учитывать в практике программирования на XSLT.

Согласно строгому определению, числа в XSLT имеют форму s×m×2^x, где s — знак числа, m — его мантисса, а x — экспонента. Эти числа имеют следующие значения:

□ знак (s) равен +1 для положительных чисел и -1 для отрицательных;

□ мантисса (m) — это положительное целое число в интервале от 0 до 253-1 включительно;

□ экспонента (x) — это целое число в интервале от -1075 до 970 включительно.

Таким образом, числа в XSLT находятся в интервале приблизительно от -10317 до 10317.

Кроме этого выделяются пять особых значений.

□ Отрицательная бесконечность. Это значение представляет отрицательные числа, меньшие, чем -10317; оно соответствует математическому значению -∞. Отрицательная бесконечность может быть результатом таких операций, как деление отрицательного числа на нуль или умножение двух очень больших (в абсолютном значении) чисел разного знака в случае, когда для записи их произведения не хватит 64 бит.

□ Положительная бесконечность. Это значение представляет очень большие положительные числа, превосходящие 10317; оно соответствует математическому значению ∞. Положительная бесконечность может быть результатом таких операций, как деление положительного числа на нуль или умножение двух очень больших (в абсолютном значении) чисел одного знака в случае, когда для записи их произведения не хватит 64 бит.

□ Отрицательный нуль. Это значение соответствует значению предела -1/x при x, стремящемся к бесконечности. Отрицательный нуль может быть результатом таких операций, как деление отрицательного числа на бесконечность или положительного числа на отрицательную бесконечность. Отрицательный нуль может также быть получен путем деления отрицательного числа на очень большое положительное число, или, наоборот, в случае, когда для записи частного не хватает 64-битной точности.

□ Положительный нуль (предел 1/x при x, стремящемся к бесконечности). Результат таких операций, как вычитание числа из самого себя, деление положительного числа на положительную бесконечность или отрицательного — на отрицательную бесконечность. Положительный нуль может также быть частным деления двух чисел одного знака, если для записи результата не хватает 64-битной точности.

□ Особое значение NaN, "не-число" (англ. "not-a-number"). Результат преобразования нечислового строкового значения в числовой формат.

Примеры особых значений:

-1 div 0 → отрицательная бесконечность

1 div 0 → положительная бесконечность

1 div (-1 div 0) → отрицательный нуль

-1 div (1 div 0) → отрицательный нуль

1 div (1 div 0) → положительный нуль

-1 div (-1 div 0) → положительный нуль

1-1 → положительный нуль

number('one') → NaN, не-число

number('NaN') → NaN, не-число

Все числовые значения, кроме NaN являются упорядоченными, иначе говоря, для них определены операции сравнения.

□ Отрицательная бесконечность является наименьшим численным значением. Две отрицательные бесконечности равны между собой.

□ Отрицательные конечные числа больше отрицательной бесконечности, но меньше отрицательного нуля.

□ Отрицательный и положительный нули считаются равными.

□ Положительные конечные числа больше положительного нуля, но меньше положительной бесконечности.

□ Положительная бесконечность является наибольшим числом. Две положительные бесконечности находятся в равенстве, все остальные числа всегда будут меньше.

Примеры

□ 1 div (1 div 0) < 1 div 0 → true

(положительный нуль меньше положительной бесконечности);

□ 1 div 0 < 2 div 0 → false

(положительный нуль равен другому положительному нулю);

□ -2 div 0 > -1 div 0 > false -1 div 0 = -2 div 0 → true

(отрицательные бесконечности равны между собой);

□ -1 div 0 < -1 → true

(отрицательная бесконечность меньше любого отрицательного числа);

□ -1 < -2 div (1 div 0) → true

(любое отрицательное число меньше отрицательного нуля);

□ -2 div (1 div 0) = 1-1 → true

1 div (1 div 0) > -2 div (1 div 0) → false

(отрицательный нуль равен положительному нулю);

□ 1 > 1 div (1 div 0) → true

(любое положительное число превосходит положительный нуль).

Нечисловые значения, NaN, являются неупорядоченными — это означает, что, сравнивая их с другими числами, нельзя установить — больше они, меньше или равны. Результат сравнений операторами "<", "<=", "=", ">", ">=" будет "ложью", если хотя бы одно из сравниваемых значений — NaN. Единственное, что можно с точностью сказать о NaN — это то, что они не равны никакому другому числу, включая, собственно, нечисловые значения. То есть, если хотя бы один из операндов — NaN, результатом сравнения с использованием оператора "!=" будет "истина". Это влечет за собой интересный способ проверки, является ли значение некоторой переменной нечисловым или нет: выражение $x!=$x (буквально значение переменной x не равно значению переменной x) обратится в "истину" в том и только том случае, если значением $x является NaN. В шаблонных правилах эта проверка может быть записана при помощи элемента xsl:if:

<xsl:if test="$x != $x">

 <xsl:text>This is not a number (NaN).</xsl:text>

</xsl:if>

Арифметические операции в XSLT никогда не вызывают ошибки. Деление на нуль, не разрешенное во многих языках программирования, не является для XSLT исключительной ситуацией. Частным такого деления будет положительная или отрицательная бесконечность. Но все же, следует осторожно использовать "опасные" выражения, например, в сравнениях. Несколько необычное поведение операторов сравнения в операциях с NaN может создать в программе курьезные, но трудно обнаруживаемые ошибки — можно легко забыть о том, что некоторые значения могут быть не равны сами себе.

Числа могут быть неявно преобразованы в булевый тип или в строку. При преобразовании числа в булевый тип, нуль (как положительный, так и отрицательный) и NaN преобразуются в false, все остальные значения (включая бесконечности) — в true.

Примеры

-1 div (1 div 0) > false 1 div 0 → true

number('NaN') > false number('true') → false

Результатом неявного преобразования числа в строку является:

□ для конечных чисел — запись числа в десятичном формате;

□ для нулей (и положительного, и отрицательного) — "0";

□ для бесконечностей (отрицательной и положительной) — "-Infinity" и "Infinity" соответственно;

□ для нечисловых значений — "NaN".

Примеры

-14 div 3 → '-4.666666666666667'

0010.00050000 → '10.0005'

-1 div (1 div 0) → '0'

1 - 1 → '0'

1 div 0 → 'Infinity'

-2 div 0 → '-Infinity'

number('NaN') → 'NaN'

number('Infinity') → 'NaN'

Кроме неявного преобразования в строку, XSLT предоставляет широкие возможности для форматирования числовых значений с использованием функции format-number.

Строковый тип (string)

Строки в XSLT практически не отличаются от строк в других языках программирования. Строка — это последовательность, состоящая из нуля или более символов определенного алфавита или набора символов (англ. character set). XSLT использует в качестве алфавита Unicode, что теоретически позволяет манипулировать любыми символами. Строки, которые не содержат символов, называются пустыми.

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

Пример

Результатом выполнения элемента

<xsl:value-of select="'text'"/>

будет строковый узел со значением "text", в то время как элемент

<xsl:value-of select="text"/>

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

Определенную сложность создает одновременное использование в литералах двойных и одинарных кавычек — некоторые процессоры будут воспринимать их как окончание значения атрибута. Такие строки проще всего будет задавать при помощи переменных, например:

<xsl:variable name="s">

 <xsl:text>'An author of "One Flew Over Cookoo's Nest"'</xsl:text>

</xsl:variable>

<xsl:value-of select="$s"/>

Следует особым образом отметить, что в XSLT, как XML-языке, символы могут быть заменены сущностями. Например, вместо символа """ (двойные кавычки) можно использовать сущность ", а вместо символа "'" (одинарные кавычки) — '. Это позволяет использовать внутри атрибутов такие конструкции, как

'this is a string'

что эквивалентно

'this is a string'

На практике следует избегать таких приемов — они сильно запутывают текст программы. Сущности следует использовать только тогда, когда это действительно необходимо.

Строки можно сравнивать при помощи операторов "=" (равно) или "!=" (не равно). При сравнении строки проверяются на посимвольное совпадение. Различные процессоры могут по-разному реализовывать процедуру сравнения, например, рассматривать разные символы с одним начертанием как одинаковые, но в одном можно быть точно уверенными — в случае, если на одних и тех же местах будут стоять символы с одинаковыми Unicode-кодами, строки будут равны.

Пример

'not' = 'no&#х74;' → true

Не следует также забывать, что один символ в строке — это необязательно один байт. Более того, это необязательно некое фиксированное число байт, ведь модель символов Unicode позволяет использовать для записи символа коды переменной длины.

Строка может быть приведена к булевому и численному типу.

В булевом представлении пустой строке соответствует false, непустой — true. Содержимое непустой строки при этом никакой роли не играет. Булевое значение строки "false" будет "истиной", равно, как и булевое значение строки "true".

Примеры

'То be' or 'not to be' → true

'Full' and '' → false

'true' and 'false' → true

При приведении к численным значениям строки разбираются как числа в десятичном формате. Если строка не является представлением числа, ее численным значением будет NaN. В свою очередь, результатом любых вычислений, в которых участвует NaN, будет также NaN.

Примеры

'2' * '2' → 4

'one' + 'two' → NaN

'2/3' + '5/6' → NaN

'2' div '3' + '5' div '6' → 1.5

При работе с численными значениями можно использовать следующие операторы:

□ -, унарный оператор, который выполняет отрицание своего единственного операнда — эта операция равносильна вычитанию числа из нуля;

□ +, бинарныйоператор сложения, возвращает сумму своих операндов;

□ -, бинарный оператор вычитания, возвращает разность своих операндов;

□ *, бинарный оператор умножения, возвращает произведение своих операндов;

□ div, бинарный оператор деления, возвращает частное от деления первого операнда на второй;

□ mod, бинарный оператор, возвращающий остаток от деления первого операнда на второй.

Обратим внимание на то, что оператор div в отличие от его трактовки в языке Pascal, выполняет нецелое деление. Результатом вычисления выражения 3 div 2 будет 1.5, а не 1.

Динамическая типизация в XSLT позволяет использовать в выражениях значения разных типов — например, складывать строки и булевые значения или производить логические операции над числами. В тех случаях, когда тип данных значения отличается от типа данных, который требуется для операции, значения будут неявным образом приведены к требуемому типу, если это, конечно, возможно.

Множество узлов (node-set)

Несмотря на то, что XSLT оперирует логической моделью XML-документа как деревом с узлами, в XSLT нет типа данных, который соответствовал бы одному узлу. Вместо этого используется гораздо более мощный и гибкий тип данных, называемый множеством узлов (англ. node-set).

Множество узлов — это чистое математическое множество, состоящее из узлов дерева: оно не содержит повторений и не имеет внутреннего порядка элементов. Множества узлов выбираются особым видом XPath-выражений, которые называются путями выборки (англ. location path).

Пример

Листинг 3.1. Документ

<А>

 <В/>

 <С>

  <D>

   <G/>

  </D>

  <E/>

  <F>

   <H/>

   <I/>

  </F>

 </C>

</A>

Предположим, что в этом документе мы хотим выбрать все узлы, являющиеся потомками элемента C, который находился бы в элементе A, который находится в корне документа. Соответствующее XPath-выражение будет записано в виде /A/C//node().

Для наглядности представим наш документ в виде дерева (рис. 3.12) и выделим в нем соответствующее множество узлов.

Рис. 3.12. Выбор множества узлов

Выбранное множество состоит из узлов элементов D, G, E, F, H, I (рис. 3.13):

Рис. 3.13. Выбранное множество

Выбор множества не означает "клонирования", создания копий узлов, которые в него входят. Это просто выбор из всех узлов входящего документа некоторого набора, удовлетворяющего критериям, заданным путем выборки. С точки зрения программиста, множество узлов может быть представлено, как неупорядоченный список ссылок на узлы. При этом практическая реализация зависит от разработчиков конкретного процессора.

В общем случае, во множество узлов не входят дети узлов, содержащихся в нем. В нашем примере узлы элементов G, H и I вошли в выбранное множество только потому, что они соответствовали пути выборки /A/C//node(). Если бы путь выборки имел вид /A/C/node() (то есть, выбрать всех детей узла C, содержащегося в узле A, находящемся в корне документа), результат (рис. 3.14) был бы иным.

Рис. 3.14. Другой путь выборки

Выбранное множество узлов имело бы вид (рис. 3.15):

Рис. 3.15. Выбранное множество

Для представления одного узла дерева в XSLT используется множество, состоящее из единственного узла. В предыдущем примере результатом выборки /A (выбрать узел A, находящийся в корне документа) было бы множество, состоящее из единственного узла (рис. 3.16).

Рис. 3.16. Множество, состоящее из единственного узла

Несмотря на то, что множества узлов неупорядочены, во многих случаях обработка узлов множества производится в порядке просмотра документа. Некоторые элементы, обрабатывающие множества (такие, как xsl:apply-templates и xsl:for-each) позволяют предварительно выполнять их сортировку при помощи элемента xsl:sort.

Множества узлов можно сравнивать при помощи операторов "=" (равно) и "!=" (не равно). В отличие от равенства математических множеств, равенство множеств узлов A и B в XSLT означает то, что найдется узел a, принадлежащий множеству A и узел b, принадлежащий множеству B такие, что их строковые значения будут равны. Неравенство множеств означает наличие в них как минимум пары узлов с различными строковыми представлениями. Такие определения делают возможным при сравнении двух множеств одновременное выполнение равенства и неравенства.

Пример

Листинг 3.2. Входящий документ A

<numbers>

 <int>1</int>

 <byte>2</byte>

 <int>2</int>

 <byte>3</byte>

</numbers>

Листинг 3.3. Преобразование

<xsl:stylesheet

 version="1.0"

 xmlns:xsl="http://www.w3.org/1999/XSL/Transform">

 <xsl:output method="text"/>

 <xsl:template match="numbers">

  <xsl:value-of select="int = byte"/>

  <xsl:text> and </xsl:text>

  <xsl:value-of select="int != byte"/>

 </xsl:template>

</xsl:stylesheet>

Результатом этого преобразования будет строка:

true and true

Этот пример показывает, что множество дочерних элементов int элемента numbers одновременно считает как равным, так и неравным множеству дочерних элементов byte.

Приведем еще несколько примеров.

Листинг 3.4. Входящий документ B

<numbers>

 <int>1</int>

 <byte>2</byte>

 <int>3</int>

 <byte>4</byte>

</numbers>

Результат:

false and true

Листинг 3.5. Входящий документ C

<numbers>

 <int>1</int>

 <byte>1</byte>

 <int>1</int>

</numbers>

Результат:

true and false

С математической точки зрения операции сравнения множеств определены в XSLT, мягко говоря, странно. Например, единственный случай, когда для двух множеств не будет выполняться неравенство ("!=") — это когда все узлы обоих множеств будут иметь одинаковое строковое представление. Вместе с тем, операции сравнения множеств очень часто используются в качестве условий и потому нужно хорошо понимать различия между ними и математическими операциями сравнения.

XSLT определяет единственную операцию над множествами — операцию объединения "|". Выражение "$A | $B" возвратит множество узлов, присутствующих либо в $A, либо в $B, либо и там, и там.

В XSLT нет встроенного оператора, который позволил бы установить принадлежность узла некоторому множеству. Для этой цели используется очень хитроумный прием, основанный на использовании функции count, которая возвращает количество узлов множества. Представим, что множество $node содержит некоторый узел, и мы хотим проверить, входит ли он во множество $nodeset. Сделать это можно при помощи выражения

count($nodeset) = count($node | $nodeset)

которое будет истинным тогда и только тогда, когда $node полностью принадлежит $nodeset.

Этот метод позволяет реализовать в XSLT другие операции над множествами — пересечение, разность и симметрическую разность. Подробное описание этих операций приводится в главе 11.

В XSLT также нет оператора, который позволил бы проверить тождественность двух узлов. Например, если каждое из множеств $A и $B содержит по одному узлу, при помощи простого оператора равенства ($A = $B) мы не сможем проверить, один и тот же это узел или два разных узла с одинаковыми текстовыми значениями.

Для того чтобы корректно выполнить такое сравнение, можно использовать функцию generate-id, которая для каждого из узлов дерева генерирует уникальный строковый идентификатор, присущий только этому узлу и никакому другому, причем для одних и тех же узлов идентификаторы всегда будут генерироваться одинаковыми. Таким образом, для проверки тождественности двух узлов, содержащихся во множествах $A и $B, будет достаточно сравнить их уникальные идентификаторы:

generate-id($А) = generate-id($В)

Множества узлов могут быть преобразованы в булевые значения, числа и строки.

При преобразовании в булевый тип пустое множество узлов преобразуется в false, а непустое — в true. Например, чтобы проверить, есть ли у текущего узла атрибут value, можно написать:

<xsl:if test="@value">

 <xsl:text>Value attribute exists here.</xsl:text>

</xsl:if>

Выражение @value возвратит непустое множество, состоящее из узла атрибута value, если он есть в текущем элементе, или пустое множество, если такого атрибута нет. В первом случае логическим эквивалентом будет true, во втором — false, то есть текст будет выведен только в случае наличия атрибута value.

При преобразовании множества узлов в строку, результатом будет строковое значение первого в порядке просмотра узла множества.

Пример

Листинг 3.6. Входящий документ

<catalog>

 <item>A</item>

 <item>B</item>

 <item>C</item>

 <item>D</item>

</catalog>

Листинг 3.7. Преобразование

<xsl:stylesheet

 version="1.0"

 xmlns:xsl="http://www.w3.org/1999/XSL/Transform">

 <xsl:output method="text"/>

 <xsl:template match="/">

  <xsl:value-of select="catalog/item"/>

 </xsl:template>

</xsl:stylesheet>

Результат:

A

При преобразовании множества узлов в число, множество сначала приводится к строке, а затем строка преобразуется в численное значение. Проще говоря, численным значением множества узлов будет численное значение первого узла в порядке просмотра документа.

Пример

Листинг 3.8. Входящий документ

<numbers>

 <integer>1</integer>

 <real>1.5</real>

 <integer>2</integer>

 <real>2.6</real>

 <integer>3</integer>

 <real>3.7</real>

</numbers>

Листинг 3.9. Преобразование

<xsl:stylesheet

 version="1.0"

 xmlns:xsl="http://www.w3.org/1999/XSL/Transform">

 <xsl:output method="text"/>

 <xsl:template match="/">

  <xsl:value-of select="numbers/real — numbers/integer"/>

 </xsl:template>

</xsl:stylesheet>

Результат:

0.5

Результирующий фрагмент дерева (result tree fragment)

Четыре типа данных, описанных выше, заимствованы языком XSLT из XPath. Вместе с тем, XSLT имеет и свой собственный тип данных, называемый result tree fragment (результирующий фрагмент дерева).

Для того чтобы понять этот тип данных, обратимся к примеру шаблона:

<xsl:template match="href">

 <B>You may visit the <A HREF="{location}">following link</A>.</B>

</xsl:template>

Если мы применим это правило к части документа

<href>

 <location>http://www.xsltdev.ru</location>

</href>

то получим следующий результат:

<B>You may visit the <A HREF="http://www.xsltdev.ru">following link</A>.</B>

В терминах деревьев выполнение этого шаблона показано на рис. 3.17.

Рис. 3.17. Часть дерева входящего документа и часть дерева сгенерированного документа

Поскольку XSLT оперирует документами, представленными в виде деревьев, уместнее будет сказать, что на самом деле шаблоны обрабатывают фрагменты входящего дерева и создают фрагменты исходящего. Последним и соответствует тип данных, который в XSLT называют результирующим фрагментом дерева. Попросту говоря, все, что создается шаблонами во время выполнения преобразования, является результирующими фрагментами и, в конечном итоге, дерево выходящего документа есть композиция этих фрагментов.

Структурно результирующий фрагмент дерева тоже является деревом — это просто отрезанная ветка. Шаблоны генерируют ветки, используя собственные инструкции, а также результаты выполнения шаблонов, которые они вызывают и в итоге множество веток срастается в одно большое дерево, которое и является целью преобразования.

Между тем, результирующие фрагменты деревьев могут и не попасть в само результирующее дерево, то есть совершенно не факт, что они всегда будут его частями. Например, результирующий фрагмент дерева может быть присвоен переменной как начальное значение. Это предоставляет следующие, очень интересные возможности.

□ Переменная может содержать дерево, являющееся результатом обработки документа. К сожалению, в чистом XSLT нельзя повторно обрабатывать части документов, однако, это реализуется при помощи механизма расширений.

□ Дерево может быть определено один раз в виде значения переменной и использовано несколько раз в выходящем документе.

Пример

Листинг 3.10. Входящий документ

<href>

 <location>http://www.xsltdev.ru</location>

</href>

Листинг 3.11. Преобразование

<xsl:stylesheet

 version="1.0"

 xmlns:xsl="http://www.w3.org/1999/XSL/Transform">

 <xsl:variable name="href">

  <body>

   <xsl:apply-templates select="href"/>

  </body>

 </xsl:variable>

 <xsl:template match="href">

  <B>You may visit the <A HREF="{location}">following link</A>.</B>

 </xsl:template>

 <xsl:template match="/">

  <result>

   <xsl:text> Result as string: </xsl:text>

   <xsl:value-of select="$href"/>

   <xsl:text> Result as tree: </xsl:text>

   <xsl:copy-of select="$href"/>

   <xsl:text> </xsl:text>

  </result>

 </xsl:template>

</xsl:stylesheet>

Листинг 3.12. Выходящий документ

<result>

 Result as string:

 You may visit the following link.

 Result as tree:

 <body><B>You may visit the <A HREF="http://www.xsltdev.ru">following

  link</A>.</B>

 </body>

</result>

Это преобразование легко понять, если обратиться к рис. 3.18.

Рис. 3.18. Генерация выходящего дерева с использованием переменных

Переменной href присваивается дерево, содержащее результат обработки элемента href, находящегося в корне входящего документа. Затем переменная href дважды используется в результирующем документе: один раз как строка, принадлежащая текстовому узлу, и один раз как результирующий фрагмент дерева.

Дерево может быть преобразовано в булевое значение, число или строку. Некоторые процессоры позволяют также преобразовывать дерево во множество узлов, которое содержит единственный элемент — корневой узел этого дерева. Такие возможности бывают весьма полезными, но не являются, к сожалению, стандартными в текущей версии языка.

При преобразовании результирующего фрагмента дерева в булевое значение результатом всегда будет true, поскольку дерево никогда не бывает "пустым" — в нем всегда присутствует корневой узел.

При преобразовании дерева в строку результатом является конкатенация (строковое сложение) всех текстовых узлов дерева в порядке просмотра.

Пример

Результирующий фрагмент дерева

<body>

<B>You may visit the <A HREF="http://www.xsltdev.ru">following

link</A>.</B>

</body>

приводится к строке

The result is: You may visit the following link.

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

Пример

Листинг 3.13. Входящий документ:

<numbers>

 <integer>1</integer>

 <real>1</real>

 <integer>2</integer>

 <real>2</real>

 <integer>3</integer>

 <real>3.5</real>

</numbers>

Листинг 3.14. Преобразование:

<xsl:stylesheet

 version="1.0"

 xmlns:xsl="http://www.w3.org/1999/XSL/Transform">

 <xsl:variable name="integers">

  <integers><xsl:copy-of select="/numbers/integer"/></integers>

 </xsl:variable>

 <xsl:variable name="reals">

  <reals><xsl:copy-of select="/numbers/real"/></reals>

 </xsl:variable>

 <xsl:template match="/">

  <result>

   <xsl:text> Integers: </xsl:text>

   <xsl:value-of select="$integers"/>

   <xsl:text> Reals: </xsl:text>

   <xsl:value-of select="$reals"/>

   <xsl:text> Reals minus integers: </xsl:text>

   <xsl:value-of select="$reals - $integers"/>

   <xsl:text> </xsl:text>

  </result>

 </xsl:template>

</xsl:stylesheet>

Листинг 3.15. Результат

<result>

Integers:

123

Reals:

123.5

Reals minus integers:

0.5

</result>

Таблица преобразования типов

Для удобства использования все взаимные преобразования типов сведены в одну таблицу (табл. 3.2).

Таблица 3.2. Взаимные преобразования типов данных XSLT

	Преобразовываемый тип
Целевой тип	boolean (булевое значение)	number (число)	string (строка)	node-set (множество узлов)	tree (дерево)
boolean (булевое значение)		0 → false NaN → false другое → true	пустая → false непустая → true	пустое → false другое → true	всегда true
number (число)	false → 0 true → 1		разбирается, как число в десятичном формате	мн-во → строка → число	дерево → строка → число
string (строка)	false → "false" true → "true"	десятичная запись числа		строковое значение первого узла в порядке просмотра	строковое сложение всех текстовых узлов дерева
node-set (множество узлов)	нет	нет	нет		нет
tree (дерево)	нет	нет	нет	нет

Переменные

Несмотря на отсутствие побочных эффектов, которое является одним из основных принципов XSLT, в преобразованиях можно использовать переменные. Переменная определяется как имя, с которым связывается некоторое значение, например:

<xsl:variable name="url" select="'http://www.xsltdev.ru'"/>

создаст переменную с именем url и присвоит ей строковое значение "http://www.xsltdev.ru". После этого переменную можно использовать в выражениях, например:

<xsl:value-of select="concat('Welcome to ', $url)"/>

Для того чтобы отличать переменные от путей выборки, в выражениях их именам предшествует префикс "$": к значению переменной с именем url мы обращались как к $url.

Каждая из переменных имеет собственную область видимости (англ. visibility scope) — область документа преобразования, в которой может быть использовано ее значение. В зависимости от этого переменные могут быть глобальными (видимыми во всем преобразовании) и локальными (видимыми только в своем родительском элементе).

Помимо переменных, в преобразованиях и шаблонных правилах могут также определяться параметры. Принцип их действия полностью совпадает с принципом действия переменных с той лишь разницей, что значения, присваиваемые параметрам, являются значениями по умолчанию и могут быть изменены извне — например, вызывающим шаблонное правило элементом типа xsl:apply-templates или xsl:call-template, или самим процессором, если речь идет о глобальных параметрах.

Использование переменных и параметров в XSLT отличается от их использования в привычных процедурных языках программирования типа С++, Java или Object Pascal из-за того, что их значения не могут изменяться. После того, как переменной или параметру присвоено некоторое изначальное значение, оно будет оставаться неизменным.

Это ограничение оказывает значительное влияние на стиль программирования преобразований. В этом смысле XSLT намного ближе к функциональным языкам типа Lisp. Например, в XSLT часто используется рекурсия, которая является одним из основных принципов функционального программирования.

Выражения

Многие из задач, которые, так или иначе, выполняются во время преобразования, связаны с вычислением выражений. Для этих целей в XSLT используется язык XPath, который помимо выбора множеств узлов дерева может также выполнять некоторые основные операции над данными.

Замечание

Несмотря на то, что XPath является самостоятельным языком, его роль в XSLT настолько велика, что здесь и далее мы будем рассматривать их как единое целое.

Можно выделить четыре основные задачи, для которых в преобразованиях используются выражения:

□ выбор узлов для обработки;

□ описание условий;

□ вычисление строковых значений, которые затем будут использованы в выходящем дереве;

□ вычисление множеств узлов, которые затем будут использованы в выходящем дереве.

Первая из задач непосредственно относится к самому процессу преобразования. Выражения, содержащиеся в атрибутах select элементов xsl:apply-templates и xsl:for-each, вычисляют множества, к узлам которых нужно применить шаблоны.

Пример

Листинг 3.16

<xsl:template match="HTML">

 <html>

  <xsl:apply-templates select="HEAD"/>

  <xsl:apply-templates select="BODY"/>

 </html>

</xsl:template>

В этом шаблонном правиле содержатся два элемента xsl:apply-templates, которые применяют шаблоны к множествам, выбранным выражениями HEAD и BODY соответственно.

Логические выражения XPath могут использоваться в качестве условий в таких элементах, как xsl:if и xsl:when, обеспечивая условную обработку.

Пример

Предположим, что нам нужно выводить различные сообщения в зависимости от возрастной информации, присутствующей во входящем документе:

Листинг 3.17. Входящий документ

<person>

 <name>Johnny</name>

 <age>19</age>

</person>

Листинг 3.18. Преобразование

<xsl:stylesheet

 version="1.0"

 xmlns:xsl="http://www.w3.org/1999/XSL/Transform">

 <xsl:template match="person">

  <xsl:if test="age >= 21">

   <xsl:text>Welcome, </xsl:text>

   <xsl:value-of select="name"/>

   <xsl:text>.</xsl:text>

  </xsl:if>

  <xsl:if test="age < 21">

   <xsl:text>Sorry, </xsl:text>

   <xsl:value-of select="name"/>

   <xsl:text>, access denied.</xsl:text>

  </xsl:if>

 </xsl:template>

</xsl:stylesheet>

Выделенные выражения age >= 21 и age < 21 (сущности > и < обозначают символы "<", и ">") определяют условия: содержимое первого элемента xsl:if будет выполняться, только если значение элемента age было не меньше 21; содержимое второго — только если значение age было строго меньше 21. Этот же самый шаблон может быть переписан с использованием элементов xsl:choose, xsl:when и xsl:otherwise.

Листинг 3.19

<xsl:stylesheet

 version="1.0"

 xmlns:xsl="http://www.w3.org/1999/XSL/Transform">

 <xsl:template match="person">

  <xsl:choose>

   <xsl:when test="age >= 21">

    <xsl:text>Welcome, </xsl:text>

    <xsl:value-of select="name"/>

    <xsl:text>.</xsl:text>

   </xsl:when>

   <xsl:otherwise>

    <xsl:text>Sorry, </xsl:text>

    <xsl:value-of select="name"/>

    <xsl:text>, access denied.</xsl:text>

   </xsl:otherwise>

  </xsl:choose>

 </xsl:template>

</xsl:stylesheet>

Результатом этого преобразования будет текст

Sorry, Johnny, access denied.

В этой строке имя johnny было заимствовано из входящего документа. Оно было создано элементом xsl:value-of:

<xsl:value-of select="name"/>

Этот элемент вычислил значение выражения name, которое было указано в его атрибуте select, преобразовал результат вычисления в строку и создал в выходящем документе текстовый узел, содержащий вычисленное значение.

В данном случае выражение name использовалось для генерации символьных данных. Между тем, выражения вполне пригодны и для того, чтобы создавать в выходящем документе целые фрагменты:

Листинг 3.20. Преобразование

<xsl:stylesheet

 version="1.0"

 xmlns:xsl="http://www.w3.org/1999/XSL/Transform">

 <xsl:template match="person">

  <xsl:choose>

   <xsl:when test="age >= 21">

    <event type="access granted">

     <xsl:copy-of select="name"/>

    </event>

   </xsl:when>

   <xsl:otherwise>

    <event type="access denied">

     <xsl:copy-of select="name"/>

     <reason type="underaged">

      <xsl:copy-of select="age"/>

     </reason>

    </event>

   </xsl:otherwise>

  </xsl:choose>

 </xsl:template>

</xsl:stylesheet>

Листинг 3.21. Выходящий документ

<event type="access denied">

 <name>John</name>

 <reason type="underaged">

  <age>19</age>

 </reason>

</event>

Элемент xsl:copy-of, который использовался в этом преобразовании, делает примерно то же самое, что и xsl:value-of — вычисляет значение выражения и включает его в дерево выходящего документа. Главным отличием xsl:copy-of является то, что при его выполнении вычисленное выражение не преобразуется в строку, что позволяет копировать в выходящее дерево множества узлов и результирующие фрагменты. В приведенном выше примере элементы name и age выходящего документа являются копиями элементов name и age входящего документа.

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

<reason type="underaged">

 age

</reason>

будет скопирован в выходящий документ, содержащий текст "age". Ни о каком вычислении выражения age речь, конечно же, не идет. Для того чтобы в результирующий документ был скопирован результат вычисления выражения, оно должно быть заключено в атрибут одного из вычисляющих элементов, например, xsl:copy-of:

<reason type="underaged">

 <xsl:copy-of select="age"/>

</reason>

В этом случае в элемент reason будет включен результат вычисления выражения age.

Виды выражений

Выражения языка XPath можно условно разделить на несколько основных типов:

□ пути выборки;

□ выражения фильтрации множеств;

□ выражения объединения множеств;

□ сравнения;

□ логические операции;

□ вызовы функций.

Рассмотрим подробно назначение и принципы работы каждого из типов выражений.

Пути выборки

Путь выборки является самым главным видом выражений, которые применяются в XSLT. Путь выборки в соответствии с некоторыми критериями выбирает множество узлов входящего документа.

Путь выборки может быть абсолютным (отсчитываться от корневого узла дерева) или относительным (отсчитываться от контекстного узла). Он может состоять из нескольких шагов выборки, каждый из которых относительно предыдущего шага (или начального узла) выбирает некоторое множество узлов. Результатом вычисления пути выборки является множество узлов, выбранное его последним шагом.

Пример

Предположим, что нам нужно получить узел элемента title, находящийся в элементе head, который находится в элементе html, находящемся в корне документа. Соответствующий путь выборки будет выглядеть как:

/html/head/title

Означает он примерно следующее:

□ "/" — ведущая косая черта обозначает абсолютный путь выборки, то есть путь, который отсчитывается от корневого узла;

□ "html" — шаг выборки элементов html;

□ "/" — разделитель шагов выборки;

□ "head" — шаг выборки элементов head;

□ "/" — разделитель шагов выборки;

□ "title" — шаг выборки элементов title.

Поскольку каждый из шагов отсчитывается от результатов предыдущего, шаг "html" будет выбирать элементы html, являющиеся дочерними элементами корневого узла и так далее. Пошаговое вычисление этого пути можно описать следующим образом:

□ "/" — путь, который выбирает корневой узел;

□ "/html" — путь, который выбирает дочерние элементы html корневого узла;

□ "/html/head" — путь, который выбирает дочерние элементы head элементов html, находящихся в корне документа;

□ "/html/head/title" — путь, выбирающий дочерние элементы title субэлементов head элементов html, которые находятся в корне документа.

Можно заметить очевидную аналогию с файловыми системами: пути выборки очень похожи на пути в структуре каталогов. Между тем, пути выборки гораздо мощнее:

□ для каждого из шагов выборки можно указать направление, в котором он будет выбирать узлы в документе — например, дочерние узлы, узлы- потомки или, наоборот, узлы-предки или братские узлы;

□ выбор узлов может проводиться не только по имени, но также и по типу или принадлежности определенному пространству имен;

□ выбранное на каждом шаге множество может фильтроваться одним или более предикатом (в отфильтрованном множестве останутся только те из выбранных узлов, которые поочередно удовлетворяют каждому из логических условий-предикатов).

Пути выборки являются средством получения информации, содержащейся в обрабатываемых документах. Неважно, что они возвращают множества узлов, неявное преобразование типов позволяет спокойно записывать выражения вида:

data/a + data/b

Несмотря на то, что data/a и data/b являются множествами узлов, в арифметическом выражении они будут неявно преобразованы к численному типу. То же самое касается строкового и булевого типа.

Фильтрующие выражения

Фильтрующие выражения выполняют две основные задачи:

□ выбор из вычисленного множества узлов некоторого подмножества в соответствии с заданными логическими критериями-предикатами;

□ вычисление путей выборки относительно узлов фильтрованного множества.

Примеры

Предположим, что переменной nodeset присвоено некоторое множество узлов. Задачи типа "выбрать каждый второй узел этого множества" или "выбрать первый узел этого множества" или вообще, любой выбор узлов этого множества в соответствии с некоторыми заданными логическими критериями являются задачами фильтрации. Выражение $nodeset[1] выберет первый в порядке просмотра документа узел множества $nodeset; выражение $nodeset[position() mod 2 = 0] выберет четные узлы множества $nodeset. Здесь "[1]" и "[position() mod 2 = 0]" являются предикатами — логическими выражениями, которые фильтруют множество.

Фильтрующие выражения также позволяют вычислять пути выборки относительно узлов фильтруемых множеств.

Пример

Листинг 3.22. Входящий документ

<data>

 <string>

  <value>a</value>

  <value>b</value>

  <value>c</value>

 </string>

 <number>

  <value>1</value>

  <value>2</value>

  <value>3</value>

 </number>

</data>

Следующее преобразование демонстрирует использование относительных путей выборки в фильтрующих выражениях:

Листинг 3.23. Преобразование

<xsl:stylesheet

 version="1.0"

 xmlns:xsl="http://www.w3.org/1999/XSL/Тransform">

 <xsl:template match="data">

  <values>

   <xsl:copy-of select="(string | number)/value"/>

  </values>

 </xsl:template>

</xsl:stylesheet>

Листинг 3.24. Входящий документ

<values>

 <value>a</value>

 <value>b</value>

 <value>c</value>

 <value>1</value>

 <value>2</value>

 <value>3</value>

</values>

Элемент values выходящего документа содержит множество, являющееся результатом вычисления выражения (string | number)/value. Это будет множество элементов value, принадлежащих элементам string или number.

Объединение множеств

Единственная операция над множествами, которая определена в XSLT, — это операция объединения. Если $nodeset1 и $nodeset2 — два множества узлов, то результатом вычисления

$nodeset1 | $nodeset2

будет множество узлов, которые принадлежат хотя бы одному из этих множеств.

Следует сказать, что, поскольку никакой тип данных не может быть преобразован во множество узлов, операнды объединения сами всегда должны быть множествами. То есть, выражение вида:

'а' | body/a

не добавит текстовый узел "а" к множеству элементов а, принадлежащих элементу body — оно просто будет некорректным.

Арифметические операции

Четыре основные бинарные операции — "+", "-", "div", "mod" и пятая, унарная операция отрицания "-" обеспечивают в XSLT основные арифметические действия. Поскольку любой из типов данных может быть преобразован в численный тип, в качестве операндов арифметических операций можно использовать что угодно — например, вычитать из строки булевое выражение:

'0.5' - true() → -0.5

Следует осторожно обращаться со знаком "-". Имена элементов и атрибутов могут включать этот знак и поэтому выражение first-last будет воспринято не как разность значений элементов first и last, а как путь выборки элементов с именами "first-last". Для того чтобы избежать таких казусов, операторы всегда следует выделять пробелами:

first - last

Операции сравнения

В XSLT имеются следующие шесть операторов сравнения:

□ "=" — равно;

□ "!=" — не равно;

□ "<" меньше;

□ ">" больше;

□ "<=" меньше или равно (не больше);

□ ">=" больше или равно (не меньше).

Результат этих сравнений всегда имеет булевый тип, то есть сравнение может быть либо истинным, либо ложным. Несмотря на внешнюю очевидность функций этих операторов, наличие такого типа данных, как множество узлов, делает четкое определение сравнений довольно сложным. Мы приведем его так, как оно приведено в спецификации, снабдив подробными комментариями и примерами.

Операции сравнения определяются в спецификации в три этапа:

□ сначала сравнение, в котором участвуют множества узлов, определяется в терминах сравнения более простых типов данных;

□ затем для простых типов данных определяются равенство ("=") и неравенство ("!=");

□ наконец, для простых типов данных определяются сравнения "<", "<=", ">", ">=".

Сравнение, хотя бы один из операндов которого является множеством узлов, определяется следующим образом:

□ если один из операндов является множеством узлов, а второй имеет булевый тип, сравнение будет истинным тогда и только тогда, когда истинным будет результат сравнения множества узлов, преобразованного к булевому типу и самого булевого операнда;

□ если один из операндов является множеством узлов, а второй имеет численный тип, сравнение будет истинным тогда и только тогда, когда во множестве узлов найдется такой узел, что сравнение текстового значения этого узла, преобразованного к числу, и самого численного операнда будет истинным;

□ если один из операндов является множеством узлов, а второй имеет строковый тип, сравнение будет истинным тогда и только тогда, когда во множестве узлов найдется такой узел, что сравнение его текстового значения и самого строкового операнда будет истинным;

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

Примеры выражений, которые мы будем приводить, будут использовать следующий входящий документ (листинг 3.25).

Листинг 3.25. Входящий документ

<values>

 <string>0.5</string>

 <string>50%</string>

 <string>1/2</string>

 <number>0.5</number>

 <number>1.0</number>

 <number>1.5</number>

</values>

Примеры сравнений множества узлов с булевым значением:

/values/string = true() → true

В этом равенстве множество узлов сравнивается с булевым значением "истины". Множество узлов, выбираемое путем /values/string, приводится к булевому типу. Результатом приведения будет "истина", поскольку множество элементов string, принадлежащих элементу values, непусто. Таким образом, сравнение является проверкой на равенство двух "истин" — и результат, естественно, тоже будет "истиной".

/values/string != boolean(/values/boolean) → false

В этом случае мы проверяем множество узлов /values/string на неравенство булевому значению множества /values/boolean. Второй операнд является "истиной" (поскольку множество элементов boolean, принадлежащих элементу values, не пусто), а значит, все сравнение обратится в "ложь".

/values/string = boolean(/values/booleans) → false

В данном случае множество /values/string сравнивается с булевым значением множества /values/booleans, которое будет "ложью", поскольку это множество будет пустым. Таким образом, результат сравнения также будет "ложью".

/values/strings = boolean(/values/booleans) → true

Множества /values/strings и /values/booleans будут пустыми, поэтому, сравнивая первое с булевым значением второго, мы получим "истину", так как "ложь" равна "лжи".

Примеры сравнения множества узлов с числом:

/values/number < 1 → true

Множество узлов /values/number может считаться меньше, чем число 1, поскольку первый элемент этого множества имеет строковое значение "0.5", при приведении которого к числу мы получаем 0.5, что меньше 1.

/values/number > 1 → true

То же самое множество узлов может считаться также и большим 1, поскольку последний элемент этого множества имеет строковое значение "1.5", при приведении которого к числу мы получаем 1.5, что больше 1.

/values/number = 1 → true

Второй элемент множества /values/number равен 1, то есть и это сравнение будет истинным.

Примеры сравнения множества узлов со строковым значением:

/values/number = '1' → false

Множество /values/number не будет равно строке "1", поскольку ни один из узлов этого множества не имеет строкового значения "1".

/values/number = '1.0' → true

Множество /values/number будет считаться равным строке "1.0", поскольку второй узел этого множества имеет текстовое значение "1.0".

/values/number != '1.0' → true

Множество /values/number может также считаться не равным строке "1.0", поскольку первый узел этого множества имеет текстовое значение "0.5", не равное "1.0".

Примеры сравнения двух множеств узлов:

/values/number = /values/string → true

Для двух этих множеств будет выполняться равенство, поскольку оба они имеют по узлу с равными строковыми значениями — первый узел /values/number и первый узел /values/string равны "0.5".

values/number != /values/string → true

Для этих же множеств будет выполняться неравенство, поскольку в них найдется неравная пара узлов (например, узел с текстовым значением "1.0" в /values/number и узел с текстовым значением "50%" в /values/string).

Определим теперь равенство и неравенство значений простых типов. При проверке на равенство или неравенство оба операнда приводятся к общему типу и сравниваются. Приведение к общему типу производится следующим образом:

□ если хотя бы один из операндов имеет булевый тип, второй также приводится к булевому типу;

□ иначе, если хотя бы один из операндов — число, второй также приводится к численному типу;

□ иначе, если хотя бы один из операндов — строка, второй также приводится к строковому типу.

После того, как оба операнда приведены к некоторому общему типу, они проверяются на равенство или неравенства как два значения этого общего типа:

□ два булевых значения равны тогда и только тогда, когда они оба являются "истиной" или оба являются "ложью";

□ равенство численных значений понимается в обычном смысле (строгое определение равенства чисел дано в стандарте IEEE 754, но вряд ли оно представляет для нас большой интерес);

□ две строки равны тогда и только тогда, когда они представлены одинаковыми последовательностями Unicode-символов.

Два значения простых типов (то есть — булевого, численного или строкового типа) неравны тогда и только тогда, когда для них не выполняется равенство.

Примеры сравнения значений простых типов:

□ true() = 1 → true

При приведении числа 1 к булевому типу получается "истина", что и подтверждаетсяэтим равенством.

□ true() = 100 → true

Результатом приведения числа 100 к булевому типу также является "истина".

□ false() = 'false' → false

При приведении непустой строки "false" к булевому типу, получается "истина". Отсюда — неверность равенства.

□ .5 =0.5 → true

.5 и 0.5 представляют одно и то же число, хоть и они записаны в разной форме.

□ .5 = '0.5' → true

Это равенство также будет верным, поскольку результатом преобразования строки "0.5" в число будет также 0.5.

□ 1 != 'two' → true

Результатом преобразования строки "two" в численный тип будет значение NaN, которое не равно 1.

При сравнении с использованием операторов "<", "<=", ">" и ">=", оба операнда всегда приводятся к численному типу и сравниваются как числа.

Примеры сравнений с использованием операторов "<", "<=", ">" и ">=":

false () > true() → false

В численном виде true() соответствует 1, a false() — 0, то есть это сравнение равносильно сравнению 0 > 1, результатом которого является "ложь".

'0' <= false() → true

Это сравнение равносильно сравнению 0 <= 0, результатом его будет "истина".

'1' >= '0' → true

Это сравнение равносильно сравнению 1 >= 0, результатом его будет "истина".

Следует обратить внимание, на то, что символы "<" и ">" заменены сущностями < и > соответственно. В случае символа "<" такая замена необходима, чтобы не нарушать выражениями синтаксис XML-документа. Заменять символ ">" обязательной нужды нет, это делается исключительно из соображений единообразности.

Логические операции

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

Семантика or и and очевидна — они соответствуют операциям логического сложения и умножения.

Результатом операции or будет "истина", если хотя бы один из операндов является "истиной". При этом если первый операнд имеет значение true, второй операнд не вычисляется — результат и так будет "истиной".

Результатом операции and будет "истина", если оба операнда истинны. При этом если первый из операндов — "ложь", то второй операнд не вычисляется — результат и так будет "ложью".

Функции

Функции значительно расширяют возможности выражений. Они принимают на вход несколько аргументов и возвращают некоторый результат, который иногда является продуктом весьма замысловатого вычисления.

Функции можно условно разделить на стандартные функции, которые определены в XPath и XSLT и должны поддерживаться (хотя на самом деле поддерживаются далеко не всегда) всеми XSLT-процессорами, и функции расширения, которые могут создаваться разработчиками в дополнение к стандартным функциям.

Контекст вычисления выражений

Выражения всегда вычисляются в некотором контексте — окружении, которое зависит от того, какая часть документа обрабатывается XSLT-процессором в данный момент, и какие объявления присутствовали в самом преобразовании.

Контекст преобразования состоит из узла, называемого контекстным узлом, двух целых чисел — размера контекста и позиции в контексте, объявлений переменных, объявлений пространств имен и библиотеки функций.

Контекст самым непосредственным образом влияет на вычисление выражений. Относительные пути выборки отсчитываются от контекстного узла, вычисление многих функций также производится в зависимости от контекста. Кроме того, в выражениях нельзя использовать функции, пространства имен и переменные, не присутствующие в контексте.

Пример

Для того чтобы показать, как изменяется контекст во время преобразования, мы напишем шаблон, который заменяет все элементы входящего документа элементами вида:

<element

 name="имя элемента"

 context-position="позиция в контексте"

 context-size="размер контекста"

 string-value="строковое значение">

 ...

</element>

Листинг 3.26. Преобразование

<xsl:stylesheet

 version="1.0"

 xmlns:xsl="http://www.w3.org/1999/XSL/Transform">

 <xsl:output indent="yes"/>

 <xsl:strip-space elements="*"/>

 <xsl:template match="*">

  <element

   name="{name()}"

   context-position="{position()}"

   context-size="size()"

   string-value="{.}">

   <xsl:apply-templates select="*"/>

  </element>

 </xsl:template>

</xsl:stylesheet>

Листинг 3.27. Входящий документ

<data>

 <part>

  <item>A</item>

  <item>B</item>

  <item>C</item>

 </part>

 <part>

  <value>D</value>

  <value>E</value>

  <value>F</value>

 </part>

</data>

Листинг 3.28. Выходящий документ

<element name="data"

 context-position="1" context-size="1" string-value="ABCDEF">

 <element name="part"

  context-position="1" context-size="2" string-value="ABC">

 <element name="item"

  context-position="1" context-size="3" string-value="A"/>

 <element name="item"

  context-position="2" context-size="3" string-value="B"/>

 <element name="item"

  context-position="3" context-size="3" string-value="C"/> </element>

 <element name="part"

  context-position="2" context-size="2" string-value="DEF">

 <element name="value"

  context-position="1" context-size="3" string-value="D"/>

 <element name="value"

  context-position="2" context-size="3" string-value="E"/>

 <element name="value"

  context-position="3" context-size="3" string-value="F"/>

 </element>

</element>

Модель преобразования

Во вводной главе мы говорили, что преобразования в XSLT являются наборами шаблонных правил, каждое из которых обрабатывает определенный фрагмент входящего документа с тем, чтобы сгенерировать фрагмент выходящего документа.

Контекст преобразования

При выполнении преобразования каждая из его инструкций, каждый из элементов обрабатывается в некотором контексте. Контекст преобразования состоит из двух частей: из текущего множества узлов и из текущего узла, которые показывают, что именно обрабатывается в данный момент. XSLT-процессор поочередно обрабатывает каждый из узлов текущего множества (при этом делая этот узел текущим узлом) и объединяет результаты в одно дерево.

Контекст преобразования тесно связан с контекстом вычисления выражений:

□ текущий узел контекста преобразования соответствует контекстному узлу вычисления выражений;

□ позиция текущего узла в текущем обрабатываемом множестве соответствует позиции контекста вычисления выражений;

□ размер текущего множества узлов соответствует размеру контекста вычисления выражений.

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

Изменения контекста могут быть продемонстрированы на следующем примере.

Листинг 3.29. Входящий документ

<summer>

 <month>June</month>

 <month>July</month>

 <month>August</month>

</summer>

Этому документу соответствует следующее дерево (рис. 3.19):

Рис. 3.19. Дерево входящего документа

Листинг 3.30. Преобразование

<xsl:stylesheet

 version="1.0"

 xmlns:xsl="http://www.w3.org/1999/XSL/Transform">

 <xsl:template match="/">

  <html>

   <head>

    <title>Summer</title>

   </head>

   <body>

    <xsl:apply-templates select="summer"/>

   </body>

  </html>

 </xsl:template>

 <xsl:template match="summer">

  <table>

   <tr>

    <xsl:apply-templates select="month"/>

   </tr>

  </table>

 </xsl:template>

 <xsl:template match="month">

  <td>

   <xsl:value-of select="."/>

  </td>

 </xsl:template>

</xsl:stylesheet>

Забегая вперед скажем, что в изначальном контексте преобразования текущее множество состоит из единственного узла — корневого узла документа. Он становится текущим и обрабатывается соответствующим шаблоном.

В нашем случае шаблонное правило, обрабатывающее корневой узел, выглядит как:

<xsl:template match="/">

 <html>

  <head>

   <title>Summer</title>

  </head>

  <body>

   <xsl:apply-templates select="summer"/>

  </body>

 </html>

</xsl:template>

Тело этого шаблона выполняется в том самом изначальном контексте, о котором мы только что упомянули: текущее множество состоит из корневого узла, он же является и текущим узлом. Мы можем показать контекст, выделяя текущее множество, пунктиром, а текущий узел — полужирной линией (рис. 3.20).

Рис. 3.20. Первоначальный контекст преобразования

Атрибут select элемента xsl:apply-templates задает выражение, вычисляющее множество узлов, которые должны быть обработаны. Выражение summer, которое содержит этот атрибут, является относительным путем выборки, который возвращает все дочерние элементы summer текущего узла. Поскольку текущим узлом в данном контексте является корневой узел дерева, значением выражения summer будет множество узлов, состоящее из субэлемента summer, корневого узла.

При выполнении элемента xsl:apply-templates процессор сделает это вычисленное множество узлов текущим множеством и начнет поочередно обрабатывать его узлы, делая их при этом текущими. Иначе говоря, выполнение элемента

<xsl:apply-templates select="summer"/>

сведется к выполнению шаблона, обрабатывающего элемент summer. Этот шаблон выглядит следующим образом:

<xsl:template match="summer">

 <table>

  <tr>

   <xsl:apply-templates select="month"/>

  </tr>

 </table>

</xsl:template>

Выполняться он будет в следующем контексте (рис. 3.21):

Рис. 3.21. Контекст шаблона элемента summer

Атрибут select элемента xsl:apply-templates, который присутствует в этом шаблоне, вычисляет новое текущее множество: путь выборки month возвращает все дочерние элементы month текущего узла. Текущим узлом является элемент summer, то есть новое текущее множество будет состоять из трех его дочерних элементов month. Таким образом, процессор будет поочередно выполнять шаблоны в каждом из трех следующих контекстов, показанных на рис. 3.22.

Рис. 3.22. Изменение контекста при выполнении шаблона элемента month

Шаблон, вычисляемый в каждом из этих контекстов, имеет следующий вид:

<xsl:template match="month">

 <td>

  <xsl:value-of select="."/>

 </td>

</xsl:template>

Элемент xsl:value-of этого шаблона создает в элементе td текстовый узел, значение которого равно строковому значению выражения ".", то есть строковому значению текущего узла, и в каждом случае это будет строковое значение соответствующего элемента month.

Контекст преобразования позволяет более четко определить такие понятия, как "обработка узла", "применение шаблона к узлу" и так далее. Все эти выражения означают одно: выполнение соответствующего шаблона с данным узлом в качестве текущего.

Выполнение преобразования

Несмотря на полную свободу в порядке выполнения шаблонов, правила изменения контекста и компоновки результирующего дерева, спецификация XSLT оговаривает очень четко — это делает XSLT весьма гибким языком, программы на котором при этом выполняются совершенно детерминированным образом.

Типовой процесс выполнения преобразования согласно спецификации включает следующие стадии:

□ дерево выходящего документа создается путем обработки множества, состоящего из единственного узла — текущего узла дерева;

□ результатом применения шаблонов к обрабатываемому множеству узлов является объединение фрагментов деревьев, которые являются результатами обработки каждого из узлов множества;

□ каждый из узлов обрабатываемого множества преобразуется следующим образом:

 • из всех шаблонов, определенных в данном преобразовании, выбираются шаблоны, соответствующие данному узлу (соответствие определяется паттерном, указанным в атрибуте match элемента xsl:template);

 • из этих шаблонов выбирается наиболее подходящий;

 • выбранный шаблон выполняется в контексте обрабатываемого множества как текущего множества узлов и обрабатываемого узла как текущего узла;

□ если шаблон содержит инструкции xsl:apply-templates или xsl:foreach, которые дополнительно выбирают узлы для обработки, процесс рекурсивно продолжается до тех пор, пока обрабатываемое множество будет содержать хотя бы один узел.

В общих чертах этот процесс был продемонстрирован на примере, приведенном в описании контекста преобразования. Сейчас мы завершим картину, показав, как в каждом из шаблонов будут создаваться результирующие фрагменты деревьев и как они затем будут "сращиваться" в дерево выходящего документа.

На сей раз, мы начнем с самых "глубоких" шаблонов — шаблонов, обрабатывающих элементы month.

<xsl:template match="month">

 <td>

  <xsl:value-of select="."/>

 </td>

</xsl:template>

Каждый из них создает результирующий фрагмент дерева следующего вида (рис. 3.23).

Рис. 3.23. Результат обработки элемента month

Шаблоны к элементам month применяются элементом xsl:apply-templates при обработке элемента summer соответствующим шаблоном:

<xsl:template match="summer">

 <table>

  <tr>

   <xsl:apply-templates select="month"/>

  </tr>

 </table>

</xsl:template>

Результатом выполнения xsl:apply-templates будет объединение результирующих фрагментов деревьев, которые получатся при обработке элементов month. Таким образом, результирующий фрагмент этого шаблона будет "собран" в следующем виде (рис. 3.24):

Рис. 3.24. Результат обработки элемента summer

Пунктиром выделены результирующие фрагменты деревьев, сгенерированные при обработке элементов month; эти фрагменты объединяются и используются при создании фрагмента дерева, являющегося результатом обработки элемента summer.

Этот результат, в свою очередь, используется в главном шаблоне — шаблоне, который обрабатывает корневой элемент:

<xsl:template match="/">

 <html>

  <head>

   <title>Summer</title>

  </head>

  <body>

   <xsl:apply-templates select="summer"/>

  </body>

 </html>

</xsl:template>

Сгенерированный при обработке элемента summer результирующий фрагмент дерева включается в корневом шаблоне в элемент body (рис.3.25).

Рис. 3.25. Результат обработки корневого узла

Пунктиром выделен результирующий фрагмент дерева, который был получен при обработке элемента summer.

Результирующий фрагмент дерева, полученный в результате обработки корневого узла, является деревом выходящего документа. В чистом XSLT это и есть результат выполнения преобразования. Для того чтобы получить физическую интерпретацию — в данном случае HTML-документ, дерево сериализуется, обращаясь в следующий выходящий документ.

Листинг 3.31. Выходящий документ проведённого преобразования

<html>

 <head>

  <title>Summer</title>

 </head>

 <body>

  <table>

   <tr>

    <td>June</td>

    <td>July</td>

    <td>August</td>

   </tr>

  </table>

 </body>

</html>

Надо сказать, что спецификация языка XSLT не оговаривает, в каком именно порядке процессоры должны выполнять шаблонные правила — главное, чтобы результат преобразования совпадал с результатом, полученным при обработке приведенным выше способом. На практике это означает, что разработчикам совершенно необязательно знать, как именно конкретный процессор применяет правила — достаточно понимать принципы шаблонной обработки. В этом одно из главных достоинств XSLT как языка, не имеющего побочных эффектов.

Глава 4 Структура преобразования

Пространство имен XSLT

Для того чтобы выделить элементы и атрибуты, которые принадлежат логической схеме XSLT, в этом языке применяется механизм пространств имен. Это означает, что в документе преобразования элементы, относящиеся к XSLT, должны принадлежать его пространству имен.

Уникальный идентификатор ресурса пространства имен XSLT имеет вид

http://www.w3.org/1999/XSL/Transform

Как отмечалось ранее, по адресу, указанному в URI пространства имен, совершенно необязательно будет находиться что-либо осмысленное. Однако в нашем случае по адресу http://www.w3.org/1999/XSL/Transform находится текстовый документ, содержащий единственную строчку:

This is the XSLT namespace.

Символ 1999 в URI пространства имен XSLT никак не соотносится с версией языка преобразования. Это просто год, который был назначен Консорциумом W3 данной спецификации и не более. Версия использованного языка определяется атрибутом version элемента xsl:stylesheet.

Общепринятым префиксом пространства имен языка XSLT является префикс xsl. Естественно, он может быть любым другим, но в этой книге мы будем использовать именно такое обозначение. Таким образом, объявление пространства имен XSLT в общем случае будет выглядеть следующим образом: xmlns:xsl="http://www.w3.org/1999/XSL/Transform"

Пример

Приведем пример простого преобразования, в котором объявлено пространство имен XSLT.

<xsl:stylesheet

 version="1.0"

 xmlns:xsl="http://www.w3.org/1999/XSL/Transform">

 <xsl:template match="/">

  <xsl:element name="root"/>

 </xsl:template>

</xsl:stylesheet>

В некоторых случаях исходный текст намного упрощается, если пространство имен XSLT объявляется по умолчанию:

<stylesheet

 version="1.0"

 xmlns="http://www.w3.org/1999/XSL/Transform">

 <template match="/">

  <element name="root"/>

 </template>

</stylesheet>

Кроме этого, пространство имен по умолчанию можно снова обнулить:

<stylesheet

 version="1.0"

 xmlns="http://www.w3.org/1999/XSL/Transform">

 <template match="root">

  <root xmlns=""/>

 </template>

</stylesheet>

В последнем случае элемент root будет принадлежать нулевому пространству имен. Результат всех трех преобразований одинаков:

<root/>

Элементы XSLT могут содержать атрибуты, принадлежащие другим, но обязательно ненулевым, пространствам имен. Такие атрибуты могут содержать дополнительную информацию, но поскольку они не относятся к XSLT, обрабатываться процессором в общем случае они не будут.

Пример

Если мы определим в преобразовании элемент вида

<xsl:template match="a" xsldoc:text="Processes all a elements"

 xmlns:xsldoc="http://www.a.com/XSL/doc">

 ...

</xsl:template>

то в общем случае атрибут xsldoc:text будет проигнорирован. Однако процессор, которому знакомо пространство имен с URI http://www.a.com/XSL/doc сможет понять, что этот атрибут применен для документирования преобразования и будет использовать его в своих целях.

Корневые элементы преобразования

За исключением случаев упрощенных преобразований, корневым элементом XSLT-документа всегда является элемент xsl:stylesheet или его синоним xsl:transform. Эти элементы полностью идентичны и различаются только именами, поэтому мы будем описывать семантику и пользоваться только элементом xsl:stylesheet.

Элементы xsl:stylesheet и xsl:transform

<xsl:stylesheet

 id="идентификатор"

 extension-element-prefixes="префиксы"

 exclude-result-prefixes="префиксы"

 version="число">

 <!--

  Содержимое: несколько элементов xsl:import, элементы верхнего уровня

 -->

</xsl:stylesheet>

<xsl:transform id="идентификатор"

 extension-element-prefixes="префиксы"

 exclude-result-prefixes="префиксы"

 version="число">

 <!--

  Содержимое: несколько элементов xsl:import, элементы верхнего уровня

 -->

</xsl:transform>

Элемент xsl:stylesheet имеет обязательный атрибут version, в котором указывается версия языка, использованная при создании этого преобразования. Текущей версией языка является версия 1.0, поэтому все преобразования, которые мы будем приводить в качестве примеров, будут начинаться следующим тегом:

<xsl:stylesheet version="1.0" ... >

Необязательный атрибут id может содержать уникальный идентификатор данного преобразования. Этот атрибут используется в тех случаях, когда преобразование включено в преобразуемый документ для его идентификации внутри этого документа.

Пример

Если преобразование, включенное в преобразуемый документ, будет иметь вид

...

<xsl:stylesheet

 version="1.0"

 id="trans"

 xmlns:xsl="http://www.w3.org/1999/XSL/Transform">

 ...

</xsl:stylesheet>

...

то ассоциироваться с документом оно будет следующей инструкцией:

<?xml-stylesheet type="text/xsl" href="#trans"?>

Необязательный атрибут extension-element-prefixes перечисляет префиксы пространств имен, которые определяют элементы расширения. Об использовании этого атрибута мы расскажем в главе 10, которая посвящена созданию расширений языка XSLT.

Необязательный атрибут exclude-result-prefixes перечисляет префиксы пространств имен, определения которых не нужно включать в выходящий документ. Использование этого атрибута подробно описано в главе 8.

Элемент xsl:stylesheet может включать следующие элементы языка XSLT:

□ xsl:import;

□ xsl:include;

□ xsl:strip-space;

□ xsl:output;

□ xsl:key;

□ xsl:decimal-format;

□ xsl:namespace-alias;

□ xsl:attribute-set;

□ xsl:variable;

□ xsl:param;

□ xsl:template.

Эти элементы называются элементами верхнего уровня, поскольку они могут находиться на самом верхнем (не считая уровня корневого элемента) уровне в иерархии элементов документа. Более того, все перечисленные элементы кроме xsl:variable и xsl:param должны находиться только на верхнем уровне. Элементы xsl:variable и xsl:param могут использоваться в шаблонах, определяя локальные переменные и параметры.

Если преобразование импортирует внешние модули, первыми дочерними элементами xsl:stylesheet должны быть элементы xsl:import. Иначе говоря, элементам xsl:import внутри xsl:stylesheet должны предшествовать только другие элементы xsl:import. Порядок всех остальных дочерних элементов xsl:stylesheet не имеет значения.

Помимо элементов верхнего уровня, xsl:stylesheet может содержать элементы других, но обязательно ненулевых пространств имен. Это позволяет включать в преобразования любую сопутствующую информацию, правда спецификация оговаривает, что такого рода элементы не должны изменять поведение элементов и функций самого XSLT.

Пример

Листинг 4.1. Преобразование с элементом верхнего уровня, не принадлежащим XSLT

<xsl:stylesheet

 version="1.0"

 xmlns:xsl="http://www.w3.org/1999/XSL/Transform">

 <source xmlns="http://www.a.com/XSL/source">

  Simple stylesheet

 </source>

 <xsl:template match="/">

  <root/>

 </xsl:template>

</xsl:stylesheet>

Выделенный полужирным шрифтом на листинге 4.1 элемент source принадлежит пространству имен с URI http://www.a.com/XSL/source. Поскольку пространство имен этого элемента ненулевое, такое объявление является корректным.

Упрощенные преобразования

Многие простые преобразования состоят из единственного правила, которое обрабатывает корневой узел входящего документа. Общий вид такого рода преобразований показан в следующем листинге.

Листинг 4.2. Простое преобразование

<xsl:stylesheet

 version="1.0"

 xmlns:xsl="http://www.w3.org/1999/XSL/Transform">

 <xsl:template match="/">

  <result>

   <!-- Шаблон -->

  </result>

 </xsl:template>

</xsl:stylesheet>

XSLT позволяет упрощать запись таких преобразований, опуская элементы xsl:stylesheet и xsl:template и оставляя только шаблон, создающий выходящий документ.

Корневой элемент упрощенной записи должен содержать атрибут xsl:version, указывающий версию языка XSLT, использованного в шаблоне. Как правило, этот элемент также содержит объявление пространства имен XSLT, хотя оно может быть определено и в другом месте.

Пример

Преобразование, приведенное в листинге 4.2, можно переписать в упрощенном виде следующим образом.

Листинг 4.3. Упрощённая запись преобразования

<result

 xsl:version="1.0"

 xmlns:xsl="http://www.w3.org/1999/XSL/Transform">

 <!-- Шаблон -->

</result >

Приведем еще один простой пример упрощенной записи преобразования, генерирующего простейшую HTML-страницу.

Листинг 4.4. Упрощённая запись преобразования XML-документа в HTML

<html xsl:version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">

 <head>

  <title>

   <xsl:value-of select="page/name"/>

  </title>

 </head>

 <body>

  <xsl:value-of select="page/content"/>

 </body>

</html>

Следующий листинг приводит полную версию этого же преобразования.

Листинг 4.5. Полная запись преобразования XML-документа в HTML

<xsl:stylesheet

 version="1.0"

 xmlns:xsl="http://www.w3.org/1999/XSL/Transform">

 <xsl:template match="/">

  <html>

   <head>

    <title>

     <xsl:value-of select="page/name"/>

    </title>

   </head>

   <body>

    <xsl:value-of select="page/content"/>

   </body>

  </html>

 </xsl:template>

</xsl:stylesheet>

Модульная организация преобразования

Как и любой, достаточно развитый язык программирования, XSLT обладает средствами для организации модульной структуры преобразований. Существуют два основных способа использования в преобразованиях внешних модулей — включение и импорт. Кроме того, поскольку преобразования в XSLT также являются XML-документами, для разбиения их на модули можно применять сущности.

Включение преобразований

Подобно тому, как мы бы использовали в языке С директиву #include для включения внешних файлов, преобразования в XSLT могут использовать для той же самой цели элемент xsl:include. Правда, в отличие от языка С, условное включение в XSLT невозможно.

Элемент xsl:include

<xsl:include

 href = "URI"/>

Обязательный атрибут href элемента xsl:include содержит URI внешнего модуля, который должен быть включен в текущее преобразование. Внешний модуль обязан быть корректным XSLT-преобразованием.

Включение внешнего преобразования является включением в прямом смысле этого слова: преобразование, включающее внешний модуль, ведет себя так, как если бы на месте элемента xsl:include было содержимое этого внешнего модуля.

Пример

Рассмотрим простое преобразование a.xsl, которое определяет значение переменной date.

Листинг 4.6. Преобразование a.xsl

<xsl:stylesheet

 version="1.0"

 xmlns:xsl="http://www.w3.org/1999/XSL/Transform">

 <xsl:variable name="date" select="'16.07.2001'"/>

</xsl:stylesheet>

Включим a.xsl в преобразование b.xsl.

Листинг 4.7. Преобразование b.xsl

<xsl:stylesheet

 version="1.0"

 xmlns:xsl="http://www.w3.org/1999/XSL/Transform">

 <xsl:include href="a.xsl"/>

 <xsl:template match="/">

  <content>

   <xsl:text>Today is </xsl:text>

   <xsl:value-of select="$date"/>

   <xsl:text>.</xsl:text>

  </content>

 </xsl:template>

</xsl:stylesheet>

Включение в преобразование b.xsl преобразования a.xsl эквивалентно замене в b.xsl соответствующего элемента xsl:include на содержимое преобразования a.xsl. В нашем случае будет включено только определение переменной date. Преобразование b.xsl можно переписать в следующем виде: .

<xsl:stylesheet

 version="1.0"

 xmlns:xsl="http://www.w3.org/1999/XSL/Transform">

 <xsl:variable name="date" select="'16.07.2001'"/>

 <xsl:template match="/">

  <content>

   <xsl:text>Today is </xsl:text>

   <xsl:value-of select="$date"/>

   <xsl:text>.</xsl:text>

  </content>

 </xsl:template>

</xsl:stylesheet>

При включении внешних преобразований при помощи xsl:include следует учитывать некоторые особенности использования этого элемента.

Все ссылки и относительные идентификаторы ресурсов (URI), используемые во включаемом преобразовании, вычисляются относительно его базового адреса.

Пример

Предположим, что URI нашего преобразования имеет вид:

http://www.xsltdev.ru/examples/a.xsl

В этом случае элемент

<xsl:include href="b.xsl"/>

будет включать преобразование с URI

http://www.xsltdev.ru/examples/b.xsl

Нет никаких проблем и с включением преобразований по абсолютным идентификаторам. Например, если преобразование identity.xsl находится по адресу

http://www.xsltdev.ru/stylesheets/identity.xsl

то включить его можно элементом

<xsl:include href=" http://www.xsltdev.ru/stylesheets/identity.xsl"/>

Естественно, включаемые модули должны быть доступны процессору во время выполнения преобразования, поэтому если они находятся на других серверах, то всегда будет существовать возможность невыполнения преобразования.

В XSLT элементы xsl:import всегда должны быть первыми дочерними элементами головного элемента xsl:stylesheet. Поэтому элементы xsl:import внешнего преобразования включаются сразу после элементов xsl:import основного преобразования. Если в основном преобразовании элементов xsl:import нет, то включаемые элементы xsl:import становятся первыми дочерними элементами xsl:stylesheet основного преобразования.

Пример

Предположим, что в основное преобразование мы импортируем файл a.xsl и включаем файл b.xsl.

Листинг 4.8. Основное преобразование

<xsl:stylesheet

 version="1.0"

 xmlns:xsl="http://www.w3.org/1999/XSL/Transform">

 <xsl:import href="a.xsl"/>

 <xsl:variable name="a"/>

 <xsl:include href="b.xsl"/>

 <!-- Содержимое основного преобразования -->

</xsl:stylesheet>

Листинг 4.9. Преобразование b.xsl

<xsl:stylesheet

 version="1.0"

 xmlns:xsl="http://www.w3.org/1999/XSL/Transform">

 <xsl:import href="c.xsl"/>

 <!-- Содержимое преобразования b.xsl -->

</xsl:stylesheet>

Тогда основное преобразование может быть переписано следующим образом.

Листинг 4.10. Основное преобразование после включения b.xsl

<xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform" version="1.0"> <xsl:import href="a.xsl"/>

 <xsl: import href=f"c.xsl"/>

 <xsl:variable name="a"/>

 <!-- Содержимое преобразования b.xsl -->

 <!-- Содержимое основного преобразования -->

</xsl:stylesheet>

Элемент xsl:include можно использовать и для включения преобразований с упрощенным синтаксисом. Преобразования такого рода будут включаться как эквивалентные им преобразования стандартного синтаксиса — то есть с корневым элементом xsl:stylesheet и единственным шаблоном, соответствующим корневому узлу.

Пример

Предположим, что мы используем преобразование упрощенного синтаксиса simple.xsl.

Листинг 4.11. Преобразование simple.xsl

<html xsl:version="1.0"

 xmlns:xsl="http://www.w3.org/1999/XSL/Transform">

 <xsl:apply-templates/>

</html>

Включим simple.xsl в основное преобразование.

Листинг 4.12. Основное преобразование

<xsl:stylesheet

 version="1.0"

 xmlns:xsl="http://www.w3.org/1999/XSL/Transform">

 <xsl:include href="simple.xsl"/>

 <xsl:template match="a">

  <xsl:value-of select="."/>

 </xsl:template>

</xsl:stylesheet>

Тогда основное преобразование может быть переписано в следующем виде.

Листинг 4.13. Основное преобразование после включения simple.xsl

<xsl:stylesheet

 version="1.0"

 xmlns:xsl="http://www.w3.org/1999/XSL/Transform">

 <xsl:template match="/">

  <html>

   <xsl:apply-templates/>

  </html>

 </xsl:template>

 <xsl:template match="a">

  <xsl:value-of select="."/>

 </xsl:template>

</xsl:stylesheet>

Полужирным шрифтом на листинге 4.13 выделен шаблон, который соответствует преобразованию simple.xsl.

Следует отметить, что разные процессоры по-разному обрабатывают включение упрощенных преобразований. К сожалению, большинство из них не поддерживают эту особенность, хотя она четко определена в спецификации, поэтому, если требуется высокая надежность и переносимость, таких включений лучше избегать.

Включаемые модули являются полноценными и самостоятельными преобразованиями. К примеру, они также могут включать другие преобразования при помощи тех же элементов xsl:include. При этом преобразование не должно прямо или косвенно включать само себя — такая ситуация породит бесконечный цикл включений.

Импорт преобразований

Другим способом использования внешних модулей в XSLT является импорт преобразований, который обеспечивается элементом xsl:import. Импорт преобразований более сложен, чем их простое включение — последовательность импорта модулей может влиять на то, как будет выполняться преобразование. Равно как и в случае с xsl:include, условное импортирование преобразований не разрешено.

Элемент xsl:import

<xsl:import

 href =" URI"/>

Синтаксис импорта преобразования практически полностью аналогичен включению: обязательный атрибут href содержит URI внешнего модуля, который должен быть импортирован в текущее преобразование. Так же, как и в случае с xsl:include, элемент xsl:import логически заменяется содержимым внешнего модуля, и относительные идентификаторы ресурсов (URI), используемые во внешнем преобразовании, отсчитываются от его базового адреса. Преобразование не может прямо или косвенно импортировать само себя.

Совет

Не следует импортировать или включать в преобразование больше кода, чем необходимо. Если в одном импортируемом модуле находится много разнородных шаблонов, определений и так далее, лучше разбить этот модуль на несколько более мелких. Половина модуля загружается быстрее, чем модуль целиком. При этом целый модуль загружается быстрее, чем две его половины по отдельности.

Главным отличием импорта преобразований является то, что последовательность импортирования внешних модулей, называемая порядком импорта оказывает влияние на приоритет исполнения шаблонов, определения и многое другое.

Порядок импорта

Как уже было сказано выше, элементы xsl:import должны всегда быть первыми дочерними элементами xsl:stylesheet. Порядок, в котором они находятся в преобразовании, определяет порядок импорта внешних модулей следующим образом.

□ Порядок импорта основного преобразования всегда старше порядка импорта внешнего преобразования.

□ В случае, если преобразование импортирует несколько внешних модулей, порядок импорта преобразований, которые импортируются раньше, младше порядка импорта последующих модулей.

□ Порядок импорта преобразования, включенного в основное при помощи элемента xsl:include, равен порядку импорта основного преобразования.

Эти правила могут быть проиллюстрированы следующими примерами.

Рассмотрим преобразование alpha.xsl, которое импортирует преобразования bravo.xsl и сharlie.xsl и включает преобразование delta.xsl.

Листинг 4.14. Фрагмент преобразования alpha.xsl

<xsl:stylesheet

 version="1.0"

 xmlns:xsl="http://www.w3.org/1999/XSL/Transform">

 <xsl:import href="bravo.xsl"/>

 <xsl:import href="charlie.xsl"/>

 <xsl:import href="delta.xsl"/>

 <!-- ... -->

</xsl:stylesheet>

В соответствии с первым правилом, порядок импорта основного преобразования старше порядка импорта внешних модулей, значит alpha.xsl старше bravo.xsl и charlie.xsl. Далее, согласно второму правилу порядок импорта преобразования bravo.xsl младше порядка charlie.xsl, поскольку оно импортируется первым. Преобразование delta.xsl будет иметь порядок импорта такой же, как и у основного преобразования alpha.xsl. Таким образом, порядок импорта в этом примере будет иметь следующий вид:

bravo.xsl

charlie.xsl

alpha.xsl delta.xsl

Преобразование bravo.xsl будет самым младшим, а преобразования alpha.xsl и delta.xsl — самыми старшими.

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

Техническая рекомендация XSLT предлагает решать эту проблему построением логического дерева импорта.

Пример

Рассмотрим следующую схему включений и импорта (табл 4.1).

Таблица 4.1. Включение и импорт преобразований

Преобразование	Импортирует	Включает
alpha.xsl	bravo.xsl charlie.xsl
bravo.xsl	delta.xsl echo.xsl	foxtrot.xsl
charlie.xsl	golf.xsl hotel.xsl
hotel.xsl		india.xsl

Этой схеме будет соответствовать логическое дерево импорта на рис. 4.1.

Рис. 4.1. Обход дерева импорта преобразований

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

Таким образом, порядок импорта преобразований от младших к старшим будет выглядеть следующим образом:

delta.xsl

echo.xsl

bravo.xsl foxtrot.xsl

golf.xsl

hotel.xsl india.xsl

charlie.xsl

alpha.xsl

Порядок, в котором импортируются модули, непосредственным образом влияет на различные аспекты преобразования. Эффект, который оказывает порядок импорта на те или иные элементы, будет подробно описан при их рассмотрении — сейчас же мы их просто коротко перечислим.

□ xsl:attribute-set — порядок импорта используется для определения главенства элементов xsl:attribute, включенных в разные именованные списки атрибутов, но создающих атрибуты с одинаковыми именами.

□ xsl:namespace-alias — в случае, если в преобразовании определяются несколько псевдонимов префиксов пространств имен, процессор использует самый старший в порядке импорта псевдоним.

□ xsl:output — эти элементы объединяются процессором. В случае конфликтов, например, когда в разных элементах xsl:output атрибуты определены по-разному, процессор должен использовать старшее в порядке импорта определение.

□ xsl:strip-space и xsl:preserve-space — в этих элементах порядок импорта также используется для разрешения конфликтов: выигрывают определения со старшим порядком импорта.

□ xsl:template — порядок импорта используется для разрешения конфликтов, которые возникают в случаях, когда один узел может быть обработан несколькими шаблонами. Шаблон, содержащийся в преобразовании с младшим порядком импорта, будет просто исключен из рассмотрения.

□ xsl:variable и xsl:param — порядок импорта используется при обращении к глобальным переменным в случае, если в разных преобразованиях существуют разные определения переменной с одним именем. В подобной ситуации будет использована переменная со старшим порядком импорта.

Использование сущностей для разбивки на модули

Поскольку XSLT-преобразования являются XML-документами, мы можем воспользоваться средствами XML для модульной организации данных. Части преобразований можно просто вынести во внешние документы и включать в документ в виде сущности.

Пример

Листинг 4.15. Входящий документ:

<root>

 <a/>

 <b/>

</root>

Листинг 4.16. Основное преобразование

<!DOCTYPE xsl:stylesheet [

 <!ENTITY ab SYSTEM "ab.xsl">

]>

<xsl:stylesheet

 version="1.0"

 xmlns:xsl="http://www.w3.org/1999/XSL/Transform">

 <xsl:template match="root">

  <ROOT>

   <xsl:apply-templates/>

  </ROOT>

 </xsl:template>

 &ab;

</xsl:stylesheet>

Листинг 4.17. Файл ab.xsl

<xsl:template match="a">

 <A/>

</xsl:template>

<xsl:template match="b">

 <B/>

</xsl:template>

Листинг 4.18. Результат преобразования

<ROOT>

 <A/>

 <B/>

</ROOT>

В этом примере в DTD-блоке мы определяем сущность с именем ab, которая содержит два шаблонных правила для обработки элементов a и b. Файл ab.xsl, в котором содержится текст внешней сущности, заменяет в документе ссылку &ab;. После раскрытия процессором сущности (замены ссылки на ее содержимое) наше преобразование будет выглядеть следующим образом.

Листинг 4.19. Основное преобразование после раскрытия сущности &ab;

<xsl:stylesheet

 version="1.0"

 xmlns:xsl="http://www.w3.org/1999/XSL/Transform">

 <xsl:template match="root">

  <ROOT>

   <xsl:apply-templates/>

  </ROOT>

 </xsl:template>

 <xsl:template match="a">

  <A/>

 </xsl:template>

 <xsl:template match="b">

  <B/>

 </xsl:template>

</xsl:stylesheet>

Совместное использование преобразований и XML-документов

Ассоциация преобразования с XML-документом

Тем, кому приходилось работать со стилями в HTML-документах, пожалуй будет знакома конструкция вида <LINK REL="stylesheet">, которая закрепляет за документом определенный стиль. Включив такую конструкцию, автор явным образом указывает, как следует отображать данный документ.

Подобные задачи возникают и при работе с XSLT. Например, если для обработки XML-документа всегда будет использоваться одно и то же преобразование, логично будет закрепить это преобразование за документом.

Для того чтобы закрепить XSLT-преобразование за XML-документом, в последнем должна быть использована инструкция по обработке xml-stylesheet, которая имеет следующий вид:

<?xml-stylesheet

 href="URI"

 type="тип"

 title="название"

 media="тип носителя"

 charset="кодировка"

 alternate="yes" | "no"?>

Заметим, что xml-stylesheet может закреплять за XML-документами не только преобразования. Основным назначением инструкции xml-stylesheet является ассоциация с документом фиксированного стиля (англ. stylesheet — стиль, стилевая таблица). С этой точки зрения преобразования являются не более, чем частным случаем стилевых таблиц.

Инструкция xml-stylesheet содержит шесть псевдоатрибутов (приставка псевдо- поясняет, что на самом деле инструкции по обработке не имеют атрибутов), два из которых, href и type, являются обязательными. Использование псевдоатрибутов xml-stylesheet поясняет табл. 4.2.

Таблица 4.2. Псевдоатрибуты инструкции по обработке xml-stylesheet

Псевдоатрибут	Описание
href	Указывает местоположение стиля, закрепляемого за документом. В случае преобразований, href указывает местоположение преобразования, которое нужно применять к этому документу. В псевдоатрибуте href может быть также указан уникальный идентификатор преобразования, если оно включено в сам документ (см. раздел "Включение преобразования в документ").
type	Указывает тип стиля, закрепляемого за документом. В нашем случае, поскольку мы ассоциируем с документом XSLT-преобразование, псевдоатрибут type должен иметь значение "text/xsl"
title	Задает название закрепляемого стиля. Название не имеет особого значения при обработке — оно просто поясняет назначение стиля
media	Указывает тип носителя или устройства, для которого предназначен результирующий документ
charset	Определяет кодировку, в которой создан стиль. Если стиль является XSLT-преобразованием, значение псевдоатрибута charset в расчет не принимается, поскольку кодировка преобразований явно или неявно определена в них самих
alternate	Указывает, является ли данный стиль основным ("no") или альтернативным ("yes"). Значением этого атрибута по умолчанию является "no"

Примечание

Что касается псевдоатрибута type, то на самом деле нет стандарта, который заставлял бы использовать значение "text/xsl". Рабочая группа XSL Консорциума W3 до сих пор обсуждает, какой именно тип должен быть присвоен XSLT. Поскольку XSLT есть XML-язык, формально следовало бы использовать "application/xml", однако с легкой подачи Microsoft все используют "text/xsl".

Инструкция xml-stylesheet может быть включена только в пролог документа, то есть она должна предшествовать корневому элементу. Не рекомендуется включать эту инструкцию в блоки DOCTYPE, поскольку некоторые парсеры и процессоры будут ее в этом случае игнорировать.

Примеры

Стандартный механизм использования xml-stylesheet может быть продемонстрирован следующим документом:

<?xml version="1.0"?>

<?xml-stylesheet type="text/xsl" href="mytransform.xsl"?>

<body>

 <!-- ... -->

</body>

В этом документе инструкция xml-stylesheet указывает на то, что этот документ должен быть обработан XSLT-преобразованием mytransform.xsl.

Псевдоатрибут title может содержать краткое описание применяемого преобразования:

<?xml-stylesheet

 title="Generate menu"

 type="text/xsl"

 href="menu.xsl"?>

Псевдоатрибуты media и alternate могут использоваться совместно для того, чтобы описать альтернативное представление документа, к примеру, на небольших мобильных устройствах:

<?xml-stylesheet

 type="text/xsl"

 href="pda.xsl"

 alternate="yes"

 media="handheld"?>

Теоретически, если документ с такой инструкцией будет показываться на мобильном устройстве (например, на Palm Pilot), он должен быть преобразован при помощи pda.xsl. На практике не следует полагаться на подобные возможности, поскольку они сильно зависят от поддержки серверов и процессоров, которая в этом отношении все еще сильно ограничена.

В заключение описания инструкции xml-stylesheet приведем правила, которые определяют ее синтаксис.

[XMS1] StyleSheetPI    ::= '<?xml-stylesheet' (S PseudoAtt)* S? '?>'

[XMS2] PseudoAtt       ::= Name S? '=' S? PseudoAttValue

[XMS3] PseudoAttValue  ::= ( '"' ([^"<&]|CharRef|PredefEntityRef)* '"'

                           | "'" ([^'<&]|CharRef|PredefEntityRef)* "'")

                           - (Char* '?>' Char*)

[XMS4] PredefEntityRef ::= '"' | '<'

                           | '>' | '&' | '''

Объединение документа и преобразования

XSLT-преобразование является, как правило, самостоятельным XML-документом, корневым элементом которого является xsl:stylesheet или xsl:transform. Вместе с тем, иногда бывает необходимо объединять преобразуемый документ и само преобразование так, чтобы они находились в одном файле.

Мы опишем два способа объединения документов и преобразований. Первый основывается на использовании инструкции xml-stylesheet для того, чтобы закрепить за документом преобразование, находящееся внутри него самого. Во втором способе обрабатываемый документ включается в преобразование как пользовательский элемент верхнего уровня и обрабатывается при помощи функции document('') с пустым строковым параметром.

Включение преобразования в документ

Корневой элемент преобразования xsl:stylesheet может быть включен в преобразуемый документ со всеми дочерними элементами верхнего уровня и так далее. Для того чтобы использовать это преобразование, псевдоатрибут href инструкции по обработке xml-stylesheet должен указывать на идентификатор элемента xsl:stylesheet, определенный в его атрибуте id.

Пример

Листинг 4.20. Входящий документ

<?xml version="1.0"?>

<?xml-stylesheet type="text/xml" href="#transform"?>

<page>

 <title>Main page</title>

 <content>Main content</content>

 <xsl:stylesheet

  id="transform"

  version="1.0"

  xmlns:xsl="http://www.w3.org/1999/XSL/Transform">

  <xsl:template match="/">

   <body title="{page/title}">

    <xsl:text><xsl:value-of select="page/content"/></xsl:text>

   </body>

  </xsl:template>

  <xsl:template match="xsl:stylesheet"/>

 </xsl:stylesheet>

</page>

Листинг 4.21. Выходящий документ

<body title="Main page">

 Main content

</body>

Поскольку элемент xsl:stylesheet включен в преобразуемый документ, он также подвергнется преобразованию. Для того чтобы избежать этого, в преобразование включается шаблонное правило, которое указывает, что элементы xsl:stylesheet следует игнорировать:

<xsl:template match="xsl:stylesheet"/>

К сожалению, приходится констатировать тот факт, что описанную возможность (хотя она и включена в спецификацию языка XSLT) поддерживают очень немногие процессоры и поэтому пока что на нее не следует полагаться.

Включение документа в преобразование

Другой возможностью объединения документов и преобразований является включение элемента документа в преобразование в виде элемента верхнего уровня.

Поскольку преобразование также является XML-документом, доступ к данным, которые оно содержит можно получить при помощи функции document, так же, как если бы документ преобразования был внешним документом. Функция document, которой в качестве параметра была передана пустая строка, возвращает множество, состоящее из корневого узла самого преобразования. То есть, если документ был включен в преобразование в качестве элемента верхнего уровня с именем, к примеру, user:input, получить доступ к нему можно при помощи выражения

document('')/xsl:stylesheet/user:input

Пример

Листинг 4.22. Входящий документ

<whatever/>

Листинг 4.23. Преобразование

<xsl:stylesheet

 version="1.0"

 xmlns:user="urn:user"

 xmlns:xsl="http://www.w3.org/1999/XSL/Transform"

 exclude-result-prefixes="user">

 <input xmlns="urn:user">

  <a/>

  <b/>

 </input>

 <xsl:template match="/">

  <xsl:apply-templates

   select="document('')/xsl:stylesheet/user:input"/>

  </xsl:template>

 <xsl:template match="user:a">

  <A/>

 </xsl:template>

 <xsl:template match="user:b">

  <B/>

 </xsl:template>

 <xsl:template match="user:input">

  <output>

   <xsl:apply-templates/>

  </output>

 </xsl:template>

</xsl:stylesheet>

Листинг 4.24. Выходящий документ

<output>

 <A/>

 <B/>

</output>

Следует обратить внимание на следующие особенности этого примера.

□ Элементы верхнего уровня в обязательном порядке должны иметь ненулевое пространство имен. Поэтому мы включили элемент input и все его дочерние узлы в пространство имен urn:user. В листинге 4.23 эти элементы выделены полужирным шрифтом.

□ В шаблонах, которые обрабатывают элементы включенного документа, должны указываться паттерны, соответствующие расширенным именам этих элементов, то есть не input, a user:input.

□ Чтобы не выводить объявления пространств имен в выходящем документе, мы включили префикс user в атрибут exclude-result-prefixes элемента xsl:stylesheet.

Как можно видеть, включение элемента input как элемента верхнего уровня породило определенные проблемы. Для того чтобы избежать их, можно воспользоваться маленьким фокусом — включать документ не как элемент верхнего уровня, а в элемент верхнего уровня.

Пример

Результат следующего преобразования в точности совпадает с результатом преобразования в предыдущем примере.

Листинг 4.25. Пользовательские данные в элементе верхнего уровня

<xsl:stylesheet

 version="1.0"

 xmlns:xsl="http://www.w3.org/1999/XSL/Transform">

 <xsl:template name="input">

  <input>

   <a/>

   <b/>

  </input>

 </xsl:template>

 <xsl:template match="/">

  <xsl:apply-templates

   select="document('')/

   xsl:stylesheet/xsl:template[@name='input']/input"/>

 </xsl:template>

 <xsl:template match="a">

  <A/>

 </xsl:template>

 <xsl:template match="b">

  <B/>

 </xsl:template>

 <xsl:template match="input">

  <output>

   <xsl:apply-templates/>

  </output>

 </xsl:template>

</xsl:stylesheet>

Хитрость заключается в том, что мы обрабатываем содержимое именованного шаблона, которое вполне может принадлежать нулевому пространству имен. Единственное, что следует иметь в виду — это то, что этот шаблон не должен конфликтовать с другими шаблонами.

В отличие от предыдущего варианта с преобразованием, включенным в документ, этот способ является гораздо более работоспособным. Минусом его является только то, что на вход все равно должен подаваться какой-нибудь XML-документ, даже если его содержимое и не обрабатывается.

Литеральные элементы результата

Как мы уже видели из множества примеров, преобразования состоят не только из элементов языка XSLT. Например, в шаблоне

<xsl:template match="b">

 <В/>

</xsl:template>

элемент B не принадлежит пространству имен XSLT и, следовательно, не считается XSLT-элементом. Такие элементы называются литеральными элементами результата (англ. literal result elements).

Когда процессор выполняет шаблон, содержащий литеральные результирующие элементы, для них в результирующем документе создаются элементы с тем же расширенным именем и атрибутами, содержимым которых является результат выполнения содержимого литерального элемента в преобразовании.

Попросту говоря, литеральные элементы выводятся в результирующий документ без изменений; но их содержимое при этом все же выполняется.

Пример

В предыдущем случае шаблон содержал пустой литеральный элемент B. При выполнении этого правила процессор просто создаст в результирующем документе элемент с тем же расширенным именем и пустым содержимым — то есть это будет его точная копия.

Теперь обратимся к случаю, когда один литеральный элемент будет включать другой:

<xsl:template match="a">

 <A>

  <B/>

 </A>

</xsl:template>

При выполнении этого шаблона процессор создаст элемент A и включит в него обработанное содержимое — то есть элемент B. Результатом этого шаблона будет XML-фрагмент:

<А>

 <В/>

</А>

Теперь попробуем включить в содержимое элемента инструкцию XSLT:

<xsl:template match="a">

 <А>

  <xsl:value-of select="." />

 </A>

</xsl:template>

При выполнении этого шаблона процессор создаст результирующий элемент а и включит в него результат выполнения его содержимого, то есть элемента xsl:value-of. Этот элемент создаст текстовый узел ей строковым значением текущего узла контекста преобразования. Например, если бы мы обрабатывали этим шаблоном элемент а вида

<a href="http://www.xsltdev.ru">Visit our site!</a>

результатом выполнения был бы следующий элемент:

<A>Visit out site!</A>

При воссоздании литеральных элементов в результирующем документе, процессор копирует также все атрибуты и узлы пространств имен, которые ассоциируются с данным элементом. Например, результатом выполнения следующего шаблона:

<xsl:template match="a">

 <A HREF="http://www.xsltdev.ru"

  xmlns:xhtml="http://www.w3.org/1999/xhtml">

  <xsl:value-of select="." />

 </A>

</xsl:template>

будет элемент вида:

<A HREF="http://www.xsltdev.ru"

 xmlns:xhtml="http://www.w3.org/1999/xhtml">

 Visit out site!

</A>

Как можно заметить, процессор воссоздал не только сам элемент, но также его атрибуты и объявления пространств имен. В этом и есть смысл литеральных элементов — они копируются в выходящее дерево без изменений, хотя и здесь есть несколько исключений.

□ Процессор не будет копировать атрибуты, принадлежащие пространству имен XSLT.

□ Процессор не будет создавать узел пространства имен, соответствующий URI http://www.w3.org/1999/XSL/Transform, то есть URI пространства имен XSLT.

□ Процессор не будет создавать узлы пространств имен, префиксы которых исключаются атрибутами exclude-result-prefixes самого литерального элемента или элемента xsl:stylesheet.

Пример

Листинг 4.26

<xsl:stylesheet

 version="1.0"

 xmlns:xsl="http://www.w3.org/1999/XSL/Transform"

 xmlns:xhtml="http://www.w3.org/1999/XHTML">

 <xsl:template match="/">

  <p

   xmlns:xslt="http://www.w3.org/1999/XSL/Transform"

   xslt:exclude-result-prefixes="xhtml">

   <xslt:value-of select="2 * 2"/>

  </p>

 </xsl:template>

</xsl:stylesheet>

Обратим внимание на следующие особенности этого преобразования.

□ В нем объявлено пространство имен с префиксом xhtml.

□ Литеральный элемент p содержит объявление пространства имен с префиксом xslt и URI http://www.w3.org/1999/XSL/Transform.

□ Литеральный элемент p содержит атрибут, xslt:exclude-result-prefixes, принадлежащий пространству имен XSLT.

Как ни странно, ни одно из этих объявлений не проникнет в выходящий документ, который будет иметь вид

<p>4</p>

Попробуем объяснить такой результат. Атрибут xslt:exclude-result-prefixes не был включен в результирующий элемент p, поскольку принадлежал пространству имен XSLT (отметим еще раз, что принадлежность эта определяется не префиксом, а значением URI). Далее, объявление пространства имен

xmlns:xslt="http://www.w3.org/1999/XSL/Transform"

которое содержалось в литеральном элементе p, не вошло в результат, потому что URI этого объявления совпадало с URI пространства имен XSLT. И, наконец, объявление пространства имен xhtml было исключено атрибутом exclude-result-prefixes.

Атрибуты языка XSLT в литеральных элементах

Мы упомянули о том, что литеральные элементы могут содержать атрибуты, принадлежащие пространству имен XSLT. В табл. 4.3 они перечислены вместе с краткими описаниями назначения.

Таблица 4.3. XSLT-атрибуты литеральных элементов

Атрибут	Назначение
xsl:version	Указывает версию языка в случае использования упрощенного синтаксиса записи преобразований
xsl:exclude-result-prefixes	Перечисляет префиксы пространств имен, которые должны быть исключены в данном элементе
xsl:extension-element-prefixes	Перечисляет префиксы пространств имен, которые используются в элементах расширения
xsl:use-attribute-sets	Перечисляет названия именованных наборов атрибутов, которые следует включить в данный элемент на выходе

Шаблоны значений атрибутов

Во многих элементах XSLT в качестве значений атрибутов могут быть указаны специальные шаблоны, называемые шаблонами значений атрибутов (attribute value templates). Замечательное свойство этих шаблонов заключается в том, что вместо простых строковых значений в атрибутах можно использовать результаты вычисления выражений. Выражения в шаблонах значений атрибутов должны быть заключены в фигурные скобки ("{}"). Если процессор встретит внутри значения атрибута выражение в таких скобках, он должен будет вычислить это выражение и заменить его в атрибуте вместе с фигурными скобками на результат вычисления в строковом виде.

Пример

Довольно часто в практике программирования на XSLT встречается потребность создавать элементы с именами, которые заранее не известны, но могут быть вычислены в ходе выполнения преобразования. Представим себе документ

<mark-up type="b">This text should be marked bold.</mark-up>

в котором атрибут type элемента mark-up указывает на тип элемента разметки, который должен быть использован для данного текстового фрагмента. Для того чтобы получить элемент вида

<b>This text should be marked bold.</b>

можно использовать следующий шаблон:

<xsl:template match="mark-up">

 <xsl:element name="{@type}">

  <xsl:value-of select="."/>

 </xsl:element>

</xsl:template>

Таким образом, в качестве имени нового элемента, содержащего текст элемента mark-up, будет использовано значение атрибута type.

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

Пример

Предположим, что мы хотим вывести ссылки на графические изображения в виде иконок. Мы задаем список файлов в виде XML-документа:

<images dir="/images">

 <image filename="rose.jpg"/>

 <image filename="orchide.gif"/>

 <image filename="primul.gif"/>

</images>

Файлы хранятся в каталоге, указанном в атрибуте dir элемента images, а иконки имеют те же имена файлов, что и большие изображения, но с префиксом "th_". Для получения ссылок на изображения мы можем воспользоваться следующим преобразованием:

<xsl:template match="images/image">

 <а href="{../@dir}/{@filename}">

  <img src="{../@dir}/th_{@filename}"/>

 </a>

</xsl:template>

Результат будет получен в виде:

<а href="/images/rose.jpg"><img src="/images/th_rose.jpg"/></a>

<a href="/images/orchide.gif"><img src="/images/th_orchide.gif"/></a>

<a href="/images/primul. gif"><img src="/images/th_primul.gif"/></a>

Для того чтобы использовать в значении атрибута левые и правые фигурные скобки в качестве простых символов, нужно удваивать их количество, то есть указывать "{{" вместо каждой левой и "}}" вместо каждой правой фигурной скобки соответственно.

Пример

Элемент, определенный как

<input name="login" type="text"

 value="{{{{{{Enter your login here}}}}}}"/>

будет преобразован в выходящем документе к виду

<input name="login" type="text" value="{{{Enter your login here}}}"/>

Фигурные скобки нельзя использовать рекурсивно для вычисления внутри выражений. К примеру, в качестве значения атрибута name, определенного как

<story name="{/h{1 + 2}/p}"/>

не будет использовано вычисленное значение выражения /h3/p. Вместо этого процессор выдаст ошибку.

Фигурные скобки могут быть спокойно использованы внутри выражения в литералах — в этом случае они не будут задавать значений атрибутов.

Пример

Элемент, определенный как

<page numbers="{concat ('{', ' 1,2,3', '}') }"/>

будет преобразован к виду

<page numbers="{1,2,3}"/>

Шаблоны значений могут быть использованы далеко не везде. К примеру, не могут содержать шаблонов следующие типы атрибутов.

□ Атрибуты, значениями которых являются выражения.

□ Атрибуты, значениями которых являются паттерны.

□ Атрибуты элементов верхнего уровня.

□ Атрибуты пространств имен (xmlns).

Шаблоны значений могут содержаться в любых атрибутах литеральных элементов, что уже несколько раз было продемонстрировано выше. Например, в литеральном элементе

<img src="{../@dir}/th_{@filename}"/>

атрибут src содержит ни что иное, как два шаблона значений.

Что же касается атрибутов элементов XSLT, то как очевидно из табл. 4.4, лишь малая их часть может содержать шаблоны значений.

Таблица 4.4. Атрибуты элементов XSLT, которые могут содержать шаблоны значений

Элемент	Атрибуты	Описание
xsl:element	name	Имя создаваемого элемента
	namespace	Пространство имен создаваемого элемента
xsl:attribute	name	Имя создаваемого атрибута
	namespace	Пространство имен создаваемого атрибута
xsl:processing-instruction	name	Имя целевого приложения инструкции по обработке
xsl:number	format	Формат номера
	lang	Языковой контекст номера
	letter-value	Традиционная или алфавитная буквенная нумерация
	grouping-separator	Символ-разделитель групп цифр номера
	grouping-size	Размер группы цифр номера
xsl:sort	lang	Языковой контекст сортировки
	data-type	Тип данных сортировки
	order	Порядок сортировки
	case-order	Старшинство прописных и строчных символов при сортировке

Таким образом, перечень параметров, которые могут изменяться динамически (иными словами — вычисляться непосредственно во время выполнения шаблона) не так велик. В частности, стандартными способами в XSLT невозможно выполнить следующее.

□ Вызвать именованный шаблон динамически: атрибут name элемента xsl:call-template должен быть задан заранее и не может содержать шаблон значения.

□ Динамически изменить режим применения шаблонов (атрибут mode элемента xsl:apply-templates).

□ Вычислить элементами xsl:copy-of и xsl:value-of выражение заранее неизвестного вида.

□ Давать переменным и параметрам имена, вычисляемые во время выполнения преобразования.

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

Глава 5 Шаблонные правила

Преобразование как набор правил

В предыдущих главах мы уже упомянули о том, что преобразование в XSLT состоит не из последовательности действий, а из набора шаблонных правил, каждое из которых обрабатывает свою часть XML-документа. Эта глава целиком посвящена вопросам создания и использования шаблонных правил, однако, прежде чем мы приступим к их рассмотрению, хотелось бы пояснить, почему же все-таки правила, а не действия.

Дело в том, что структуры XML-документов (даже принадлежащих одной логической схеме) могут быть настолько разнообразны, что создание императивной программы, которая выполняла бы их преобразование, является очень сложной задачей. Возможность включения или исключения тех или иных элементов, наличие или отсутствие атрибутов, да и неопределенность самой структуры документа в конечном итоге приводят к экспоненциальному увеличению количества операторов ветвления, циклов и так далее. Программа становится большой, сложной и малопонятной.

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

Вследствие этого, язык XSLT был создан декларативным: вместо того, чтобы определять последовательность действий, программа в XSLT декларирует правила преобразования. Каждое из этих правил может в свою очередь вызывать другие правила, таким образом обеспечивая обработку документов сколь угодно сложной структуры.

Определение шаблонного правила

Элемент xsl:template

Синтаксис этого элемента приведен ниже:

<xsl:template

 match="пaттерн"

 name="имя"

 priority="число"

 mode="имя">

 <!-- Содержимое: несколько элементов xsl:param, тело шаблона -->

</xsl:template>

Элемент верхнего уровня xsl:template определяет в преобразовании шаблонное правило, или просто шаблон. Элемент xsl:template имеет всего четыре атрибута, смысл которых мы кратко опишем ниже.

Атрибут match задает паттерн — образец узлов дерева, для преобразования которых следует применять этот шаблон.

Пример

<xsl:template match="bold">

 <b><xsl:value-of select="."/></b>

</xsl:template>

В этом правиле атрибут match говорит о том, что оно должно использоваться для обработки элементов bold — в данном случае они будут заменяться на элементы b. Шаблоны, в которых определен атрибут match, вызываются при помощи инструкции xsl:apply-templates.

Шаблон также может иметь имя, определяемое атрибутом name. Шаблон, в котором задано имя, называется именованным шаблоном. Именованные шаблоны могут вызываться вне зависимости от текущего контекста, и даже вести себя как функции — принимать на вход параметры и возвращать некоторые значения.

Пример

<xsl:template name="bold">

 <b><xsl:value-of select="."/></b>

</xsl:template>

В отличие от предыдущего примера, это правило не будет обрабатывать какие-либо определенные узлы. Вызвать его можно будет только по имени посредством элемента xsl:call-template.

При определении шаблона нужно обязательно указать хотя бы один из атрибутов match или name, причем эти атрибуты могут присутствовать в xsl:template одновременно.

Атрибут mode определяет режим данного шаблонного правила. Режимы позволяют задавать различные преобразования для одних и тех же частей документа (о них мы поговорим позже).

Атрибут priority используется для определения значения, которое называется приоритетом шаблонного правила. Это значение используется для разрешения конфликтов шаблонов в случае, когда один узел может быть обработан различными правилами.

Атрибуты шаблонного правила не влияют на выполнение его содержимого. Они используются элементами xsl:apply-templates и xsl:call-template при выборе шаблонов. Правила, которые были импортированы в преобразование, вызываются элементом xsl:apply-imports.

Вызов шаблонных правил

Рассмотрим следующий простой пример.

Листинг 5.1. Входящий документ

<para><bold>text</bold></para>

Попробуем написать пару шаблонов, которые будут изменять имена элементов para и bold на p и b соответственно. Сначала напишем преобразование для bold:

<xsl:template match="bold">

<b><xsl:value-of select="."/></b>

</xsl:template>

В этом правиле создается элемент b, в который включается текстовое значение текущего узла (то есть, обрабатываемого элемента bold). Применив это преобразование к входящему документу, мы получим следующий результат:

<b>text</b>

Как говорят математики, что и требовалось. Попробуем проделать тот же трюк с элементом para и создадим преобразование, включающее оба правила.

Листинг 5.2. Преобразование с para и bold — версия 1

<xsl:stylesheet

 version="1.0"

 xmlns:xsl="http://www.w3.org/1999/XSL/Transform">

 <xsl:template match="bold">

  <b><xsl: value-of select="."/></b>

 </xsl:template>

 <xsl:template match="para">

  <p><xsl:value-of select="."/></p>

 </xsl:template>

</xsl:stylesheet>

На этот раз вместо ожидаемого результата вида <p><b>text</b></p> мы получим

<p>

 text

</p>

Попробуем ответить на три вопроса: кто виноват, что делать и куда делся элемент b.

Для ответа на вопрос, куда делся элемент b, пожалуй, необходимо будет пояснить, что же именно происходит при преобразовании этого документа. Последовательно рассмотрим стадии этого процесса.

□ Процессор начинает обработку с корневого узла дерева. Он выбирает шаблон, соответствующий этому узлу. В нашем преобразовании такого шаблона нет, значит, процессор применит к корню шаблонное правило, определенное по умолчанию (см. раздел "Встроенные шаблоны" данной главы).

□ По умолчанию шаблонное правило корневого узла обрабатывает все дочерние узлы. В нашем документе единственным дочерним узлом корня будет элемент para.

□ Для элемента para в нашем преобразовании задан шаблон, который и будет применен к этому элементу.

□ В соответствии с этим шаблоном, процессор создаст элемент p и включит в него текстовое значение выражения ".". Как мы знаем, выражение "." является сокращенной формой выражения "self::node()", которое возвратит текущий узел. Таким образом, элемент <xsl:value-of select="."/> вычислит и возвратит строковое значение текущего узла, то есть узла para. Строковым значением элемента является конкатенация всех его текстовых потомков. Единственным текстовым потомком нашего para является текстовый узел со значением "text" и вот он-то и выводится между открывающим и закрывающим тегами созданного элемента p.

Таким образом, элемент b "потерялся" потому, что шаблон для bold просто не вызывался. Виноваты, естественно, мы сами, поскольку не включили его вызов. Осталось только разобраться, как можно вызвать шаблон для обработки элемента bold.

Ответ на этот вопрос предельно прост — для вызова неименованных шаблонных правил В XSLT используется элемент xsl:apply-templates.

Элемент xsl:apply-templates

Синтаксис этого элемента выглядит следующим образом:

<xsl:apply-templates

 select="выражение"

 mode="режим">

 <!-- Содержимое: несколько элементов xsl:sort или xsl:with-param -->

</xsl:apply-templates>

Элемент xsl:apply-templates применяет шаблонные правила к узлам, которые возвращаются выражением, указанным в атрибуте select. Если атрибут select опущен, то xsl:apply-templates применяет шаблонные правила ко всем дочерним узлам текущего узла, то есть

<xsl:apply-templates/>

равносильно

<xsl:apply-templates select="child::node()"/>

Атрибут mode используется для указания режима, в котором должны применяться шаблоны — мы поговорим о различных режимах чуть позже.

Прежде чем двигаться дальше, опишем более подробно, что означает "применить шаблон" (англ. apply — применить, template — шаблон). Применение шаблонов — это составная часть обработки документа, которая может быть описана следующим порядком действий.

□ На первом шаге процессор вычисляет выражение, указанное в атрибуте select. Его значением должно быть множество узлов. Полученное множество узлов упорядочивается и становится текущим списком узлов контекста преобразования.

□ Для каждого из узлов этого списка процессор находит наиболее подходящий шаблон для обработки. Процессор делает этот узел текущим и затем выполняет в измененном контексте выбранное шаблонное правило.

□ Дерево, которое является результатом выполнения шаблона, добавляется в выходящее дерево.

Применительно к нашему примеру с para и bold, мы можем изменить преобразование так, что в создаваемый элемент p будет включаться не текстовое значение элемента para, а результат обработки его дочерних узлов.

Листинг 5.3. Преобразование с para и bold — версия 2

<xsl:stylesheet

 version="1.0"

 xmlns:xsl="http://www.w3.org/1999/XSL/Transform">

 <xsl:template match="bold">

  <b><xsl:value-of select="."/></b>

 </xsl:template>

 <xsl:template match="para">

  <p><xsl:apply-templates</p>

 </xsl:template>

</xsl:stylesheet>

Проследим за процессом выполнения этого преобразования.

□ Обработка начинается с корневого узла дерева. Для него нет заданных шаблонных правил, значит, применено будет правило по умолчанию — обработать все дочерние узлы. Множество дочерних узлов корня содержит единственный элемент para, значит, текущий список узлов контекста будет состоять из одного узла. Для него в преобразовании определен шаблон, который и будет выполнен процессором.

□ Шаблон, соответствующий элементу para, создает элемент p, содержимым которого будет результат выполнения инструкции xsl:apply-templates, то есть результат применения шаблонов к дочерним узлам текущего узла — элемента para.

□ Единственным дочерним узлом элемента para является элемент bold. Процессор изменит контекст так, что текущий список узлов будет содержать только элемент bold и выполнит соответствующее шаблонное правило, которое создаст элемент b и включит в него узел, вычисленный инструкцией <xsl:value-of select="."/>, то есть текстовый узел со строковым значением текущего узла, элемента bold.

Три шага этого преобразования продемонстрированы на рис. 5.1.

Рис. 5.1. Процесс преобразования

Здесь слева показан текущий список узлов, посередине — дерево документа с выделенным пунктиром текущим узлом, справа — генерируемое выходящее дерево.

Результатом этого преобразования будет документ:

<p><b>text</b></p>

Рассмотрим чуть более сложное преобразование документа:

<para>

 <bold>text1</bold>

 <para>

  <bold>text2</bold>

 </para>

</para>

Порядок действий в этом случае будет приблизительно следующим.

□ Первым обрабатывается корневой узел. Процессор применяет шаблоны к дочерним узлам (вернее к одному дочернему узлу — элементу para).

□ Шаблон, обрабатывающий элемент para, создает в выходящем документе элемент p и применяет шаблоны к своим дочерним узлам — на этот раз их два, bold и para.

□ Шаблон, обрабатывающий элемент bold, создает в выходящем документе элемент b и текстовый узел со значением "text1".

□ Шаблон, обрабатывающий элемент para, создает в выходящем дереве узел p и применяет шаблоны к дочерним узлам.

□ Единственным дочерним узлом элемента para является элемент bold.

□ Шаблон, обрабатывающий этот элемент bold, создает в выходящем документе элемент b и текстовый узел со значением "text2".

Процесс преобразования показан на рис. 5.2.

Рис. 5.2. Процесс преобразования

Результатом этого преобразования будет документ:

<p>

 <b>text1</b>

 <p>

  <b>text2</b>

 </p>

</p>

Атрибут select элемента xsl:apply-templates позволяет выбирать, к каким именно узлам будет применяться этот шаблон. Значение select — это XPath-выражение, которое должно возвращать множество узлов. В случае, если атрибут select указан, шаблоны будут поочередно применяться к каждому из узлов выбранного множества.

Пример

Если при обработке элементов para мы хотим обрабатывать только дочерние элементы bold и никакие другие, шаблон обработки элементов para будет записан следующим образом:

<xsl:template match="para">

 <p><xsl:apply-templates select="bold"/></p>

</xsl:template>

Результатом обработки документа

<para>

 <bold>text1</bold>

 <para>

  <bold>text2</bold>

 </para>

</para>

будет теперь

<p>

 <b>text1</b>

</p>

Элемент para, который во входящем документе включен в другой элемент para, не будет обработан по той простой причине, что он не вошел во множество, выбранное XPath-выражением "bold". В то же время, если мы запишем

<xsl:template match="para">

 <p><xsl:apply-templates select="bold|para"/></p>

</xsl:template>

то результат будет таким же, как и прежде:

<p>

 <b>text1</b>

 <p>

  <b>text2</b>

 </p>

</p>

Следует хорошо понимать разницу между атрибутом select элемента xsl:apply-templates и атрибутом match элемента xsl:template. Атрибут match содержит не XPath-выражение, а паттерн XSLT; в отличие от атрибута select в xsl:apply-templates он не выбирает никакого множества узлов, он используется только для того, чтобы проверить, может ли данный узел обрабатываться этим шаблоном или нет.

Атрибут select элемента xsl:apply-templates наоборот, содержит не паттерн, а выражение, единственным требованием к которому является то, что оно должно возвращать множество узлов. Например, некорректным будет определение вида

<xsl:apply-templates select="para+1"/>

поскольку выражение para+1 не может возвратить множество узлов.

Кроме этого требования, никаких других ограничений на выражения в этом атрибуте нет. В нем можно использовать переменные, содержащие множества узлов, функции, возвращающие множества узлов (например, такие, как id или key), выражения с операциями над множествами (именно таким выражением — выражением объединениябыло выражение bold|para), пути выборки, фильтрующие выражения, в общем, любые выражения, которые только могут возвращать множества. Например, для того, чтобы обработать содержимое произвольного внешнего XML-документа, в атрибуте select элемента xsl:apply-template следует использовать функцию document.

Пример

Объявление вида

<xsl:apply-templates select="document('a.xml')//para"/>

применит шаблоны ко всем элементам para документа a.xml.

Режимы

Очень часто в преобразованиях требуется обрабатывать одни и те же узлы, но разными способами. Типичным примером такого рода задачи является генерация оглавления документа вместе с преобразованием его содержимого. Очевидно, что просто шаблонами здесь не обойтись, и чтобы не получить другой результат, нужно каким-то образом указывать, что по-другому должна вестись и обработка.

Эта проблема решается в XSLT просто и элегантно. Атрибут mode элемента xsl:template задает режим этого шаблона. Точно такой же атрибут есть у элемента xsl:apply-templates: в этом элементе он устанавливает режим обработки. При выполнении xsl:apply-templates процессор будет применять только те шаблоны преобразования, режим которых совпадает с выбранным режимом обработки.

Пример

В качестве примера приведем преобразование, которое добавляет в XHTML-файл перечень текстовых ссылок, обнаруженных в этом документе. Грубо говоря, XHTML — это XML-версия языка HTML, а значит XSLT вполне подходит для обработки XHTML-документов.

URI пространства имен языка XHTML — "http://www.w3.org/1999/xhtml"; этому языку мы назначим префикс "xhtml" и, кроме того, сделаем это пространство пространством имен по умолчанию:

<xsl:stylesheet

 version="1.0"

 xmlns:xsl="http://www.w3.org/1999/XSL/Transform"

 xmlns:xhtml="http://www.w3.org/1999/xhtml"

 xmlns="http://www.w3.org/1999/xhtml">

 ...

</xsl:stylesheet>

Начнем с шаблона, который будет выводить каждую из ссылок. В каждой ссылке мы будем выводить только ее атрибут href и текст, который она содержит. Для удобочитаемости мы также добавим элемент br и символ переноса строки .

<xsl:template match="xhtml:a">

 <xsl:copy>

  <xsl:copy-of select="@href|text()"/>

 </xsl:copy>

 <br/>

 <xsl:text> </xsl:text>

</xsl:template>

Мы чуть позже познакомимся с элементами xsl:copy, xsl:copy-of и xsl:text, пока же скажем, что

<xsl:copy>

 <xsl:copy-of select="@href|text()"/>

</xsl:copy>

копирует в выходящий документ текущий узел, его атрибут href (@href) и дочерние текстовые узлы (text()).

Элемент <xsl:text> </xsl:text> выводит символ переноса строки. Элемент <br/> является литеральным элементом результата — он никак не обрабатывается, а просто выводится в результирующий документ.

Следующее преобразование называется идентичным преобразованием — оно просто копирует все узлы один в один:

<xsl:template match="@*|node()">

 <xsl:copy>

  <xsl:apply-templates select="@*|node()"/>

 </xsl:copy>

</xsl:template>

И, наконец, нам понадобится преобразование для элемента body — в него мы включим копию содержимого, а также ссылки, отсортированные в алфавитном порядке:

<xsl:template match="xhtml:body">

 <xsl:copy>

  <xsl:apply-templates select="@*|node()"/>

  <h1>Links found on this page:<h1>

  <xsl:apply-templates

   select=".//xhtml:a[@href and not(xhtml:*)]">

  <xsl:sort select="."/>

 </xsl:apply-templates>

 </xsl:copy>

</xsl:template>

Если мы попытаемся выполнить преобразование, состоящее из этих шаблонов, мы обнаружим, что в тексте самого документа ссылки испортились — там тоже добавились элементы br и переносы строк. Это произошло потому, что шаблон для обработки ссылок имеет больший приоритет, чем шаблон, копирующий содержимое документа.

Для исправления этой ошибки мы выделим шаблон обработки ссылок в отдельный режим links:

<xsl:template match="xhtml:a" mode="links">

 ...

</xsl:template>

Теперь это правило не будет применяться к ссылкам во время копирования содержимого документа, потому что при выполнении инструкции

<xsl:apply-templates select="@*|node()"/>

режим будет пустым, значит шаблон для xhtml:а вызываться не будет. Для того чтобы применить его при помощи xsl:apply-templates, мы добавим в этот элемент атрибут mode:

<xsl:apply-templates

 select=".//xhtml:a[@href and not(xhtml:*)]"

 mode="links">

 <xsl:sort select="."/>

</xsl:apply-templates>

Разберем более подробно это определение. Данная инструкция будет применять шаблоны с режимом links к узлам, возвращаемым выражением ".//xhtml:a[@href and not (xhtml:*)]", отсортированным в алфавитном порядке своих строковых значений. Выражение ".//xhtml:a[@href and not(xhtml:*)]" возвращает всех потомков текущего узла (путь выборки ".//"), которые принадлежат пространству имен xhtml, являются элементами с именами а, (тест имени "xhtml:a"), при этом имеют атрибут href и не включают в себя другие элементы (предикат "[@href and not (xhtml:*)]").

Преобразование целиком будет иметь следующий вид.

Листинг 5.4. Преобразование, добавляющее перечень ссылок

<xsl:stylesheet

 version="1.0"

 xmlns:xsl="http://www.w3.org/1999/XSL/Transform"

 xmlns:xhtml="http://www.w3.org/1999/xhtml"

 xmlns="http://www.w3.org/1999/xhtml">

 <xsl:template match="xhtml:body">

  <xsl:copy>

   <xsl:apply-templates select="@*|node()"/>

   <h1>Links found on this page:</h1>

   <xsl:apply-templates select=".//xhtml:a[@href and not (xhtml:*)]">

    <xsl:sort select="."/>

   </xsl:apply-templates>

  </xsl:copy>

 </xsl:template>

 <xsl:template match="@*|node()">

  <xsl:copy>

   <xsl:apply-templates select="@*|node()"/>

  </xsl:copy>

 </xsl:template>

 <xsl:template match="xhtml:a">

  <xsl:copy>

   <xsl:copy-of select="@href|text()"/>

  </xsl:copy>

  <br/>

  <xsl:text> </xsl:text>

 </xsl:template>

</xsl:stylesheet>

Применив это преобразование, например, к главной странице Консорциума W3 (http://www.w3.org), мы получим ее точный дубликат, в конце которого будет приведен перечень всех найденных текстовых ссылок. Выходящий документ будет заканчиваться фрагментом вида:

<h1>Links found on this page:</h1>

<a href="Consortium/">About W3C</a><br/>

<a href="WAI/">Accessibility</a><br/>

<a href="Consortium/Activities">Activities</a><br/>

и так далее.

Заметим, что того же эффекта можно было добиться другими способами, например, при помощи именованных шаблонов или элемента xsl:for-each, однако применение режимов, пожалуй, является наиболее гибкой техникой.

Досадным ограничением режимов является то, что режим нельзя выбирать динамически. Атрибут mode обязан иметь фиксированное значение, то есть вызов вида:

<xsl:apply-templates mode="{$mode}"/>

будет некорректным. Особо серьезных практических противопоказаний для динамических режимов нет, будем надеяться, что в следующих версиях XSLT они появятся.

Именованные шаблоны

Вместо того чтобы при помощи атрибута match указывать, какая часть входящего документа должна преобразовываться данным шаблоном, ему можно присвоить имя и вызывать в любой момент вне зависимости от контекста преобразования. Такие шаблоны очень схожи по принципу с процедурами в императивных языках программирования — они позволяют выносить часто используемые части преобразований, передавать им параметры и вызывать вне зависимости от того, что именно обрабатывается в данный момент.

Имя шаблонному правилу присваивается атрибутом name элемента xsl:template. После этого шаблону более необязательно иметь атрибут match, теперь он может быть вызван просто по имени. Два шаблона с одним порядком импорта не могут иметь одинаковых имен. Если же одинаковые имена имеют шаблоны различного порядка импорта, шаблоны старшего порядка переопределяют младшие шаблоны

Пример

При генерации HTML-страниц часто встречающейся задачей является создание элемента head. Элемент head, как правило, содержит несколько элементов meta, предоставляющих метаинформацию, элемент title, который определяет название страницы и элемент link, который связывает данную страницу с другими документами, например, с каскадными таблицами стилей (CSS).

Для того чтобы упростить процедуру генерации head, мы можем вынести ее в отдельный именованный шаблон.

Листинг 5.5. Именованный шаблон для генерации элемента head

<xsl:template name="head">

 <head>

  <meta name="keywords" content="XSLT, XPath, XML"/>

  <meta name="description"

   content="This site is dedicated to XSLT and Xpath."/>

  <title>XSLTdev.ru - XSLT developer resource</title>

  <link rel="stylesheet" type="text/css" href="style/main.css"/>

 </head>

</xsl:template>

Думается, этот шаблон не требует пояснений — он просто создает в входящем документе несколько элементов. Непонятным пока остается другое — как вызывать именованные шаблоны? Элемент xsl:apply-templates явно не подходит, поскольку именованные шаблоны не обязаны иметь атрибут match. Их выполнение производится элементом xsl:call-template.

Элемент xsl:call-template

Приведем синтаксис этого элемента:

<xsl:call-template

 name="имя">

 <!-- Содержимое: несколько элементов xsl:with-param -->

</xsl:call-template>

Обязательный атрибут name указывает имя шаблона, который вызывается этой инструкцией. Например, шаблон с именем "head", приведенный выше, может быть вызван следующим образом:

<xsl:call-template name="head"/>

Атрибут name при вызове обязан иметь фиксированное значение — точно так же, как и в случае с mode и xsl:apply-templates, динамика здесь не разрешена.

При вызове xsl:call-template не изменяет контекста преобразования. Фактически, вызов именованного шаблона эквивалентен замене в тексте преобразования элемента xsl:call-template на тело вызываемого шаблона.

Приведем пример.

Листинг 5.6. Входящий документ

<content>

 Just a few words...

</content>

Листинг 5.7. Преобразование

<xsl:stylesheet

 version="1.0"

 xmlns:xsl="http://www.w3.org/1999/XSL/Transform">

<xsl:template match="/">

 <html>

  <xsl:call-template name="head"/>

  <body><xsl:copy-of select="content/node()"/></body>

 </html>

</xsl:template>

<xsl:template name="head">

 <head>

  <meta name="keywords" content="XSLT, XPath, XML"/>

  <meta name="description"

   content="This site is dedicated to XSLT and Xpath."/>

  <title>XSLTdev.ru - XSLT developer resource</title>

  <link rel="stylesheet" type="text/css" href="style/main.css"/>

 </head>

</xsl:template>

</xsl:stylesheet>

Листинг 5.8. Выходящий документ

<html>

 <head>

  <meta name="keywords" content="XSLT, XPath, XML">

  <meta name="description"

   content="This site is dedicated to XSLT and Xpath.">

  <title>XSLTdev.ru - XSLT developer resource</title>

  <link rel="stylesheet" type="text/css" href="style/main.css">

 </head>

 <body>Just a few words...</body>

</html>

Примечание

Несколько более эффективным способом использования в документе статических частей (как содержимое элемента head в приведенном примере) является хранение этих частей во внешних документах и вставка их в выходящий документ при помощи элемента xsl:copy-of и функции document.

В этом примере шаблон, обрабатывающий корневой элемент, фактически эквивалентен шаблону вида:

<xsl:template match="/">

 <html>

  <head>

   <meta name="keywords" content="XSLT, XPath, XML"/>

   <meta name="description"

    content="This site is dedicated to XSLT and Xpath."/>

   <title>XSLTdev.ru - XSLT developer resource</title>

   <link rel="stylesheet" type="text/css" href="style/main.css"/>

  </head>

  <body><xsl:value-of select="content"/></body>

 </html>

</xsl:template>

В принципе именованные шаблоны не обязаны иметь атрибут match, но он все же может быть определен. В этом случае шаблон можно будет применять как для обработки частей документов элементом xsl:apply-templates, так и вызывая его по имени элементом xsl:call-template.

Пример

Изменим объявление нашего шаблона head следующим образом:

<xsl:template name="head" match="head">

 ...

</xsl:template>

Теперь, если входящий документ будет иметь вид

<page>

 <head/>

 <content>Just a few words...</content>

</page>

то результат выполнения следующих двух шаблонов будет одинаков.

Листинг 5.9. Шаблон для page — версия 1

<xsl:template match="page">

 <html>

  <xsl:apply-templates select="head"/>

  <body><xsl:copy-of select="content/node()/></body>

 </html>

</xsl:template>

Листинг 5.10. Шаблон для page — версия 2

<xsl:template match="page">

 <html>

  <xsl:call-template name="head"/>

  <body><xsl:copy-of select="content/node()/></body>

 </html>

</xsl:template>

В чем же состоит разница вызова шаблона элементами xsl:apply-templates и xsl:call-template? Перечислим несколько отличий.

□ Элемент xsl:apply-templates применяет подходящие шаблоны к узлам определенного множества; xsl:call-template просто выполняет тело фиксированного именованного шаблона.

□ При вызове шаблона инструкцией xsl:apply-templates происходит изменение контекста — обрабатываемое множество узлов становится текущим списком узлов преобразования, а обрабатываемый узел — текущим узлом; xsl:call-template не изменяет контекст преобразования.

□ Инструкция xsl:apply-templates позволяет использовать различные режимы — применяются только те шаблоны, значение атрибута mode которых равно значению этого атрибута у вызывающей инструкции; xsl:call-template выполняет шаблон с заданным именем вне зависимости от того, в каком режиме происходит обработка и каково значение атрибута mode этого шаблона.

□ Если для обработки определенного узла подходит несколько шаблонов, то при выполнении xsl:apply-templates процессор будет выбирать наиболее подходящий из них; xsl:call-template всегда будет выполнять тот единственный шаблон преобразования, который имеет указанное имя.

□ Если в преобразовании не определен шаблон для обработки некоторого узла, но к нему элементом xsl:apply-templates все же применяются шаблоны, процессор будет использовать шаблон обработки по умолчанию; если элемент xsl:call-template вызывает отсутствующий шаблон, процессор выдаст сообщение об ошибке, потому что не сможет найти шаблон с заданным именем.

□ При использовании xsl:apply-templates процессор игнорирует значения атрибутов name элементов xsl:template; точно так же xsl:call-template принимает во внимание только значение атрибута name, игнорируя атрибуты match, mode и priority.

При желании можно найти еще с десяток отличий, но и этих положений вполне достаточно для того, чтобы понять разницу. Главным выводом из этого сравнения является то, что xsl:apply-templates демонстрирует декларативный, а xsl:call-template процедурный стиль программирования В первом случае мы используем объявленные (или задекларированные) правила преобразования, во втором — используем шаблон просто как процедуру.

Встроенные шаблоны

Для того чтобы обеспечить рекурсивную обработку документа при преобразовании, в XSLT существуют так называемые встроенные шаблоны. Несмотря на то, что они не описываются в преобразованиях явным образом, встроенные шаблоны применяются процессорами по умолчанию в случаях, когда более подходящих шаблонов нет.

Существуют пять основных шаблонных правил, которые применяются процессорами по умолчанию.

Первое из них обеспечивает рекурсивную обработку дочерних элементов документа, которые находятся как в корне, так и в других элементах. Это правило эквивалентно следующему шаблону:

<xsl:template match="*|/">

 <xsl:apply-templates/>

</xsl:template>

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

<xsl:template match="*|/" mode="режим">

 <xsl:apply-templates mode="режим"/>

</xsl:template>

В XSLT также определяется встроенное правило для обработки текстовых узлов и атрибутов — это правило просто выводит их текстовые значения. Шаблон такого преобразования может быть записан в виде:

<xsl:template match="text()|@*">

 <xsl:value-of select="."/>

</xsl:template>

Четвертое правило касается обработки инструкций по обработке и комментариев. Это правило не делает ничего, то есть инструкции и комментарии просто опускаются в выходящем документе. Шаблон такого преобразования будет иметь вид

<xsl:template match="processing-instruction()|comment()"/>

Последнее, пятое правило определяет обработку узлов пространств имен. Аналогично инструкциям и комментариям, с ними по умолчанию не следует делать ничего, то есть узлы пространств имен просто удаляются.

Встроенные шаблоны имеют наименьший приоритет импорта, а значит, будут использоваться лишь тогда, когда в преобразовании нет другого, более подходящего правила. Иными словами, любой шаблон, определенный в преобразовании, будет иметь больший приоритет, чем у встроенных правил.

Такое положение вещей позволяет переопределять преобразования, применяемые к узлам документа по умолчанию. Например, во многих случаях бывает весьма полезным идентичное преобразование, которое копирует узлы как есть. Мы уже встречались с ним, когда создавали шаблон для генерации таблицы ссылок XHTML-документа; теперь мы чуть более подробно разберем его работу.

Идентичное преобразование

Наличие в XSLT шаблонов, выполняемых по умолчанию, иногда приводит к тому, что процессоры ведут себя не совсем логично с человеческой точки зрения. Например, в простейшем случае может понадобиться переименовать все элементы с именами bold в элементы с именами b. Однако результатом обработки документа

<а>

 text a

 <bold>

  text b

  <bold/>

 </bold>

 <c>

  text c

 </c>

</a>

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

<xsl:stylesheet

 version="1.0"

 xmlns:xsl="http://www.w3.org/1999/XSL/Transform">

 <xsl:template match="bold">

  <b><xsl:apply-templates/></b>

 </xsl:template>

</xsl:stylesheet>

будет документ вида

text a

<b>

 text b

 <b/>

</b>

text c

Как можно заметить, в выходящем документе элементы а и с "пропали", но при этом их содержимое осталось нетронутым. Все дело во встроенных шаблонах, которые по умолчанию рекурсивно обрабатывают содержимое элементов и копируют текстовые узлы, если иного не определено.

Для того чтобы избежать подобного рода казусов, можно использовать идентичное преобразование, которое в случае отсутствия шаблонов для обработки тех или иных узлов копирует их в выходящий документ как есть. Идентичное преобразование записывается в следующем виде.

Листинг 5.11. Идентичное преобразование

<xsl:stylesheet version="1.0"

 xmlns:xsl="http://www.w3.org/1999/XSL/Transform">

 <xsl:template match="@*|node()">

  <xsl:copy>

   <xsl:apply-templates select="@*|node()"/>

  </xsl:copy>

 </xsl:template>

</xsl:stylesheet>

Единственный шаблон этого преобразования при помощи элемента xsl:copy рекурсивно создает в выходящем документе копии узлов и атрибутов. На практике идентичное преобразование используется очень часто, и потому мы настоятельно рекомендуем сохранить его в отдельном файле и импортировать при потребности.

Поясним, что это преобразование выполняет не просто копирование документа (для этого было бы достаточно элемента xsl:copy-of). Идентичное преобразование переопределяет встроенные шаблоны; теперь, если для обработки какого-либо узла в преобразовании не определено подходящего шаблона, он вместе со всеми своими потомками будет скопирован в выходящий документ без изменений.

Идентичное преобразование очень полезно в тех случаях, когда требуется изменить только некоторые части документа, оставив остальное в неприкосновенности. Например, в предыдущем примере нам нужно было только переименовать все документы bold. Искомое преобразование, импортирующее идентичное преобразование из файла identity.xsl, будет записано следующим образом.

Листинг 5.12

<xsl:stylesheet

 version="1.0"

 xmlns:xsl="http://www.w3.org/1999/XSL/Transform">

 <xsl:import href="identity.xsl"/>

 <xsl:template match="bold">

  <b>

   <xsl:apply-templates/>

  </b>

 </xsl:template>

</xsl:stylesheet>

Результат будет иметь вид:

<a>

 text a

 <b>

  text b

  <b/>

 </b>

 <c>

  text c

 </c>

</a>

Другим примером использования идентичного преобразования может послужить случай, когда нужно просто удалить из документа некоторые узлы. Например, нам необходимо избавиться от комментариев (быстро и без шума).

<xsl:stylesheet

 version="1.0"

 xmlns:xsl="http://www.w3.org/1999/XSL/Transform">

 <xsl:import href="identity.xsl"/>

 <xsl:template match="comment()"/>

</xsl:stylesheet>

Разрешение конфликтов в шаблонах

Как правило, каждое преобразование в XSLT определяет, включает или импортирует множество шаблонов, которые обрабатывают указанные части документов. При этом один и тот же узел документа может соответствовать нескольким шаблонным правилам. К примеру, элемент content может быть обработан любым из следующих трех шаблонов.

Листинг 5.14. Конфликтующие шаблоны

<xsl:template match="*">

 <element/>

</xsl:template>

<xsl:template match="node()">

 <node/>

</xsl:template>

<xsl:template match="content">

 <content/>

</xsl:template>

Ситуация, когда для обработки узла может быть применено несколько правил, называется конфликтом шаблонов. Конфликты такого рода неизбежны практически в любом преобразовании, к примеру, большинство шаблонов будет вступать в конфликт со встроенными правилами преобразования.

Для того чтобы в конфликтной ситуации решить, какой именно из шаблонов должен быть применен к данному узлу, процессоры используют два простых правила.

□ Шаблоны, имеющие младший порядок импорта, исключаются из рассмотрения. Иными словами, из множества правил, подходящих для обработки текущего узла, остаются только правила, имеющие самый старший порядок импорта.

□ Из оставшегося множества выбирается шаблон с наивысшим приоритетом. Если таких шаблонов несколько, процессор может либо выдать ошибку, либо применить тот, который описан в преобразовании последним.

Во втором из этих двух правил, мы встретились с понятием приоритета шаблона. Приоритет шаблона это не что иное, как численное значение, которое может быть указано в атрибуте priority элемента xsl:template. В том случае, если значение этого атрибута не определено, приоритет шаблонного правила вычисляется следующим образом.

□ Прежде всего, шаблон, который обрабатывает несколько альтернатив, перечисленных через знак "|", будет рассматриваться как множество шаблонов, обрабатывающих каждую из возможностей. Например, шаблон с атрибутом match="b|bold|B" будет рассматриваться как три одинаковых шаблона с атрибутами match="b", match="bold" и match="B" соответственно.

□ Если паттерн состоит из имени (QName) или конструкции processing-instruction(литерал), которым предшествует дескриптор оси дочернего узла или атрибута (ChildOrAttributeAxisSpecifier), приоритет шаблона равен 0. Такие паттерны могут иметь следующий вид:

 • QName или child::QName — выбор дочерних элементов;

 • @QName или attribute::QName — выбор атрибутов;

 • processing-instruction(литерал) или child::processing-instruction(литерал) — именной выбор дочерних инструкций по обработке.

Примеры паттернов с приоритетом, равным 0:

 • content — выбор дочернего элемента content;

 • fo:content — выбор дочернего элемента content с префиксом пространств имен fo;

 • child::processing-instruction('арр') — выбор дочерних инструкций по обработке, которые имеют вид <?app содержимое?>;

 • @xsd:name — выбор атрибута xsd:name текущего узла;

 • @select — выбор атрибута select текущего узла.

□ Если паттерн состоит из конструкции NCName:*, которой предшествует ChildOrAxisSpecifier, приоритет шаблона будет равен -0.25. Такие паттерны могут иметь следующий вид:

 • префикс:* или child::префикс:* — выбор всех дочерних элементов в определенном пространстве имен;

 • @префикс:* или attribute::префикс:* — выбор всех атрибутов в определенном пространстве имен.

Примеры паттернов с приоритетом, равным -0.25:

 • fo:* — выбор всех дочерних элементов в пространстве имен с префиксом fo;

 • attribute::xsl:* — выбор всех атрибутов текущего элемента, которые находятся в пространстве имен с префиксом xsl.

□ Если паттерн состоит из проверки узла (NodeTest), которой предшествует ChildOrAttributeAxisSpecifier, приоритет шаблона будет равен -0.5. Паттерны такого рода будут выглядеть как:

 • NodeTest или child::NodeTest — выбор всех дочерних узлов, соответствующих данной проверке;

 • QNodeTest или attribute::NodeTest — выбор всех атрибутов, соответствующих данной проверке.

□ Примеры паттернов с приоритетом, равным -0.5:

 • text() — выбор дочерних текстовых узлов;

 • child::comment() — выбор дочерних комментариев;

 • @* — выбор всех атрибутов данного шаблона.

□ Если ни одно из предыдущих условий не выполняется, приоритет шаблона равен 0.5.

Для удобства использования составим таблицу (табл. 5.1) с приоритетами тех или иных паттернов.

Таблица 5.1. Приоритет паттернов

Вид паттерна	Приоритет
QName	0
child::QName
@QName
attribute::QName
processing-instruction(литерал)
child::processing-instruction(литерал)
префикс:*	-0.25
child::префикс:*
@префикс:*
attribute::префикс:*
NodeTest	-0.5
child::NodeTest
@NodeTest
attribute::NodeTest
Другие паттерны	0.5

Несмотря на то, что вычислением приоритета преобразований занимается процессор, полезно понимать механизм этого вычисления для того, чтобы уметь предсказывать, как будет решен конфликт тех или иных шаблонов. Довольно часто в преобразованиях допускаются ошибки, связанные с приоритетом применения шаблонов.

Пример

Вычислим в качестве упражнения приоритеты шаблонов для следующего примера.

Листинг 5.15. Преобразование

<xsl:stylesheet

 version="1.0"

 xmlns:xsl="http://www.w3.org/1999/XSL/Transform"

 xmlns:a="a">

 <xsl:strip-space elements="*"/>

 <!-- Первый шаблон -->

 <xsl:template match="a:b">

  <xsl:message>

   <xsl:text>1</xsl:text>

   <xsl:call-template name="print-name"/>

  </xsl:message>

  <xsl:apply-templates/>

 </xsl:template>

 <!-- Второй шаблон -->

 <xsl:template match="a:a/a:b">

  <xsl:message>

   <xsl:text>2</xsl:text>

   <xsl:call-template name="print-name"/>

  </xsl:message>

  <xsl:apply-templates/>

 </xsl:template>

 <!-- Третий шаблон -->

 <xsl:template match="a:*">

  <xsl:message>

   <xsl:text>3</xsl:text>

   <xsl:call-template name="print-name"/>

  </xsl:message>

  <xsl:apply-templates/>

 </xsl:template>

 <!-- Четвертый шаблон -->

 <xsl:template match="node()">

  <xsl:message>

   <xsl:text>4</xsl:text>

   <xsl:call-template name="print-name"/>

  </xsl:message>

  <xsl:apply-templates/>

 </xsl:template>

 <!-- Пятый шаблон -->

 <xsl:template match="b">

  <xsl:message>

   <xsl:text>5</xsl:text>

   <xsl:call-template name="print-name"/>

  </xsl:message>

  <xsl:apply-templates/>

 </xsl:template>

 <xsl:template name="print-name">

  <xsl:text> template matched </xsl:text>

  <xsl:value-of select="name()"/>

  <xsl:text>.</xsl:text>

 </xsl:template>

</xsl:stylesheet>

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

Приоритет первого шаблона, паттерн которого соответствует продукции QName, будет равен 0. Приоритет второго шаблона будет равен 0.5, поскольку его паттерн не удовлетворяет другим условиям. Паттерн третьего шаблона имеет вид NCName:*, а значит, его приоритет равен -0.25. Приоритет четвертого шаблона равен -0.5, поскольку его паттерн является проверкой узла (NodeTest). Приоритет последнего, пятого шаблона будет равен 0, поскольку паттерн b соответствует продукции QName.

Попробуем применить это преобразование к следующему документу:

<?ORA bypass="yes"?>

<b>

 <a xmlns="a">

  <b>

   <b>

    <c/>

   </b>

  </b>

 </a>

</b>

Проследим за тем, как будет выполняться преобразование.

□ Инструкции по обработке <?ORA bypass="yes"?>, которая идет в документе первой, соответствует только один, четвертый шаблон.

□ Корневому элементу b соответствуют два шаблона — четвертый и пятый, однако приоритет пятого шаблона выше, и поэтому применен будет именно он.

□ Следующему элементу, a, соответствуют третий и четвертый шаблоны. Здесь процессор должен применить третий шаблон, так как его приоритет выше, чем приоритет четвертого шаблона.

□ Элемент b, включенный в элемент а, соответствует первому, второму, третьему и четвертому шаблонам. Наивысший приоритет из них имеет второй шаблон.

□ Следующему элементу b соответствуют первый, третий и четвертый шаблоны. В этом случае процессор выберет первый шаблон.

□ Элемент с соответствует третьему и четвертому шаблонному правилу. В этом случае процессор должен будет использовать третий шаблон.

Сравнивая этот анализ с сообщениями процессора, можно убедиться в верности прогноза:

4 template matched ORA.

5 template matched b.

3 template matched a.

2 template matched b.

1 template matched b.

3 template matched c.

Напомним, что приоритет преобразований может быть также явно указан в атрибуте priority элемента xsl:template. Например, если бы в предыдущем преобразовании четвертый шаблон был определен в виде

<xsl:template match="node()" priority="1">

 <xsl:message>

  <xsl:text>4</xsl:text>

  <xsl:call-template name="print-name"/>

 </xsl:message>

 <xsl:apply-templates/>

</xsl:template>

то его приоритет был бы выше, чем у всех остальных шаблонов, а поскольку он соответствует всем узлам в обрабатываемом документе, то во всех случаях применялся бы только он один. Сообщения процессора имели бы вид

4 template matched ORA.

4 template matched b.

4 template matched a.

4 template matched b.

4 template matched b.

4 template matched c.

Между тем, явное указание приоритета шаблона не может изменить порядок его импорта. То есть, если бы в предыдущем примере четвертый шаблон был бы вынесен во внешний модуль и импортирован в основное преобразование, в любом случае он бы применялся только в отсутствие более подходящих правил.

Пример

Листинг 5.16. Основное преобразование

<xsl:stylesheet

 xmlns:xsl="http://www.w3.org/1999/XSL/Transform"

 version="1.0"

 xmlns:a="a">

 <xsl:import href="b.xsl"/>

 <xsl:strip-space elements="*"/>

 <xsl:template match="a:b">

  <xsl:message>

   <xsl:text>1</xsl:text>

   <xsl:call-template name="print-name"/>

  </xsl:message>

  <xsl:apply-templates/>

 </xsl:template>

 <xsl:template match="a:a/a:b">

  <xsl:message>

   <xsl:text>2</xsl:text>

   <xsl:call-template name="print-name"/>

  </xsl:message>

  <xsl:apply-templates/>

 </xsl:template>

 <xsl:template match="a:*">

  <xsl:message>

   <xsl:text>3</xsl:text>

   <xsl:call-template name="print-name"/>

  </xsl :message>

  <xsl:apply-templates/>

 </xsl:template>

 <xsl:template match="b">

  <xsl:message>

   <xsl:text>5</xsl:text>

   <xsl:call-template name="print-name"/>

  </xsl:message>

  <xsl:apply-templates/>

 </xsl:template>

</xsl:stylesheet>

Листинг 5.17. Преобразование b.xsl

<xsl:stylesheet

 xmlns:xsl="http://www.w3.org/1999/XSL/Transform"

 version="1.0"

 xmlns:a="a">

 <xsl:strip-space elements="*"/>

 <xsl:template match="node()" priority="1">

  <xsl:message>

   <xsl:text>4</xsl:text>

   <xsl:call-template name="print-name"/>

  </xsl:message>

  <xsl:apply-templates/>

 </xsl:template>

 <xsl:template name="print-name">

  <xsl:text> template matched </xsl:text>

  <xsl:value-of select="name()"/>

  <xsl:text>.</xsl:text>

 </xsl:template>

</xsl:stylesheet>

Как уже было сказано ранее, четвертое преобразование, вынесенное теперь в импортируемый модуль, при разрешении конфликтов шаблонов будет самым младшим вследствие того, что порядок его импорта меньше, чем у других преобразований. Сообщения процессора будут иметь вид

4 template matched ORA.

5 template matched b.

3 template matched a.

2 template matched b.

1 template matched b.

3 template matched c.

Кстати сказать, XSLT предоставляет возможность выполнять в преобразованиях импортированные шаблоны вместо тех, которые, по мнению процессора, лучше подходят. Подобно тому, как для применения шаблонных правил мы использовали элемент xsl:apply-templates, импортированные шаблоны могут быть вызваны элементом xsl:apply-imports.

Элемент xsl:apply-imports

Синтаксис этого элемента:

<xsl:apply-imports/>

Элемент xsl:apply-imports можно использовать в шаблонах для применения правил, которые были импортированы во внешних модулях, но затем переопределены шаблонами основного преобразования.

Пример

Предположим, что в преобразованиях часто используется шаблон, который заменяет элементы home ссылками на сайт http://www.xsltdev.ru:

<xsl:template match="home">

 <а href="http://www.xsltdev.ru">www.xsltdev.ru</a>

</xsl:template>

При необходимости этот шаблон может быть переопределен. К примеру, ссылка может выглядеть как

Visit <а href="http://www.xsltdev.ru">www.xsltdev.ru</a>

Соответственно, шаблон будет иметь вид

<xsl:template match="home">

 <xsl:text>Visit </xsl:text>

 <a href="http://www.xsltdev.ru">www.xsltdev.ru</a>

</xsl:template>

Можно заметить, что оба шаблона имеют общую часть, которая выводит гипертекстовую ссылку. Эта часть может быть вынесена во внешнее преобразование home.xsl.

Листинг 5.18. Преобразование home.xml

<xsl:stylesheet version="1.0"

 xmlns:xsl="http://www.w3.org/1999/XSL/Transform">

 <xsl:template match="home">

  <a href="http://www.xsltdev.ru">www.xsltdev.ru</a>

 </xsl:template>

</xsl:stylesheet>

Для того чтобы использовать внешний шаблон, основное преобразование должно импортировать его при помощи xsl:import и применять посредством xsl:apply-imports.

Листинг 5.19. Основное преобразование base.xsl

<xsl:stylesheet

 xmlns:xsl="http://www.w3.org/1999/XSL/Transform"

 version="1.0">

 <xsl:import href="home.xsl"/>

 <xsl:template match="home">

  <xsl:text>Visit </xsl:text>

  <xsl:apply-imports/>

 </xsl:template>

</xsl:stylesheet>

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

Элемент xsl:apply-imports применяет шаблоны точно так же, как и элемент xsl:apply-templates, но при этом он имеет две особенности.

□ Шаблоны, определенные в основном преобразовании, применяться не будут, поскольку xsl:apply-imports применяет только импортированные правила.

□ Элемент xsl:apply-imports применяет только те правила, режим (mode) которых совпадает с режимом текущего шаблона.

В текущей версии XSLT xsl:apply-imports не может вызывать импортированные именованные шаблоны.

Для того чтобы лучше понять, зачем нужна такая сложная схема импорта, проведем аналогию с объектно-ориентированным программированием. Если рассматривать правила преобразований как методы классов, то импорт преобразований будет ни чем иным, как наследованием — все методы (шаблоны) класса-потомка (импортируемого преобразования) будут доступны в классе-наследнике (импортирующем преобразовании). При этом класс-наследник может переопределить методы класса потомка (шаблоны основного преобразования имеют порядок импорта старше, чем шаблоны импортированного преобразования). В этой схеме использование элемента xsl:apply-imports будет равносильно вызову метода родительского класса вместо переопределенного метода класса потомка.

Приведем пример Java-классов, которые будут аналогичны преобразованиям home.xsl и base.xsl.

Листинг 5.20. Класс home

public class home {

 public String home() {

  return "<a href=\"http://www.xsltdev.ru\">www.xsltdev.ru</a>";

 }

}

Листинг 5.21. Класс base

public class base extends home {

 public String home() {

  return ("Visit " + super.home());

 }

}

В этом примере вызов родительского метода super.home() соответствует применению элементом xsl:apply-imports импортированного шаблона.

Тело шаблона

Фактически, элемент xsl:template, определяющий шаблонное правило, задает не более чем условия, при которых это правило должно выполняться. Конкретные же действия и инструкции, которые должны быть исполнены, определяются содержимым элемента xsl:template и составляют тело шаблона.

Пример

Тело следующего шаблона (выделенное полужирным шрифтом):

<xsl:template match="page">

 <body>

  <xsl:value-of select="."/>

 </body>

 Комментарии

 <xsl:copy-of select="comment()"/>

</xsl:template>

состоит из литерального элемента body, текстового узла и элемента xsl:copy-of. При выполнении этого шаблона элемент body будет выведен как есть (при этом содержимое его будет вычислено); текстовый узел будет скопирован в выходящее дерево; элемент xsl:copy-of будет заменен множеством дочерних комментариев текущего узла.

Следует заметить, что текстовый узел в данном случае состоит не только из строки "Комментарии". Он включает также все пробельные символы и символы переноса строки.

Тело шаблона может быть также и пустым. В этом случае результат обработки узлов, соответствующих этому шаблону будет пустым. Например, если в преобразовании содержится шаблон вида

<xsl:template match="comment()"/>

то каждый раз, встретив узел комментария и обрабатывая его этим правилом, процессор будет получать пустой результат. Таким образом, используя пустые шаблоны совместно с идентичным преобразованием можно добиться эффекта удаления определенных узлов из шаблона, как это было показано ранее в этой главе.

Тело шаблона может содержать любые текстовые узлы, комментарии, инструкции по обработке и литеральные элементы результата при условии, что не будет нарушен синтаксис XML-документа. Тело шаблона может также содержать следующие элементы XSLT, называемые также инструкциями (не путать с инструкциями по обработке):

□ xsl:apply-imports;

□ xsl:apply-templates;

□ xsl:attribute;

□ xsl:call-template;

□ xsl:choose;

□ xsl:comment;

□ xsl:copy;

□ xsl:copy-of;

□ xsl:element;

□ xsl:fallback;

□ xsl:for-each;

□ xsl:if;

□ xsl:message;

□ xsl:number;

□ xsl:param;

□ xsl:processing-instruction;

□ xsl:text;

□ xsl:value-of;

□ xsl:variable.

Элементы xsl:param и xsl:variable, которые входят в этот список в преобразовании, могут быть как элементами верхнего уровня, так иинструкциями. В первом случае они определяют глобальные параметры и переменные, во втором — локальные.

Если элементы xsl:param используются для определения локальных переменных, они должны быть первыми дочерними элементами xsl:template, то есть, строго говоря, определение

<xsl:template name="page">

 <xsl:text>Text</xsl:text>

 <xsl:param name="foo"/>

</xsl:template>

будет некорректным. На самом деле многие процессоры игнорируют эту ошибку, вполне разумно считая, что ничего смертельного в ней нет. Но, конечно, лучше использовать стандартный вариант:

<xsl:template name="page">

 <xsl:param name="foo"/>

 <xsl:text>Text</xsl:text>

</xsl:template>

Переменные и параметры

Было бы слишком просто и слишком бесполезно лишь констатировать, что переменные и параметры в XSLT похожи между собой и сильно отличаются от переменных в других языках программирования. Мы попытаемся разобраться в этом вопросе несколько глубже — чем именно и ради чего конкретно переменные в XSLT обладают такими свойствами.

В классической книге Монти Бен-Ари "Языки программирования" [Бен-Ари 2000] приводится следующее определение переменной:

Переменная — это имя, присвоенное ячейке памяти или ячейкам, которые могут содержать представление конкретного типа (данных).

Затем следует комментарий:

Значение может изменяться во время выполнения программы.

Если немного сменить уровень абстракции, первая часть этого определения верна и по отношению к параметрам, и переменным XSLT (далее мы будем говорить просто "переменные", поскольку различия между ними на данный момент несущественны). Конечно, где-то там внутри реализации конкретного XSLT-процессора есть память, поделенная на ячейки, в которой процессор хранит информацию. Такие детали нас, естественно, не интересуют, ибо мы больше рассуждаем о логических, чем о физических моделях. В логической же модели переменная представляется как объект определенного типа, с которым связано имя, — по этому имени мы можем обращаться к объекту, использовать его значение и так далее. Иными словами, в XSLT под переменной понимается не более чем ассоциация между значением и именем, и если мы вдруг скажем, что переменная x имеет значение 5, это будет означать, что имя "x" связано объектом численного типа, значение которого равно 5. Заметим небольшую разницу с определением Бен-Ари: мы не говорим о том, что число 5 лежит в какой-то ячейке памяти (хотя, несомненно, оно так и есть) и что этой ячейке присвоено имя "x" — мы говорим об ассоциации между объектом и именем и только.

Теперь, когда более или менее ясно, что же мы имеем в виду под переменными, на новой строчке полужирным шрифтом напишем следующее:

Переменные в XSLT не могут быть изменены.

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

Практически во всех процедурных языках оператор присваивания вида

переменная = выражение

с незначительными вариациями работает приблизительно следующим образом:

□ сначала вычисляется присваиваемое выражение;

□ затем вычисляется адрес переменной;

□ затем значение, полученное на первом шаге, копируется в ячейки памяти, начиная с адреса, полученного на втором шаге присваивания.

В XSLT нет оператора присваивания. Переменным и параметрам никогда не присваиваются значения в приведенном выше смысле, объявление переменной или параметра лишь связывает указанное имя со значением некоторого выражения. Иными словами, объявление переменной есть создание ассоциации между объектом и именем.

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

Элемент xsl:variable

Синтаксис этого элемента в XSLT определен так:

<xsl:variable

 name="имя"

 select="выражение">

 <!-- Содержимое: шаблон -->

</xsl:variable>

Для объявления переменных в XSLT служит элемент xsl:variable, который может как присутствовать в теле шаблона, так и быть элементом верхнего уровня. Элемент xsl:variable связывает имя, указанное в обязательном атрибуте name, со значением выражения, указанного в атрибуте select или с деревом, которое является результатом выполнения шаблона, содержащегося в этом элементе. В том случае, если объявление переменной было произведено элементом верхнего уровня, переменная называется глобальной переменной. Переменные, определенные элементами xsl:variable в шаблонах (то есть не на верхнем уровне) называются локальными переменными.

Таким образом, объявление переменной в XSLT происходит всего в два шага:

□ сначала вычисляется значение присваиваемого выражения;

□ затем полученное значение связывается с указанным именем.

Значение присваиваемого выражения вычисляется в зависимости от того, как был определен элемент xsl:variable:

□ если в элементе xsl:variable определен атрибут select, то значением присваиваемого выражения будет результат вычисления выражения, указанного в этом атрибуте;

□ если атрибут select не определен, но сам элемент xsl:variable имеет дочерние узлы (иными словами, содержит шаблон), значением определяемой переменной будет результирующий фрагмент дерева, полученный в результате выполнения содержимого xsl:variable;

□ если атрибут select не определен и при этом сам элемент xsl:variable пуст, значением параметра по умолчанию будет пустая строка.

Использовать значения, присвоенные переменным при инициализации, можно, указывая впереди имени переменной символ "$", например для переменной x — $x. В XPath-выражениях синтаксис обращения к переменным соответствует продукции VariableReference.

Имя переменной соответствует синтаксическому правилу QName, иными словами, оно может иметь вид имя или префикс:имя. Как правило, имена переменным даются без префиксов, однако в том случае, если префикс все же указан, переменная ассоциирует с некоторым объектом не простое, а расширенное имя. Соответственно, обращение к объекту должно будет производиться также посредством расширенного имени.

Область видимости переменных

Каждая из переменных имеет собственную область видимости (англ. scope) — область, в которой может быть использовано ее значение. Область видимости определяется следующим образом.

□ Областью видимости глобальной переменной является все преобразование, то есть значение переменной, объявленной элементом верхнего уровня, может быть использовано в преобразовании где угодно. К такой переменной можно обращаться даже до ее объявления, единственным ограничением является то, что переменная не должна определяться через собственное значение — явно или неявно.

□ Локальную переменную можно использовать только после ее объявления и только в том же родительском элементе, которому принадлежит объявляющий элемент xsl:variable. В терминах XPath область видимости локальной переменной будет определяться выражением

following-sibling:node()/descendant-or-self:node().

Для того чтобы до конца прояснить ситуацию, приведем несколько примеров.

Предположим, что мы определяем переменную с именем ID и значением 4 следующим образом:

<xsl:stylesheet

 version="1.0"

 xmlns:xsl="http://www.w3.org/1999/XSL/Transform">

 ...

 <xsl:variable name="ID" select="4"/>

 ...

</xsl:stylesheet>

Несложно видеть, что здесь мы определили глобальную переменную, а значит, ее значение можно использовать в преобразовании в любом месте. Например, мы можем определить через нее другие глобальные переменные, либо использовать в шаблоне:

<xsl:stylesheet

 version="1.0"

 xmlns:xsl="http://www.w3.org/1999/XSL/Transform">

 ...

 <xsl:variable name="leaf" select="//item[@id=$ID]"/>

 <xsl:variable name="ID" select="4"/>

 <xsl:variable name="path" select="$leaf/ancestor-or-self::item"/>

 ...

</xsl:stylesheet>

Причем, как уже было сказано, глобальная переменная может быть использована и до объявления: в нашем случае переменная leaf определяется через переменную ID, a path — через leaf. Конечно же, не следует забывать и то правило, что переменные не могут объявляться посредством самих себя, явно или неявно. Очевидно, что объявление:

<xsl:variable name="ID" select="$ID - 1"/>

было бы некорректным ввиду явного использования переменной при собственном определении. Точно так же были бы некорректны определения:

<xsl:variable name="ID" select="$id — 1/>

<xsl:variable name="id" select="$ID + 1"/>

поскольку переменная ID определяется через переменную id, которая определяется через переменную ID и так до бесконечности.

Дела с локальными переменными обстоят чуть-чуть сложнее. Для того чтобы объяснить, что же такое область видимости, обратимся к следующему преобразованию.

Листинг 5.22. Преобразование, использующее переменные i, j, k и gt

<xsl:stylesheet

 version="1.0"

 xmlns:xsl="... ">

 <xsl:template match="/">

  <xsl:variable

   name="i"

   select="2"/>

  <xsl:variable

   name="j"

   select="$i - 1"/>

  <xsl:if test="$i > $j">

   <xsl:variable name="k">

    <xsl:value-of select="$i"/>

    <xsl:value-of select="$gt"/>

    <xsl:value-of select="$j"/>

   </xsl:variable>

   <result>

    <xsl:copy-of select="$k"/>

   </result>

  </xsl:if>

 </xsl:template>

 <xsl:variable name="gt">

  is greater than

 </xsl:variable>

</xsl:stylesheet>

В этом преобразовании определены три локальные переменные — i, j и k и одна глобальная переменная — gt. На следующих четырех листингах мы выделим серой заливкой область видимости переменной (то есть область, где ее можно использовать), а само определение переменной отметим полужирным шрифтом.

Листинг 5.23. Области видимости переменных i, j, k и gt

Область видимости переменной i               Область видимости переменной j

<xsl:stylesheet                  <xsl:stylesheet

 version="1.0" xmlns:xsl="... ">  version="1.0" xmlns:xsl="... ">

 <xsl:template match="/">         <xsl:template match="/">

  <xsl:variable name="i"           <xsl:variable name="i"

   select="2"/>                     select="2"/>

  <xsl:variable name="j"           <xsl:variable name="j"

   select="$i - 1"/>                select="$i - 1"/>

  <xsl:if test="$i > $j">          <xsl:if test="$i > $j">

   <xsl:variable name="k">          <xsl:variable name="k">

    <xsl:value-of select="$i"/>      <xsl:value-of select="$i"/>

    <xsl:value-of select="$gt"/>     <xsl:value-of select="$gt"/>

    <xsl:value-of select="$j"/>      <xsl:value-of select="$j"/>

   </xsl:variable>                  </xsl:variable>

   <result>                         <result>

    <xsl:copy-of select="$k"/>       <xsl:copy-of select="$k"/>

   </result>                        </result>

  </xsl:if>                        </xsl:if>

 </xsl:template>                  </xsl:template>

 <xsl:variable name="gt">         <xsl:variable name="gt">

  is greater than                  is greater than

 </xsl:variable>                  </xsl:variable>

</xsl:stylesheet>                </xsl:stylesheet>

Область видимости переменной k               Область видимости переменной gt

<xsl:stylesheet                  <xsl:stylesheet

 version="1.0" xmlns:xsl="... ">  version="1.0" xmlns:xsl="... ">

 <xsl:template match="/">         <xsl:template match="/">

  <xsl:variable name="i"           <xsl:variable name="i"

   select="2"/>                     select="2"/>

  <xsl:variable name="j"           <xsl:variable name="j"

   select="$i - 1"/>                select="$i - 1"/>

  <xsl:if test="$i > $j">          <xsl:if test="$i > $j">

   <xsl:variable name="k">          <xsl:variable name="k">

    <xsl:value-of select="$i"/>      <xsl:value-of select="$i"/>

    <xsl:value-of select="$gt"/>     <xsl:value-of select="$gt"/>

    <xsl:value-of select="$j"/>      <xsl:value-of select="$j"/>

   </xsl:variable>                  </xsl:variable>

   <result>                         <result>

    <xsl:copy-of select="$k"/>       <xsl:copy-of select="$k"/>

   </result>                        </result>

  </xsl:if>                        </xsl:if>

 </xsl:template>                  </xsl:template>

 <xsl:variable name="gt">         <xsl:variable name="gt">

  is greater than                  is greater than

 </xsl:variable>                  </xsl:variable>

</xsl:stylesheet>                </xsl:stylesheet>

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

□ Имена двух глобальных переменных могут совпадать в том и только том случае, когда они имеют разный порядок импорта. Например, если переменные с одинаковыми именами определены в разных преобразованиях, одно из них может быть импортировано. В этом случае переменная будет иметь значение, которое задано элементом xsl:variable со старшим порядком импорта.

□ Допускается совпадение имен локальной и глобальной переменных — в этом случае в области видимости локальной переменной будет использоваться локальное значение, в области видимости глобальной (но не локальной) — глобальное значение. Иными словами, локальные переменные "закрывают" значения глобальных.

□ Две локальные переменные могут иметь совпадающие имена в том и только том случае, если их области видимости не пересекаются.

Первое правило мы уже упоминали, когда разбирали порядок импорта: тогда мы сказали, что переменные со старшим порядком импорта переопределяют переменные с младшим порядком импорта. Это довольно важное обстоятельство, поскольку оно добавляет некоторые интересные возможности, но при этом также может породить скрытые ошибки.

Пример

Предположим, что в следующем преобразовании в шаблоне с именем choice мы генерируем два элемента input.

Листинг 5.24. Преобразование en.xsl

<xsl:stylesheet

 version="1.0"

 xmlns:xsl="http://www.w3.org/1999/XSL/Transform">

 <xsl:variable name="submit" select="'Submit'"/>

 <xsl:variable name="reset" select="'Reset'"/>

 <xsl:template name="choice">

  <input type="button" value="{$submit}"/>

  <xsl:text> </xsl: text>

  <input type="reset" value="{$reset}"/>

 </xsl:template>

 <xsl:template match="/">

  <xsl:call-template name="choice"/>

 </xsl:template>

</xsl:stylesheet>

Результатом этого преобразования будет следующий фрагмент:

<input type="button" value="Submit"/>

<input type="reset" value="Reset"/>

Для того чтобы перевести надписи на этих кнопках на другой язык достаточно просто переопределить переменные. Например, результатом выполнения следующего шаблона.

Листинг 5.25. Преобразование de.xsl

<xsl:stylesheet

 version="1.0"

 xmlns:xsl="http://www.w3.org/1999/XSL/Transform">

 <xsl:import href="en.xsl"/>

 <xsl:variable name="submit" select="'Senden'"/>

 <xsl:variable name="reset" select="'Loeschen'"/>

</xsl:stylesheet>

будет тот же фрагмент, но уже на немецком языке:

<input type="button" value="Senden"/>

<input type="reset" value="Loeschen"/>

С другой стороны, переопределение переменных может быть и опасным: в случае, если отдельные модули разрабатывались независимо, совпадение имен глобальных переменных может привести к ошибкам. Для того чтобы такое было в принципе исключено, имя переменной следует объявлять в определенном пространстве имен, например:

<xsl:variable name="app:href" select="..."/>

<xsl:variable name="db:href" select="..."/>

В том случае, если префиксы app и db (которые, конечно же, должны быть объявлены) будут указывать на разные пространства имен, никакого конфликта между этими двумя переменными не будет.

Возвращаясь к теме совпадений имен переменных, продемонстрируем "скрытие" локальной переменной значения глобальной:

<xsl:stylesheet

 version="1.0"

 xmlns:xsl="http://www.w3.org/1999/XSL/Transform">

 <xsl:variable name="i" select="1"/>

 <xsl:template match="/">

  <xsl:text>i equals </xsl:text>

  <xsl:value-of select="$i"/>

  <xsl:text> </xsl:text>

  <xsl:variable name="i" select="$i + 1"/>

  <xsl:text>i equals </xsl:text>

  <xsl:value-of select="$i"/>

 </xsl:template>

</xsl:stylesheet>

Результатом выполнения этого шаблона будет:

i equals 1

i equals 2

Как можно видеть, объявление локальной переменной i "скрыло" значение глобальной переменной i. Более того, это преобразование любопытно еще и тем, что локальная переменная объявляется через глобальную — такое тоже допускается.

Рассмотрим теперь случай двух локальных переменных. Попробуем объявить две локальные переменные — одну за другой в следующем шаблоне:

<xsl:stylesheet

 version="1.0"

 xmlns:xsl="http://www.w3.org/1999/XSL/Transform">

 <xsl:template match="/">

  <xsl:variable name="i" select="1"/>

  <xsl:text>i equals </xsl:text>

  <xsl:value-of select="$i"/>

  <xsl:text> </xsl:text>

  <xsl:variable name="i" select="2"/>

  <xsl:text>i equals </xsl:text>

  <xsl:value-of select="$i"/>

 </xsl:template>

</xsl:stylesheet>

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

Failed to compile style sheet

At xsl:variable on line 9 of file stylesheet.xsl:

Variable is already declared in this template

Приведем теперь другое преобразование, в котором элементы xsl:variable принадлежат двум братским элементам:

<xsl:stylesheet

 version="1.0"

 xmlns:xsl="http://www.w3.org/1999/XSL/Transform">

 <xsl:template match="/">

  <p>

   <xsl:variable name="i" select="1"/>

   <xsl:text>i equals </xsl:text>

   <xsl:value-of select="$i"/>

  </p>

  <p>

   <xsl:variable name="i" select="2"/>

   <xsl:text>i equals </xsl:text>

   <xsl:value-of select="$i"/>

  </p>

 </xsl:template>

</xsl:stylesheet>

В этом случае никакого пересечения областей видимости нет, поэтому и ошибкой наличие в одном шаблоне двух локальных переменных с одинаковыми именами тоже не будет. Приведенное выше преобразование возвратит результат вида:

<p>

 i equals 1

</p>

<p>

 i equals 2

</p>

Использование переменных

Как правило, первой реакцией на известие о том, что переменные в XSLT нельзя изменять является реплика: "Да зачем они вообще тогда нужны?!".

Претензия со стороны процедурного программирования вполне серьезна и обоснованна — изменяемые переменные являются большим подспорьем в сложных многошаговых вычислениях. Тем не менее, переменные, даже в том виде, в каком они присутствуют в XSLT, являются очень важным и полезным элементом языка. Ниже мы перечислим наиболее типичные случаи использования переменных.

□ Переменные могут содержать значения выражений, которые много раз используются в преобразовании. Это избавит процессор от необходимости пересчитывать выражение каждый раз по-новому.

□ Переменной может присваиваться результат преобразования, что позволяет манипулировать уже сгенерированными частями документа.

□ Переменные могут использоваться для более прозрачного доступа к внешним документам.

Примеры

Первый случай использования совершенно очевиден: если в преобразовании многократно используется какое-либо сложное для вычисления или просто громоздкое для записи выражение, переменная может служить для сохранения единожды вычисленного результата. Например, если мы много раз обращаемся ко множеству ссылок данного документа посредством выражения вида:

//a[@href]

гораздо удобней и экономней с точки зрения вычислительных ресурсов объявить переменную вида

<xsl:variable name="links" select="//a[@href]"/>

и использовать ее в преобразовании как $a. Фильтрующие выражения языка XPath (продукция FilterExpr) позволяют затем обращаться к узлам выбранного множества так же, как если бы мы работали с изначальным выражением. Например, $a[1] будет эквивалентно //a[@href][1], a $a/@href — выражению //a[@href]/@href. При этом при обращении к $a процессор не будет заново искать все элементы a с атрибутом href, что, по всей вероятности, положительно скажется на производительности.

Другой иллюстрацией этому же случаю использования переменной может быть следующая ситуация: в некоторых случаях выражения могут быть просты для вычисления, но слишком громоздки для записи. Гораздо элегантней один раз вычислить это громоздкое выражение, сохранить его в переменной и затем обращаться по короткому имени. Например, следующий элемент xsl:variable вычисляет и сохраняет в переменной gv длинную и громоздкую ссылку:

<xsl:variable name="gv"

 select="concat('http://host.com:8080/GeoView/GeoView.jsp?',

 'Language=en&',

 'SearchText=Select&',

 'SearchTarget=mainFrame&',

 'SearchURL=http://host.com:8080/servlet/upload')"/>

После такого определения применение этой ссылки в преобразовании становится удобным и лаконичным:

<а href="{$gv}" target="_blank">Launch GeoBrowser</a>

Второй типовой случай использования переменных также заметно облегчает создание выходящего дерева, делая этот процесс гибким и легко конфигурируемым. Примером формирования HTML-документа при помощи такого подхода может быть следующий шаблон:

<xsl:template match="/">

 <html>

  <xsl:copy-of select="$head"/>

  <xsl:copy-of select="$body"/>

 </html>

</xsl:template>

Достоинство этого подхода в том, что переменные, содержащие фрагменты деревьев как бы становятся модулями, блоками, из которых в итоге собирается результирующий документ.

Более практичным применением возможности переменных содержать фрагменты деревьев является условное присвоение переменной значения. Представим себе следующий алгоритм:

если

 условие1

то

 присвоить переменной1 значение 1

иначе

 присвоить переменной1 значение2

Для процедурного языка с изменяемыми переменными это не проблема. На Java такой код выглядел бы элементарно:

переменная1 = условие1 ? значение1 : значение2;

или чуть в более длинном варианте:

if (условие1)

 переменная1 = значение1;

else

 переменная1 = значение2;

Однако если бы в XSLT мы написали что-нибудь наподобие:

<xsl:choose>

 <xsl:when test="условие1">

  <xsl:variable name="переменная1" select="значение1"/>

 </xsl:when>

 <xsl:otherwise>

  <xsl:variable name="переменная1" select="значение2"/>

 </xsl:otherwise>

</xsl:choose>

то требуемого результата все равно не достигли бы по той простой причине, что определенные нами переменные были бы доступны только в своей области видимости, которая заканчивается закрывающими тегами элементов xsl:when и xsl:otherwise. Правильный шаблон для решения этой задачи выглядит следующим образом:

<xsl:variable name="переменная1">

 <xsl:choose>

  <xsl:when test="условие1">

   <xsl:copy-of select="значение1"/>

  </xsl:when>

  <xsl:otherwise>

   <xsl:copy-of select="значение2"/>

  </xsl:otherwise>

 </xsl:choose>

<xsl:variable>

Конечно, это не точно то же самое — на самом деле мы получаем не значение, а дерево, содержащее это значение, но для строковых и численных значений особой разницы нет: дерево будет вести себя точно так же, как число или строка. Для булевых значений и множеств узлов приходится изыскивать другие методы. Булевое значение можно выразить через условие, например:

<xsl:variable name="переменная 1"

 select="(значение 1 and условие1) or (значение2 and not(условие2))"/>

Для множества узлов можно использовать предикаты и операции над множествами:

<xsl:variable name="переменная1"

 select="значение1[условие1] | значение2[not(условие2)]"/>

Заметим, что шаблон, содержащийся в элементе xsl:variable, может включать в себя такие элементы, как xsl:call-template, xsl:apply-templates и так далее. То есть переменной можно присвоить результат выполнения одного или нескольких шаблонов.

Использование внешних документов в преобразовании, как правило, сопровождается громоздкими выражениями вида:

document('http://www.xmlhost.com/docs/а.xml')/page/request/param

и так далее.

Для того чтобы при обращении к внешнему документу не использовать каждый раз функцию document, можно объявить переменную, которая будет содержать корневой узел этого документа, например:

<xsl:variable

 name="a.xml"

 select="document('http://www.xmlhost.com/docs/a.xml')"/>

После этого к документу http://www.xmlhost.com/docs/a.xml можно обращаться посредством переменной с именем a.xml, например:

<xsl:value-of select="$a.xml/page/request/param"/>

Параметры

Параметры в XSLT практически полностью идентичны переменным. Они точно так же связывают с объектом имя, посредством которого в дальнейшем можно к этому объекту обращаться. Главным различием является то, что значение, данное параметру при инициализации, является всего лишь значением по умолчанию, которое может быть переопределено при вызове.

До сих пор мы говорили о шаблонах, как о правилах, часто используя эти слова как синонимы. Попробуем теперь немного сменить угол зрения и представить их как функции, каждая из которых преобразует некоторый узел и возвращает фрагмент дерева в качестве результата. С этой точки зрения параметры шаблонов являются ни чем иным, как аргументами этих функций.

Работа с параметрами обеспечивается двумя элементами — xsl:param, который объявляет в шаблоне новый параметр и xsl:with-param, который указывает значение параметра при вызове шаблона.

Элемент xsl:param

Синтаксически этот элемент задается как:

<xsl:param

 name="имя"

 select="выражение">

 <!-- Содержимое: шаблон -->

</xsl:param>

Элемент xsl:template, задающий в преобразовании шаблонное правило, может включать несколько элементов xsl:param, которые и будут определять параметры этого шаблона. Кроме этого, xsl:param может указываться в виде элемента верхнего уровня — в этом случае он будет определять глобальный параметр.

Элемент xsl:param объявляет параметр с именем, которое задается обязательным атрибутом name. Имя параметра может иметь расширенную форму, например "user:param", но чтобы не возиться с пространствами имен, на практике имена всегда дают простые — типа "i" или "myParam".

Параметру может быть присвоено значение по умолчанию — то есть значение, которое будет использоваться в случае, если параметра с таким именем шаблону передано не было. Значение по умолчанию вычисляется следующим образом:

□ если в элементе xsl:param определен атрибут select, то значением по умолчанию будет результат вычисления выражения, указанного в этом атрибуте;

□ если атрибут select не определен, но сам элемент xsl:param имеет дочерние узлы, то значением определяемого параметра по умолчанию будет фрагмент дерева, полученного в результате выполнения содержимого xsl:param;

□ если атрибут select не определен и при этом сам элемент xsl:param пуст, то значением параметра по умолчанию будет пустая строка.

Примеры

Элемент

<xsl:param name="x" select="2 * 2"/>

создаст параметр, значением которого по умолчанию будет 4. Точно такой же эффект будет иметь элемент

<xsl:param name="x" select="2 * 2">

 <xsl:value-of select="5 * 5/>

</xsl:param>

Его содержимое не будет приниматься в расчет, поскольку в xsl:param присутствует атрибут select. Если же убрать атрибут select:

<xsl:param name="x">

 <xsl:value-of select="5 * 5/>

</xsl:param>

то значение параметра x по умолчанию действительно будет результатом вычисления его содержимого. Однако, вопреки довольно здравому разумению, этим значением не будет число 25 и даже не строка "25" и тем более не множество, состоящее из текстового узла со значением 25. Значением параметра x по умолчанию будет результирующий фрагмент дерева, корень которого будет иметь единственный текстовый узел со значением "25" (рис. 5.3).

Рис. 5.3. Фрагмент дерева, который будет значением параметра x по умолчанию

Не стоит пугаться такой структуры в качестве значения параметра. То, что параметр x вдруг будет содержать дерево, ничуть не ограничивает его использование, ведь дерево при потребности может быть приведено к числу или к строке; к множеству узлов же не может быть приведен ни один тип данных.

Предупреждение

Напомним, что при приведении дерева к булевому типу, результатом всегда будет истина. Дерево всегда содержит как минимум корневой узел, и поэтому оно никогда не будет считаться пустым.

Определение параметра вида:

<xsl:param name="x"/>

то есть когда в нем нет ни атрибута select, ни содержимого, присвоит параметру пустую строку, то есть будет эквивалентно

<xsl:param name="x" select="''"/>

Точно так же, как и в случае с переменными, значение заданного в шаблоне параметра можно использовать в выражениях, добавляя перед именем параметра префикс "$". К примеру, значение нашего параметра x может быть получено конструкцией вида $x.

Для того чтобы передать в шаблон определенные значения параметров, элементы, которые вызывают этот шаблон, должны содержать один или несколько элементов xsl:with-param, который мы рассмотрим чуть ниже. Глобальные параметры, объявленные элементами xsl:param верхнего уровня, также могут быть переданы преобразованию, однако конкретный механизм реализации этой передачи целиком и полностью зависит от реализации конкретного процессора.

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

Область видимости параметров определяется в точности так же, как область видимости переменных. Единственным, на что следует обратить здесь внимание — это то, что элементы xsl:param, определяемые в шаблонах, должны всегда быть его первыми дочерними элементами. Поэтому область видимости локальных параметров определяется несколько легче, чем область видимости локальных переменных: после определения параметр может использоваться в том шаблоне где угодно.

Прямым следствием из этого является то, что один шаблон не может иметь двух параметров с одинаковыми именами, поскольку их области видимости будут обязательно пересекаться, ведь один из параметров в любом случае будет следовать за другим.

Элемент xsl:with-param

Синтаксис этого элемента выглядит следующим образом:

<xsl:with-param

 name="имя"

 select="выражение">

 <!-- Содержимое: шаблон -->

</xsl:with-param>

Как можно заметить, элемент xsl:with-param абсолютно идентичен элементу xsl:param (отличаются только их имена). Практически настолько же похоже и их действие: элемент xsl:with-param тоже связывает с именем параметра значение, и при выполнении шаблона это значение будет использоваться вместо значения параметра по умолчанию.

Таким образом, значение параметра, заданного в шаблоне, выбирается в соответствии со следующими положениями:

□ если в элементе, который вызывает этот шаблон, присутствует элемент xsl:with-param, передающий значение этого параметра, в шаблоне будет использоваться переданное значение;

□ если в элементе, который вызывает этот шаблон, элемента xsl:with-param, с соответствующим именем нет, в качестве значения параметра будет использоваться значение по умолчанию.

Элемент xsl:with-param может использоваться только в качестве дочернего элемента xsl:apply-templates и xsl:call-template.

В качестве простого примера приведем шаблон, который выводит сокращение названия для недели по его номеру. Номер дня передается в шаблон параметром с именем day-number.

Листинг 5.26. Вывод названия дня недели по номеру

<xsl:template name="day-name">

 <xsl:param name="day-number" select="0"/>

 <xsl:choose>

  <xsl:when test="$day-number=1">Mon</xsl:when>

  <xsl:when test="$day-number=2">Tue</xsl:when>

  <xsl:when test="$day-number=3">Wed</xsl:when>

  <xsl:when test="$day-number=4">Thu</xsl:when>

  <xsl:when test="$day-number=5">Fri</xsl:when>

  <xsl:when test="$day-number=6">Sat</xsl:when>

  <xsl:when test="$day-number=7">Sun</xsl:when>

  <xsl:otherwise>Hmm...</xsl:otherwise>

 </xsl:choose>

</xsl:template>

Результатом вызова:

<xsl:call-template name="day-name">

 <xsl:with-param name="day-number" select="1"/>

</xsl:call-template>

будет текстовый узел "Mon". Рассмотрим теперь случай, когда параметра передано не было:

<xsl:call-template name="day-name"/>

Шаблон выведет задумчивое Hmm..., поскольку значение параметра day-number будет по умолчанию нулем (атрибут select имеет вид select="0") и в операторе выбора xsl:choose сработает условие xsl:otherwise.

Параметры могут быть использованы как в именованных, так и в неименованных шаблонах. Именованные шаблоны с параметрами ведут себя как самые настоящие функции — они могут вызываться с определенными параметрами вне зависимости от контекста, только чтобы выполнить какие-либо действия с переданными значениями. В случае обычных, неименованных шаблонов параметры могут предоставлять некую дополнительную информацию.

Пример

Представим себе описание меню в следующем формате:

<menu>

 <menuitem index="1" name="Home" href="home.htm"/>

 <menuitem index="2" name="News" href="news.htm"/>

 <menuitem index="3" name="Profile" href="profile.htm"/>

 <menuitem index="4" name="Contact" href="contact.htm"/>

</menu>

Для того чтобы при обработке особым образом выделять текущую страницу, определим в шаблоне параметр current и будем выводить название страницы в элементе b (от англ. bold — полужирный), если значение current равно индексу данного пункта меню; если текущая страница и индекс пункта меню не совпадают, то выводиться будет ссылка.

<xsl:template match="menuitem">

 <xsl:param name="current" select="1"/>

 <xsl:choose>

  <xsl:when test="$current=@index">

   <b>

    <xsl:value-of select="@name"/>

   </b>

  </xsl:when>

  <xsl:otherwise>

   <a href="{@href}">

    <xsl:value-of select="@name"/>

   </a>

  </xsl:otherwise>

 </xsl:choose>

</xsl:template>

Результатом выполнения шаблона

<xsl:template match="menu">

 <xsl:apply-templates select="menuitem">

  <xsl:with-param name="current" select="3"/>

 </xsl:apply-templates>

</xsl:template>

будет фрагмент меню вида

<a href="home.htm">Home</a>

<a href="news.htm">News</a>

<b>Profile</b>

<a href="contact.htm">Contact</a>

Попробуем теперь обработать элементы menuitem, не указывая значение параметра current:

<xsl:template match="menu">

 <xsl:apply-templates select="menuitem"/>

</xsl:template>

Результат будет получен в виде:

<b>Home</b>

<а href="news.htm">News</a>

<а href="profile.htm">Profile</a>

<a href="contact.htm">Contact</a>

Этот фрагмент выходящего документа легко объяснить. Вследствие определения:

<xsl:param name="current" select="1"/>

значением параметра current по умолчанию является 1, и поэтому в меню был выбран пункт с индексом 1.

Мы упомянули, что значением параметра может быть дерево. Попробуем пояснить эту концепцию на примере генерации HTML-документа.

Итак, предположим, что мы генерируем выходящий документ следующим именованным шаблоном:

<xsl:template name="html">

 <xsl:param name="head">

  <head>

   <title>Title one</title>

  </head>

 </xsl:param>

 <html>

  <xsl:copy-of select="$head"/>

   <body>

    <xsl:text>content</xsl:text>

   </body>

  </html>

 </xsl:template>

Параметр head по умолчанию будет содержать дерево, состоящее из элемента head и его дочернего элемента title, который содержит текст "Title one". Результат выполнения вызова

<xsl:call-template name="html"/>

мы можем видеть на следующем листинге:

<html>

 <head>

  <title>Title one</title>

 </head>

 <body>content</body>

</html>

Выделенный фрагмент относится к части дерева, которая была создана копированием значения параметра head.

Попробуем теперь передать в качестве параметра дерево, сгенерированное следующим шаблоном:

<xsl:template name="head">

 <head>

  <title>Title two</title>

  <style type="text/css">

   H1 {border-width: 1; border: solid; text-align: center}

  </style>

 </head>

</xsl:template>

Для того чтобы передать результат выполнения этого шаблона в виде значения параметра head именованному шаблону head, воспользуемся следующей конструкцией:

<xsl:call-template name="html">

 <xsl:with-param name="head">

  <xsl:call-template name="head"/>

 </xsl:with-param>

</xsl:call-template>

Выходящий документ будет получен в виде:

<html>

 <head>

  <title>Title two</title>

  <style type="text/css">

   H1 {border-width: 1; border: solid; text-align: center}

  </style>

 </head>

 <body>content</body>

</html>

Выделенный фрагмент, как и в предыдущем случае, соответствует части документа, полученной при копировании значения параметра head.

Приведенные выше примеры демонстрируют, как можно собрать выходящий документ по кусочкам из фрагментов деревьев. При умелом использовании изложенные подходы позволяют добиться очень высокой гибкости и универсальности преобразований.

Глава 6 XPath-выражения

Выражения для XML-документов

По мере распространения XML-технологий и развития смежных с ними областей стали выделяться не только задачи, которые хорошо подходят для решения с помощью XML, но и задачи, которые нужно решать при программировании самих XML-приложений. Одной из таких задач является обращение к определенным частям XML-документа. Например, если нам нужно получить из документа, скажем, цену продукта, которая находится в атрибуте value элемента price, принадлежащему элементу product, сделать это при помощи стандартных SAX- или DOM-интерфейсов было бы, мягко говоря, не очень удобно. И это еще простой пример. Бывают, действительно, сложные случаи, когда нужно выбрать узел определенного типа, который может находиться в нескольких местах в документе, да еще и должен обладать заданными свойствами.

Для выполнения часто встречающихся задач такого рода был создан язык XPath, название которого расшифровывается, как XML Path — язык XML- путей. Главной задачей этого языка является адресация, или, по-другому, определение местоположения частей XML-документа. На практике это означает выбор в документе множества узлов, которые соответствуют определенным условиям расположения.

Помимо главной задачи, в XPath имеются также дополнительные функции для работы со строками, числами, булевыми значениями и множествами узлов. Поэтому на самом деле XPath — это много больше, чем просто язык адресации. XPath-выражения, являющиеся самой общей конструкцией языка, могут возвращать значения любого из основных типов (кроме результирующего фрагмента дерева — этот тип может быть использован только в XSLT).

В языке XSLT очень часто используются XPath-выражения — во всех вычислениях, выборках, сравнениях и так далее, XSLT опирается на XPath. В XPath есть арифметические и логические операции, а также библиотека базовых функций (которые, правда, дополняются некоторыми функциями XSLT). Можно с уверенностью заявить, что без знания языка XPath будет невозможно создавать реально функционирующие преобразования.

К счастью, несмотря на все особенности, язык XPath настолько прост, что иногда его используют, даже не отдавая себе отчета, что это XPath. Скажем, когда мы пишем

<xsl:value-of select="page/number"/>

для того, чтобы вывести номер страницы, указанный в элементе number, который находится в элементе page, мы не задумываемся о том, что page/number — это на самом деле XPath-выражение, точнее, путь выборки.

Более того, как мы позднее увидим, пути выборки настолько аналогичны путям в файловых системах, что использовать их можно, абсолютно не понимая семантики — чисто по аналогии. Однако, для построения сложных выражений нужно хорошо понимать, что стоит за тем или иным синтаксисом.

Для того чтобы четко определить все грамматические конструкции этого языка, мы опять будем применять расширенные формы Бэкуса-Наура, по возможности раскрывая и упрощая их. Чтобы не путать номераXPath-продукций с другими синтаксическими правилами, мы будем использовать в номере префикс XP, например:

[ХР1] LocationPath ::= RelativeLocationPath

                       | AbsoluteLocationPath

В синтаксических правилах, которые мы будем приводить, используются три нетерминала NCName, QName и S, которые мы уже рассматривали ранее. NCName и QName относятся к расширенным именам, a S обозначает пробельное пространство.

XPath-выражения являются статическими компонентами языка XSLT. Выражения нельзя создавать во время выполнения преобразования, иначе говоря, функции высшего порядка (функции, результатом вычисления которых также являются функции) в XSLT отсутствуют. Нельзя сделать, например, следующее:

<!-- Создаем XPath-выражение -->

<xsl:variable name="expr" select="concat(.'page/number[', id, ']')"/>

<!-- Вычисляем динамически созданное XPath-выражение -->

<xsl:value-of select="eval($expr)"/>

В XPath отсутствует функция eval, которая вычисляла бы значение XPath-выражения, переданного ей в виде строки.

Примечание

Функция eval присутствует в некоторых XSLT-процессорах, например в Saxon в виде расширения saxon:evaluate.

Контекст вычисления выражений

Как мы видели ранее, в XSLT одно и то же правило преобразования может применяться к различным частям XML-документа и в каждом случае результат будет разным — в зависимости от того, как выглядит обрабатываемый фрагмент. Подобно этому, XPath-выражения тоже вычисляются в зависимости от контекста. Контекст показывает, какой узел в данный момент обрабатывается преобразованием, какова позиция этого узла в обрабатываемом множестве, сколько всего узлов в этом множестве, какие переменные доступны и какие значения они имеют, какие функции могут быть вызваны и, наконец, какие пространства имен объявлены. Иными словами, контекст — это полное описание положения, окружения или ситуации, в которой происходит вычисление.

Если давать строгое определение в соответствии со спецификацией XPath, то контекст составляют следующие части.

□ Контекстный узел — узел, который обрабатывается в текущий момент. Контекстный узел оказывает влияние на вычисление многих выражений — например, относительные пути выборки будут отсчитываться относительно контекстного узла. В большинстве случаев контекстный узел совпадает с текущим узлом преобразования, однако во время вычисления самих XPath-выражений, они могут различаться.

□ Целое положительное число, показывающее размер контекста — количество узлов во множестве, которое обрабатывается в данный момент. Это число может быть получено функцией last.

□ Целое положительное число, показывающее позицию контекстного узла в контексте вычисления выражения — то есть порядковый номер узла в текущем множестве преобразования, которое было соответствующим образом упорядочено. Это число может быть получено функцией position. Позиция первого узла равна 1, позиция последнего — значению функции last.

□ Множество связанных переменных. Это множество есть множество пар вида "имя-значение", в котором имя переменной связывается со значением, присвоенным ей. Переменные не определяются в самом XPath, для этого следует использовать элемент языка XSLT xsl:variable. Переменные могут содержать как значения любого из четырех базовых типов XPath (булевый тип, строка, число, множество узлов), так и значения других типов. Например, в XSLT значению переменной можно присвоить результирующий фрагмент дерева, а расширения языка так и вовсе могут присваивать переменным объекты любых типов. Другое дело, что XPath-выражения в соответствии со стандартом не должны непосредственно работать другими типами объектов, кроме своих четырех базовых. Механизмы расширения XPath и XSLT будут рассматриваться в главе 10.

В отношении переменных важно понимать, что это не более чем объекты, доступ к которым можно получить по имени.

□ Библиотека функций, состоящая из множества функций, которые могут быть выполнены процессором. В XPath определяется базовая библиотека, функции которой должны быть реализованы в процессоре, однако эта библиотека может быть расширена. Например, XSLT определяет несколько дополнительных функций, которые также должны поддерживаться всеми XSLT-процессорами. Более того, в преобразованиях можно использовать и собственные функции расширения. Таким образом, библиотека функций контекста состоит из всех функций, доступных при вычислении выражения.

□ Множество объявлений пространств имен. Это множество связывает префиксы пространств имен с уникальными идентификаторами ресурсов (URI), которые им соответствуют.

Пути выборки

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

Синтаксис путей выборки во многом похож на синтаксис путей в файловых системах — сказывается то обстоятельство, что иерархическая структура данных в XML-документах очень близка к древовидной структуре каталогов. В качестве примера сравним дерево каталогов (рис. 6.1) с таким же деревом, записанным в виде XML-документа (листинг 6.1).

Рис. 6.1. Древовидная структура каталогов

Листинг 6.1 XML-документ

<Java>

 <Doc>

  <ClassGenerator/>

  <SchemaProcessor/>

  <XMLParser>

   <images/>

  </XMLParser>

 </Doc>

 <Lib>

  <Servlets>

   <classes/>

   <doc>

    <images/>

   </doc>

   <lib/>

   <src/>

  </Servlets>

 </Lib>

</Java>

В этой иерархии каталогов путь "/" соответствует корневому каталогу, путь "/Java/Lib/Servlets/src" — каталогу src. Путь из каталога Java в каталог XMLParser имеет вид "Doc/XMLParser", а путь из каталога Lib в каталог images — "Servlets/doc/images".

Перемещаться в системе каталогов можно не только вглубь, но также на верхние уровни при помощи пути "..", который осуществляет переход в родительский каталог. К примеру, для того, чтобы перейти из каталога "/Java/Lib/Servlets/doc/images" в каталог "/Java/Doc/XMLParser/images", можно воспользоваться путем "../../../../Doc/XMLParser/images".

Пути файловой системы, приведенные выше, в точности совпадают с путями выборки, которые мы бы использовали для обращения к соответствующим частям ХМL-документа. Путь выборки "/" содержит корневой узел, путь выборки "/java/Lib/Servlets/src" — элемент src, принадлежащий элементу Servlets, который принадлежит элементу Lib, который принадлежит элементу Java, находящемуся в корне элемента. Путь выборки "Doc/XMLParser" выбирает элементы XMLParser, находящиеся в элементах Doc, принадлежащих контекстному узлу.

В XPath существует два вида путей выборки — относительные и абсолютные пути. Абсолютный путь (например, "/Java/Doc/ClassGenerator") начинается ведущей косой чертой ("/") и отсчитывается от корневого узла документа, в то время как относительный путь (например, "Doc/XMLParser") отсчитывается от контекстного узла.

И абсолютный, и относительный пути выборки состоят из нескольких шагов выборки, разделенных косой чертой ("/"). Вычисление пути выборки производится последовательным выполнением составляющих его шагов. В случае абсолютного пути выборки, первый шаг выполняется относительно корневого узла дерева, в случае относительного пути — относительно контекстного узла контекста.

Пример

В файловой системе выполнить путь вида Lib/Servlets/classes означает:

□ из текущего каталога перейти в подкаталог Lib;

□ затем перейти в подкаталог Servlets;

□ и наконец — в подкаталог classes.

Для того чтобы выполнить такой же путь выборки в XML-документе, нужно

сделать следующее:

□ выполнить первый шаг, "Lib" — выбрать все дочерние элементы контекстного узла, имеющие имя "Lib";

□ затем выполнить шаг "Servlets" — для каждого из узлов, выбранных предыдущим шагом, выбрать дочерние элементы "Servlets" и объединить их в одно множество;

□ наконец, выполнить шаг "classes" — для каждого из узлов, выбранных на предыдущем этапе, выбрать дочерние элементы classes и объединить их в одно множество.

Опишем более подробно алгоритм вычисления пути выборки:

□ если путь выборки является абсолютным путем, то первый его шаг выполняется в контексте корневого узла документа, который содержит контекстный узел;

□ если путь выборки является относительным путем, то первый его шаг выполняется относительно контекстного узла;

□ каждый последующий шаг пути выборки выполняется для каждого узла множества, выбранного на предыдущем шаге, — таким образом выбирается несколько множеств, которые затем объединяются — это и есть множество, выбранное на текущем шаге.

Пример

Рассмотрим процесс выполнения пути выборки /A/B/D/G/I в следующем документе:

<A>

 <B/>

 <B>

  <D>

   <G/>

  </D>

  <G>

   <I/>

  </G>

  <G/>

  <G>

   <I/>

   <I/>

  </G>

  <D/>

  <E/>

  <F>

   <H/>

  </F>

 </B>

 <C/>

</A>

На рис. 6.2 показано логическое дерево, соответствующее этому документу.

Рис. 6.2. Логическое дерево, представляющее XML-документ

Для того чтобы лучше понять процесс выбора, проследим по шагам за тем, как будет обрабатываться этот путь.

1. Данный путь (рис. 6.3) является абсолютным путем выборки, значит, он должен выполняться, начиная от корневого узла.

Рис. 6.3. Начальный узел пути выборки

2. Первым шагом пути (рис. 6.4) является шаг A, который выбирает все дочерние элементы A контекстного узла.

Рис. 6.4. Первый шаг

3. Вторым шагом пути (рис. 6.5) является шаг B, который выбирает все дочерние элементы в узлов множества, выбранного на предыдущем шаге. Так как тогда был выбран единственный узел A, текущий шаг выберет два дочерних элемента в этого узла.

Рис. 6.5. Второй шаг

4. На очередном шаге (рис. 6.6) мы выбираем дочерние элементы D. Как можно заметить, один из элементов в, выбранных на прошлом этапе, не содержит таких элементов, значит, в этом случае, шаг выборки возвратит пустое множество. Второй элемент B имеет три дочерних элемента B. В итоге мы получим множество, состоящее из трех элементов D.

Рис. 6.6. Третий шаг

5. Следующий шаг, G (рис. 6.7) выбирает дочерние элементы G. Первый элемент D, выбранный на прошлом шаге, включает один элемент G, второй не имеет таких элементов, третий — имеет три дочерних элемента G. Таким образом, на данном шаге будет выбрано множество, состоящее из четырех элементов G.

Рис. 6.7. Четвертый шаг

6. Последний шаг, I (рис. 6.8) выбирает для каждого из четырех элементов G дочерние элементы I. Первый элемент G не имеет дочерних элементов, второй имеет один дочерний элемент I, третий не содержит элементов и четвертый содержит два элемента I. В итоге результатом выполнения этого шага будет множество, состоящее из 3 элементов I.

Рис. 6.8. Пятый шаг

Пути выборки соответствует продукция LocationPath, которая записывается следующим образом:

[XP1] LocationPath ::= RelativeLocationPath

                       | AbsoluteLocationPath

Эта продукция означает, что путь выборки может быть либо относительным путем, которому соответствует продукция RelativeLocationPath, либо абсолютным путем с продукцией AbsoluteLocationPath:

[XP2] AbsoluteLocationPath ::= '/' RelativeLocationPath?

                               | AbbreviatedAbsoluteLocationPath

[XP3] RelativeLocationPath ::= Step

                               | RelativeLocationPath '/' Step

                               | AbbreviatedRelativeLocationPath

Упростим LocationPath, раскрыв дочерние продукции:

LocationPath ::= '/'

                 | RelativeLocationPath

                 | '/' RelativeLocationPath

                 | '//' RelativeLocationPath

Таким образом, путь выборки имеет четыре основных варианта, которые мы сейчас и разберем:

□ путь '/' — используется для обращения к корневому узлу дерева;

□ путь вида RelativeLocationPath — есть относительный путь выборки;

□ путь вида '/' RelativeLocationPath — это абсолютный путь выборки, то есть относительный путь, которому предшествует '/';

□ путь вида '//' RelativeLocationPath — это абсолютный путь выборки, в котором использован сокращенный синтаксис. Путь такого вида эквивалентен пути вида '/descendant-or-self:node()/' RelativeLocationPath. Первой его частью является путь '/descendant-or-self:node()', который выбирает все узлы документа (кроме узлов атрибутов и пространств имен).

Главной деталью LocationPath является относительный путь выборки, продукция которого также может быть переписана в раскрытом и упрощенном виде:

RelativeLocationPath ::= Step

                         | RelativeLocationPath '/' Step

                         | RelativeLocationPath '//' Step

В соответствии с этой продукцией, относительный путь выборки состоит из одного или нескольких шагов выборки, разделенных '/' или '//'. Как уже отмечалось ранее, конструкция '//' есть сокращенный вариант от '/descendant-or-self::node()/'. Таким образом, главным элементом пути выборки является шаг выборки.

Примеры:

□ / — выберет корневой узел документа;

□ /а — выберет элемент а, находящийся в корне документа;

□ //а — выберет множество всех элементов а текущего документа.

Шаги выборки

Любой путь — это последовательность шагов, путь выборки — это последовательности шагов выборки, которые нужно совершить, чтобы получить искомый результат. Каждый шаг выборки состоит из трех частей.

□ Первая часть называется осью навигации — она показывает направление, в котором будет производиться выбор на данном шаге. Например, можно выбирать дочерние узлы, узлы-атрибуты или родительские узлы контекстного узла (см. также раздел "Оси навигации" данной главы).

□ Второй частью шага выборки является тест узла. Тест узла показывает, узлы какого типа или с какими именами должны быть выбраны на данном шаге.

□ Третья часть шага выборки — это один или несколько предикатов, логических выражений, которые фильтруют множество узлов, выбранных на данном шаге.

Проще говоря, ось навигации отвечает на вопрос "куда двигаемся?", тест узла — на вопрос "какие узлы ищем?", а предикаты — на вопрос "какими свойствами должны обладать выбираемые узлы?".

Пример

Шаг выборки attribute::href[. = 'http://www.xsltdev.ru'] состоит из оси навигации attribute, которая выбирает атрибуты данного узла, теста узла href, который выбирает узлы с именем href и нулевым пространством имен, и предиката [. = 'http://www.xsitdev.ru'], который оставляет в выбираемом множестве те узлы, текстовое значение которых равно "http://www.xsltdev.ru". Таким образом, на этом шаге будут выбраны все атрибуты href текущего узла, имеющие значение "http://www.xsltdev.ru".

Шаг выборки соответствует EBNF-продукции Step, а первая его часть, ось навигации — продукции AxisSpecifier:

[XP4] Step          ::= AxisSpecifier NodeTest Predicate*

                        | AbbreviatedStep

[XP5] AxisSpecifier ::= AxisName '::'

                        | AbbreviatedAxisSpecifier

Продукцию Step можно значительно упростить и записать в следующем виде:

Step ::= '.'

         | '..'

         | NodeTest Predicate*

         | '@' NodeTest Predicate*

         | AxisName '::' NodeTest Predicate*

В первых четырех случаях шаг выборки записан при помощи сокращенного синтаксиса, а именно:

□ шаг выборки '.' эквивалентен шагу self::node(), который выбирает контекстный узел;

□ шаг выборки '..' эквивалентен шагу parent::node(), который выбирает родительский узел контекстного узла;

□ шаг выборки вида NodeTest Predicate* эквивалентен шагу выборки вида 'child::' NodeTest Predicate*, который выбирает узлы из множества дочерних узлов контекстного узла;

□ шаг выборки вида '@' NodeTest Predicate* эквивалентен шагу выборки вида 'attribute::' NodeTest Predicate*, который выбирает узлы из множества атрибутов контекстного узла.

Последний случай, AxisName ' ::' NodeTest Predicate* представляет полный синтаксис шага выборки: сначала идет наименование оси и тест узла, разделенные двумя двоеточиями ("::"), затем несколько предикатов.

Оси навигации

Важной особенностью путей выборки является то, что шаги в них могут совершаться не в двух направлениях (вглубь и на верхний уровень), как в случае с файловыми системами, а во многих других. При выполнении шага выборки из некоторого контекстного узла направление движения по логическому дереву документа задается первой частью этого шага, осью навигации. В XPath имеется 13 осей навигации, а именно:

□ self — эта ось навигации содержит только сам контекстный узел;

□ child — содержит все дочерние узлы контекстного узла; не содержит узлов атрибутов и пространств имен;

□ parent — содержит родительский узел контекстного узла, если он есть;

□ descendant — содержит все узлы-потомки контекстного узла; не содержит узлов атрибутов и пространств имен;

□ descendant-or-self — содержит контекстный узел, а также всех его потомков; не содержит узлов атрибутов и пространств имен;

□ ancestor — содержит узлы, которые являются предками контекстного узла;

□ ancestor-or-self — содержит контекстный узел, а также всех его предков;

□ following — содержит узлы, следующие за контекстным узлом, в порядке просмотра документа; не содержит его потомков; не содержит узлов атрибутов и пространств имен;

□ following-sibling — содержит братские узлы контекстного узла, которые следуют за ним в порядке просмотра документа; если контекстный узел является атрибутом или узлом пространства имен, то following-sibling не будет содержать никаких узлов;

□ preceding — содержит узлы, предшествующие контекстному узлу в порядке просмотра документа; не содержит его предков; не содержит узлов атрибутов и пространств имен;

□ preceding-sibling — содержит братские узлы контекстного узла, которые предшествуют ему в порядке просмотра документа; в случае, если контекстный узел является узлом атрибута или пространства имен, preceding-sibling не будет содержать никаких узлов;

□ attribute — содержит атрибуты контекстного узла, если он является элементом; в противном случае не содержит ничего;

□ namespace — содержит узлы пространств имен контекстного узла, если он является элементом; в противном случае не содержит ничего.

Шаг выборки вида ось::node() будет содержать все узлы, принадлежащие этой оси. Например, attribute::node() (или, сокращенно @node()) будет содержать все атрибуты текущего узла.

Для того чтобы понять, как оси навигации расположены в дереве документа, обратимся к рис. 6.9.

Рис. 6.9. Расположение в документе осей навигации

На этом рисунке не показано расположение осей атрибутов и пространств имен вследствие того, что эти оси не имеют в документе физического направления.

Каждая ось имеет базовый тип узла — это тип узла, который считается "главным" в этом направлении навигации. Этот тип устанавливается следующим образом: если ось может содержать узлы элементов, ее базовым типом является элемент, в противном случае базовым типом оси навигации является тип узлов, которые она может содержать.

Кроме того, каждой оси соответствует прямое или обратное направление просмотра, которое определяет, в каком порядке будут перебираться узлы, выбираемые этой осью. Оси навигации, которые содержат узлы, предшествующие в порядке просмотра документа контекстному узлу, имеют обратное направление просмотра, все остальные оси просматриваются в прямом порядке. Поскольку оси как self и parent не могут содержать более одного узла, порядок просмотра для них не играет никакого значения.

Базовые типы узлов и направление их просмотра можно свести в одну таблицу (табл. 6.1).

Таблица 6.1. Базовые типы узлов и направления просмотра осей навигации

Ось навигации	Базовый тип узла	Направление просмотра
self	Узел элемента	Нет
child	Узел элемента	Прямое
parent	Узел элемента	Нет
descendant	Узел элемента	Прямое
descendant-or-self	Узел элемента	Прямое
ancestor	Узел элемента	Обратное
ancestor-or-self	Узел элемента	Обратное
following	Узел элемента	Прямое
following-sibling	Узел элемента	Прямое
preceding	Узел элемента	Обратное
preceding-sibling	Узел элемента	Обратное
attribute	Узел атрибута	Прямое
namespace	Узел пространства имен	Прямое

Базовый тип влияет на то, как в данном шаге выборки будет выполняться тест узла, а направление просмотра на позицию, которую будет занимать тот или иной узел в данном направлении.

Легче всего понять, какие узлы и в каком порядке содержат те или иные оси навигации, представив это графически. Рис. 6.10 иллюстрирует выбор узлов осями навигации. Здесь показано дерево документа, контекстный узел, выделенный жирной линией, и множество узлов, содержащееся в данной оси, ограниченное пунктиром. Узлы выбранного множества пронумерованы в порядке просмотра оси.

Рис. 6.10. Расположение и порядок просмотра осей навигации в документе

Приведем продукцию AxisName, которая описывает синтаксис осей навигации.

[XP6] AxisName ::= 'ancestor'

                   | 'ancestor-or-self'

                   | 'attribute'

                   | 'child'

                   | 'descendant'

                   | 'descendant-or-self'

                   | 'following'

                   | 'following-sibling'

                   | 'namespace'

                   | 'parent'

                   | 'preceding'

                   | 'preceding-sibling'

                   | 'self'

Оси навигации показывают, в каком направлении следует искать узлы, — среди тех, которые предшествовали контекстному узлу, или тех, которые будут следовать за ним, родительские или дочерние элементы, узлы атрибутов или пространств имен.

При этом оси навигации могут содержать узлы разных типов и с разными именами. Следующая часть шага выборки, тест узла уточняет, что конкретно мы ищем.

Тесты узлов

Вторая часть шага выборки, тест узла, оставляет из множества, которое содержит ось навигации, только узлы, соответствующие определенному типу или имеющие определенные имена.

Продукция NodeTest, соответствующая тесту узла, определяется следующим образом:

[XP7] NodeTest ::= NameTest

                   | NodeType '(' ')'

                   | 'processing-instruction' '(' Literal ')'

Раскрыв продукции NameTest и NodeType, EBNF-синтаксис теста узла можно переписать в упрощенном виде:

NodeTest ::= '*'

             | NCName:*

             | QName

             | 'comment()'

             | 'text()'

             | 'processing-instruction'

             | 'processing-instruction' '(' Literal ')'

             | 'node()'

Рассмотрим подробно каждый случай.

□ Тест узла '*' выполняется для любого узла, тип которого является базовым типом оси навигации данного шага выборки. Иными словами, шаг выборки attribute::* или @* выберет все атрибуты контекстного узла, а namespace::* — все узлы пространств имен. Для всех остальных осей тест * будет выбирать узлы элементов, принадлежащих данной оси.

□ Тест узла вида 'NCName:*' выполняется для узлов определенного пространства имен. Этот тест имеет вид префикс:*, где префикс соответствует проверяемому пространству (он должен быть определен в контексте вычисляемого шага выборки). Этот тест выполняется для всех узлов пространства имен, которое соответствует префиксу вне зависимости от локальной части имени.

□ Тест вида QName выполняется для узлов базового типа, которые имеют расширенные имена, равные QName. Если в QName не указан префикс, то тест будет выполняться для узлов с соответствующим именем и нулевым пространством имен. В случае, если префикс указан, узел будет удовлетворять тесту, если его пространство имен будет совпадать с пространством имен, которое соответствует префиксу, а локальная часть имени будет равна локальной части QName.

□ Тест 'comment()' выполняется для любого узла комментария.

□ Тест 'text()' выполняется для любого текстового узла.

□ Тест узла 'processing-instruction()' выполняется для любого узла инструкции по обработке.

□ Тест 'processing-instruction (' Literal ')', или, в упрощенном виде processing-instruction(строка) выполняется для инструкций по обработке, имеющих имя, равное строковому параметру этого теста узла.

□ Тест узла 'node()' выполняется для любого узла. Шаг выборки вида ось::node() выберет все узлы, принадлежащие данной оси.

Примеры:

□ child::node() — выберет все дочерние узлы контекстного узла;

□ child::* — выберет дочерние элементы контекстного узла;

□ attribute::* — выберет атрибуты контекстного узла;

□ xsl:* — выберет все дочерние элементы контекстного узла, принадлежащие пространству имен с префиксом xsl;

□ xsl:template  — выберет все дочерние элементы template контекстного узла, принадлежащие пространству имен с префиксом xsl;

□ comment() — выберет все дочерние узлы комментариев;

□ self::comment() — выберет контекстный узел, если он является комментарием, или пустое множество в противном случае;

□ descendant::processing-instruction() — выберет все узлы инструкций по обработке, которые являются потомками контекстного узла;

□ following::processing-instruction('арр')— выберет все узлы инструкций по обработке с целевым приложением "app", которые следуют за контекстным узлом в порядке просмотра документа.

Тест узла показывает, какого типа узлы мы ищем. Комментарии? Текстовые узлы? Узлы с определенными именами или принадлежащие определенному пространству имен? Или подойдут любые узлы?

Итак, ось навигации позволяет указывать направления шага по дереву документа, тест узла — тип или имя выбираемого узла. Третья часть шага выборки (один или несколько предикатов) позволяет дополнять эти критерии логическими условиями, которые должны выполняться для выбираемых на данном шаге узлов.

Предикаты

При выборе узлов каждый шаг выборки может иметь один или несколько предикатов, которые будут фильтровать выбираемое множество узлов. Предикат — это логическое выражение, вычисляемое для. каждого узла выбранного множества, и только в том случае, если результатом является истина, узел остается в фильтруемом множестве.

Продукция предиката, Predicate, определяется следующим образом:

[XP8] Predicate     ::= '[' PredicateExpr ']'

[XP9] PredicateExpr ::= Expr

PredicateExpr — это логическое выражение предиката, которое в данной версии языка ничем не отличается от обычного выражения. Продукцию предиката можно упростить и переписать в следующем виде:

Predicate ::= '[' Expr ']'

Как можно видеть, синтаксис предикатов довольно примитивен — это просто выражение, заключенное в квадратные скобки. При вычислении предиката результат этого выражения приводится к булевому типу.

Фильтрация множества узлов выполняется следующим образом.

□ Фильтруемое множество сортируется в направлении просмотра оси навигации данного шага. Для осей ancestor, ancestor-or-self, preceding, preceding-sibling фильтруемое множество сортируется в обратном порядке просмотра документа, для остальных осей — в прямом порядке просмотра.

□ Выражение предиката вычисляется для каждого узла отсортированного множества в следующем контексте.

 • Фильтруемый узел (тот, для которого в данный момент вычисляется предикат) становится контекстным узлом.

 • Количество узлов фильтруемого множества становится размером контекста.

 • Позиция фильтруемого узла в отсортированном множестве становится позицией контекста.

□ Результат вычисления предиката преобразуется в булевый тип согласно следующим правилам.

 • Если результатом вычисления является число, равное позиции контекста, булевым значением предиката будет true, в противном случае — false. Например, предикат [2] равносилен предикату [position()=2] — он обратится в истину только для второго узла фильтруемого множества.

 • Все остальные типы данных приводятся к булевому типу в соответствии со стандартными правилами (см. также раздел "Типы данных" настоящей главы).

□ Из фильтруемого множества исключаются все узлы, булевое значение предиката для которых было ложью.

□ В случае, если в шаге выборки было несколько предикатов, процедура фильтрации повторяется с каждым из них, оставляя в отфильтрованном множестве только те узлы, для которых каждый из предикатов будет истиной.

Таким образом, предикаты определяют свойства, которыми должны обладать выбираемые узлы.

Примеры:

□ a[1] — выберет первый в порядке просмотра документа дочерний элемент а контекстного узла;

□ a[position() mod 2 = 0] — выберет все четные дочерние элементы а;

□ *[. = 'а'] — выберет все дочерние элементы, текстовое значение которых равно "а";

□ *[name() = 'a'] — выберет все дочерние элементы, имя которых равно "а";

□ *[starts-with(name(), 'a')] — выберет все дочерние элементы, имя которых начинается с "а";

□ *[. = 'а'][1] — выберет первый дочерний элемент, текстовое значение которого равно "а";

□ *[. = 'a'][position() mod 2 = 0] — выберет все дочерние элементы, текстовое значение которых равно "а", затем из них выберет четные элементы.

Сокращенный синтаксис

Пути выборки — это наиболее часто используемые XPath-выражения и для того, чтобы сделать их менее громоздкими, в XPath имеется так называемый сокращенный синтаксис, с которым мы уже встречались в предыдущих главах. Его продукции записываются следующим образом:

[XP10] AbbreviatedAbsoluteLocationPath

 :: = '//' RelativeLocationPath

[XP11] AbbreviatedRelativeLocationPath

 ::= RelativeLocationPath '//' Step

[XP12] AbbreviatedStep

 ::= '.'

     | '..'

[XP13] AbbreviatedAxisSpecifier

 ::= '@'?

Первое сокращение, '//' — это краткая версия для "/descendant-or-self::node()/". Шаг выборки descendant-or-self::node() возвращает всех потомков контекстного узла (не включая узлов атрибутов и пространств имен). Сокращенный путь вида '//' RelativeLocationPath раскрывается в путь вида

'/descendant-or-self::node()/' RelativeLocation

а путь вида RelativeLocationPath '//' Step — в путь

RelativeLocationPath '/descendant-or-self::node()/' Step

Сокращенный шаг вида '.' возвращает контекстный узел, его полная версия — self::node().

Сокращенный шаг '..' возвращает родительский узел контекстного узла. Это сокращение равносильно шагу выборки parent::node().

Заметим, что сокращения "." и ".." являются сокращенными шагами выборки. Это, в частности, означает, что к ним нельзя присовокуплять предикаты и так далее. Выражение ".[ancestor::body]" будет с точки зрения синтаксиса XPath некорректным. Вместо этого можно использовать выражение "self::node()[ancestor::body]", которое будет синтаксически правильным.

Наиболее часто используемой осью навигации является ось child, содержащая все дочерние узлы контекстного узла. Шаги выборки, которые обращаются к дочерним узлам, имеют вид 'child::' NodeTest Predicate*. Самым полезным сокращением является то, что в шагах такого вида дескриптор оси 'child::' может быть опущен, и тогда упрощенные шаги будут иметь вид NodeTest Predicate*.

Дескриптор оси навигации 'attribute::' также может быть сокращен до '@'. Шаг выборки 'attribute::' NodeTest Predicate* может быть переписан с использованием, сокращенного синтаксиса в виде '@'. NodeTest Predicate*.

Примеры:

□ .//* — выберет все элементы-потомки контекстного узла;

□ ..//* — выберет все дочерние элементы родителя контекстного узла;

□ @* — выберет все атрибуты контекстного узла;

□ .//@* — выберет все атрибуты всех потомков контекстного узла;

□ //* — выберет все элементы документа, содержащего контекстный узел;

□ //@* — выберет все атрибуты всех элементов документа, содержащего контекстный узел;

□ html/body — выберет элементы body, принадлежащие дочерним элементам html контекстного узла.

Примеры путей выборки

Простые шаги выборки:

□ child::* — выберет все дочерние элементы контекстного узла;

□ child::comment() — выберет все узлы комментариев контекстного узла;

□ child::node() — выберет все дочерние узлы контекстного узла вне зависимости от их типа;

□ child::query — выберет все дочерние элементы контекстного узла, имеющие имя query;

□ child::xsql:* — выберет все дочерние элементы, которые находятся в пространстве имен, определяемом префиксом xsql;

□ child::xsql:query — выберет все дочерние элементы query, которые находятся в пространстве имен, определяемом префиксом xsql;

□ attribute::* — выберет все атрибуты контекстного узла;

□ attribute::href — выберет атрибут href контекстного узла, если он существует;

□ parent::* — выберет родительский узел контекстного узла, если тот является элементом, и пустое множество, если родительский узел имеет другой тип, например является корнем дерева;

□ parent::node() — выберет родительский узел контекстного узла вне зависимости от его типа. Единственный случай, когда этот шаг выберет пустое множество — это когда контекстный узел является корневым узлом документа;

□ parent::xsl:template — выберет родительский узел, если тот является элементом с именем template и имеет пространство имен с префиксом xsl, иначе выберет пустое множество;

□ self::* — выберет контекстный узел, если он является элементом и пустое множество узлов, если контекстный узел имеет другой тип;

□ self:* — выберет все дочерние элементы контекстного узла, принадлежащие пространству имен с префиксом self;

□ self::text() — выберет контекстный узел, если он является текстовым узлом;

□ self::node() — выберет контекстный узел вне зависимости от его типа;

□ self::query — выберет контекстный узел, если он является элементом с именем query, и пустое множество, если контекстный узел имеет другое имя или не является элементом;

□ preceding::para — выберет все элементы para, которые предшествуют контекстному узлу в порядке просмотра документа;

□ preceding::comment() — выберет все узлы комментариев, которые предшествуют контекстному узлу в порядке просмотра документа;

□ preceding-sibling::* — выберет все братские (принадлежащие тому же родителю) элементы контекстного узла, которые предшествуют ему в порядке просмотра документа;

□ following::processing-instruction('fop') — выберет все узлы инструкций по обработке, которые имеют имя (целевое приложение) "fop" и следуют за контекстным узлом в порядке просмотра документа;

□ following-sibling::text() — выберет все текстовые узлы, которые являются братьями контекстного узла и следуют за ним в порядке просмотра документа;

□ descendant::* — выберет все элементы-потомки контекстного узла;

□ descendant::node() — выберет все узлы-потомки контекстного узла;

□ descendant::b — выберет все элементы b, являющиеся потомками контекстного узла;

□ descendant-or-self::* — выберет все элементы-потомки контекстного узла, а также сам контекстный узел, если он также является элементом;

□ ancestor::* — выберет все элементы, которые являются предками контекстного узла; выбранное множество не будет включать корневой узел, поскольку он не является элементом;

□ ancestor::node() — выберет все узлы, являющиеся предками контекстного узла; выбранное множество будет включать корневой узел (за исключением того случая, когда контекстный узел сам является корневым);

□ ancestor::p — выберет все элементы p, являющиеся предками контекстного узла;

□ ancestor-or-self::node() — выберет контекстный узел, а также все узлы, являющиеся его предками. Выбранное этим шагом множество будет всегда включать корневой узел;

□ ancestor-or-self::body — выберет все элементы body, которые являются предками контекстного узла, а также сам контекстный узел, если он является элементом body;

□ namespace::* — выберет все узлы пространств имен, ассоциированные с контекстным узлом; это множество будет, как минимум, содержать узел пространства имен xml;

□ namespace::xyz — выберет узел пространства имен, определяемого префиксом xyz; поскольку один префикс может соответствовать только одному пространству, возвращаемое множество будет содержать не более одного узла.

Шаги выборки с предикатами:

□ child::*[1] — выберет первый дочерний элемент контекстного узла; этот шаг выборки равносилен child::*[position()=1];

□ child::p[1] — выберет первый дочерний элемент p контекстного узла; этот шаг выборки равносилен child::p[position()=1];

□ child::*[last()] — выберет последний дочерний узел контекстного узла; этот шаг выборки равносилен child::*[position()=last()];

□ child::*[last()-1] — выберет предпоследний дочерний узел контекстного узла; этот шаг выборки равносилен шагу child::*[position()=last()]. Если контекстный узел имеет только один дочерний элемент, выбираемое множество будет пустым;

□ child::p[position() mod 2 = 0] — выберет все четные элементы p;

□ child::p[position() mod 2 = 1] — выберет все нечетные элементы p;

□ child::а[2][attribute::name='b'] — Выберет второй дочерний элемент а контекстного узла, если он имеет атрибут name со значением "b";

□ child::a[attribute::name='b'][2] — выберет второй дочерний элемент а контекстного узла из тех, которые имеют атрибут name со значением "b"; этот шаг выборки отличается от шага выборки в предыдущем примере — порядок следования предикатов имеет значение;

□ child::a[position()=$i] — выберет дочерний элемент а, позиция которого равна значению переменной i;

□ parent::*['root'] — выберет родительский узел контекстного узла, если он является элементом; если он является корнем документа, этот шаг выборки не выберет ничего; предикат ['root'] не имеет никакого действия, поскольку строка 'root' как непустая строка тождественно преобразуется в истину;

□ preceding-sibling::*[attribute::*] — выберет все братские узлы контекстного узла, которые предшествуют ему, являются элементами и содержат, по крайней мере, один атрибут;

□ preceding-sibling:p[1] — выберет ближайший (первый в обратном порядке просмотра) элемент p, который предшествует контекстному узлу;

□ following::а[attribute::href][not(descendant::img)] — выберет все узлы, которые следуют за контекстным в порядке просмотра документа, являются элементами с именем а, имеют атрибут href, но не имеют элементов-потомков с именем img;

□ ancestor::node()[2] — выберет второго предка (то есть "деда") контекстного узла;

□ descendant-or-self::a[attribute::href] — выберет контекстный узел, а также все узлы-потомки контекстного узла, если они являются элементами с именем а и имеют атрибут href;

□ namespace::*[contains(self::node(), 'XML')] — выберет узлы пространств имен, которые ассоциируются с контекстным узлом, и строковое значение (URI) которых содержит подстроку 'XML'.

Использование сокращенного синтаксиса в шагах выборки:

□ table — выберет все дочерние элементы table контекстного узла; этот шаг выборки равносилен child::table;

□ @* — выберет все атрибуты контекстного узла; полная версия этого шага выборки выглядит как attribute::*;

□ *[i] — выберет первый дочерний элемент контекстного узла; этот шаг выборки равносилен шагу child::*[position()=1];

□ *[last()] — выберет последний дочерний узел контекстного узла; этот шаг выборки равносилен шагу child::*[position()=last()];

□ descendant-or-self::a[@href] — выберет контекстный узел, а также все узлы-потомки контекстного узла, если они являются элементами с именем а и имеют атрибут href; этот шаг выборки эквивалентен шагу descendant-or-self::a[attribute::href]; еще короче его можно записать как .//a[@href];

□ following::a[@href][not(@target)] — выберет все узлы, которые следуют в порядке просмотра документа за контекстным узлом, являются элементами с именем а, имеют атрибут href, но не имеют атрибута target; этот шаг эквивалентен шагу following::a[attribute::href][not(attribute::target)];

□ .. — выберет родительский узел контекстного узла; этот шаг выборки эквивалентен шагу parent::node();

□ namespace::*[contains(., 'XML')] — выберет узлы пространств имен, которые ассоциируются с контекстным узлом, и строковое значение (URI) которых содержит подстроку 'XML'. Этот шаг выборки эквивалентен шагу namespace::*[contains(self::node(), 'XML')];

□ preceding-sibling::*[@*] — выберет все братские узлы контекстного узла, которые предшествуют ему, являются элементами и содержат, по крайней мере, один атрибут;

□ *[not(self::para)] — выберет все дочерние элементы контекстного узла, кроме элементов para;

□ *[para or chapter] — выберет все дочерние элементы контекстного узла, которые имеют хотя бы один дочерний элемент para или chapter;

□ *[para and chapter] — выберет все дочерние элементы контекстного узла, которые имеют хотя бы один дочерний элемент para и хотя бы один дочерний элемент chapter;

□ *[para][chapter] — выберет все дочерние элементы контекстного узла, которые имеют хотя бы один дочерний элемент para и хотя бы один дочерний элемент chapter; этот шаг выборки равносилен *[para and chapter], однако в общем случае это неверно;

□ *[* or @*] — выберет все дочерние элементы, содержащие атрибуты или элементы;

□ *[not(* or @*)] — выберет все дочерние элементы, не содержащие ни атрибутов, ни элементов;

□ *[@name or @href] — выберет все дочерние элементы контекстного узла, имеющие хотя бы один из атрибутов name или href;

□ @*[count(.|../@href) != count(../@href)] — выберет все атрибуты контекстного узла, кроме атрибутов href;

□ [local-name() != 'href'] — выберет все атрибуты контекстного узла, кроме атрибутов href; это выражение практически аналогично предыдущему (за тем исключением, что в этом способе не учитываются пространства имен).

Примеры путей выборки:

□ / — выберет корневой узел документа;

□ /* — выберет элемент, находящийся в корне документа (элемент документа);

□ ancestor::body/a — выберет все элементы а, принадлежащие всем предкам-элементам body контекстного узла;

□ /ancestor::body/a — выберет все элементы а, принадлежащие всем предкам-элементам body корневого узла (это будет пустое множество);

□ //ancestor::body/a — выберет все элементы а, принадлежащие всем предкам-элементам body корневого узла и потомков корневого узла; иными словами, путь //ancestor::body выбирает элементы body, являющиеся предками каких-либо узлов документа, шаг a — дочерние узлы этих элементов; это выражение равносильно выражению //body[node()]/a;

□ preceding::а/@b — выберет атрибуты b элементов а, предшествующих контекстному узлу;

□ /doc/chapter — выберет элементы chapter, принадлежащие элементам doc, которые находятся в корне документа;

□ //doc/chapter — выберет элементы chapter, которые находятся в любом элементе doc документа;

□ doc/chapter — выберет элементы chapter, которые находятся в дочерних элементах doc контекстного узла;

□ self::node()[ancestor::body[1]] — выберет множество, состоящее из контекстного узла, если во множестве его предков body есть первый элемент (иначе — пустое множество); это выражение равносильно выражению self::node()[ancestor::body], поскольку если ancestor::body — непустое множество, то у него будет первый элемент;

□ *[contains(name(), 'ody')]/*[contains(name(),'able')] — выберет множество элементов, в имени которых присутствует строка "able" при условии, что они принадлежат дочерним элементам контекстного узла, в имени которых присутствует строка "ody";

□ *[last()]/preceding-sibling::*[2] — выберет второй с конца дочерний элемент контекстного узла. Это выражение равносильно *[last()-2];

□ */@* — выберет все атрибуты всех дочерних элементов контекстного узла;

□ //* [local-name(.) = 'body'] — выберет все элементы body текущего документа вне зависимости от их пространств имен.

Паттерны

В языке XSLT определяется подмножество выражений языка XPath, которые называются паттернами (от англ. pattern — образец). Паттерны представляют собой упрощенные пути выборки, которые используются для определения, соответствует ли узел заданному образцу.

Чаще всего паттерны применяются в элементе xsl:template в атрибуте match. Шаблоны такого типа будут выполняться только для тех узлов, которые удовлетворяют заданному образцу. Например, следующий шаблон будет выполняться только для элементов body, принадлежащих элементу html:

<xsl:template match="html/body">

 ...

</xsl:template>

Кроме этого, паттерны применяются при нумерации и при определениях ключей.

Паттерны являются сильно упрощенными путями выборки. Единственные оси, которые могут использоваться в паттернах, — это child, attribute и descendant-or-self, причем ось навигации descendant-or-self может быть указана только в сокращенном виде оператором "//". То, что в паттернах используются только оси атрибутов и узлов-потомков, позволяет XSLT-процессорам значительно оптимизировать процесс сопоставления узла заданному образцу — ведь теперь даже в самом худшем сценарии не нужно метаться по всему документу, выбирая узлы, содержащиеся в тех или иных осях навигации. Правда, оператор "//" остается не менее опасным — при его проверке может понадобиться перебрать всех предков текущего узла, что может быть весьма и весьма затруднительно (хотя и проще, чем перебор всех потомков).

Хоть паттерны и выглядят как пути выборки, на самом деле механизм их работы несколько иной. Они не выбирают множество узлов, как таковое, они проверяют узлы на соответствие образцу, который они определяют. Это в принципе эквивалентно выбору множества и проверке узла на вхождение в него, но, как правило, так не делается, поскольку такая проверка потребовала бы слишком больших затрат времени. Гораздо дешевле в этом смысле воспользоваться тем фактом, что синтаксис паттернов упрощен, и осей не так много для того, чтобы создать более эффективный алгоритм проверки соответствия узлов. Например, для того чтобы проверить соответствие некоторого узла, назовем его X, паттерну body/a, совершенно необязательно вычислять путь выборки body/a и затем проверять, входит ли узел X в полученное множество. Достаточно проверить, является ли именем узла "a", а именем его родителя (если он, конечно, есть) — "body".

Образцы для сравнения могут состоять из одного или нескольких паттернов, которые перечисляются через знак "|". Для того чтобы соответствовать такому перечислению в целом, узел должен соответствовать хотя бы одному из паттернов, входящих в него. Здесь тоже есть определенная аналогия с множествами, оператор "|" означает как бы объединение: узел входит в объединение множеств, если он входит хотя бы в одно из объединяемых множеств. Но, конечно же, и здесь упрощенный синтаксис играет свою роль для оптимизации — оперировать множествами, выбираемыми каждым из паттернов, было бы очень неэкономно.

Паттерны и их продукции описываются в спецификации самого языка XSLT, но мы приводим их в той же главе, что и выражения языка XPath, поскольку они очень похожи и имеют к тому же практические одинаковые семантические принципы. Паттерны используют также некоторые продукции языка XPath (такие, как NodeTest, Predicate и другие).

При нумерации EBNF-продукций паттернов мы будем нумеровать их с префиксом PT ([PT1], [PT2] и т.д.), чтобы не путать с продукциями других языков, рассматриваемых в этой книге.

Самая общая продукция паттерна называется Pattern и показывает, что образец соответствия может быть как одиночным паттерном, так и перечислением нескольких паттернов с разделяющими символами "|". Продукция LocationPathPattern соответствует одиночному паттерну, показывая своим названием (англ. location path pattern — образец пути выборки) конструкционную близость к самим путям выборки.

[PT1] Pattern ::= LocationPathPattern

                  | Pattern '|' LocationPathPattern

Одиночный паттерн определяется следующим образом:

[PT2] LocationPathPattern

 ::= '/' RelativePathPattern?

     | IdKeyPattern (('/' | '//') RelativePathPattern)?

     | '//'? RelativePathPattern

Упростив эту продукцию, мы получим следующее правило:

LocationPathPattern ::= '/'

                        | RelativePathPattern

                        | '/' RelativePathPattern

                        | '//' RelativePathPattern

                        | IdKeyPattern

                        | IdKeyPattern '/' RelativePathPattern

                        | IdKeyPattern '//' RelativePathPattern

Если учесть, что нетерминал RelativePathPattern соответствует образцу относительного пути, можно легко заметить, как похожи первые четыре возможности в этом правиле на то, что мы разбирали при описании самих абсолютных и относительных путей.

□ Паттерну '/' соответствует только корневой узел.

□ Паттерн RelativePathPattern задает образец относительного пути. Например, паттерну a/b соответствуют элементы b, находящиеся в элементах a.

□ Паттерну '/' RelativePathPattern соответствуют узлы, которые соответствуют образцу относительного пути при отсчете от корневого узла. Например, паттерну /a/b соответствуют элементы b, находящиеся в элементах a, находящихся в корне документа.

□ Паттерну '//' RelativePathPattern соответствуют узлы, которые соответствуют относительному пути при отсчете от любого узла документа. Например, паттерну //a/b соответствуют любые элементы b, имеющие родителем элемент с именем а. Фактически, этот паттерн не отличается от паттерна a/b (единственное различие в том, что они могут иметь разные приоритеты).

Последние три случая в правиле LocationPathPattern относятся к таким механизмам XSLT, как адресация по уникальным идентификаторам и ключам.

В первой главе книги, когда мы описывали синтаксис и семантику языка разметки документов XML, мы коротко остановились на уникальных атрибутах — атрибутах, которые определяются типом ID и значения которых должны быть уникальны внутри документа. Как мы узнали, это позволяет более эффективно обращаться к элементам в документе.

XSLT позволяет использовать уникальные атрибуты элементов при помощи функции id, которая возвращает множество, состоящее из узла, уникальный атрибут которого равен переданному ей значению, или пустое множество, если такого элемента нет.

Кроме того, XSLT предоставляет похожий механизм, механизм ключей, который выбирает узлы не по уникальным атрибутам, а по значениям именованных ключей, определенных в преобразовании. Для этого служит функция key.

Поскольку два этих механизма схожи по семантике, они определяются в XSLT в едином паттерне:

[PT3] IdKeyPattern ::= 'id' '(' Literal ')'

                       | 'key' '(' Literal ',' Literal ')'

Этому паттерну соответствуют только узлы, принадлежащие результату одной из двух функций — id или key.

Оставим детали использования ключей и ID-атрибутов на потом и вернемся к разбору вариантов синтаксиса паттернов.

□ Паттерну IdKeyPattern '/' RelativePathPattern соответствуют узлы, которые соответствуют образцу пути RelativePathPattern отсчитанного относительного узла, соответствующего IdKeyPattern. Например, узел соответствует паттерну id('index5')/a/b, если он является элементом с именем b, его родителем является элемент а, а его родитель в свою очередь имеет уникальный атрибут со значением "index5".

□ Паттерн IdKeyPattern '//' RelativePathPattern аналогичен предыдущему: ему соответствуют узлы, которые соответствуют паттерну RelativePathPattern, отсчитанному от любого потомка или самого узла, входящего в IdKeyPattern. Например, паттерну id('index5')//a/b будет соответствовать любой дочерний элемент b элемента a, являющегося потомком элемента, уникальный атрибут которого имеет значение index5, или если он сам имеет такой атрибут.

Мы более подробно остановимся на ключевых паттернах, когда будем разбирать функции id и key, а пока обратимся к главной детали всех вышеперечисленных продукций — к образцу относительного пути, RelativePathPattern. Его продукция записывается в следующем виде:

[PT4] RelativePathPattern

 ::= StepPattern

     | RelativePathPattern '/' StepPattern

     | RelativePathPattern '//' StepPattern

Если сравнить это правило с упрощенной продукцией RelativeLocationPath, можно заметить совпадение с точностью до имен продукций. Образец относительного пути строится точно так же, как и обычный путь выборки — перечислением через разделяющие символы "/" и "//" шагов, в данном случае — шагов образца относительного пути.

Эти шаги соответствуют продукции StepPattern, которая отличается от продукции Step только тем, что разрешает использовать только оси child и attribute.

[PT5] StepPattern ::= ChildOrAttributeAxisSpecifier NodeTest

                      Predicate*

Продукция ChildOrAxisSpecifier описывает дескрипторы осей child и attribute в полном или сокращенном виде:

[P6] ChildOrAttributeAxisSpecifier

 ::= AbbreviatedAxisSpecifier

     | ('child' | 'attribute') '::'

Для простоты мы можем раскрыть эту продукцию, получив ее в следующем виде:

ChildOrAttributeAxisSpecifier

 ::= '@' ?

     | 'child::'

     | 'attribute::'

Тогда продукцию StepPattern тоже можно переписать:

StepPattern ::= NodeTest Predicate*

                | '@' NodeTest Predicate*

                | 'child::' NodeTest Predicate*

                | 'attribute::' NodeTest Predicate*

Теперь стало совершенно очевидно, что шаг паттерна это не что иное, как подмножество шагов выборки, в которых ограничено множество осей навигации.

Таким образом, синтаксически паттерны отличаются от путей выборки тем, что в них можно использовать только две оси навигации (не считая descendant-or-self в виде оператора), но зато можно в качестве узла отсчета использовать узел, выбранный по своему уникальному атрибуту или по значению ключа.

Паттерны могут использоваться в XSLT в следующих атрибутах:

□ атрибуты count и from элемента xsl:number;

□ атрибут match элемента xsl:key;

□ атрибут match элемента xsl:template.

Последние два случая паттернов отличаются от первого тем, что в них нельзя использовать переменные. Определение вида

<xsl:template match="*[name() = $name]">

 ...

</xsl:template>

будет некорректным.

Семантика паттернов

Остановимся подробнее на вопросе — что же означает "соответствие узла некоторому паттерну".

Прежде всего, заметим, что любой паттерн является также и XPath-выражением. Тогда строгое определение соответствия узла паттерну можно дать следующим образом.

Узел X соответствует паттерну P тогда и только тогда, когда существует такой узел Y, принадлежащий оси ancestor-or-self узла X, что множество, получаемое в результате вычисления выражения P в контексте узла Y будет содержать узел X.

Пример

Рассмотрим это определение на примере паттерна body//а. Строго говоря, узел будет соответствовать этому паттерну, если во множестве его предков (плюс сам узел) найдется такой узел, что множество body//а, вычисленное в его контексте, будет содержать проверяемый узел. На практике первые два элемента а приведенного ниже документа соответствуют этому паттерну, потому что существует элемент html, содержащий элемент body, потомками которого эти элементы а являются.

Листинг 6.2

<html>

 <body>

  <a>

   <!-- Соответствует паттерну body//a -->

  </a>

  <p>

   <a>

    <!-- Соответствует паттерну body//a -->

   </a>

  </p>

 </body>

 <а>

  <!-- Не соответствует паттерну body//а -->

 </а>

</html>

Существует также и более простое определение соответствия. Узел X соответствует паттерну P тогда и только тогда, когда X принадлежит множеству //P. В приведенном выше примере паттерну body//а соответствуют все узлы множества //body//а.

Эти определения эквивалентны. На практике следует пользоваться тем, которое кажется более понятным.

Примеры паттернов

□ body — соответствует элементам body с нулевым пространством имен;

□ xhtml:body — соответствует элементам body, принадлежащим пространству имен с префиксом xhtml;

□ body/a — соответствует дочерним элементам а элемента body;

□ * — соответствует любому элементу, который принадлежит нулевому пространству имен;

□ а[1] — соответствует каждому первому элементу а своего родительского узла; элемент будет соответствовать этому паттерну, если ему не предшествует никакой братский элемент a — то есть из всех дочерних элементов а некоторого узла этому паттерну будет соответствовать только первый в порядке просмотра документа элемент;

□ a[position() mod 2 = 0] — соответствует каждому четному элементу a своего родительского узла; иначе говоря, из всех элементов а некоторого узла этому паттерну будут соответствовать только четные;

□ / — соответствует корневому узлу;

□ /html — узел будет соответствовать этому паттерну тогда и только тогда, когда он является элементом с именем html и нулевым пространством имен и находится при этом в корне элемента;

□ //html — соответствует любому элементу html документа, принадлежащему нулевому пространству имен; этот паттерн равносилен паттерну html;

□ *[starts-with(local-name(), 'A') or starts-with(local-name(), 'a')] — соответствует любому элементу, имя которого начинается на букву "а" в любом регистре символов;

□ *[string-length(local-name())=2] — соответствует любому элементу, локальная часть имени которого состоит из двух символов;

□ *[starts-with(namespace-uri(),'http') or starts-with(namespace-uri(), 'HTTP')] — соответствует любому элементу, URI пространства имен которого начинается на "http" или "HTTP";

□ br[not(*)] — соответствует элементу br, который не имеет дочерних элементов;

□ id('i') — соответствует элементу, уникальный атрибут которого (атрибут, имеющий тип ID) равен "i";

□ id('i')/@id — соответствует атрибуту id элемента, уникальный атрибут которого равен "i"; заметим, что уникальный атрибут элемента вовсе не обязательно должен иметь имя id;

□ key('name', 'html')/@href — соответствует атрибуту href узла, значение ключа с именем "name" которого равно "html";

□ *|@* — соответствует любому элементу или атрибуту;

□ a|b|с — соответствует элементам а, b и с;

□ node() — соответствует любому узлу, кроме узла атрибута и пространства имен (поскольку они не являются дочерними узлами своих родителей);

□ node() | attribute::* | namespace::* — соответствует любому узлу, включая узлы атрибутов и пространств имен;

□ node()[not(self::text())] — соответствует любому узлу, кроме текстового узла, узла атрибута и узла пространства имен.

Выражения

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

Выражениям языка соответствует нетерминал Expr. И хотя синтаксическое правило, определяющее этот нетерминал, записывается очень просто, в данный момент оно нам абсолютно ничего не скажет.

Базовая конструкция, использующаяся в выражениях, называется первичным выражением (от англ. primary expression). Первичные выражения могут быть переменными, литералами, числами, вызовами функций, а также обычными выражениями Expr, сгруппированными в круглых скобках:

[XP15] PrimaryExpr ::= VariableReference

                       | '(' Expr ')'

                       | Literal

                       | Number

                       | FunctionCall

Переменные

Переменные вызываются в выражениях XPath по своему имени, которому предшествует символ "$". Например, если мы объявили переменную nodes:

<xsl:variable name="nodes" select="a/b"/>

то использовать в выражениях мы ее будем как $nodes.

Переменные, так же как элементы и атрибуты XML, могут иметь расширенные имена вида QName, состоящие из префикса пространства имен и локальной части имени. Это позволяет создавать переменные, принадлежащие различным пространствам имен.

Пример

Мы можем определить две переменные с одинаковыми локальными частями имен в разных пространствах, используя при определении имени префикс. Естественно, префикс должен быть заранее связан с URI пространства имен.

<xsl:stylesheet

 version="1.0"

 xmlns:xsl="http://www.w3.org/1999/XSL/Transform"

 xmlns:a="uri:a"

 xmlns:b="uri:b">

 <xsl:variable name="a:elementcount" select="count(//a:*)"/>

 <xsl:variable name="b:elementcount" select="count(//b:*)"/>

 ...

</xsl:stylesheet>

В этом преобразовании количество элементов документа, принадлежащих пространству имен а, будет содержаться в переменной a:elementcount, а пространству имен b — в переменной b:elementcount.

Отсутствие префикса в XPath-выражениях не означает, что следует использовать префикс по умолчанию. Отсутствие префикса означает, что префикс является нулевым со всеми вытекающими последствиями. Например, если шаблон

<xsl:template match="counts">

 <xsl:value-of select="$a:elementcount"/>

 <xsl:text> </xsl:text>

 <xsl:value-of select="$b:elementcount"/>

</xsl:template>

будет корректен, в шаблоне

<xsl:template match="counts" xmlns="uri:a">

 <xsl:value-of select="$elementcount"/>

 <xsl:text> </xsl:text>

 <xsl:value-of select="$b:elementcount"/>

</xsl:template>

процессор не сможет найти объявление переменной $elementcount, потому что расширенное имя объявленной переменной состоит из URI пространства имен "uri:а" и локальной части имени elementcount, а расширенное имя переменной elementcount состоит из нулевого URI и локальной части elementcount. Иными словами, эти переменные принадлежат разным пространствам.

Операции с булевыми значениями

XPath поддерживает только две логические операции — and (логическое "и") и or (логическое "или"). В XPath нет оператора логического отрицания, вместо него применяется функция not, которая возвращает "истину", если аргументом была "ложь" и наоборот.

Логические операторы в XPath бинарны, то есть требуют два операнда булевого типа. Если операнды имеют другой тип, то они будут приведены к булевым значениям.

Логические вычисления в XPath абсолютно стандартны. Мы приведем их для справки в табл. 6.2.

Таблица 6.2. Вычисление логических выражений

Значение		Выражение
A	B	A or В	A and В
false	false	false	false
false	true	true	false
true	false	true	false
true	true	true	true

Как и во многих других языках, операция "и" (and) старше операции "или" (or). Например, такое выражение, как A and B or C and D or E эквивалентно выражению (A and В) or (С and D) or E.

Приведем синтаксические правила продукций логических операций XPath. Операции "или" соответствует продукция OrExpr, операции "и" — продукция AndExpr.

[XP21] OrExpr  ::= AndExpr | OrExpr 'or' AndExpr

[XP22] AndExpr ::= EqualityExpr | AndExpr 'and' EqualityExpr

Операции с числами

Перечень арифметических операций в XPath довольно ограничен. К ним относится сложение, вычитание, умножение, деление и унарная операция отрицания, которая меняет значение операнда на противоположное. Кроме того, числа можно сравнивать при помощи операторов сравнения.

Арифметические операции

Арифметические операции XPath сведены в табл. 6.3.

Таблица 6.3. Арифметические операции в XPath-выражениях

Операция	Синтаксис
Сложение	A + B
Вычитание	A - B
Умножение	A * B
Деление	A div B
Остаток деления	A mod B
Унарное отрицание	- A

Если операнды, значения, участвующие в операции, не являются числами, они сначала приводятся к этому типу, а уж затем производится операция. Например, можно легко перемножать литералы:

'2' * '2' → 4

Арифметические действия в XPath работают, что называется, "как обычно", то есть совершенно стандартным образом. Арифметика XPath основывается на стандарте IEEE 754, который был использован и в других распространенных языках программирования, например в Java. Пожалуй, следует лишь обратить внимание на операторы деления, поскольку в разных языках они означают разные действия и потому легко запутаться.

Оператор div делит свой первый операнд на второй. Это не целочисленное деление, как в некоторых других языках, div осуществляет деление чисел с плавающей точкой. Оператор div аналогичен оператору деления "/" в таких языках, как Java, С++ и Pascal.

Примеры:

3.2 div 2.5 → 1.28

3.2 div -2.5 → -1.28

-3.2 div -2.5 → 1.28

Оператор mod возвращает остаток деления первого своего оператора на второй. Поскольку в разных языках остаток деления вычисляется по-разному, легче всего будет пояснить его функционирование в XPath на примере:

3.2 mod 2 → 1.2

3.2 mod -2 → 1.2

-3.2 mod 2 → -1.2

-3.2 mod -2 → -1.2

Оператор mod аналогичен оператору "%" в таких языках, как Java и ECMAScript.

Результат остатка от деления имеет тот же знак, что и делимое. Этот факт можно использовать для того, чтобы выполнять деление без остатка, например число A можно нацело разделить на число B выражением (A - (A mod B)) div B.

Пример:

(3.2 - (3.2 mod 2)) div 2 → 1

Во избежание ошибок следует аккуратно использовать знак вычитания в арифметических операциях. Дело в том, что синтаксис XML разрешает использовать символ "-" в именах элементов, которые в свою очередь также могут быть использованы в выражениях в составе путей выборки. Например, A - B означает разность A и B, в то время как A-B будет воспринято, как имя 'A-B'. Поэтому рекомендуется выделять знак минуса пробелами.

Приведем продукции выражений с арифметическими операциями.

Унарному отрицанию соответствует продукция UnaryExpr. Как можно видеть, в текущей версии языка это — единственная унарная операция (то есть операция одного элемента).

[XP27] UnaryExpr ::= UnionExpr | '-' UnaryExpr

Попробуем упростить это правило, раскрыв рекурсию

UnaryExpr ::= '-' * UnionExpr

Таким образом, унарное отрицание можно повторять несколько раз:

------5 → 5

Умножению, делению и вычислению остатка деления соответствует одна продукция MultiplicativeExpr:

[XP26] MultiplicativeExpr ::= UnaryExpr

                              | MultiplicativeExpr MultiplyOperator UnaryExpr

                              | MultiplicativeExpr 'div' UnaryExpr

                              | MultiplicativeExpr 'mod' UnaryExpr

Оператор умножения вынесен в отдельное правило:

[XP34] MultiplyOperator ::= '*'

Сложению и вычитанию соответствует правило AdditiveExpr:

[XP25] AdditiveExpr ::= MultiplicativeExpr

                        | AdditiveExpr '+' MultiplicativeExpr

                        | AdditiveExpr '-' MultiplicativeExpr

Операции сравнения

XPath позволяет сравнивать числа при помощи операторов, перечисленных в табл. 6.4.

Таблица 6.4. Операторы сравнения

Оператор	Значение
=	Равно
!=	Не равно
<	Меньше
>	Больше
<=	Меньше или равно (не больше)
>=	Больше или равно (не меньше)

XPath-выражения чаще всего используются в значениях атрибутов, символ "<" в которых в соответствии с синтаксисом XML использовать нельзя. Поэтому операторы сравнения "меньше" ("<") и "не больше" ("<=") нужно записывать с использованием сущностей. Оператор "меньше" может быть записан как "<;", а оператор "не больше" как "<=".

Пример

Результатом обработки элемента

<xsl:value-of select="1<2"/>

будет строка "true".

Сравнение всегда требует наличия двух операндов числового типа. Если операнды не являются числами, они будут соответствующим образом преобразованы.

В XPath вполне корректным будет выражение вида A > B > C. Однако результат его будет довольно неожиданным. В XPath действует правило левой ассоциативности операторов сравнения, поэтому A > B > C будет равносильно (А > B) > C. То есть A будет сравнено с B, затем результат, истина или ложь, будет преобразован в числовой тип (получится 1 или 0) и затем сравнен со значением C.

Пример:

3 > 2 > 1 → (3 > 2) > 1 → 1 > 1 → false

3 > 2 > 0 → (3 > 2) > 0 → 1 > 0 → true

Неравенствам в XPath соответствует продукция RelationalExpr:

[XP24] RelationalExpr ::= AdditiveExpr

                          | RelationalExpr '<' AdditiveExpr

                          | RelationalExpr '>' AdditiveExpr

                          | RelationalExpr '<=' AdditiveExpr

                          | RelationalExpr '>=' AdditiveExpr

Операции "равно" и "не равно" записываются при помощи продукции

EqualityExpr:

[XP23] EqualityExpr ::= RelationalExpr

                        | EqualityExpr '=' RelationalExpr

                        | EqualityExpr '!=' RelationalExpr

Операции с множествами узлов

Три основные операции с множествами узлов, которые поддерживает язык XPath, — это фильтрация множества, выборка с использованием путей и объединение.

Фильтрация

Множества узлов, которые получаются в результате вычисления выражений, можно фильтровать — то есть выбирать из них узлы, удовлетворяющие заданным свойствам подобно тому, как это делалось предикатами в шагах выборки.

В выражениях множества узлов могут также фильтроваться одним или несколькими предикатами. Узел остается в фильтруемом множестве, только если он удовлетворяет всем предикатам поочередно.

Пример

Предположим, что нам нужно оставить в фильтруемом множестве узлов, которое присвоено переменной nodes, только те узлы, которые имеют имя а и атрибут href. Искомое выражение может быть записано следующим образом:

$nodes[self::а][@href]

Можно использовать и более сложные конструкции, например, фильтровать объединение двух множеств — присвоенного переменной nodes и возвращаемого путем выборки body/*:

($nodes|body/*)[self::a][@href]

Выражение, в котором производится фильтрация узлов, отвечает EBNF-правилу FilterExpr:

[XP20] FilterExpr ::= PrimaryExpr | FilterExpr Predicate

Если раскрыть рекурсию, которая имеется в этом правиле, его можно переписать в более простом виде:

FilterExpr ::= PrimaryExpr Predicate*

Выражение PrimaryExpr, которое используется в этой продукции, должно обязательным образом возвращать множество узлов. В противном случае процессор выдаст ошибку, потому что никакой другой тип не может быть преобразован во множество узлов.

Использование в выражениях путей выборки

Помимо того, что выражение само по себе может быть путем выборки, относительные пути можно комбинировать с другими выражениями. Например, можно выбрать все дочерние элементы узлов множества, содержащегося в переменной

$nodes/*

Для разделения шагов выборки в фильтрующих выражениях можно использовать операторы "/" и "//". Например, для того, чтобы получить всех потомков узлов из множества, присвоенного переменной, можно использовать выражение вида

$nodes//node()

Здесь node() — это тест узла, выполняющийся для всех типов узлов, а //, как и обычно, сокращение от /descendant-or-self:node()/.

Выражения, которые используют пути выборки, соответствуют продукции PathExpr:

[XP19] PathExpr ::= LocationPath

                    | FilterExpr

                    | FilterExpr '/' RelativeLocationPath

                    | FilterExpr '//' RelativeLocationPath

Объединение множеств

Множества могут быть объединены при помощи оператора "|". В объединение будут входить узлы, которые присутствуют хотя бы в одном из множеств, причем результат не содержит повторений. Объединять можно любые выражения, результатом вычисления которых являются множества узлов.

Пример

Множество всех элементов а, b и с документа может быть задано выражением //a|//b|//c.

Выражению объединения соответствует продукция UnionExpr:

[XP18] UnionExpr ::= PathExpr | UnionExpr '|' PathExpr

Старшинство операций

Теперь, когда мы изучили все типы операций XPath, можно дать синтаксическое определение выражению и выстроить все операции в порядке старшинства.

Выражению, как самой общей конструкции XPath, соответствует продукция Expr, которая определяется следующим образом:

[XP14] Expr ::= OrExpr

То есть, фактически, выражение в XPath определяется через логическое выражение. Естественно, выражения не обязаны быть логическими. Просто в иерархии синтаксических правил логическое выражение "или" находится выше всего. Верхние правила определяются через более примитивные правила и так далее. В итоге иерархия выражений выстраивается следующим образом (в скобках приведены названия EBNF-правил):

□ выражения (Expr);

□ логические выражения "или" (OrExpr);

□ логические выражения "и" (AndExpr);

□ выражения равенства и неравенства (EqualityExpr);

□ выражения сравнения (RelationalExpr);

□ выражения сложения и вычитания (AdditiveExpr);

□ выражения умножения и деления (MultiplicativeExpr);

□ унарные выражения (UnaryExpr);

□ выражения объединения множеств (UnionExpr);

□ выражения путей выборки (PathExpr);

□ пути выборки (LocationPath), фильтрация множеств (FilterExpr), относительные пути выборки (RelativeLocationPath).

По этой схеме несложно выяснить старшинство операций — чем ниже выражение находится в этой иерархии, тем выше его приоритет. Для полной ясности, перечислим операции в порядке старшинства от старших, с большим приоритетом, к младшим, с меньшим приоритетом выполнения:

□ операции с путями выборки;

□ операция объединения множеств (|);

□ унарная операция отрицания (-);

□ умножение, деление и вычисление остатка от деления (*, div и mod);

□ операции сложения и вычитания (+ и -);

□ операции сравнения (<, >, <=, =>);

□ операции проверки равенства и неравенства (= и !=);

□ операция "и" (and);

□ операция "или" (or).

Операции одного порядка имеют левую ассоциативность, как это было показано на примере с операциями сравнения (3 > 2 > 1 равносильно (3 > 2) >1).

Функции

Кроме операций, которые обеспечивают примитивные базовые действия, в XPath можно использовать функции. Спецификация языка XPath определяет базовую библиотеку функций, которую должны поддерживать все XSLT-процессоры. В XSLT эта библиотека дополняется еще несколькими полезными функциями. Кроме этого, большинство процессоров реализуют механизм расширений, при помощи которого можно использовать в XSLT собственные функции.

В этой главе мы будем рассматривать только функции базовой библиотеки XPath. Функции, которые добавляются в XSLT, будут разбираться чуть позже, а функции-расширения и их создание вообще является достаточно сложной темой, вынесенной в отдельную главу.

Прежде, чем разбирать функции, рассмотрим синтаксис их вызова. Он описывается правилом FunctionCall:

[XP16] FunctionCall ::= FunctionName

                        '(' ( Argument ( ',' Argument )* )? ')'

Таким образом, вызов функции состоит из имени и перечисленных в круглых скобках аргументов, которых может в принципе и не быть. С точки зрения синтаксиса аргументом функции может быть любое выражение, однако на практике функции предъявляют к своим аргументам определенные требования. Мы будем записывать правила вызова той или иной функции прототипом вида

тип1 функция(тип2, тип3, тип4?)

где тип1 — тип возвращаемого значения, тип2, тип3, тип4 — типы передаваемых параметров, символ "?" обозначает аргумент, который может быть опущен. Также может быть использован символ * для обозначения аргумента, который может повторяться несколько раз. Например,

string concat(string, string, string*)

определяет функцию concat, которая возвращает строку, а на вход принимает два или более строковых параметра.

Аргументы функции отвечают EBNF-продукции Argument:

[XP17] Argument ::= Expr

Имя функции определяется синтаксическим правилом FunctionName. Функция может иметь любое корректное с точки зрения XML имя, кроме названий типов узлов (comment, processing-instruction, text и node):

[XP35] FunctionName ::= QName - NodeType

В базовой библиотеке XPath выделяют четыре типа функций: функции для работы с булевыми значениями, с числами, со строками и с множествами узлов.

Булевые функции Функция boolean

boolean boolean(object)

Функция boolean явным образом преобразует объект, который ей передается в булевый тип в соответствии с правилами, изложенными в главе "Типы данных XPath". Напомним вкратце эти правила.

□ Число преобразуется в "ложь", если оно является положительным или отрицательным нулем или не-числом (NaN). В противном случае число будет преобразовано в "истину".

□ Строка преобразуется в "ложь", если она не содержит символов, то есть, ее длина равна нулю. Непустая строка преобразуется в "истину".

□ Множество узлов преобразуется в "ложь", если оно пусто. Непустое множество узлов преобразуется в "истину".

□ Объекты других типов преобразуются в булевые значения по собственным правилам. Например, результирующий фрагмент дерева всегда преобразуется в "истину".

Примеры:

boolean(2-2) → false

boolean(number('two')) → false

boolean(-1) → true

boolean(1 div 0) → true

boolean(-1 div (1 div 0)) → false

boolean(-1 div (-1 div 0)) → false

boolean(-1 div (-1 div 0) +1) → true

boolean('') → false

boolean('true') → true

boolean('false') → true

boolean(/) → true

Это выражение всегда будет обращаться в true, поскольку у документа всегда есть корневой узел.

boolean(/self::node()) → true

Это выражение также обратится в true, поскольку корневой узел соответствует тесту node().

boolean(/self::text()) → false

Это выражение обратится в false, поскольку корневой узел не является текстовым узлом.

Функция not

boolean not(boolean)

Функция not выполняет логическое отрицание. Если аргументом была "истина", not возвращает "ложь", если аргумент был "ложью", not вернет"истину". Если функции был передан аргумент не булевого типа (например, число), то он сначала будет сконвертирован в тип boolean.

Примеры:

not(false) → true

not(true) → false

not('false') → false

not('true') → false

not(0) → true

not(/) → false

Функции true и false

boolean true()

boolean false()

Две функции true и false возвращают тождественную "истину" и тождественную "ложь" соответственно. В XPath нет констант и, тем более, логических констант, определяющих "истину" и "ложь", как в других языках. Функции true и false восполняют эту нехватку.

Примеры:

true() or $var → true

Это выражение всегда будет истинным вне зависимости от значения переменной var, поскольку дизъюнкция (логическая операция "или") с тождественной "истиной" всегда будет "истиной".

false() and $var → false

Это выражение всегда будет ложным вне зависимости от значения переменной var, поскольку конъюнкция (логическая операция "и") с тождественной "ложью" всегда будет "ложью".

Функция lang

boolean lang(string)

Функция lang может использоваться для того, чтобы определить языковой контекст контекстного узла. В элементах XML можно использовать атрибут lang пространства имен xml для определения языка содержимого узла, например;

<text xml:lang="en-gb">

Yet no living human being have been ever blessed with seeing...

</text>

Пространство имен, соответствующее префиксу xml, не требуется объявлять. Это служебное пространство имен, которое неявно задано во всех XML-документах.

Функция lang возвратит "истину", если идентификатор языка, который передан ей в виде строкового параметра, соответствует языковому контексту контекстного узла. Это определяется следующим образом.

□ Если ни один из предков контекстного узла не имеет атрибута xml:lang, функция возвращает "ложь".

□ Иначе строковый параметр проверяется на соответствие значению атрибута xml:lang ближайшего предка. Если эти значения равны в любом регистре символов, или атрибут начинается как значение параметра функции и имеет суффикс, начинающийся знаком "-", функция возвращает "истину".

□ В противном случае функция возвращает "ложь".

Примеры:

Функция lang('en') возвратит "истину" в контексте любого из следующих элементов:

<body xml:lang="EN"/>

<body xml:lang="en-GB"/>

<body xml:lang="en-us"/>

<body xml:lang="EN-US"/>

Функция lang('de') возвратит "истину" в контексте элемента b и "ложь" — в контексте элементов а и с:

<а>

 <b xml:lang="de">

  <c xml:lang="en"/>

 </b>

</a>

Числовые функции

Функция number

number number(object?)

Функция number явным образом конвертирует свой аргумент в числовой тип. Если аргумент не указан, функции передается множество узлов, состоящее из единственного контекстного узла. Коротко напомним правила преобразования в числовой тип.

□ Значения булевого типа преобразуются в 0 или 1 следующим образом: "ложь" преобразуется в 0, "истина" в 1.

□ Строковое значение преобразуется в число, которое оно представляет.

□ Множество узлов сначала преобразуется в строку, а затем, как строка в число. Фактически численным значением множества узлов является численное значение его первого узла.

□ Объекты других типов преобразуются в число в соответствии с собственными правилами. Например, результирующий фрагмент дерева так же как и множество узлов сначала преобразуется к строке, а затем в численный формат.

Примеры

number($to_be or not($to_be)) → 1

Значение этого выражения будет 1, поскольку $to_be or not($to_be) будет истинным вне зависимости от значения переменной to_be.

number(false()) → 0

number('00015.0001000') → 15.0001

number('.0001000') → 0.0001

number('1.') → 1

number('-.1') → -0.1

number('-5') → -5

Функция sum

number sum(node-set)

Функция sum суммирует значения узлов из переданного ей множества. Строковые значения узлов сначала преобразуются в числа, а затем все полученные числа складываются.

Пример

Листинг 6.3. Входящий документ

<list>

 <item>1</item>

 <item>3</item>

 <item>5</item>

</list>

Листинг 6.4. Преобразование

<xsl:stylesheet

 xmlns:xsl="http://www.w3.org/1999/XSL/Transform"

 version="1.0">

 <xsl:template match="list">

  <xsl:copy>

   <xsl:apply-templates/>

  </xsl:copy>

 </xsl:template>

 <xsl:template match="item">

  <sum>

   <xsl:value-of select="sum(preceding-sibling::item|.)"/>

  </sum>

 </xsl:template>

</xsl:stylesheet>

Листинг 6.5. Результат

<list>

 <sum>1</sum>

 <sum>4</sum>

 <sum>9</sum>

 <sum>16</sum>

 <sum>25</sum>

</list>

В этом преобразовании мы заменяем каждый элемент item на сумму значений предшествующих ему элементов плюс собственное значение. Предшествующие элементы выбираются путем выборки preceding-sibling::item, текущий элемент — сокращенным путем ".", затем эти два множества объединяются при помощи оператора |, и, наконец, мы вычисляем сумму значений узлов, входящих в них функцией sum.

Строковые значения суммируемых узлов преобразовываются в числовой формат так же, как они преобразовывались бы функцией number. Например, если входящий документ будет иметь вид

<list>

 <item>1</item>

 <item>3</item>

 <item>five</item>

 <item>7</item>

 <item>9</item>

</list>

то на выходе мы получим

<list>

 <sum>1</sum>

 <sum>4</sum>

 <sum>NaN</sum>

 <sum>NaN</sum>

 <sum>NaN</sum>

</list>

потому что, начиная с третьего элемента, в суммировании будет участвовать значение number('five'), то есть не-число (NaN).

Функции floor и ceiling

number floor(number)

number ceiling(number)

Функции floor и ceiling (англ. пол и потолок соответственно) осуществляют округление численного аргумента до ближайшего не большего и ближайшего не меньшего целого соответственно.

Примеры

floor(2.3) → 2

ceiling(2.3) → 3

floor(-2.3) → -3

ceiling(-2.3) → -2

floor(-1 div 0) → -Infinity

ceiling(-1 div 0) → -Infinity

floor('zero') → NaN

ceiling(-1 div (-1 div 0)) → 0

Функция round

number round(number)

Функция round округляет число до ближайшего целого значения. У этой функции есть несколько нюансов, которые мы сейчас разберем.

□ Если дробная часть числа равна 0.5, то функция вернет ближайшее большее целое.

□ Если аргумент является не-числом (NaN), то результат также будет NaN.

□ Если аргумент является положительной или отрицательной бесконечностью, то результатом будет тоже положительная или отрицательная бесконечность, то есть аргумент не изменится.

□ Если аргумент является положительным или отрицательным нулем, результатом будет также положительный или отрицательный нуль, то есть аргумент не изменится.

□ Если аргумент меньше нуля, но больше или равен — 0.5, результатом будет отрицательный нуль.

Примеры

round(2.5) → 3

round(2.49) → 2

round(-1.7) → -2

1 div round(0.5) → Infinity

1 div round(-0.5) → -Infinity

round(1 div 0) → Infinity

round('one') → NaN

Строковые функции

Функция string

string string(object?)

Подобно функциям boolean и number, функция string преобразует свой аргумент к строковому типу явным образом. Если аргумент опущен, функции передается множество узлов, состоящее из единственного контекстного узла.

Напомним вкратце правила приведения других типов к строке.

□ Булевые значения преобразуются в строку следующим образом:

 • "истина" (true) преобразуется в строку "true";

 • "ложь" (false) преобразуется в строку "false".

□ Числа преобразуются к строковому виду следующим образом:

 • не-число (NaN) преобразуется в строку "NaN";

 • положительный нуль преобразуется в строку "0";

 • отрицательный нуль преобразуется в строку "0";

 • положительная бесконечность преобразуется в строку "Infinity";

 • отрицательная бесконечность преобразуется в строку "-Infinity";

 • положительные целые преобразуются в свое десятичное представление без ведущих нулей и без точки ("."), отделяющей дробную часть от целой;

 • отрицательные целые преобразуются так же, как и положительные, но с начальным знаком "минус" ("-");

 • остальные числа преобразуются в десятичное представление с использованием точки ("."), отделяющей целую часть от дробной части; целая часть не содержит ведущих нулей (кроме случая с числами в интервале (-1;1)), дробная часть содержит столько цифр, сколько требуется для точного представления числа.

□ Множество узлов преобразуется в строковое значение своего первого в порядке просмотра документа узла. Если множество пусто, функция возвращает пустую строку.

□ Объекты других типов преобразуются в строку в соответствии с собственными правилами. Например, результирующий фрагмент дерева преобразуется в конкатенацию всех своих строковых узлов.

Примеры

string(boolean(0)) → false

string(number('zero')) → NaN

string(number('.50000')) →0.5

string(number(00500.)) → 500

Для строкового форматирования чисел рекомендуется использовать функцию XSLT format-number совместно с элементом xsl:decimal-format.

Функция concat

string concat(string, string, string*)

Функция concat принимает на вход две или более строки и возвращает конкатенацию (строковое сложение) своих аргументов.

Пример:

concat('not','with','standing',' problem') → 'notwithstanding problem'

Функция starts-with

boolean starts-with(string, string)

Функция starts-with принимает на вход два строковых аргумента и возвращает true, если первая строка начинается второй и false в противном случае.

starts-with('http://www.xsltdev.ru', 'http') → true

starts-with('Title', 'ti') → false

Функция contains

boolean contains(string, string)

Функция contains принимает на вход два строковых аргумента и возвращает true, если первая строка содержит вторую и false в противном случае.

contains('address@host.com', '(@') → true

Функция substring-before

string substring-before(string, string)

Функция substring-before принимает на вход два строковых аргумента. Эта функция находит в первой строке вторую и возвращает подстроку, которая ей предшествует. Если вторая строка не содержится в первой, функция вернет пустую строку.

Примеры

substring-before('12-May-1998', '-') → '12'

substring-before('12 May 1998', ' ') → '12'

substring-before('12 May 1998', ' ') → '12'

substring-before('12 May 1998', '-') → ''

Функция substring-after

string substring-after(string, string)

Эта функция аналогична функции substring-before, только она возвращает строку, которая следует за вторым аргументом. Если вторая строка не содержится в первой, эта функция также вернет пустую строку.

Примеры

substring-after('12-May-1998', '-') → 'May-1998'

substring-after('12 May 1998', ' ') → 'May 1998'

substring-after('12 May 1998', ' ') → 'May 1998'

substring-after('12 May 1998', '-') → ''

Функция substring

string substring(string, number, number?)

Функция substring возвращает подстроку переданного ей строкового аргумента, которая начинается с позиции, указанной вторым аргументом и длиной, указанной третьим аргументом. Если третий аргумент опущен, подстрока продолжается до конца строки. Если численные аргументы являются нецелыми, они округляются при помощи функции round.

В XPath позицией первого символа является 1, а не 0, как в некоторых других языках программирования.

При вычислении подстроки учитываются следующие условия.

□ Если первый численный аргумент меньше 1 (это относится и к отрицательной бесконечности), то подстрока начинается с начала строки.

□ Если первый численный аргумент больше длины строки (это относится и к положительной бесконечности), то подстрока будет пустой.

□ Если второй численный аргумент меньше 1 (это относится и к отрицательной бесконечности), то подстрока будет пустой.

□ Если второй численный аргумент, сложенный с первым, больше длины строки плюс один, подстрока будет продолжаться до конца строки.

Примеры

substring('123456', 2, 3) → '234'

substring('123456', 2, 5) → '23456'

substring('123456', 2, 6) → '23456'

substring('123456', 2) → '23456'

substring('123456', -4) → '123456'

substring('123456', 5, 5) → '5'

substring('123456', 5) → '56'

substring ('123456', 6) → '6'

substring('123456', 1 div 0, ) → ''

substring('123456', 2, -1) → ''

Функция string-length

number string-length(string?)

Функция string-length возвращает число символов строкового аргумента. Если аргумент опущен, string-length возвращает длину строкового представления контекстного узла.

Напомним, что длина строки не имеет ничего общего с количеством байт, которое требуется для ее представления. Разные формы кодирования используют разное количество байт для записи символов, внутренние представления строк также могут быть различными, но длина строки в любом случае — это число символов, которые ее составляют.

Примеры

string-length('Barnes and Noble') →16

string-length('Barness#x20;& Noble') → 14

Функция normalize-space

string normalize-space(string?)

Функция normalize-space производит со своим строковым аргументом так называемую нормализацию пробельного пространства. Это означает, что в строке удаляются ведущие и заключающие пробельные символы, а все последовательности пробелов заменяются одним пробельным символом. Иными словами, функция удаляет "лишние" пробелы в строке.

Если аргумент функции опущен, она выполняется со строковым значением контекстного узла.

Примеры

normalize-space(' А - В - С ') → 'А-В-С'

normalize-space('А &#х9; В &#х9; С') > 'A B C'

Функция translate

string translate(string, string, string)

Функция translate производит замену символов первого своего строкового аргумента, которые присутствуют во втором аргументе на соответствующие символы третьего аргумента.

Пример

translate('abcdefgh', 'aceg', 'ACEG') → 'AbCdEfGh'

Если некоторый символ повторяется во втором аргументе несколько раз, учитывается только первое его появление.

Пример

translate('abcdefgh', 'acaeaga', 'ACBECGD') → 'AbCdEfGh'

Если второй аргумент длиннее третьего, символы, для которых нет соответствующей замены, удаляются из строки.

Пример

translate('a b-c=d+e|f/g\h', 'aceg-=+|/\', 'ACEG') → 'AbCdEfGh'

Если третий аргумент длиннее второго, остаток строки игнорируется.

Пример

translate('abcdefgh', 'aceg', 'ACEGBDFH') → ' AbCdEfGh'

Функцию translate можно использовать, например, для изменения регистра символов. Конечно, это будет работать только для тех языков, для которых такая функция будет записана, но и этого в большинстве случаев будет достаточно. В будущем предполагается включить в новые версии языка более мощные функции для работы с регистрами символов.

Пример

Для того чтобы изменять регистр слов русского языка, мы можем определить две переменные, lowercase и uppercase, которые будут содержать строчные и прописные символы основного русского алфавита (мы включили в него букву ё — строчную ("ё") и прописную ("Ё"), хотя в соответствии с Unicode она относится к расширениям). Мы также создадим два именованных шаблона, которые будут менять регистр символов строкового параметра str. Для удобства использования мы вынесем определения переменных и шаблонов во внешний модуль ru.xsl.

Листинг 6.6. Преобразование ru.xsl

<xsl:stylesheet

 version="1.0"

 xmlns:xsl="http://www.w3.org/1999/XSL/Transform">

 <xsl:variable

  name="uppercase"

  select="concat('АБВГ',

                 'ДЕЁЖЗ',

                 'ИЙКЛ',

                 'МНОП',

                 'РСТУ',

                 'ФХЦЧ',

                 'ШЩЪЫ',

                 'ЬЭЮЯ')"/>

 <xsl:variable

  name="lowercase"

  select="concat('абвг',

                 'деёжЗ',

                 'ийкл',

                 'мноп',

                 'рсту',

                 'фхцч',

                 'шщъы',

                 'ьэюя')"/>

 <xsl:template name="lower">

  <xsl:param name="str"/>

  <xsl:value-of select="translate($str, $uppercase, $lowercase)"/>

 </xsl:template>

 <xsl:template name="upper">

  <xsl:param name="str"/>

  <xsl:value-of select="translate($str, $lowercase, $uppercase)"/>

 </xsl:template>

</xsl:stylesheet>

Использовать этот модуль можно, включив или импортировав его в основное преобразование элементами xsl:include или xsl:import. После этого в основном преобразовании будут доступны переменные lowercase и uppercase, которые можно будет использовать в функции translate и шаблоны с именами lower и upper.

Использовать функцию translate с переменными lowercase и uppercase можно следующим образом:

translate('Дом', $uppercase, $lowercase) → 'дом'

translate('Дом', $lowercase, $uppercase) → 'ДОМ'

Именованные шаблоны можно вызывать элементом xsl:call-template, передавая параметр при помощи xsl:with-param. Например, следующий фрагмент шаблона

...

<xsl:call-template name="lower">

 <xsl:with-param name="str" select="'Дом'"/>

</xsl:call-template>

...

создаст в выходящем дереве текстовый узел со значением "дом".

Функции множеств узлов

Функции last и position

number last()

number position()

Функция last возвращает текущий размер контекста — число, которое показывает, сколько узлов находится в обрабатываемом в данный момент множестве.

Функция position возвращает позицию контекста — число, показывающее порядковый номер контекстного узла в обрабатываемом множестве.

Пример

В этом примере мы будем заменять все элементы элементами вида

<element name="..." position="...">

 ...

</element>

где атрибут name будет содержать имя, a position — через дробь позицию элемента в контексте и размер контекста.

Листинг 6.7. Входящий документ

<а>

 <b/>

 <c/>

 <d>

  <e/>

  <f/>

 </d>

</a>

Листинг 6.8. Преобразование

<xsl:stylesheet

 version="1.0"

 xmlns:xsl="http://www.w3.org/1999/XSL/Transform">

 <xsl:output indent="yes"/>

 <xsl:strip-space elements="*"/>

 <xsl:template match="*">

  <element name="{name()}" pos="{position()}/{last()}">

   <xsl:apply-templates/>

  </element>

 </xsl:template>

</xsl:stylesheet>

Листинг 6.9. Выходящий документ

<element name="a" pos="1/1">

 <element name="b" pos="1/3"/>

 <element name="c" pos="2/3"/>

 <element name="d" pos="3/3">

  <element name="e" pos="1/2"/>

  <element name="f" pos="2/2"/>

 </element>

</element>

Отметим, что если бы мы не удаляли лишние пробельные символы во входящем документе при помощи элемента xsl:strip-space, в контексте преобразования учитывались бы также и текстовые узлы, которые им соответствуют. Выходящий документ без этого элемента имел бы следующий вид:

<element name="a" pos="1/1">

 <element name="b" pos="2/7"/>

 <element name="c" pos="4/7"/>

 <element name="d" pos="6/7">

  <element name="e" pos="2/5"/>

  <element name="f" pos="4/5"/>

 </element>

</element>

Функция count

number count(node-set)

Функция count возвращает число узлов, которое входит во множество, переданное ей в качестве аргумента.

Пример

Для того чтобы подсчитать количество всех элементов второго уровня, можно воспользоваться выражением count(/*/*). Например, для входящего документа из примера к функциям last и position (листинг 6.7) это выражение примет значение 3.

Приведем несколько других примеров, используя тот же документ.

Покажем, что дерево документа на листинге 6.7 имеет ровно один корневой узел:

count(/) → 1

и ровно один элемент, находящийся в корне:

count(/*) → 1

Подсчитаем количество текстовых узлов, принадлежащих элементу a (это те самые пробельные текстовые узлы, которые были удалены элементом xsl:strip-space):

count(/a/text()) → 4

Подсчитаем общее количество элементов в документе:

count(//*) → 6

Функции local-name, namespace-uri и name

string local-name(node-set?)

string namespace-uri(node-set?)

string name(node-set?)

Функция local-name возвращает локальную часть имени первого в порядке просмотра документа узла множества, переданного ей в качестве аргумента. Эта функция выполняется следующим образом.

□ Если аргумент опущен, то значением функции по умолчанию является множество, содержащее единственный контекстный узел. Иными словами, функция возвратит локальную часть расширенного имени контекстного узла (если она существует).

□ Если аргументом является пустое множество, функция возвращает пустую строку.

□ Если первый в порядке просмотра документа узел переданного множества не имеет расширенного имени, функция возвращает пустую строку.

□ В противном случае функция возвращает локальную часть расширенного имени первого в порядке просмотра документа узла переданного множества.

Функция namespace-uri работает совершенно аналогично функции local-name за тем исключением, что возвращает не локальную часть расширенного имени, a URI пространства имен этого узла. Эта функция выполняется следующим образом.

□ Если аргумент опущен, его значением по умолчанию является множество, содержащее единственный контекстный узел.

□ Если аргументом является пустое множество, функция возвращает пустую строку.

□ Если первый в порядке просмотра документа узел переданного множества не имеет расширенного имени, функция возвращает пустую строку.

□ Если первый в порядке просмотра документа узел переданного множества не принадлежит никакому пространству имен, функция возвращает пустую строку.

□ В противном случае функция возвращает URI пространства имен первого в порядке просмотра документа узла переданного множества.

Функция name возвратит имя вида QName, которое будет соответствовать расширенному имени первого в порядке просмотра документа узла переданного ей множества.

Это имя должно соответствовать расширенному имени узла, то есть должны совпадать локальные части и пространства имен. Вместе с тем, это вовсе не означает, что префиксы также будут совпадать. Например, если в элементе определены несколько префиксов для одного пространства, функция name может использовать любой из них.

Пример

Для следующего элемента

<a:body

 xmlns:a="http://www.a.com"

 xmlns:b="http://www.a.com"

 xmlns:c="http://www.a.com"/>

функция name может вернуть a:body, b:body или c:body.

Большинство процессоров все же возвращает префикс, с которым узел был объявлен.

Так же как local-name и namespace-uri, функция name имеет следующие особенности использования.

□ Если аргумент опущен, то его значением по умолчанию является множество, содержащее единственный контекстный узел.

□ Если аргументом является пустое множество, то функция возвращает пустую строку.

□ Если первый в порядке просмотра документа узел переданного множества не имеет расширенного имени, то функция возвращает пустую строку.

□ В противном случае функция возвращает имя вида QName, соответствующее расширенному имени первого в порядке просмотра документа узла переданного множества.

Пример

Мы можем видоизменить преобразование, приведенное в примере к функциям last и position (листинг 6.7), чтобы генерируемые элементы содержали информацию об имени, пространстве имен и локальной части имени элементов.

Листинг 6.10. Входящий документ

<a:a

 xmlns:a="http://www.a.com"

 xmlns:b="http://www.b.com">

 <b:b>

  <c/>

 </b:b>

</a:a>

Листинг 6.11. Преобразование

<xsl:stylesheet

 version="1.0"

 xmlns:xsl="http: //www.w3.org/1999/XSL/Transform"

 xmlns:a="http://www.a.com"

 xmlns:b="http://www.b.com">

 <xsl:output indent="yes"/>

 <xsl:template match="*">

  <element

   name="{name()}"

   namespace-uri="{namespace-uri()}"

   local-name="{local-name()}">

   <xsl:apply-templates/>

  </element>

 </xsl:template>

</xsl:stylesheet>

Листинг 6.12. Выходящий документ

<element

 xmlns:a="http://www.a.com"

 xmlns:b="http://www.b.com"

 name="a:a"

 namespace-uri="http://www.a.com"

 local-name="a">

 <element name="b:b"

  namespace-uri="http://www.b.com"

  local-name="b">

  <element name="c"

   namespace-uri=""

   local-name="c"/>

 </element>

</element>

Функция id

node-set id(object)

Мы уже встречались с функцией id, когда говорили об уникальных атрибутах элементов и еще раз — когда разбирали паттерны. Функция id позволяет обращаться к элементам по значениями их уникальных атрибутов.

Функция id выполняется по-разному в зависимости от того, какой тип данных ей передается.

□ Если аргументом функции является строка, она рассматривается как набор идентификаторов, разделенных пробелами. В результирующее множество узлов войдут узлы тех элементов текущего документа, значения уникальных атрибутов которых входят в набор идентификаторов, определяемый строковым аргументом.

□ Если аргументом функции является множество узлов, результатом ее выполнения будет объединение результатов функции id, примененной к строковому значению каждого из узлов множества.

□ Если аргументом функции является объект другого типа, аргумент вначале преобразуется в строку и функция id выполняется как со строковым параметром.

Пример

Предположим, что мы используем XML для того, чтобы описать граф — множество вершин, соединенных дугами (рис. 6.11).

Рис. 6.11. Изображение графа, который мы будем описывать в XML

Каждой вершине будет соответствовать элемент vertex. Для того чтобы описать все связи, мы дадим каждой вершине уникальное имя, которое будет записано в ее ID-атрибуте name. Имена вершин, с которыми она соединена, будут перечислены в атрибуте connects типа IDREFS.

Документ, описывающий этот граф, может выглядеть следующим образом.

Листинг 6.13. Документ gemini.xsl

<!DOCTYPE vertices SYSTEM "gemini.dtd">

<vertices>

 <vertex name="alpha" connects="tau"/>

 <vertex name="beta" connects="upsilon"/>

 <vertex name="gamma" connects="zeta"/>

 <vertex name="delta" connects="zeta lambda upsilon"/>

 <vertex name="epsilon" connects="nu mu tau"/>

 <vertex name="zeta" connects="delta gamma"/>

 <vertex name="theta" connects="tau"/>

 <vertex name="iota" connects="tau upsilon"/>

 <vertex name="kappa" connects="upsilon"/>

 <vertex name="lambda" connects="delta xi"/>

 <vertex name="mu" connects="epsilon"/>

 <vertex name="nu" connects="epsilon"/>

 <vertex name="xi" connects="lambda"/>

 <vertex name="tau" connects="alpha theta iota epsilon"/>

 <vertex name="upsilon" connects="beta iota kappa delta"/>

</vertices>

Декларация типа документа вынесена во внешний файл gemini.dtd.

Листинг 6.14. Файл gemini.dtd

<!ELEMENT vertices (vertex*)>

<!ELEMENT vertex EMPTY>

<!ATTLIST vertex

 name ID #REQUIRED

 connects IDREFS #REQUIRED>

При обработке этого документа функция id будет очень полезна для выбора элементов соединенных вершин. Действительно, функция id, которой будет передано значение атрибута connects (в котором через пробелы перечислены вершины, смежные данной), возвратит множество, состоящее из элементов с перечисленными уникальными идентификаторами. Так, например, функция id('tau upsilon') возвратит множество, состоящее из двух элементов с атрибутами name, равными tau и upsilon соответственно.

Более того, функция id может быть вычислена и от множества узлов. В этом случае ее значением будет объединение множеств, полученных в результате выполнения функции от строкового значения каждого узла переданного множества. Например, id(id('tau upsilon')/@connects) возвратит множество, состоящее из вершин с именами alpha, beta, delta, epsilon, theta, iota и kappa — множество вершин, смежных с вершинами tau и upsilon.

Приведем пример преобразования, которое в каждый элемент vertex добавляет комментарий, в котором перечислены имена вершин, достижимых из текущей, не более чем за два шага.

Для того чтобы найти множество вершин, достижимых за один шаг (иначе говоря, смежных), мы воспользуемся выражением вида id(@connects), для выборки множества вершин, достижимых из текущей за два шага — выражением id(id(@connects)/@connects). Таким образом, множество вершин, достижимых не более чем за два шага, будет вычисляться как

id(@connects)|id(id(@connects)/@connects)

Листинг 6.15. Преобразование gemini.xsl

<xsl:stylesheet

 version="1.0"

 xmlns:xsl="http://www.w3.org/1999/XSL/Transform">

 <xsl:output doctype-system="gemini.dtd"/>

 <xsl:template match="vertices">

  <xsl:copy>

   <xsl:apply-templates/>

  </xsl:copy>

 </xsl:template>

 <xsl:template match="vertex">

  <vertex name="{@name}" connects="{@connects}">

   <xsl:comment>

    <xsl:for-each select="id(@connects)|id(id@connects)/@connects)">

     <xsl:text> </xsl:text>

     <xsl:value-of select="@name"/>

    </xsl:for-each>

   </xsl:comment>

  </vertex>

 </xsl:template>

</xsl:stylesheet>

Листинг 6.16. Выходящий документ

<!DOCTYPE vertices SYSTEM "gemini.dtd">

<vertices>

 <vertex name="alpha" connects="tau">

  <!-- alpha epsilon theta iota tau-->

 </vertex>

 <vertex name="beta" connects="upsilon">

  <!-- beta delta iota kappa upsilon-->

 </vertex>

 <vertex name="gamma" connects="zeta">

  <!-- gamma delta zeta-->

 </vertex>

 <vertex name="delta" connects="zeta lambda upsilon">

  <!-- beta gamma delta zeta iota kappa lambda xi upsilon-->

 </vertex>

 <vertex name="epsilon" connects="nu mu tau">

  <!-- alpha epsilon theta iota mu nu tau-->

 </vertex>

 <vertex name="zeta" connects="delta gamma">

  <!-- gamma delta zeta lambda upsilon-->

 </vertex>

 <vertex name="theta" connects="tau">

  <!-- alpha epsilon theta iota tau-->

 </vertex>

 <vertex name="iota" connects="tau upsilon">

  <!-- alpha beta delta epsilon theta iota kappa tau upsilon-->

 </vertex>

 <vertex name="kappa" connects="upsilon">

  <!-- beta delta iota kappa upsilon-->

 </vertex>

 <vertex name="lambda" connects="delta xi">

  <!-- delta zeta lambda xi upsilon-->

 </vertex>

 <vertex name="mu" connects="epsilon">

  <!-- epsilon mu nu tau-->

 </vertex>

 <vertex name="nu" connects="epsilon">

  <!-- epsilon mu nu tau-->

 </vertex>

 <vertex name="xi" connects="lambda">

  <!-- delta lambda xi-->

 </vertex>

 <vertex name="tau" connects="alpha theta iota epsilon">

  <!-- alpha epsilon theta iota mu nu tau upsilon-->

 </vertex>

 <vertex name="upsilon" connects="beta iota kappa delta">

  <!-- beta delta zeta iota kappa lambda tau upsilon-->

 </vertex>

</vertices>

Базовые продукции XPath

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

Литералы — это строковые значения, заключенные в одинарные или двойные кавычки. В литералах нельзя использовать символ кавычек, в которые они заключены. Кроме этого, поскольку XPath-выражения чаще всего используются в атрибутах элементов, в них нельзя использовать символы "<" и "&" — они должны заменяться на сущности. Литералам соответствует продукция Literal, определяемая в виде:

[XP29] Literal ::= '"' [^"]* '"' | "'" [^']* "'"

XPath использует десятичную систему счисления. Наборы цифр, соответствующие правилу Digits, могут состоять из цифр от 0 до 9:

[XP31] Digits ::= [0-9]+

Число в XPath состоит из последовательности цифр, которые могут быть разделены точкой, причем точка может стоять как в начале числа (.5), так и в конце (5.). Числу соответствует EBNF-правило Number:

[XP30] Number ::= Digits ('.' Digits?)? | '.' Digits

Оператору умножения соответствует символ "*" и синтаксическое правило MultiplyOperator:

[XP34] MultiplyOperator ::= '*'

Именам переменных, которые используются в XPath, предшествует символ "$". Сами же имена должны удовлетворять продукции QName, которую мы рассматривали в разделе "Расширенные имена".

[XP36] VariableReference ::= '$' QName

Продукция NodeType, использованная в тесте узла (см. раздел "Тесты узлов" данной главы, продукция [XP7]), определяет типы узлов, которые можно проверить при тесте — comment (комментарий), text (текстовый узел), processing-instruction (узел инструкции по обработке) и node (узел любого типа). NodeType записывается следующим образом:

[XP38] NodeType ::= 'comment'

                    | 'text'

                    | 'processing-instruction'

                    | 'node'

Другая конструкция, NameTest, которая также используется в тесте узла, проверяет узлы базового типа оси на соответствие определенному имени. EBNF-правило NameTest имеет следующий синтаксис:

[ХР37] NameTest ::= '*' | NCName ':' '*' | QName

Имя функции в XPath может быть любым корректным XML-именем за исключением тех имен, которые используются для обозначения типов узлов. Правило FunctionName имеет вид:

[XP35] FunctionName ::= QName - NodeType

В целях удобочитаемости, в выражениях можно использовать пробельное пространство. Ему соответствует EBNF-правило ExprWhiteSpace:

[XP39] ExprWhitespace ::= S

Разбор XPath-выражений

Хотя синтаксис языка XPath укладывается в тридцать с небольшим синтаксических правил, реализация интерпретатора XPath-выражений может быть довольно непростой задачей. Для того чтобы хоть как-то упростить ее, в XPath определяются так называемые токены выражения (англ. expression token). Токены — это единицы, из которых состоит выражение. Будучи сами очень простыми, они выстраиваются в более сложные конструкции, образуя, в итоге, выражения.

Примером токенов являются операторы, которым соответствуют продукции Operator и OperatorName:

[XP33] OperatorName ::= 'and' | 'or' | 'mod* | 'div'

[XP32] Operator     ::= OperatorName

                        | MultiplyOperator

                        | '/' | '//' | '|' | '+' | '-'

                        | '=' | '!=' | '<' | '>' | '<=' | '>='

Продукция самого токена выражения имеет вид:

[ХР28] ExprToken ::= '(' | ')' | '[' | ']'

                     | ' . ' | ' .. ' | '@' | ' | ':: '

                     | NameTest

                     | NodeType

                     | Operator

                     | FunctionName

                     | AxisName

                     | Literal

                     | Number

                     | VariableReference

При разборе XPath-выражения оно сначала разбивается на отдельные токены, а затем из них организуются более сложные структуры. При разбивке выражения на отдельные токены, следует всегда выбирать токен с самым длинным строковым представлением.

Помимо этого, для того чтобы грамматика XPath-выражений была однозначной, в спецификации языка приводятся следующие правила разбора.

□ Если текущему токену предшествует другой токен, причем этот предшествующий токен не является символом @, ::, (, [ или нетерминалом Operator, то текущий токен, являющийся символом *, должен восприниматься как знак умножения, а токен, являющийся NCName, — как нетерминал OperatorName.

□ Если за текущим токеном вида NCName следует открывающая круглая скобка (символ "("), токен должен восприниматься или как имя функции (FunctionName), или как тип узла (NodeType).

□ Если за текущим токеном вида NCName следуют символы "::", токен должен восприниматься как имя оси навигации (AxisName).

□ Если ничего из вышеперечисленного не выполняется, токен не должен восприниматься, как MultiplyOperator, OperatorName, NodeType, FunctionName или AxisName.

Мы привели эти правила в точности так, как они описаны в спецификации языка XPath. Их довольно непросто понять в такой формулировке, поэтому мы попытаемся объяснить их другими словами.

□ Символ * является знаком умножения (MultiplyOperator) тогда и только тогда, когда ему предшествует токен, но этот токен не является токеном @, ::, (, [ или Operator.

□ Токен NCName представляет имя оператора (OperatorName) тогда и только тогда, когда ему предшествует токен, но этот токен не является токеном ::, (, [ или Operator.

□ Токен NCName является именем функции (FunctionName) или типом узла (NodeType) тогда и только тогда, когда за ним следует символ "(".

□ Токен NCName является именем оси навигации (AxisName) тогда и только тогда, когда за ним следуют символы "::".

Глава 7 Основные элементы XSLT

Основные и дополнительные элементы

Все элементы XSLT можно разделить на две группы: элементы основные и элементы дополнительные. Это разделение очень условно, ничего подобного в спецификации языка XSLT нет, однако, мы будем им пользоваться, считая основными элементами те элементы XSLT, которые непосредственно отвечают за создание узлов выходящего дерева или обеспечивают контроль над этим процессом. К дополнительным элементам мы будем относить все остальные элементы XSLT.

Таким образом, множество основных элементов будет включать в себя следующее:

□ xsl:element — создание в выходящем дереве узла элемента;

□ xsl:attribute — создание в выходящем дереве узла атрибута;

□ xsl:attribute-set — определение именованного набора атрибутов;

□ xsl:text — создание текстового узла;

□ xsl:value-of — создание текстового узла по результатам вычисления выражения;

□ xsl:comment — создание узла комментария;

□ xsl:processing-instruction — создание узла инструкции по обработке;

□ xsl:copy — копирование текущего узла вместе с его узлами пространств имен;

□ xsl:copy-of — копирование результата вычисления выражения;

□ xsl:if — условная обработка;

□ xsl:choose, xsl:when и xsl:otherwise — выбор одной из нескольких альтернатив согласно некоторым условиям;

□ xsl:for-each — итеративная обработка множества узлов.

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

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

□ Что, если в выходящем документе требуется создать элемент сзаранее неизвестным (например, вычисляемым во время выполнения) именем?

□ Как создать элемент, принадлежащий пространству имен, известному обрабатывающему процессору?

Поясним на примерах суть и той и другой проблемы.

Представим себе входящий документ вида

<element name="a">

 <element name="b"/>

</element>

который нужно преобразовать во что-нибудь наподобие

<а>

 <b/>

</а>

Совершенно очевидно, что литеральными элементами тут не обойдешься — мы не знаем заранее имена элементов выходящего документа, ибо они определяются значениями атрибутов входящего.

Представим теперь, что нам в XSLT-преобразовании необходимо сгенерировать другое XSLT-преобразование. Скажем из элемента вида

<remove element="a"/>

нужно получить шаблон

<xsl:template match="a"/>

Беда в том, что литеральные элементы не могут быть использованы для создания, скажем, элемента xsl:template по той причине, что любой элемент с локальной частью имени template, принадлежащий пространству имен XSLT будет рассматриваться процессором, как элемент самого преобразования. Очевидно, что

<xsl:template match="remove">

 <xsl:template match="{@element}"/>

</xsl:template>

будет некорректным определением. He поможет и смена префикса, ведь принадлежность пространству имен определяется не им.

Для того чтобы решить эти проблемы (главным образом, первую), XSLT предоставляет возможность создавать узлы элементов при помощи элемента xsl:element.

Элемент xsl:element

Синтаксическая конструкция этого элемента задается следующим образом:

<xsl:element

 name="{имя}"

 namespace="{пространство имен}

 "use-attribute-sets="имена">

 <!-- Содержимое: шаблон -->

</xsl:element>

Здесь обязательный атрибут name указывает имя создаваемого элемента. Этот атрибут может содержать шаблон значения, а значит, имя элемента может быть вычислено во время выполнения.

Атрибут namespace указывает URI пространства имен создаваемого элемента. Точно так же, как и name, этот атрибут может содержать шаблон значения, что позволяет вычислять пространство имен создаваемого элемента при помощи выражений.

Атрибут use-attribute-sets перечисляет имена наборов атрибутов, которые должны быть включены в создаваемый элемент.

Содержимым xsl:element является шаблон, который выполняется процессором и затем включается в создаваемый элемент.

Пример

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

Листинг 7.1. Входящий документ

<fire on="babylon"/>

Листинг 7.2. Шаблон, заменяющий имя элемента значением атрибута

<xsl:template match="*">

 <xsl:element name="{@*}">

  <xsl:attribute name="{name(@*)}">

   <xsl:value-of select="name()"/>

  </xsl:attribute>

 </xsl:element>

</xsl:template>

Листинг 7.3. Выходящий документ

<babylon on="fire"/>

В этом примере код <xsl:element name="{@*}">...</xsl:element> создает элемент, именем которого становится значение выражения @*, указанного в виде шаблона значения атрибута name. Это выражение выбирает множество, состоящее из узлов атрибутов текущего элемента, а если привести его к строке, в результате получится текстовое значение первого атрибута элемента.

Подобным образом выбирается имя атрибута создаваемого элемента и его значение.

Вычисленное значение атрибута name может задавать и расширенное имя элемента, то есть иметь форму префикс:имя. В этом случае элемент будет создаваться в том пространстве имен, которое соответствует указанному префиксу, например

<xsl:element name="xsl:template"/>

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

<xsl:template xmlns:xsl="http://www.w3.org/1999/XSL/Transform"/>

Заметим, что элемент вида

<xsl:element name="{concat{'xsl',':','template')}"/>

даст тот же результат.

Другим способом указания пространства имен при использовании элемента xsl:element является использование атрибута namespace. Например, для предыдущего случая мы могли бы записать

<xsl:element

 name="template"

 namespace="http://www.w3.org/1999/XSL/Transform"/>

и получить в итоге

<template xmlns="http://www.w3.org/1999/XSL/Transform"/>

что эквивалентно результату предыдущего примера, хоть и различается внешне.

Атрибут namespace тоже может быть сконструирован на этапе выполнения, например:

<xsl:element

 name="template"

 namespace="{concat('http://www.w3.org/', 2001 - 2, '/XSL/Transform')}"/>

что также даст элемент template, принадлежащий пространству имен XSLT.

Для того чтобы разобраться в приоритетах атрибутов name и namespace на определение пространства имен, приведем несколько правил, которые пояснят этот процесс.

□ Если в элементе xsl:element определен атрибут namespace, то создаваемый элемент будет принадлежать пространству имен с URI, который будет значением этого атрибута. Если значением атрибута namespace будет пустая строка, создаваемый элемент будет принадлежать нулевому пространству имен. Как правило, процессоры используют префикс, указанный в имени атрибутом name, но, вместе с тем, они не обязаны так делать. Поэтому в общем случае следует ожидать, что префикс может быть любым.

□ Если в элементе xsl:element не определен атрибут namespace, но имя, заданное в атрибуте name имеет префикс, то создаваемый элемент будет принадлежать соответствующему этому префиксу пространству имен. Однако и в этом случае не гарантируется, что префикс создаваемого элемента будет таким, каким он был задан в атрибуте name.

□ В случае, если в элементе xsl:element не определен атрибут namespace и имя, заданное в атрибуте name не имеет префикса, создаваемый элемент будет принадлежать пространству имен, которое действует для создающего элемента xsl:element по умолчанию.

Повторим еще раз, что во всех трех случаях сказать что-либо достоверно о префиксе создаваемого элемента нельзя — префикс с точки зрения пространств имен не является значащей частью имени элемента. Вместе с тем, на практике процессоры, как правило, используют префикс, указанный в атрибуте name, или не используют префикс вообще, если префикс в name указан не был.

Приведем несколько примеров.

Для начала покажем, что, согласно первому правилу, атрибут namespace имеет наивысший приоритет при определении пространства имен выходящего элемента. Рассмотрим следующее преобразование.

Листинг 7.4.

<xsl:stylesheet

 version="1.0"

 xmlns:xsl="http://www.w3.org/1999/XSL/Transform">

<xsl:template match="/">

<xsl:element

 name="xsl:html"

 namespace="http://www.w3.org/1999/xhtml"/>

</xsl:template>

</xsl:stylesheet>

В выделенном элементе xsl:element пространство имен создаваемого элемента указано вроде бы два раза: в виде значения атрибута namespace и в виде префикса имени ("xsl"). Результат будет выглядеть следующим образом:

<xsl:html xmlns:xsl="http://www.w3.org/1999/xhtml"/>

Процессор использовал пространство имен, указанное в атрибуте namespace, локальную часть имени, заданного атрибутом name ("html"), а также префикс (только префикс, но не связанное с ним пространство имен) этого имени ("xsl").

В свою очередь конструкция вида

<xsl:element name="xsl:html" namespace=""/>

создаст элемент

<xsl:html xmlns:xsl=""></xsl:html>

что на самом деле эквивалентно просто <html/>.

Таким образом, атрибут namespace наиболее приоритетен для определения пространства имен создаваемого элемента. Обратимся теперь к случаю, когда этот атрибут опущен в xsl:element. Объявление вида

<xsl:element name="xsl:html"/>

создаст элемент

<xsl:html xmlns:xsl="http://www.w3.org/1999/XSL/Transform"/>

Как видим, отсутствие namespace и namespace="" — не одно и то же.

Рассмотрим теперь случай, когда нет ни атрибута namespace, ни префикса в name:

<xsl:stylesheet

 version="1.0"

 xmlns:xsl="http://www.w3.org/1999/XSL/Transform">

<xsl:template match="/">

 <xsl:element name="html"/>

</xsl:template>

</xsl:stylesheet>

Результатом этого преобразования будет документ, состоящий из одного пустого элемента html:

<html/>

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

<xsl:stylesheet

 version="1.0"

 xmlns:xsl="http://www.w3.org/1999/XSL/Transform">

 <xsl:template match="/" xmlns="http://www.w3.org/1999/xhtml">

  <xsl:element name="html"/>

 </xsl:template>

</xsl:stylesheet>

Результатом в этот раз будет элемент с локальной частью имени "html", принадлежащий пространству имен с URI "http://www.w3.org/1999/xhtml":

<html xmlns="http://www.w3.org/1999/xhtml" />

Создание узлов атрибутов

Элемент xsl:attribute

Этот элемент задается конструкцией вида:

<xsl:attribute

 name="{имя}"

 namespace="{пространство имен}">

 <!-- Содержимое: шаблон -->

</xsl:attribute>

Использование элементов xsl:attribute и xsl:element во многом аналогично. Обязательный атрибут name указывает имя, а атрибут namespace — URI пространства имен создаваемого атрибута, причем процесс вычисления расширенного имени атрибута практически идентичен этому в процедуре вычисления имени элемента, который был приведен при разборе xsl:element.

Показаний к применению xsl:attribute несколько больше, чем для xsl:element. В частности, xsl:attribute следует использовать, если:

□ требуется создать атрибут с не известным заранее именем или пространством имен;

□ требуется создать атрибут в пространстве имен, которое является для процессора значащим (например, в пространстве имен XSLT);

□ требуется создать атрибут, вычисление значения которого не может быть реализовано одним или несколькими XPath-выражениями (например, условный вывод атрибута).

Приведем некоторые примеры.

Покажем, как преобразовать структуру вида

<element name="record">

 <attribute name="fieldcount" value="12"/>

 <attribute name="title" value="Aggregation"/>

</element>

в элемент

<record fieldcount="12" title="Aggregation"/>

Для достижения цели воспользуемся следующим преобразованием.

Листинг 7.5. Создание атрибутов при помощи xsl:attribute

<xsl:stylesheet

 version="1.0"

 xmlns:xsl="http://www.w3.org/1999/XSL/Transform">

 <xsl:template match="element">

  <xsl:element name="{@name}">

   <xsl:apply-templates select="attribute"/>

  </xsl:element>

 </xsl:template>

 <xsl:template match="attribute">

  <xsl:attribute name="{@name}">

   <xsl:value-of select="@value"/>

  </xsl:attribute>

 </xsl:template>

</xsl:stylesheet>

Элемент xsl:attribute не может использоваться где угодно: узлы атрибутов должны создаваться только как дочерние узлы узлов элементов. Более того, узлы атрибутов должны создаваться до создания дочерних узлов других типов — текста, элементов и так далее. Таким образом, xsl:attribute может быть использован в содержимом любого из следующих родителей:

□ литерального элемента результата;

□ элемента xsl:element;

□ элемента xsl:copy в случае, если текущий, копируемый узел является элементом;

□ элемента xsl:attribute-set в случае определения именованного набора атрибутов.

При этом, как было показано в предыдущем примере, xsl:attribute не обязан использоваться только в качестве их непосредственного дочернего элемента. Главное, чтобы атрибуты создавались в элементах и только в элементах.

Элемент xsl:attribute также не может использоваться для генерации объявлений пространств имен. В соответствии с технической рекомендацией XSLT, xsl:attribute не может создавать атрибуты, имена которых имеют префикс xmlns.

Если атрибут создается в элементе, который уже имеет атрибут с таким же именем, старый атрибут будет переопределен новым значением.

Рассмотрим пример.

Листинг 7.6. Фрагмент шаблона

<а href="http://www.aaa.com">

 <xsl:attribute name="href">

  <xsl:text>http://www.bbb.com</xsl:text>

 </xsl:attribute>

</a>

Листинг 7.7. Результат

<a href="http://www.bbb.com"/>

Поскольку атрибут может содержать только текст, результатом выполнения содержимого xsl:attribute тоже должны быть только текстовые узлы. Процессор в лучшем случае проигнорирует нетекстовые узлы, в худшем выведет сообщение об ошибке, прервав дальнейшую обработку, так что следует очень внимательно относиться к содержимому xsl:attribute.

Текстовое значение атрибута может задаваться не только символьными данными, Оно может генерироваться также элементами XSLT, такими, как, например, xsl:text и xsl:value-of. То есть вполне корректным будет следующее определение:

<xsl:attribute name="href">

 <xsl:text>http://</xsl:text>

 <xsl:value-of select="concat('www', '.', 'bbb')"/>

 <xsl:text>.com</xsl:text>

</xsl:attribute>

В том случае, если текстовое значение атрибута содержит символы перевода строки, при генерации атрибута они будут заменены сущностями, то есть определение

<xsl:attribute name="href">а¶

 b</xsl:attribute>

создаст атрибут с именем "href" и значением "a b":

<а href="a b"/>

Техническая рекомендация объясняет такую ситуацию следующим образом: в соответствии со стандартом языка XML, символы перевода строки должны нормализоваться в значениях атрибутов пробелами, сущности же нормализовать не нужно. Но если бы символ перевода строки нормализовался в XSLT при выводе пробелом, то определения

<xsl:attribute name="href">a□b</xsl:attribute>

и

<xsl:attribute name="href">a¶

b</xsl:attribute>

были бы эквивалентны, что не отражает реального положения вещей. Для того чтобы исправить эту несуразицу, символ перевода строки при выводе в атрибуте нормализуется в XSLT символьной сущностью ( или ).

Подводя итог, перечислим в краткой форме основные особенности обращения с xsl:attribute.

□ Атрибуты могут создаваться только в узлах элементов. Если атрибут создается в узле, который не является узлом элемента, процессор может либо выдать ошибку, либо проигнорировать создаваемый атрибут.

□ Атрибуты могут содержать только текстовые узлы. Процессор может либо выдать ошибку, либо проигнорировать нетекстовые узлы.

□ Узлы атрибутов должны быть первыми узлами, которые создаются в элементах. XSLT не разрешает создавать атрибуты после того, как в элемент включены дочерние узлы других типов.

□ В случае, когда документ преобразуется в другой XML-документ, символы перевода строки в элементе заменяются символьными сущностями.

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

Элемент xsl:attribute-set

Синтаксис элемента определяется следующей конструкцией:

<xsl:attribute-set

 name="имя"

 use-attribute-sets="имена">

 <!-- Содержимое: несколько элементов xsl:attribute -->

</xsl:attribute-set>

Для того чтобы упростить создание в элементах целых наборов атрибутов, можно заранее определить их в элементе xsl:attribute-set. Обязательный атрибут name задает имя набора атрибутов. Элемент xsl:attribute-set содержит последовательность, состоящую из нуля или более элементов xsl:attribute.

Именованные наборы атрибутов можно использовать, указывая их имена в значении атрибута use-attribute-sets, который может присутствовать в элементах xsl:element, xsl:copy и xsl:attribute-set, а также в литеральных результирующих элементах. В атрибуте use-attribute-sets через пробел перечисляются имена наборов атрибутов, которые должны быть использованы в данном элементе.

Включение набора атрибутов в элемент равносильно простому копированию элементов xsl:attribute, определенных в соответствующих элементах xsl:attribute-set.

Пример

Предположим, что во входящем документе нам нужно вывести структуру, состоящую из элементов с именем element, атрибут name которых равен имени, атрибут attr-count — количеству атрибутов, а атрибут node-count — количеству дочерних узлов соответствующего элемента.

Листинг 7.8. Входящий документ

<a b="1" c="2">

 <d e="3" f="4" g="5"/>

</a>

Листинг 7.9. Преобразование

<xsl:stylesheet

 version="1.0"

 xmlns:xsl="http://www.w3.org/1999/XSL/Transform">

 <xsl:output indent="yes"/>

 <xsl:attribute-set name="attrs">

  <xsl:attribute name="attr-count">

   <xsl:value-of select="count(@*)"/>

  </xsl:attribute>

 </xsl:attribute-set>

 <xsl:attribute-set name="elements">

  <xsl:attribute name="name">

   <xsl:value-of select="name()"/>

  </xsl:attribute>

  <xsl:attribute name="node-count">

   <xsl:value-of select="count(*)"/>

  </xsl:attribute>

 </xsl:attribute-set>

 <xsl:template match="*">

  <xsl:element name="element"

   use-attribute-sets="elements attrs">

   <xsl:apply-templates select="*"/>

  </xsl:element>

 </xsl:template>

</xsl:stylesheet>

Листинг 7.10. Выходящий документ

<?xml version="1.0" encoding="utf-8"?>

<element name="a" node-count="1" attr-count="2">

 <element name="d" node-count="0" attr-count="3"/>

</element>

В этом преобразовании определение элемента

<xsl:element name="element"

 use-attribute-sets="elements attrs">

 <xsl:apply-templates select="*"/>

</xsl:element>

равносильно определению

<xsl:element name="element">

 <xsl:attribute name="name">

  <xsl:value-of select="name()"/>

 </xsl:attribute>

 <xsl:attribute name="node-count">

  <xsl:value-of select="count(*)"/>

 </xsl:attribute>

 <xsl:attribute name="attr-count">

  <xsl:value-of select="count(@*)"/>

 </xsl:attribute>

 <xsl:apply-templates select="*"/>

</xsl:element>

Как уже было сказано, элемент xsl:attribute-set может также использовать другие наборы атрибутов при помощи use-attribute-sets. Например, в предыдущем преобразовании набор атрибутов elements мог быть определен как:

<xsl:attribute-set name="elements"

 use-attribute-sets="attrs">

 <xsl:attribute name="name">

  <xsl:value-of select="name()"/>

 </xsl:attribute>

 <xsl:attribute name="node-count">

  <xsl:value-of select="count(*)"/>

 </xsl:attribute>

</xsl:attribute-set>

Тогда для достижения того же результата элемент с именем element мог быть создан с использованием только одного набора атрибутов:

<xsl:element name="element"

 use-attribute-sets="elements">

 <xsl:apply-templates select="*"/>

</xsl:element>

Именованный набор атрибутов не может прямо или косвенно (посредством других наборов атрибутов) использовать в значении use-attribute-sets себя самого. Такая ситуация породила бы бесконечный цикл. Вообще, не рекомендуется выстраивать сложную иерархию именованных наборов атрибутов, поскольку это может сильно усложнить обработку и снизить эффективность преобразования, хотя, естественно, все зависит от конкретного случая.

Атрибут xsl:use-attribute-sets

Мы упомянули о том, что именованные наборы атрибутов используются в элементах посредством атрибута xsl:use-attribute-sets. Разберем более детально, где этот атрибут может применяться, и какие функции он при этом выполняет. Для удобства эти данные сведены в табл. 7.1.

Таблица 7.1. Использование атрибута xsl:use-attribute-sets

Родительский элемент	Особенности использования
xsl:attribute-set	Включает в определяемый набор атрибутов атрибуты из перечисленных наборов
xsl:element	Включает в создаваемый элемент атрибуты из перечисленных наборов. Включение эквивалентно текстовому включению — значения атрибутов вычисляются в контексте создающего элемента xsl:element
xsl:copy	Включает в копируемый элемент атрибуты из перечисленных наборов. Принцип действия— как в случае с xsl:element. Копируемый узел должен быть элементом
Литеральный результирующий элемент	Принцип действия такой же, как и в случае с xsl:element. В случае совпадения имен, значения атрибутов из набора будут переопределять значения атрибутов самого элемента. При использовании в литеральном элементе, атрибут xsl:use-attribute-sets должен быть обязательным образом объявлен принадлежащим пространству имен XSLT. Как правило, это делается указанием префикса xsl

Создание текстовых узлов

Шаблон преобразования может содержать текстовые узлы, которые при выполнении шаблона после обработки пробельных символов будут попросту скопированы в результирующее дерево. Таким образом, для того, чтобы вывести в выходящий документ некоторый текст, можно просто включить его в шаблон преобразования.

Рассмотрим пример.

Листинг 7.11. Входящий документ

<answer>No!</answer>

Листинг 7.12. Шаблон преобразования

<xsl:template match="answer">

 The answer was "<xsl:value-of select="text()"/>".

</xsl:template>

Листинг 7.13. Созданный текст

The answer was "No!".

Текстовые узлы могут также быть созданы элементами xsl:text и xsl:value-of. Элемент xsl:text используется для создания текстовых узлов, содержащих пробельные и специальные символы, в то время как элемент xsl:value-of выводит в выходящее дерево строковый результат вычисления выражений.

Элемент xsl:text

Синтаксис данного элемента представлен ниже:

<xsl:text

 disable-output-escaping="yes" | "no">

 <!-- Содержимое: символьные данные -->

</xsl:text>

Элемент xsl:text служит для того, чтобы создавать в выходящем документе текстовые узлы. При этом xsl:text имеет следующие особенности.

□ Преобразования будут сохранять пробельные символы, находящиеся в элементе xsl:text. То есть, для того чтобы вывести в выходящий документ пробельный символ, например такой, как символ перевода строки, достаточно написать

<xsl:text> </xsl:text>

□ Элемент xsl:text имеет атрибут disable-output-escaping, который позволяет избежать замены в выходящем документе специальных символов на символьные или встроенные сущности. Например, для того, чтобы вывести символ "<" можно указать в преобразовании

<xsl:text disable-output-escaping="yes"><</xsl:text>

В остальных случаях символьные данные, включенные в элемент xsl:text, ведут себя так же, как и вне xsl:text.

Элемент xsl:value-of

Этот элемент является одним из наиболее часто используемых в XSLT. Он служит для вычисления значений выражений.

Синтаксическая конструкция элемента следующая:

<xsl:value-of

 select="выражение"

 disable-output-escaping="yes" | "no"/>

В обязательном атрибуте select этого элемента задается выражение, которое вычисляется процессором, затем преобразовывается в строку и выводится в результирующем дереве в виде текстового узла. Процессор не станет создавать текстовый узел, если результатом вычисления выражения была пустая строка. В целях оптимизации дерева, соседствующие текстовые узлы будут объединены в один.

Элемент xsl:value-of очень похож на элемент xsl:copy-of, только в отличие от последнего он сначала преобразовывает вычисленное выражение к строковому виду, а уж затем выводит его в выходящий документ. Иными словами, выражение

<xsl:value-of select="выражение"/>

равносильно

<xsl:copy-of select="string{выражение}"/>

Соответственно, преобразование различных типов данных в строковый тип производится точно так же, как если бы мы использовали для этой цели функцию string.

Пример

Для составления таблицы умножения можно воспользоваться следующим преобразованием.

Листинг 7.14. Входящий документ

<numbers>

 <number>1</number>

 <number>2</number>

 <number>3</number>

 <number>4</number>

 <number>5</number>

 <number>6</number>

 <number>7</number>

 <number>8</number>

 <number>9</number>

</numbers>

Листинг 7.15. Преобразование, создающее таблицу умножения

<xsl:stylesheet

 version="1.0"

 xmlns:xsl="http://www.w3.org/1999/XSL/Transform">

 <xsl:output method="text"/>

 <xsl:template match="numbers">

  <xsl:variable name="numbers" select="number"/>

  <xsl:for-each select="$numbers">

   <xsl:variable name="a" select="."/>

   <xsl:for-each select="$numbers">

    <xsl:variable name="b" select="."/>

    <!-- Если результат произведения меньше 10, добавляем пробел -->

    <xsl:if test="$a * $b < 10">

     <xsl:text> </xsl:text>

    </xsl:if>

    <xsl:value-of select="$a*$b"/>

    <xsl:text> </xsl:text>

   </xsl:for-each>

   <xsl:text> </xsl:text>

  </xsl:for-each>

 </xsl:template>

</xsl:stylesheet>

Листинг 7.16. Выходящий документ

1  2  3  4  5  6  7  8  9

2  4  6  8 10 12 14 16 18

3  6  9 12 15 18 21 24 27

4  8 12 16 20 24 28 32 36

5 10 15 20 25 30 35 40 45

6 12 18 24 30 36 42 48 54

7 14 21 28 35 42 49 56 63

8 16 24 32 40 48 56 64 72

9 18 27 36 45 54 63 72 81

В данном случае элемент xsl:value-of используется для вычисления произведения переменных a и b. Численный результат преобразуется в строку и выводится в выходящий документ в виде текста.

Равно, как и xsl:text, элемент xsl:value-of может иметь атрибут disable-output-escaping, полезный для вывода специальных символов, которые в противном случае были бы заменены сущностями.

Пример

Результатом выполнения элемента

<xsl:value-of select="concat('Divide ', '&', ' impera')"/>

будет текстовый узел

Divide & impera

Чтобы придать амперсанту более привычный вид, мы можем использовать атрибут disable-output-escaping:

<xsl:value-of

select="concat('Divide ', '&', ' impera')"

disable-output-escaping="yes"/>

Результатом выполнения этого шаблона уже будет текст:

Divide & impera

Создание узлов комментариев и инструкций по обработке

Элемент xsl:comment

Этот элемент задается конструкцией вида:

<xsl:comment>

<!-- Содержимое: шаблон -->

</xsl:comment>

Элемент xsl:comment создает в результирующем дереве узел комментария. Текстом комментария становится результат выполнения шаблона, который содержится в элементе xsl:comment.

Точно так же как и в случае с xsl:processing-instruction, результат выполнения шаблона должен содержать только текстовые узлы. Узлы других типов будут либо проигнорированы, либо вызовут ошибку.

В соответствии с синтаксисом XML, комментарий в XML не может содержать двух знаков "-" последовательно ("--") и оканчиваться на "-". Поэтому наличие таких последовательностей символов в тексте комментария будет являться в XSLT ошибкой. Для того чтобы избежать некорректного синтаксиса, процессор может разделять два последовательных минуса пробелом (заменять "--" на "- -") или добавлять пробел после завершающего минуса комментария.

Пример

Элемент:

<xsl:comment> | Please remove this later +</xsl:comment>

создаст комментарий:

<!--

 | Please remove this later

 +-->

Элемент xsl:processing-instruction

Синтаксис элемента представлен ниже:

<xsl:processing-instruction

 name="{имя}">

 <!-- Содержимое: шаблон -->

</xsl:processing-instruction>

Элемент xsl:processing-instruction создает в результирующем дереве узел инструкции по обработке. Обязательный атрибут name определяет имя целевого приложения, которому будет адресована инструкция по обработке. В этом атрибуте может быть указан шаблон значения атрибута.

Пример

Элемент:

<xsl:processing-instruction name="servlet">

 <xsl:text>links="follow" session-timeout="7200000"</xsl:text>

</xsl:processing-instruction>

создаст в выходящем документе инструкцию по обработке вида:

<?servlet links="follow" session-timeout="7200000"?>

Содержимым создаваемой инструкции по обработке является результат выполнения шаблона, содержащегося внутри элемента xsl:processing- instruction. Этот результат должен содержать только текстовые узлы, в противном случае процессор может либо выдать ошибку, либо проигнорировать нетекстовые узлы вместе с их содержимым.

Инструкция по обработке не может содержать последовательности символов "?>", поскольку это было бы некорректно с точки зрения синтаксиса XML.

В случае, если результат выполнения шаблона содержит такую комбинацию, процессор может либо выдать ошибку, либо разделить символы "?" и ">" пробелом:"? >".

Имя инструкции по обработке, должно быть корректным XML-именем (но не равным при этом "xml" в любом регистре символов). Например, следующее определение будет совершенно корректным:

<xsl:processing-instruction name="_">

 <xsl:text>logout _</xsl:text>

</xsl:processing-instruction>

В результате получится следующая инструкция: <?_ logout _?>

Для того чтобы создать в выходящем XML-документе инструкцию xml-stylesheet, которая используется для связывания документов со стилями и преобразованиями, можно воспользоваться следующим определением:

<xsl:processing-instruction name="xml-stylesheet">

 <xsl:text>href="style.xsl" type="text/xsl"</xsl:text>

</xsl:processing-instruction>

Результирующий документ будет содержать инструкцию по обработке в виде:

<?xml-stylesheet href="style.xsl" type="text/xsl"?>

Элемент xsl:processing-instruction не может создать декларацию XML, несмотря на то, что с точки зрения синтаксиса (но не семантики) она имеет форму инструкции по обработке. Для вывода XML-декларации следует использовать элемент xsl:output.

Копирование узлов

Преобразование может включать в себя не только создание новых, но и копирование существующих узлов. Для этого можно использовать элементы xsl:copy и xsl:copy-of, использование которых будет подробно разобрано ниже.

Элемент xsl:copy

Ниже представлена синтаксическая конструкция этого элемента:

<xsl:copy

 use-attribute-sets = "наборы атрибутов">

 <!-- Содержимое: шаблон -->

</xsl:copy>

Элемент xsl:copy создает копию текущего узла вне зависимости от его типа. Вместе с текущим узлом в выходящее дерево копируются только узлы пространств имен, ассоциированные с ним. Дочерние узлы и узлы атрибутов в выходящий документ не копируются.

Если xsl:copy используется для копирования корневого узла или узда элемента, в выходящем документе процессор создает дочерний фрагмент дерева, являющийся результатом выполнения шаблона, содержащегося в xsl:copy.

Пример

Предположим, что в каждый элемент преобразовываемого документа нам нужно добавить атрибут element-count со значением, равным количеству его дочерних элементов, а все остальные узлы оставить, как есть.

Листинг 7.17. Входящий документ

<а> text

 <b attr="value"/>

 <c/>

 <d>

  text

  <e/>

 </d>

</a>

Листинг 7.18. Шаблон преобразования

<xsl:template match="@*|node()">

 <xsl:copy>

  <xsl:attribute name="element-count">

   <xsl:value-of select="count(*) "/>

  </xsl:attribute>

  <xsl:apply-templates select="@*|node()"/>

 </xsl:copy>

</xsl:template>

Листинг 7.19. Выходящий элемент

<a element-count="3">

 text

 <b element-count="0" attr="value"/>

 <c element-count="0"/>

 <d element-count="1">

  text

  <e element-count="0"/>

 </d>

</a>

Если xsl:copy используется для создания в выходящем документе копии узла элемента, в него при помощи атрибута use-attribute-sets могут быть также включены именованные наборы атрибутов (см. раздел "Именованные наборы атрибутов" данной главы).

Пример

Предыдущее преобразование может быть переписано в виде

<xsl:attribute-set name="elements">

 <xsl:attribute name="element-count">

  <xsl:value-of select="count(*)"/>

 </xsl:attribute>

</xsl:attribute-set>

<xsl:template match="@*|node()">

 <xsl:copy use-attribute-sets="elements">

  <xsl:apply-templates select="@*|node()"/>

 </xsl:copy>

</xsl:template>

Результат преобразования будет абсолютно идентичен выходящему документу, полученному в предыдущем примере.

Элемент xsl:copy-of

Синтаксис элемента несложен:

<xsl:copy-of

 select="выражение"/>

Использование элемента xsl:copy-of полностью аналогично использованию элемента xsl:value-of за тем исключением, что xsl:copy-of при выводе значения выражения преобразует его к строке не во всех случаях. Поведение xsl:copy-of зависит от того, какой тип данных возвращает выражение.

□ Если результат вычисления имеет булевый, числовой или строковый тип, то xsl:copy-of выводит его в виде текстового узла. В этом случае поведение xsl:copy-of абсолютно не отличается от поведения элемента xsl:value-of.

□ Если результатом вычисления выражения является множество узлов (node-set), то xsl:copy-of копирует в выходящий документ все узлы в порядке просмотра документа вместе с их потомками.

□ Если результатом вычисления является результирующий фрагмент дерева, то он копируется в выходящий документ в неизмененном виде.

Рассмотрим пример.

Листинг 7.20. Входящий документ

<values>

 <boolean>false</boolean>

 <string>text</string>

 <number>3.14</number>

 <node-set>

  <item>10</item>

  <item>20</item>

  <item>30</item>

 </node-set>

 <tree>

  text

  <root>

   text

   <branch>

    text

    <leaf/>

    <leaf/>

   </branch>

   <leaf/>

  </root>

 </tree>

</values>

Листинг 7.21. Преобразование

<xsl:stylesheet

 version="1.0"

 xmlns:xsl="http://www.w3.org/1999/XSL/Transform">

 <xsl:template match="/">

  <xsl:variable name="boolean" select="values/boolean='true'"/>

  <xsl:variable name="string" select="string(values/string)"/>

  <xsl:variable name="number" select="number(values/number)"/>

  <xsl:variable name="node-set" select="values/node-set/*"/>

  <xsl:variable name="tree">

   <xsl:copy-of select="values/tree/*"/>

  </xsl:variable>

  <xsl:text> Value-of boolean:</xsl:text>

  <xsl:value-of select="$boolean"/>

  <xsl:text> Copy-of boolean:</xsl:text>

  <xsl:copy-of select="$boolean"/>

  <xsl:text> Value-of string:</xsl:text>

  <xsl:value-of select="$string"/>

  <xsl:text> Copy-of string:</xsl:text>

  <xsl:copy-of select="$string"/>

  <xsl:text> Value-of number:</xsl:text>

  <xsl:value-of select="$number"/>

  <xsl:text> Copy-of number:</xsl:text>

  <xsl:copy-of select="$number"/>

  <xsl:text> Value-of node-set:</xsl:text>

  <xsl:value-of select="$node-set"/>

  <xsl:text> Copy-of node-set:</xsl:text>

  <xsl:copy-of select="$node-set"/>

  <xsl:text> Value-of tree:</xsl:text>

  <xsl:value-of select="$tree"/>

  <xsl:text> Copy-of tree:</xsl:text>

  <xsl:copy-of select="$tree"/>

 </xsl:template>

</xsl:stylesheet>

Листинг 7.22. Выходящий документ

Value-of boolean:false

Copy-of boolean:false

Value-of string:text

Copy-of string:text

Value-of number:3.14

Copy-of number:3.14

Value-of node-set:10

Copy-of node-set:<item>10</item><item>20</item><item>30</item>

Value-of tree:

  text

   text

Copy-of tree:<root>

  text

  <branch>

   text

   <leaf/>

   <leaf/>

  </branch>

  <leaf/>

 </root>

Условная обработка

В XSLT имеются две инструкции, которые поддерживают условную обработку — xsl:if и xsl:choose. Инструкция xsl:if позволяет создавать простые условия типа "если-то", в то время как xsl:choose создает более сложную конструкцию для выбора одной из нескольких имеющихся возможностей в зависимости от выполнения тех или иных условий.

Элемент xsl:if

Синтаксис элемента следующий:

<xsl:if

 test="выражение">

 <!-- Содержимое: шаблон -->

</xsl:if>

Элемент xsl:if является простейшим условным оператором в XSLT. Выражение, содержащееся в обязательном атрибуте test, вычисляется и приводится к булевому типу. В том и только том случае, если выражение имеет значение true, процессор выполняет шаблон, содержащийся в xsl:if.

Вследствие того, что атрибуты в XML не могут содержать некоторые специальные символы (такие как "<" и "&"), их необходимо заменять символьными сущностями. В особенности это касается сравнения чисел типа "меньше"; объявление вида

<xsl:if test="a < b"/>

будет с точки зрения синтаксиса XML некорректным. Вместо него следует использовать эквивалентное объявление

<xsl:if test="a < b"/>

Следует заметить, что символ "больше" (">") заменять сущностью необязательно. Однако из соображений единообразия принято заменять и его.

Пример

Предположим, мы преобразовываем список названий

<list active="Bravo">

 <item>Alpha</item>

 <item>Bravo</item>

 <item>Charlie</item>

</list>

во фрагмент HTML-кода, в котором каждый элемент item должен быть преобразован в соответствующий элемент option, а значение, выбранное во входящем документе атрибутом active элемента list, должно быть помечено булевым атрибутом selected.

Листинг 7.23. Шаблон преобразования, использующий элемент xsl:if

<xsl:template match="item">

 <option>

  <!--

   | Если текстовое значение элемента равно

   | значению атрибута active его родительского элемента

   +-->

  <xsl:if test=". = ../@active">

   <!-- To выводим атрибут selected -->

   <xsl:attribute name="selected">selected</xsl:attribute>

  </xsl:if>

  <xsl:value-of select="."/>

 </option>

</xsl:template>

Результат:

<option>Alpha</option>

<option selected>Bravo</option>

<option>Charlie</option>

Примечание

В данном преобразовании использовался метод вывода "html". Подробнее о методах вывода выходящего документа см. раздел "Контроль вывода документа" 8 главы.

К сожалению, элемент xsl:if в XSLT не может реализовать конструкцию if-then-else (англ. если-то-иначе). Условные выражения такого вида реализуются при помощи элементов xsl:choose, xsl:when и xsl:otherwise.

Элементы xsl:choose, xsl:when, xsl:otherwise

Ниже даны синтаксические конструкции этих элементов:

<xsl:choose>

 <!--

  | Содержимое: один или более элемент xsl:when, опциональный

  | элемент xsl:otherwise

  +-->

</xsl:choose>

<xsl:when

 test="выражение">

 <!-- Содержимое: шаблон -->

</xsl:when>

<xsl:otherwise>

 <!-- Содержимое: шаблон -->

</xsl:otherwise>

Элемент xsl:choose содержит один или несколько элементов xsl:when и необязательный элемент xsl:otherwise. При обработке xsl:choose процессор поочередно вычисляет выражения, содержащиеся в атрибутах test элементов xsl:when, приводит их к булевому типу и выполняет содержимое первого (и только первого) элемента, тестовое выражение которого будет равно true. В случае если ни одно из тестовых выражений не обратилось в "истину" и в xsl:choose присутствует xsl:otherwise, процессор выполнит содержимое этого элемента.

Элементы xsl:choose, xsl:when и xsl:otherwise можно совместно использовать для получения конструкции типа if-then-else. Условие вида "если выражение A истинно, то выполнить действие B иначе выполнить действие C", которое в других языках программирования может быть записано, к примеру, как

если

 верно условиеА

то

 выполнить шаблонB

иначе

 выполнить шаблонC

в XSLT может быть определено следующим образом:

<xsl:choose>

 <xsl:when test="условиеА">

  шаблонB

 </xsl:when>

 <xsl:otherwise>

  шаблонC

 </xsl:otherwise>

</xsl:choose>

Вместе с тем, условие вида "если — то — иначе" это не все, на что способен элемент xsl:choose. Возможность указывать несколько элементов xsl:when позволяет записывать более сложные условия выбора вида:

если

 верно условие1

то

 выполнить шаблон1

иначе если

 верно условие2

то

 выполнить шаблон2

 ...

иначе если

 верно условиеN

то

 выполнить шаблонN

иначе

 выполнить шаблонМ

Такой множественный условный переход совершенно прозрачно оформляется в виде следующей xsl:choose-конструкции:

<xsl:choose>

 <xsl:when test="условие1">

  шаблон1

 </xsl:when>

 <xsl:when test="условие2">

  шаблон2

 </xsl:when>

 <!-- ... -->

 <xsl:when test="условиеN">

  шаблонN

 </xsl:when>

 <xsl:otherwise>

  шаблонМ

 </xsl:otherwise>

</xsl:choose>

Циклическая обработка

Элемент xsl:for-each

Конструкция этого элемента такова:

<xsl:for-each

 select="выражение">

 <!-- Содержимое: несколько элементов xsl:sort, шаблон -->

</xsl:for-each>

Элемент xsl:for-each используется для создания в выходящем документе повторяемых частей структуры. Обязательный атрибут select указывает выражение, результатом вычисления которого должно быть множество узлов. Шаблон, содержащийся в xsl:for-each, будет выполнен процессором для каждого узла этого множества.

Пример

Мы можем использовать xsl:for-each для того, чтобы создать список гипертекстовых ссылок для документа вида.

Листинг 7.24. Входящий документ

<html>

 <head>

  <title>I'm just a simple page...</title>

 </head>

 <body>

  Please visit <a href="http://www.aaa.com">this link</a>.

  Or <a href="http://www.bbb.com">this one</a>.

  Or visit <a href="http://www.ccc.com">this site</a>.

  Or click <a href="http://www.ddd.com">here</a>.

 </body>

</html>

Будем считать, что в этом документе элементы гипертекстовых ссылок а являются потомками элемента body, который находится в элементе html.

Листинг 7.25. Шаблон преобразования

<xsl:template match="/">

 <links>

  <xsl:for-each select="/html/body//a">

   <a href="{@href}">

    <xsl:value-of select = "@href"/>

   </a>

  </xsl:for-each>

 </links>

</xsl:template>

Листинг 7.26. Результат преобразования

<links>

 <a href="http://www.aaa.com">http://www.aaa.com</a>

 <a href="http://www.bbb.com">http://www.bbb.com</a>

 <a href="http://www.ccc.com">http://www.ccc.com</a>

 <a href="http://www.ddd.com">http://www.ddd.com</a>

</links>

Элемент xsl:for-each изменяет контекст преобразования. Множество узлов, возвращаемое выражением в атрибуте select, становится текущим множеством узлов, а узел, шаблон для которого выполняется в данный момент, становится текущим узлом.

Как мы знаем, множества узлов в XSLT не имеют внутреннего порядка. Однако, обработка узлов в xsl:for-each будет происходить в так называемом порядке просмотра документа, который зависит от того, какое выражение использовалось для вычисления обрабатываемого множества. Порядок обработки множества узлов в xsl:for-each может быть также изменен элементами xsl:sort, которые могут присутствовать в xsl:for-each. Элемент xsl:sort задает сортировку обрабатываемого множества узлов, изменяя, таким образом, порядок просмотра, что часто бывает очень полезно.

Глава 8 Дополнительные элементы и функции языка XSLT

Дополнительные элементы и функции

В этой главе разбираются дополнительные элементы и функции языка XSLT, которые выполняют в преобразованиях различные задачи, непосредственно не связанные с созданием узлов выходящего документа. Дополнительные элементы и функции XSLT расширяют возможности преобразования, предоставляя разного рода вспомогательный сервис.

К дополнительным элементам XSLT мы отнесем следующие:

□ xsl:preserve-space и xsl:strip-space — работа с пробельными символами;

□ xsl:message — сообщения процессора;

□ xsl:sort — сортировка множеств перед обработкой;

□ xsl:namespace-alias — определение псевдонимов пространств имен;

□ xsl:key — определение ключей;

□ xsl:number — нумерация;

□ xsl:decimal-format — определение десятичного формата;

□ xsl:output — контроль сериализации.

В XSLT также определяются дополнительные функции, расширяющие базовую библиотеку функций XPath:

□ key — использование ключей;

□ format-number — форматирование чисел;

□ document — обращение к внешним документам;

□ current — обращение к текущему узлу преобразования;

□ unparsed-entity-uri — получение URI неразбираемой сущности по ее имени;

□ generate-id — генерация уникального идентификатора узла документа;

□ system-property — получение информации о свойствах системы, окружения.

Обработка пробельных символов

В XSLT выделяются четыре пробельных символа, обработка которых несколько отличается от обработки других символов. Их Unicode-коды и описания сведены в табл. 8.1.

Таблица 8.1. Unicode-коды пробельных символов

Unicode-коды		Описание
Десятичный	Шестнадцатеричный
#9	#x9	Горизонтальная табуляция
#10	#xA	Перевод строки
#13	#xD	Возврат каретки
#32	#x20	Пробел

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

Пример

Рассмотрим шаблон преобразования, содержащий пробельные символы ("□" обозначает пробел, а "¶" — перевод строки).

Листинг 8.1. Шаблон преобразования с пробельными символами

<xsl:template match="/">¶

¶

□□□<a>¶

□□□¶

□□□□□□□□□<b/>¶

□□□□□□¶

□□□□□□□□□</a>¶

¶

</xsl:template>

Поскольку текстовые узлы этого шаблона содержат только пробельные символы, они будут удалены из дерева преобразования, и результат будет иметь вид:

<a><b/></a>

Вообще, текстовый узел будет сохранен при выполнении хотя бы одного из следующих условий.

□ Он содержит хотя бы один непробельный символ.

□ Он принадлежит элементу, в котором сохранение пробельных символов задано средствами XML, а именно атрибутом xml:space со значением preserve.

□ Он принадлежит элементу, имя которого включено во множество имен элементов, для которых нужно сохранять пробельные символы.

Во всех остальных случаях текстовый узел будет удален.

Продемонстрируем все три случая сохранения текстового узла на примерах.

Первый случай довольно прост. Шаблон

<xsl:template match="/">¶

¶

□□<a/>¶

¶

</xsl:template>

создаст в выходящем документе фрагмент

<а/>

безо всяких пробельных символов, в то время как шаблон

<xsl:template match="/">¶

¶

□□|<a/>|¶

¶

</xsl:template>

создаст фрагмент вида

¶

¶

□□|<a/>|¶

¶

Различие двух этих шаблонов в том, что в первом текстовые узлы содержат текст "¶ ¶ □□" и "¶ ¶ " соответственно, а во втором — "¶ ¶ □□|" и "| ¶ ¶". Текстовые узлы второго шаблона не будут удалены, поскольку они содержат непробельные символы (символы "|").

Второй случай сохранения текстовых узлов основан на использовании возможностей XML по управлению пробельными символами. Если в элементе задан атрибут xml:space со значением "preserve", обрабатывающее программное обеспечение должно сохранять в нем и в его потомках пробельные символы. Единственным исключением из этого правила может быть опять же атрибут xml:space, заданный в элементе-потомке со значением "default".

Пример

Шаблон

<xsl:template match="/">¶

□□<а>¶

□□□□<b>¶

□□□□□□<c>¶

□□□□□□□□<d/>¶

□□□□□□</c>¶

□□□□</b>¶

□□</a>¶

</xsl:template>

создаст в выходящем документе фрагмент вида:

<a><b><c><d/></c></b></a>

Если же шаблон будет определен в виде:

<xsl:template match="/">¶

□□<а xml:space="preserve">¶

□□□□<b>¶

□□□□□□<c xml:space="default">¶

□□□□□□□□<d/>¶

□□□□□□</c>¶

□□□□</b>¶

□□</a>¶

</xsl:template>

то в выходящем фрагменте в элементах а и b пробельные символы будут сохранены, а в элементах с и d — удалены:

<а xml:space="preserve">¶

□□□□<b>¶

□□□□□□<c xml: space="default"><d/></c>¶

□□□□</b>¶

□□</а>

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

Для преобразований сохраняющее множество состоит из единственного элемента xsl:text, то есть единственный элемент в преобразовании, для которого пробельные текстовые узлы не будут удаляться, — это элемент xsl:text. Поэтому его часто используют для вывода в выходящем документе пробельных символов.

Для входящих документов сохраняющее множество состоит из имен всех элементов. То есть по умолчанию преобразования сохраняют все пробельные текстовые узлы. Для изменения сохраняющего множества элементов входящего документа используются элементы xsl:preserve-space и xsl:strip-space.

Элементы xsl:preserve-space и xsl:strip-space

Синтаксические конструкции этих элементов очень похожи:

<xsl:preserve-space

 elements="токены"/>

<xsl:strip-space

 elements="токены"/>

Элемент xsl:preserve-space добавляет, a xsl:strip-space удаляет имя элемента из сохраняющего множества входящего документа.

Пример

Предположим, нам нужно сохранять пробельные символы во всех элементах d и удалять их в элементах с. Тогда в преобразовании достаточно указать

<xsl:preserve-space elements="d"/>

<xsl:strip-space elements="c"/>

Вообще, обязательные атрибуты elements элементов xsl:strip-space и xsl:preserve-space содержат не сами имена элементов, а так называемые проверки имен. Проверка имени имеет три варианта синтаксиса.

□ Синтаксис "*" используется для выбора произвольных имен. Ей будут соответствовать любые имена элементов.

□ Синтаксис "имя" используется для выбора элементов с заданным именем. К примеру, проверке имени "d" будут соответствовать все элементы с именем "d".

□ Синтаксис "префикс:*" используется для выбора всех элементов в данном пространстве имен. К примеру, если в документе определен префикс пространства имен upr в виде атрибута xmlns:upr="http://www.upr.com", проверке имени "upr:*" будут соответствовать все элементы пространства имен, определяемого идентификатором "http://www.upr.com".

Пример

Предположим, что нам необходимо сохранить пробельные символы в элементе с именем с и удалить их в элементе e и элементах, принадлежащих пространству имен, определяемому идентификатором "urn:d".

Листинг 8.2. Входящий документ

<а xmlns:d="urn:d">¶

□□<d:b>¶

□□□□<c>¶

□□□□□□</e>¶

□□□□</c>¶

□□</d:b>¶

</a>

Листинг 8.3. Преобразование

<xsl:stylesheet

 version="1.0"

 xmlns:xsl="http://www.w3.org/1999/XSL/Transform">

 <xsl:preserve-space elements="c"/>

 <xsl:strip-space elements="e t:*"

  xmlns:t="urn:d"/>

 <xsl:template match="/">

  <xsl:copy-of select="/"/>

 </xsl:template>

</xsl:stylesheet>

Листинг 8.4. Выходящий документ

<?xml version="1.0" encoding="utf-8"?><a xmlns:d="urn:d">¶

□□<d:b><c>¶

□□□□□□<e/>¶

□□□□</c></d:b>¶

</a>

Сообщения процессора

По большому счету, мы не можем контролировать процесс преобразования. Процессор может сам выбирать, как и в какой последовательности он будет выполнять те или иные шаблоны — таковы особенности декларативного программирования. Вместе с тем мы все-таки можем получить кое-какую информацию о ходе преобразования, используя механизм, называемый в XSLT сообщениями.

Элемент xsl:message

Синтаксис этого элемента дан ниже:

<xsl:message

 terminate="yes" | "no">

 <!-- Содержимое: шаблон -->

</xsl:message>

Элемент xsl:message указывает процессору на то, что он должен вывести сообщение, которое является результатом обработки шаблона, содержащегося в этом элементе. Механизм вывода сообщения зависит от реализации того или иного процессора и может быть различным — от вывода текста сообщения на экран до вызова внешнего модуля для обработки сообщения.

Пример

Иногда в процессе отладки преобразования бывает полезно выводить сообщения о том, какой элемент обрабатывается в данный момент.

Листинг 8.5. Входящий документ

<a><b><c><d/></c></b></a>

Листинг 8.6. Преобразование

<xsl:stylesheet

 version="1.0"

 xmlns:xsl="http://www.w3.org/1999/XSL/Transform">

 <xsl:template match="*">

  <element name="{name()}">

   <xsl:message>

    <xsl:text>Processing element </xsl:text>

    <xsl:value-of select="name()"/>

    <xsl:if test="parent::*">

     <xsl:text> which has a parent element </xsl:text>

     <xsl:value-of select="name(..)"/>

    </xsl:if>

    <xsl:text>.</xsl:text>

   </xsl:message>

   <xsl:apply-templates/>

  </element>

 </xsl:template>

</xsl:stylesheet>

Листинг 8.7. Выходящий документ

<element name="a">

 <element name="b">

  <element name="c">

   <element name="d"/>

  </element>

 </element>

</element>

Листинг 8.8. Сообщения процессора

Processing element a.

Processing element b which has a parent element a.

Processing element с which has a parent element b.

Processing element d which has a parent element c.

Атрибут terminate указывает на то, должен ли процессор прекратить дальнейшую обработку документа или нет. Значением этого атрибута по умолчанию является "no", что означает, что процессор должен просто вывести сообщения и продолжать дальнейшее выполнение шаблона. Если же в xsl:message указано terminate="yes", то процессор, выведя сообщение, прервет обработку. Этот прием может использоваться, например, для того, чтобы проверять входящие документы на соответствие определенной схеме.

Пример

При помощи xsl:message мы можем запретить обработку документов, которые не имеют в корне элемент с именем "html" в любом регистре символов.

Листинг 8.9. Шаблон преобразования

<xsl:template match="/">

 <xsl:if test="translate(name(*),'html','HTML')!='HTML'">

  <xsl:message terminate="yes">

   <xsl:text>Document has no root HTML element.</xsl:text>

  </xsl:message>

 </xsl:if>

</xsl:template>

Если мы будем обрабатывать документ вида

<hTmL>

 <body/>

</hTmL>

обработка не будет прервана, в то время как преобразование документа

<ht-ml>

 <body/>

</ht-ml>

будет прервано сообщением:

Document has no root HTML element:

Processing terminated using xsl:message

Сортировка

При преобразовании документа элементами xsl:for-each и xsl:apply-templates, выбранные узлы по умолчанию обрабатываются в порядке просмотра документа, который зависит от выражения, использованного в атрибуте select этих элементов. XSLT позволяет изменять этот порядок посредством использования механизма сортировки.

Элементы xsl:for-each и xsl:apply-templates могут содержать один или несколько элементов xsl:sort, которые позволяют предварительно сортировать обрабатываемое множество узлов.

Элемент xsl:sort

Синтаксис этого элемента определяется в XSLT как:

<xsl:sort

 select = "выражение"

 lang = "язык"

 data-type = "text" | "number" | "имя"

 order = "ascending" | "descending"

 case-order = "upper-first" | "lower-first" />

В случае если xsl:for-each и xsl:apply-templates содержат элементы xsl:sort, обработка множества узлов должна производиться не в порядке просмотра документа, а в порядке, который определяется ключами, вычисленными при помощи xsl:sort. Первый элемент xsl:sort, присутствующий в родительском элементе, определяет первичный ключ сортировки, второй элемент — вторичный ключ, и так далее.

Элемент xsl:sort обладает атрибутом select, значением которого является выражение, называемое также ключевым выражением. Это выражение вычисляется для каждого узла обрабатываемого множества, преобразуется в строку и затем используется как значение ключа при сортировке. По умолчанию значением этого атрибута является ".", что означает, что в качестве значения ключа для каждого узла используется его строковое значение.

После этих вычислений узлы обрабатываемого множества сортируются по полученным строковым значениям своих ключей и обрабатываются в новом порядке. Если ключи некоторых узлов совпадают, они могут быть в дальнейшем отсортированы вторичными и так далее ключами.

Элемент xsl:sort может иметь следующие необязательные атрибуты, которые указывают некоторые параметры сортировки.

□ Атрибут order определяет порядок, в котором узлы должны сортироваться по своим ключам. Этот атрибут может принимать только два значения — "ascending", указывающее на восходящий порядок сортировки, и "descending", указывающее на нисходящий порядок. Значением по умолчанию является "ascending", то есть восходящий порядок.

□ Атрибут lang определяет язык ключей сортировки. Дело в том, что в разных языках символы алфавита могут иметь различный порядок, что, соответственно, должно учитываться при сортировке. Атрибут lang в XSLT может иметь те же самые значения, что и атрибут xml:lang (например: "en", "en-us", "ru" и т.д.). Если значение этого атрибута не определено, процессор может либо определять язык исходя из параметров системы, либо сортировать строки исходя из порядка кодов символов Unicode.

□ Атрибут data-type определяет тип данных, который несут строковые значения ключей. Техническая рекомендация XSLT разрешает этому атрибуту иметь следующие значения:

 • "text" — ключи должны быть отсортированы в лексикографическом порядке исходя из языка, определенного атрибутом lang или параметрами системы;

 • "number" — ключи должны сравниваться в численном виде. Если строковое значение ключа не является числом, оно будет преобразовано к не-числу (NaN), и, поскольку нечисловые значения неупорядочены, соответствующий узел может появиться в отсортированном множестве где угодно;

 • "имя" — в целях расширяемости XSLT также позволяет указывать в качестве типа данных произвольное имя. В этом случае реализация сортировки полностью зависит от процессора;

 • значением атрибута data-type по умолчанию является "text".

□ Атрибут case-order указывает на порядок сортировки символов разных регистров. Значениями этого атрибута могут быть "upper-first", что означает, что заглавные символы должны идти первыми, или "lower-first", что означает, что первыми должны быть строчные символы. К примеру, строки "ночь", "Улица", "фонарь", "Аптека", "НОЧЬ", "Фонарь" при использовании case-order="upper-first" будут иметь порядок "Аптека", "НОЧЬ", "ночь", "Фонарь", "фонарь", "улица". При использовании case-order="lower-first" те же строки будут идти в порядке "Аптека", "ночь", "НОЧЬ", "фонарь", "Фонарь", "улица". Значение case-order по умолчанию зависит от процессора и языка сортировки. В большинстве случаев заглавные буквы идут первыми.

Как можно видеть, элемент xsl:sort определяет сортировку достаточно гибко, но вместе с тем не следует забывать, что эти возможности могут быть реализованы в процессорах далеко не полностью. Поэтому одна и та же сортировка может быть выполнена в разных процессорах по-разному.

Приведем простой пример сортировки имен и фамилий.

Рассмотрим пример.

Листинг 8.10. Входящий документ

<list>

 <person>

  <name>William</name>

  <surname>Gibson</surname>

 </person>

 <person>

  <name>William</name>

  <surname>Blake</surname>

 </person>

 <person>

  <name>John</name>

  <surname>Fowles</surname>

 </person>

</list>

Отсортируем этот список сначала по именам в убывающем, а затем по фамилиям в возрастающем порядке.

<xsl:template match="list">

 <xsl:copy>

  <xsl:for-each select="person">

   <xsl:sort select="name" order="descending"/>

   <xsl:sort select="surname"/>

   <xsl:copy-of select="."/>

  </xsl:for-each>

 </xsl:copy>

</xsl:template>

Листинг 8.12. Выходящий документ

<list>

 <person>

  <name>William</name>

  <surname>Blake</surname>

 </person>

 <person>

  <name>William</name>

  <surname>Gibson</surname>

 </person>

 <person>

  <name>John</name>

  <surname>Fowles</surname>

 </person>

</list>

К сожалению, сортировкой нельзя управлять динамически. Все атрибуты элемента xsl:sort должны обладать фиксированными значениями.

Псевдонимы пространств имен

Любопытным фактом является то, что XML-документ, являющийся результатом выполнения XSLT-преобразования, может и сам быть XSLT- преобразованием. Иными словами, преобразования могут генерироваться другими преобразованиями. В некоторых случаях такая возможность будет очень полезна, например, входящий XML-документ может описывать преобразование, которое нужно сгенерировать.

Листинг 8.13. XML-документ, описывающий требуемое преобразование

<transform>

 <remove select="a"/>

 <replace select="b" with="B"/>

 <replace select="c" with="C"/>

</transform>

Приведенный выше документ описывает преобразование, которое должно удалять из входящего документа элементы а, а элементы b и c заменять элементами B и C соответственно. Такое преобразование может выглядеть следующим образом.

Листинг 8.14. Преобразование

<xsl:stylesheet

 version="1.0"

 xmlns:xsl="http://www.w3.org/1999/XSL/Transform">

 <xsl:template match="a"/>

 <xsl:template match="b">

  <xsl:element name="B">

   <xsl:apply-templates/>

  </xsl:element>

 </xsl:template>

 <xsl:template match="c">

  <xsl:element name="C">

   <xsl:apply-templates/>

  </xsl:element>

 </xsl:template>

 <xsl:template match="@*|node()">

  <xsl:copy>

   <xsl:apply-templates select="@*|node()"/>

  </xsl:copy>

 </xsl:template>

</xsl:stylesheet>

Преобразование, генерирующее такой код, не представляет особой сложности. Например, шаблон для обработки элемента replace может иметь следующий вид:

<xsl:template match="replace">

 <xsl:element name="xsl:template">

  <xsl:attribute name="match">

   <xsl:value-of select="@select"/>

  </xsl:attribute>

  <xsl:element name="xsl:element">

   <xsl:attribute name="name">

    <xsl:value-of select="@with"/>

   </xsl:attribute>

   <xsl:element name="xsl:apply-templates"/>

  </xsl:element>

 </xsl:element>

</xsl:template>

Шаблон этот выглядит очень громоздко, потому что мы не могли просто включить в него создаваемое правило: поскольку мы создаем элементы в пространстве имен XSLT, находясь в шаблоне, они воспринимались бы не как генерируемые, а как принадлежащие генерирующему преобразованию. Очевидно, что шаблон вида

<xsl:template match="replace">

 <xsl:template match="{@select}">

  <xsl:element name="{@with}">

   <xsl:apply-templates/>

  </xsl:element>

 </xsl:template>

</xsl:template>

был бы некорректен. По этой причине нам пришлось генерировать все инструкции при помощи xsl:element и xsl:attribute, что сделало шаблон громоздким и малопонятным.

Если внимательно рассмотреть проблему, то окажется, что она состоит в том, что мы хотим в преобразовании использовать элементы одного пространства имен так, как если бы они относились к другому пространству.

К счастью, XSLT предоставляет легкий и удобный способ для решения такого рода задачи: пространству имен можно назначить псевдоним при помощи элемента xsl:namespace-alias.

Элемент xsl:namespace-alias

Синтаксическая конструкция этого элемента выглядит следующим образом:

<xsl:namespace-alias

 stylesheet-prefiх="префикс" | "#default"

 result-prefix="префикс" | "#default"/>

Элемент xsl:namespace-alias назначает пространству имен выходящего документа пространство имен, которое будет подменять его в преобразовании, иначе говоря — псевдоним.

Обязательный атрибут result-prefix указывает, какому пространству имен назначается псевдоним. Обязательный атрибут stylesheet-prefix указывает, какое пространство имен будет использоваться в качестве его псевдонима в преобразовании. Оба атрибута содержат префиксы пространств имен, которые, естественно, должны быть ранее объявлены в преобразовании.

Пример

Возвращаясь к генерации преобразования, мы можем изменить пространство имен генерируемых элементов так, чтобы они не воспринимались процессором как элементы XSLT. Для того чтобы в выходящем документе эти элементы все же принадлежали пространству имен XSLT, измененное пространство имен в преобразовании должно указываться как псевдоним этого пространства.

Листинг 8.15. Преобразование, использующее псевдонимы пространств имен

<xsl:stylesheet

 version="1.0"

 xmlns:xsl="http://www.w3.org/1999/XSL/Transform"

 xmlns:axsl="http://www.w3.org/1999/XSL/Transform/Alias">

 <xsl:namespace-alias

  stylesheet-prefix="axsl"

  result-prefix="xsl"/>

 <xsl:template match="replace">

  <axsl:template match="{@select}">

   <axsl:element name="{@with}">

    <axsl:apply-templates/>

   </axsl:element>

  </axsl:template>

 </xsl:template>

 <xsl:template match="remove">

  <axsl:template match="{@select}"/>

 </xsl:template>

 <xsl:template match="transform">

  <axsl:stylesheet version="1.0">

   <xsl:apply-templates/>

   <axsl:template match="@*|node()">

    <axsl:copy>

     <axsl:apply-templates select="@*|node()"/>

    </axsl:copy>

   </axsl:template>

  </axsl:stylesheet>

 </xsl:template>

</xsl:stylesheet>

В этом преобразовании элемент xsl:namespace-alias указывает на то, что все элементы, принадлежащие в преобразовании пространству имен с URI

http://www.w3.org/1999/XSL/Transform/Alias

в выходящем документе должны принадлежать пространству имен с URI

http://www.w3.org/1999/XSL/Transform

то есть пространству имен XSLT.

Результатом применения этого преобразования к документу из листинга 8.13 будет следующий документ.

Листинг 8.16. Выходящее преобразование

<axsl:stylesheet

 version="1.0"

 xmlns:axsl="http://www.w3.org/1999/XSL/Transform"

 xmlns:xsl="http://www.w3.org/1999/XSL/Transform">

 <axsl:template match="a"/>

 <axsl:template match="b">

  <axsl:element name="B">

   <axsl:apply-templates/>

  </axsl:element>

 </axsl:template>

 <axsl:template match="c">

  <axsl:element name="C">

   <axsl:apply-templates/>

  </axsl:element>

 </axsl:template>

 <axsl:template match="@*|node()">

  <axsl:copy>

   <axsl:apply-templates select="@*|node()"/>

  </axsl:copy>

 </axsl:template>

</axsl:stylesheet>

В этом сгенерированном преобразовании элементы имеют префикс axsl, но при этом принадлежат пространству имен XSLT.

Атрибуты stylesheet-prefix и result-prefix элемента xsl:namespace-alias могут иметь значения "#default". Определение вида

<xsl:namespace-alias

 stylesheet-prefix="a"

 result-prefix="#default"/>

означает, что элементы, принадлежащие в преобразовании пространству имен а, в выходящем документе должны принадлежать пространству имен по умолчанию. Определение вида

<xsl:namespace-alias

 stylesheet-prefix="#default"

 result-prefix="a"/>

означает, что элементы, принадлежащие в преобразовании пространству имен по умолчанию, в выходящем документе должны принадлежать пространству имен а.

Пример

Листинг 8.17. Преобразование

<xsl:stylesheet

 version="1.0"

 xmlns:xsl="http://www.w3.org/1999/XSL/Transform"

 xmlns:a="urn:a"

 xmlns="urn:b">

 <xsl:namespace-alias

  stylesheet-prefix="#default"

  result-prefix="a"/>

 <xsl:namespace-alias

  stylesheet-prefix="a"

  result-prefix="#default"/>

 <xsl:template match="root">

  <result>

   <a:element/>

  </result>

 </xsl:template>

</xsl:stylesheet>

Листинг 8.18. Выходящий документ

<result xmlns="urn:a" xmlns:a="urn:b">

 <a:element/>

</result>

Результатом этого преобразования является то, что пространство имен с URI "urn:а" стало пространством имен по умолчанию, а пространство имен с URI "urn:b" изменило префикс на а.

В преобразованиях можно объявлять несколько псевдонимов пространств имен при условии, что одно и то же пространство имен преобразования не должно быть объявлено элементами xsl:namespace-alias с одинаковым порядком импорта псевдонимом для различных пространств имен выходящего документа.

Пример

Если преобразование a.xsl содержит определение

<xsl:namespace-alias

 stylesheet-prefix="x"

 result-prefix="a"/>

а преобразование b.xsl — определение

<xsl:namespace-alias

 stylesheet-prefix="x"

 result-prefix="b"/>

где в обоих преобразованиях префикс x представляет одно пространство имен, а пространства имен a и b — разные, то преобразование a.xsl не сможет включать преобразование b.xsl и наоборот, потому что они будут иметь одинаковый порядок импорта и содержать элементы xsl:namespace-alias, назначающие разным пространствам имен одинаковые псевдонимы. В одном преобразовании такие псевдонимы также не имеют права встречаться. Если же подобное все же случилось, процессор может сигнализировать ошибку или использовать определение, которое было дано в преобразовании последним.

Совсем иначе обстоит дело с импортированием. При импортировании определения старших в порядке импорта преобразований могут переопределять определения младших преобразований. Таким образом, если преобразование a.xsl будет импортировать преобразование b.xsl, пространство имен x будет назначено псевдонимом пространству имен а и наоборот.

Ключи

Прежде чем мы приступим к разбору ключей, которые являются одной из самых мощных концепций языка XSLT, попробуем решить одну несложную задачку.

Листинг 8.19. Входящий документ

<items>

 <item source="a" name="A"/>

 <item source="b" name="B"/>

 <item source="a" name="C"/>

 <item source="c" name="D"/>

 <item source="b" name="E"/>

 <item source="b" name="F"/>

 <item source="c" name="G"/>

 <item source="a" name="H"/>

</items>

Пусть входящий документ представляет собой список объектов (элементов item), каждый из которых имеет имя (атрибут name) и источник (атрибут source). Требуется сгруппировать объекты по своим источникам и получить документ приблизительно следующего вида.

Листинг 8.20. Требуемый результат

<sources>

 <source name="a">

  <item source="a" name="A"/>

  <item source="a" name="C"/>

  <item source="a" name="H"/>

 </source>

 <source name="b">

  <item source="b" name="B"/>

  <item source="b" name="E"/>

  <item source="b" name="F"/>

 </source>

 <source name="c">

  <item source="c" name="D"/>

  <item source="c" name="G"/>

 </source>

</sources>

Первым шагом на пути решения этой задачи является формулировка в терминах XSLT предложения "сгруппировать объекты по своим источникам". Источник каждого объекта определяется его атрибутом source, значит множество объектов, принадлежащих одному источнику "а", будет определяться путем выборки

/items/item[@source='a']

Тогда для каждого элемента item в его группу войдут элементы, которые будут выбраны выражением

/items/item[@source=current()/@source]

Попробуем использовать этот факт в следующем шаблоне:

<xsl:template match="item">

 <source name="{@source}">

  <xsl:copy-of select="/items/item[@source=current()/@source]"/>

 </source>

</xsl:template>

Как и ожидалось, при применении этого правила к элементам item для каждого из них будет создана группа, принадлежащая тому же источнику, — уже хороший результат, но в условии требуется создать по группе не для каждого объекта, а для каждого источника. Чтобы достичь этого, можно создавать группу только для первого объекта, принадлежащего ей. Провести такую проверку опять же несложно: объект будет первым в группе тогда и только тогда, когда ему не предшествуют другие, элементы item, принадлежащие тому же источнику. Иначе говоря, создаем группы только для тех элементов, для которых выражение

preceding-sibling::item[@source-current()/@source]

будет возвращать пустое множество.

С небольшими добавлениями искомое преобразование целиком будет иметь вид.

Листинг 8.21. Преобразование

<xsl:stylesheet

 version="1.0"

 xmlns:xsl="http://www.w3.org/1999/XSL/Transform">

 <xsl:template match="items">

  <sources>

   <xsl:apply-templates/>

  </sources>

 </xsl:template>

 <xsl:template match="item">

  <xsl:choose>

   <xsl:when

    test="preceding-sibling::item[@source=current()/@source]"/>

   <xsl:otherwise>

    <source name="{@source}">

     <xsl:copy-of select="self::node()

      |following-sibling::item[@source=current()/@source]"/>

    </source>

   </xsl:otherwise>

  </xsl:choose>

 </xsl:template>

</xsl:stylesheet>

Бесспорно, решение было несложным, но довольно громоздким. Самым же узким местом в этом преобразовании является обращение к элементам item источника текущего элемента посредством сравнения атрибутов source.

Проблема совершенно стандартна для многих преобразований: нужно выбирать узлы по определенным признакам, причем делать это нужно как можно более эффективно. Хорошо, что в нашем документе было всего восемь элементов item, но представьте себе ситуацию, когда элементов действительно много.

Проблема, которую мы подняли, достаточно серьезна. Она состоит в оптимизации поиска узлов с определенными свойствами в древовидно организованной структуре.

Попробуем разобраться в смысле фразы "узел обладает определенными свойствами". Очевидно, это означает, что для этого узла выполняется некое логическое условие, иначе говоря, некий предикат обращается в "истину".

Однако какого именно типа условия мы чаще всего проверяем? Анализируя различные классы задач, можно придти к выводу, что в большинстве случаев предикаты являются равенствами — выражениями, которые обращаются в "истину" тогда и только тогда, когда некоторый параметр узла, не зависящий от текущего контекста, равен определенному значению. В нашем примере смысл предиката на самом деле состоит не в том, чтобы проверить на истинность выражение @source=current()/@source, а в том, чтобы проверить на равенство @source и current()/@source.

Если переформулировать это для общего случая, то нам нужно выбрать не те узлы, для которых истинно выражение A=B, скорее нужно выбрать те, для которых значение A равно значению B. Иначе говоря, узел будет идентифицироваться значением в своего свойства A. И если мы заранее вычислим значения свойств A, проблема поиска узлов в дереве сведется к классической проблеме поиска элементов множества (в нашем случае — узлов дерева) по определенным значениям ключей (в нашем случае — значениями свойств A).

Чтобы пояснить это, вернемся к нашему примеру: мы ищем элементы item со значением атрибута source, равным заданному. Свойством, идентифицирующим эти элементы, в данном случае будут значения их атрибутов source, которые мы можем заранее вычислить и включить в табл. 8.2.

Таблица 8.2. Значения атрибута source элементов item

Идентификатор (значение атрибута source)	Элемент item
a	<item source="a" name="A"/>
a	<item source="a" name="C"/>
a	<item source="a" name="H"/>
b	<item source="b" name="B"/>
b	<item source="b" name="E"/>
b	<item source="b" name="F"/>
с	<item source="c" name="D"/>
с	<item source="c" name="G"/>

Таким образом, значение "с" идентифицирует объекты с именами D и G, а значение "а" — объекты с именами A, C и H, причем находить соответствующие элементы в таблице по их ключевому свойству не составляет никакого труда.

Несмотря на то, что произведенные нами манипуляции чрезвычайно просты (и настолько же эффективны), процессор вряд ли в общем случае сможет сделать что-либо подобное сам, и потому очень важной является возможность явным образом выделять в XSLT-преобразованиях ключевые свойства множеств узлов.

В этом разделе мы будем рассматривать две конструкции, позволяющие манипулировать множествами узлов посредством ключей — это элемент xsl:key, который определяет в преобразовании именованный ключ, и функция key, которая возвращает множество узлов, идентифицирующихся заданными значениями ключей.

Элемент xsl:key

Синтаксис элемента несложен:

<xsl:key

 name="имя"

 match="паттерн"

 use="выражение"/>

Элемент верхнего уровня xsl:key определяет в преобразовании ключ именем, заданным в значении атрибута name, значением которого для каждого узла документа, соответствующего паттерну match, будет результат вычисления выражения, заданного в атрибуте use. Ни атрибут use, ни атрибут match не могут содержать переменных.

Пример

В нашем примере элементы item идентифицируются значениями своих атрибутов source. Для их идентификации мы можем определить ключ с именем src следующим образом:

<xsl:key name="src" match="item" use="@source"/>

Следуя строгому определению, данному в спецификации языка, ключом называется тройка вида (node, name, value), где node — узел, name — имя и value — строковое значение ключа. Тогда элементы xsl:key, включенные в преобразование, определяют множество всевозможных ключей обрабатываемого документа. Если этому множеству принадлежит ключ, состоящий из узла x, имени у и значения z, говорят, что узел x имеет ключ с именем у и значением z или что ключ у узла x равен z.

Пример

Ключ src из предыдущего примера определяет множество, которое состоит из следующих троек:

(<item name="A".../>, 'src', 'a')

(<item name="B".../>, 'src', 'b')

(<item name="C".../>, 'src', 'a')

(<item name="D".../>, 'src', 'c')

...

(<item name="H".../>, 'src', 'a')

В соответствии с нашими определениями мы можем сказать, что элемент

<item source="b" name="B"/>

имеет ключ с именем "src" и значением "b" или что ключ "src" элемента

<item source="a" name="H"/>

равен "a".

Для того чтобы обращаться к множествам узлов по значениям их ключей, в XSLT существует функция key, о которой мы сейчас и поговорим.

Функция key

Ниже приведена синтаксическая конструкция данной функции:

node-set key(string, object)

Итак, элементы xsl:key нашего преобразования определили множество троек (node, name, value). Функция key(key-name, key-value)выбирает все узлы x такие, что значение их ключа с именем key-name (первым аргументом функции) равно key-value (второму аргументу функции).

Пример

Значением выражения key('src', 'a') будет множество элементов item таких, что значение их ключа "src" будет равно "а". Попросту говоря, это будет множество объектов источника "а".

Концепция ключей довольно проста, и существует великое множество аналогий в других языках программирования: от хэш-функций до ключей в реляционных таблицах баз данных. По всей вероятности, читателю уже встречалось что-либо подобное.

Но не следует забывать, что язык XSLT — довольно нетрадиционный язык и с точки зрения синтаксиса, и с точки зрения модели данных. Как следствие, ключи в нем имеют довольно много скрытых нюансов, которые очень полезно знать и понимать. Мы попытаемся как можно более полно раскрыть все эти особенности.

Определение множества ключей

Не представляет особой сложности определение множества ключей в случае, если в определении они идентифицируются строковыми выражениями. Например, в следующем определении

<xsl:key name="src" match="item" use="string(@source)"/>

атрибут use показывает, что значением ключа src элемента item будет значение атрибута source. Но что можно сказать о следующем определении:

<xsl:key name="src" match="item" use="@*"/>

Очевидно, это уже гораздо более сложный, но, тем не менее, вполне реальный случай, не вписывающийся в определения, которые давались до сих пор. Мы говорили лишь о том, что множество ключей определяется элементами xsl:key преобразования, но как именно оно определяется — оставалось доселе загадкой. Восполним этот пробел, дав строгое определение множеству ключей.

Узел x обладает ключом с именем у и строковым значением z тогда и только тогда, когда в преобразовании существует элемент xsl:key такой, что одновременно выполняются все нижеперечисленные условия:

□ узел x соответствует паттерну, указанному в его атрибуте match;

□ значение его атрибута name равно имени y;

□ результат u вычисления выражения, указанного в значении атрибута use в контексте текущего множества, состоящего из единственного узла x, удовлетворяет одному из следующих условий:

 • u является множеством узлов и z равно одному из их строковых значений;

 • u не является множеством узлов и z равно его строковому значению.

Без сомнения, определение не из простых. Но как бы мы действовали, если бы физически создавали в памяти множество ключей? Ниже представлен один из возможных алгоритмов:

□ для каждого элемента xsl:key найти множество узлов документа, удовлетворяющих его паттерну match (множество X);

□ для каждого из найденных узлов (x ∈ X) вычислить значение выражения атрибута use (значение u(x));

□ если u(x) является множеством узлов (назовем его Uх), то для каждого uxi ∈ Uх создать ключ (x, n, string(uxi)), где n — имя ключа (значение атрибута name элемента xsl:key);

□ если u(x) является объектом другого типа (назовем его ux), создать ключ (x, n, string(ux)).

Пример

Найдем множество ключей, создаваемое определением

<xsl:key name="src" match="item" use="@*"/>

Имена всех ключей будут одинаковы и равны "src". Множество x узлов, удовлетворяющих паттерну item, будет содержать все элементы item обрабатываемого документа. Значением выражения, заданного в атрибуте use, будет множество всех узлов атрибутов каждого из элементов item. Таким образом, множество узлов будет иметь следующий вид:

(<item name="А".../>, 'src', 'a')

(<item name="А".../>, 'src', 'A')

(<item name="В".../>, 'src', 'b')

(<item name="В".../>, 'src', 'В')

(<item name="С".../>, 'src', 'а')

(<item name="С".../>, 'src', 'С')

(<item name="D".../>, 'src', 'с')

(<item name="D".../>, 'src', 'D')

...

(<item name="H".../>, 'src', 'a')

(<item name="H".../>, 'src', 'H')

В итоге функция key('src', 'a') будет возвращать объекты с именами A, C и H, а функция key('src', 'A') — единственный объект с именем A (поскольку ни у какого другого элемента item нет атрибута со значением "A").

Необходимо сделать следующее замечание: совершенно необязательно, чтобы процессор действительно физически создавал в памяти множества ключей. Это множество определяется чисто логически — чтобы было ясно, что же все-таки будет возвращать функция key. Процессоры могут вычислять значения ключей и искать узлы в документе и во время выполнения, не генерируя ничего заранее. Но большинство процессоров, как правило, все же создают в памяти определенные структуры для манипуляций с ключами. Это могут быть хэш-таблицы, списки, простые массивы или более сложные нелинейные структуры, упрощающие поиск, — важно другое. Важно то, что имея явное определение ключа в xsl:key, процессор может производить такую оптимизацию.

Использование нескольких ключей в одном преобразовании

В случае, когда к узлам в преобразовании нужно обращаться по значениям различных свойств, можно определить несколько ключей — каждый со своим именем. Например, если мы хотим в одном случае обращаться к объектам, принадлежащим одному источнику, а во втором — к объектам с определенными именами, мы можем определить в документе два ключа — один с именем src, второй — с именем name:

<xsl:key name="src" match="item" use="@source"/>

<xsl:key name="name" match="item" use="@name"/>

Множество ключей, созданных этими двумя определениями, будет выглядеть следующим образом:

(<item name="А".../>, 'src', 'а')

(<item name="А".../>, 'name', 'А')

(<item name="В".../>, 'src', 'b')

(<item name="В".../>, 'name', 'В')

(<item name="C".../>, 'src', 'a')

(<item name="C".../>, 'name', 'С')

(<item name="D".../>, 'src', 'с')

(<item name="D".../>, 'name', 'D')

...

(<item name="H".../>, 'src', 'a')

(<item name="H".../>, 'name', 'H')

В этом случае функция key('src', 'а') возвратит объекты с именами A, C и H, а функция key('name', 'а') — объект с именем А.

Имя ключа является расширенным именем. Оно может иметь объявленный префикс пространства имен, например

<xsl:key

 name="data:src"

 match="item"

 use="@source"

 xmlns:data="urn:user-data"/>

В этом случае функция key(key-name, key-value) будет возвращать узлы, значение ключа с расширенным именем key-name которых равно key-value. Совпадение расширенных имен определяется как обычно — по совпадению локальных частей и URI пространств имен.

Использование нескольких определений одного ключа

Процессор должен учитывать все определения ключей данного преобразования — даже если некоторые из них находятся во включенных или импортированных модулях. Порядок импорта элементов xsl:key не имеет значения: дело в том, что определения ключей с одинаковыми именами для одних и тех же узлов, но с разными значениями ключа не переопределяют, а дополняют друг друга.

Пример

Предположим, что в нашем документе имеется несколько элементов item, в которых не указано значение атрибута source, но по умолчанию мы будем причислять их к источнику а. Соответствующие ключи будут определяться следующим образом:

<xsl:key name="src" match="item[@source]" use="@source"/>

<xsl:key name="src" match="item[not(@source)]" use="'a'"/>

To есть для тех элементов item, у которых есть атрибут source, значением ключа будет значение этого атрибута, для тех же элементов, у которых атрибута source нет, его значением будет "а".

Для входящего документа вида

<items>

 <item source="a" name="A"/>

 <item source="b" name="B"/>

 <item source="a" name="C"/>

 <item source="c" name="D"/>

 ...

 <item source="a" name="H"/>

 <item name="I"/>

 <item name="J"/>

 <item name="K"/>

</items>

соответствующее множество ключей будет определяться следующим образом:

(<item name="А".../>, 'src', 'а')

(<item name="В".../>, 'src', 'b')

(<item name="С".../>, 'src', 'а')

(<item name="D".../>, 'src', 'c')

...

(<item name="H".../>, 'src', 'a')

(<item name="I".../>, 'src', 'a')

(<item name="J".../>, 'src', 'a')

(<item name="K".../>, 'src', 'a')

Функция key('src', 'a') возвратит объекты с именами A, C, H, I, J и K.

То, что одни и те же узлы могут иметь разные значения одного ключа, является также очень удобным свойством. Например, два определения ключей, приведенные выше, можно дополнить третьим:

<xsl:key name="src" match="item[not(@source)]" use="'#default'"/>

Это определение позволит по значению "#default" обращаться к объектам, принадлежащим источнику по умолчанию.

Использование множеств узлов в функции key

Функция key принимает на вход два аргумента: первым аргументом является строка, задающая имя ключа, в то время как вторым аргументом может быть объект любого типа. В том случае, если аргумент key-value в функции key(key-name, key-value) является множеством узлов, функция key возвратит все узлы, имеющие ключ key-name со значением, равным хотя бы одному из строковых значений узла множества key-value.

Пример

Предположим, что источники объектов будут сгруппированы следующим образом:

<sources>

 <source name="a"/>

 <source name="c"/>

</source>

Для того чтобы вычислить множество элементов item, принадлежащих любому из источников данной группы, достаточно будет воспользоваться выражением вида

key('src', sources/source/@name)

Множество узлов, выбираемое путем sources/source/@name, будет содержать атрибуты name элементов source. Их строковые значения будут равны а и с, значит, наше выражение возвратит множество элементов item, значение атрибута source которых равно либо а либо с.

Использование ключей в нескольких документах

Ключи, определенные в преобразовании, могут использоваться для выбора узлов в различных обрабатываемых документах. Функция key возвращает узлы, которые принадлежат текущему документу, то есть документу, содержащему текущий узел. Значит, для того, чтобы выбирать узлы из внешнего документа, необходимо сделать текущим узлом один из узлов этого внешнего документа. Контекстный документ может быть легко изменен элементом xsl:for-each, например, для того, чтобы текущим документом стал документ a.xml, достаточно написать

<xsl:for-each select="document('а.xml')">

 <!-- Теперь текущим документом стал документ а.xml -->

</xsl:for-each>

Пример

Предположим, что нам нужно выбрать объекты, принадлежащие источнику a, причем принадлежность объектов определена в двух внешних документах, a.xml и b.xml.

Листинг 8.22. Входящий документ

<source name="a"/>

Листинг 8.23. Документ a.xml

<items>

 <item source="a" name="A"/>

 <item source="b" name="B"/>

 <item source="a" name="C"/>

 <item source="c" name="D"/>

</items>

Листинг 8.24. Документ b.xml

<items>

 <item source="b" name="E"/>

 <item source="b" name="F"/>

 <item source="c" name="G"/>

 <item source="a" name="H"/>

</items>

Листинг 8.25. Преобразование

<xsl:stylesheet

 version="1.0"

 xmlns:xsl="http://www.w3.org/1999/XSL/Transform">

 <xsl:key name="src" match="item" use="@source"/>

 <xsl:template match="source">

  <xsl:variable name="name" select="@name"/>

  <xsl:copy>

   <xsl:for-each select="document('a.xml')|document('b.xml')">

    <xsl:copy-of select="key('src', $name)"/>

   </xsl:for-each>

  </xsl:copy>

 </xsl:template>

</xsl:stylesheet>

Листинг 8.26. Выходящий документ

<source>

 <item source="a" name="A"/>

 <item source="a" name="C"/>

 <item source="a" name="H"/>

</source>

Составные ключи

В теории реляционных баз данных существует такое понятие, как составной ключ. Согласно определению К. Дж. Дейта [Дейт 1999], составной ключ — это "потенциальный ключ; состоящий из более чем одного атрибута".

Хотя концепция ключей в XSLT сильно отличается от того, что называется ключом в реляционных БД, идея весьма и весьма интересна: использовать при обращении к множествам узлов не одно свойство, а некоторую их комбинацию.

Главная проблема состоит в том, что значение ключа в XSLT всегда является строкой, одним из самых примитивных типов. И выбирать множества узлов можно только по одному строковому значению за один раз. Ничего похожего на key(key-name, key-value-1, key-value-2, ...) для выбора узлов, первое свойство которых равно key-value-1, второе — key-value-2 и так далее, XSLT не предоставляет.

Выход достаточно очевиден: если значение ключа не может быть сложной структурой, оно должно выражать сложную структуру. Иными словами, раз значением составного ключа может быть только строка, то эта строка должна состоять из нескольких частей.

Пример

Предположим, что объекты с одинаковыми именами могут принадлежать различным источникам. Покажем, как с помощью ключей можно решить следующие задачи:

□ найти объект с определенным именем и источником;

□ найти объекты с определенным именем;

□ найти объекты с определенным источником.

Листинг 8.27. Входящий документ

<items>

 <item source="a" name="A"/>

 <item source="b" name="B"/>

 <item source="b" name="E"/>

 <item source="b" name="F"/>

 <item source="a" name="C"/>

 <item source="c" name="G"/>

 <item source="a" name="H"/>

 <item source="a" name="B"/>

 <item source="b" name="G"/>

 <item source="c" name="H"/>

 <item source="c" name="C"/>

 <item source="c" name="D"/>

 <item source="b" name="A"/>

 <item source="a" name="B"/>

 <item source="c" name="D"/>

 <item source="c" name="E"/>

 <item source="a" name="F"/>

</items>

Для элементов item мы будем генерировать ключи, значения которых будут состоять из двух частей — источника и имени, разделенных символом "-". Для того чтобы решить одним ключом все три поставленные задачи, мы будем использовать для его определения три элемента xsl:key.

Листинг 8.28. Входящий документ

<xsl:stylesheet

 version="1.0"

 xmlns:xsl="http://www.w3.org/1999/XSL/Transform">

 <xsl:key name="src" match="item" use="concat(@source,'-')"/>

 <xsl:key name="src" match="item" use="concat('-', @name)"/>

 <xsl:key name="src" match="item" use="concat(@source, '-', @name)"/>

 <xsl:template match="/">

  <result>

   <items source="a" name="B">

    <xsl:copy-of select="key('src', 'a-B')"/>

   </items>

   <items name="B">

    <xsl:copy-of select="key('src', '-B')"/>

   </items>

   <items source="a">

    <xsl:copy-of select="key('src', 'a-')"/>

   </items>

  </result>

 </xsl:template>

</xsl:stylesheet>

Листинг 8.29. Выходящий документ

<result>

 <items source="a" name="B">

  <item source="a" name="B"/>

  <item source="a" name="B"/>

 </items>

 <items name="B">

  <item source="b" name="B"/>

  <item source="a" name="B"/>

  <item source="a" name="B"/>

 </items>

 <items source="a">

  <item source="a" name="A"/>

  <item source="a" name="C"/>

  <item source="a" name="H"/>

  <item source="a" name="B"/>

  <item source="a" name="B"/>

  <item source="a" name="F"/>

 </items>

</result>

У приведенного здесь способа формирования ключа есть определенные ограничения: необходимо иметь априорную информацию о строковых значениях каждого из свойств, составляющих наш композитный ключ для того, чтобы корректно формировать его строковые представления. Например, если бы в приведенном выше документе имена объектов и источников могли бы содержать символ "-", было бы непонятно, к какому объекту относится составной ключ "a-b-c": к объекту с источником a-b и именем с или к объекту с источником а и именем b-c. К счастью, в большинстве случаев такая информация имеется, и генерировать составные ключи не очень сложно.

Функция key в паттернах

Разбирая синтаксические правила построения паттернов, мы встретились с особой формой паттерна, в котором могла использоваться функция key. Приведем еще раз эту продукцию:

[PT3] IdKeyPattern ::= 'id' '(' Literal ')'

                       | 'key' '(' Literal ',' Literal ')'

Функция key(key-name, key-value) в паттерне будет соответствовать узлам, значение ключа key-name которых равняется или принадлежит объекту key-value. Это позволяет использовать возможности ключей при проверке узлов на соответствие образцу.

Пример

Предположим, что нам нужно по-особому обработать объекты, принадлежащие источнику а. Для этого мы можем создать шаблон следующего вида.

Листинг 8.30. Шаблон, использующий функцию key в паттерне

<xsl:template match="key('src', 'a')">

 <!-- Содержимое шаблона -->

</xsl:template>

Этот шаблон будет применяться к любым узлам, имеющим ключ src со значением а.

Нумерация

Нумерация, несомненно, является одной из самых естественных проблем, решаемых при помощи XSLT. Задача нумерации состоит в том, чтобы, исходя из позиции обрабатываемого узла в дереве документа, вычислить по заданным критериям его порядковый номер. В качестве примера такого рода задачи можно привести вывод номеров частей, разделов и глав книги, указание номеров элементов списка или строк таблицы.

Для вычисления порядковых номеров узлов в дереве в XSLT существует несколько способов. В простых случаях для достижения цели бывает достаточно воспользоваться одним из следующих XPath-выражений.

□ Для того чтобы получить порядковый номер текущего узла в обрабатываемом множестве, можно использовать функцию position. Обратим внимание, что это будет позиция узла в обрабатываемом в данный момент множестве, а не в дереве исходящего документа.

□ Функция count(preceding-sibling::*)+1 возвращает порядковый номер текущего элемента среди других элементов его родителя, иначе говоря, среди его братьев. Путь выборки preceding-sibling::* выбирает множество братских элементов, предшествующих текущему узлу, а функция count вычисляет их количество. Таким образом, значение count(preceding-sibling::*)+1 будет равно 1 для первого элемента (поскольку ему другие элементы не предшествуют), 2 — для второго (ему предшествует один элемент) и так далее.

□ Для того чтобы учитывать при подсчете только определенные элементы, можно переписать предыдущее выражение в чуть более строгом виде. Например, выражение, считающее только элементы chapter, будет задаваться следующим образом: (preceding-sibling::chapter) +1.

□ Глубина текущего узла от корня дерева может быть вычислена выражением count(ancestor-or-self::node()). Это выражение будет возвращать 1 для корневого узла, 2 для элемента документа и так далее.

Вычислять выражения и выводить вычисленные значения в результирующее дерево следует, как и обычно — при помощи элемента xsl:value-of.

Пример

<xsl:value-of select="count(preceding-sibling::chapter)+1"/>

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

Другим, несравненно более легким и удобным способом нумерации и индексирования узлов является использование элемента xsl:number.

Элемент xsl:number

Синтаксис элемента описывается следующей конструкцией:

<xsl:number

 level="single"

      | "multiple"

      | "any"

 count="паттерн"

 from="паттерн"

 value="выражение"

 format="{строка}"

 lang="{токен}"

 letter-value={ "alphabetic"

              | "traditional" }

 grouping-separator="{символ}"

 grouping-size="{число}"/>

Элемент xsl:number вычисляет номер узла в соответствии с заданными критериями, форматирует его и затем вставляет в результирующее дерево в виде текстового узла. То, что все это выполняется в одном элементе преобразования, имеет существенные преимущества по сравнению с использованием XPath-выражений: программа становится более простой и понятной, причем далеко не в ущерб функциональности.

К сожалению, в этом случае, как и во многих других, универсальность использования повлекла за собой семантическую сложность. Несмотря на то, что xsl:number имеет всего девять атрибутов (причем ни один из них не является обязательным), мы посвятим их описанию значительное количество страниц. Пока же, чтобы сориентировать читателя, мы кратко перечислим назначения атрибутов xsl:number.

□ Атрибут level указывает, на каких уровнях дерева следует искать нумеруемые узлы.

□ Атрибут count указывает, какие именно узлы следует считать при вычислении номера.

□ Атрибут from указывает, в какой части документа будет производиться нумерация.

□ Атрибут value задает выражения, которые следует использовать для вычисления значения номера.

□ Атрибут format определяет, как номер будет форматироваться в строку.

□ Атрибут lang задает языковой контекст нумерации.

□ Атрибут letter-value определяет параметры буквенных методов нумерации.

□ Атрибут grouping-separator задает символ, разделяющий группы цифр в номере.

□ Атрибут grouping-size определяет количество цифр в одной группе.

Выполнение элемента xsl:number можно условно разделить на два этапа — вычисление номера и его строковое форматирование. На этапе вычисления активными являются элементы level, count, from и value. Форматирование производится с учетом значений атрибутов format, lang, letter-value, grouping-separator и grouping-size. Результатом первого этапа является список номеров, который форматируется в текстовый узел на втором этапе.

Вычисление номеров

Пожалуй, самым простым для понимания (но не самым простым в использовании) способом вычисления номера является использование XPath-выражений. Этот способ практически идентичен использованию xsl:value-of, как было показано в начале этой главы. Единственным отличием xsl:number является то, что после вычисления номера он сначала форматируется, а потом уже вставляется в результирующее дерево в виде текстового узла.

Результатом первого этапа форматирования при определенном атрибуте value является список, состоящий из числа, полученного в результате вычисления выражения, указанного в значении этого атрибута.

Пример

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

Листинг 8.31. Входящий документ для примеров преобразований с использованием xsl:number

<doc>

 <chapter title="First chapter">

  <section title="First section">

   <para>paragraph 1</para>

   <para>paragraph 2</para>

   <para>paragraph 3</para>

  </section>

  <section title="Second section">

   <para>paragraph 4</para>

   <para>paragraph 5</para>

  </section>

 </chapter>

 <chapter title="Second chapter">

  <section title="Third section">

   <para>paragraph 6</para>

   <para>paragraph 7</para>

   <para>paragraph 8</para>

   <para>paragraph 9</para>

  </section>

  <section title="Forth section">

   <para>paragraph 10</para>

   <para>paragraph 11</para>

   <para>paragraph 12</para>

  </section>

  <section title="Fifth section">

   <para>paragraph 13</para>

   <para>paragraph 14</para>

   <para>paragraph 15</para>

   <para>paragraph 16</para>

  </section>

 </chapter>

 <chapter title="Third chapter">

  <section title="Sixth section">

   <para>paragraph 17</para>

   <para>paragraph 18</para>

  </section>

 </chapter>

</doc>

В качестве первого примера приведем два шаблона, обрабатывающих элементы chapter: один с использованием xsl:value-of, а второй с использованием xsl:number.

Листинг 8.32. Вариант нумерующего шаблона с использованием xsl:value-of

<xsl:template match="chapter">

 <xsl:value-of select="position()"/>

 <xsl:text>. </xsl:text>

 <xsl:value-of select="@title"/>

 <xsl:text> </xsl:text>

</xsl:template>

Листинг 8.33. Вариант нумерующего шаблона с использованием xsl:number

<xsl:template match="chapter">

 <xsl:number value="position()" format="1. "/>

 <xsl:value-of select="@title"/>

 <xsl:text> </xsl:text>

</xsl:template>

Результат обоих шаблонов имеет следующий вид:

1. First chapter

2. Second chapter

3. Third chapter

Использование xsl:number даже в этом простом случае сэкономило одну строчку в коде. Однако, если бы вместо нумерации арабскими цифрами (1, 2, 3 и т.д.) нужно было применить нумерацию римскими цифрами (I, II, III и т.д.), в преобразовании с xsl:number мы бы изменили всего один символ (вместо format="1. " указали бы format="I. "), в то время как в преобразовании с xsl:value-of пришлось бы писать сложную процедуру преобразования числа в римскую запись.

В том случае, если атрибут value опущен, номера элементов вычисляются исходя из значений атрибутов level, count и from.

Атрибут level имеет три варианта значений: single, multiple и any, значением по умолчанию является single. Процедура вычисления номеров существенным образом зависит от того, какой из этих вариантов используется — при методе single считаются элементы на одном уровне, при методе multiple — на нескольких уровнях и при методе any — на любых уровнях дерева. Алгоритм вычисления списка номеров в каждом из случаев не слишком сложен, но понять его только по формальному описанию довольно непросто. Поэтому каждый из методов будет дополнительно проиллюстрирован примерами вычисления.

Атрибут count содержит паттерн, которому должны удовлетворять нумеруемые узлы. Узлы, не соответствующие этому образцу, просто не будут приниматься в расчет. Значением этого атрибута по умолчанию является паттерн, выбирающий узлы с тем же типом и именем, что и у текущего узла (если, конечно, у него есть имя).

Атрибут from содержит паттерн, который определяет так называемую область нумерации, или область подсчета. При вычислении номера будут приниматься во внимание только те нумеруемые узлы, которые принадлежат этой области. По умолчанию областью подсчета является весь документ.

Метод single

Метод single используется для того, чтобы вычислить номер узла, основываясь на его позиции среди узлов того же уровня. Нумерацию, в которой используется метод single, также называют одноуровневой нумерацией.

Областью нумерации этого метода будет множество всех потомков ближайшего предка текущего узла, удовлетворяющего паттерну, указанному в атрибуте from.

Вычисление номера производится в два шага.

□ На первом шаге находится узел уровня дерева. Узлом уровня будет узел, удовлетворяющий следующим условиям:

 • он является первым (то есть ближайшим к текущему) узлом, принадлежащим оси ancestor-or-self текущего узла;

 • он удовлетворяет паттерну count;

 • он принадлежит области подсчета;

 • если такого узла нет, список номеров будет пустым.

□ На втором шаге вычисляется номер узла уровня. Этот номер будет равен 1 плюс количество узлов, принадлежащих оси навигации preceding-sibling и удовлетворяющих паттерну count.

Надо сказать, от атрибута from в методе single мало пользы. Единственный эффект, который можно от него получить, — это пустой список номеров в случае, если первый узел, принадлежащий оси ancestor-or-self и удовлетворяющий паттерну count, не будет иметь предка, соответствующего паттерну атрибута from.

Пример

Разберем функционирование одноуровневой нумерации в следующем шаблоне:

<xsl:template match="para">

 <xsl:number format="     1." count="section"/>

 <xsl:number format="1." count="para"/>

 <xsl:value-of select="."/>

 <xsl:text> </xsl:text>

</xsl:template>

Мы продемонстрируем вычисление номера одного из элементов para на схематическом изображении дерева обрабатываемого документа (рис. 8.1). Узел обрабатываемого элемента мы выделим полужирной линией, узел элемента doc пометим буквой d, узлы элементов chapter — буквой с, элементов section и para — буквами s и p соответственно.

Рис. 8.1. Дерево обрабатываемого документа

В качестве первого примера приведем вычисление номера элементом

<xsl:number format="     1." count="section"/>

На первом шаге нам нужно найти узел уровня дерева. Этим узлом будет первый элемент section, являющийся предком текущего узла. На рис. 8.2 он обведен пунктиром.

Рис. 8.2. Первый шаг вычисления номера

Номер этого элемента будет равен 1 плюс количество предшествующих ему братских элементов section. Это множество выделено пунктиром на рис. 8.3.

Рис. 8.3. Второй шаг вычисления номера

Выделенное множество содержит два узла. Таким образом, искомый номер будет равен 3.

Проведем такой же разбор для определения

<xsl:number format="1." count="para"/>

В этом случае паттерну, указанному в элементе count удовлетворяет сам текущий узел, значит, он и будет являться узлом уровня, как это показано на рис. 8.4.

Рис. 8.4. Первый шаг вычисления номера

Выделим множество элементов para, являющихся братьями узла уровня и предшествующих ему (рис. 8.5).

Рис. 8.5. Второй шаг вычисления номера

Выделенное множество содержит всего один узел, значит, искомый номер будет равен 2.

Таким образом, результатом обработки выделенного элемента para будет следующая строка:

    3.2.paragraph 14

Метод multiple

Метод multiple похож на метод single, но при этом он немного сложнее, поскольку вычисляет номера узлов сразу на нескольких уровнях дерева. Нумерацию с применением метода multiple называют также многоуровневой нумерацией.

Область нумерации метода multiple определяется так же, как и в случае с методом single: учитываются только потомки ближайшего предка текущего узла, удовлетворяющего паттерну, указанному в атрибуте from.

Вычисление списка номеров узлов выполняется в два этапа:

□ На первом этапе выбирается множество нумеруемых узлов, удовлетворяющее следующим условиям:

 • его узлы принадлежат оси навигации ancestor-or-self текущего узла;

 • его узлы соответствуют паттерну count;

 • его узлы принадлежат области подсчета.

□ На втором этапе для каждого узла нумеруемого множества вычисляется позиция среди собратьев. Позиция нумеруемого узла будет равна 1 плюс количество узлов, принадлежащих его оси навигации preceding-sibling и соответствующих паттерну count.

Пример

Для демонстрации вычисления номеров на нескольких уровнях дерева документа проследим за выполнением инструкции

<xsl:number

 format="     1.1."

 level="multiple"

 count="doc|chapter|para"

 from="doc"/>

при обработке того же элемента para.

Прежде всего, надо определить область подсчета. Значением атрибута from является паттерн doc, значит, подсчет будет вестись среди всех потомков ближайшего к текущему элементу para предка, который является элементом doc. Это множество выделено на рис. 8.6 штрих-пунктирной линией.

Рис. 8.6. Определение области подсчета

Следующим шагом выберем узлы, принадлежащие оси навигации ancestor-or-self текущего узла para и удовлетворяющие паттерну doc|chapter|para. Это множество будет включать сам текущий элемент, а также его предки chapter и doc. На рис. 8.7 они обведены пунктиром.

Рис. 8.7. Первый шаг вычисления номера

Следующим шагом оставим только те из выбранных узлов, которые входят в область подсчета. Эти узлы обведены на рис. 8.8 пунктиром.

Рис. 8.8. Второй шаг вычисления номера

Мы получили множество узлов, состоящее всего из двух элементов — chapter и para вследствие того, что элемент doc был исключен как не входящий в область подсчета. Выделим множества пересчитываемых узлов, предшествующих нумеруемым элементам (рис. 8.9).

Рис. 8.9. Третий шаг вычисления номера

В этом примере элемент chapter, так же как и элемент para, будет иметь номер 2. Соответственно, результатом выполнения инструкции xsl:number в этом случае будет строка

     2.2.paragraph 14

Метод any

Метод any используется для того, чтобы вычислить номер узла, основываясь на его позиции среди всех учитываемых узлов элемента.

Областью нумерации этого метода будет множество всех узлов, следующих в порядке просмотра документа за первым предком текущего узла, который удовлетворяет паттерну, указанному в атрибуте from.

Номер вычисляется как 1 плюс количество узлов области подсчета, удовлетворяющих паттерну count и предшествующих в порядке просмотра документа текущему узлу.

Пример

В качестве примера применения метода any вычислим порядковый номер элемента para среди всех элементов документа, начиная со второй главы. Инструкцию такого рода мы запишем в виде

<xsl:number

 format="     1."

 level="any"

 count="*"

 from="chapter[2]"/>

При ее выполнении мы сначала определим область, в которой будут подсчитываться узлы (обведены штрих-пунктирной линией на рис. 8.10).

Рис. 8.10. Определение области подсчета узлов

Следующим шагом выделим подмножество области подсчета, предшествующее в порядке просмотра текущему узлу para (рис. 8.11).

Рис. 8.11. Первый шаг вычисления номера

Выделенное множество содержит 11 узлов, значит, искомый номер будет равен 12.

Перед тем, как перейти к рассмотрению способов форматирования номеров, приведем итоговый пример (листинг 8.34), в котором в шаблонах будут использоваться все три метода нумерации.

Листинг 8.34. Шаблон, использующий разные методы нумерации

<xsl:stylesheet

 version="1.0"

 xmlns:xsl="http://www.w3.org/1999/XSL/Transform"»

 <xsl:template match="doc">

  <xsl:text>Resulting document </xsl:text>

  <xsl:text>================== </xsl:text>

  <xsl:apply-templates select="chapter"/>

 </xsl:template>

 <xsl:template match="chapter">

  <xsl:number format="1. "/>

  <xsl:value-of select="@title"/>

  <xsl:text> </xsl:text>

  <xsl:apply-templates select="section"/>

 </xsl:template>

 <xsl:template match="section">

  <xsl:number format="   1.1 "

   level="multiple"

   count="chapter|section"/>

  <xsl:value-of select="@title"/>

  <xsl:text> </xsl:text>

  <xsl:apply-templates select="para"/>

 </xsl:template>

 <xsl:template match="para">

  <xsl:number

   format="     a) "

   level="any"

   count="para"/>

  <xsl:value-of select="."/>

  <xsl:text> </xsl:text>

 </xsl:template>

</xsl:stylesheet>

Опишем словесно нумерацию, которая будет применяться в этом преобразовании.

□ Элементы chapter будут нумероваться в соответствии со своей позицией среди других элементов chapter того же уровня.

□ Элементы section будут нумероваться при помощи многоуровневой нумерации — номер будет состоять из номера элемента chapter и номера самого элемента section.

□ Элементы para будут нумероваться исходя из своей позиции среди всех остальных элементов para вне зависимости от того, на каких уровнях в документе они находятся.

Результатом применения этого преобразования к документу, приведенному в листинге 8.31, будет следующий текст.

Листинг 8.35. Выходящий документ

Resulting document

==================

1. First chapter

  1.1 First section

     a) paragraph 1

     b) paragraph 2

     c) paragraph 3

  1.2. Second section

     d) paragraph 4

     e) paragraph 5

2. Second chapter

  2.1 Third section

     f) paragraph 6

     g) paragraph 7

     h) paragraph 8

     i) paragraph 9

  2.2 Forth section

     j) paragraph 10

     k) paragraph 11

     l) paragraph 12

  2.3 Fifth section

     m) paragraph 13

     n) paragraph 14

     o) paragraph 15

     p) paragraph 16

3. Third chapter

  3.1 Sixth section

     q) paragraph 17

     r) paragraph 18

Форматирование номеров

Возвращаясь немного назад, напомним, что результатом первого этапа выполнения xsl:number является список номеров, который может быть пустым или содержать одно или несколько чисел. Несложно увидеть, что количество номеров в этом списке будет зависеть от следующих условий.

□ Список номеров будет пустым, если в области нумерации не оказалось нумеруемых узлов.

□ Список номеров будет состоять не более чем из одного числа при использовании методов single и any.

□ Список номеров будет состоять из нуля или более чисел (по одному на каждый уровень нумерации) при использовании метода multiple.

На этапе форматирования список номеров преобразуется в строку и вставляется результирующее дерево в виде текстового узла.

Преобразование номеров из списка в строку имеет совершенно иной характер, нежели чем приведение числа к строковому типу. При форматировании номера нужно получить не просто строковое представление числа, здесь требуется сгенерировать значащий текстовый индекс, который совершенно необязательно должен иметь цифровую запись.

Форматирование списка номеров производится в соответствии со значениями атрибутов format, lang, letter-value, grouping-separator и grouping-size, назначение и использование которых мы и будем разбирать в этом разделе.

Основным атрибутом форматирования является атрибут format, который содержит последовательность форматирующих токенов. Каждый форматирующий токен состоит из букв и цифр; он определяет процедуру форматирования для каждого числа из списка форматируемых номеров. В значении атрибута format форматирующие токены отделяются друг от друга сочетаниями символов, которые не являются буквами и цифрами. Такие сочетания называются разделяющими последовательностями. При форматировании они остаются в строковом выражении номера без изменений.

Пример

В примере к методу multiple мы использовали следующий элемент xsl:number:

<xsl:number

 format="     1.1."

 level="multiple"

 count="doc|chapter|para"

 from="doc"/>

Разберем строение атрибута format этого элемента (на рис. 8.12 пробелы обозначены символами "□"):

Рис. 8.12. Строение атрибута format элемента xsl:number

Список номеров в том примере состоял из номера элемента chapter (числа 2) и номера элемента para (тоже 2). Номер, генерируемый элементом xsl:number, будет состоять из:

□ разделяющей последовательности "□□□□□", которая будет скопирована, как есть;

□ числа 2, которое получается в результате форматирования номера 2 форматирующим токеном "1";

□ разделяющего символа ".";

□ числа 2, которое получается в результате форматирования номера 2 вторым форматирующим токеном "1";

□ разделяющего символа ".".

Объединив все эти части, мы получим отформатированный номер "□□□□□2.2".

Несложно заметить, что главную роль при преобразовании списка номеров в их строковое представление играют форматирующие токены. Каждый такой токен преобразовывает соответствующий ему номер в строку. В табл. 8.3 мы приведем описания этих преобразований.

Таблица 8.3. Форматирующие токены

Токен	Описание	Примеры
		Токен	Преобразование
1	Форматирует номер в виде строкового представления десятичного числа	1	1 → '1'
		1	2 → '2'
		1	10 → '10'
		1	999 → '999'
		1	1000 → '1000'
0...01	Форматирует номер в виде строкового представления десятичного числа; если получившая строка короче токена, она дополняется предшествующими нулями	0001	1 → '0001'
		001	2 → '002'
		001	10 → '010'
		01	999 → '999'
		00001	1000 → '01000'
A	Форматирует номер в виде последовательности заглавных букв латинского алфавита	A	1 → 'A'
		A	2 → 'B'
		A	10 → 'J'
		A	27 → 'AA'
		A	999 → 'ALK'
		A	1000 → 'ALL'
a	Форматирует номер в виде последовательности строчных букв латинского алфавита	a	1 → 'a'
		a	2 → 'b'
		a	10 → 'j'
		a	27 → 'aa'
		a	999 → 'alk'
		a	1000 → 'all'
I	Форматирует номер заглавными римскими цифрами	I	1 → 'I'
		I	2 → 'II'
		I	10 → 'X'
		I	27 → 'XXVII'
		I	999 → 'IM'
		I	1000 → 'M'
i	Форматирует номер строчными римскими цифрами	i	1 → 'i'
		i	2 → 'ii'
		i	10 → 'x'
		i	27 → 'xxvii'
		i	999 → 'im'
		i	1000 → 'm'
Другой	Форматирует номер k как k-й член последовательности, начинающейся этим токеном. Если нумерация таким токеном не поддерживается, вместо него используется токен 1.	Не поддерживающийся токен	1 → '1'
		b	10 → 'k'
		Б	2 → 'В'
		Б	27 → 'Ы'
		á	999 → 'ανψ'
		å	1000 → 'βζο'

При использовании алфавитной нумерации процессор может учитывать значение атрибута lang элемента xsl:number для того, чтобы использовать буквы алфавита соответствующего языка. Однако на практике возможность эта поддерживается очень слабо: большинство процессоров поддерживают алфавитную нумерацию только с использованием латиницы. Поэтому для того, чтобы использовать при алфавитной нумерации кириллицу, вместо атрибута lang следует использовать форматирующие токены "А" (русская заглавная буква "А") и "&#х430;" (русская строчная буква "а").

Пример

Для форматирования номеров в последовательности 1.1.a, 1.1.б, 1.1.в, …, 1.2.а и так далее можно использовать объявление вида:

<xsl:number

 format="1.&#х430;"

 level="multiple"

 count="chapter|section"

 from="doc"/>

Представим теперь себе следующую ситуацию: нам нужно начать нумерацию с латинской буквы i для того, чтобы получить последовательность номеров вида i, j, k, l, m и так далее. Первое, что приходит в голову — это запись вида

<xsl:number format="i" ... />

Однако вместо требуемой последовательности мы получим последовательность строчных римских цифр: i, ii, iii и так далее. Иными словами, некоторые форматирующие токены определяют нумерующую последовательность двусмысленно: одним вариантом является алфавитная последовательность, начинающаяся этим токеном, другим — некая традиционная для данного языка (например, последовательность римских цифр для английского).Для того чтобы различать эти последовательности в двусмысленных ситуациях, в xsl:number существует атрибут letter-value. Если его значением является "alphabetic", нумерующая последовательность является алфавитной, значение "traditional" указывает на то, что следует использовать традиционный для данного языка способ. Если атрибут letter-value опущен, процессор может сам выбирать между алфавитным и традиционным способами нумерации.

При использовании цифровых форматов нумерации (иными словами, токенов вида 1, 01, 001 и так далее) цифры в номере можно разделить на группы, получив, например, такие номера как "2.00.00" из 20000 или "0-0-0-2" из 2. Для этой цели в xsl:number используется пара атрибутов grouping-separator и grouping-size.

Атрибут grouping-separator задает символ, который следует использовать для разбивки номера на группы цифр, в то время как grouping-size указывает размер группы. Эти атрибуты всегда должны быть вместе — если хотя бы один из них опущен, второй просто игнорируется.

Пример

Элемент xsl:number вида

<xsl:number

 format="[00000001]"

 grouping-separator="."

 grouping-size="2"/>

будет генерировать номера в следующей последовательности:

1 → '[00.00.00.01]'

2 → '[00.00.00.02]'

...

999 → '[00.00.09.99]'

1000 → '[00.00.10.00]'

Пожалуй, следует упомянуть, что в значениях атрибутов format, lang, letter-value, grouping-size и grouping-separator могут быть указаны шаблоны значений, иными словами могут использоваться выражения в фигурных скобках. Это может быть полезно, например, для того, чтобы сгенерировать форматирующие токены во время выполнения преобразования.

Пример

В следующем шаблоне формат номера секции зависит от значения атрибута format ее родительского узла:

<xsl:template match="section">

 <xsl:number

  format="{../@format}-1 "

  level="multiple"

  count="chapter|section"/>

 <xsl:value-of select="@title"/>

</xsl:template>

При обработке входящего документа

<doc>

 <chapter format="I" title="First Chapter">

  <section title="First Section"/>

  <section title="Second Section"/>

  <section title="Third Section"/>

 </chapter>

</doc>

нумерация секций будет выглядеть как

I-1 First Section

I-2 Second Section

I-3 Third Section

Если же атрибут format элемента chapter будет иметь значение 1, секции будут пронумерованы в виде

1-1 First Section

1-2 Second Section

1-3 Third Section

Форматирование чисел

Мы уже познакомились с функцией языка XPath string, которая конвертирует свой аргумент в строку. Эта функция может преобразовать в строку и численное значение, но возможности ее при этом сильно ограничены.

К счастью, XSLT предоставляет мощные возможности для форматирования строкового представления чисел при помощи функции format-number и элемента xsl:decimal-format.

Функция format-number

Запись функции имеет следующий вид:

string format-number(number, string, string?)

Функция format-number принимает на вход три параметра. Первым параметром является число, которое необходимо преобразовать в строку, применив при этом форматирование. Вторым параметром является образец, в соответствии с которым будет форматироваться число. Третий параметр указывает название десятичного формата, который следует применять.

Образец форматирования в XSLT определяется точно так же, как в классе DecimalFormat языка Java. Для того чтобы читателю, не знакомому с Java, не пришлось изучать документацию этого языка, мы приведем полный синтаксис образцов форматирования. Продукции образца форматирования мы будем помечать номерами с префиксом NF, чтобы не путать их с другими продукциями.

Прежде всего, образец форматирования может состоять из двух частей: первая часть определяет форматирование положительного числа, вторая часть — отрицательного. Запишем это в виде EBNF-продукции:

[NF 1] NFPattern ::= NFSubpattern (NFSubpatternDelim NFSubpattern)?

Двум частям образца форматирования соответствуют нетерминалы NFSubpattern, которые разделены нетерминалом NFSubpatternDelim.

В случае если вторая часть образца форматирования опушена, отрицательные числа форматируются точно так же, как и положительные, но им предшествует префикс отрицательного числа (по умолчанию — знак "минус", "-").

Примеры

format-number(1234.567,'#.00;negative #.00') → '1234.57'

format-number(-1234.567,'#.00/negative #.00') → 'negative 1234.57'

format-number(-1234.567,'#.00') → '-1234.57'

Каждая из частей образца форматирования состоит из префикса (NFPrefix), целой части (NFInteger), необязательной дробной части (NFFractional) и суффикса (NFSuffix).

[NF 2] NFSubpattern ::= NFPrefix NFinteger NFFractional? NFSuffix

Префикс или суффикс образца форматирования могут содержать символ процента. Если суффикс содержит символ процента, число должно быть умножено на 100 и выведено со знаком процента. Наличие символа процента в префиксе на форматирование не влияет.

Пример

format-number(0.45,'0.00%') → '45.00%'

format-number(0.45,'0.##%') → '45.00%'

format-number(0.45678,'%0.00') → '%0.46'

format-number(0.45678,'0.####%') → '45.678%'

Префикс задает строку, которая будет предшествовать числу, это может быть последовательность любых неформатирующих символов (NFChar) плюс символ процента (NFPercent). Аналогично, суффикс будет следовать за числом, и он тоже не может содержать форматирующих символов (за исключением символа процента).

[NF 3] NFPrefix ::= (NFChar NFPercent?)*

[NF 4] NFSuffix ::= (NFChar NFPercent?)*

Пример

Если мы хотим заключить наше число, к примеру, в квадратные скобки, мы должны будем включить в его образец форматирования префикс "[" и суффикс "]":

format-number(123456, '[#]') → '[123456]'

Нетерминал NFinteger определяет, как будет выглядеть целая часть числа. Он начинается несколькими символами NFOptDigit (по умолчанию "#"), показывающими позиции, в которых цифры необязательны, и состоит из символов NFReqDigit (по умолчанию "0"), показывающих позиции обязательных цифр, а также символа NFGroupDelim (по умолчанию ","), показывающего позицию символа-разделителя групп цифр.

[NF 5] NFInteger ::= NFOptDigit*

                     (NFReqDigit* NFGroupDelim

                     | NFGroupDelim NFOptDigit*)?

                     NFReqDigit+

Примеры

format-number(1234.56,'#0000') → '1235'

format-number(1234.56,'00000') → '01235'

format-number(1234.56,'00,000') → '01,235'

format-number(1234.56,'000,00') → '0,12,35'

Замечание

Некоторые процессоры позволяют указывать несколько символов-разделителей. Однако даже в этом случае они учитывают только последний из этих символов.

Пример

format-number(123456789.0123,'0000,000,00') → '1,23,45,67,89'

Дробная часть числа, представленная нетерминалом NFFraction, начинается символом-разделителем целой и дробной части NFFractionDelim (по умолчанию "."), продолжается последовательностью символов обязательных позиций цифр NFReqDigit и заканчивается последовательностью символов необязательных позиций NFOptDigit:

[NF 6] NFFraction ::= NFFractionDelim NFReqDigit* NFOptDigit*

Примеры

format-number(1234.567,'#.00') → '1234.57'

format-number(1234.567,'#.00#') → '1234.567'

format-number(1234.567,'#.0000') → '1234.5670'

Продукция NFChar, использующаяся при определении префикса (NFPrefix) и суффикса (NFSuffix), может содержать любые неформатирующие символы:

[NF 7] NFChar ::= (Char - NFSymbol)

К специальным форматирующим символам относятся следующие:

□ символ обязательной позиции цифры (по умолчанию "0");

□ символ необязательной позиции цифры (по умолчанию "#");

□ символ-разделитель образцов форматирования для положительного и отрицательного числа (по умолчанию ";");

□ символ-разделитель целой и дробной части (по умолчанию ".");

□ символ процента (по умолчанию "%").

Перечислим их продукции:

[NF 8] NFSymbol           ::= NFReqDigit

                              | NFOptDigit

                              | NFSubpatternDelim

                              | NFFractionDelim

                              | NFGroupDelim

                              | NFPercent

[NF 9] NFReqDigit         ::= '0'

[NF 10] NFOptDigit        ::= '#'

[NF 11] NFSubpatternDelim ::= ';'

[NF 12] NFFractionDelim   ::= '.'

[NF 13] NFGroupDelim      ::= ','

[NF 14] NFPercent         ::= '%'

Синтаксические правила, которые мы привели выше, пока не являются стандартными. Они корректно передают синтаксис образца форматирования, но являются более строгими, чем определения в документации языка Java.

Элемент xsl:decimal-format

Синтаксис элемента задан конструкцией вида:

<xsl:decimal-format

 name="имя"

 decimal-separator="символ"

 grouping-separator="символ"

 infinity="строка"

 minus-sign="символ"

 NaN="строка"

 percent="символ"

 per-mille="символ"

 zero-digit="символ"

 digit="символ"

 pattern-sераrator="символ"/>

XSLT позволяет изменять специальные символы, влияющие на форматирование строки. Именованный набор таких символов и некоторых других указаний называется десятичным форматом и определяется элементом xsl:decimal-format. От атрибутов этого элемента зависит, как будут обрабатываться символы образца форматирования и как число будет отображаться на выходе:

Атрибут name элемента xsl:decimal-format задает расширенное имя десятичного формата. Если имя не указано, это означает, что элемент xsl:decimal-format определяет десятичный формат по умолчанию.

Остальные атрибуты контролируют интерпретацию форматирующего образца и вывод строкового представления числа следующим образом:

□ decimal-separator — задает символ, разделяющий целую и дробную части числа. Значением этого атрибута по умолчанию является символ ".", с Unicode-кодом #x2e. Атрибут decimal-separator рассматривается как специальный символ образца форматирования. Кроме того, он будет использован как разделяющий символ при выводе;

□ grouping-separator — задает символ, группирующий цифры в целой части записи числа. Такие символы используются, например, для группировки тысяч ("1,234,567.89"). Значением по умолчанию является символ ",", код #x2c. grouping-separator рассматривается как специальный символ образца форматирования. Помимо этого, он будет использован как разделяющий символ групп цифр при выводе числа;

□ percent — задает символ процента. Значением по умолчанию является символ "%", код #x25. Этот символ будет распознаваться в образце форматирования и использоваться при выводе;

□ per-mille — задает символ промилле. Значением по умолчанию является символ "‰", код #х2030. Символ промилле распознается в образце форматирования и используется в строковом представлении числа;

□ zero-digit — задает символ нуля. Значением по умолчанию является символ "0", код #x30;. В качестве цифр при отображении числа будут использоваться символ нуля и 9 символов, следующих за ним. Символ нуля распознается в образце форматирования и используется при выводе строкового представления числа;

□ digit — определяет символ, который используется в образце форматирования для определения позиции необязательного символа. Значением по умолчанию является символ "#". Этот символ распознается как форматирующий символ необязательной цифры. Он не включается в строковое представление числа;

□ pattern-separator — определяет символ, который используется в образце форматирования для разделения положительного и отрицательного форматов числа. Он не включается в строковое представление числа. Значением этого атрибута по умолчанию является символ ";";

□ infinity — задает строку, которая будет представлять бесконечность. Значением по умолчанию является строка "Infinity";

□ NaN — задает строку, которая будет представлять не-числа. Значением по умолчанию является строка "NaN";

□ minus-sign — задает символ, который будет использоваться для обозначения отрицательных чисел. Значением по умолчанию является символ "-", код #x2D.

Элемент xsl:decimal-format не имеет смысла без функции format-number. Все, на что влияют его атрибуты — это формат, который будет использоваться при преобразовании чисел в строку функцией format-number.

Примеры

Определение десятичного формата:

<xsl:decimal-format

 name="format1"

 decimal-separator=","

 minus-sign="N"

 grouping-separator=":"

 infinity="∞"

 NaN="not-a-number"

 percent="%"

 digit="$"

 pattern-separator="|"/>

Примеры функций format-number:

format-number(123456.78, '$,0000', 'format1) → '123456,7800'

format-number(-123456.78, '$,00$$', 'format1') → 'N123456,78'

format-number(123456.78, '$,0000|$,0000-', 'format1') → '123456,7800'

format-number(-123456.78, '$,00001$,0000-', 'format1') → '123456,7800-'

format-number(-123456.78, '000:000:000,00$$', 'format1') → 'N000:123:456,78'

format-number('zero', '000:000:000,00$$', 'format1') -> 'not-a-number'

format-number(1 div 0, '$,$', 'format1') → '∞'

format-number(-1 div 0, '$,$', 'format1') → 'N∞'

Определение десятичного формата:

<xsl:decimal-format name="format2" zero-digit="/"/>

Примеры функций format-number:

format-number(123456789, '#', 'format2') → '012345678'

format-number(123456789, '#') → '123456780'

Определение десятичного формата:

<xsl:decimal-format name="format3" zero-digit="1"/>

Примеры функций format-number:

format-number(123456789, '#', 'format3') → '23456789:'

format-number(12345.06789, '#.#####', 'format3') → '23456.1789:'

Десятичный формат, определяемый элементом xsl:decimal-format, в отличие от многих других элементов не может переопределяться в преобразованиях со старшим порядком импорта. Элементы xsl:decimal-format должны определять десятичные форматы с различными именами (за исключением тех случаев, когда значения их атрибутов полностью совпадают).

Контроль вывода документа

Несмотря на то, что XSLT-процессоры должны лишь только преобразовывать логические модели документов, организованные в виде деревьев, многие из них имеют также возможность выдавать результат преобразования в виде последовательности символов.

Элемент xsl:output

Синтаксис этого элемента приведен ниже:

<xsl:output

 method = "xml" | "html" | "text" | "имя"

 version = "токен"

 encoding = "строка"

 omit-xml-declaration = "yes" | "no"

 standalone = "yes" | "no"

 doctype-public = "строка"

 doctype-system = "строка"

 cdata-section-elements = "имена"

 indent = "yes" | "no"

 media-type = "строка"/>

Элемент верхнего уровня xsl:output позволяет указывать, каким образом должно быть выведено результирующее дерево.

Главным атрибутом элемента xsl:output является атрибут method, который определяет, какой метод должен использоваться для вывода документа. Значением этого атрибута может быть любое имя, но при этом техническая рекомендация XSLT определяет только три стандартных метода вывода — "xml", "html" и "text". В том случае, если процессор поддерживает нестандартный метод вывода, его реализация полностью зависит от производителя.

Если в преобразовании не определен элемент xsl:output или в нем не указан атрибут method, метод преобразования выбирается по умолчанию исходя из следующих условий.

□ Если корень выходящего документа имеет дочерний элемент с локальным именем "html" (в любом регистре символов), которому предшествуют только пробельные символы, методом вывода по умолчанию становится "html".

□ Во всех остальных случаях методом вывода по умолчанию является "xml".

Пример

Для документа

<HTML>

 <HEAD>

  <TITLE>XSL Transformations (XSLT)</TITLE>

 </HEAD>

 <BODY>

  <H1>XSL Transformations (XSLT)<BR/>Version 1.0</H1>

 </BODY>

</HTML>

Методом вывода по умолчанию будет "html", а для документа

<BODY>

 <H1>XSL Transformations (XSLT)<BR/>Version 1.0</H1>

</BODY>

будет выбран метод вывода "xml".

Помимо главного атрибута method, элемент xsl:output имеет следующие атрибуты:

□ version (версия) — определяет версию языка выходящего документа;

□ indent (индентация) — определяет, должен ли процессор добавлять пробельные символы для более наглядного форматирования документа;

□ encoding (кодировка) — определяет, в какой кодировке должен быть выведен документ. Значение этого атрибута не зависит от регистра символов, то есть значения encoding="utf-8" и encoding="UtF-8" будут эквивалентны. В атрибуте encoding можно использовать только печатаемые символы ASCII, то есть символы интервала от #x21 до #x7e. Значением encoding должно быть название набора символов, определенное в стандартах IANA (Internet Assigned Numbers Authority) или RFC2278. В противном случае, атрибут должен начинаться символами "x-";

□ media-type — определяет тип содержимого MIME выходящего документа;

□ doctype-system — определяет системный идентификатор, который должен быть использован в декларации типа документа (DTD);

□ doctype-public — определяет публичный идентификатор, который должен быть использован в декларации типа документа (DTD);

□ omit-xml-declaration (пропустить декларацию XML) — определяет, нужно ли включать декларацию XML в выходящий документ или нет. Значением этого атрибута должно быть либо "yes" (пропустить декларацию), либо "no" (включить декларацию в выходящий документ);

□ standalone (самостоятельный документ) — определяет, должен ли процессор выводить указание на самостоятельность документа (standalone declaration). Значением этого атрибута может быть либо "yes" (выводить указание), либо "no" (не выводить указание на самостоятельность);

□ cdata-section-elements — определяет список элементов, текстовое содержимое которых должно быть выведено с использованием секций CDATA.

Использование этих атрибутов зависит от того, какой из методов выбран для вывода преобразованного документа.

Метод вывода "xml"

Для того чтобы вывести результирующее дерево в виде XML-документа, следует использовать в элементе xsl:output метод "xml". Ниже мы подробно опишем, каким образом на выход должны влиять другие атрибуты этого элемента.

Атрибут version

Этот атрибут определяет версию языка XML, которая должна использоваться для вывода результирующего документа. В случае если процессор не поддерживает указанную версию, он может либо выдать ошибку, либо использовать одну из поддерживаемых версий. На данный момент единственной действующей версией языка является версия 1.0 и потому, если в атрибуте в version будет указано другое значение, единственным эффектом от этого будет измененный параметр version в декларации XML.

Пример

Предположим, что в преобразовании версия выходящего документа задана как 1.2:

<xsl:output method="xml" version="1.2"/>

Тогда процессор может вывести декларацию XML в следующем виде:

<?xml version="1.2" encoding="utf-8"?>

Значением атрибута version по умолчанию является "1.0", то есть, для того, чтобы получить декларацию XML вида

<?xml version="1.0" и т. д. ?>

достаточно опустить определение атрибута version:

<xsl:output method="xml"/>

Атрибут encoding

Атрибут encoding указывает на то, какая кодировка предпочтительна для выходящего документа. Множество кодировок зависит от используемого процессора, но при этом в соответствии с технической рекомендацией все они обязаны поддерживать Unicode-формы кодировок UTF-8 и UTF-16.

В случае если процессор не поддерживает кодировку, указанную в атрибуте encoding, процессор может либо выдать ошибку, либо использовать UTF-8 или UTF-16.

Если атрибут encoding опущен, процессор должен по умолчанию использовать UTF-8 или UTF-16. На практике абсолютное большинство процессоров используют по умолчанию кодировку UTF-8.

При выводе содержимого выходящего документа может возникнуть ситуация, когда в выходящем потоке будут находиться символы, которые невозможно будет отобразить при используемой кодировке. В этом случае непечатаемые символы должны быть заменены символьными сущностями.

Пример

Представим себе входящий документ в кодировке UTF-8, содержащий символ кириллицы "Э" с Unicode-кодом #x42d (или #1069 в десятичной системе счисления):

<?xml version="1.0" encoding="utf-8"?>

<page>Э</page>

Если преобразование будет использовать для вывода кодировку, которая не может отображать символы кириллического алфавита, например ISO-8859-1, то символ "Э" в выходящем документе должен быть заменен символьной сущностью.

Листинг 8.36. Преобразование

<xsl:stylesheet

 version="1.0"

 xmlns:xsl="http://www.w3.org/1999/XSL/Transform">

 <xsl:output

  method="xml"

  encoding="ISO-8859-1"

  indent="yes"/>

 <xsl:template match="/">

  <xsl:copy-of select="/page"/>

 </xsl:template>

</xsl:stylesheet>

Листинг 8.37. Выходящий документ

<?xml version="1.0" encoding="ISO-8859-1"?>

<page>Э</page>

Вместе с тем синтаксис XML не разрешает использовать символьные сущности в именах элементов и атрибутов, и наличие в них символов, не отображаемых кодировкой вывода, будет являться ошибкой. Если в предыдущем примере документ будет иметь вид

<?xml version="1.0" encoding="utf-8"?>

<страница>Э</страница>

то вывести результирующее дерево в кодировке ISO-8859-1 будет невозможно.

Атрибут indent

Индентацией называют форматирование исходного текста, не влияющее на семантику, но облегчающее читаемость. К примеру, один и тот же XML-документ можно написать как

<A><В><С/></В><С><В></В></С></А>

или

<A>

 <B>

  <C/>

 </B>

 <C>

  <B>

  </B>

 </C>

</A>

Очевидно, что второй случай гораздо легче для понимания, поскольку в нем легко можно видеть принадлежность элементов одного другому. Подобное форматирование можно использовать и при выводе преобразованного документа при помощи атрибута indent элемента xsl:output. Если этот атрибут имеет значение "yes", процессор может добавить один или несколько пробельных символов или символов перевода строки — в зависимости от реализации. Как правило, каждый дочерний элемент помещают на новой строке, добавляя впереди два пробела на каждый уровень вложенности.

Пример

Листинг 8.38. Входящий документ

<?xml version="1.0" encoding="utf-8"?>

<A><B><C/></B><C><B></В></C></A>

Листинг 8.39. Преобразование

<xsl:stylesheet

 version="1.0"

 xmlns:xsl="http://www.w3.org/1999/XSL/Transform">

 <xsl:output indent="yes"/>

 <xsl:template match="/">

  <xsl:copy-of select="/"/>

 </xsl:template>

</xsl:stylesheet>

Листинг 8.40. Выходящий документ

<?xml version="1.0" encoding="utf-8"?>

<A>

 <B>

  <C/>

 </B>

 <C>

  <B/>

 </C>

</A>

Следует быть осторожными при использовании indent="yes" там, где в содержимом документа могут встречаться значащие пробелы. Индентация позволяет процессору при выводе документа добавлять пробельные символы по собственному усмотрению. В случаях, когда при последующей обработке преобразованного документа пробельные символы могут быть восприняты неадекватно, лучше индентацию не использовать.

Атрибут cdata-section-elements

Для того чтобы вывести текстовое содержимое некоторых элементов в виде секций CDATA, XSLT предлагает простой механизм — следует лишь перечислить в атрибуте cdata-section-elements элемента xsl:output элементы, которые на выходе должны содержать секции символьных данных.

Пример

Листинг 8.41. Входящий документ

<?xml version="1.0" encoding="utf-8"?>

<page><br/><br/></page>

Листинг 8.42. Преобразование

<xsl:stylesheet

 version="1.0"

 xmlns:xsl="http://www.w3.org/1999/XSL/Transform">

 <xsl:output

  indent="yes"

  cdata-section-elements="page"/>

 <xsl:template match="/">

  <xsl:copy-of select="/"/>

 </xsl:template>

</xsl:stylesheet>

Листинг 8.43. Выходящий документ

<?xml version="1.0" encoding="utf-8"?>

<page><![CDATA[<br/>]]><br/>

</page>

В соответствии с синтаксисом XML, секции CDATA не могут содержать последовательности символов "]]>". Потому, встретив такую комбинацию в тексте элемента, имя которого включено в cdata-section-elements, процессор заменит ее двумя секциями CDATA. Одна будет содержать "]]", вторая – ">".

Пример

Листинг 8.44. Входящий документ

<?xml version="1.0" encoding="utf-8"?>

<page>

 <data>]]></data>

 <pre><!-- Comment --></pre>

</page>

Листинг 8.45. Преобразование

<xsl:stylesheet

 version="1.0"

 xmlns:xsl="http://www.w3.org/1999/XSL/Transform">

 <xsl:output

 indent="yes"

 cdata-section-elements="data pre"/>

 <xsl:template match="/">

  <xsl:copy-of select="/"/>

 </xsl:template>

</xsl:stylesheet>

Листинг 8.46. Выходящий документ

<?xml version="1.0" encoding="utf-8"?>

<page>

 <data><![CDATA[]]]]><![CDATA[>]]></data>

 <pre><![CDATA[<!-- Comment -->]]></pre>

</page>

Атрибут doctype-system

Для определения логической структуры документов в XML используются DTD — определения типов документов. В большинстве случаев определения типов содержатся во внешних ресурсах, которые включаются в документ в виде системных или публичных идентификаторов.

XSLT позволяет создавать ссылки на внешние определения типов при помощи атрибута doctype-system элемента xsl:output.

Пример

Предположим, что мы создаем документ, логическая схема которого определена во внешнем файле по адресу "/dtds/document.dtd". Тогда, определив в преобразовании элемент xsl:output с атрибутом doctype-system, равным "/dtds/document.dtd", мы получим в выходящем документе определение типа в виде

<!DOCTYPE элемент SYSTEM "/dtds/document.dtd">

где элемент — первый элемент выходящего документа.

Листинг 8.47. Входящий документ

<?xml version="1.0" encoding="utf-8"?>

<page> content </page>

Листинг 8.48. Преобразование

<xsl:stylesheet

 version="1.0"

 xmlns:xsl="http://www.w3.org/1999/XSL/Transform">

 <xsl:output indent="yes" doctype-system="/dtds/document.dtd"/>

 <xsl:template match="/"><xsl:copy-of select="/"/></xsl: template>

</xsl:stylesheet>

Листинг 8.49. Выходящий документ

<?xml version="1.0" encoding="utf-8"?>

<!DOCTYPE page SYSTEM "/dtds/document.dtd">

<page> content </page>

Атрибут doctype-public

Если в преобразовании атрибутом doctype-system элемента xsl:output задано внешнее определение логического типа документа, это определение может быть расширено также и публичным идентификатором. Публичный идентификатор указывается в атрибуте doctype-public элемента xsl:output. Его использование может быть продемонстрировано следующим примером.

Листинг 8.50. Входящий документ

<?xml version="1.0" encoding="utf-8"?>

<page> content </page>

Листинг 8.51. Преобразование

<xsl:stylesheet

 version="1.0"

 xmlns:xsl="http://www.w3.org/1999/XSL/Transform">

 <xsl:output indent="yes"

  doctype-system="/dtds/document.dtd"

  doctype-public="-//Document//Description" />

 <xsl:template match="/"><xsl:copy-of select="/"/></xsl:template>

</xsl:stylesheet>

Листинг 8.52. Выходящий документ

<?xml version="1.0" encoding="utf-8"?>

<!DOCTYPE page

 PUBLIC "-//Document//Description" "/dtds/document.dtd">

<page> content </page>

Атрибут media-type

Атрибут media-type позволяет задавать медиа-тип содержимого выходящего документа. Для метода вывода "xml" значением media-type по умолчанию является "text/xml". Несмотря на то, что media-type не оказывает никакого влияния на содержимое самого документа, XSLT-процессоры, используемые на стороне сервера, могут в зависимости от значения этого атрибута изменять MIME-тип исходящих данных при использовании, к примеру, такого протокола, как HTTP.

Атрибут omit-xml-declaration

XML-документы, в принципе, могут быть корректными и без декларации XML. Поэтому XSLT позволяет опускать эту декларацию в выходящем документе, для чего значению атрибута omit-xml-declaration должно быть присвоено "yes":

<xsl:output

 omit-xml-declaration="yes"/>

В случае если значение атрибута omit-xml-declaration опущено или не равно "yes", процессор будет выводить в выходящем документе декларацию XML, которая включает информацию о версии (по умолчанию "1.0") и кодировке документа (по умолчанию "utf-8" или "utf-16" в зависимости от процессора).

Атрибут standalone

Для того чтобы объявить документ как самостоятельный или несамостоятельный (standalone или non-standalone соответственно), следует использовать атрибут standalone элемента xsl:output. Если этот атрибут будет присутствовать в xsl:output, то процессор включит в декларацию XML объявление standalone с соответствующим значением. Если атрибут standalone не указан, объявление standalone в декларацию XML выходящего документа включено не будет.

Метод вывода "html"

В нынешнем состоянии языки XML и HTML сильно похожи синтаксически, но при этом имеют некоторые довольно весомые различия. Метод вывода "html" используется для того, чтобы выводить документы в формате, который будет понятен большинству существующих на данный момент Web-браузеров.

Одно из основных различий HTML и XML состоит в том, что в XML пустые элементы имеют формат <имя/>, в то время как в HTML тот же элемент был бы выведен, как <имя> — без косой черты. Метод вывода "html" учитывает эти различия и выводит теги пустых элементов HTML без косой черты после имени. В соответствии с технической рекомендацией языка HTML 4.0, пустыми элементами являются area, base, basefont, br, col, frame, hr, img, input, isindex, link, meta и param.

Пример

Листинг 8.53. Входящий документ

<?xml version="1.0" encoding="utf-8"?>

<page>

 <title>I'm just a simple page...</title>

 <content>I've got a simple content</content>

</page>

Листинг 8.54. Преобразование

 <xsl:stylesheet

  version="1.0"

  xmlns:xsl="http://www.w3.org/1999/XSL/Transform">

 <xsl:output indent="yes" method="html"/>

 <xsl:template match="/page">

  <html>

   <head>

    <title>

     <xsl:value-of select="title"/>

    </title>

   </head>

   <body>

    Welcome!<br/>

    Be our guest! <HR/>

    <xsl:value-of select="content"/>

   </body>

  </html>

 </xsl:template>

</xsl:stylesheet>

Листинг 8.55. Выходящий документ

<html>

 <head>

  <meta http-equiv="Content-Type" content="text/html; charset=utf-8">

  <title>I'm just a simple page...</title>

 </head>

 <body>

  Welcome!<br>

  Be our guest! <HR>

  I've got a simple content

 </body>

</html>

Как можно заметить, метод вывода "html" распознает элементы HTML вне зависимости от регистра символов — в нашем примере пустой элемент <HR/> был выведен как <HR>, что соответствует синтаксису HTML.

Документы, которые преобразуются в HTML, могут также иметь программы, определенные внутри элемента script или стили, заданные внутри элемента style. В случае если внутри этих элементов оказываются символы, считающиеся в XML специальными — такие как "<", "&" и так далее, процессор не должен заменять их символьными или встроенными сущностями.

Пример

Предположим, что в преобразуемом документе элемент script определен с использованием специальных символов, которые заменены сущностями:

<script> if (a > b) swap(a, b) </script>

или с использованием секций символьных данных:

<script><![CDATA[ if (a>b) swap(a, b) ]]></script>

При использовании метода вывода "html" оба варианта будут выведены, как

<script> if (a>b) swap(a, b) </script>

Пожалуй, стоит еще раз повторить, что это относится только к элементам style и script. Специальные символы, использованные в других элементах, будут заменены символьными или встроенными сущностями.

Пример

<P>This >o< is a black hole of this page!</P>

будет выведено как

<P>This >o< is a black hole of this page!</P>

В соответствии со спецификацией, некоторые атрибуты в HTML могут и не иметь значений — как правило, это атрибуты с булевыми значениями, такие, к примеру, как атрибут selected элемента option, присутствие которого в элементе означает то, что опция выбрана, отсутствие — то, что она не выбрана. Для того чтобы получить в выходящем документе

<option selected>

следует в преобразовании указывать

<option selected="selected">

то есть присваивать булевому атрибуту значение, равное собственному имени. Такие значения будут выведены в минимизированной форме, как это и требовалось.

HTML и XML также имеют небольшие различия в формате вывода инструкций по обработке. В то время как в XML эти инструкции имеют вид

<?приложение содержимое?>

в HTML инструкции по обработке заканчиваются не "?>", а просто правой угловой скобкой (">"):

<?приложение содержимое>

Таким образом, результатом выполнения кода

<xsl:processing-instruction name="app">content</xsl:processing-instruction>

при использовании метода XML будет

<?app content?>

а при использовании метода HTML

<?app content>

Атрибут version

Атрибут version элемента xsl:output в методе "html" обозначает версию языка HTML, которая должна использоваться в выходящем документе. По умолчанию значением этого атрибута является "4.0", что означает соответствие выходящего документа спецификации языка HTML версии 4.0. Отметим, что последней версией языка HTML на момент написания этой книги является версия 4.02, однако отличия между этими версиями незначительны.

Атрибут encoding

Кодировка выходящего документа определяется в HTML несколько иначе, чем в XML. Если в XML мы использовали определение encoding в декларации XML, то в HTML кодировка описывается в элементе meta следующим образом:

<html> <head>

<meta http-equiv="Content-Type"

 content="text/html; charset=windows-1251">

...

Поэтому, если в выходящем документе внутри корневого элемента html присутствует элемент head, процессор должен добавить в него элемент meta с соответствующим определением кодировки.

Пример

Элемент

<xsl:output encoding="ISO-8859-1"/>

добавит в элемент headвыходящего HTML-документа элемент meta в следующем виде:

<meta http-equiv="Content-Type"

 content="text/html; charset=ISO-8859-1">

Таким образом, для определения кодировки выходящего HTML-документа не следует вручную создавать соответствующий элемент meta — нужно просто указать требуемую кодировку в атрибуте encoding элемента xsl:output.

Атрибут indent

XSLT позволяет использовать в HTML документах индентацию точно так же, как мы бы использовали ее в методе "xml".

Атрибуты doctype-system и doctype-public

Декларация типа документа с внешними системными или публичными идентификаторами может быть использована в HTML точно так же, как в XML. Поскольку в объявлении типа документа после <!DOCTYPE должно стоять имя корневого элемента, при методе вывода "html" этим именем будет "HTML" или "html" в зависимости от регистра символов имени корневого элемента документа.

Атрибут media-type

Атрибут media-type определяет медиа-тип содержимого выходящего документа. Для HTML-документов значением media-type по умолчанию будет "text/html".

Метод вывода "text"

XSLT позволяет выводить результат преобразования как простой текст. При использовании method="text" результирующее дерево приводится к строке, то есть в этом случае результатом преобразования будет строковое сложение всех текстовых узлов дерева.

Пример

Входящий документ

<?xml version="1.0" encoding="utf-8"?>

<page>

 <title>My heart's in the Highlands</title>

 <content>My heart is not here</content>

</page>

одним и тем же шаблоном:

<xsl:template match="/page">

 <poem title="{title}">

  <xsl:value-of select="title"/>

  <xsl:text> </xsl:text>

  <xsl:value-of select="content"/>

 </poem>

</xsl:template>

при использовании метода вывода "xml" будет преобразован к виду

<?xml version="1.0" encoding="utf-8"?>

<poem title="My heart's in the Highlands">

 My heart's in the Highlands

 My heart is not here

</poem>

а при использовании метода "text" к виду

My heart's in the Highlands

My heart is not here

Атрибут encoding

Атрибут encoding указывает на предпочтительную кодировку вывода текста документа. Значение атрибута encoding по умолчанию зависит от программной платформы, на которой производится преобразование. В большинстве процессоров по умолчанию используются кодировки UTF-8, ASCII и ISO-8859-1.

В случае если кодировка, используемая для вывода текста, не отображает некоторые символы документа, процессор может выдать ошибку.

Атрибут media-type

По умолчанию в качестве значения атрибута media-type, используемого для простого текста, указывается "text/plain". Значение атрибута media-type может быть использовано сервером, преобразующим документ в качестве MIME-типа.

Другие методы вывода

Как уже было сказано раньше, спецификация XSLT позволяет помимо основных методов "xml", "html" и "text" использовать также и другие методы, реализация которых будет зависеть от производителя того или иного процессора. Кажется вполне логичной и закономерной возможность использования, к примеру, такого метода, как "pdf" для создания документов в Adobe Portable Document Format (переносимом формате документов) или метода "bin" для создания двоичного потока данных. Однако, на данном этапе, процесс сериализации (создания физической сущности из логической модели) пока еще не определен в общем виде для произвольного метода. Возможно, в будущем, по аналогии с объектной моделью документа (DOM) будут созданы схожие интерфейсы для более легкого определения методов сериализации и интеграции преобразований в другие программы, но в настоящее время следует ограничиваться тремя основными методами.

Отметим также, что спецификация языка XSLT определяет функциональность элемента xsl:output как возможную, но не обязательную. Процессоры обязаны манипулировать логическими моделями XML-документов, но при этом они не обязаны поддерживать сериализацию и уметь выводить преобразованный XML-документ как последовательность байт. Конечно же, абсолютное большинство процессоров поддерживает такую возможность, но при всем том она остается не более чем возможностью.

Поэтому из соображений переносимости можно лишь только надеяться, что документ будет выведен так, как было задумано. Не следует исключать возможности, что в определённых условиях процессор не сможет контролировать процесс вывода документа.

Типичным примером такой ситуации может быть использование процессора совместно с другими компонентами, которые обмениваются с процессором документами в виде DOM-структур, но сами загружают и выводят документы. В этом примере компоненты, занимающиеся выводом преобразованного документа, могут спокойным образом игнорировать все то, что было указано в элементе xsl:output или в атрибутах disable-output-escaping других элементов преобразования. Более того, они даже не будут знать, что было там указано, поскольку эти значения не касаются процесса преобразования как такового — они относятся к выводу, контролировать который процессор в данном случае не может.

Отсюда следует однозначный вывод: не нужно чересчур злоупотреблять возможностями xsl:output и disable-output-escaping.

Замена специальных символов

Как мы уже знаем, в XML есть несколько специальных символов, которые, как правило, заменяются процессором при выводе документа на соответствующие символьные или встроенные сущности. К примеру, для того, чтобы вывод был корректным XML-документом, процессор обязан заменять символы "<" и "&" на встроенные (< и &) или символьные (< и &) сущности.

Между тем довольно часто бывает необходимым выводить в выходящем документе символы разметки.

Пример

Пусть входящий документ содержит описание товара, заданное в секции CDATA:

<?xml version="1.0" encoding="utf-8"?>

<product>

 <title>An elephant</title>

 <description><![CDATA[This is a <em>big</em> and <b>grey</b> animal!]]></description>

</product>

Если мы будем преобразовывать этот документ с использованием шаблона

<xsl:template match="product">

 <p>

  <xsl:value-of select="title"/><xsl:text> </xsl:text><br/>

  <xsl:value-of select="description"/>

</p>

</xsl:template>

то в выходящем документе специальные символы будут заменены:

<p>An elephant

<br/>This is a <em>big</em> and <b>grey</b> animal!</p>

Для того чтобы избежать замены, можно воспользоваться атрибутом disable-output-escaping (отменить замену символов) элементов xsl:value-of и xsl:text. Этот атрибут может принимать значения "yes" и "no" ("no" — значение по умолчанию). Значение "yes" означает, что процессор при выводе текста, создаваемого xsl:text или xsl:value-of не должен заменять специальные символы. Если бы в предыдущем примере мы использовали преобразование.

Листинг 8.56. Преобразование, содержащее disable-output-escaping

<xsl:stylesheet version="1.0"

 xmlns:xsl="http://www.w3.org/1999/XSL/Transform">

 <xsl:output indent="yes" method="xml"/>

 <xsl:template match="product">

  <p>

   <xsl:value-of select="title"/><xsl:text> </xsl:text><br/>

   <xsl:value-of disable-output-escaping="yes" select="description"/>

  </p>

 </xsl:template>

</xsl:stylesheet>

то на выходе мы бы получили документ

<?xml version="1.0" encoding="utf-8"?>

<p>An elephant

<br/>This is a <em>big</em> and <b>grey</b> animal!</p>

Атрибут disable-output-escaping налагает ряд ограничений на использование текстовых узлов, генерируемых элементами xsl:text и xsl:value-of: эти узлы не могут входить в качестве текстового содержимого в узлы атрибутов, комментариев или инструкций по обработке. Кроме того, дерево, содержащее текстовые узлы, для которых была отменена замена специальных символов, не может быть приведено к строке или числу. И в том и в другом случае процессор может либо выдать ошибку преобразования, либо проигнорировать отмену замены специальных символов.

Атрибут disable-output-escaping имеет также и более концептуальное ограничение. Процессор сможет отменить замену символов только в том случае, когда он сам будет контролировать процесс вывода. Как мы уже обсуждали в предыдущем разделе, ситуации, когда процесс вывода не будет выполняться самим процессором, не такая уж и редкость. Поэтому следует использовать disable-output-escaping только в тех случаях, когда другой альтернативы нет или когда имеется полная уверенность, что этот метод будет работать.

Атрибут disable-output-escaping работает с методами вывода "xml" и "html", но не оказывает никакого влияния на метод "text", поскольку при этом методе все специальные символы и так выводятся без замены.

Кодировки в XSLT-преобразованиях

Несмотря на то, что в логических деревьях, которыми манипулирует XSLT, текстовые узлы представляются в кодировке Unicode, очень часто в обрабатываемых документах бывает необходимо использовать также другие кодировки. К примеру, большинство русскоязычных документов хранятся в кодировках Windows-1251 и KOI8-R.

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

Кодировка входящего документа указывается в его xml-декларации. Например, документы в кодировке Windows-1251 должны иметь xml-декларацию вида

<?xml version="1.0" encoding="windows-1251"?>

Возможно, небольшим сюрпризом окажется то, что в соответствии со стандартом XML, имена тегов вовсе не обязаны состоять исключительно из латинских букв. В имени элемента можно использовать весь кириллический алфавит, а также множество других символов. Совершенно корректным будет документ

<?xml version="1.0" encoding="windows-1251"?>

<страница>

 <содержимое/>

</страница>

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

Пример

Листинг 8.57. Входящий документ

<?xml version="1.0" encoding="windows-1251"?>

<каждый>

 <охотник>

  <желает>

   <знать>

    <где>

     <сидит>

      <фазан/>

     </сидит>

    </где>

   </знать>

  </желает>

 </охотник>

</каждый>

Листинг 8.58. Преобразование

<?xml version="1.0" encoding="windows-1251"?>

<xsl:stylesheet

 version="1.0"

 xmlns:xsl="http://www.w3.org/1999/XSL/Transform">

 <xsl:output indent="yes" encoding="windows-1251"/>

 <xsl:template match="каждый">

  <редкий>

   <xsl:apply-templates/>

  </редкий>

 </xsl:template>

 <xsl:template match="охотник">

  <рыболов>

   <xsl:apply-templates/>

  </рыболов>

 </xsl:template>

 <xsl:template match="желает/знать">

  <может>

   <забыть>

    <xsl:apply-templates/>

   </забыть>

  </может>

 </xsl:template>

 <xsl:template match="где">

  <как>

   <xsl:apply-templates/>

  </как>

 </xsl:template>

 <xsl:template match="сидит">

  <плавает>

   <xsl:apply-templates/>

  </плавает>

 </xsl:template>

 <xsl:template match="фазан">

  <щука>

   <xsl:apply-templates/>

  </щука>

 </xsl:template>

</xsl:stylesheet>

Листинг 8.59. Выходящий документ

<?xml version="1.0" encoding="windows-1251"?>

<редкий>

 <рыболов>

  <может>

   <забыть>

    <как>

     <плавает>

      <щука/>

     </плавает>

    </как>

   </забыть>

  </может>

 </рыболов>

</редкий>

Напомним, что кодировка выходящего документа определяется атрибутом encoding элемента xsl:output и не зависит от кодировок преобразования и обрабатываемых документов. Например, можно легко создать преобразование, которое будет изменять кодировку входящего документа. Это будет идентичное преобразование с элементом xsl:output, определяющим целевой набор символов.

Листинг 8.60. Преобразование, изменяющее кодировку документа на KOI8-R

<xsl:stylesheet version="1.0"

 xmlns:xsl="http://www.w3.org/1999/XSL/Transform">

 <xsl:output encoding="KOI8-R"/>

 <xsl:template match="@*|node()">

  <xsl:copy>

   <xsl:apply-templates select="@*|node()"/>

  </xsl:copy>

 </xsl:template>

</xsl:stylesheet>

Как можно видеть, XSLT довольно гибко поддерживает кодировки — входящие и выходящие документы, а также сами преобразования могут иметь разные наборы символов. Единственным ограничением является множество кодировок, поддерживаемое самим процессором, вернее парсером, который он использует для разбора входящих документов, и сериализатором, который служит для создания физического экземпляра выходящего документа.

Практически во всех процессорах поддерживаются кодировки UTF-8, US- ASCII и ISO-8859-1, но далеко не все могут работать с Windows-1251 или KOI8-R. Поэтому, создавая документы и преобразования в нестандартных кодировках, мы заведомо ограничиваем переносимость решений. В случаях, когда XML/XSLT приложения создаются под конкретный процессор с заведомо известными возможностями, это не является большой проблемой, однако в тех случаях, когда требуется универсальность или точно не известно, каким процессором будет производиться обработка, единственным выходом будет использовать UTF-8 — как во входящих документах, так и в самих преобразованиях.

Случай нескольких входящих документов

Базовая архитектура преобразования подразумевает один входящий документ. Несмотря на это, в преобразованиях можно использовать и обрабатывать информацию, хранящуюся в других, внешних документах. Доступ к этим документам можно получить при помощи функции document.

Функция document

Запись функции:

node-set document(object, node-set?)

Функция document позволяет обращаться к внешним документам по их URI, например

<xsl:copy-of select="document('http://www.w3.org')"/>

скопирует в выходящий документ содержимое главной страницы Консорциума W3.

Функция document возвращает множество узлов. В простейшем случае это множество будет состоять из корневого узла внешнего документа. Функцию document можно использовать в более сложных XPath-выражениях, например в выражениях фильтрации. Так функция

<xsl:copy-of select="document('http://www.w3.org')/html/body/a"/>

скопирует все элементы а, находящиеся в теле (/html/body) внешнего документа.

Базовый сценарий использования функции document очень прост: ей передается строка, содержащая URI внешнего ресурса, а результатом является множество узлов, состоящее из корня внешнего документа. Однако на этом возможности document не заканчиваются. Мы рассмотрим несколько вариантов вызова функции document с параметрами различного типа.

Вызов document(string)

В случае если функции document передана строка, возвращаемое множество будет состоять из корневого узла внешнего документа. URI этого документа как раз и сообщается строковым аргументом функции document.

Интересной особенностью является возможность передать пустую строку:

document('')

В этом случае document возвратит корневой узел самого преобразования. При помощи document('') можно получать доступ к информации, хранящейся в самом преобразовании (оно ведь тоже является ХМL-документом). К сожалению, перед обращением к документу не существует способа проверить его существование. Процессор может либо выдать ошибку, либо возвратить пустое множество.

Пример

Листинг 8.61. Преобразование

<xsl:stylesheet

 version="1.0"

 xmlns:xsl="http://www.w3.org/1999/XSL/Transform"

 xmlns:user="urn:user-namespace">

 <user:data>

  <item>1</item>

  <item>2</item>

 </user:data>

 <xsl:variable

  name="data" select="document('')/xsl:stylesheet/user:data"/>

 <xsl:template match="/">

  <xsl:copy-of select="$data/item"/>

 </xsl:template>

</xsl:stylesheet>

Листинг 8.62. Выходной документ

<item

 xmlns:xsl="http://www.w3.org/1999/XSL/Transform"

 xmlns:user="urn:user-namespace">1</item>

<item

 xmlns:xsl="http://www.w3.org/1999/XSL/Transform"

 xmlns:user="urn:user-namespace">2</item>

Вызов document(node-set)

Передавая функции document множество узлов, можно получить доступ к нескольким документам, URI которых являются строковыми значениями узлов множества. Это, в частности, позволяет обращаться к документам, URI которых указаны в узлах обрабатываемого документа. Например, в контексте элемента

<а href="http://www.w3.org">...</а>

вполне корректным вызовом функции document будет document (@href).

Выражение @href — здесь возвращает множество, состоящее из единственного узла атрибута. Его строковое значение ("http://www.w3.org") будет использовано как URI внешнего документа. Результирующее множество узлов будет содержать единственный корневой узел документа, расположенного по адресу http://www.w3.org.

Приведем еще один пример. XPath-выражение //a/@href возвращает множество всех атрибутов href элементов а текущего документа. Тогда множество document(//a/@href) будет содержать корневые узлы всех документов, на которые ссылается посредством элементов а текущий документ.

Вызов document(string, node-set)

URI, которые передаются функции document, могут быть как абсолютными, так и относительными, например document('doc.xml') возвратит корень документа doc.xml, находящегося в том же каталоге, что и само преобразование.

Функция document позволяет менять "точку отсчета" относительных URI. Если в качестве второго аргумента функции document передано множество узлов, то относительные идентификаторы ресурсов будут отсчитываться от базового адреса первого (в порядке просмотра документа) узла этого множества.

Базовым URI узла дерева является:

□ если элемент или инструкция по обработке принадлежит внешней сущности, базовым URI соответствующего узла будет URI внешней сущности;

□ иначе базовым URI является URI документа;

□ базовым URI текстового узла, узла атрибута, комментария или пространства имен является базовый URI родительского элемента.

Поясним вышесказанное на примерах.

Конструкция

<xsl:copy-of select="document('doc.xml')"/>

копирует в выходящий документ doc.xml, находящийся в одном каталоге вместе с преобразованием.

Несмотря на то, что в следующем определении xsl:for-each меняет контекст, document('doc.xml') все равно возвращает корень документа doc.xml, находящегося в одном с преобразованием каталоге:

<xsl:for-each select="document('a/data.xml')">

 <xsl:copy-of select="document('doc.xml')"/>

</xsl:for-each>

В следующей конструкции document('doc.xml', /) копирует документ a/doc.xml, поскольку в качестве базового URI используется URI корня документа a/data.xml:

<xsl:for-each select="document('a/data.xml')">

 <xsl:copy-of select="document('doc.xml', /)"/>

</xsl:for-each>

Того же самого эффекта можно достичь следующим образом:

<xsl:copy-of select="document('doc.xml', document('a/data.xml'))"/>

В следующей конструкции за базовый URI опять принимается URI самого преобразования (вернее, его корневого узла):

<xsl:copy-of select="document('doc.xml', document(''))"/>

Протестируем теперь все это вместе в одном преобразовании.

Листинг 8.63. Преобразование

<xsl:stylesheet

 version="1.0"

 xmlns:xsl="http://www.w3.org/1999/XSL/Transform">

 <xsl:template match="/">

  <xsl:copy-of select="document('doc.xml')"/>

  <xsl:for-each select="document('a/data.xml')">

   <xsl:copy-of select="document('doc.xml')"/>

  </xsl:for-each>

  <xsl:for-each select="document('a/data.xml')">

   <xsl:copy-of select="document('doc.xml', /)"/>

  </xsl:for-each>

  <xsl:copy-of select="document('doc.xml', document('a/data.xml'))"/>

  <xsl:for-each select="document('a/data.xml')">

   <xsl:copy-of select="document('doc.xml', document(''))"/>

  </xsl:for-each>

 </xsl:template>

</xsl:stylesheet>

Листинг 8.64. Документ doc.xml

<doc>doc.xml</doc>

Листинг 8.65. Документ a/doc.xml

<doc>a/doc.xml</doc>

Листинг 8.66. Выходящий документ

<doc>doc.xml</doc>

<doc>doc.xml</doc>

<doc>a/doc.xml</doc>

<doc>a/doc.xml</doc>

<doc>doc.xml</doc>

Вызов document(node-set, node-set)

Если функции document передаются два множества узлов, то вычисление результата можно описать примерно следующим образом:

□ каждый из узлов первого аргумента преобразуется в строковый вид;

□ для каждого из полученных значений выполняется вызов типа document(string, node-set);

□ результирующие множества объединяются.

Иными словами, document(node-set, node-set) работает через document(string, node-set) точно так же, как document(node-set) работает через document(string). Разница лишь в том, что в первом случае базовый URI будет изменен.

Другие дополнительные функции XSLT

Функция current

Выражение для этой функции имеет вид:

node-set current()

Функция current возвращает множество, состоящее из текущего узла преобразования.

Мы часто использовали термины текущий узел и узел контекста как синонимы: действительно, в большинстве случаев между ними нет никакой разницы, текущий узел преобразования совпадает с узлом контекста вычисления выражений. Однако бывают ситуации, когда они являются двумя различными узлами.

Представим себе, что нам нужно выбрать элементы item со значением атрибута source, равным значению этого атрибута текущего узла. Очевидно, путь выборки будет выглядеть как item[предикат], где предикат определяет условие равенства атрибутов текущего и выбираемого. Но как записать это условие? Предикат будет вычисляться в контексте проверяемого элемента item, значит, все относительные пути выборки типа @source или ./@source или self::item/@source будут отсчитываться именно от проверяемого элемента. В этом случае узел контекста и текущий узел преобразования — не одно и то же.

Для того чтобы обратиться в предикате именно к текущему узлу, следует использовать функцию current:

item[@source=current()/@source]

Это выражение выберет все дочерние элементы item текущего узла, значение атрибута source которых будет таким же, как и у него.

Функция unparsed-entity-uri

Выражение для этой функции следующее:

string unparsed-entity-uri(string)

Функция unparsed-entity-uri возвращает уникальный идентификатор ресурса, который соответствует неразбираемой внешней сущности, имя которой передано как аргумент.

Пример

Описывая синтаксис XML, мы приводили пример документа, который использовал неразбираемые внешние сущности.

Листинг 8.67. Входящий документ использующий неразбираемые внешние сущности

<!DOCTYPE menu [

 <!ELEMENT menu (menuitem*)>

 <!ELEMENT menuitem EMPTY>

 <!ATTLIST menuitem

  image ENTITY #REQUIRED

  title CDATA #REQUIRED

  href CDATA #REQUIRED>

 <!NOTATION gif SYSTEM "gif-viewer.exe">

 <!NOTATION jpg SYSTEM "jpg-viewer.exe">

 <!ENTITY news SYSTEM "news.gif" NDATA gif>

 <!ENTITY products SYSTEM "prod.jpg" NDATA jpg>

 <!ENTITY support SYSTEM "support.gif" NDATA gif>

]>

<menu>

 <menuitem image="news" title="News" href="news.htm"/>

 <menuitem image="products" title="Products" href="prods.htm"/>

 <menuitem image="support" title="Support" href="support.htm"/>

</menu>

Для того чтобы вычислить местоположение графических файлов, соответствующих пунктам этого меню, нужно будет использовать функцию unparsed- entity-uri. Аргументом этой функции в данном случае будет значение атрибута image, ведь именно этот атрибут задает имя неразбираемой сущности, которая соответствует изображению пункта меню. Преобразование такого документа в HTML будет иметь приблизительно следующий вид.

Листинг 8.68. Преобразование, использующее функцию unparsed-entity-uri

<xsl:stylesheet

 version="1.0"

 xmlns:xsl="http://www.w3.org/1999/XSL/Transform">

 <xsl:output

  method="html"

  indent="yes"/>

 <xsl:template match="menu">

  <table>

   <xsl:apply-templates select="menuitem"/>

  </table>

 </xsl:template>

 <xsl:template match="menuitem">

  <tr>

   <td>

    <A alt="{@title}" href="{@href}">

     <img src="{unparsed-entity-uri(@image)}"/>

    </A>

   </td>

  </tr>

 </xsl:template>

</xsl:stylesheet>

Результат преобразования приведен на следующем листинге.

Листинг 8.69. Выходящий документ

<table>

 <tr>

  <td>

   <A alt="News" href="news.htm">

    <img src="file:/C:/XML/news.gif"/>

   </A>

  </td>

 </tr>

 <tr>

  <td>

   <A alt="Products" href="prods.htm">

    <img src="file:/C:/XML/prod.jpg"/>

   </A>

  </td>

 </tr>

 <tr>

  <td>

   <A alt="Support" href="support.htm">

    <img src="file:/С:/XML/support.gif"/>

   </A>

  </td>

 </tr>

</table>

Остается только добавить, что unparsed-entity-uri — это единственная функция, которая позволяет работать с неразбираемыми сущностями. Никаких средств для обработки нотаций и вспомогательных приложений, которые им соответствуют, в XSLT нет. Сказывается тот факт, что неразбираемые сущности и нотации очень редко используются в документах, поэтому их поддержка в XSLT минимальна.

Функция generate-id

Синтаксическая конструкция этой функции:

string generate-id(node-set?)

Функция generate-id возвращает уникальный строковый идентификатор первого в порядке просмотра документа узла, передаваемого ей в виде аргумента. Если аргумент опущен, функция возвращает уникальный идентификатор контекстного узла. Если аргументом является пустое множество, функция должна возвращать пустую строку.

Функция generate-id обладает следующими свойствами.

□ Функция generate-id возвращает для двух узлов один и тот же идентификатор тогда и только тогда, когда эти два узла совпадают. Это означает, что во время выполнения одного преобразования функция generate-id будет возвращать один идентификатор для одного и того же узла, а для разных узлов generate-id обязательно возвратит разные идентификаторы.

□ Возвращаемый идентификатор состоит только из цифр и букв ASCII и начинается буквой, то есть синтаксически является корректным XML-именем и может использоваться как имя элемента, атрибута, как значение ID-атрибута или в любом другом месте, где могут использоваться имена XML.

Кроме этого спецификация оговаривает следующие важные положения, которые мы приведем ниже.

□ Процессор не обязан генерировать один и тот же идентификатор при разных выполнениях преобразования одного и того же документа. Иными словами, если в понедельник процессор X при выполнении преобразования Y сгенерирует для узла Z документа D идентификатор I, то во вторник тот же процессор X при выполнении того же преобразования Y с тем же документом D может сгенерировать для того же самого узла Z совершенно другой, отличный от I идентификатор.

□ Форма возвращаемого идентификатора может быть произвольной, но при этом она должна удовлетворять описанному выше синтаксису. Это означает, что каждый процессор может по-своему генерировать идентификатор. Спецификация не определяет никакого стандартного метода реализации функции generate-id.

□ Генерируемый идентификатор может совпадать, а может и не совпадать со значениями уникальных атрибутов, то есть атрибутов, тип данных которых объявлен в блоке DTD как ID.

Помимо очевидного применения, например, для явного задания уникального идентификатора в выходящем документе, функция generate-id совершено неожиданным образом облегчает задачи группировки. Подробнее об этом мы расскажем в главе 11.

Пример

Предположим, что в наших XML-документах изменилась логическая схема: теперь каждый элемент item должен обладать уникальным атрибутом id.

Выполнить задачу конвертации может простое преобразование.

Листинг 8.70. Преобразование

<xsl:stylesheet

 version="1.0"

 xmlns:xsl="http://www.w3.org/1999/XSL/Transform">

 <xsl:template match="@*|node()">

  <xsl:copy>

   <xsl:apply-templates select="@*|node()"/>

  </xsl:copy>

 </xsl:template>

 <xsl:template match="item">

  <xsl:copy>

   <xsl:attribute name="id">

    <xsl:text><xsl:value-of select="generate-id()"/><xsl:text>

   </xsl:attribute>

   <xsl:apply-templates select="@*|node()"/>

  </xsl:copy>

 </xsl:template>

</xsl:stylesheet>

В выходящем документе элементы item будут иметь уникальные идентификаторы.

Листинг 8.71. Выходящий документ

<?xml version="1.0" encoding="utf-8"?>

<items>

 <item id="b1b1b2" source="a" name="A"/>

 <item id="b1b1b4" source="b" name="B"/>

 ...

 <item id="b1b1c34" source="a" name="F"/>

</items>

Сразу оговоримся, что этот способ будет работать не всегда: generate-id создает идентификатор, который является уникальным среди всех остальных идентификаторов узлов, а не среди всех значений уникальных атрибутов документа. Так что если бы какой-либо элемент имел ID-атрибут со значением b1b1b4, выходящий документ перестал бы быть правильным. Однако же, если в документе до преобразования вообще не было уникальных атрибутов, все будет в порядке.

Функция system-property

Синтаксис этой функции приведен ниже:

object system-property(string)

Функция system-property возвращает значение свойства, которое определяется ее строковым параметром. Аргумент этой функции должен представлять расширенное имя системного свойства. Если процессор не поддерживает свойство с таким именем, функция должна вернуть пустую строку.

Эта функция предназначена для получения информации об окружении, в котором производится преобразование. В стандарте языка указано, что все процессоры в обязательном порядке должны поддерживать следующие системные свойства:

□ xsl:version — это свойство должно возвращать номер версии языка XSLT, которую поддерживает данный процессор.

□ xsl:vendor — это свойство должно возвращать текстовую информацию о производителе используемого процессора.

□ xsl:vendor-uri — это свойство должно возвращать URL производителя — как правило, xsl:vendor-uri — это адрес Web-сайта производителя процессора.

К сожалению, в первой версии языка XSLT процессоры обязаны поддерживать только эти свойства. Очень полезным, было бы, например, свойство, возвращающее имя преобразования или преобразовываемого файла. К сожалению, ничего подобного в стандарте не предусмотрено.

Пример

В качестве примера приведем небольшой шаблон, выводящий в виде комментария информацию о процессоре.

Листинг 8.72. Шаблон, выводящий системную информацию

<xsl:template name="info">

 <xsl:comment>

  <xsl:text> | XSLT Version: </xsl:text>

  <xsl:value-of

   select="format-number(system-property('xsl:version'), '0.0')"/>

  <xsl:text> | XSLT Processor: </xsl:text>

  <xsl:value-of select="system-property('xsl:vendor')"/>

  <xsl:text> | URL: </xsl:text>

  <xsl:value-of select="system-property('xsl:vendor-url')"/>

  <xsl:text> +</xsl:text>

 </xsl:comment>

</xsl:template>

Процессор SAXON, написанный Майклом Кеем (Michael Kay), выводит следующий комментарий:

<!--

 | XSLT Version: 1.0

 | XSLT Processor: SAXON 6.0.2 from Michael Kay of ICL

 | URL: http://users.iclway.co.uk/mhkay/saxon/index.html

 +-->

Ожидается, что в будущих версиях XSLT набор системных свойств будет расширен. Кроме того, многие процессоры поддерживают дополнительные системные свойства, не оговоренные в спецификации.

Глава 9 Совместное использование XSLT с другими языками программирования

XSLT и другие языки

Несмотря на то, что XSLT является вполне самостоятельным языком, его очень часто используют как составную часть в проектах, которые пишутся на других языках программирования. Тому существует множество причин. Попытаемся выделить главные из них.

□ Традиционные императивные языки программирования очень плохо подходят для обработки древовидно структурированных данных. Программы, действия в которых непременно выполняются последовательно одно за другим, в общем случае не могут эффективно (с точки зрения компактности и понятности кода) обработать сложные иерархические структуры.

□ В некоторых случаях XSLT-преобразования документов оказываются, наоборот, настолько сложны, что из соображений эффективности и простоты бывает намного легче использовать традиционные языки.

□ Во многих проектах использование XSLT может обеспечить легкую и гибкую интеграцию. Например, если одним из этапов процедуры обмена XML-данными будет XSLT-преобразование, расширение количества форматов, известных системе, будет производиться не дописыванием исходного кода, а добавлением преобразований. А поскольку XSLT обеспечивает не только синтаксические, но и семантические преобразования, то есть преобразования на структурном уровне, роль этого языка в проектах интеграции, основанных на использовании XML, может быть очень велика.

□ Использование XSLT-преобразований может коренным образом упростить создание Web-ориентированных приложений. Надо сказать, что во многих случаях XSLT-преобразования просто избавляют от необходимости программировать что-либо на других языках; однако даже тогда, когда без традиционных подходов не обойдешься, XSLT служит хорошую службу, обеспечивая простой, удобный и легко настраиваемый вывод фрагментов HTML.

В этом разделе мы приведем примеры использования преобразований в различных языках и средах разработки. Конечно же, предлагаемые программы очень просты, но и их уже должно быть достаточно, чтобы начать применять XSLT в составе своих проектов.

Выполнение XSLT-преобразований в Object Pascal

В этой главе мы приведем пример использования XSLT-преобразований в простом проекте, созданном в среде разработки Delphi. Базовым языком Delphi является Object Pascal. Решение, которое мы предложим, будет основываться на использовании библиотеки MSXML Parser 3.0 от Microsoft.

Небольшое приложение, которое мы создадим, будет преобразовывать XML-документ (по умолчанию — "source.xml") при помощи XSLT-преобразования (по умолчанию — "stylesheet.xsl") и показывать результат преобразования.

Импорт MSXML в Delphi

Первым шагом после создания нового проекта (назовем его DelphiXML) будет импортирование библиотеки типов MSXML. Это позволит использовать в программе классы, интерфейсы и методы MSXML, в том числе и XSLT-процессор.

Для того чтобы импортировать библиотеку типов MSXML, выберем пункт меню Project/Import Type Library… (рис. 9.1).

Рис. 9.1. Импорт MSXML — шаг 1

В появившемся диалоге выберем пункт "Microsoft XML v3.0 (Version 3.0)" и создадим новый модуль кнопкой Create Unit (рис. 9.2).

Рис. 9.2. Импорт MSXML — шаг 2

Получившийся файл MSXML2_TLB.pas присоединим к проекту (Project/Add to Project…); теперь можно приступать к работе.

Для того чтобы использовать MSXML в нашем проекте, нам потребуется включить модуль MSXML2_TLB в список используемых модулей. Кроме того, для обработки исключений нам также потребуется модуль comobj. В итоге объявление uses будет выглядеть следующим образом:

uses

 Windows, Messages, SysUtils, Classes, Graphics, Controls,

 Forms, Dialogs, StdCtrls, ComCtrls, MSXML2_TLB, comobj;

Форма проекта

Нам понадобится форма с тремя страничками и тремя компонентами TMemo. В первом будет показываться исходный текст преобразуемого документа, во втором — XSLT-преобразование и в третьем — результат преобразования.

Приблизительный внешний вид формы показан на рис. 9.3.

Рис. 9.3. Внешний вид формы проекта

Использование DOMDocument

Объектная модель XML-документа в импортированной библиотеке будет представлена интерфейсом DOMDocument. В главном модуле проекта мы объявим две переменные, которые будут соответствовать обрабатываемому документу (xmlSource) и документу преобразования (xmlStylesheet):

var

 xmlSource: DOMDocument;

 xmlStylesheet: DOMDocument;

Для того чтобы создать экземпляры объектов наших документов, мы воспользуемся классом СoDOMDocument, который был создан в модуле MSXML2_TLB при импортировании. Метод Create этого класса создаст объекты, к методам и свойствам которых мы будем обращаться посредством уже упомянутого интерфейса DOMDocument:

xmlSource := CoDOMDocument.Create;

xmlStylesheet := CoDOMDocument.Create;

Для того чтобы загрузить XML-файл, мы воспользуемся функцией load интерфейса DOMDocument:

xmlSource.load('source.xml');

При загрузке файла вполне вероятны ошибки. Например, XML-документ может не являться хорошо оформленным. Для того чтобы успешно справиться с такого рода исключительными ситуациями, мы будем использовать конструкцию try...except и отрабатывать исключение EoleException:

try

 xmlStylesheet.load('stylesheet.xsl');

 memoStylesheet.Text := xmlStylesheet.xml;

except

 on e: EOleException do

  memoStylesheet.Text := e.Message;

end;

Для выполнения самого преобразования нам будет нужно использовать функцию transformNode:

try

 memoResult.Text := xmlSource.transformNode(xmlStylesheet);

except

 on e: EOleException do

  memoResult.Text := e.Message;

end;

Для удобства мы можем также добавить диалоги для загрузки файлов и многое другое, но эти усовершенствования мы здесь разбирать не будем. Ограничимся тем, что приведем главную часть исходного кода этого проекта.

Листинг 9.1. Использование XSLT-преобразования в Delphi

unit source;

interface

uses

 Windows, Messages, SysUtils, Classes, Graphics, Controls, Forms, Dialogs,

 StdCtrls, ComCtrls, MSXML2_TLB, comobj;

type

 TMain = class(TForm)

  { Компоненты формы и обработчики событий }

 private

 public

 end;

var

 xmlSource: DOMDocument;

 xmlStylesheet: DOMDocument;

 Main: TMain;

implementation

{$R *.DFM}

procedure TMain.FormCreate(Sender: Tobject);

begin

 xmlSource := CoDOMDocument.Create;

 xmlStylesheet := CoDOMDocument.Create;

 try

  xmlSource.load('source.xml');

  memoSource.Text := xmlSource.xml;

 except

  on e: EOleException do

   memoSource.Text := e.Message;

 end;

 try

  xmlStylesheet.load('stylesheet.xsl');

  memoStylesheet.Text := xmlStylesheet.xml;

 except

  on e: EOleException do

   memoStylesheet.Text := e.Message;

 end;

end;

procedure TMain.pcMainChange(Sender: TObject);

begin

 if pcMain.ActivePage = sheetResult then

 try

  memoResult.Text := xmlSource.transformNode(xmlStylesheet);

 except

  on e: EOleException do

   memoResult.Text := e.Message;

 end;

end;

{ Прочие процедуры и функции }

end.

Процесс использования нашего приложения приведен на следующих рисунках (рис. 9.4–9.6).

Рис. 9.4. Входящий документ

Рис. 9.5. Преобразование

Рис. 9.6. Выходящий документ

Выполнение XSLT-преобразований в C/C++

В качестве примера использования XSLT в языках С и С++ мы приведем очень простую программу, которая выполняет над документом source.xml преобразование stylesheet.xsl и выводит результат в файл document.out. На этот раз в качестве процессора мы будем использовать Xalan-C++, а в качестве среды разработки — Microsoft Visual С++.

Настройка путей

Для того чтобы использовать библиотеки Xalan в своем проекте, прежде всего, необходимо включить в исходный код файлы заголовков:

#include "util/PlatformUtils.hpp"

#include "XalanTransformer/XalanTransformer.hpp"

Файл PlatformUtils.hpp относится к библиотеке Xerces-C++, который используется в Xalan в качестве парсера XML-документов. Файл заголовка XalanTransformer.hpp относится к классу XalanTransformer, который мы и будем использовать для преобразования нашего документа.

Заголовочные файлы Xalan и Xerces могут быть найдены в поставке Xalan в каталогах xml-xalan\c\src и xml-xerces\c\src соответственно. Для того чтобы они могли бытьобнаружены компилятором, эти пути следует явным образом прописать в настройках среды (меню Tools/Options), как показано на рис. 9.7.

Рис. 9.7. Настройка путей Xalan в MSVC

Для того чтобы скомпилированный объектный код мог быть скомпонован, в проекте также должны быть указаны пути к библиотечным файлам Xalan (рис. 9.8).

Рис. 9.8. Настройка путей библиотек в проекте

Использование класса XalanTransformer

Теперь, когда мы разобрались со всякого рода настройками, можно заняться самой программой. Типичный сценарий использования Xalan в программе можно проиллюстрировать следующим кодом.

Листинг 9.2. Типовой сценарий использования Xalan

// Инициализируем Xerces

XMLPlatformUtils::Initialize();

// Инициализируем класс XalanTransformer

XalanTransformer::initialize();

// Создаем экземпляр класса XalanTransformer

XalanTransformer theXalanTransformer;

...

// Выполняем преобразование

theXalanTransformer.transform( ... );

...

// Освобождаем XalanTransformer

XalanTransformer::terminate();

// Освобождаем Xerces

XMLPlatformUtils::Terminate();

В соответствии с этим сценарием наша программа будет выглядеть следующим образом:

#include "StdAfx.h"

#include "util/PlatformUtils.hpp"

#include "XalanTransformer/XalanTransformer.hpp"

#include "strstream"

int main(int argc, const char* argv[]) {

 using std::cerr;

 // Инициализируем Xerces

 XMLPlatformUtils::Initialize();

 // Инициализируем класс XalanTransformer

 XalanTransformer::initialize();

 // Создаем экземпляр класса XalanTransformer

 XalanTransformer theXalanTransformer;

 // Выполняем преобразование

 int theResult = theXalanTransformer.transform("source.xml",

  "stylesheet.xsl", "document.out");

 // В случае, если произошла ошибка, выводим, информацию о ней

 if (theResult != 0) {

  cerr << "XalanError: \n" << theXalanTransformer.getLastError();

 }

 // Освобождаем XalanTransformer

 XalanTransformer::terminate();

 // Освобождаем Xerces

 XMLPlatformUtils::Terminate();

 return theResult;

}

Выполнение XSLT-преобразований в PHP

Начиная с четвертых версий, PHP поставляется вместе с XSLT-процессором Sablotron, который включен в РНР в качестве расширения.

Для того чтобы использовать Sablotron в PHP-скриптах, следует выполнить следующие действия:

1. Убедиться, что файл php_sablot.dll присутствует в каталоге расширений.

2. Убедиться, что в файле php.ini присутствует строка extension=php_sablot.dll.

3. Убедиться, что библиотеки expat.dll и sablot.dll находятся в каталоге, указанном в переменной окружения PATH.

Замечание

Приведенное описание касается только использования Sablotron на платформе Windows32. На других платформах потребуется сконфигурировать РНР с флагом --with-sablot. В остальном установка совершенно аналогична.

Теперь, когда библиотека Sablotron подключена, мы сможем написать небольшую программу, которая будет выводить страницу гостевой книги.

Страница гостевой книги

Предположим, что мы храним (или экспортируем) данные гостевой книги в следующем формате.

Листинг 9.3. Данные гостевой книги — файл source.xml

<page>

 <date>18/08/2001</date>

 <messages>

  <message>

   <ID>1</ID>

   <POSTED>15/03/45BC</POSTED>

   <PERSON>Julius</PERSON>

   <EMAIL>caesar@hotmail.com</EMAIL>

   <SUBJECT>:(</SUBJECT>

   <MSG>Et tu, Brute...</MSG>

  </message>

  <message>

   <ID>2</ID>

   <POSTED>20/07/1969</POSTED>

   <PERSON>Neil</PERSON>

   <SUBJECT>What did I have to say? Oh, yes...</SUBJECT>

   <MSG>One small step for a man; one giant leap for mankind!</MSG>

  </message>

 </messages>

</page>

Для того чтобы вывести форму гостевой книги и сообщения, содержащиеся в source.xml, мы создадим следующее преобразование.

Листинг 9.4. Преобразование stylesheet.xsl

<xsl:stylesheet

 version="1.0"

 xmlns:xsl="http://www.w3.org/1999/XSL/Transform">

 <!-- Формат вывода - html -->

 <xsl:output method="html"/>

 <!-- Шаблон обработки корневого узла -->

 <xsl:template match="/">

  <!-- Создаем форму гостевой книги -->

  <form method="POST" action="guestbook.xsql">

   <table>

    <tr>

     <td>Name</td>

     <td>E-mail</td>

    </tr>

    <tr>

     <td><input class="flat" type="text" name="person"/></td>

     <td><input class="flat" type="text" name="email"/></td>

    </tr>

    <tr>

     <td colspan="2">

      <xsl:text>Subject</xsl:text><BR/>

      <input type="text" name="subject"/><br/>

      <!-- В скрытом поле posted помещаем текущую дату -->

      <input type="hidden" name="posted" value="{page/date}"/><br/>

      <textarea rows="10" cols="50" name="msg"/><br/><br/>

      <input type="submit" value="Post"/>

     </td>

    </tr>

   </table>

  </form>

  <!-- Обрабатываем страницу -->

  <xsl:apply-templates select="page"/>

 </xsl:template>

 <!-- Обработка страницы -->

 <xsl:template match="page">

  <xsl:apply-templates select="messages"/>

 </xsl:template>

 <!-- Обработка сообщений -->

 <xsl:template match="messages">

  <xsl:apply-templates select="message"/>

 </xsl:template>

 <!-- Вывод сообщения -->

 <xsl:template match="message">

  <p>

   <xsl:text>From: </xsl:text>

   <xsl:choose>

    <!-- Если e-mail не указан, выводим просто имя -->

    <xsl:when test="not(EMAIL)">

     <xsl:value-of select="PERSON"/>

    </xsl:when>

    <!-- Если e-mail указан, выводим гиперссылку -->

    <xsl:otherwise>

     <A href="mailto:{EMAIL}"><xsl:value-of select="PERSON"/></A>

    </xsl:otherwise>

   </xsl:choose>

   <!-- Выводим дату записи -->

   <xsl:value-of select="concat(', ', POSTED)"/><br/>

   <!-- Если была указана тема, выводим ее -->

   <xsl:if test="SUBJECT">

    <xsl:text>Subject: </xsl:text>

    <xsl:value-of select="SUBJECT"/><BR/>

   </xsl:if>

   <HR/>

   <!-- Выводим текст сообщения -->

   <xsl:value-of select="MSG"/>

  </p>

 </xsl:template>

</xsl:stylesheet>

Теперь займемся самим php-скриптом.

Листинг 9.5. Скрипт guestbook.php

<html>

 <head>

  <title>Guestbook</title>

  <META

   http-equiv="Content-Type"

   content="text/html; charset=windows-1251">

  <link rel="stylesheet" type="text/css" href="style.css"/>

 </head>

 <body>

  <?php

   // Загружаем входящий документ

   $sourcefile = "source.xml";

   $sourcehandle = fopen($sourcefile, "r")

    or die("Невозможно открыть входящий документ.");

   $source = fread($sourcehandle, filesize($sourcefile));

   // Загружаем преобразование

   $stylesheetfile = "stylesheet.xsl";

   $stylesheethandle = fopen($stylesheetfile, "r")

    or die("Невозможно открыть файл преобразования");

   $stylesheet = fread($stylesheethandle, filesize($stylesheetfile));

   // Инициализируем XSLT-процессор

   $xslt = @xslt_create() or die("Can't create XSLT handle!");

   // Выполняем преобразование

   @xslt_process($stylesheet, $source, $result);

   // Выводим результат

   echo $result;

   // Освобождаем ресурсы

   @xslt_free($xslt);

  ?>

 </body>

</html>

Приблизительный результат выполнения этого скрипта можно видеть на рис. 9.9.

Рис. 9.9. Сгенерированная из PHP-скрипта страница гостевой книги

Выполнение XSLT-преобразований в JavaScript

JavaScript является одним из наиболее популярных скриптовых языков, которые применяются при программировании для Web. В этой главе мы покажем, как при помощи JavaScript и MSXML создать интерактивный каталог, основанный на XML и XSLT.

Предположим, что каталог организован в виде иерархии категорий приблизительно следующим образом.

Листинг 9.6. XML-документ каталога

<?xml version="1.0" encoding="windows-1251"?>

<catalog>

 <category title="Компьютеры">

  <category title="Настольные компьютеры"/>

  <category title="Серверы"/>

 </category>

 <category title="Комплектующие">

  <category title="Процессоры"/>

  <category title="Материнские платы"/>

 </category>

 <category title="Расходные материалы">

  <category title="Картриджи">

   <category title="Картриджи для плоттеров"/>

   <category title="Картриджи для принтеров"/>

  </category>

  <category title="Тонеры"/>

  <category title="Бумага"/>

 </category>

</catalog>

При отображении этого дерева мы будем раскрывать только определенную выбранную ветвь категорий. Скажем, если пользователь выбрал категорию "Расходные материалы", показывать информацию о компьютерах мы ему не будем. Иными словами, мы будем показывать только те категории, которые являются надкатегориями выбранной. Для того чтобы сделать это как можно эффективнее, мы выполним следующие шаги.

□ При помощи ключа и уникального идентификатора, сгенерированного функцией generate-id, мы найдем в дереве требуемую категорию и присвоим ее переменной $category.

□ Воспользовавшись осью ansector-or-self, мы найдем все надкатегории данной, то есть все категории, которые прямо или косвенно содержат найденную. Путь выборки будет иметь вид $category/ancestor-or-self::category. Найденное множество мы присвоим переменной $path.

□ При обработке каждой из категорий мы будем обрабатывать ее подкатегории только в том случае, если она является надкатегорией выбранной; иначе говоря — только в том случае, когда ее узел принадлежит множеству узлов $path. Проверять это мы будем при помощи условия count(.|$path)=count($path).

Искомое преобразование в итоге запишется в виде.

Листинг 9.7. Преобразование обрабатывающее наш каталог

<?xml version="1.0" encoding="windows-1251"?>

<xsl:stylesheet

 version="1.0"

 xmlns:xsl="http://www.w3.org/1999/XSL/Transform">

 <!-- Выводим документ в формате html и кодировке windows-1251 -->

 <xsl:output method="html" encoding="windows-1251"/>

 <!--

  | Переменная, которая содержит уникальный

  | идентификатор выбранного узла дерева

  +-->

 <xsl:param name="current" select="''"/>

 <!-- Определение ключа категории -->

 <xsl:key name="cat" match="category" use="generate-id(.)"/>

 <!-- Находим текущую категорию -->

 <xsl:variable name="category" select="key('cat',$current)"/>

 <!--

  | Находим надкатегории текущей категории, узлы которых

  | мы будем раскрывать в дереве

  +-->

 <xsl:variable name="path"

  select="$category/ancestor-or-self::category"/>

 <!-- Шаблон обработки каталога -->

 <xsl:template match="catalog">

  <xsl:apply-templates select="category"/>

 </xsl:template>

 <!-- Шаблон обработки категории-->

 <xsl:template match="category">

  <!-- Параметр, указывающий отступ -->

  <xsl:param name="indent"/>

  <!-- Выводим отступ -->

  <xsl:value-of select="$indent"/>

  <!-- Выводим информацию о категории в виде ссылки -->

  <а href="javascript:expand('{generate-id(.)}')">

   <!-- Перед названием категории выводим соответствующую иконку -->

   <img height="11" width="11" border="0">

    <xsl:choose>

     <!--

      | Если категория не содержит субэлементов,

      | выводим иконку с точкой

      +-->

     <xsl:when test="not(*)">

      <xsl:attribute name="src">images/dot.gif</xsl:attribute>

     </xsl:when>

     <!--

      | Если категория принадлежит ветке выбранной категории,

      | выводим иконку с минусом, что означает раскрытую ветку

      +-->

     <xsl:when test="count(.|$path)=count($path)">

      <xsl:attribute name="src">images/minus.gif</xsl:attribute>

     </xsl:when>

     <!--

      | Если категория не принадлежит ветке выбранной категории,

      | выводим иконку с плюсом, что означает нераскрытую ветку

      +-->

     <xsl:otherwise>

      <xsl:attribute name="src">images/plus.gif</xsl:attribute>

     </xsl:otherwise>

    </xsl:choose>

   </img>

   <!--

    | Выводим неразрывный пробел.

    |   в Unicode соответствует  

    +-->

   <xsl:text> </xsl:text>

   <!-- Выводим название категории -->

   <xsl:value-of select="@title"/>

  </a>

  <br/><xsl:text> </xsl:text>

  <!--

   | Если категория принадлежит раскрываемой ветке,

   | обрабатываем ее подкатегории

   +-->

  <xsl:if test="count(.|$path)=count($path)">

   <xsl:apply-templates select="category">

    <!-- Увеличиваем отступ на три пробела -->

    <xsl:with-param name="indent"

     select="concat($indent,'   ')"/>

   </xsl:apply-templates>

  </xsl:if>

 </xsl:template>

</xsl:stylesheet>

Теперь осталось лишь только создать страницу, которая при помощи JavaScript и MSXML будет выполнять преобразования и выводить результат.

Для того чтобы воспользоваться возможностями MSXML, мы включим в нашу страницу два объекта:

<!-- Объект, представляющий входящий документ -->

<object

 id="source"

 width="0"

 height="0"

 classid="clsid:f5078f32-c551-11d3-89b9-0000f81fe221">

 <param name="async" value="false">

 <param name="validateOnParse" value="false">

</object>

<!-- Объект, представляющий документ преобразования -->

<object

 id="stylesheet"

 width="0"

 height="0"

 classid="clsid:f5078f32-c551-11d3-89b9-0000f81fe221">

 <param name="async" value="false">

 <param name="validateOnParse" value="false">

</object>

"Магический" код clsid:f5078f32-c551-11d3-89b9-0000f81fe221, который присутствует в тегах обоих объектов, на самом деле не что иное, как уникальный идентификатор библиотеки MSXML 3.0, которую мы и будем использовать для выполнения преобразования. Итак, код нашей HTML- страницы будет выглядеть следующим образом.

Листинг 9.8. Код HTML-страницы

<html>

 <head>

  <meta

   http-equiv="Content-Type"

   content="text/html; charset=windows-1251" />

  <style type="text/css">

   body {font-family:Tahoma,Verdana,Arial,sans-serif; font-size:14px}

   a:link {COLOR:#990000; BACKGROUND: #ffffff; TEXT-DECORATION: none}

   a:hover {BACKGROUND: #dddddd; TEXT-DECORATION: none}

   a:visited {COLOR: #990000; TEXT-DECORATION: none}

  </style>

  <script language="JavaScript">

   <!--

   // Объявляем глобальные переменные

   // Входящий документ

   var source;

   // Преобразование

   var stylesheet;

   // Результат

   var result;

   // Функция, выполняющая действия по инициализации

   function init() {

    // Инициализируем ссылку на объект входящего документа

    source = document.all['source'];

    // Загружаем входящий документ

    source.load('source.xml');

    // Инициализируем ссылку на объект преобразования

    stylesheet = document.all['stylesheet'];

    // Загружаем документ преобразования

    stylesheet.load('stylesheet.xsl');

    // Находим элемент, в который мы будем выводить

    // результат обработки

    result = document.all['result'];

   }

   // Функция, выполняющая "раскрытие"

   //определенной ветки дерева категорий.

   function expand(id) {

    // Получаем ссылку на атрибут select

    // объявления параметра current

    var attSelect = stylesheet.selectSingleNode(

     "/xsl:stylesheet/xsl:param[@name='current']/@select");

    // Изменяем значение этого атрибута. Одинарные кавычки необходимы

    // для того, чтобы новое значение воспринималось как литерал.

    attSelect.nodeValue = "'" + id + "'";

    // Выполняем преобразование

    strResult = source.transformNode(stylesheet);

    // Обновляем страницу

    result.innerHTML = strResult;

   }

   //-->

  </script>

 </head>

 <body onload="init()">

  <!-- Объект, представляющий входящий документ -->

  <object

   id="source"

   width="0"

   height="0"

   classid="clsid:f5078f32-c551-11d3-89b9-0000f81fe221">

   <param name="async" value="false">

   <param name="validateOnParse" value="false">

  </object>

  <!-- Объект, представляющий документ преобразования -->

  <object

   id="stylesheet"

   width="0"

   height="0"

   classid="clsid:f5078f32-c551-11d3-89b9-0000f81fe221">

   <param name="async" value="false">

   <param name="validateOnParse" value="false">

  </object>

  <a href="javascript:expand(' ')">Каталог</а>

  <!-- В этом элементе мы будем выводить результат -->

  <div id="result"/>

 </body>

</html>

В браузере эта страница будет выглядеть следующим образом (рис. 9.10).

Рис. 9.10. Динамический каталог на HTML с использованием JavaScript, MSXML на основе XML и XSLT

Выполнение XSLT-преобразований в VBScript/ASP

Использование MSXML на стороне сервера не сильно отличается от клиентской версии, которую мы разобрали выше. Поскольку MSXML является стандартным СОМ-объектом, его можно использовать в любом языке программирования, умеющем работать с COM. В следующем примере будет показано, как можно использовать MSXML в ASP-странице, написанной на языке VBScript. Мы напишем небольшое Web-приложение, которое позволит отправлять короткие сообщения (SMS) через разные службы, используя один интерфейс.

Почти у всех операторов мобильной связи формы для отправки сообщений более или менее стандартны, например:

<form action=" http://www.bmtelecom.ru/wap/xm.php?snd=1 " method="POST">

 <input type="hidden" name="num" value="номер телефона">

 <textarea rows="10" cols="50" name="msg">текст сообщения</textarea>

 <br><br>

 <input class="flat" type="submit" value="Послать сообщение">

</form>

При этом различаться могут адреса служб отправки сообщений, методы отправки форм и наименования полей ввода. Все это мы можем описать в отдельном документе.

Листинг 9.9. Документ, описывающий формы служб отправки сообщений — services.xml

<services>

 <service id="MTNSMS">

  <action>http://www.mtnsms.com/sendsms.php</action>

  <method>GET</method>

  <text>msg</text>

  <number>num</number>

 </service>

 <service id="SMSHost">

  <action>http://www.smshost.net/servlets/sms</action>

  <method>POST</method>

  <text>message</text>

  <number>phone</number>

 </service>

</services>

Контакт-лист после этого может быть оформлен следующим образом.

Листинг 9.10. Контакт-лист — документ source.xml

<?xml version="1.0" encoding="windows-1251"?>

<people>

 <person id="p1">

  <name>Иван Иванович</name>

  <number>18005557684</number>

  <service id="MTNSMS"/>

 </person>

 <person id="p2">

  <name>Иван Никифорович</name>

  <number>447856273447</number>

  <service id="SMSHost"/>

 </person>

</people>

Преобразование, генерирующее HTML-страницу с формой отправки можно задать как.

Листинг 9.11. Преобразование stylesheet.xsl

<?xml version="1.0" encoding="windows-1251"?>

<xsl:stylesheet

 version="1.0"

 xmlns:xsl="http://www.w3.org/1999/XSL/Transfоrm">

 <xsl:output

  method="html"

  indent="yes"

  encoding="windows-1251"/>

 <!-- Параметр, указывающий выбранного адресата, по умолчанию - p1 -->

 <xsl:param name="id" select="p1"/>

 <xsl:template match="/">

  <html>

   <xsl:call-template name="head"/>

   <body>

    <xsl:apply-templates select="people"/>

   </body>

  </html>

 </xsl:template>

 <xsl:template match="people">

  <!-- Создаем список адресатов -->

  <xsl:apply-templates select="person"/>

  <!-- Создаем форму для выбранного адресата -->

  <xsl:apply-templates select="person[@id=$id]" mode="form"/>

 </xsl:template>

 <xsl:template match="person">

  <!-- Если текущий адресат выбран -->

  <xsl:if test="@id = $id">

   <!-- Выводим его имя в квадратных скобках и без гиперссылки -->

   <xsl:text> [&#хА0;</xsl:text>

   <xsl:value-of select="name"/>

   <xsl:text> ] </xsl:text>

  </xsl:if>

  <!-- Если адресат не выбран -->

  <xsl:if test="@id != $id">

   <!-- Выводим его имя без скобок и с гиперссылкой -->

   <xsl:text> &#хА0;&#хА0;</xsl:text>

   <A href="sms.asp?id={@id}">

    <xsl:value-of select="name"/>

   </A>

   <xsl:text>   </xsl:text>

  </xsl:if>

 </xsl:template>

 <!-- Шаблон создания формы для выбранного адресата -->

 <xsl:template match="person" mode="form">

  <!--

   | Находим элемент, описывающий параметры службы отправки сообщений

   | текущему адресату

   +-->

  <xsl:variable name="service"

   select="document('services.xml')/services/

   service[@id = current()/service/@id]"/>

  <br/>

  <form

   action="{$service/action}" method="{$service/method}">

   <input type="hidden"

    name="{$service/number}"

    value="{number}"/>

   <textarea class="no-scrollbar" rows="10" cols="50"

    name="{$service/text}"/>

   <br/>

   <input class="flat" type="submit" value="Послать сообщение"/>

  </form>

 </xsl:template>

 <xsl:template name="head">

  <head>

   <title>SMS Center</title>

   <link rel="stylesheet" type="text/css" href="style.css"/>

  </head>

 </xsl:template>

</xsl:stylesheet>

Теперь дело осталось за ASP-страницей, которая применяла бы преобразование stylesheet.xsl к документу source.xml и возвращала результат клиенту.

Листинг 9.12. ASP-страница, использующая XSLT-преобразования

<%@ LANGUAGE = VBScript %>

<%

 ' Загружаем входящий документ

 Dim source

 Set source = Server.CreateObject("MSXML2.FreeThreadedDOMDocument.3.0")

 source.load Server.MapPath("source.xml")

 ' Загружаем преобразование

 Dim stylesheet

 Set stylesheet =

  Server.CreateObject("MSXML2.FreeThreadedDOMDocument.3.0")

 stylesheet.load Server.MapPath("stylesheet.xsl")

 ' Создаем объект XSLTemplate для преобразования

 Dim templates

 Set templates = Server.CreateObject("MSXML2.XSLTemplate")

 templates.stylesheet = stylesheet.documentElement

 ' Создаем объект XSLT-процессора

 Dim processor

 Set processor = templates.createProcessor

 processor.input = source

 ' Присваиваем параметру id значение параметра запроса id

 ' (то, что передано в sms.asp?id=...)

 processor.addParameter "id", "" + Request.QueryString("id"), ""

 ' Выполняем преобразование

 processor.transform

 ' Возвращаем результат

 Response.Charset = "windows-1251"

 Response.Write processor.output

%>

На рис. 9.11 показаны результаты работы sms.asp для id=p1 и id=p2.

Рис. 9.11. Внешний вид страницы, возвращаемой sms.asp

При вызове страницы sms.asp или sms.asp?id=p1 форма отправки сообщений будет сгенерирована в следующем виде:

<form action="http://www.mtnsms.com/sendsms.php" method="GET">

 <input type="hidden" name="num" value="18005557684">

 <textarea class="no-scrollbar" rows="10" cols="50" name="msg">

 </textarea>

 <br><br>

 <input class="flat" type="submit" value="Послать сообщение">

</form>

Для sms.asp?id=p2 форма будет иметь вид:

<form action="http://www.smshost.net/servlets/sms" method="POST">

 <input type="hidden" name="phone" value="447856273447">

 <textarea class="no-scrollbar" rows="10" cols="50" name="message">

 </textarea>

 <br><br>

 <input class="flat" type="submit" value="Послать сообщение">

</form>

Выполнение XSLT-преобразований в Python

Пример использования XSLT-преобразований в Python, который мы продемонстрируем ниже, будет основываться на использовании библиотек 4Suite и PyXML.

Простейший скрипт, преобразующий документ source.xml при помощи преобразования stylesheet.xsl будет выглядеть следующим образом.

Листинг 9.13. Простейший вызов 4Suite

python -с "import sys;from xml.xslt import _4xslt;_4xslt.Run(sys.argv[1:])" -i source.xml stylesheet.xsl

Использование XSLT-процессора в собственных программах на Python ненамного сложнее.

Листинг 9.14. Использование XSLT-процессора в Python

# Импортируем библиотеки

import sys

from xml.xslt.Processor import Processor

# Создаем XSLT-процессор

processor = Processor()

# Загружаем XSLT-преобразование

processor.appendStylesheetUri('stylesheet.xsl')

# Выполняем преобразование

result = processor.runUri('source.xml')

# Выводим результирующий документ print result

Выполнение XSLT-преобразований в PL/SQL

Универсальность технологии XSLT позволяет использовать ее на самых различных уровнях архитектуры приложений. В этом разделе мы приведем пример использования преобразований внутри базы данных.

На этот раз в качестве целевой платформы будет использоваться база данных Oracle 8i, которая обеспечивает поддержку XSLT несколькими встроенными пакетами: XMLDOM, XMLPARSER и XSLPROCESSOR.

Представим себе следующую схему элементарной БД (рис. 9.12):

Рис. 9.12. Схема простой базы данных

Таблица STYLESHEET содержит XSLT-преобразования, которые хранятся в полях CONTENT, поле ID указывает уникальный идентификатор каждого из них.

Таблица SOURCE содержит XML-документы (поле CONTENT), каждому из которых соответствует некоторое преобразование (внешний ключ STYLESHEETID). Нашей задачей будет создание представления, в котором документы, хранящиеся в таблице SOURCE, будут обрабатываться соответствующими преобразованиями из таблицы STYLESHEET.

Прежде всего, создадим таблицы и ключи, соответствующие приведенной выше схеме базы данных.

Листинг 9.15. Создание схемы БД

-- Создаем таблицу stylesheet

CREATE TABLE STYLESHEET

 (ID     INTEGER NOT NULL,

 CONTENT CLOB NULL);

-- Создаем первичный ключ таблицы STYLESHEET

ALTER TABLE STYLESHEET

 ADD (PRIMARY KEY (ID));

-- Создаем таблицу SOURCE

CREATE TABLE SOURCE

 (ID          INTEGER NOT NULL,

 CONTENT      CLOB NULL,

 STYLESHEETID INTEGER NOT NULL);

-- Создаем первичный ключ таблицы SOURCE

ALTER TABLE SOURCE

 ADD (PRIMARY KEY (ID));

-- Создаем внешний ключ, связывающий таблицы SOURCE и STYLESHEET

ALTER TABLE SOURCE

 ADD (FOREIGN KEY (STYLESHEETID) REFERENCES STYLESHEET);

После того, как схема базы данных была создана, в нее можно добавить записи, содержащие преобразования и обрабатываемые ими документы. Мы ограничимся простым преобразованием и еще более простым документом.

Листинг 9.16. Преобразование

<xsl:stylesheet

 version="1.0"

 xmlns:xsl="http://www.w3.org/1999/XSL/Transform">

 <xsl:template match="A">

  <B><xsl:value-of select="."/></B>

 </xsl:template>

</xsl:stylesheet>

Листинг 9.17. Обрабатываемый документ

<A>value</A>

Листинг 9.18. SQL-скрипт, загружающий документ и преобразование в БД

-- Сохраняем преобразование

INSERT INTO STYLESHEET VALUES

(1, '<xsl:stylesheet                                     '||

    ', version="1.0"                                     '||

    '  xmlns:xsl="http://www.w3.org/1999/XSL/Transform"> '||

    '  <xsl:template match="A">                          '||

    '   <B><xsl:value-of select="."/></B>                '||

    '   </xsl:template>                                  '||

    '  </xsl:stylesheet>                                 ');

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

INSERT INTO SOURCE VALUES

(1, '<A>value</A>', 1);

Для того чтобы выполнять преобразования в SELECT-выражении представления таблицы SOURCE, мы напишем функцию PROCESS, которая будет возвращать результат обработки документа с уникальным идентификатором, заданным параметром sourceID.

Листинг 9.19. Функция PROCESS

CREATE OR REPLACE FUNCTION PROCESS (sourceID NUMBER) RETURN VARCHAR2 IS

 -- Инициализация XML-парсера и XSLT-процессора

 parser XMLPARSER.Parser := XMLPARSER.newParser;

 processor XSLPROCESSOR.Processor := XSLPROCESSOR.newProcessor;

 -- Переменные для CLOB-значений входящего документа и преобразования

 sourceCLOB CLOB;

 stylesheetCLOB CLOB;

 -- Переменные для DOM-объектов входящего документа и преобразования

 sourceXML XMLDOM.DOMDocument;

 stylesheetXML XMLDOM.DOMDocument;

 -- Переменная для объекта преобразования

 stylesheet XSLPROCESSOR.Stylesheet;

 -- Переменная результата

 result varchar2(32767);

BEGIN

 -- Получаем CLOB-значение входящего документа в переменную sourceCLOB

 SELECT CONTENT

 INTO sourceCLOB

 FROM SOURCE

 WHERE ID = sourceID;

 -- Получаем CLOB-значение соответствующего преобразования

 SELECT STYLESHEET.CONTENT

 INTO stylesheetCLOB

 FROM STYLESHEET, SOURCE

 WHERE SOURCE.ID = sourceID AND SOURCE.STYLESHEETID = STYLESHEET.ID;

 -- Если хотя бы одно из значений - NULL, прерываем обработку

 -- и возвращаем NULL

 IF sourceCLOB IS NULL OR stylesheetCLOB IS NULL THEN

  RETURN NULL;

 END IF;

 -- Разбираем CLOB-значение входящего документа

 XMLPARSER.parseCLOB(parser, sourceCLOB);

 sourceXML := XMLPARSER.getDocument(parser);

 -- Разбираем CLOB-значение документа преобразования

 XMLPARSER.parseCLOB(parser, stylesheetCLOB);

 stylesheetXML := XMLPARSER.getDocument(parser);

 -- Инициализируем объект преобразования

 stylesheet := XSLPROCESSOR.newStylesheet(stylesheetXML, NULL);

 -- Выполняем преобразование

 XSLPROCESSOR.processXSL(processor, stylesheet, sourceXML, result);

 -- Освобождаем ресурсы

 XSLPROCESSOR.freeProcessor(processor);

 XMLPARSER.freeParser(parser);

 XMLDOM.freeDocument(sourceXML);

 XMLDOM.freeDocument(stylesheetXML);

 RETURN result;

 -- Обработка исключений

 EXCEPTION

  -- Если возникла исключительная ситуация

  WHEN OTHERS THEN

   -- Освобождаем ресурсы

   XSLPROCESSOR.freeProcessor(processor);

   XMLPARSER.freeParser(parser);

   XMLDOM.freeDocument(sourceXML);

   XMLDOM.freeDocument(stylesheetXML);

  -- Передаем исключение дальше

  RAISE;

END;

Представление обработанных документов теперь может быть описано совершенно элементарно.

Листинг 9.20. Представление PROCESSED_SOURCE

CREATE OR REPLACE VIEW PROCESSED_SOURCE AS

SELECT ID, PROCESS(ID) AS CONTENT

FROM SOURCE;

Продемонстрируем работу функции PROCESS и представления PROCESS_SOURCE на примере двух запросов.

Листинг 9.21. Запросы к таблице SOURCE и представлению PROCESSED_SOURCE

SQL> SELECT * FROM SOURCE;

ID  CONTENT       STYLESHEETID

--  ------------  ------------

1   <A>value</A>  1

SQL> SELECT * FROM PROCESSED_SOURCE;

ID CONTENT

-- -------------------------------------------------------

1  <?xml version = '1.0' encoding = 'UTF-8'?> <B>value</B>

Выполнение XSLT-преобразований в Java

Язык Java традиционно широко поддерживает XML-технологии: большинство передовых разработок в этой области реализуется, как правило, сначала на Java и уж затем переносится на другие платформы разработки.

Не стал исключением и XSLT. Можно смело сказать, что количество XSLT-средств, написанных на Java, превосходит половину вообще всех существующих в настоящее время XSLT-пакетов.

Для того чтобы продемонстрировать использование XSLT в Java, мы приведем два варианта одной и той же программы — серверного приложения (сервлета), которое по запросу клиента будет возвращать информацию о текущем HTTP-сеансе в формате HTML.

Первый вариант сервлета можно назвать "традиционным". В нем HTML-документ создается серией инструкций out.println(...), которые выводят в выходящий поток размеченную HTML-тегами информацию о текущем сеансе.

Листинг 9.22. Традиционный вариант сервлета

import javax.servlet.*;

import javax.servlet.http.*;

import java.io.*;

import java.util.*;

public class example extends HttpServlet {

 /**

 * Инициализация.

 */

 public void init(ServletConfig config) throws ServletException {

  super.init(config);

 }

 /**

 * Основной метод сервлета

 */

 public void service(HttpServletRequest request,

  HttpServletResponse response)

  throws ServletException, IOException {

  // Выставляем тип содержимого

  response.setContentType("text/html");

  // Инициализируем выходящий поток

  OutputStreamWriter osw =

   new OutputStreamWriter(response.getOutputStream());

  PrintWriter out = new PrintWriter (response.getOutputStream());

  // Выполняем вывод HTML-страницы

  out.println("<html>");

  // Выводим головную часть HTML-документа

  out.println(" <head>");

  out.println("  <title>Request information</title>");

  out.println(" </head>");

  // Выводим тело документа

  out.println(" <body>");

  // Выводим общую информацию о запросе

  out.println("  <h1>General information</h1>");

  out.println("  <table>");

  // Выводим имя сервера

  out.println("   <tr>");

  out.println("    <td>Server name</td>");

  out.println("    <td>" + request.getServerName() + "</td>");

  out.println("   </tr>");

  // Выводим порт сервера

  out.println("   <tr>");

  out.println("    <td>Server port</td>");

  out.println("    <td>" + request.getServerPort() + "</td>");

  out.println("   </tr>");

  // Выводим адрес запрашивающей стороны

  out.println("   <tr>");

  out.println("    <td>Remote address</td>") ;

  out.println("    <td>" + request.getRemoteAddr() + "</td>");

  out.println("   </tr>");

  // Выводим название протокола запроса

  out.println("   <tr>");

  out.println("    <td>Protocol</td>");

  out.println("    <td>" + request.getProtocol() + "</td>");

  out.println("   </tr>");

  // Выводим метод запроса

  out.println("   <tr>") ;

  out.println("    <td>Method</td>");

  out.println("    <td>" + request.getMethod() + "</td>");

  out.println("   </tr>");

  // Выводим URI запроса

  out.println("   <tr>");

  out.println("    <td>Request URI</td>");

  out.println("    <td>" + request.getRequestURI() + "</td>");

  out.println("   </tr>");

  // Выводим строку запроса

  out.println("   <tr>");

  out.println("    <td>Query String</td>");

  out.println("    <td>" + request.getQueryString() + "</td>");

  out.println("   </tr>");

  out.println("  </table>");

  // Выводим параметры запроса

  out.println("  <h1>Request parameters</h1>");

  out.println("  <table>");

  for (Enumeration e = request.getParameterNames();

   e.hasMoreElements();) {

   String name = e.nextElement().toString();

   String[] values = request.getParameterValues(name);

   for (int i=0; i < values.length; i++) {

    out.println("   <tr>");

    out.println("    <td>" + name + "</td>");

    out.println("    <td>" + values[i] + "</td>");

    out.println("   </tr>");

   }

  }

  out.println("  </table>");

  // Выводим параметры HTTP-сессии

  out.println("  <h1>Session parameters</h1>");

  out.println("  <table>");

  HttpSession session = request.getSession(true);

  String[] names = session.getValueNames();

  for (int i=0; i < names.length; i++) {

   String name = session.getValueNames()[i];

   out.println("   <tr>");

   out.println("    <td>" + name + "</td>");

   out.println("    <td>" +

   session.getValue(name).toString() + "</td>");

   out.println("   </tr>");

  }

  out.println("  </table>");

  // Выводим cookies

  response.addCookie(new Cookie("content", "apple jam"));

  out.println("  <h1>Cookies</h1>");

  out.println("  <table>");

  Cookie[] cookies = request.getCookies();

  for (int i=0; i < cookies.length; i++) {

   out.println("   <tr>");

   out.println("    <td>" + cookies[i].getName() + "</td>");

   out.println("    <td>" + cookies[i].getValue() + "</td>");

   out.println("   </tr>");

  }

  out.println("  </table>");

  out.println(" </body>");

  out.println("</html>");

  // Закрываем выходящий поток

  out.close();

 }

}

Результатом обращения к этому сервлету по URL вида

http://localhost/servlet/example?x=1&y=2&z=3&x=4&y=5&z=6

будет документ, аналогичный представленному на рис. 9.13.

Рис. 9.13. Результат обращения к сервлету

Несложно видеть, насколько жестко в этом сервлете закодирована презентация данных: для минимального изменения генерируемого документа придется в обязательном порядке изменять сам сервлет, что в современных системах может быть непозволительной роскошью, — все равно, что перебирать мотор для того, чтобы перекрасить автомобиль.

Второй вариант того же самого сервлета, который мы предложим ниже, демонстрирует, как в данном случае при помощи XSLT можно разделить данные и их презентацию. Идея очень проста: вместо того, чтобы в жестко заданном виде выводить информацию в выходящий поток, можно создать XML-документ в виде DOM-объекта и затем применить к нему XSLT-преобразование, которое создаст для него требуемое HTML-представление.

В этом варианте сервлета мы будем использовать Java-версию XML-библиотеки Oracle XDK (Oracle XML SDK, платформа разработки XML-приложений, созданная в Oracle Corp.). В данном примере из этой библиотеки мы будем использовать только XSLT-процессор (класс XSLProcessor) и реализацию DOM-модели XML-документа (класс XMLDocument). Во всем остальном мы будем полагаться на Java-реализацию стандартных интерфейсов объектной модели документа DOM, разработанной Консорциумом W3. DOM-интерфейсы позволят нам манипулировать XML-документом на уровне модели: создавать и включать друг в друга узлы элементов, текстовые узлы и так далее.

Листинг 9.23. Вариант сервлета, использующий XSLT

import javax.servlet.*;

import javax.servlet.http.*;

import java.io.*;

import java.util.*;

import java.net.*;

import oracle.xml.parser.v2.*;

import org.w3c.dom.*;

public class example extends HttpServlet {

 /**

 * Функция, создающая в элементе parent элемент с именем name и

 * текстовым значением value. Если value имеет значение null,

 * текст не создается.

 */

 public static Element addElement(Element parent, String name, String value) {

  Element child = parent.getOwnerDocument().createElement(name);

  parent.appendChild(child);

  if (value != null) {

   Text text = parent.getOwnerDocument().createTextNode(value);

   child.appendChild(text);

  }

  return child;

 }

 /**

 * Инициализация.

 */

 public void init(ServletConfig config) throws ServletException {

  super.init(config);

 }

 /**

 * Основной метод сервлета

 */

 public void service(HttpServletRequest request,

  HttpServletResponse response)

  throws ServletException, IOException {

  // Выставляем тип содержимого

  response.setContentType("text/html");

  // Инициализируем выходящий поток

  OutputStreamWriter o_sw =

   new OutputStreamWriter(response.getOutputStream());

  PrintWriter out = new PrintWriter(response.getOutputStream());

  // Получаем объекты

  cookie Cookie[] cookies = request.getCookies();

  // Создаем выходящий документ

  XMLDocument doc = new XMLDocument();

  // Создаем корневой элемент

  Request Element elRequest = doc.createElement("Request");

  doc.appendChild(elRequest);

  // Создаем элемент General

  Element elGeneral = addElement(elRequest, "General", null);

  // Создаем элементы, содержащие общую информацию

  addElement(elGeneral, "ServerName", request.getServerName());

  addElement(elGeneral, "ServerPort",

   Integer.toString(request.getServerPort()));

  addElement(elGeneral, "RemoteAddr", request.getRemoteAddr());

  addElement(elGeneral, "Protocol", request.getProtocol());

  addElement(elGeneral, "Method", request.getMethod());

  addElement(elGeneral, "RequestURI", request.getRequestURI());

  addElement(elGeneral, "QueryString", request.getQueryString());

  // Создаем элемент Param

  Element elParam = addElement(elRequest, "Param", null);

  // В элементе Param создаем элементы, описывающие параметры запроса

  for (Enumeration e = request.getParameterNames();

   e.hasMoreElements();) {

   String name = e.nextElement().toString();

   String[] values = request.getParameterValues(name);

   // Для каждого из значений каждого из параметров

   // создаем соответствующий элемент

   for (int i=0; i < values.length; i++)

    addElement(elParam, name, values[i]);

  }

  // Создаем элемент Session

  Element elSession = addElement(elRequest, "Session", null);

  // Получаем объект HTTP-сессии

  HttpSession session = request.getSession(true);

  // Получаем имена параметров сессии

  String[] names = session.getValueNames();

  // В элементе Session создаем по элементу

  // для каждого из параметров сессии

  for (int i=0; i < names.length; i++)

   addElement(elSession, session.getValueNames()[i],

    session.getValue(session.getValueNames()[i]).toString());

  // Создаем элемент Cookie

  Element elCookie = addElement(elRequest, "Cookie", null);

  // Создаем по элементу для каждого из объектов cookies

  for (int i=0; i < cookies.length; i++)

   addElement(elCookie, cookies[i].getName(), cookies[i].getValue());

  // Преобразовываем созданный документ и выводим результат

  try {

   // Загружаем преобразование

   XSLStylesheet stylesheet = new XSLStylesheet(

    new URL("http://localhost/stylesheet.xsl"), null);

   // Выполняем преобразование

   XMLDocumentFragment fragment =

    (XMLDocumentFragment)doc.transformNode(stylesheet);

   // Выводим результат

   fragment.print(out);

  }

  catch (MalformedURLException mue) {}

  catch (XSLException xsle) {}

  // Закрываем выходящий поток

  out.close();

 }

}

В этом сервлете вместо того, чтобы просто печатать в выходящий поток данные и HTML-разметку, в переменной doc мы генерируем DOM-объект XML-документа. После того как все текстовые узлы и узлы элементов будут сгенерированы, документ, содержащийся в переменной doc, примет приблизительно следующий вид.

Листинг 9.24. XML-документ, сгенерированный в сервлете

<Request>

 <General>

  <ServerName>aphrodite.fzi.de</ServerName>

  <ServerPort>80</ServerPort>

  <RemoteAddr>127.0.0.1</RemoteAddr>

  <Protocol>HTTP/1.1</Protocol>

  <Method>GET</Method>

  <RequestURI>/servlet/example1</RequestURI>

  <QueryString>x=1&y=2&z=3&x=4&y=5&z=6

  </QueryString>

 </General>

 <Param>

  <z>3</z>

  <z>6</z>

  <y>2</y>

  <y>5</y>

  <x>1</x>

  <x>4</x>

 </Param>

 <Session>

  <v>4</v>

 </Session>

 <Cookie>

  <content>apple jam</content>

  <JServSessionIdroot>aaenbyjqc0</JServSessionIdroot>

 </Cookie>

</Request>

После того как генерация документа завершена, к нему применяется преобразование stylesheet.xsl, которое создает его HTML-представление.

Листинг 9.25. Преобразование stylesheet.xsl

<xsl:stylesheet

 version="1.0"

 xmlns:xsl="http://www.w3.org/1999/XSL/Transform">

 <xsl:template match="Request">

  <html>

   <head>

    <title>Request information</title>

   </head>

   <body><xsl:apply-templates mode="table"/></body>

  </html>

 </xsl:template>

 <xsl:template match="*" mode="table">

  <h1><xsl:apply-templates select="." mode="header"/></h1>

  <table><xsl:apply-templates mode="row"/></table>

 </xsl:template>

 <xsl:template match="General" mode="header">

  <xsl:text>General information</xsl:text>

 </xsl:template>

 <xsl:template match="Param" mode="header">

  <xsl:text>Request parameters</xsl:text>

 </xsl:template>

 <xsl:template match="Session" mode="header">

  <xsl:text>Session parameters</xsl:text>

 </xsl:template>

 <xsl:template match="Cookie" mode="header">

  <xsl:text>Cookies</xsl:text>

 </xsl:template>

 <xsl:template match="*" mode="row">

  <tr>

   <td><xsl:apply-templates select="." mode="name"/></td>

   <td><xsl:value-of select="."/></td>

  </tr>

 </xsl:template>

 <xsl:template match="*" mode="name">

  <xsl:value-of select="name()"/>

 </xsl:template>

 <xsl:template match="General/ServerName" mode="name">

  <xsl:text>Server name</xsl:text>

 </xsl:template>

 <xsl:template match="General/ServerPort" mode="name">

  <xsl:text>Server port</xsl:text>

 </xsl:template>

 <xsl:template match="General/RemoteAddr" mode="name">

  <xsl:text>Remote address</xsl:text>

 </xsl:template>

 <xsl:template match="General/RequestURI" mode="name">

  <xsl:text>Request URI</xsl:text>

 </xsl:template>

 <xsl:template match="General/QueryString" mode="name">

  <xsl:text>Query string</xsl:text>

 </xsl:template>

</xsl:stylesheet>

Результатом этого преобразования является следующий HTML-документ, внешний вид которого полностью идентичен документу, показанному на рис. 9.13.

Листинг 9.26. Результирующий HTML-документ

<html>

 <head>

  <title>Request information</title>

 </head>

 <body>

  <h1>General information</h1>

  <table>

   <tr>

    <td>Server name</td>

    <td>aphrodite.fzi.de</td>

   </tr>

   <tr>

    <td>Server port</td>

    <td>80</td>

   </tr>

   <tr>

    <td>Remote address</td>

    <td>127.0.0.1</td>

   </tr>

   <tr>

    <td>Protocol</td>

    <td>HTTP/1.1</td>

   </tr>

   <tr>

    <td>Method</td>

    <td>GET</td>

   </tr>

   <tr>

    <td>Request URI</td>

    <td>/servlet/example1</td>

   </tr>

   <tr>

    <td>Query string</td>

    <td>x=1&y=2&z=3&x=4&y=5&z=6</td>

   </tr>

  </table>

  <h1>Request parameters</h1>

  <table>

   <tr>

    <td>z</td>

    <td>3</td>

   </tr>

   <tr>

    <td>z</td>

    <td>6</td>

   </tr>

   <tr>

    <td>y</td>

    <td>2</td>

   </tr>

   <tr>

    <td>y</td>

    <td>5</td>

    </tr>

   <tr>

    <td>x</td>

    <td>1</td>

   </tr>

   <tr>

    <td>x</td>

    <td>4</td>

   </tr>

  </table>

  <h1>Session parameters</h1>

  <table>

   <tr>

    <td>v</td>

    <td>4</td>

   </tr>

  </table>

  <h1>Cookies</h1>

  <table>

   <tr>

    <td>content</td>

    <td>apple jam</td>

   </tr>

   <tr>

    <td>JServSessionIdroot</td>

    <td>aaenbyjqc0</td>

   </tr>

  </table>

 </body>

</html>

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

Представим, к примеру, что нам потребовалось перевести названия полей выводимого документа на русский язык — получить текст "Общая информация" вместо "General information" и так далее. В первом случае для внесения этого элементарного представления потребуется переписывать, перекомпилировать и обновлять на сервере сервлет; во втором случае все, что нужно будет сделать, — это исправить несколько строк в файле stylesheet.xsl.

Краткие выводы

В заключение хотелось бы сделать несколько комментариев относительно применения XSLT и вообще XML-технологий.

Как и в любом другом случае, нужно очень тщательно взвешивать целесообразность применения в проекте тех или иных средств. К сожалению, шумиха вокруг XML имеет чисто коммерческий характер, маркетинговые службы часто выдают желаемое за действительное, объявляя XML серебряной пулей для всех проблем информационных технологий.

Как мы знаем, серебряных пуль не бывает. Нужно всегда очень трезво относиться к выбору технологий, хорошо понимая их плюсы, минусы и что каждый из этих знаков будет означать для конкретного проекта. Глупо вслепую следовать моде и тенденциям, не обращая внимания на возникающие при этом издержки.

С этих позиций XSLT является наименее проблемной технологией в том смысле, что если встает вопрос, использовать XSLT или нет, это уже означает: вопрос об использовании XML-технологий решен положительно. Значит, разработчики уже пошли на жертвы ресурсов памяти и процессорной мощности, которые XSLT вряд ли ужесточит. Иначе говоря, аппаратные требования не являются определяющими для использования XSLT.

Другое обстоятельство, которое необходимо принимать во внимание, — это сложность самого преобразования. Базовый набор элементов XSLT вкупе с расширениями уже представляется чрезвычайно мощным средством для выполнения различных преобразований, однако в некоторых случаях даже этого может быть недостаточно. В других случаях мощь XSLT может наоборот оказаться неоправданной — например, с задачей представления внешнего вида HTML-документа в Web-браузере могут великолепно справиться каскадные таблицы стилей (CSS).

Глава 10 Расширения языка XSLT

Что такое расширения?

Предыдущие главы этой книги были посвящены, в основном, тому, что может XSLT. Эти возможности, естественно, далеко не безграничны, да и нельзя ожидать слишком многого от специализированного языка, каким является XSLT.

Вместе с тем в XSLT-преобразованиях может оказаться очень полезной функциональность традиционных языков программирования. Например, математических функций и операторов, имеющихся в XPath, явно недостаточно для выполнения сложных вычислений, которые могут потребоваться в преобразованиях. XSLT не имеет встроенных функций для обращения к базам данных, оставляют желать лучшего средства для работы с множествами, текстовыми данными, датами и временными параметрами, словом задачи, не представляющие никакой сложности в традиционных языках программирования, могут быть чрезвычайно трудоемкими в XSLT. Скажем, тригонометрические функции можно реализовать в XSLT рекурсивными вычислениями последовательностей Тейлора, но насколько проще было бы использовать функции sin и cos.

Таким образом, перед разработчиками языка стояла следующая дилемма: либо дублировать функциональность традиционных языков программирования в XSLT или XPath, либо изыскивать другие средства достижения тех же результатов.

Решение этой проблемы было довольно простым: вместо того, чтобы заново реализовывать все множество функций, которые только могут понадобиться при обработке документов, спецификация XSLT позволяет процессорам предоставлять интерфейсы для расширения XSLT и XPath за счет использования других языков программирования, например, Java, JavaScript или Python.

Существуют два способа расширения XSLT: при помощи функций и элементов расширения. Не изменяя структуры преобразований, два эти способа позволяют использовать при обработке документов возможности традиционных языков, что часто бывает очень полезно, а иногда и просто необходимо.

Рассмотрим примеры.

В языке XPath нет функции, которая генерировала бы псевдослучайное значение. Следующее преобразование приводит пример решения этой задачи с помощью стандартного класса Math языка Java.

Листинг 10.1. Преобразование, использующее класс java.lang.Math

<xsl:stylesheet version="1.0"

 xmlns:xsl="http://www.w3.org/1999/XSL/Transfоrm"

 xmlns:math="java:java.lang.Math"

 exclude-result-prefixes="math">

 <xsl:template match="/">

  <random><xsl:value-of select="math:random()"/></random>

 </xsl:template>

</xsl:stylesheet>

Результатом выполнения этого преобразования будет документ вида:

<random>0.0538608432986305</random>

Значение 0.0538608432986305 было получено посредством вызова метода random класса java.lang.Math и представляет собой некоторое псевдослучайное значение.

В качестве примера элемента расширения можно привести элемент saxon:entity-ref, определенный в XSLT-процессоре Saxon. Этот элемент создает в выходящем документе сущность с указанным именем.

Листинг 10.2. Использование элемента расширения saxon:entity-ref

<xsl:stylesheet

 version="1.0"

 xmlns:xsl="http://www.w3.org/1999/XSL/Transform"

 xmlns:saxon="http://icl.com/saxon"

 extension-element-prefixes="saxon">

 <xsl:template match="/">

  <xsl:text>Everybody</xsl:text>

  <saxon:entity-ref name="nbsp"/>

  <xsl:text>needs</xsl:text>

  <saxon:entity-ref name="nbsp"/>

  <xsl:text>space</xsl:text>

</xsl:template>

</xsl:stylesheet>

Результатом этого преобразования будет текст

Everybody needs space

Несложно понять, насколько мощным средством являются расширения. Они фактически позволяют реализовать в преобразованиях функциональность традиционных языков программирования. Иными словами, почти все то, что можно сделать в обычных языках программирования, можно сделать и в преобразованиях.

Как это часто бывает, за дополнительные возможности приходится платить. Использование механизма расширений предъявляет определенные требования и накладывает некоторые ограничения.

□ Реализация механизма расширений в текущей версии языка целиком и полностью зависит от производителей процессоров. Вследствие этого интерфейсы расширения различных XSLT-процессоров могут отличаться даже для одного языка программирования. Это в итоге ведет к несовместимости расширений и непереносимости XSLT-решений между различными процессорами.

□ Возможность использования того или иного языка для написания расширений зависит от наличия интерфейса XSLT-процессора для этого языка. Не следует ожидать, что любой процессор сможет работать с расширениями, написанными на любом языке, то есть, иначе говоря, расширения привязывают преобразования к строго определенному процессору или, в лучшем случае, группе процессоров.

□ В то время как сам XSLT не имеет сторонних эффектов, расширения этого принципа придерживаться не обязаны. Вследствие этого преобразования, в которых есть расширения с побочными эффектами могут из-за различных методов обработки входящего документа генерировать на разных процессорах разный результат.

Итак, вопрос, использовать расширения или нет — это вопрос "функциональность против переносимости", и, хотя его решение будет всегда зависеть от конкретной задачи, существуют также и довольно общие критерии оценки, которые мы приведем в следующей таблице (табл. 10.1).

Таблица 10.1. Использование расширений: критерии за и против

Использовать расширения стоит, если:	Использовать расширения не стоит, если:
преобразования будут выполняться на заранее известном процессоре или группе процессоров;	целевой процессор неизвестен. Преобразования должны быть переносимы, насколько это возможно;
в XSLT нет средств для выполнения требуемой задачи, либо они очень неэффективны;	в XSLT имеются средства для выполнения требуемой задачи;
преобразование должно обладать побочными эффектами;	преобразование может обойтись без побочных эффектов;
целевой процессор предоставляет интерфейс для хорошо известного разработчику языка программирования	интерфейс для нужного языка программирования в целевом процессоре отсутствует

Подводя итог, образно выражаясь, скажем, что расширения — это пушка, стрелять из которой по воробьям рекомендуется только, когда не остается ничего другого, или воробьи достаточно велики.

К сожалению, не представляется возможным описать в одной главе интерфейсы расширения даже наиболее распространенных XSLT-процессоров. Вместо этого мы постараемся изложить основные принципы создания расширения, а также приведем несколько общих примеров, которые смогут послужить основой для создания частных решений.

Основным языком реализации расширений, приводимых в этой главе, будет Java. Пожалуй, Java является единственным языком, интерфейсы расширений для которого достаточно стандартизированы, чтобы можно было говорить об общих подходах. Однако, если читатель не знаком с этим языком — ничего страшного, ведь основное внимание в этой главе уделяется использованию расширений в XSLT, а не написанию их в других языках и Java-код приводится только для того, чтобы сделать примеры рабочими.

Функции расширения

Прежде чем описывать использование функций расширения, вспомним, как мы вызывали в преобразованиях обычные функции, например, функцию concat:

<xsl:value-of select="concat('para', 'bellum')"/>

Атрибут select содержит XPath-выражение concat('para', 'bellum'), которое с точки зрения синтаксиса XPath является вызовом функции и соответствует продукции FunctionCall:

[XP16] FunctionCall ::= FunctionName

                        '(' ( Argument ( ',' Argument ) * ) ? ')'

Аргументами функции являются выражения, а имя может быть любым корректным XML-именем (за исключением node, comment, processing-instruction и text, которые используются для проверки типа узла):

[XP17] Argument     ::= Expr

[XP35] FunctionName ::= QName - NodeType

В плане синтаксиса функции расширения ничем не отличаются от стандартных функций: они отвечают тем же самым грамматическим правилам. Единственное различие состоит в том, что функции стандартных библиотек XPath и XSLT принадлежат нулевому пространству имен, в то время как пространство имен функций расширения должно обязательным образом быть ненулевым. Иными словами, вызовы функций, имеющие вид имя(аргумент, аргумент, ...), будут считаться вызовами функций базовых библиотек, а вызовы вида префикс:имя(аргумент, аргумент, ...) будут считаться вызовами функций расширения.

Пример

Выражение

round(0.6)

является вызовом функции базовой библиотеки XPath, в то время как выражение

math:round(0.6)

является вызовом функции расширения.

Практически во всех процессорах пространство имен функции расширения является звеном, которое связывает ее с конкретной реализацией.

Пример

<xsl:value-of select="math:round(0.6)" xmlns:math="java:java.lang.Math"/>

Элемент xsl:value-of вычисляет выражение math:round(0.6), которое является вызовом функции расширения. Само имя функции состоит из локальной части round и префикса math, которому соответствует URI java:java.lang.Math. В большинстве XSLT-процессоров вызов такого рода будет означать обращение к статической функции round класса java.lang.Math.

Простейшим случаем использования расширений в XSLT-процессорах, написанных на Java, является обращение к стандартным функциям пакетов Java.

Пример

Предположим, что входящий документ описывает координаты множества точек, а преобразование создает SVG-документ, содержащий линии, которые их последовательно соединяют.

Примечание

SVG — это XML-язык для описания масштабируемой векторной графики (от англ. scalable vector graphics). SVG позволяет простым XML-синтаксисом описывать векторную графику. SVG-документы могут показываться в браузерах при помощи таких компонент, как Adobe SVG Viewer или Batik от Apache XML Project.

Листинг 10.3. Входящий документ

<?xml version="1.0" encoding="windows-1251"?>

<точки width="200" height="200">

 <точка x="-50" y="-50"/>

 <точка x=" 50" y="-50"/>

 <точка x=" 50" y=" 50"/>

 <точка x="-50" y=" 50"/>

</точки>

Листинг 10.4. Преобразование

<?xml version="1.0" encoding="windows-1251"?>

<xsl:stylesheet

 version="1.0"

 xmlns:xsl="http://www.w3.org/1999/XSL/Transform"

 xmlns="http://www.w3.org/2000/svg">

 <xsl:output

  indent="yes"

  doctype-public="-//W3C//DTD SVG 1.0//EN"

  doctype-system="http://www.w3.org/TR/2001/REC-SVG-20010904/DTD/svg10.dtd"/>

 <xsl:template match="/">

  <svg width="200" height="200">

   <desc>Simple line-based figure</desc>

   <xsl:apply-templates select="точки"/>

  </svg>

 </xsl:template>

 <xsl:template match="точки">

  <g style="stroke:black; stroke-width:2">

   <xsl:apply-templates select="точка"/>

  </g>

 </xsl:template>

 <xsl:template match="точка">

  <line

   x1="{@x + 100}"

   y1="{@y + 100}"

   x2="{following-sibling::точка[1]/@x + 100}"

   y2="{following-sibling::точка[1]/@y + 100}">

   <xsl:if test="position() = last()">

    <xsl:attribute name="x2">

     <xsl:value-of

      select="preceding-sibling::точка[last()]/@x + 100"/>

    </xsl:attribute>

    <xsl:attribute name="y2">

     <xsl:value-of

      select="preceding-sibling::точка[last()]/@y + 100"/>

    </xsl:attribute>

   </xsl:if>

  </line>

 </xsl:template>

</xsl:stylesheet>

Результатом этого преобразования является следующий SVG-документ.

Листинг 10.5. Выходящий SVG-документ

<!DOCTYPE svg

 PUBLIC "-//W3C//DTD SVG 1.0//EN"

 "http://www.w3.org/TR/2001/REC-SVG-20010904/DTD/svg10.dtd">

<svg xmlns="http://www.w3.org/2000/svg" width="200" height="200">

 <desc>Simple line-based figure</desc>

 <g style="stroke:black; stroke-width:2">

  <line x1="50" y1="50" x2="150" y2="50"/>

  <line x1="150" y1="50" x2="150" y2="150"/>

  <line x1="150" y1="150" x2="50" y2="150"/>

  <line x1="50" y1="150" x2="50" y2="50"/>

 </g>

</svg>

На рис. 10.1 приведен пример визуального представления этого документа.

Рис. 10.1. Визуальное представление полученного SVG-документа

Предположим теперь, что нам нужно не просто создать по данному множеству точек набор соединяющих их линий, но еще и произвести некоторые геометрические преобразования, например поворот на заданный в градусах угол α.

Формулы преобразования координат при повороте чрезвычайно просты:

x = x'∙cos(α) − y∙sin(α),

у = x'∙sin(α) + x'∙cos(α),

где x' и y' — старые координаты точки, x и y — новые координаты точки, а α — угол поворота. Единственная загвоздка состоит в том, что функций sin и cos в базовой библиотеке XPath нет.

Самым простым выходом в такой ситуации является использование расширений. Например, в случае XSLT-процессора, который может использовать Java-расширения (Saxon, Xalan, Oracle XSLT Processor и так далее) надо будет лишь только объявить пространство имен вида:

xmlns:math="java:java.lang.Math"

и использовать функции math:sin и math:cos.

Листинг 10.6. Преобразование, осуществляющее поворот

<?xml version="1.0" encoding="windows-1251"?>

<xsl:stylesheet

 version="1.0"

 xmlns:xsl="http://www.w3.org/1999/XSL/Transform"

 xmlns="http://www.w3.org/2000/svg"

 xmlns:math="java:java.lang.Math">

 <xsl:output

  indent="yes"

  doctype-public="-//W3C//DTD SVG 1.0//EN"

  doctype-system="http://www.w3.org/TR/2001/REC-SVG-20010904/DTD/svg10.dtd"/>

 <xsl:param name="alpha" select="30"/>

 <xsl:variable name="alpha-radian" select="3.14 * ($alpha div 180)"/>

 <xsl:template match="/">

  <svg width="200" height="200">

   <desc>Simple line-based figure</desc>

   <xsl:apply-templates select="точки"/>

  </svg>

 </xsl:template>

 <xsl:template match="точки">

  <g style="stroke:black; stroke-width:2">

   <xsl:apply-templates select="точка"/>

  </g>

 </xsl:template>

 <xsl:template match="точка">

  <xsl:variable name="x1" select="@x"/>

  <xsl:variable name="y1" select="@y"/>

  <xsl:variable name="x2r">

   <xsl:choose>

    <xsl:when test="position() = last()">

     <xsl:value-of select="preceding-sibling::точка[last()]/@x"/>

    </xsl:when>

    <xsl:otherwise>

     <xsl:value-of select="following-sibling::точка[1]/@x"/>

    </xsl:otherwise>

   </xsl:choose>

  </xsl:variable>

  <xsl:variable name="y2r">

   <xsl:choose>

    <xsl:when test="position() = last()">

     <xsl:value-of select="preceding-sibling::точка[last()]/@y"/>

    </xsl:when>

    <xsl:otherwise>

     <xsl:value-of select="following-sibling::точка[1]/@y"/>

    </xsl:otherwise>

   </xsl:choose>

  </xsl:variable>

  <xsl:variable name="x2" select="number($x2r)"/>

  <xsl:variable name="y2" select="number($y2r)"/>

  <line

   x1="{$x1 * math:cos($alpha-radian) -

        $y1 * math:sin($alpha-radian) + 100}"

   y1="{$x1 * math:sin($alpha-radian) +

        $y1 * math:cos($alpha-radian) + 100}"

   x2="{$x2 * math:cos($alpha-radian) -

        $y2 * math:sin($alpha-radian) + 100}"

   y2="{$x2 * math:sin($alpha-radian) +

        $y2 * math:cos($alpha-radian) + 100}"/>

 </xsl:template>

</xsl:stylesheet>

Результатом этого преобразования будет следующий документ.

Листинг 10.7. Результирующий SVG-документ

<!DOCTYPE svg

 PUBLIC "-//W3C//DTD SVG 1.0//EN"

 "http://www.w3.org/TR/2001/REC-SVG-20010904/DTD/svg10.dtd">

<svg

 xmlns="http://www.w3.org/2000/svg"

 xmlns:math="java:java.lang.Math"

 width="200"

 height="200">

 <desc>Simple line-based figure</desc>

  <g style="stroke:black; stroke-width:2">

  <line

   x1="81.68060041188197" y1="31.70359014757173"

   x2="168.29640985242827" y2="81.68060041188197"/>

  <line

   x1="168.29640985242827" y1="81.68060041188197"

   x2="118.31939958811803" y2="168.29640985242827"/>

  <line

   x1="118.31939958811803" y1="168.29640985242827"

   x2="31.70359014757173" y2="118.31939958811803"/>

  <line

   x1="31.70359014757173" y1="118.31939958811803"

   x2="81.68060041188197" y2="31.70359014757173"/>

 </g>

</svg>

Визуальное представление этого документа демонстрирует рис. 10.2, где представлен поворот, выполненный на 30°:

Рис. 10.2. Визуальное представление полученного SVG-документа

Анализируя полученный документ, мы можем заметить объявление пространства имен с префиксом math, которое было в него включено:

<svg

 xmlns="http://www.w3.org/2000/svg"

 xmlns:math="java:java.lang.Math"

 width="200"

 height="200">

 ...

Это тот самый случай, когда объявление пространства имен используется в самом преобразовании, но является лишним в выходящем документе. Для того чтобы избавиться от него, нужно просто включить префикс math в атрибут exclude-result-prefixes элемента xsl:stylesheet.

<xsl:stylesheet

 version="1.0"

 xmlns:xsl="http://www.w3.org/1999/XSL/Transform"

 xmlns="http://www.w3.org/2000/svg"

 xmlns:math="java:java.lang.Math"

 exclude-result-prefixes="math">

 ...

Поскольку мы все равно используем в этом преобразовании расширения, мы можем написать свой собственный класс, который будет выполнять вычисление новых координат точки, исключив таким образом из преобразования все математические операции.

Листинг 10.8. Класс, вычисляющий координаты точки после поворота

package de.fzi.xslt;

public class rot {

 public static double X(double x, double y, double degree) {

  double radian = Math.PI * degree / 180;

  return x * Math.cos(radian) - y * Math.sin(radian);

 }

 public static double Y(double x, double y, double degree) {

  double radian = Math.PI * degree / 180;

  return x * Math.sin(radian) + y * Math.cos(radian);

 }

}

Для того чтобы использовать методы этого класса в качестве функций расширения, немного изменим объявления в элементе xsl:stylesheet:

<xsl:stylesheet

 version="1.0"

 xmlns:xsl="http://www.w3.org/1999/XSL/Transform"

 xmlns="http://www.w3.org/2000/svg"

 xmlns:rot="java:de.fzi.xslt.rot"

 exclude-result-prefixes="rot">

Создание элемента line теперь может быть записано в виде:

<line

 x1="{rot:X($x1, $y1, $alpha) + 100}"

 y1="{rot:Y($x1, $y1, $alpha) + 100}"

 x2="{rot:X($x2, $y2, $alpha) + 100}"

 y2="{rot:Y($x2, $y2, $alpha) + 100}"/>

Как мы отмечали выше, интерфейсы использования функций расширения весьма различаются между разными процессорами даже в случае такого переносимого языка, как Java. Отличия могут быть и в форме вызовов функций, и в форме объявлений пространств имен. Например, в процессоре Saxon пространство имен для класса de.fzi.xslt.rot может быть объявлено как:

xmlns:rot="java:de.fzi.xslt.rot"

в Xalan — как:

xmlns:rot="xalan://de.fzi.xslt.rot"

в Oracle XSLT Processor — как:

xmlns:rot="http://www.oracle.com/XSL/Transform/java/de.fzi.xslt.rot"

При этом сами вызовы во всех трех случаях будут одинаковыми:

rot:X($x, $y, $angle)

для метода X или

rot:Y($x, $y, $angle)

для метода Y.

Функция function-available

При использовании функций расширения всегда есть вероятность того, что это расширение в силу каких-либо причин поддерживаться данным процессором не будет. Чаще всего это случается, во-первых, когда процессор просто физически не в состоянии вызвать эту функцию (например, процессор, написанный на C++, вряд ли будет содержать средства для выполнения Java-кода), во-вторых, когда расширение недоступно (например, процессор не в состоянии найти указанный Java-класс или динамическую библиотеку), и в-третьих, когда пространство имен объявлено неверно (например, с URI java:de.fzi.xslt.rot вместо xalan://de.fzi.xslt.rot). Результатом обращения к неподдерживаемому расширению будет, естественно, ошибка.

XSLT позволяет избежать подобного рода ошибок путем предварительной проверки наличия заданной функции расширения. Для этой цели служит стандартная функция function-available (от англ. function is available — функция доступна)

boolean function-available(string)

Функция function-available принимает на вход строку, представляющую имя функции и возвращает true, если эта функция может быть вызвана и false — если нет.

Строковый аргумент этой функции представляет расширенное имя функции, он должен соответствовать продукции QName, то есть иметь вид имя или префикс:имя. В первом случае function-available проверяет, реализована ли в данном процессоре стандартная функция с таким именем, например function-available('concat') скорее всего, возвратит true.

В случае, если аргумент function-available имеет вид префикс:имя, функция function-available проверяет доступность указанной функции расширения. Например, для того, чтобы проверить, может ли в данном контексте быть вызвана функция rot:X, необходимо вычислить выражение

function-available('rot:X')

В данном случае true будет означать, что функция rot:X может быть вызвана, false — что функция в силу каких-то причин недоступна.

Функция function-available может помочь в создании преобразований, которые используют расширения, но при этом в некоторой степени сохраняют переносимость между различными процессорами. Достаточно написать несколько вариантов вызова функции расширения для каждого из процессоров, на которых преобразование должно работать, а затем использовать вариант с доступной данному процессору функцией расширения.

Пример

Для того чтобы обеспечить работоспособность расширения, реализованного классом de.fzi.xslt.rot в наиболее распространенных XSLT-процессорах, написанных на Java (как-то: Saxon, Xalan и Oracle XSLT Processor), прежде всего необходимо объявить соответствующие пространства имен:

<xsl:stylesheet

 version="1.0"

 xmlns:xsl="http://www.w3.org/1999/XSL/Transform"

 xmlns="http://www.w3.org/2000/svg"

 xmlns:saxon="java:de.fzi.xslt.rot"

 xmlns:xalan="xalan://de.fzi.xslt.rot"

 xmlns:oracle="http://www.oracle.com/XSL/Transform/java/de.fzi.xslt.rot"

 exclude-result-prefixes="saxon xalan oracle">

...

Префикс saxon соответствует интерфейсу расширений в XSLT-процессоре Saxon, префикс xalan — процессору Xalan и префикс oracle — Oracle XSLT Processor.

Теперь осталось только найти поддерживаемый вариант расширения и произвести соответствующий вызов.

Листинг 10.9

<xsl:choose>

 <xsl:when test="function-available('saxon:X') ">

  <line

   x1="{saxon:X($x1, $y1, $alpha) + 100}"

   y1="{saxon:Y($x1, $y1, $alpha) + 100}"

   x2="{saxon:X($x2, $y2, $alpha) + 100}"

   y2="{saxon:Y($x2, $y2, $alpha) + 100}"/>

 </xsl:when>

 <xsl:when test="function-available('xalan:X')">

  <line

   x1="{xalan:X($x1, $y1, $alpha) + 100}"

   y1="{xalan:Y($x1, $y1, $alpha) + 100}"

   x2="{xalan:X($x2, $y2, $alpha) + 100}"

   y2="{xalan:Y($x2, $y2, $alpha) + 100}"/>

 </xsl:when>

 <xsl:when test="function-available('oracle:X')">

  <line

   x1="{oracle:X($x1, $y1, $alpha) + 100}"

   y1="{oracle:Y($x1, $y1, $alpha) + 100}"

   x2="{oracle:X($x2, $y2, $alpha) + 100}"

   y2="{oracle:Y($x2, $y2, $alpha) + 100}"/>

 </xsl:when>

 <xsl:otherwise>

  <xsl:message terminate="yes">

   <xsl:text>Necessary extension function is not available.</xsl:text>

   <xsl:text> Supported processors are:</xsl:text>

   <xsl:text> Saxon, Xalan, Oracle XSLT Processor.</xsl:text>

  </xsl:message>

 </xsl:otherwise>

</xsl:choose>

В случае, если хотя бы одна из функций saxon:X, xalan:X, oracle:X будет доступна при обработке, она будет использована процессором для создания атрибутов элемента line. В противном случае, процессор прервет выполнение преобразования и выведет указанное в элементе xsl:message сообщение.

Нельзя не согласиться с тем, что приведенный выше способ не отличается элегантностью. Реализовывать свой вариант для каждого существующего процессора может быть довольно трудоемкой задачей — но такова уж плата за возможности расширений.

Функция расширения nodeset

Одной из самых полезных функций расширения, которая, как правило, уже штатно реализована во многих процессорах (то есть, не требует дополнительного программирования) является функция nodeset. Эта функция позволяет в обход прямого запрета спецификации конвертировать результирующий фрагмент дерева во множество узлов.

Предположим, что мы создаем в переменной rtf результирующий фрагмент дерева следующего вида:

<xsl:variable name="rtf">

 <item>1</item>

 <item>2</item>

 <item>3</item>

</xsl:variable>

При попытке вычислить выражение вида $rtf/item[2] процессор в соответствии со спецификацией должен вывести ошибку, поскольку в этом фильтрующем выражении (см. продукцию [XP20] FilterExpr) переменная rtf должна содержать множество узлов, а не фрагмент дерева.

Текущая спецификация языка XPath совершенно явно говорит о том, что ни один тип данных не может быть преобразован во множество узлов. Функция nodeset действует в обход этого запрещения: она принимает на вход результирующий фрагмент дерева и возвращает множество, состоящее из корневого узла этого фрагмента.

В разных процессорах эта функция имеет различный синтаксис: она может носить имя nodeset или node-set, или nodeSet, однако семантика ее во всех случаях одинакова:

nodeset nodeset(result-tree-fragment)

Функция принимает на вход единственный аргумент, являющийся фрагментом дерева и возвращает множество узлов, состоящее из его корня.

Пример

Предположим, что мы обрабатываем входящий документ, содержащий трехбуквенные коды языков.

Листинг 10.10. Входящий документ

<items>

 <item>ENG</item>

 <item>FRE</item>

 <item>GER</item>

 <item>GRE</item>

 <item>ITA</item>

 <item>NOR</item>

 <item>POR</item>

 <item>SPA</item>

</items>

Фрагмент шаблона, обрабатывающий этот список, может выглядеть следующим образом:

<select name="language">

 <xsl:for-each select="items/item">

  <option>

   <xsl:value-of select="."/>

  </option>

 </xsl:for-each>

</select>

Если в преобразовании нам понадобится доопределить входящий список кодами RUS и UKR, не исправляя входящий документ, можно поступить следующим образом:

□ создать в переменной фрагмент дерева, содержащий элементы item входящего документа плюс элементы item, доопределяющие этот список;

□ преобразовать дерево в список узлов;

□ обрабатывать список узлов точно так же, как мы бы обрабатывали сам входящий документ.

Преобразование, реализующее эти три шага, приведено ниже.

Листинг 10.11. Преобразование

<xsl:stylesheet

 version="1.0"

 xmlns:xsl="http://www.w3.org/1999/XSL/Transform"

 xmlns:xalan="http://xml.apache.org/xalan"

 exclude-result-prefixes="xalan">

 <xsl:template match="items">

  <!--

   | Создаем переменную tree, содержащую элементы item

   | входящего документа а также два дополнительных элемента

   +-->

  <xsl:variable name="tree">

   <xsl:copy-of select="item"/>

   <item>RUS</item>

   <item>UKR</item>

  </xsl:variable>

  <!--

   | Конвертируем переменную tree во множество узлов,

   | результат присваиваем переменной items

   +-->

  <xsl:variable name="items" select="xalan:nodeset($tree)"/>

  <!--

   | Обрабатываем узлы $items/item точно так же,

   | как мы обрабатывали бы узлы items/item

   +-->

  <select name="language">

   <xsl:for-each select="$items/item">

    <option>

     <xsl:value-of select="."/>

    </option>

   </xsl:for-each>

  </select>

 </xsl:template>

</xsl:stylesheet>

Результат этого преобразования приведен на следующем листинге.

Листинг 10.12. Выходящий документ

<select name="language">

 <option>ENG</option>

 <option>FRE</option>

 <option>GER</option>

 <option>GRE</option>

 <option>ITA</option>

 <option>NOR</option>

 <option>POR</option>

 <option>SPA</option>

 <option>USA</option>

 <option>RUS</option>

 <option>UKR</option>

</select>

Вне всякого сомнения, функция nodeset является одним из наиболее востребованных в XSLT расширений, ведь возможность не только создавать, но и манипулировать уже созданными древовидными структурами является чрезвычайно полезной.

В качестве одного из примеров применения функции nodeset можно привести реализацию с ее помощью многошаговых преобразований.

В качестве примера рассмотрим схему трансформации, изображенную на рис. 10.3, в которой документ А сначала нужно обработать преобразованием 1, затем полученный результат (документ В) обработать преобразованием 2. Конечным результатом цепочки преобразований в данном случае является документ С.

Рис. 10.3. Двухшаговое преобразование

При выполнении преобразования процессор применяет шаблоны ко множеству узлов входящего документа и выстраивает результирующее дерево. Таким образом, для того, чтобы повторно применить шаблоны к уже обработанному документу (читай: к полученному дереву), нужно просто иметь возможность преобразовывать дерево во множество узлов.

Пример

Представим себе два простых преобразования, first.xsl и second.xsl, первое из которых заменяет во входящем документе элементы а на элементы b, а второе — элементы b на элементы с.

Листинг 10.13. Преобразование first.xsl

<xsl:stylesheet

 version="1.0"

 xmlns:xsl="http://www.w3.org/1999/XSL/Transform">

 <xsl:template match="a">

  <b>

   <xsl:apply-templates select="@*|node()"/>

  </b>

 </xsl:template>

 <xsl:template match="@*|node()">

  <xsl:copy>

   <xsl:apply-templates select="@*|node()"/>

  </xsl:copy>

 </xsl:template>

</xsl:stylesheet>

Листинг 10.14. Преобразование second.xsl

<xsl:stylesheet

 version="1.0"

 xmlns:xsl="http://www.w3.org/1999/XSL/Transform">

 <xsl:template match="b">

  <c>

   <xsl:apply-templates select="@*|node()"/>

  </c>

 </xsl:template>

 <xsl:template match="@*|node()">

  <xsl:copy>

   <xsl:apply-templates select="@*|node()"/>

   </xsl:copy>

  </xsl:template>

</xsl:stylesheet>

Для того чтобы последовательно применить два этих преобразования к некоторому входящему документу a.xml, мы можем, например, дважды вызвать процессор:

java org.apache.xalan.xslt.Process -IN a.xml -XSL first.xsl -OUT b.xml

java org.apache.xalan.xslt.Process -IN b.xml -XSL second.xsl -OUT c.xml

В результате этих вызовов XSLT-процессор Xalan сначала применит преобразование first.xsl к документу a.xml и сохранит результат в файле b.xml, а затем обработает полученный документ b.xml при помощи преобразования second.xml и сохранит результат в файле c.xml.

В качестве альтернативы, например, для тех случаев, когда пакетная обработка невозможна, мы можем создать преобразование, последовательно применяющее шаблоны преобразований first.xsl и second.xsl к входящему документу. Для этого:

□ назначим шаблонам преобразования first.xsl режим first, а шаблонам преобразования second.xsl — режим second;

□ в основном шаблоне применим шаблоны режима first к узлам входящего документа, сохранив результат в переменной b;

□ приведем результирующее дерево, содержащееся в переменной b ко множеству узлов;

□ обработаем полученное множество узлов шаблонами режима second.

Следующий листинг демонстрирует предложенный подход.

Листинг 10.5. Преобразование first-then-second.xsl

<xsl:stylesheet

 version="1.0"

 xmlns:xsl="http://www.w3.org/1999/XSL/Transform"

 xmlns:xalan="http://xml.apache.org/xalan"

 exclude-result-prefixes="xalan">

 <!-- Шаблоны преобразования first -->

 <xsl:template match="a" mode="first">

  <b>

   <xsl:apply-templates select="@*|node()" mode="first"/>

  </b>

 </xsl:template>

 <xsl:template match="@*|node()" mode="first">

  <xsl:copy>

   <xsl:apply-templates select="@*|node()" mode="first"/>

  </xsl:copy>

 </xsl:template>

 <!-- Шаблоны преобразования second -->

 <xsl:template match="@*|node()" mode="second">

  <xsl:copy>

   <xsl:apply-templates select="@*|node()" mode="second"/>

  </xsl:copy>

 </xsl:template>

 <xsl:template match="b" mode="second">

  <c>

   <xsl:apply-templates select="@*|node()" mode="second"/>

  </c>

 </xsl:template>

 <!-- Основное преобразование -->

 <xsl:template match="/">

  <!-- Присваиваем переменной а корень входящего документа -->

  <xsl:variable name="a" select="/"/>

  <!-- Выводим переменную a -->

  <xsl:comment> a: </xsl:comment>

  <xsl:copy-of select="$a"/>

  <!-- Присваиваем переменной b результат обработки переменной a -->

  <xsl:variable name="b">

   <xsl:apply-templates select="$a" mode="first"/>

  </xsl:variable>

  <!-- Выводим переменную b -->

  <xsl:comment> b: </xsl:comment>

  <xsl:copy-of select="$b"/>

  <!-- Присваиваем переменной с результат обработки переменной b -->

  <xsl:variable name="c">

   <xsl:apply-templates select="xalan:nodeset($b)" mode="second"/>

  </xsl:variable>

  <!-- Выводим переменную c -->

  <xsl:comment> c: </xsl:comment>

  <xsl:copy-of select="$c"/>

 </xsl:template>

</xsl:stylesheet>

Ход этого преобразования лучше всего прокомментирует полученный результат.

Листинг 10.16. Входящий документ

<а>

 <a>1</a>

 <a>2</a>

</а>

Листинг 10.17. Выходящий документ

<!-- а: -->

<а>

 <a>1</a>

 <a>2</a>

</а>

<!-- b:-->

<b>

 <b>1</b>

 <b>2</b>

</b>

<!-- с: -->

<с>

 <c>1</c>

 <c>2</c>

</с>

Элементы расширения

Другой, несколько реже используемой, но не менее мощной возможностью расширения XSLT являются элементы расширения. В отличие от обычных элементов, при выполнении преобразования элементы расширения не просто копируются в выходящее дерево. При их обработке процессор должен выполнить определенные действия. Например, многие XSLT-процессоры, написанные на Java, позволяют связывать элементы расширения с методами Java-классов.

Пример

Предположим, что при выполнении преобразования в выходящий документ нам необходимо включить информацию о том, когда документ был сгенерирован — добавить элемент вида:

<p>This page was generated at 10:23.</p>

Пожалуй, самым элегантным решением этой задачи будет использование элемента расширения, который копировал бы в выходящий документ текущее время. Иначе говоря, при выполнении шаблона вида:

<xsl:template match="/">

 <!-- ... -->

 <p>This page was generated at <ext:time/>.</p>

</xsl:template>

элемент расширения ext:time должен быть заменен текущим временем. Ниже мы приведем пример реализации этого элемента для процессора Xalan.

Интерфейс программирования расширений в Xalan требует, чтобы для каждого элемента расширения был определен метод вида:

тип элемент(org.apache.xalan.extensions.XSLProcessorContext context,

            org.apache.xalan.templates.ElemExtensionCall elem)

где тип — тип возвращаемого значения, а элемент — локальная часть имени элемента расширения. Поскольку мы создаем элемент с локальной частью имени time и строковым типом возвращаемых данных, прототип нашего метода будет выглядеть как:

public String time(XSLProcessorContext context,

                   ElemExtensionCall elem)

Два аргумента, которые передаются методу элемента расширения, описывают контекст преобразования (XSLProcessorContext) и параметры вызова элемента расширения (ElemExtensionCall). Чуть позже мы покажем, как можно использовать эти объекты для создания более функциональных элементов расширения; пока же продолжим с элементом ext:time.

Следующим шагом мы создадим класс расширения ext.java, в котором реализуем описанный выше метод time.

Листинг 10.18 Класс ext.java

package de.fzi.xslt;

import java.util.Date;

import java.text.SimpleDateFormat;

import org.apache.xalan.extensions.XSLProcessorContext;

import org.apache.xalan.templates.ElemExtensionCall;

public class ext {

 public String time(XSLProcessorContext context,

  ElemExtensionCall elem) {

  SimpleDateFormat df = new SimpleDateFormat("HH:mm");

  return df.format(new Date());

 }

}

Равно как и в случае с функциями расширения, связующим звеном между элементами и Java-имплементацией их семантики служат пространства имен. В нашем случае класс de.fzi.xslt.ext может быть связан с префиксом пространства имен ext следующим объявлением:

xmlns:ext="xalan://de.fzi.xslt.ext"

Однако это еще не все. Для того чтобы элементы определенного пространства имен воспринимались процессором как элементы расширения, необходимо также явно указать префиксы этих пространств в атрибуте extension-element-prefixes элемента xsl:stylesheet:

<xsl:stylesheet

 ...

 extension-element-prefixes="ext">

 ...

</xsl:stylesheet>

В итоге наше преобразование будет иметь следующий вид.

Листинг 10.19. Преобразование, использующее элемент расширения

<xsl:stylesheet

 version="1.0"

 xmlns:xsl="http://www.w3.org/1999/XSL/Transform"

 xmlns:ext="xalan://de.fzi.xslt.ext"

 extension-element-prefixes="ext">

 <xsl:template match="/">

  <!-- ... -->

  <p>This page was generated at <ext:time/>.</p>

 </xsl:template>

</xsl:stylesheet>

Результатом этого преобразования будет документ вида:

<p>This page was generated at 11:56.</p>

Функциональность предложенного выше элемента расширения может быть легко расширена. Например, мы можем создать элемент ext:date, который будет выводить текущую дату или время в формате, зависящем от значения его атрибута pattern.

Листинг 10.20. Класс ext.java реализация элемента ext:date

package de.fzi.xslt;

import java.util.Date;

import java.text.SimpleDateFormat;

import org.apache.xalan.extensions.XSLProcessorContext;

import org.apache.xalan.templates.ElemExtensionCall;

public class ext{

 public String date(XSLProcessorContext context, ElemExtensionCall elem) {

  SimpleDateFormat df;

  // Получаем значение атрибута pattern элемента расширения

  String pattern = elem.getAttribute("pattern");

  // Если атрибут pattern не определен,

  // используем образец форматирования, определенный по умолчанию

  if (pattern == null)

   df = new SimpleDateFormat();

  // Если атрибут pattern определен, используем его значение

  // в качестве образца форматирования

  else

   df = new SimpleDateFormat(pattern);

  return df.format(new Date());

 }

}

В преобразовании этот элемент мы можем использовать как:

<p>This page was generated at <ext:date pattern="HH:mm"/> on

<ext:date pattern="dd/MM/yyyy"/>.</p>

или:

<p>This page was generated on <ext:date/>.</p>

В первом случае результатом будет:

<p>This page was generated at 12:11 on 08/10/2001.</p>

Во втором:

<p>This page was generated on 08.10.01 12:11.</p>

Естественно, семантика элементов расширения не ограничивается простым копированием в выходящий документ заданных значений. Элементы расширения могут выполнять гораздо более сложные функции, ограниченные, пожалуй, лишь только воображением разработчика. При этом элементы расширения на удивление удачно вписываются в структуру самого преобразования, ведь принцип их использования не сильно отличается от принципа использования самих элементов XSLT.

Функция element-available

boolean element-available(string)

Функция element-available совершенно аналогична функции function-available: она служит для проверки доступности в преобразовании того или иного элемента. Строковый параметр element-available задает расширенное имя элемента; функция возвращает true, если элемент с таким именем доступен, false — если нет.

Пример

Предположим, что преобразование, созданное нами для процессора Xalan с использованием элемента расширения ext:date, будет выполняться на каком-либо другом процессоре. В этом случае велика вероятность того, что вследствие несовместимости механизмов расширений это преобразование завершится ошибкой — "чужой" процессор просто не сможет выполнить элемент ext:date.

Во избежание этого, мы можем использовать функцию element-available для проверки доступности элемента ext:date до его вызова.

Листинг 10.21. Преобразование, использующее функцию element-available

<xsl:stylesheet

 version="1.0"

 xmlns:xsl="http://www.w3.org/1999/XSL/Transform"

 xmlns:ext="xalan://de.fzi.xslt.ext"

 extension-element-prefixes="ext">

 <xsl:template match="/">

  <result>

   <xsl:if test="element-available('ext:date')">

    <p>This page was generated at <ext:date pattern="HH:mm"/> on <ext:date pattern="dd/MM/yyyy"/>.</p>

   </xsl:if>

  </result>

 </xsl:template>

</xsl:stylesheet>

Элемент xsl:fallback

Другим способом обработки исключительных ситуаций, связанных с невозможностью выполнить тот или иной элемент преобразования, является использование элемента xsl:fallback. Синтаксическая конструкция этого элемента следующая:

<xsl:fallback>

 <!-- Содержимое: шаблон -->

</xsl:fallback>

Элемент xsl:fallback включается в "критическую" инструкцию, то есть в элемент, который может быть неизвестен процессору. В случае, если критическая инструкция отрабатывается нормально, содержимое xsl:fallback попросту игнорируется. Иначе, если процессор в силу некоторых причин не может выполнить критическую инструкцию, вместо нее он будет выполнять содержимое дочернего элемента xsl:fallback.

Пример

На тот случай, если процессор не сможет выполнить наш элемент расширения ext:date, мы можем "подстраховать" его следующим образом:

<ext:date pattern="HH:mm">

 <xsl:fallback>unknown time</xsl:fallback>

</ext:date>

В этом случае шаблон

<xsl:template match="/">

 <!-- ... -->

 <p>This page was generated at <ext:date pattern="HH:yy">

  <xsl:fallback>unknown time</xsl:fallback>

 </ext:date>.</p>

</xsl:template>

в случае невозможности выполнить ext:date выведет

<p>This page was generated at unknown time.</p>

Заметим, что xsl:fallback применим не только для обработки исключительных ситуаций, связанных с элементами расширения. Наборы доступных процессору элементов XSLT будут также меняться от версии к версии, и xsl:fallback вполне пригодится для обеспечения обратной совместимости. Например, если в версии XSLT 2.0 будет определен элемент xsl:for-each-group, то xsl:fallback можно использовать при создании альтернативного варианта для процессоров, которые еще не поддерживают новую версию:

<xsl:for-each-group select="item" group-by="@number">

 <!-- ... -->

 <xsl:fallback>

  <xsl:for-each select="item[generate-id(.)=

   generate-id(key('item', @number))]">

   <!-- ... -->

  </xsl:for-each>

 </xsl:fallback>

</xsl:for-each>

Инициатива EXSLT

Функции и элементы расширения с лихвой восполняют ограниченность языков XSLT и XPath, предоставляя возможности обычных императивных языков там, где они необходимы. Между тем, как показывает практика, задачи, которые приходится решать при помощи расширений, как правило, совершенно стандартны — например, разобранная выше функция nodeset, так или иначе реализована почти во всех XSLT-процессорах.

Инициатива EXSLT была порождена естественным желанием разработчиков иметь в своих XSLT-преобразованиях стандартные расширения и не дублировать усилия по решению общих проблем. В рамках EXSLT создаются стандартные библиотеки расширений XSLT для различных процессоров. Кроме того, EXSLT активно поддерживается многими разработчиками XSLT-процессоров с тем, чтобы обеспечить переносимость преобразований, использующих EXSLT-расширения.

Для конечного пользователя EXSLT — это множество библиотек расширений, которые можно загрузить с сайта http://www.exslt.org. Помимо этого, EXSLT-расширения уже являются встроенными для некоторых процессоров. Например, в процессоре Saxon реализовано большинство элементов и функций расширения EXSLT.

На данном этапе разработанные в рамках EXSLT библиотеки включают в себя следующие модули.

□ Common — общие функции и элементы расширения. Включает функции exslt:node-set и exslt:object-type и элемент exslt:document.

□ Math — математические функции.

□ Sets — функции для работы с множествами узлов (как-то: пересечение, разность и так далее).

□ Functions — элементы для определения пользовательских функций.

□ Dates and Times — элементы и функции для работы с временными параметрами.

□ Strings — модуль для работы со строками.

□ Regular Expressions — функции для работы с регулярными выражениями.

EXSLT покрывает большинство стандартных задач расширений — поэтому, прежде, чем браться за разработку собственных модулей расширения, следует проверить — нет ли уже реализованных аналогов. Кроме того, библиотеки EXSLT могут послужить хорошим примером программирования расширений.

Глава 11 Готовые решения

Группировка

Мы уже рассматривали задачу группировки, когда разбирали устройство и функционирование ключей — это была та самая задача, в которой из документа вида.

Листинг 11.1 Входящий документ

<items>

 <item source="a" name="A"/>

 <item source="b" name="B"/>

 <item source="a" name="C"/>

 <item source="c" name="D"/>

 <item source="b" name="E"/>

 <item source="b" name="F"/>

 <item source="c" name="G"/>

 <item source="a" name="H"/>

</items>

нужно было получить документ вида.

Листинг 11.2. Требуемый результат

<sources>

 <source name="а">

  <item source="a" name="A"/>

  <item source="a" name="C"/>

  <item source="a" name="H"/>

 </source>

 <source name="b">

  <item source="b" name="B"/>

  <item source="b" name="E"/>

  <item source="b" name="F"/>

 </source>

 <source name="c">

  <item source="c" name="D"/>

  <item source="c" name="G"/>

 </source>

</sources>

Легко понять, почему такая задача называется задачей группировки: требуется сгруппировать элементы item по значениям одного из своих атрибутов.

Напомним вкратце решение, которое было тогда предложено. При обработке первого объекта каждой группы мы создавали элемент source, в который включали все элементы item, принадлежащие этой группе. Для определения первого элемента мы использовали выражение

preceding-sibling::item[@source=current()/@source]

которое возвращало непустое множество только тогда, когда элемент не был первым в группе.

В этом разделе мы приведем гораздо более эффективное и остроумное решение задачи группировки, впервые предложенное Стивом Мюнхом (Steve Muench), техническим гуру из Oracle Corporation. Оно основывается на двух посылках.

□ Мы можем выбрать множество узлов по их свойствам при помощи ключей.

□ Мы можем установить, является ли узел первым узлом множества в порядке просмотра документа при помощи функции generate-id.

С первым пунктом все, пожалуй, ясно — выбор множества узлов по определенному критерию — это самое прямое предназначение ключей. Второй же пункт оставляет легкое недоумение: функция generate-id вроде бы предназначена только для генерации уникальных значений.

Для того чтобы развеять все сомнения, напомним, как ведет себя эта функция, если аргументом является множество узлов. В этом случае generate-id возвращает уникальный идентификатор первого в порядке просмотра документа узла переданного ей множества. Значит для того, чтобы проверить, является ли некий узел первым узлом группы, достаточно сравнить его уникальный идентификатор со значением выражения generate-id($group), где $group — множество узлов этой группы.

С учетом приведенных выше возможностей группирующее преобразование переписывается удивительно элегантным образом.

Листинг 11.3. Группирующее преобразование

<xsl:stylesheet

 version="1.0"

 xmlns:xsl="http://www.w3.org/1999/XSL/Transform">

 <xsl:key name="src" match="item" use="@source"/>

 <xsl:template match="items">

  <sources>

   <xsl:apply-templates

    select="item[generate-id(.)=generate-id(key('src', @source))]"/>

  </sources>

 </xsl:template>

 <xsl:template match="item">

  <source name="{@source}">

   <xsl:copy-of select="key('src', @source)"/>

  </source>

 </xsl:template>

</xsl:stylesheet>

Результат выполнения этого преобразования уже был приведен в листинге 11.2.

Перечисление узлов

Функции name и local-name предоставляют возможности для работы с документом, имена элементов и атрибутов в котором заранее неизвестны. Например, если шаблон определен как:

<xsl:template match="*[starts-with(local-name(), 'чеб')]">

 ...

</xsl:template>

то обрабатываться им будут все элементы, локальные части имен которых начинаются на "чеб" (например, "чебуреки", "Чебоксары", "чебурашка").

Следующее преобразование демонстрирует, как при помощи функции local-name и ключей сосчитать количество элементов и атрибутов документа с различными именами.

Листинг 11.4. Входящий документ

<foo bar="1">

 <bar foo="2"/>

 <bar bar="3"/>

 <foo foo="4">

  <bar bar="5"/>

  <bar foo="6"/>

 </foo>

</foo>

Листинг 11.5. Преобразование

<xsl:stylesheet

 version="1.0"

 xmlns:xsl="http://www.w3.org/1999/XSL/Transform">

 <!-- Выводим информацию в текстовом виде -->

 <xsl:output method="text"/>

 <!--

  | Создаем ключ, отображающий узлы атрибутов и элементов

  | в их локальные части имен.

  +-->

 <xsl:key name="node" match="*" use="local-name()"/>

 <xsl:key name="node" match="@*" use="local-name()"/>

 <xsl:template match="*|@*">

  <xsl:variable name="name" select="local-name()"/>

  <!--

   | Если узел является первым узлом группы (первым встретившимся

   | узлом документа с данным именем), выводим информацию о

   | количестве узлов в группе (количество узлов с таким же именем).

   +-->

  <xsl:if test="generate-id(.) = generate-id(key('node', $name))">

   <xsl:text>Node '</xsl:text>

   <xsl:value-of select="local-name()"/>

   <xsl:text>' found </xsl:text>

   <xsl:value-of select="count(key('node', $name))"/>

   <xsl:text> times. </xsl:text>

  </xsl:if>

  <!-- Рекурсивно обрабатываем дочерний элемент и атрибуты -->

  <xsl:apply-templates select="*|@*"/>

 </xsl:template>

</xsl:stylesheet>

Листинг 11.6. Выходящий документ

Node 'foo' found 5 times.

Node 'bar' found 7 times.

Именованный шаблон как функция

Сложно переоценить возможности механизмов расширений языка XSLT. Они позволяют сочетать простоту и гибкость обработки XML-документов при помощи элементов XSLT и выражений XPath. Практически любая функция, которая отсутствует в XSLT, может быть написана на подходящем языке программирования и подключена к процессору.

Но как уже отмечалось ранее, функции расширения ограничивают переносимость преобразований. Во-первых, функции расширения одного процессора совсем необязательно будут присутствовать в другом процессоре — скорее наоборот. Во-вторых, не приходится надеяться, что пользовательские модули, написанные на одном языке или с использованием одного интерфейса, смогут использоваться любым процессором. Поэтому часто перед разработчиком стоит проблема решить определенную задачу, используя только стандартные функции и элементы XSLT.

В этом разделе мы рассмотрим возможность использования именованных шаблонов в качестве функций, которые принимают на вход несколько параметров и возвращают некоторое вычисленное значение.

Использование именованных шаблонов как функций обуславливается следующими тезисами.

□ Именованный шаблон можно вызывать вне зависимости от того, какая часть документа обрабатывается в данный момент.

□ Именованному шаблону можно передавать параметры.

□ Результат выполнения именованного шаблона можно присваивать переменной.

Вызов именованного шаблона выполняется элементом xsl:call-template, в атрибуте name которого указывается имя вызываемого шаблона. Такой вызов не зависит от того, какая часть документа обрабатывается в данный момент и может производиться по необходимости.

Параметры именованному шаблону передаются точно так же, как и обычному — при помощи элементов xsl:with-param, которые могут быть включены в вызывающий элемент xsl:call-template. Примером вызова именованного шаблона с параметрами может быть конструкция вида

<xsl:call-template name="foo">

 <xsl:with-param name="x" select="1"/>

 <xsl:with-param name="y" select="2"/>

</xsl:call-template>

которая вызывает шаблон с именем foo и передает ему параметр x со значением, равным 1 и параметр y со значением, равным 2.

Вызов именованного шаблона может также производиться при инициализации переменной — внутри элемента xsl:variable. В этом случае с переменной связывается результирующий фрагмент дерева, возвращаемый именованным шаблоном.

Пример

В качестве примера приведем простой шаблон, который вычисляет квадрат переданного ему параметра x:

<xsl:template name="sqr">

 <xsl:param name="x"/>

 <xsl:value-of select="$x * $x"/>

</xsl:template>

Для того чтобы присвоить переменной у квадрат числа 6 мы можем записать следующее:

<xsl:variable name="y">

 <xsl:call-template name="sqr">

  <xsl:with-param name="x" select="6"/>

 </xsl:call-template>

</xsl:variable>

Обратим внимание, что значение переменной y будет иметь вовсе не численный тип. Несмотря на то, что элемент

<xsl:value-of select="$y"/>

выведет строку "36", переменная у содержит не число, а дерево, и 36 лишь является результатом конвертации в строку при выполнении xsl:value-of.

Для того чтобы присвоить переменной результат выполнения именованного шаблона в виде булевого значения, строки или числа, следует воспользоваться промежуточной переменной для явного преобразования типов.

Пример

После выполнения действий

<xsl:variable name="result">

 <xsl:call-template name="sqr">

  <xsl:with-param name="x" select="6"/>

 </xsl:call-template>

</xsl:variable>

<xsl:variable name="sqr-string" select="string($result)"/>

<xsl:variable name="sqr-number" select="number($result)"/>

переменные sqr-string и sqr-number будут содержать строковое и численное значение результата вычисления соответственно.

Немного сложнее обстоит дело с булевым типом. При приведении дерева к булевому типу результатом всегда будет "истина", поэтому такое преобразование необходимо выполнить в два шага: сначала преобразовать дерево в число, только затем число в булевый тип.

Пример

В следующем преобразовании шаблон с именем less-than сравнивает значения параметров x и y. Переменной less-than присваивается булевое значение результата сравнения.

Листинг 11.7. Вычисление булевого значения функции

<xsl:stylesheet

 version="1.0"

 xmlns:xsl="http://www.w3.org/1999/XSL/Transform">

 <xsl:template match="/">

  <xsl:variable name="result">

   <xsl:call-template name="less-than">

    <xsl:with-param name="x" select="2"/>

    <xsl:with-param name="y" select="1"/>

   </xsl:call-template>

  </xsl:variable>

  <xsl:variable name="less-than" select="boolean(number($result))"/>

  <xsl:value-of select="$less-than"/>

 </xsl:template>

 <xsl:template name="less-than">

  <xsl:param name="x"/>

  <xsl:param name="y"/>

  <xsl:value-of select="number($x < $y)"/>

 </xsl:template>

</xsl:stylesheet>

Пример

Простым примером шаблона-функции может быть шаблон, который форматирует дату в нужном виде, например 7 августа 93 года как "07-Aug-1993".

В качестве параметров этот шаблон будет принимать численные значения дня, месяца и года. Год, имеющий значение меньшее 25, мы будем считать принадлежащим новому тысячелетию.

Листинг 11.8. Шаблон, форматирующий дату

<xsl:template name="format-date">

 <xsl:param name="day"/>

 <xsl:param name="month"/>

 <xsl:param name="year"/>

 <xsl:value-of select="format-number($day, '00')"/>

 <xsl:text>-</xsl:text>

 <xsl:choose>

  <xsl:when test="$month = 1">Jan</xsl:when>

  <xsl:when test="$month = 2">Feb</xsl:when>

  <xsl:when test="$month = 3">Mar</xsl:when>

  <xsl:when test="$month = 4">Apr</xsl:when>

  <xsl:when test="$month = 5">May</xsl:when>

  <xsl:when test="$month = 6">Jun</xsl:when>

  <xsl:when test="$month = 7">Jul</xsl:when>

  <xsl:when test="$month = 8">Aug</xsl:when>

  <xsl:when-test="$month = 9">Sen</xsl:when>

  <xsl:when test="$month = 10">Oct</xsl:when>

  <xsl:when test="$month = 11">Nov</xsl:when>

  <xsl:when test="$month = 12">Dec</xsl:when>

 </xsl:choose>

 <xsl:text>-</xsl:text>

 <xsl:choose>

  <xsl:when test="$year <= 25">

   <xsl:value-of select="format-number($year +2000, '0000')"/>

  </xsl:when>

  <xsl:otherwise>

   <xsl:value-of select="format-number($year, '0000')"/>

  </xsl:otherwise>

 </xsl:choose>

</xsl:template>

Рекурсия

Отсутствие в XSLT изменяемых переменных (оценим красоту этой тавтологии) как, впрочем, и многое другое, делает этот язык совершенно непохожим на многие классические языки программирования. В этом разделе мы опишем рекурсию [Кормен и др. 2000, Кнут 2000] — чрезвычайно простую, но в то же время исключительно мощную технику, которая в большинстве случаев компенсирует нехватку в XSLT переменных и других процедурных конструкций.

Не вдаваясь в строгие определения дискретной математики, можно сказать, что рекурсия это всего лишь описание объекта или вычисления в терминах самого себя. Пожалуй, самым простым примером рекурсии является факториал, функция, которая математически определяется как:

0!=1

n!=n×(n-1)!

Программа на процедурном языке (например, таком, как Java), вычисляющая факториал совершенно тривиальна:

int factorial(int n) {

 if (n == 0) return 1;

 else return n * factorial(n-1);

}

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

Листинг 11.9. Именованный шаблон, вычисляющий факториал

<xsl:template name="factorial">

 <xsl:param name="n"/>

 <xsl:choose>

  <xsl:when test="$n=0">1</xsl:when>

  <xsl:otherwise>

   <xsl:variable name="n-1">

    <xsl:call-template name="factorial">

     <xsl:with-param name="n" select="$n-1"/>

    </xsl:call-template>

   </xsl:variable>

   <xsl:value-of select="$n * number($n-1)"/>

  </xsl:otherwise>

 </xsl:choose>

</xsl:template>

Вызвав этот шаблон с параметром n равным 6 следующим образом:

<xsl:call-template name="factorial">

 <xsl:with-param name="n" select="number(6)"/>

</xsl:call-template>

мы получим текстовый узел, значение которого будет равно "720".

Очевидным требованием к рекурсивным функциям является возможность выхода из рекурсии. Если бы в определении факториала не было указано, что 0!=1, вычисления так бы и продолжались без конца.

Главным минусом рекурсии является требовательность к ресурсам. Каждый раз, при вызове именованного шаблона, процессор должен будет каким-то образом сохранять в памяти передаваемые ему формальные параметры. Например, если мы попробуем сосчитать факториал от 170, процессору понадобится держать в памяти сразу 170 чисел. Безусловно, в случае с факториалом это не является большой проблемой — точность 64-битных чисел исчерпается гораздо раньше, чем закончится память, но в случае хранения в переменных действительно больших объемов информации (например, частей деревьев) такая угроза существует. Кроме того, рекурсивные решения, как правило, работают медленнее, чем решения, не использующие рекурсию.

Так в чем же смысл использования рекурсии? Дело в том, что вследствие определенных ограничений (связанных, в частности с неизменяемыми переменными) в XSLT существуют задачи, которые не могут быть реализованы иначе кроме как через рекурсию. Самым характерным примером такой задачи являются циклы.

Циклы

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

Весомым ограничением такого рода циклической обработки является невозможность генерировать множества узлов. В текущей версии языка никакой другой тип не может быть приведен ко множеству узлов, значит, в любое из них могут входить только те узлы, которые изначально присутствуют в одном из обрабатываемых документов. Это означает, что ни xsl:apply-templates, ни xsl:for-each не могут быть использованы для того, чтобы реализовать простые while- или for-циклы для произвольных множеств.

Цикл while

Наиболее примитивной циклической конструкцией во многих языках программирования является цикл while (англ. пока). Цикл while, как правило, имеет следующий вид:

пока

 верно условие

выполнять

 действия

В качестве примера while-цикла напишем на языке Java программу вычисления факториала в итеративном стиле:

int factorial(int n) {

 int i = n;

 int result = 1;

 while (i != 0) {

  result = result * i;

  i--;

 }

 return result;

}

В этой функции условием является отличие значения переменной i от 0, а действиями — умножение значения переменной result на значение переменной i, и уменьшение значения этой переменной на 1.

Цикл while не может быть запрограммирован в XSLT итеративно потому как действия, как правило, изменяют значения переменных, в контексте которых вычисляется условие, определяющее, продолжать выполнение цикла или нет. Дадим другую общую запись цикла while, выделив изменение переменных:

пока

 верно условие(x1,x2, ...,xn)

выполнить

 x1' := функция1(x1,x2,...,xn)

 х2' := функция2(x1,x2,...,xn)

 ...

 xn' := функцияn(x1,x2,...,xn)

 действия(x1,x2,...,хn)

 x1 := x1'

 x2 := x2'

 ...

 xn := xn'

иначе

 вернуть результат(x1,...,хn)

Переопределение значений переменных x₁, … , х_n в этом случае выполняют n функций: функция₁ …, функция_n. И если изменить значение переменной мы не могли, переопределить связанное с ней значение мы вполне в состоянии, добавив в контекст новый параметр или переменную с тем же именем.

Теперь мы можем записать весь цикл while как одну рекурсию:

while(x1, ..., xn) ::=

 если

  выполняется условие(x1, ..., xn)

 то

  действия(x1, ..., хn)

  while(функция1(x1, ..., хn),

   функция2(x1, ..., хn),

   ...,

   функцияn(x1, ..., xn))

 иначе

  результат(x1, ..., хn)

Теперь уже совершенно очевидно, как while-цикл должен выглядеть в преобразовании.

Листинг 11.10. Шаблон цикла while в общем виде

<xsl:template name="while">

 <xsl:param name="x1"/>

 <!-- ... -->

 <xsl:param name="xn"/>

 <xsl:choose>

  <xsl:when test="условие($x1,...,$xn)">

   <!-- Действия -->

   <xsl:call-template name="while">

    <xsl:with-param name="x1" select="функция_1($x1, ... $xn) "/>

    <!-- ... -->

    <xsl:with-param name="xn" select="функция_n($x1, ... $xn) "/>

   </xsl:call-template>

  </xsl:when>

  <xsl:otherwise>

   <xsl:value-of select="результат($x1, ..., $xn)"/>

  </xsl:otherwise>

 </xsl:choose>

</xsl:template>

В качестве примера приведем while-цикл для программы, вычисляющей факториал. Java-код был следующим:

while (i != 0) {

 result = result * i;

 i--;

}

В этом цикле участвуют две переменные — i и result. Функции, использующиеся в этом цикле, запишутся следующим образом:

условие($1, $result)      ::= ($i != 0)

функцияi($i, $result)     ::= ($i - 1)

функцияresult($i, $result) ::= ($i * $result)

результат($I, $result)    ::= ($result)

Именованный шаблон для этого случая будет иметь вид.

Листинг 11.11. Пример шаблона цикла while

<xsl:template name="while">

 <xsl:param name="i"/>

 <xsl:param name="result"/>

 <xsl:choose>

  <xsl:when test="$i != 0">

   <xsl:call-template name="while">

    <xsl:with-param name="i" select="$i — 1"/>

    <xsl:with-param name="result" select="$result * $i"/>

   </xsl:call-template>

  </xsl:when>

  <xsl:otherwise>

   <xsl:value-of select="$result"/>

  </xsl:otherwise>

 </xsl:choose>

</xsl:template>

Вызвать этот шаблон можно следующим образом:

<xsl:template match="/">

 <xsl:call-template name="while">

  <xsl:with-param name="i" select="6"/>

  <xsl:with-param name="result" select="1"/>

 </xsl:call-template>

</xsl:template>

Результатом будет, естественно, число 720.

Цикл for

Частным случаем цикла while является цикл for. В разных языках программирования for имеет различную семантику; мы будем рассматривать циклы for вида

for (int i = 0; i < n; i++) { ... }

в языках Java и С или

for i := 0 to n-1 do begin ... end;

в Pascal. Иными словами, нас будет интересовать циклическое выполнение определенных действий при изменении значения некоторой переменной (называемой иногда индексом цикла) в интервале целых чисел от 0 до n включительно.

Цикл for может быть определен через while с использованием следующих условных и изменяющих функций:

условие($i, $n,$x1,...,$хk)      :: = ($i < $n)

функцияi($i, $n, $x1, ... , $xk) ::= ($i + 1)

функцияn($i, $n, $x1, ..., $xk)  :: = ($n)

Шаблон цикла for в общем виде будет выглядеть как.

Листинг 11.12. Шаблон цикла for в общем виде

<xsl:template name="for">

 <xsl:param name="i" select="0"/>

 <xsl:param name="n"/>

 <!-- Другие переменные -->

 <xsl:param name="x1"/>

 <!-- ... -->

 <xsl:param name="xk"/>

 <xsl:choose>

  <xsl:when test="$i < $n">

   <!-- Действия -->

   <xsl:call-template name="for">

    <xsl:with-param name="i" select="$i + 1"/>

    <xsl:with-param name="n" select="$n"/>

    <!-- Другие переменные -->

    <xsl:with-param" name="x1" select функция1($i, $n, $x1, ..., $xk) "/>

    <!-- ... -->

    <xsl:with-param name="xk" select="функцияk($i, $n, $x1, ..., $xk)"/>

   </xsl:call-template>

  </xsl:when>

  <xsl:otherwise>

   <xsl:value-of select="результат($i,$n,$x1,...,$xk)"/>

  </xsl:otherwise>

 </xsl:choose>

</xsl:template>

В качестве примера цикла for приведем шаблон, вычисляющий n первых чисел Фибоначчи.

Числа Фибоначчи — это рекуррентная последовательность вида

1 1 2 3 5 8 13 21 ...

и так далее, где каждое последующее число определяется как сумма двух предыдущих.

Для вычисления n первых чисел Фибоначчи мы можем использовать две переменные current и last, соответствующих текущему число и числу, полученному на предыдущем шаге соответственно. Функции, переопределяющие эти переменные, совершенно очевидны:

функцияlast($i, $n, $last, $current)   ::= ($current)

функцияcurrent($i, $n, $last, $current) ::= ($current + $last)

Поскольку в данном случае нам не нужно возвращать результат, нужно лишь циклически выводить очередное число Фибоначчи, шаблон for может быть немного упрощен использованием элемента xsl:if вместо xsl:choose.

Листинг 11.13. Шаблон, вычисляющий числа Фибоначчи

<xsl:template name="for">

 <xsl:param name="i" select="0"/>

 <xsl:param name="n"/>

 <xsl:param name="last" select="0"/>

 <xsl:param name="current" select="1"/>

 <xsl:if test="$i < $n">

  <xsl:text> </xsl:text>

  <xsl:value-of select="$current"/>

  <xsl:call-template name="for">

   <xsl:with-param name="i" select="$i + 1"/>

   <xsl:with-param name="n" select="$n"/>

   <xsl:with-param name="last" select="$current"/>

   <xsl:with-param name="current" select="$last + $current"/>

  </xsl:call-template>

 </xsl:if>

/xsl:template>

Вызванный в основном шаблоне как:

<xsl:template match="/">

 <xsl:call-template name="for">

  <xsl:with-param name="n" select="6"/>

 </xsl:call-template>

</xsl:template>

этот шаблон создаст в выходящем документе последовательность:

1 1 2 3 5 8

Приведем еще более простой пример, в котором элемент option выводится заданное число раз.

Листинг 11.14. Вывод 10 элементов option

<xsl:stylesheet

 version="1.0"

 xmlns:xsl="http://www.w3.org/1999/XSL/Transform'">

 <xsl:template match="/">

  <xsl:call-template name="for">

   <xsl:with-param name="n" select="10"/>

  </xsl:call-template>

 </xsl:template>

 <xsl:template name="for">

  <xsl:param name="i" select="0"/>

  <xsl:param name="n"/>

  <xsl:if test="$i < $n">

   <option>

    <xsl:value-of select="$i"/>

   </option>

   <xsl:call-template name="for">

    <xsl:with-param name="i" select="$i + 1"/>

    <xsl:with-param name="n" select="$n"/>

   </xsl:call-template>

  </xsl:if>

 </xsl:template>

</xsl:stylesheet>

Листинг 11.15 Выходящий документ

<option>0</option>

<option>1</option>

<option>2</option>

<option>3</option>

<option>4</option>

<option>5</option>

<option>6</option>

<option>7</option>

<option>8</option>

<option>9</option>

Пожалуй, этим примером мы и закончим рассмотрение рекурсии. Осталось лишь добавить, что при всей своей простоте и вычислительной мощи, рекурсия является гораздо более требовательной к ресурсам техникой программирования, чем обычная итеративная обработка. Поэтому всегда следует тщательно оценивать, во что может вылиться использование рекурсии. В любом случае следует избегать глубоких рекурсий (функций, количество рекурсивных вызовов в которых может быть большим) и рекурсий, неэкономно использующих память.

Кроме того, большинство действий, выполнение которых в XSLT затруднено, в классических языках программирования выполняется, как правило, намного легче и эффективней. Поэтому, каждый раз, когда стоит вопрос об использовании рекурсии, наряду с ней следует рассматривать такую альтернативу, как использование расширений XSLT, написанных на обычном императивном языке.

Метод Пиза для for-цикла

Для простых for-циклов, которые должны выполниться строго определенное число раз, вместо рекурсии можно использовать весьма остроумный метод, предложенный Венделлом Пизом (Wendell Piez, Mullberry Technologies, Inc). Суть метода состоит в том, что хоть мы и не можем сгенерировать множество узлов, выбрать множество с определенным количеством узлов нам вполне по силам.

Для начала выберем какое-нибудь множество узлов документа преобразования:

<xsl:variable name="set" select="document('')//node()"/>

Затем для повторения определенных действий несколько раз используем конструкцию вида

<xsl:for-each select="$set[position() <= $number]">

 <!-- Действия -->

</xsl:for-each>

где number указывает требуемое число итераций.

При использовании метода Пиза следует учитывать следующие особенности.

□ Множество узлов set не должно быть слишком большим — иначе его выбор будет неэффективным.

□ Множество узлов set обязательно должно содержать число итераций (number) узлов.

В целом же метод Пиза — классический пример эффективного применения инструментов не по назначению.

Операции над множествами

Рассматривая такой тип данных, как множества узлов, мы отмечали ограниченность операций, которые можно с ними производить. В частности, XSLT не предоставляет стандартных операторов для определения принадлежности одного множества другому, нахождения пересечений, разности множеств и так далее. Возможности, которые были представлены при описании этого типа данных, основанные на использовании оператора равенства, на самом деле реализуют далеко не математические операции над множествами.

В этом разделе мы рассмотрим иной подход к реализации операций над множествами, основанный на очень простом определении принадлежности узла множеству. Узел node принадлежит множеству nodeset тогда и только тогда, когда выполняется равенство

count($nodeset) = count($node | $nodeset)

Учитывая это обстоятельство, операции над множествами можно представить, как показано в табл. 11.1. Результирующее множество выделено штриховкой.

Таблица 11.1. Операции над множествами

Операция	Графическое представление	XPath-выражение
Объединение		$A | $B
Пересечение		$А[count(.|$B)=count($B)]
Разность		$A[count(.|$B)!=count($B)]
Симметрическая разность		$A[count(.|$B)!=count($B)] | $B[count(.|$A)!=count($A)]

Приведенные выше методы были разработаны Майклом Кеем (Michael Kay, Software AG), Оливером Беккером (Oliver Becker, Humboldt-Universitat zu Berlin), Кеном Холманом (Ken Holman, Crane Softwrights Ltd.) и публикуются с любезного разрешения авторов.

class='book'> Перенос строк и элементы BR Большинству читателей, скорее всего, хорошо знаком такой элемент языка HTML, как BR, который используется для обозначения разрыва строки. В обычных текстовых файлах для той же самой цели используются символы с кодами #xA, #xD или их комбинации в зависимости от платформы. При совместном использовании неразмеченного текста и HTML часто возникает задача преобразования символов перевода строки в элементы BR и наоборот.

Замену элемента BR на текстовый узел, содержащий перевод строки, можно проиллюстрировать следующим тривиальным шаблоном.

Листинг 11.16. Шаблон замены элементов BR на перенос строки

<xsl:template match="BR">

 <xsl:text> </xsl:text>

</xsl:template>

Гораздо сложнее написать шаблон, делающий обратную операцию, — замену символов переноса строки на элементы BR. В XSLT нет встроенного механизма для замены подстроки в строке (тем более на элемент), поэтому нам придется создать для этой цели собственный шаблон.

Для этой цели мы можем воспользоваться функциями substring-before и substring-after. Функция substring-before($str, $search-for) возвратит часть строки str, которая предшествует первому вхождению в нее подстроки search-for, а функция substring-after($str, $search-for) — последующую часть. То есть заменить первое вхождение можно шаблоном вида

<!-- ... -->

<xsl:value-of select = "substring-before($str, $search-for)"/>

<xsl:copy-of select = "$replace-with"/>

<xsl:value-of select = "substring-after($str, $search-for)"/>

<!-- ... -->

Для того же, чтобы заменить все вхождения, достаточно рекурсивно повторить операцию замены первого вхождения с той частью строки, которая следует за ним. Приведем шаблон, который выполняет эту операцию.

Листинг 11.17. Шаблон для замены подстроки в строке

<xsl:template name="replace" match="text()" mode="replace">

 <xsl:param name="str" select="."/>

 <xsl:param name="search-for" select="' '"/>

 <xsl:param name="replace-with">

  <xsl:element name="BR"/>

  <xsl:text> </xsl:text>

 </xsl:param>

 <xsl:choose>

  <xsl:when test="contains($str, $search-for)">

   <xsl:value-of select="substring-before($str, $search-for)"/>

   <xsl:copy-of select="$replace-with"/>

   <xsl:call-template name="replace">

    <xsl:with-param name="str"

     select="substring-after($str, $search-for)"/>

    <xsl:with-param name="search-for" select="$search-for"/>

    <xsl:with-param name="replace-with " select="$replace-with"/>

   </xsl:call-template>

  </xsl:when>

  <xsl:otherwise>

   <xsl:value-of select="$str"/>

  </xsl:otherwise>

 </xsl:choose>

</xsl:template>

Шаблон, приведенный в этом листинге, может быть вызван двумя способами: элементом xsl:apply-templates в режиме replace (в этом случае он будет обрабатывать текстовые узлы выбранного множества), или при помощи именного вызова элементом xsl:call-template. Шаблон принимает на вход три параметра.

□ Параметр str, содержащий строку, в которой нужно произвести замену. По умолчанию этому параметру присваивается текстовое значение текущего узла.

□ Параметр search-for, содержащий подстроку, которую требуется найти и заменить в строке str. По умолчанию замене будут подлежать символы переноса строки, "&#хА;".

□ Параметр replace-with, содержащий объект, на который следует заменять подстроки search-for. По умолчанию эти подстроки будут заменяться на элемент BR и следующий за ним перенос строки, добавленный для лучшей читаемости.

В качестве примера отформатируем содержание следующего элемента:

<pre>One little rabbit

Two little rabbits

Three little rabbits</pre>

Запишем шаблон для обработки элемента pre:

<xsl:template match="pre">

 <xsl:copy>

  <xsl:apply-templates mode="replace"/>

 </xsl:copy>

</xsl:template>

Результат его выполнения будет иметь следующий вид:

<pre>One little rabbit<BR/>

Two little rabbits<BR/>

Three little rabbits</pre>

Данные, разделенные запятыми (CSV)

Рекурсивную методику замены, которую мы представили выше, можно использовать для того, чтобы разметить данные, разделенные запятыми (или CSV, comma-separated values). CSV — это старый простой формат представления данных, в котором они просто перечисляются через запятую, например:

a, b, с, d, e, f, g

и так далее. Формат CSV был одним из первых шагов к созданию языков разметки: данные в нем уже размечались запятыми.

Покажем на простом примере, как можно преобразовать CSV-данные в XML-документ. Пусть входящий документ выглядит как:

<data>a, b, с, d, e, f</data>

Для того чтобы решение было как можно более общим, вынесем создание XML-разметки для каждого из элементов этой последовательности в отдельный шаблон:

<xsl:template name="item">

 <xsl:param name="item"/>

 <item><xsl:copy-of select="$item"/></item>

</xsl:template>

Тогда головной размечающий шаблон запишется в виде.

Листинг 11.18. Шаблон, размечающий данные в строковом формате

<xsl:template name="markup" match="text()" mode="CSV">

 <xsl:param name="str" select="."/>

 <xsl:param name="delimiter" select="','"/>

 <xsl:choose>

  <xsl:when test="contains($str,$delimiter)">

   <xsl:call-template name="item">

    <xsl:with-param name="item"

     select="substring-before($str, $delimiter)"/>

   </xsl:call-template>

   <xsl:call-template name="markup">

    <xsl:with-param name="str"

     select="substring-after($str, $delimiter)"/>

   </xsl:call-template>

   <xsl:with-param name="delimiter" select="$delimiter"/>

  </xsl:when>

  <xsl:otherwise>

   <xsl:call-template name="item">

    <xsl:with-param name="item" select="$str"/>

   </xsl:call-template>

  </xsl:otherwise>

 </xsl:choose>

</xsl:template>

На вход шаблон markup принимает два параметра — str, строка, которую нужно разметить (по умолчанию — значение текущего узла) и delimiter — строка, разделяющая отдельные значения в str (по умолчанию — запятая ",").

Шаблон, форматирующий содержимое элемента data, будет в таком случае выглядеть следующим образом:

<xsl:template match="data">

 <xsl:copy>

  <xsl:apply-templates mode="CSV"/>

 </xsl:copy>

</xsl:template>

Результат этого преобразования будет иметь следующий вид:

<data>

 <item>a</item>

 <item> b</item>

 <item> c</item>

 <item> d</item>

 <item> e</item>

 <item> f</item>

</data>

Обратим внимание на то, что в элементах item присутствуют лишние пробелы, которые в начальной последовательности шли за запятыми. Избавиться от них можно, указав в качестве разделяющей строки символ ", ":

<xsl:template match="data">

 <xsl:copy>

  <xsl:apply-templates mode="CSV">

   <xsl:with-param name="delimiter" select="', '"/>

  </xsl:apply-templates>

 </xsl:copy>

</xsl:template>

Результатом, как и следовало ожидать, будет:

<data>

 <item>a</item>

 <item>b</item>

 <item>c</item>

 <item>d</item>

 <item>e</item>

 <item>f</item>

</data>

Кстати сказать, того же эффекта можно было добиться, изменив шаблон item, который отвечает за XML-представление каждого из элементов последовательности.

Глава 12 Развитие технологий

Как известно, успех технологии зависит не только от того, насколько продумана и проработана она была. Ее широкое распространение невозможно без поддержки и заинтересованности ведущих производителей программного обеспечения. В этом смысле XSLT очень повезло: имплементациями языка с самых ранних черновых вариантов занимались такие крупные разработчики, как Microsoft, Oracle, IBM, Adobe, Lotus и многие другие. Поддержка Apache XML Project помогла XSLT завоевать популярность и среди open-source сообщества (open-source — разработки с "открытым" исходным кодом).

Так или иначе, сейчас следует лишь констатировать стабильный рост популярности XSLT. Количество XSLT-процессоров уже исчисляется десятками, а число разработчиков — пожалуй, что и тысячами.

Повышенный интерес помог в чрезвычайно короткий срок (менее года) изучить на практике недостатки и достоинства нового языка и приступить к разработке последующих версий, которые бы учитывали эти практические результаты. В декабре 2000 года была выпущена версия 1.1,. в которой было не только исправлено большинство основных проблем первой версии XSLT, но и включены очень важные дополнения — такие, например, как определение интерфейсов расширений для языков Java и JavaScript/ECMAScript. В августе 2001 года версии 1.1 дали статус Final Draft и положили на полку — она никогда не будет стандартом (технической рекомендацией Консорциума W3).

Нужно сказать, что по количеству доработок и дополнений версия XSLT 1.1 могла вполне претендовать на роль нового стандарта XSLT. Однако, в такой напряженной области информационных технологий, как XML, приходится считаться с другими разработками, ибо все они взаимосвязаны. На решение прекратить продвижение XSLT 1.1 и перейти к 2.0 во многом повлияли такие проекты, как XML Schema и XQuery.

XML Schema — это долгожданный XML-язык, описывающий структуру XML-документа, своего рода более мощный вариант DTD. XML Schema, в частности, позволяет описывать простые и сложные типы данных элементов и атрибутов, ограничивать количества повторений, определять в XML-документах первичные и внешние ключи и многое другое. Помимо этого, XML Schema определяется в XML-синтаксисе, что позволяет использовать для обработки схем стандартные XML-инструменты. Спецификация XML Schema получила статус технической рекомендации Консорциума W3 в мае 2001 года.

XQuery — это текущий проект W3C по созданию языка запросов для XML-документов. В основу XQuery легло множество предыдущих исследований в области языков запросов для полуструктурированных данных — пожалуй, стоит упомянуть такие, как Quilt, XML-QL и Lorel. Почти все старые языки запросов для XML были университетскими исследовательскими проектами; в XQuery же заинтересованы такие гиганты, как Microsoft и Software AG.

Следует пояснить, каким образом XML Schema и XQuery влияют на XSLT — казалось бы, их области применения несколько различаются. Напомним, что весомая часть функциональности XSLT зависит от языка XPath, который используется также и в XPointer. Как оказалось, XPath важен не только для XSLT и XPointer, но и для XQuery. Модель XML-документа, описанная в первой версии XPath, оказалась мощной, легко реализуемой и понятной абстракцией физической сущности XML и поэтому ее было решено использовать также и в XQuery. В следующей своей инкарнации эта модель будет выделена в отдельную спецификацию — "XQuery 1.0 and XPath 2.0 Data Model" ("Модель данных XQuery 1.0 и XPath 2.0"). Функции и операторы также будут выделены в отдельный документ — "XQuery 1.0 and XPath 2.0 Functions and Operators Version 1.0" ("Операторы и функции в XQuery 1.0 и XPath 2.0, версия 1.0").

Принятие XML Schema также оказывает определенное влияние на XPath. В схемах ХМL-документов можно определять типы данных атрибутов и элементов. Соответственно, семантика XPath выражений должна отражать эту метаинформацию: например, оператор сложения "+" будет вести себя по-разному на строковых и числовых операндах.

Пример

Рассмотрим выражение int/x + int/y на простейшем документе:

<int>

 <x>2</x>

 <y>2</y>

</int>

В первой версии XPath результатом вычисления int/x + int/у в любом случае будет 4. Между тем, старшие версии могут учитывать метаинформацию о типе обрабатываемых данных и возвращать 4 в случае числовых операндов и "22" в случае строковых.

На момент написания этих строк работа над XSLT 2.0 и XPath 2.0 идет полным ходом. Конечно, пока еще рано заглядывать вперед и раскрывать секреты рабочей группы XSL, однако, основываясь на опубликованных спецификациях XLST 1.1 и требованиях к версии XSLT 2.0, кое-какие выводы сделать все же можно.

Отличия XSLT 1.1 от XSLT 1.0

Отсутствие result tree fragment

Главное и наиболее существенное отличие XSLT 1.1 от XSLT 1.0 состоит в том, что тип данных, известный в XSLT 1.0 как result tree fragment (результирующий фрагмент дерева) в XSLT 1.1. отсутствует. Вместо него в версии 1.1 используется множество узлов, состоящее из единственного корневого узла результирующего фрагмента.

На первый взгляд, разница между двумя этими методами представления фрагментов деревьев минимальна. Но если принять во внимание положения языка XPath о том, что ни один тип данных не может быть преобразован во множество узлов, разница эта оказывается огромной. Получается, что, несмотря на то, что результирующий фрагмент и множество, состоящее из его корня, представляют одни и те же данные и структуры, с фрагментом нельзя делать многое из того, что можно делать с множеством узлов.

Пример

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

<xsl:variable name="colors">

 <color>#0E0E0E</color>

 <color>#FFFFFF</color>

</xsl:variable>

создает в переменной colors результирующий фрагмент дерева. В соответствии со спецификацией XPath 1.0 выражение $colors/color[1] будет некорректным, поскольку типом colors является результирующий фрагмент дерева, который не может быть напрямую преобразован во множество узлов. Иными словами, совершенно логичное и оправданное выражение не является корректным. Конечно, существуют способы обойти этот запрет — с помощью расширений и тому подобного, но нельзя не согласиться с тем, что результирующие фрагменты являются самой большой занозой в XSLT 1.0.

XSLT 1.1 исправляет этот просчет. Переменная colors, определенная выше, будет иметь своим значение не фрагмент дерева, а множество из одного, корневого, узла этого фрагмента и ее можно использовать везде, где только можно использовать тип данных node-set.

Несколько выходящих документов

Как известно, преобразование в XSLT 1.0 имеет один основной входящий документ (плюс документы, доступные при помощи функции document) и ровно один выходящий документ. То есть, для того, чтобы сгенерировать на основе одного входящего документа несколько выходящих следует просто выполнить несколько преобразований.

Следуя многочисленным запросам программистов, почти все разработчики XSLT-процессоров предоставили в своих продуктах возможность генерировать несколько выходящих документов непосредственно из одного преобразования. Элемент xsl:document, добавленный в XSLT 1.1, сделал эту возможность стандартной.

Пример

Самым простым применением xsl:document является разбиение одного документа на несколько. Например, имея документ вида

<book>

 <chapter>Text 1</chapter>

 <chapter>Text 2</chapter>

 <chapter>Text 3</chapter>

</book>

мы можем выделить элементы chapter в отдельные файлы, а в самом выходящем документе создать оглавление со ссылками.

Листинг 12.1. Преобразование, использующее элемент xsl:document

<xsl:stylesheet

 version="1.1"

 xmlns:xsl="http://www.w3.org/1999/XSL/Transform">

 <xsl:template match="book">

  <xsl:copy>

   <xsl:apply-templates select="chapter"/>

  </xsl:copy>

 </xsl:template>

 <xsl:template match="chapter">

  <chapter href="chapter{position()}.xml"/>

  <xsl:document href="chapter{position()}.xml">

   <xsl:copy-of select="."/>

  </xsl:document>

 </xsl:template>

</xsl:stylesheet>

Результатом этого преобразования будут следующие четыре документа.

Листинг 12.2. Главный выходящий документ преобразования

<book>

 <chapter href="chapter1.xml"/>

 <chapter href="chapter2.xml"/>

 <chapter href="chapter3.xml"/>

</book>

Листинг 12.3. Документ chapter1.xml

<chapter>Text 1</chapter>

Листинг 12.4. Документ chapter2.xml

<chapter>Text 2</chapter>

Листинг 12.5. Документ chapter3.xml

<chapter>Text 3</chapter>

Дополнительные возможности по расширению

В XSLT 1.1 был введен элемент xsl:script, предоставляющий дополнительные возможности для создания и использования функций расширения. При помощи xsl:script функции расширения могут быть явным образом определены в самом преобразовании.

Пример

В процессоре, который поддерживает скриптовые языки типа JavaScript, исходный код функций расширения может включаться в само преобразование, например.

Листинг 12.6. Преобразование, включающее функцию расширения

<xsl:stylesheet

 version="1.1"

 xmlns:xsl="http://www.w3.org/1999/XSL/Transform"

 xmlns:js="javascript:code">

 <xsl:script language="javascript" implements-prefix="js">

  function iff(arg1, arg2, arg3) {

   if (arg1) {

    return arg2;

   } else {

    return arg3;

   }

  }

 </xsl:script>

 ...

</xsl:stylesheet>

Атрибут implements-prefix (англ. implements prefix — реализует префикс) связывает определяемую функцию с некоторым пространством имен (как мы отмечали ранее, все функции расширения должны принадлежать ненулевым пространствам имен). При вызове функций из этого пространства имен в XPath-выражениях, процессор будет искать их определения в элементах xsl:script, которые реализуют соответствующий префикс.

Атрибут language определяет язык программирования, в котором написано расширение. Очевидно, язык влияет на то, как будет выполняться расширение — например, должен ли процессор интерпретировать содержимое xsl:script или следует загрузить внешний Java-класс. Естественно, не следует ожидать, что любой процессор сможет выполнять расширения, написанные на произвольных языках программирования — как правило, разработчики XSLT-средств в документации к своим продуктам оговаривают, какие языки расширения они поддерживают. Как следствие, преобразование, использующее расширения, написанные на "непонятном" процессору языке, либо не будут выполнены вообще, либо будут выполнены некорректно.

Помимо двух обязательных атрибутов implements-prefix и language, в элемент xsl:script могут быть включены атрибуты src и archive, которые указывают физическое местоположение кода расширения.

"Внешние" типы данных

Четыре основных типа данных языка XPath (булевый, численный, строковый типы и множества узлов) в первой версии XSLT были расширены типом результирующего фрагмента дерева. В некотором смысле, фрагменты деревьев были "внешним" типом по отношению к XPath, но, тем не менее, многие из функций базовой библиотеки с успехом с этим типом работали.

В XSLT 1.1 была впервые представлена поддержка произвольных внешних типов данных. Функции расширения могут возвращать и оперировать любыми типами данных. Например, в XSLT-процессорах, написанных на Java, в случае использования расширений в качестве значений часто используются произвольные классы.

Пример

Форматирование текущей даты и времени, которое было продемонстрировано в главе 10 элементом ext:date, может быть переписано при помощи функций расширения следующим образом.

Листинг 12.7. Использование внешних типов данных в преобразовании

<xsl:stylesheet

 version="1.1"

 xmlns:xsl="http://www.w3.org/1999/XSL/Transform"

 xmlns:Date="java:java.util.Date"

 xmlns:SimpleDateFormat="java.text.SimpleDateFormat">

 <xsl:variable name="df" select="SimpleDateFormat:new('HH:mm')"/>

 <xsl:variable name="now" select="Date:new()"/>

 <xsl:template match="/">

  <xsl:value-of select="SimpleDateFormat:format($df, $now)"/>

 </xsl:template>

</xsl:stylesheet>

Пространства имен с префиксами Date и SimpleDateFormat определяют привязку к Java-классам java.util.Date и java.text.SimpleDateFormat соответственно (в этом примере мы используем формат URI пространств имен, принятый в процессоре Saxon).

Объявление

<xsl:variable name="df" select="SimpleDateFormat:new('HH:mm')"/>

присваивает переменной df результат выполнения конструктора класса SimpleDateFormat со строковым параметром "HH:mm", что эквивалентно Java-коду

SimpleDateFormat df = new SimpleDateFormat("НН:mm");

Иными словами, переменной df был присвоен "внешний" тип данных java.text.SimpleDateFormat. Аналогично, переменная now содержит данные типа java.util.Date. Фактически, этим переменным были присвоены экземпляры соответствующих классов.

Выражение SimpleDateFormat:format($df, $now), использованное в этом преобразовании, представляет собой ни что иное, как применение метода format экземпляра класса SimpleDateFormat, присвоенного переменной df к экземпляру класса Date, присвоенного переменной now. В переводе на Java:

df.format(now);

Надо сказать, что оперирование внешними типами — отнюдь не нововведение XSLT 1.1. Во многих процессорах интерфейсы расширения позволяют функциям возвращать произвольные типы данных. Важно, что теперь эта возможность закреплена в официальном документе Консорциума W3, и следует полагать, что и из второй версии языка она никуда не денется.

Стандартные интерфейсы расширений

Важным дополнением в XSLT 1.1 по сравнению с первой версией языка является определение стандартных интерфейсов расширения для языков IDL, JavaScript/ECMAScript и Java на основе интерфейсов DOM2.

Одна из проблем, с которыми всегда приходится сталкиваться при работе с расширениями, является проблема переносимости. Вследствие того, что интерфейсы привязки к конкретным языкам программирования отдали в первой версии на усмотрение разработчиков процессоров, несовместимость интерфейсов не позволяет гарантировать работоспособность расширений при переходе с одного процессора на другой (даже если речь идет о процессорах одного типа, например, написанных на языке Java процессорах Saxon, Xalan и Oracle XSLT Processor).

Ситуация, действительно, довольно досадная. С одной стороны, и XSLT, и Java являются переносимыми языками, с другой стороны, их сочетание в случае использования расширений оказывается непереносимым даже на Java-платформах. Стандартные интерфейсы, выработанные в XSLT 1.1, по всей вероятности, намного упростят положение вещей — ведь если написанное единожды Java-расширение будет работать на всех Java-платформах, этого уже будет достаточно, для того чтобы смело использовать всю мощь расширений.

Другие изменения

Помимо приведенных выше отличий версии 1.1 от первой версии языка, новый вариант включает в себя также некоторые другие добавления и исправления:

□ добавлена расширенная поддержка пространств имен при преобразовании;

□ добавлена поддержка XML Base;

□ добавлена возможность использования параметров при вызове шаблонов элементом xsl:apply-imports;

□ расширено множество атрибутов элементов XSLT, которые могут содержать шаблоны значений атрибутов;

□ добавлено определение лексикографического порядка (наподобие 'а' < 'b' → true);

□ добавлено сравнение строк без учета регистра символов;

□ добавлены операторы для проверки порядка следования узлов в документе;

□ исправлены обнаруженные ошибки.

Отличия XSLT 2.0 от XSLT 1.1

Прежде чем приступить к описанию отличий второй версии XSLT от версии 1.1 (и, соответственно, 1.0), следует сделать одно существенное замечание. Лицензионные соглашения Консорциума W3 не позволяют раскрывать широкой общественности внутренние материалы рабочих групп W3C до того, как они будут официально опубликованы. Потому, строго говоря, все, что будет ниже сказано о версии 2.0 — это не более чем совокупность гипотез, пожеланий и выводов, сделанных на основе спецификации XSLT 1.1 и требований к XSLT 2.0 и XPath 2.0. Эти документы доступны публично.

Изменения в XPath 2.0

Разрабатываемая версия языка XPath, вследствие интеграции с XQuery, очевидно, претерпит серьезные изменения. Новая спецификация уже сейчас разбита на два документа: документ, описывающий модель данных и документ, описывающий функции и операторы. Поэтому на данный момент сложно делать точный прогноз относительно того, что же получится в итоге. Мы ограничимся перечислением основных требований:

□ поддержка группы XML-стандартов: определение модели в терминах XML Information Set, выделение общего синтаксиса и семантики с XQuery 1.0;

□ переопределение операторов сравнения на множествах;

□ определение операторов пересечения и разности множеств;

□ расширение множества агрегатных функций (наподобие sum, count, min, max — функций, работающих на множествах);

□ возможность использования выражений, возвращающих множества узлов в качестве шагов выборки, например /a/(b|c)/d вместо /а/b/d | /a/c/d;

□ введение оператора аналогичного оператору ? в Java и С (выражение a ? b : с, где а имеет булевый тип, возвращает b, если a — "истина" и с, если a — "ложь");

□ дополнительные строковые функции как-то: замена подстроки, выравнивание, изменение регистра символов;

□ поддержка регулярных выражений;

□ поддержка примитивных типов XML Schema;

□ использование информации о структуре документа, определенной в его схеме;

□ поддержка экспоненциальной нотации чисел (наподобие 2Е10 = 1024);

□ поддержка функций приведения и преобразования (аналог CAST и CONVERT из SQL).

Выбор шаблонов для элементов пространства имен, определенного по умолчанию

Одним из значительных неудобств первой версии XSLT была невозможность сменить пространство имен, определенное по умолчанию для паттернов. То есть, если шаблон будет определен как

<xsl:template match="foo">

 ...

</xsl:template>

то обрабатывать он будет только те элементы foo, которые принадлежат нулевому пространству имен. Для элемента

<bar:foo xmlns:bar="urn:bar-namespace"/>

придется писать шаблон вида

<xsl:template match="ns:foo" xmlns:ns="urn:bar-namespace">

 ...

</xsl:template>

В случае целого документа принадлежащего ненулевому пространству имен, определения подобного рода могут оказаться слишком громоздкими. Решение этой проблемы может быть очень простым и элегантным.

Листинг 12.8. Изменение пространства имен для паттерна

<xsl:stylesheet

 version="2.0"

 xmlns:xsl="http://www.w3.org/1999/XSL/Transform"

 xmlns="urn:bar-namespace">

 <xsl:template match="foo">

  ...

 </xsl:template>

</xsl:stylesheet>

В элементе xsl:stylesheet пространство имен с URI "urn:bar-namespace" определяется как пространство имен по умолчанию и паттерн foo соответствует элементу с локальной частью имени "foo" и URI пространства имен "urn:bar-namespace".

Средства для форматирования даты и времени

В первых версиях XSLT элемент xsl:decimal-format и функция format-number обеспечивали форматирование чисел при их текстовом отображении. К сожалению, подобных инструментов для форматирования даты предусмотрено не было.

Поскольку связка элемента, определяющего именованный формат и функции, выполняющей форматирование, оказалась очень удачной, по всей вероятности, подобную схему мы будем наблюдать и в версии 2.0. Скорее всего, связка для форматирования даты и времени будет состоять из элемента xsl:date-format и функции format-date.

Функции id и key на внешних документах

В XSLT 1.1 функции id и key возвращают множества узлов документа, который содержит текущий узел преобразования. То есть для того, чтобы использовать ключи или уникальные идентификаторы для выбора узлов внешнего документа, необходимо сначала сменить контекст, например:

<xsl:for-each select="document('ext.xml')">

 <xsl:copy-of select="key('name', 'value')"/>

</xsl:for-each>

Требования ко второй версии XSLT предполагают упрощение работы с ключами и уникальными идентификаторами на внешних документах.

Включение неразбираемых внешних сущностей в виде текста

В первых версиях XSLT отсутствовала возможность включения внешних сущностей, не разбирая их как XML-документы. Без помощи расширений было невозможно включить в выходящий документ простой внешний текстовый файл. Между тем, вполне подходящим решением была бы функция типа unparsed-entity, которая по данному URI возвращала бы содержимое ресурса в виде строки. Естественно, при этом необходимо учитывать кодировку внешней сущности и Unicode-символы, которые не могут присутствовать в XML (например, управляющие символы).

Использование именованных сущностей вместо кодов символов

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

<xsl:text disable-output-escaping="yes">&nbsp;</xsl:text>

совсем не гарантирующим, кстати, что в выходящем файле окажется именно  .

В самом преобразовании сущности можно определять в DTD-заголовке следующим образом:

<!DOCTYPE xsl:stylesheet [

 <!ENTITY nbsp "&#хА0;">

]>

<xsl:stylesheet ... >

 ...

</xsl:stylesheet>

Однако на выходящий документ эти определения никоим образом не сказываются.

Обращение ссылок по ID/IDREF

Функция id позволяет отыскать в документе элементы по заданным значениями ID-атрибутов. Это особенно полезно при работе с IDREF-атрибутами, которые ссылаются на ID-атрибуты: можно с легкостью выбрать элементы, на которые ссылается текущий элемент. Новым требованием к XSLT 2.0 является возможность "обращать" такого рода ссылки — то есть находить элементы, которые ссылаются на данный элемент (включают определенные значения в свои IDREF-атрибуты).

Другие требования

В числе прочих требований, предъявленных к XSLT 2.0, можно перечислить следующие:

□ поддержка группировки;

□ поддержка Unicode-нормализации строк;

□ сортировка узлов в соответствии с информацией о их типах, сообщенной XML-схемой документа;

□ создание и копирование узлов с учетом информации об их типах;

□ создание пространства имен с вычисляемым префиксом и URI.

Приложение 1 Обзор XSLT-процессоров

Здесь даны необходимые сведения по всем существующим XSLT-процессорам, достаточные для того, чтобы сориентировать разработчика и помочь ему выбрать наиболее подходящий инструмент. Перечислим основные факторы, которые мы будем учитывать для каждого из рассматриваемых процессоров:

□ поддерживаемые программные или языковые платформы;

□ поддержка расширений;

□ полнота реализации;

□ популярность;

□ скорость.

Несмотря на то, что XSLT-процессоры являются довольно сложными программами, в подавляющем большинстве они распространяются по бесплатным лицензиям. Как следствие, ценовой показатель не является в данном случае определяющим.

Популярность XSLT-процессоров

Немаловажным фактором при выборе XSLT-процессора является его популярность: ведь чем более распространен процессор, тем больше возможность учитывать опыт предыдущих разработок и тем меньше вероятность найти грабли, на которые до этого еще не наступили другие.

На рис. П1.1 представлены результаты опросов, проведенных нами среди русскоязычных XML-разработчиков. В опросе принимали участие посетители сайта http://www.xmlhack.ru и подписчики конференции fido7.ru.xml. Параметр, приведенный в процентах, показывает, какая часть опрошенных использует этот процессор.

Рис. П1.1. Популярность основных XSLT-процессоров

Как и следовало ожидать, что наиболее популярным XSLT-процессором для решений на платформе Win32 является собственная разработка Microsoft — процессор MSXML. На Java-платформах самым популярным средством является Xalan, который разрабатывался в Apache XML Project.

Производительность XSLT-процессоров

Другим важным параметром, который следует учитывать при выборе процессора, является производительность или скорость выполнения преобразований. От производительности процессора зависит реальность использования XSLT в решениях, требующих быстрого времени реакции (например, на Web-серверах).

Производительность процессоров очень нелегко оценить. Во-первых, дело приходится иметь с различными программными и языковыми платформами, производительность которых различается уже сама по себе. Во-вторых, вследствие применения различных алгоритмов, эффективность процессоров может неодинаково проявляться на различных типах преобразований (например, на преобразовании А процессор I может быть быстрее процессора II, а на преобразовании В — медленнее). В-третьих, не все процессоры полностью и правильно реализуют возможности XSLT, то есть далеко не все преобразования будут выполняться на всех процессорах одинаково. Наконец, из всего времени обработки сложно выделить время, потраченное собственно на преобразование (а не на разбор и сериализацию XML).

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

С любезного разрешения Кевина Джонса (Kevin Jones) и DataPower, Inc, мы опубликуем результаты двух исследований производительности XSLT-процессоров, основанных на сравнительном анализе времени выполнения контрольного набора примеров. Сами примеры и исходную статистическую информацию можно найти на следующих Web-сайтах:

□ http://www.datapower.com/XSLTMark

□ http://www.tfi-technology.com/xml/xslbench.html

Мы приведем результаты этих исследований, выразив их в процентах (рис. П1.2 и П1.3). Относительную оценку в 100% имеет процессор с наивысшей скоростью, 50% — процессор, который оказался в два раза медленнее и так далее.

Рис. П1.2. Оценка производительности XSLT-процессоров в соответствии с XSLBench

Рис. П1.3. Оценка производительности XSLT-процессоров в соответствии с XSLTMark

Замечание

К моменту выхода книги в свет эта информация, скорее всего, потеряет свою актуальность — появятся новые процессоры, а старые будут переработаны. Несмотря на это, в глобальной перспективе расстановка сил вряд ли изменится, и поэтому приведенные данные могут быть полезны при выборе процессора и в будущем.

Библиотека Microsoft XML Parser

Основные характеристики. □ Платформы: MS Windows.

□ Расширения: функции расширения на JavaScript и VBScript.

□ Полнота реализации: один из наиболее проработанных процессоров.

□ Разработчик: Microsoft Corporation.

□ URL: http://msdn.microsoft.com/xml.

Продукт, названный Microsoft XML Parser, на самом деле далеко не только парсер. MSXML — это базовый компонент, объединяющий DOM/SAX-парсер, XSLT-процессор и некоторые другие инструменты. Мы будем рассматривать только XSLT-функциональность.

Компания Microsoft начала проявлять интерес к XSLT уже на самых ранних этапах разработки языка - когда он еще не был выделен из родительской технологии XSLT. Прототип процессора, предложенный Microsoft, был одной из первых рабочих реализаций XSLT. К сожалению, в этом прототипе был реализован ранний диалект языка, не совместимый со стандартной версией XSLT. Он получил большое распространение вместе с браузерами Internet Explorer 4.0, 5.0 и 5.5, и, как результат, множество программистов и по сей день работают с нестандартной версией XSLT, которая описывается пространством имен "http://www.w3.org/TR/WD-xsl". Поддержка стандартного XSLT была реализована в версии MSXML 3.0, которая вышла в марте 2000 года (более полная, production-версия появилась чуть позже, осенью).

Ранний вариант XSLT, реализованный в MSXML 2.0 и ниже, имеет схожие с XSLT 1.0 принципы, но также и целый ряд несовместимых отличий. Следует скорее сказать, что WD-xsl — это другой язык и программировать на нем тоже следует по-другому. Для того чтобы использовать стандартный XSLT в MSXML, следует обновить этот компонент, загрузив новую версию с Web-сайта Microsoft. Однако, и это еще не все. Дело в том, что Microsoft не отказалась от старой нестандартной версии и MSXML 3.0 поддерживает ее наравне с XSLT 1.0. Более того, по умолчанию, MSXML устанавливается в так называемом side-by-side режиме (англ. side-by-side - бок о бок). Это означает, что вновь установленный компонент не замещает предыдущую версию полностью. Поэтому устанавливать MSXML следует в режиме замены — по окончанию установки следует воспользоваться утилитой xmlinst.exe, также доступной с Web-сайта Microsoft для того, чтобы полностью заменить старую версию.

Типичными симптомами не до конца обновленной версии MSXML является следующее:

□ при попытке выполнить корректные преобразования, определенные в пространстве имен с URI "http://www.w3.org/1999/XSL/Transform", не происходит ничего или выдается ошибка;

□ при попытке выполнить те же преобразования, исправив URI на "http://www.w3.org/TR/WD-xsl", процессор пытается выполнить преобразование, но выдает ошибку о некорректности преобразования (в то время как оно работает на других процессорах);

□ в преобразованиях не работают переменные, именованные шаблоны, шаблоны значений атрибутов, ключи и импортирование.

В случае обнаружения подобных признаков единственным советом является обновление версии MSXML в режиме замены.

Предупреждение

Перед установкой MSXML3 рекомендуется внимательно ознакомиться с документацией на предмет возможности установки в режиме замены. Некоторые программные продукты (такие, как SQL Server и Biztalk Server) используют старую версию XSLT-процессора, и обновление в режиме замены приведет к нестабильности их работы.

Использование

Так как MSXML уже давно превратился в стандартный компонент Windows, использовать его можно разными способами - например, в собственных приложениях или как ISAPI-расширение. При разработке XSLT-преобразований MSXML, как правило, применяется либо совместно с браузером Internet Explorer, либо как самостоятельная утилита командной строки.

Первый способ заключается в том, что с XML-документом посредством инструкции xml-stylesheet ассоциируется преобразование и Internet Explorer отображает результат преобразования.

Пример

Листинг П1.1. Входящий документ source.xml

<?xml-stylesheet type="text/xsl" href="stylesheet.xsl"?>

<date>18.10.2001</date>

Листинг П1.2. Преобразование stylesheet.xsl

<?xml version="1.0" encoding="windows-1251"?>

<xsl:stylesheet

 version="1.0"

 xmlns:xsl="http://www.w3.org/1999/XSL/Transform">

 <xsl:template match="/">

  <html>

   <head>

    <title>Today is page</title>

   </head>

   <body>

    <xsl:apply-templates select="date"/>

   </body>

  </html>

 </xsl:template>

 <xsl:template match="date">

  <H1>

   <xsl:text>Сегодня </xsl:text>

   <xsl:value-of select="."/>

  </H1>

 </xsl:template>

</xsl:stylesheet>

Документ source.xml будет отображен в браузере Internet Explorer следующим образом (рис. П1.4).

Рис. П1.4. Документ source.xml, отображенный браузером Internet Explorer

Другим, вариантом является использование утилиты командной строки msxsl.exe, которая также доступна на Web-сайте MSDN. Эта утилита есть не более чем оболочка для MSXML, позволяющая вызывать основной компонент из командной строки.

Использование msxsl.exe совершенно стандартно: для применения преобразования stylesheet.xsl к документу source.xml и вывода результата в файле result.xml нужно выполнить следующую команду:

msxsl.exe source.xml stylesheet.xsl -о result.xml

Расширения

MSXML поддерживает пользовательские функции расширения, которые могут быть написаны на скриптовых языках VBScript и JScript и включены непосредственно в сами преобразования.

Пример

Листинг П1.3. Входящий документ

<?xml version="1.0" encoding="windows-1251"?>

<page>Сегодня <date/>.</page>

Листинг П1.4. Преобразование

<xsl:stylesheet version="1.0"

 xmlns:xsl="http://www.w3.org/1999/XSL/Transform"

 xmlns:msxsl="urn:schemas-microsoft-com:xslt"

 xmlns:ext="urn:extension-functions"

 exclude-result-prefixes="msxsl ext">

 <xsl:output encoding="windows-1251"/>

 <msxsl:script

  language="JavaScript"

  implements-prefix="ext">

  function date() {

   now = new Date;

   return now.getDate() + '.' +

    (now.getMonth() + 1) + '.' +

    now.getYear();

  }

 </msxsl:script>

 <xsl:template match="/">

  <html>

   <head>

    <title>Today is page</title>

   </head>

   <body>

    <xsl:apply-templates/>

   </body>

  </html>

 </xsl:template>

 <xsl:template match="date">

  <xsl:value-of select="ext:date()"/>

 </xsl:template>

</xsl:stylesheet>

Листинг П1.5. Выходящий документ

<html>

 <head>

  <META

   http-equiv="Content-Type"

   content="text/html;

   charset=windows-1251">

  <title>Today is page</title>

 </head>

 <body>Сегодня 18.10.2001.</body>

</html>

Как и во многих других процессорах, в MSXML предусмотрена функция расширения node-set, которая преобразует результирующий фрагмент дерева во множество узлов. Функция node-set принадлежит пространству имен с URI "urn:schemas-microsoft-com:xslt", и стандартным сценарием ее использования будет примерно следующий:

<xsl:stylesheet

 version="1.0"

 xmlns:xsl="http://www.w3.org/1999/XSL/Transform"

 xmlns:msxsl="urn:schemas-microsoft-com:xslt"

 exclude-result-prefixes="msxsl ">

 <!-- ...-->

 <xsl:variable name="tree">

  <!-- Переменная, содержащая результирующий фрагмент дерева -->

  <item>A</item>

  <item>B</item>

 </xsl:variable>

 <!-- ... -->

 <xsl:template ... >

  <!-- Обращение к $tree, как ко множеству узлов -->

  <xsl:value-of select="msxsl:node-set($tree)/item[1]"/>

 </xsl:template>

</xsl:stylesheet>

К сожалению, текущая версия MSXML не поддерживает расширение пользовательскими элементами.

Процессор Xalan

Основные характеристики.

□ Платформы: Java, С++.

□ Расширения: функции и элементы расширения.

□ Полнота реализации: один из наиболее проработанных процессоров. □ Разработчик: Apache XML Project.

□ URL: http://xml.apache.org.

Xalan — это очень известный XSLT-процессор, созданный в рамках Apache XML Project для языковых платформ Java и С++. Xalan, как и остальные продукты Apache XML Project, поставляется с открытым исходным кодом и открытым API, что делает его очень привлекательным для интеграции в другие приложения.

Использование

По сути дела, Xalan Java и Xalan C++ — это библиотеки, позволяющие использовать XSLT-преобразования в собственных проектах. Xalan Java поддерживает набор интерфейсов TrAX (от англ. transformation API for XML — программный интерфейс преобразований для XML), определяющий стандартные модели и методы преобразования XML-документов в Java-программах.

Помимо этого, и Xalan Java и Xalan С++ предусматривают возможность выполнения преобразований из командной строки. Для Xalan Java стандартный вызов будет выглядеть так:

java org.apache.xalan.xslt.Process -in source.xml -xsl stylesheet.xsl -OUT result.xml

Если при попытке выполнения этой команды выдается сообщение вида:

Exception in thread "main" java.lang.NoClassDefFoundError:

org/apache/xalan/xslt/Process

это означает, что библиотека xalan.jar не прописана в переменной окружения CLASSPATH, запустить Xalan в этом случае можно, указав xalan.jar в параметрах явным образом:

java -cp xalan.jar org.apache.xalan.xslt.Process -in source.xml -xsl stylesheet.xsl -out result.xml

Библиотека Xalan С++ имеет несколько вариантов для платформ Windows 32, Linux, AIX, HP-UX и Solaris, каждый из которых включает также скомпилированную утилиту TestXSLT, позволяющую выполнять преобразования из командной строки:

TestXSLT -in source.xml -xsl stylesheet.xsl -out result.xml

Расширения

Xalan С++ позволяет вызывать в XSLT-преобразовании пользовательские функции расширения, написанные на языке С. Кроме того, в дополнение к базовым функциям XSLT, Xalan С++ реализует несколько наиболее часто используемых функций, например, функцию nodeset. В текущей версии (1.2) Xalan С++ не поддерживает элементы расширения.

Возможности расширения Xalan Java намного богаче. Xalan Java, как и Xalan С++, реализует дополнительную библиотеку функций (которая по сравнению с Xalan С++ также намного шире). Помимо этого, Xalan Java позволяет создавать функции и элементы расширения на Java и других языках программирования.

Остановимся на последнем пункте более подробно. Xalan позволяет использовать библиотеку BSF (от англ. bean scripting framework — система скриптовых языков для bean-компонент). BSF — это библиотека, которая позволяет использовать скриптовые языки в Java-приложениях и апплетах. На данный момент BSF позволяет реализовывать в Xalan Java расширения на следующих скриптовых языках:

□ Mozilla Rhino (фактически, еще один вариант JavaScript);

□ NetRexx;

□ BML;

□ JPython;

□ Jacl;

□ PerlScript;

□ VBScript;

□ JavaScript.

Процессор Saxon

Основные характеристики.

□ Платформы: Java.

□ Расширения: функции и элементы расширения на Java.

□ Полнота реализации: практически идеальная.

□ Разработчик: Майкл Кей.

□ URL: http://saxon.sourceforge.net.

XSLT-процессор Saxon был разработан и до сих пор поддерживается единственным человеком — Майклом Кеем (Michael Kay), который в настоящий момент является редактором спецификации XSLT 2.0. Процессор Saxon, так же как и Xalan, является бесплатным open-source продуктом.

На Web-сайте Saxon доступны два варианта процессора — полный Saxon и облегченная версия, скомпилированная для Windows — Instant Saxon, которая занимает всего 400 килобайт в архиве, но практически не уступает полной версии по функциональности.

Следует особым образом подчеркнуть полноту реализации Saxon. Майкл Кей является известным специалистом по XSLT, который много времени уделяет консультированию разработчиков в списке-рассылке XSL List. Столь плотная работа с конечными пользователями позволяет ему быстро реагировать на информацию о допущенных ошибках и несоответствиях. Как результат, разработанный и поддерживаемый им процессор считается образцом соответствия стандарту XSLT. В целом, Saxon можно описать как выдающийся продукт от выдающегося человека.

Использование

Легкий вариант, Instant Saxon представляет собой утилиту командной строки saxon.exe, с помощью которой можно применять преобразования к XML-документам:

saxon.exe -о result.xml source.xml stylesheet.xsl

Полная версия Saxon (включающая также исходный код) тоже может использоваться как утилита командной строки:

java com.icl.saxon.stylesheet -о result.xml source.xml stylesheet.xsl

Как и в случае с Xalan, библиотеку saxon.jar придется либо включить в переменную окружения CLASSPATH, либо указывать явным образом

java -cp saxon.jar com.icl.saxon.StyleSheet -o result.xml source.xml stylesheet.xsl

Между тем, Saxon — это далеко не только процессор командной строки. Saxon предоставляет очень мощные возможности для использования в собственных проектах. В частности, Saxon поддерживает TrAX (Transformation API for XML), о котором мы говорили чуть выше, позволяет применять пользовательские парсеры и сериализаторы, предоставляет API для Java и многое другое.

Расширения

Расширения для Saxon могут быть созданы на языке Java в виде функций и элементов. Saxon отличает возможность использования Java-функций расширения, написанных для других Java-процессоров (в частности Xalan и Oracle XSLT Processor).

Для программирования элементов расширения Saxon предоставляет интерфейс com.icl.saxon.style.ExtensionElementFactory, который несколько отличается от подхода, предложенного в Xalan. В Xalan элементу расширения соответствует функция класса, в то время как в Saxon элементу расширения соответствует "фабрика классов", ExtensionElementFactory, возвращающая по данному имени элемента класс-наследник com.icl.saxon.style.StyleElement, соответствующий экземпляру элемента.

Помимо описанных выше возможностей, базовая библиотека функций XPath расширена в Saxon большим количеством функций, облегчающих работу со строками, множествами, датами и так далее. Saxon также включает некоторые из расширений, предложенные инициативой EXSLT.

Библиотека Oracle XDK

Основные характеристики.

□ Платформы: Java, C/C++, PL/SQL.

□ Расширения: поддержка функций расширения.

□ Полнота реализации: сравнительно хорошая (уступает Saxon и MSXML).

□ Разработчик: Oracle Corporation.

□ URL: http://technet.oracle.com/tech/xml/.

Так же как и MSXML, Oracle XDK (от англ. XML Development Kit - комплект для XML-разработки) состоит из нескольких компонентов, предназначенных для разработки XML-приложений на Java, С, С++ и PL/SQL. Библиотека Oracle XDK включает XML-парсер, реализующий DOM и SAX интерфейсы, XSLT-процессор, генератор классов и процессор для XML Schema. Java-версия XDK также включает XSQL-сервлет и утилиту XML SQL (в сокращении — XSU), которые являются основой решений Oracle для обеспечения XML-функциональности в базах данных. XSU предоставляет возможности для экспорта и импорта реляционных данных в виде XML, а сервлет XSQL позволяет использовать возможности XSU в клиент-серверных приложениях (в частности — на Web-серверах). Примечательно, что XSU и XSQL работают не только с базой данных Oracle, но и с любыми другими базами данных, которые поддерживают JDBC-доступ. Oracle XDK разработан под руководством Стива Мюнха (Steve Muench), который также является очень известным специалистом по XML.

Главным образом в Oracle XDK нас интересует библиотека, отвечающая за выполнение XSLT-преобразований — Oracle XSLT Processor. Этот компонент включен во все языковые версии XDK: существует вариант для Java, С, С++ и даже для PL/SQL (что позволяет выполнять преобразования внутри базы данных Oracle).

Относительно проработанности Oracle XSLT Processor можно сказать следующее: XSLT 1.0 поддерживается полностью (или почти полностью), однако периодически попадаются мелкие ошибки, которые оперативно исправляются в следующих релизах. XSLT-процессор играет важную роль в Web-решениях Oracle и потому его поддержке и отладке уделяется большое внимание.

Использование

Главной областью применения Oracle XSLT Processor является его использование совместно с технологиями XSQL и XSU для обеспечения Web-доступа к реляционным данным. Кроме этого, Oracle XSLT Processor легко интегрируется в другие приложения и также может выполняться из командной строки. Например, в Java-версии Oracle XDK для выполнения преобразования следует запустить команду:

java oracle.xml.parser.v2.oraxsl source.xml stylesheet.xsl result.xml

Если выдается сообщение о ненайденном классе, можно попробовать следующий вариант:

java -cp xmlparserv2.jar oracle.xml.parser.v2.oraxsl source.xml stylesheet.xsl result.xml

Можно также воспользоваться утилитой пакетной обработки oraxsl:

oraxsl source.xml stylesheet.xsl result.xml

Расширения

Java-версия Oracle XSLT Processor может расширяться пользовательскими функциями, написание которых, в принципе, ничем не отличаются от стандартных методов создания Java-функций расширения.

К сожалению, Oracle XSLT Processor не поддерживает пользовательские элементы расширения. Стандартных дополнений базовой библиотеки функций XPath и XSLT также не предусмотрено.

Процессор Sablotron

Основные данные процессора.

□ Платформы: С++, Perl, PHP, Python.

□ Расширения: нет.

□ Полнота реализации: XSLT 1.0 и XPath 1.0 реализованы не полностью.

□ Разработчик: Ginger Alliance.

□ URL: http://www.gingerall.com.

XSLT-процессор Sablotron, разработанный в Ginger Alliance, — это еще один пример весьма успешного open source проекта в области XML-технологий. Sablotron — это библиотека для преобразования XML-документов, которая построена (вернее, почти построена) в соответствии со спецификациями XSLT, XPath и DOM. Процессор Sablotron изначально написан на С++ и компилируется под несколько платформ, в числе которых Linux, Windows 32, Solaris, HP-UX, FreeBSD, OpenBSD, OpenServer и UnixWare. Открытый код также позволяет переносить Sablotron под другие платформы, так что этот список, вполне возможно, будет расширен.

К сожалению, реализация XSLT и XPath в Sablotron вызывает определенные нарекания. В текущей версии (0.71) Sablotron далеко не полностью поддерживает эти стандарты: например, в путях выборки не работают оси навигации following и preceding, некоторые функции (как то: id, lang, unparsed-entity-uri) не реализованы вообще, многие из функций и элементов реализованы не до конца или работают не в полном соответствии со спецификациями. В общем, соответствие Sablotron стандартам оставляет желать лучшего, хотя и в таком виде он является вполне функциональным процессором.

Использование

Особую популярность процессору Sablotron'у придает наличие для него расширений под языки Perl, PHP и Python. Долгое время Sablotron был единственным XSLT-процессором, который существовал для Perl, и поэтому Perl-программистам для выполнения XSLT-преобразований не оставалось ничего, кроме как использовать Sablotron.

Помимо интерфейсов для С++, Perl, Python и PHP, для Sablotron также существует утилита для выполнения преобразований из командной строки sabcmd:

sabcmd stylesheet.xsl source.xml result.xml

Процессор xt

Характеристики процессора.

□ Платформы: Java.

□ Расширения: функции расширения, некоторые элементы расширения.

□ Полнота реализации: практически полностью реализует XSLT версии PR-xslt-19991008.

□ Разработчик: Джеймс Кларк (James Clark).

□ URL: http://www.jclark.com/xml/xt.html.

Без всякого сомнения, xt является легендарным процессором. Он был написан Джеймсом Кларком - человеком, чей вклад в технологию XSLT сложно переоценить. Кларк был редактором первой версии XSLT, а его процессор xt был одним из первых прототипов, реализующих новый язык. На xt практическим способом было проверено, множество идей, касающихся XSLT, ведь мало создать мощный язык — нужно еще и позаботиться о том, чтобы его можно было реализовать на практике в интерпретаторах, процессорах и компиляторах.

Процессор xt, безусловно, сыграл свою роль в развитии технологии XSLT. К сожалению, Джеймс Кларк более не продолжает этот проект. Версия от 5 ноября 1999 года является последней версией xt. Она все еще доступна на Web-сайте http://www.jclark.com/xml/xt.html, но более не поддерживается.

В последней (если не сказать, финальной) версии xt язык XSLT реализован в почти полном соответствии с версией PR-xslt-19991008. Буквы PR в этом коде означают "proposed recommendation" (англ. предлагаемая рекомендация). PR - это одна из последних стадий принятия нового стандарта в Консорциуме W3, так что можно сказать, что xt реализует почти стандартную версию XSLT. Процессор xt имеет ряд ограничений и недоработок, но уже поздно надеяться, что они будут когда-либо исправлены.

Использование

Как и любой другой XSLT-процессор, написанный на Java, xt можно без труда использовать в Java-проектах. Помимо этого, xt можно использовать в качестве сервлета и из командной строки.

Сервлет-версия xt реализована в классе com.jclark.xsl.sax.XSLservlet и может выполняться на контейнерах, поддерживающих Java Servlet API версии 2.1 и выше.

Версия xt для командной строки позволяет выполнять преобразования посредством следующей команды:

java -Dcom.jdark.xsl.sax.parser=SAX-драйвер com.jclark.xsl.sax.Driver source.xml stylesheet.xsl result.xml

В этой команде параметр SAX-драйвер указывает на класс, который xt будет использовать в качестве SAX-парсера для разбора входящего документа.

Для платформы Windows32 процессор xt поставляется также в уже скомпилированной версии. Его запуск в этом случае выглядит как

xt source.xml stylesheet.xsl result.xml

Расширения

В xt реализован стандартный метод вызова Java-функций расширения (если быть до конца откровенными, Кларк фактически и придумал этот "стандартный" способ). Функции реализуются в Java-классах, которые затем подключаются при помощи URI пространств имен.

Сверх этого, xt также реализует несколько дополнительных функций для операций над множествами (xt:node-set, xt:intersection и xt:difference) и дополнительный элемент xt:document, который позволяет выводить результат преобразования сразу в несколько выходящих файлов. Позже эта же концепция была реализована в некоторых других процессорах и перенесена в версию XSLT 1.1.

Библиотека libxslt

Основные характеристики.

□ Платформы: C/Gnome, Perl, Python.

□ Расширения: функции и элементы расширения.

□ Полнота реализации: практически полное соответствие XSLT 1.0.

□ Разработчик: Даниел Вейлард (Daniel Veillard).

□ URL: http://xmlsoft.org/XSLT/.

Наравне с Saxon и xt, библиотека libxslt является еще одним примером того, насколько сильным может быть open-source продукт, даже если он создается, в основном, одним человеком. Библиотека libxslt изначально создавалась для поддержки XSLT-преобразований в проекте Gnome. Для разбора XML, работы с древовидными структурами и вычисления XPath-выражений libxslt использует другую Gnome-библиотеку: libxml. Библиотека libxslt написана практически на чистом ANSI С (языке С стандарта ANSI) и работает на таких платформах, как Linux, Unix и Windows32.

Использование

Прежде всего, как C-библиотеку, libxslt можно подключать к собственным модулям посредством документированного API, а также при помощи разработанных врапперов использовать в Perl и Python-программах. Поскольку по степени совместимости и разработанности libxslt явно превосходит Sablotron, думается, что в скором времени он станет гораздо более популярным.

В libxslt также включена утилита xsltproc, которая обеспечивает для libxslt интерфейс командной строки:

xsltproc -о result.xml stylesheet.xsl source.xml

В языках Perl и Python libxslt используется при помощи модулей XML::LibXSLT и libxsltmod соответственно.

Расширения

Другим преимуществом libxslt по сравнению с Sablotron является возможность использования расширений, причем как в виде функций, так и в виде элементов. Функции и элементы расширения в libxslt оформляются в виде C-функций, затем регистрируются в процессоре перед вызовом и используются в преобразованиях так же, как и в случае с Java — посредством пространств имен.

В дополнение к этому, в libxslt по умолчанию также реализовано множество общепринятых расширений — в частности, многие из функций, предложенных в процессоре Saxon и инициативе EXSLT.

Приложение 2 Краткий справочник элементов и атрибутов XSLT

Обозначения

Ниже перечислены обозначения, используемые в данной книге.

□ attribute

Обязательный атрибут.

□ attribute

Необязательный атрибут.

□ attribute="строка"

Атрибут со строковым параметром.

□ attribute="{строка}"

Атрибут со строковым параметром, значение которого является шаблоном значения атрибута.

□ attribute="yes" | "no"

Атрибут с вариантами значений.

□ attribute={ "yes" | "no" }

Атрибут с вариантами значений, которые могут быть заданы шаблонами значений атрибутов.

□ <!-- Содержимое: шаблон -->

Содержимым элемента является шаблон.

□ <!-- Содержимое: несколько элементов xsl:import ... -->

Элемент содержит последовательность из нуля или более элементов xsl:import.

□ <!-- Содержимое: один или более элемент xsl:when ... -->

Элемент содержит последовательность из одного или более элементов xsl:when.

□ <!-- Содержимое: ... опциональный элемент xsl:otherwise -->

Элемент содержит элемент xsl:otherwise, который может быть пропущен.

Элементы

В табл. П2.1 приведены описания основных элементов XSLT.

Таблица П2.1. Описание основных элементов XSLT

Элемент	Описание
<xsl:apply-imports/>	Инструкция. Применяет шаблонные правила, которые содержатся в импортированных преобразованиях
<xsl:apply-templates select="выражение" mode="режим"> <!-- Содержимое: несколько элементов xsl:sort или xsl:with-param --> </xsl:apply-templates>	Инструкция. Применяет шаблонные правила к множеству узлов, возвращаемому выражением, записанным в атрибуте select. • select — содержит выражение, возвращающее множество узлов для обработки; • mode — указывает режим, в котором должны применяться шаблоны
<xsl:attribute name="{имя}"	Инструкция. Создает в выходящем документе узел атрибута. • name — определяет имя атрибута; • namespace — URI пространства имен создаваемого атрибута
namespace="{пространство имен}"> <!-- Содержимое: шаблон --> </xsl:attribute>
<xsl:attribute-set name="имя" use-attribute-sets="имена"> <!-- Содержимое: несколько элементов xsl:attribute --> </xsl:attribute-set>	Элемент верхнего уровня. Определяет именованный набор атрибутов. • name — содержит имя набора атрибутов; • use-attribute-sets — перечисляет через пробелы имена наборов атрибутов, которые следует включить в определяемый набор
<xsl:call-template name="имя"> <!-- Содержимое: несколько элементов xsl:with-param --> </xsl:call-template>	Инструкция. Вызов именованного шаблона. • name — имя вызываемого шаблона
<xsl:choose> <!-- Содержимое: один или более элемент xsl:when, опциональный элемент xsl:otherwise --> </xsl:choose>	Инструкция. Выполняет содержимое одного из субэлементов в зависимости от условий
<xsl:comment> <!-- Содержимое: шаблон --> </xsl:comment>	Инструкция. Создает в выходящем документе узел комментария
<xsl:copy use-attribute-sets="имена"> <!-- Содержимое: шаблон --> </xsl:copy>	Инструкция. Создает в выходящем документе копию текущего узла. Копии дочерних узлов не создаются. • use-attribute-sets — перечисляет именованные наборы атрибутов, которые следует добавить в создаваемый узел
<xsl:copy-of select="выражение"/>	Инструкция. Копирует в выходящий документ результат вычисления выражения. • select — содержит выражение, результат которого нужно скопировать
<xsl:decimal-format name="имя" decimal-separator="символ" grouping-separator="символ" infinity="строка" minus-sign="символ" NaN="строка" percent="символ" per-mille="символ" zero-digit="символ" digit="символ" pattern-separator="символ"/>	Элемент верхнего уровня. Определяет именованный набор параметров для формата числа. • name — имя. Если name отсутствует, формат числа определяется по умолчанию; • decimal-separator — символ, разделяющий целую и дробную часть; • grouping-separator — символ, разделяющий группы цифр целой части числа; • infinity — строка, соответствующая бесконечности; • minus-sign — символ отрицания; • NaN — строка, соответствующая нечислу; • percent — символ процента; • per-mille — символ промилле; • zero-digit — символ нуля; • digit — символ, помечающий позицию необязательной цифры; • pattern-separator — символ, разделяющий положительный и отрицательный образцы форматирования
<xsl:element name="{имя}" namespace="{пространство имен}" use-attribute-sets="имена"> <!-- Содержимое: шаблон --> </xsl:element>	Инструкция. Создает в выходящем документе элемент. • name — имя элемента; • namespace — URI пространства имен создаваемого элемента; • use-attribute-sets — перечисляет имена наборов атрибутов, которые надо включить в создаваемый элемент
<xsl:fallback> <!-- Содержимое: шаблон --> </xsl:fallback>	Инструкция. Выполняется при невозможности выполнить родительскую инструкцию
<xsl:for-each select="выражение"> <!-- Содержимое: несколько элементов xsl:sort, шаблон --> </xsl:for-each>	Инструкция. Выполняет содержащийся шаблон для каждого из узлов множества. • select — содержит выражение, возвращающее перебираемое множество узлов
<xsl:if test="выражение" > <!-- Содержимое: шаблон --> </xsl:if>	Инструкция. Выполняет или не выполняет дочерний шаблон в зависимости от заданного условия. • test — содержит выражение проверяемого условия
<xsl:import href="URI"/>	Элемент верхнего уровня. Импортирует указанный шаблон. • href — URI импортируемого шаблона
<xsl:include href="URI"/>	Элемент верхнего уровня. Включает указанный шаблон. • href — URI включаемого шаблона
<xsl:key name="имя" match="паттерн" use="выражение"/ >	Элемент верхнего уровня. Определяет именованный ключ. • name — имя ключа; • match — выбирает узлы, для которых будут определяться значения ключа; • use — выражение, значение которого будет значением ключа для каждого из узлов
<xsl:message terminate="yes" | "no"> <!-- Содержимое: шаблон --> </xsl:message>	Инструкция. Указывает процессору на то, что нужно вывести сообщение. • terminate — определяет, следует ли прервать обработку после вывода сообщения или нет
<xsl:namespace-alias stylesheet-prefix="префикс" | "#default" result-prefix="префикс" | "#default"/>	Элемент верхнего уровня. Определяет псевдоним для префикса. • stylesheet-prefix — префикс в преобразовании; • result-prefix — префикс в результирующем документе
<xsl:number level="single" | "multiple" | "any" count="паттерн" from="паттерн" value="выражение" format="{строка}" lang="{токен}" letter-value={ "alphabetic" | "traditional" } grouping-separator="{символ}" grouping-size="{число}"/>	Инструкция. Выводит номер в соответствии с заданными критериями. • level — на каких уровнях нумеровать узлы; • count — какие узлы учитывать при нумерации; • from — в какой части документа нумеровать узлы; • value — выражение, вычисляющее номер. • format — форматирующая строка номера; • lang — язык для алфавитных последовательностей; • letter-value — алфавитная или традиционная нумерация; • grouping-separator — разделяющий символ групп цифр номера; • grouping-size — количество цифр в группах цифр номера
<xsl:otherwise> <!-- Содержимое: шаблон --> </xsl:otherwise>	Субэлемент элемента xsl:choose. Выполняется в элементе xsl:choose, если ни одно из других условий не верно.
<xsl:output method="xml" | "html" | "text" | " префикс:имя" version="токен" encodings="строка" omit-xml-declaration="yes" | "no" standalone="yes" | "no" doctype-public="строка" doctype-system="строка" cdata-section-elements="имена" indent="yes" | "no" media-type="строка"/>	Элемент верхнего уровня. Определяет параметры вывода результирующего документа. • method — метод сериализации; • version — версия языка сериализации; • encoding — кодировка выходящего документа; • omit-xml-declaration — опустить декларацию XML; • standalone — самостоятельный или несамостоятельный документ; • doctype-public — публичный идентификатор типа документа; • doctype-system — системный идентификатор типа документа; • cdata-section-elements — элементы, содержимое которых следует выводить как секции CDATA; • indent — индентация (вывод отступов); • media-type — медиа-тип
<xsl:param name="имя" select="выражение"> <!-- Содержимое: шаблон --> </xsl:param>	Инструкция, элемент верхнего уровня. Определяет параметр преобразования или шаблонного правила. • name — имя параметра; • select — выражение, задающее значение параметра
<xsl:preserve-space elements="токены"/>	Элемент верхнего уровня. Определяет элементы входящего документа, в которых следует сохранять текстовые узлы, содержащие только пробельные символы. • elements — перечисляет элементы, в которых пробельные символы должны быть сохранены
<xsl:processing-instruction name="{имя}"> <!-- Содержимое: шаблон --> </xsl:processing-instruction>	Инструкция. Создает узел инструкции по обработке. • name — определяет имя целевого приложения создаваемой инструкции
<xsl:sort select="выражение" lang="{токен}" data-type={ "text" | "number" | "префикс:имя" } order={ "ascending" | "descending" } case-order={ "upper-first" | "lower-first"}/>	Субэлемент элементов xsl:apply-templates и xsl:for-each. • select — выражения для сортировки; • lang — язык сортировки; • data-type — тип данных сортировки; • order — порядок сортировки; • case-order — упорядоченность строчных и прописных букв
<xsl:strip-space elements="токены"/>	Элемент верхнего уровня. Определяет элементы входящего документа, в которых следует удалять текстовые узлы, содержащие только пробельные символы. • elements — перечисляет элементы, в которых пробельные символы должны быть удалены
<xsl:stylesheet id="идентификатор" extension-element-prefixes="префиксы" exclude-result-prefixes="префиксы" version="число"> <!-- Содержимое: несколько элементов xsl:import, элементы верхнего уровня --> </xsl:stylesheet>	Корневой элемент преобразования. • id — идентификатор преобразования; • extension-element-prefixes — префиксы элементов расширения; • exclude-result-prefixes — префиксы, не включаемые в выходящий документ; • version — версия языка XSLT
<xsl:template match="паттерн" namе="имя" priority="число" modе="имя"> <!-- Содержимое: несколько элементов xsl:param, шаблон --> </xsl:template>	Элемент верхнего уровня. Определяет шаблонное правило. • match — содержит паттерн, которому должны удовлетворять узлы, обрабатываемые данным шаблоном; • name — имя шаблона; • priority — приоритет шаблона; • mode — режим шаблона
<xsl:text disable-output-escaping="yes" | "no"> <!-- Содержимое: символьные данные --> </xsl:text>	Инструкция. Создает в выходящем документе текстовый узел. Пробельные символы, находящиеся внутри xsl:text, не удаляются. • disable-output-escaping — определяет, должны ли в выходящем документе особые символы этого текстового узла заменяться на сущности
<xsl:transform id="идентификатор" extension-element-prefixes="префиксы" exclude-result-prefixes="префиксы" version="число"> <!-- Содержимое: несколько элементов xsl:import, элементы верхнего уровня --> </xsl:transform>	Корневой документ преобразования. Псевдоним элемента xsl:stylesheet
<xsl:value-of select="выражение" disable-output-escaping="yes" | "no"/>	Инструкция. Создает в выходящем документе текстовый узел, содержащий результат вычисления выражения, приведенный к строке. • select — содержит вычисляемое выражение; • disable-output-escaping — определяет, должны ли в выходящем документе особые символы этого текстового узла заменяться на сущности
<xsl:variable name="имя" select="выражение" > <!-- Содержимое: шаблон --> </xsl:variable>	Инструкция, элемент верхнего уровня. Создает глобальную или локальную переменную. Значение переменной не может быть изменено. • name — задает имя определяемой переменной; • select — задает значение определяемой переменной
<xsl:when test="выражение"> <!-- Содержимое: шаблон --> </xsl:when>	Субэлемент элемента xsl:choose. Выполняется один из вариантов в блоке xsl:choose в зависимости от условия. • test — задает выражение логического условия
<xsl:with-param name="имя" select="выражение"> <!-- Содержимое: шаблон --> </xsl:with-param>	Субэлемент элементов xsl:apply- templates, xsl:call-template. Задает значение одного параметра при вызове параметризованного шаблона. • name — имя параметра; • select — выражение, значение которого должно быть передано как параметр. В случае, если атрибут select не определен, значением передаваемого параметра является дерево, полученное в результате выполнения содержимого xsl:with-param. Если элемент при этом пуст, значением параметра является пустая строка

Атрибуты

Сведения об атрибутах XSLT представлены в табл. П2.2.

Таблица П2.2. Атрибуты XSLT

Атрибут	Назначение
xsl:version	Указывает версию языка в случае использования упрощенного синтаксиса записи преобразований
xsl:exclude-result-prefixes	Перечисляет префиксы пространств имен, которые должны быть исключены в данном элементе
xsl:extension-elements-prefixes	Перечисляет префиксы пространств имен, которые используются в элементах расширения
xsl:use-attribute-sets	Перечисляет названия именованных наборов атрибутов, которые следует включить в данный элемент на выходе

Приложение 3 Краткий справочник функций XSLT и XPath

Обозначения

Прототип функции имеет следующий синтаксис:

тип1 функция(тип2, тип3, тип4?)

Здесь тип1 — тип возвращаемого значения, тип2, тип3, тип4 — типы передаваемых параметров.

При этом символ "?" обозначает аргумент, который может быть опущен, а символ * служит для обозначения аргумента, который может повторяться несколько раз.

Функции

В табл. П3.1–П3.5 представлено описание наиболее часто используемых функций.

Таблица П3.1. Булевые функции

Функция	Описание
boolean boolean(object)	Явным образом преобразует объект, который ей передается в булевый тип
boolean not(boolean)	Выполняет логическое отрицание
boolean true()	Возвращает true, "истину"
boolean false()	Возвращает false, "ложь"
boolean lang(string)	Возвращает "истину", если идентификатор языка, который передан ей в виде строкового параметра, соответствует языковому контексту контекстного узла

Таблица П3.2. Числовые функции

Функция	Описание
number number(object?)	Явным образом конвертирует свой аргумент в числовой тип. Если аргумент опущен, то выполняется с множеством, состоящим из контекстного узла
number sum(node-set)	Суммирует значения узлов из переданного ей множества
number floor(number)	Округляет аргумент до ближайшего не большего целого
number ceiling(number)	Округляет аргумент до ближайшего не меньшего целого
number round(number)	Округляет аргумент до ближайшего целого значения

Таблица П3.3. Строковые функции

Функция	Описание
string string(object?)	Преобразует свой аргумент к строковому типу явным образом. Если аргумент опущен, то выполняется с множеством, состоящим из контекстного узла
string concat(string, string, string*)	Возвращает конкатенацию (строковое сложение) своих аргументов
boolean starts-with (string, string)	Принимает на вход два строковых аргумента и возвращает true, если первая строка начинается со второй и false в противном случае
boolean contains (string, string)	Принимает на вход два строковых аргумента и возвращает true, если первая строка содержит вторую и false в противном случае
string substring-before(string, string)	Принимает на вход два строковых аргумента, находит в первой строке вторую и возвращает подстроку, которая ей предшествует
string substring-after(string, string)	Принимает на вход два строковых аргумента, находит в первой строке вторую и возвращает подстроку, которая за ней следует
string substring(string, number, number?)	Возвращает подстроку переданного ей строкового аргумента, которая начинается с позиции, указанной вторым аргументом и длиной, указанной третьим аргументом. Если третий аргумент не указан, то подстрока продолжается до конца строки
number string-length(string?)	Возвращает число символов строкового аргумента
string normalize-space(string?)	Производит со строковым аргументом нормализацию пробельного пространства. Если аргумент опущен, выполняется со строковым значением контекстного узла
string translate (string, string, string)	Производит замену символов первого своего строкового аргумента, которые присутствуют во втором аргументе на соответствующие символы третьего аргумента

Таблица П3.4. Функции множеств узлов

Функция	Описание
number last()	Возвращает размер контекста вычисления выражения
number position()	Возвращает позицию контекста вычисления выражения
number count(node-set)	Возвращает число узлов, которое входит во множество, переданное ей в качестве аргумента
string local-name(node-set?)	Возвращает локальную часть имени первого в порядке просмотра документа узла множества, переданного в качестве аргумента или локальную часть имени контекстного узла, если аргумент отсутствует. Если аргумент опущен, то выполняется с множеством, состоящим из контекстного узла
string namespace-uri(node-set?)	Возвращает URI пространства имен первого в порядке просмотра документа узла множества, переданного в качестве аргумента или локальную часть имени контекстного узла, если аргумент отсутствует. Если аргумент опущен, то выполняется с множеством, состоящим из контекстного узла
string name(node-set?)	Возвращает в виде префикс:имя расширенное имя локальную часть имени первого в порядке просмотра документа узла множества, переданного в качестве аргумента или локальную часть имени контекстного узла, если аргумент отсутствует. Если аргумент опущен, то выполняется с множеством, состоящим из контекстного узла
node-set id(object)	Возвращает множество узлов по уникальным идентификаторам

Таблица П3.5. Другие функции

Функция	Описание
node-set key(string, object)	По данному имени и значению ключа возвращает множество узлов, которые им обладают
node-set document(object, node-set?)	Позволяет обращаться к внешним документам по заданным URI. Первый узел необязательного параметра node-set принимается за точку отсчета для относительных URI
node-set current()	Возвращает текущий узел преобразования
string unparsed-entity-uri(string)	Возвращает URI неразбираемой сущности по ее имени
string generate-id(node-set?)	Возвращает уникальный строковый идентификатор первого узла переданного множества или контекстного узла, если аргумент опущен
object system-property(string)	Возвращает значение свойства, имя которого передано как аргумент

Приложение 4 Интернет-ресурсы, посвященные XSLT

Зарубежные интернет-ресурсы по XSLT

□ http://www.dpawson.co.uk/xsl/sect2/sect21.html

XSLT Questions and Answers. Большой архив вопросов и ответов по XSLT.

□ http://www.zvon.org

The Guide to the XML Galaxy. Большой репозитарий примеров, уроков и материалов для изучения XML-технологий и, в частности, XSLT.

□ http://www.datapower.com/XSLTMark/res_2001_04_01.html

XSLT Benchmarking. Тесты эффективности различных XSLT-процессоров.

□ http://www.tfi-technology.com/xml/xslbench.html

XSLT Processor Benchmarking. Тесты эффективности различных XSLT-процессоров.

□ http://msdn.microsoft.com/library/default.asp?url=/library/en-us/xmlsdk30/htm/xmconxsltfaq.asp?frame=true

Microsoft MSXML 3.0

XSLT Developer's Guide: XSLT FAQ. Вопросы и ответы об XSLT-разработке на основе библиотеки MSXML.

□ http://www.netcrucible.com/xslt/msxml-faq.htm

Unofficial MSXML XSLT FAQ. Неофициальный список вопросов и ответов по реализации XSLT в библиотеке MSXML.

□ http://www.ibiblio.org/xml/books/bible2/chapters/ch17.html

Chapter 17 of the XML Bible: XSL Transformations. Глава, посвященная XSLT из популярной книги "Библия XML".

□ http://www.biglist.com/lists/xsl-list/archives/

XSL Mailing List archives. Архив сообщений списка рассылки XSL Mailing List.

□ http://www.oasis-open.org/cover/xsl.html

The XML Cover Pages. Extensible Stylesheet Language (XSL). Сжатая информация и большой список ресурсов, посвященных XSLT.

□ http://www.dpawson.co.uk/xsl/xslvocab.html

XSLT Terminology. Глоссарий XSLT.

□ http://www.w3schools.com/xsl/

W3C XSL School. Школа Консорциума W3.

□ http://incrementaldevelopment.com/xsltrick/

XSLT and XPath tips and tricks. Приемы и методы работы с XSLT и XPath.

□ http://www.xml.org/xml/resources_focus_xslt.shtml

XSL, XSLT and XPath resources. Большой перечень ресурсов, посвященных XSL, XSLT и XPath.

Русскоязычные ресурсы

□ http://xmlhack.ru

Новости и ресурсы для XML-разработчиков.

□ http://www.xml.nsu.ru

Школы Консорциума W3 на русском языке.

□ http://citforum.ru/internet/xml.shtml

Ресурсы XML на CITForum.

□ http://www.sinor.ru/~xml

Подборка XML-ресурсов.

Технические рекомендации и стандарты

□ http://www.w3.org/TR/xslt

XSL Transformations (XSLT). Version 1.0. Спецификация языка XSLT.

□ http://www.w3.org/TR/XPath

XML Path Language (XPath). Version 1.0. Спецификация языка XPath.

□ http://www.w3.org/TR/REC-xml

Extensible Markup Language (XML) 1.0 (Second Edition). Спецификация языка XML.

□ http://www.w3.org/TR/1999/REC-xml-names-19990114

Namespaces in XML. Спецификация пространств имен XML.

□ http://www.w3.org/TR/xml-stylesheet/

Associating Style Sheets with XML documents. Version 1.0. Ассоциация преобразований с XML-документами.

□ http://www.unicode.org/charts/

Unicode Code Charts. Таблицы символов Unicode.

Переводы стандартов на русский язык

□ http://www.rol.ru/news/it/helpdesk/xml01.htm

Расширяемый язык разметки (XML) 1.0 (вторая редакция). Перевод Радика Усманова, Luxoft (IBS).

□ http://www.rol.ru/news/it/helpdesk/xslt01.htm

Язык преобразований XSL (XSLT). Версия 1.0. Перевод Радика Усманова, Luxoft (IBS).

□ http://www.tkachenko.org/xpath/REC-xpath-19991116-ru.html

Язык XML Path(XPath). Версия 1.0. Перевод Олега Ткаченко (Multiconn International).

□ http://www.rol.ru/news/it/helpdesk/xpath01.htm

Язык XML Path (XPath). Версия 1.0. Перевод Радика Усманова, Luxoft (IBS).

□ http://www.rol.ru/news/it/helpdesk/xnamsps.htm

Пространства имен в XML. Перевод Радика Усманова, Luxoft (IBS).

Другие ресурсы

Списки рассылки

□ http://www.mulberrytech.com/xsl/xsl-list/index.html

XSL List

□ Open Forum on XSL

Самый авторитетный список рассылки на тему XSL, XSLT и сопутствующих технологий.

Электронные конференции

□ comp.text.xml

Международная конференция, посвященная XML-технологиям.

□ fido7.ru.xml

Русская конференция, посвященная XML-технологиям.

Список литературы

1. Бен-Ари 2000

Бен-Ари М. Языки программирования. Практический сравнительный анализ. — М.: Мир, 2000. — 366 с.

2. Бредли 1998

Bradley N. The XML companion. — Addison Wesley Longman Limited, 1998. — 440 c.

3. Дейт 1999

Дейт К. Введение в системы баз данных. — СПб.: Издательский дом "Вильямс", 1999. — 848 с.

4. Кей 2001

Kay М. XSLT Programmer's Reference. — WROX Press, 2001. — 939 с.

5. Кнут 2000

Кнут Д. Искусство программирования. Т. 1. Основные алгоритмы. — М.: Издательский дом "Вильямс", 2000. — 720 с.

6. Кормен и др. 2000

Кормен Т., Лейзерсон Ч., Ривест Р. Алгоритмы: построение и анализ. — М.: МЦНМО, 2000. — 960 с.

7. Мюнх 2000

Muench S. Building Oracle XML Applications. — O'Reilly & Associates, 2000. — 775 c.

Оглавление

Предисловие

  О чем эта книга?

  Для кого эта книга?

  Как работать с книгой?

  Структура книги

    Глава 1. Введение в XML

    Глава 2. Введение в XSLT

    Глава 3. Идея и модель языка XSLT

    Глава 4. Структура преобразования

    Глава 5. Шаблонные правила

    Глава 6. XPath-выражения

    Глава 7. Основные элементы XSLT

    Глава 8. Дополнительные элементы и функции языка XSLT

    Глава 9. Использование XSLT совместно с другими языками программирования

    Глава 10. Расширения языка XSLT

    Глава 11. Готовые решения

    Глава 12. Развитие технологий

    Приложение 1. Обзор XSLT-процессоров

    Приложение 2. Краткий справочник элементов и атрибутов XSLT

    Приложение 3. Краткий справочник функций XSLT и XPath

    Приложение 4. Интернет-ресурсы, посвященные XSLT

  Соглашения

    Расширенная форма Бэкуса-Наура

    Обозначения

  Благодарности

Глава 1 Введение в XML

  Что такое XML?

    Разметка документов

  XML снаружи и изнутри

    Конструкции XML

      Элемент

      Атрибут

      Инструкция по обработке

      Секции СDATA

      Комментарии (comments)

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

      Расширенные имена

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

      Декларация типа документа (DTD)

      Определение элемента

      Определение списка атрибутов

      Определение сущности

      Определение нотации

    Символьные данные в XML-документах

      Использование Unicode

      Коды некоторых символов Unicode

    Базовые продукции XML

    XML-документы с точки зрения спецификации

  Использование технологии XML

    SAX-парсеры

    DOM-парсеры

    Основные классы задач XML

      Создание новых языков

      Хранение данных

      Обмен данными и проекты интеграции

  Краткая история XML

Глава 2 Введение в XSLT

  Документ = Данные + Структура

  XSLT как язык

    Отсутствие "побочных" эффектов

    Расширения

  Преобразования снаружи

  Области применения XSLT

    XSLT в архитектуре клиент-сервер

      XSLT на стороне сервера

      XSLT на стороне клиента

    XSLT в Web-решениях

    XSLT при обмене данными

  История XSLT

Глава 3 Идея и модель языка XSLT

  Модель XML-документа

    Деревья

    Узлы дерева XML-документа

      Корневой узел

      Узлы элементов

      Узлы атрибутов

      Текстовые узлы

      Узлы пространств имен

      Узлы инструкций по обработке

      Узел комментария

      Сводная таблица характеристик узлов

    Ограничения модели XML-документа

    Порядок просмотра документа

  Типы данных

    Булевый тип (boolean)

    Численный тип (number)

    Строковый тип (string)

    Множество узлов (node-set)

    Результирующий фрагмент дерева (result tree fragment)

    Таблица преобразования типов

  Переменные

  Выражения

    Виды выражений

      Пути выборки

      Фильтрующие выражения

      Объединение множеств

      Арифметические операции

      Операции сравнения

      Логические операции

      Функции

    Контекст вычисления выражений

  Модель преобразования

    Контекст преобразования

    Выполнение преобразования

Глава 4 Структура преобразования

  Пространство имен XSLT

  Корневые элементы преобразования

    Элементы xsl:stylesheet и xsl:transform

  Упрощенные преобразования

  Модульная организация преобразования

    Включение преобразований

    Элемент xsl:include

    Импорт преобразований

    Элемент xsl:import

      Порядок импорта

    Использование сущностей для разбивки на модули

  Совместное использование преобразований и XML-документов

    Ассоциация преобразования с XML-документом

    Объединение документа и преобразования

      Включение преобразования в документ

      Включение документа в преобразование

  Литеральные элементы результата

    Атрибуты языка XSLT в литеральных элементах

  Шаблоны значений атрибутов

Глава 5 Шаблонные правила

  Преобразование как набор правил

  Определение шаблонного правила

    Элемент xsl:template

  Вызов шаблонных правил

    Элемент xsl:apply-templates

  Режимы

  Именованные шаблоны

    Элемент xsl:call-template

  Встроенные шаблоны

  Идентичное преобразование

  Разрешение конфликтов в шаблонах

    Элемент xsl:apply-imports

  Тело шаблона

  Переменные и параметры

    Элемент xsl:variable

    Область видимости переменных

    Использование переменных

  Параметры

    Элемент xsl:param

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

    Элемент xsl:with-param

Глава 6 XPath-выражения

  Выражения для XML-документов

    Контекст вычисления выражений

    Пути выборки

      Шаги выборки

      Оси навигации

      Тесты узлов

      Предикаты

      Сокращенный синтаксис

      Примеры путей выборки

    Паттерны

      Семантика паттернов

      Примеры паттернов

  Выражения

    Переменные

    Операции с булевыми значениями

    Операции с числами

      Арифметические операции

      Операции сравнения

    Операции с множествами узлов

      Фильтрация

      Использование в выражениях путей выборки

      Объединение множеств

    Старшинство операций

  Функции

    Булевые функции Функция boolean

      Функция not

      Функции true и false

      Функция lang

    Числовые функции

      Функция number

      Функция sum

      Функции floor и ceiling

      Функция round

    Строковые функции

      Функция string

      Функция concat

      Функция starts-with

      Функция contains

      Функция substring-before

      Функция substring-after

      Функция substring

      Функция string-length

      Функция normalize-space

      Функция translate

    Функции множеств узлов

      Функции last и position

      Функция count

      Функции local-name, namespace-uri и name

      Функция id

  Базовые продукции XPath

    Разбор XPath-выражений

Глава 7 Основные элементы XSLT

  Основные и дополнительные элементы

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

    Элемент xsl:element

  Создание узлов атрибутов

    Элемент xsl:attribute

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

    Элемент xsl:attribute-set

    Атрибут xsl:use-attribute-sets

  Создание текстовых узлов

    Элемент xsl:text

    Элемент xsl:value-of

  Создание узлов комментариев и инструкций по обработке

    Элемент xsl:comment

    Элемент xsl:processing-instruction

  Копирование узлов

    Элемент xsl:copy

    Элемент xsl:copy-of

  Условная обработка

    Элемент xsl:if

    Элементы xsl:choose, xsl:when, xsl:otherwise

  Циклическая обработка

    Элемент xsl:for-each

Глава 8 Дополнительные элементы и функции языка XSLT

  Дополнительные элементы и функции

  Обработка пробельных символов

    Элементы xsl:preserve-space и xsl:strip-space

  Сообщения процессора

    Элемент xsl:message

  Сортировка

    Элемент xsl:sort

  Псевдонимы пространств имен

    Элемент xsl:namespace-alias

  Ключи

    Элемент xsl:key

    Функция key

    Определение множества ключей

    Использование нескольких ключей в одном преобразовании

    Использование нескольких определений одного ключа

    Использование множеств узлов в функции key

    Использование ключей в нескольких документах

    Составные ключи

    Функция key в паттернах

  Нумерация

    Элемент xsl:number

      Вычисление номеров

      Форматирование номеров

  Форматирование чисел

    Функция format-number

    Элемент xsl:decimal-format

  Контроль вывода документа

    Элемент xsl:output

      Метод вывода "xml"

      Метод вывода "html"

      Метод вывода "text"

      Другие методы вывода

    Замена специальных символов

    Кодировки в XSLT-преобразованиях

  Случай нескольких входящих документов

    Функция document

      Вызов document(string)

      Вызов document(node-set)

      Вызов document(string, node-set)

      Вызов document(node-set, node-set)

  Другие дополнительные функции XSLT

    Функция current

    Функция unparsed-entity-uri

    Функция generate-id

    Функция system-property

Глава 9 Совместное использование XSLT с другими языками программирования

  XSLT и другие языки

  Выполнение XSLT-преобразований в Object Pascal

    Импорт MSXML в Delphi

    Форма проекта

    Использование DOMDocument

  Выполнение XSLT-преобразований в C/C++

    Настройка путей

    Использование класса XalanTransformer

  Выполнение XSLT-преобразований в PHP

    Страница гостевой книги

  Выполнение XSLT-преобразований в JavaScript

  Выполнение XSLT-преобразований в VBScript/ASP

  Выполнение XSLT-преобразований в Python

  Выполнение XSLT-преобразований в PL/SQL

  Выполнение XSLT-преобразований в Java

  Краткие выводы

Глава 10 Расширения языка XSLT

  Что такое расширения?

  Функции расширения

    Функция function-available

    Функция расширения nodeset

  Элементы расширения

    Функция element-available

    Элемент xsl:fallback

  Инициатива EXSLT

Глава 11 Готовые решения

  Группировка

  Перечисление узлов

  Именованный шаблон как функция

  Рекурсия

  Циклы

    Цикл while

    Цикл for

    Метод Пиза для for-цикла

  Операции над множествами

  Перенос строк и элементы BR

  Данные, разделенные запятыми (CSV)

Глава 12 Развитие технологий

  Отличия XSLT 1.1 от XSLT 1.0

    Отсутствие result tree fragment

    Несколько выходящих документов

    Дополнительные возможности по расширению

    "Внешние" типы данных

    Стандартные интерфейсы расширений

    Другие изменения

  Отличия XSLT 2.0 от XSLT 1.1

    Изменения в XPath 2.0

    Выбор шаблонов для элементов пространства имен, определенного по умолчанию

    Средства для форматирования даты и времени

    Функции id и key на внешних документах

    Включение неразбираемых внешних сущностей в виде текста

    Использование именованных сущностей вместо кодов символов

    Обращение ссылок по ID/IDREF

    Другие требования

Приложение 1 Обзор XSLT-процессоров

  Популярность XSLT-процессоров

  Производительность XSLT-процессоров

  Библиотека Microsoft XML Parser

    Использование

    Расширения

  Процессор Xalan

    Использование

    Расширения

  Процессор Saxon

    Использование

    Расширения

  Библиотека Oracle XDK

    Использование

    Расширения

  Процессор Sablotron

    Использование

  Процессор xt

    Использование

    Расширения

  Библиотека libxslt

    Использование

    Расширения

Приложение 2 Краткий справочник элементов и атрибутов XSLT

  Обозначения

  Элементы

  Атрибуты

Приложение 3 Краткий справочник функций XSLT и XPath

  Обозначения

  Функции

Приложение 4 Интернет-ресурсы, посвященные XSLT

  Зарубежные интернет-ресурсы по XSLT

  Русскоязычные ресурсы

  Технические рекомендации и стандарты

  Переводы стандартов на русский язык

  Другие ресурсы

    Списки рассылки

    Электронные конференции

Список литературы