Глава 5 Шаблонные правила
Преобразование как набор правил
В предыдущих главах мы уже упомянули о том, что преобразование в XSLT состоит не из последовательности действий, а из набора шаблонных правил, каждое из которых обрабатывает свою часть XML-документа. Эта глава целиком посвящена вопросам создания и использования шаблонных правил, однако, прежде чем мы приступим к их рассмотрению, хотелось бы пояснить, почему же все-таки правила, а не действия.
Дело в том, что структуры XML-документов (даже принадлежащих одной логической схеме) могут быть настолько разнообразны, что создание императивной программы, которая выполняла бы их преобразование, является очень сложной задачей. Возможность включения или исключения тех или иных элементов, наличие или отсутствие атрибутов, да и неопределенность самой структуры документа в конечном итоге приводят к экспоненциальному увеличению количества операторов ветвления, циклов и так далее. Программа становится большой, сложной и малопонятной.
В то же время само преобразование может быть очень простым. Не понимая, что нужно сделать, чтобы преобразовать документ целиком, тем не менее, можно хорошо понимать, как следует обработать каждую из его частей.
Вследствие этого, язык XSLT был создан декларативным: вместо того, чтобы определять последовательность действий, программа в XSLT декларирует правила преобразования. Каждое из этих правил может в свою очередь вызывать другие правила, таким образом обеспечивая обработку документов сколь угодно сложной структуры.
Определение шаблонного правила
Элемент xsl:template
Синтаксис этого элемента приведен ниже:
match="пaттерн"
name="имя"
priority="число"
mode="имя">
Элемент верхнего уровня
xsl:template
определяет в преобразовании шаблонное правило, или просто шаблон. Элемент xsl:template
имеет всего четыре атрибута, смысл которых мы кратко опишем ниже.
Атрибут
match
задает паттерн — образец узлов дерева, для преобразования которых следует применять этот шаблон.
Пример
В этом правиле атрибут
match
говорит о том, что оно должно использоваться для обработки элементов bold
— в данном случае они будут заменяться на элементы b
. Шаблоны, в которых определен атрибут match
, вызываются при помощи инструкции xsl:apply-templates
.
Шаблон также может иметь имя, определяемое атрибутом
name
. Шаблон, в котором задано имя, называется именованным шаблоном. Именованные шаблоны могут вызываться вне зависимости от текущего контекста, и даже вести себя как функции — принимать на вход параметры и возвращать некоторые значения.
Пример
В отличие от предыдущего примера, это правило не будет обрабатывать какие-либо определенные узлы. Вызвать его можно будет только по имени посредством элемента
xsl:call-template
.
При определении шаблона нужно обязательно указать хотя бы один из атрибутов
match
или name
, причем эти атрибуты могут присутствовать в xsl:template
одновременно.
Атрибут
mode
определяет режим данного шаблонного правила. Режимы позволяют задавать различные преобразования для одних и тех же частей документа (о них мы поговорим позже).
Атрибут
priority
используется для определения значения, которое называется приоритетом шаблонного правила. Это значение используется для разрешения конфликтов шаблонов в случае, когда один узел может быть обработан различными правилами.
Атрибуты шаблонного правила не влияют на выполнение его содержимого. Они используются элементами
xsl:apply-templates
и xsl:call-template
при выборе шаблонов. Правила, которые были импортированы в преобразование, вызываются элементом xsl:apply-imports
.
Элемент xsl:template
Синтаксис этого элемента приведен ниже:
match="пaттерн" name="имя" priority="число" mode="имя"> Элемент верхнего уровня
xsl:templatexsl:templateАтрибут
match В этом правиле атрибут
matchboldbmatchxsl:apply-templatesШаблон также может иметь имя, определяемое атрибутом
name В отличие от предыдущего примера, это правило не будет обрабатывать какие-либо определенные узлы. Вызвать его можно будет только по имени посредством элемента
xsl:call-templateПри определении шаблона нужно обязательно указать хотя бы один из атрибутов
matchnamexsl:templateАтрибут
modeАтрибут
priorityАтрибуты шаблонного правила не влияют на выполнение его содержимого. Они используются элементами
xsl:apply-templatesxsl:call-templatexsl:apply-imports
Вызов шаблонных правил
Рассмотрим следующий простой пример.
Листинг 5.1. Входящий документ
text
Попробуем написать пару шаблонов, которые будут изменять имена элементов
para
и bold
на p
и b
соответственно. Сначала напишем преобразование для bold
:
В этом правиле создается элемент
b
, в который включается текстовое значение текущего узла (то есть, обрабатываемого элемента bold
). Применив это преобразование к входящему документу, мы получим следующий результат:
text
Как говорят математики, что и требовалось. Попробуем проделать тот же трюк с элементом
para
и создадим преобразование, включающее оба правила.
Листинг 5.2. Преобразование с para и bold — версия 1
version="1.0"
xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
На этот раз вместо ожидаемого результата вида
text
мы получим
text
Попробуем ответить на три вопроса: кто виноват, что делать и куда делся элемент
b
.
Для ответа на вопрос, куда делся элемент
b
, пожалуй, необходимо будет пояснить, что же именно происходит при преобразовании этого документа. Последовательно рассмотрим стадии этого процесса.
□ Процессор начинает обработку с корневого узла дерева. Он выбирает шаблон, соответствующий этому узлу. В нашем преобразовании такого шаблона нет, значит, процессор применит к корню шаблонное правило, определенное по умолчанию (см. раздел "Встроенные шаблоны" данной главы).
□ По умолчанию шаблонное правило корневого узла обрабатывает все дочерние узлы. В нашем документе единственным дочерним узлом корня будет элемент
para
.
□ Для элемента
para
в нашем преобразовании задан шаблон, который и будет применен к этому элементу.
□ В соответствии с этим шаблоном, процессор создаст элемент
p
и включит в него текстовое значение выражения ".
". Как мы знаем, выражение ".
" является сокращенной формой выражения "self::node()
", которое возвратит текущий узел. Таким образом, элемент
вычислит и возвратит строковое значение текущего узла, то есть узла para
. Строковым значением элемента является конкатенация всех его текстовых потомков. Единственным текстовым потомком нашего para является текстовый узел со значением "text
" и вот он-то и выводится между открывающим и закрывающим тегами созданного элемента p
.
Таким образом, элемент
b
"потерялся" потому, что шаблон для bold
просто не вызывался. Виноваты, естественно, мы сами, поскольку не включили его вызов. Осталось только разобраться, как можно вызвать шаблон для обработки элемента bold
.
Ответ на этот вопрос предельно прост — для вызова неименованных шаблонных правил В XSLT используется элемент
xsl:apply-templates
.
Элемент xsl:apply-templates
Синтаксис этого элемента выглядит следующим образом:
select="выражение"
mode="режим">
Элемент
xsl:apply-templates
применяет шаблонные правила к узлам, которые возвращаются выражением, указанным в атрибуте select
. Если атрибут select
опущен, то xsl:apply-templates
применяет шаблонные правила ко всем дочерним узлам текущего узла, то есть
равносильно
Атрибут
mode
используется для указания режима, в котором должны применяться шаблоны — мы поговорим о различных режимах чуть позже.
Прежде чем двигаться дальше, опишем более подробно, что означает "применить шаблон" (англ. apply — применить, template — шаблон). Применение шаблонов — это составная часть обработки документа, которая может быть описана следующим порядком действий.
□ На первом шаге процессор вычисляет выражение, указанное в атрибуте
select
. Его значением должно быть множество узлов. Полученное множество узлов упорядочивается и становится текущим списком узлов контекста преобразования.
□ Для каждого из узлов этого списка процессор находит наиболее подходящий шаблон для обработки. Процессор делает этот узел текущим и затем выполняет в измененном контексте выбранное шаблонное правило.
□ Дерево, которое является результатом выполнения шаблона, добавляется в выходящее дерево.
Применительно к нашему примеру с
para
и bold
, мы можем изменить преобразование так, что в создаваемый элемент p будет включаться не текстовое значение элемента para, а результат обработки его дочерних узлов.
Листинг 5.3. Преобразование с para и bold — версия 2
version="1.0"
xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
Проследим за процессом выполнения этого преобразования.
□ Обработка начинается с корневого узла дерева. Для него нет заданных шаблонных правил, значит, применено будет правило по умолчанию — обработать все дочерние узлы. Множество дочерних узлов корня содержит единственный элемент
para
, значит, текущий список узлов контекста будет состоять из одного узла. Для него в преобразовании определен шаблон, который и будет выполнен процессором.
□ Шаблон, соответствующий элементу
para
, создает элемент p
, содержимым которого будет результат выполнения инструкции xsl:apply-templates
, то есть результат применения шаблонов к дочерним узлам текущего узла — элемента para
.
□ Единственным дочерним узлом элемента
para
является элемент bold
. Процессор изменит контекст так, что текущий список узлов будет содержать только элемент bold
и выполнит соответствующее шаблонное правило, которое создаст элемент b
и включит в него узел, вычисленный инструкцией
, то есть текстовый узел со строковым значением текущего узла, элемента bold
.
Три шага этого преобразования продемонстрированы на рис. 5.1.
Рис. 5.1. Процесс преобразования
Здесь слева показан текущий список узлов, посередине — дерево документа с выделенным пунктиром текущим узлом, справа — генерируемое выходящее дерево.
Результатом этого преобразования будет документ:
text
Рассмотрим чуть более сложное преобразование документа:
text1
text2
Порядок действий в этом случае будет приблизительно следующим.
□ Первым обрабатывается корневой узел. Процессор применяет шаблоны к дочерним узлам (вернее к одному дочернему узлу — элементу
para
).
□ Шаблон, обрабатывающий элемент para, создает в выходящем документе элемент p и применяет шаблоны к своим дочерним узлам — на этот раз их два,
bold
и para
.
□ Шаблон, обрабатывающий элемент
bold
, создает в выходящем документе элемент b
и текстовый узел со значением "text1
".
□ Шаблон, обрабатывающий элемент
para
, создает в выходящем дереве узел p
и применяет шаблоны к дочерним узлам.
□ Единственным дочерним узлом элемента
para
является элемент bold
.
□ Шаблон, обрабатывающий этот элемент
bold
, создает в выходящем документе элемент b
и текстовый узел со значением "text2
".
Процесс преобразования показан на рис. 5.2.
Рис. 5.2. Процесс преобразования
Результатом этого преобразования будет документ:
text1
text2
Атрибут
select
элемента xsl:apply-templates
позволяет выбирать, к каким именно узлам будет применяться этот шаблон. Значение select
— это XPath-выражение, которое должно возвращать множество узлов. В случае, если атрибут select
указан, шаблоны будут поочередно применяться к каждому из узлов выбранного множества.
Пример
Если при обработке элементов para мы хотим обрабатывать только дочерние элементы
bold
и никакие другие, шаблон обработки элементов para
будет записан следующим образом:
Результатом обработки документа
text1
text2
будет теперь
text1
Элемент
para
, который во входящем документе включен в другой элемент para
, не будет обработан по той простой причине, что он не вошел во множество, выбранное XPath-выражением "bold
". В то же время, если мы запишем
то результат будет таким же, как и прежде:
text1
text2
Следует хорошо понимать разницу между атрибутом
select
элемента xsl:apply-templates
и атрибутом match
элемента xsl:template
. Атрибут match
содержит не XPath-выражение, а паттерн XSLT; в отличие от атрибута select в xsl:apply-templates
он не выбирает никакого множества узлов, он используется только для того, чтобы проверить, может ли данный узел обрабатываться этим шаблоном или нет.
Атрибут
select
элемента xsl:apply-templates
наоборот, содержит не паттерн, а выражение, единственным требованием к которому является то, что оно должно возвращать множество узлов. Например, некорректным будет определение вида
поскольку выражение
para+1
не может возвратить множество узлов.
Кроме этого требования, никаких других ограничений на выражения в этом атрибуте нет. В нем можно использовать переменные, содержащие множества узлов, функции, возвращающие множества узлов (например, такие, как
id
или key
), выражения с операциями над множествами (именно таким выражением — выражением объединения было выражение bold|para
), пути выборки, фильтрующие выражения, в общем, любые выражения, которые только могут возвращать множества. Например, для того, чтобы обработать содержимое произвольного внешнего XML-документа, в атрибуте select
элемента xsl:apply-template
следует использовать функцию document
.
Пример
Объявление вида
применит шаблоны ко всем элементам
para
документа a.xml
.
Рассмотрим следующий простой пример.
text Попробуем написать пару шаблонов, которые будут изменять имена элементов
paraboldp bboldВ этом правиле создается элемент
bboldtextКак говорят математики, что и требовалось. Попробуем проделать тот же трюк с элементом
para version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
На этот раз вместо ожидаемого результата вида
text
textПопробуем ответить на три вопроса: кто виноват, что делать и куда делся элемент
bДля ответа на вопрос, куда делся элемент
b□ Процессор начинает обработку с корневого узла дерева. Он выбирает шаблон, соответствующий этому узлу. В нашем преобразовании такого шаблона нет, значит, процессор применит к корню шаблонное правило, определенное по умолчанию (см. раздел "Встроенные шаблоны" данной главы).
□ По умолчанию шаблонное правило корневого узла обрабатывает все дочерние узлы. В нашем документе единственным дочерним узлом корня будет элемент
para□ Для элемента
para□ В соответствии с этим шаблоном, процессор создаст элемент
p..self::node()paratextpТаким образом, элемент
bboldboldОтвет на этот вопрос предельно прост — для вызова неименованных шаблонных правил В XSLT используется элемент
xsl:apply-templatesЭлемент xsl:apply-templates
Синтаксис этого элемента выглядит следующим образом:
select="выражение" mode="режим"> Элемент
xsl:apply-templatesselectselectxsl:apply-templatesравносильно
Атрибут
modeПрежде чем двигаться дальше, опишем более подробно, что означает "применить шаблон" (англ. apply — применить, template — шаблон). Применение шаблонов — это составная часть обработки документа, которая может быть описана следующим порядком действий.
□ На первом шаге процессор вычисляет выражение, указанное в атрибуте
select□ Для каждого из узлов этого списка процессор находит наиболее подходящий шаблон для обработки. Процессор делает этот узел текущим и затем выполняет в измененном контексте выбранное шаблонное правило.
□ Дерево, которое является результатом выполнения шаблона, добавляется в выходящее дерево.
Применительно к нашему примеру с
parabold version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
Проследим за процессом выполнения этого преобразования.
□ Обработка начинается с корневого узла дерева. Для него нет заданных шаблонных правил, значит, применено будет правило по умолчанию — обработать все дочерние узлы. Множество дочерних узлов корня содержит единственный элемент
para□ Шаблон, соответствующий элементу
parapxsl:apply-templatespara□ Единственным дочерним узлом элемента
paraboldboldbboldТри шага этого преобразования продемонстрированы на рис. 5.1.
Рис. 5.1. Процесс преобразования
Здесь слева показан текущий список узлов, посередине — дерево документа с выделенным пунктиром текущим узлом, справа — генерируемое выходящее дерево.
Результатом этого преобразования будет документ:
text
Рассмотрим чуть более сложное преобразование документа:
text1 text2 Порядок действий в этом случае будет приблизительно следующим.
□ Первым обрабатывается корневой узел. Процессор применяет шаблоны к дочерним узлам (вернее к одному дочернему узлу — элементу
para□ Шаблон, обрабатывающий элемент para, создает в выходящем документе элемент p и применяет шаблоны к своим дочерним узлам — на этот раз их два,
boldpara□ Шаблон, обрабатывающий элемент
boldbtext1□ Шаблон, обрабатывающий элемент
parap□ Единственным дочерним узлом элемента
parabold□ Шаблон, обрабатывающий этот элемент
boldbtext2Процесс преобразования показан на рис. 5.2.
Рис. 5.2. Процесс преобразования
Результатом этого преобразования будет документ:
text1 text2 Атрибут
selectxsl:apply-templatesselectselectЕсли при обработке элементов para мы хотим обрабатывать только дочерние элементы
boldpara
Результатом обработки документа
text1 text2 будет теперь
text1Элемент
paraparabold
то результат будет таким же, как и прежде:
text1 text2 Следует хорошо понимать разницу между атрибутом
selectxsl:apply-templatesmatchxsl:templatematchxsl:apply-templatesАтрибут
selectxsl:apply-templatesпоскольку выражение
para+1Кроме этого требования, никаких других ограничений на выражения в этом атрибуте нет. В нем можно использовать переменные, содержащие множества узлов, функции, возвращающие множества узлов (например, такие, как
idkeybold|paraselectxsl:apply-templatedocumentОбъявление вида
применит шаблоны ко всем элементам
paraa.xmlРежимы
Очень часто в преобразованиях требуется обрабатывать одни и те же узлы, но разными способами. Типичным примером такого рода задачи является генерация оглавления документа вместе с преобразованием его содержимого. Очевидно, что просто шаблонами здесь не обойтись, и чтобы не получить другой результат, нужно каким-то образом указывать, что по-другому должна вестись и обработка.
Эта проблема решается в XSLT просто и элегантно. Атрибут
modexsl:apply-templatesxsl:apply-templatesВ качестве примера приведем преобразование, которое добавляет в XHTML-файл перечень текстовых ссылок, обнаруженных в этом документе. Грубо говоря, XHTML — это XML-версия языка HTML, а значит XSLT вполне подходит для обработки XHTML-документов.
URI пространства имен языка XHTML —
"http://www.w3.org/1999/xhtml"xhtml 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"> ...Начнем с шаблона, который будет выводить каждую из ссылок. В каждой ссылке мы будем выводить только ее атрибут
hrefbr
Мы чуть позже познакомимся с элементами
xsl:copyxsl:copy-ofxsl:text копирует в выходящий документ текущий узел, его атрибут
href@hreftext()Элемент
Следующее преобразование называется идентичным преобразованием — оно просто копирует все узлы один в один:
И, наконец, нам понадобится преобразование для элемента
body Links found on this page:
select=".//xhtml:a[@href and not(xhtml:*)]"> Если мы попытаемся выполнить преобразование, состоящее из этих шаблонов, мы обнаружим, что в тексте самого документа ссылки испортились — там тоже добавились элементы
brДля исправления этой ошибки мы выделим шаблон обработки ссылок в отдельный режим
links ...Теперь это правило не будет применяться к ссылкам во время копирования содержимого документа, потому что при выполнении инструкции
режим будет пустым, значит шаблон для
xhtml:аxsl:apply-templatesmode select=".//xhtml:a[@href and not(xhtml:*)]" mode="links"> Разберем более подробно это определение. Данная инструкция будет применять шаблоны с режимом
links".//xhtml:a[@href and not (xhtml:*)]"".//xhtml:a[@href and not(xhtml:*)]".//xhtmlаxhtml:ahref[@href and not (xhtml:*)]Преобразование целиком будет иметь следующий вид.
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"> Links found on this page:
Применив это преобразование, например, к главной странице Консорциума W3 (http://www.w3.org), мы получим ее точный дубликат, в конце которого будет приведен перечень всех найденных текстовых ссылок. Выходящий документ будет заканчиваться фрагментом вида:
Links found on this page:
About W3C
Accessibility
Activities
и так далее.
Заметим, что того же эффекта можно было добиться другими способами, например, при помощи именованных шаблонов или элемента
xsl:for-eachДосадным ограничением режимов является то, что режим нельзя выбирать динамически. Атрибут
modeбудет некорректным. Особо серьезных практических противопоказаний для динамических режимов нет, будем надеяться, что в следующих версиях XSLT они появятся.
Именованные шаблоны
Вместо того чтобы при помощи атрибута
match
указывать, какая часть входящего документа должна преобразовываться данным шаблоном, ему можно присвоить имя и вызывать в любой момент вне зависимости от контекста преобразования. Такие шаблоны очень схожи по принципу с процедурами в императивных языках программирования — они позволяют выносить часто используемые части преобразований, передавать им параметры и вызывать вне зависимости от того, что именно обрабатывается в данный момент.
Имя шаблонному правилу присваивается атрибутом name элемента
xsl:template
. После этого шаблону более необязательно иметь атрибут match
, теперь он может быть вызван просто по имени. Два шаблона с одним порядком импорта не могут иметь одинаковых имен. Если же одинаковые имена имеют шаблоны различного порядка импорта, шаблоны старшего порядка переопределяют младшие шаблоны
Пример
При генерации HTML-страниц часто встречающейся задачей является создание элемента
head
. Элемент head
, как правило, содержит несколько элементов meta
, предоставляющих метаинформацию, элемент title
, который определяет название страницы и элемент link
, который связывает данную страницу с другими документами, например, с каскадными таблицами стилей (CSS).
Для того чтобы упростить процедуру генерации
head
, мы можем вынести ее в отдельный именованный шаблон.
Листинг 5.5. Именованный шаблон для генерации элемента head
content="This site is dedicated to XSLT and Xpath."/>
XSLTdev.ru - XSLT developer resource
Думается, этот шаблон не требует пояснений — он просто создает в входящем документе несколько элементов. Непонятным пока остается другое — как вызывать именованные шаблоны? Элемент
xsl:apply-templates
явно не подходит, поскольку именованные шаблоны не обязаны иметь атрибут match
. Их выполнение производится элементом xsl:call-template
.
Элемент xsl:call-template
Приведем синтаксис этого элемента:
name="имя">
Обязательный атрибут name указывает имя шаблона, который вызывается этой инструкцией. Например, шаблон с именем "
head
", приведенный выше, может быть вызван следующим образом:
Атрибут
name
при вызове обязан иметь фиксированное значение — точно так же, как и в случае с mode
и xsl:apply-templates
, динамика здесь не разрешена.
При вызове
xsl:call-template
не изменяет контекста преобразования. Фактически, вызов именованного шаблона эквивалентен замене в тексте преобразования элемента xsl:call-template
на тело вызываемого шаблона.
Приведем пример.
Листинг 5.6. Входящий документ
Just a few words...
Листинг 5.7. Преобразование
version="1.0"
xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
content="This site is dedicated to XSLT and Xpath."/>
XSLTdev.ru - XSLT developer resource
Листинг 5.8. Выходящий документ
content="This site is dedicated to XSLT and Xpath.">
XSLTdev.ru - XSLT developer resource
Just a few words...
Примечание
Несколько более эффективным способом использования в документе статических частей (как содержимое элемента
head
в приведенном примере) является хранение этих частей во внешних документах и вставка их в выходящий документ при помощи элемента xsl:copy-of
и функции document
.
В этом примере шаблон, обрабатывающий корневой элемент, фактически эквивалентен шаблону вида:
content="This site is dedicated to XSLT and Xpath."/>
XSLTdev.ru - XSLT developer resource
В принципе именованные шаблоны не обязаны иметь атрибут
match
, но он все же может быть определен. В этом случае шаблон можно будет применять как для обработки частей документов элементом xsl:apply-templates
, так и вызывая его по имени элементом xsl:call-template
.
Пример
Изменим объявление нашего шаблона head следующим образом:
...
Теперь, если входящий документ будет иметь вид
Just a few words...
то результат выполнения следующих двух шаблонов будет одинаков.
Листинг 5.9. Шаблон для page — версия 1
Второе встроенное правило преобразования аналогично первому, с той лишь особенностью, что для каждого режима преобразования рекурсивная обработка происходит в том же самом режиме. В XSLT это правило выглядело бы следующим образом:
В XSLT также определяется встроенное правило для обработки текстовых узлов и атрибутов — это правило просто выводит их текстовые значения. Шаблон такого преобразования может быть записан в виде:
Четвертое правило касается обработки инструкций по обработке и комментариев. Это правило не делает ничего, то есть инструкции и комментарии просто опускаются в выходящем документе. Шаблон такого преобразования будет иметь вид
Последнее, пятое правило определяет обработку узлов пространств имен. Аналогично инструкциям и комментариям, с ними по умолчанию не следует делать ничего, то есть узлы пространств имен просто удаляются.
Встроенные шаблоны имеют наименьший приоритет импорта, а значит, будут использоваться лишь тогда, когда в преобразовании нет другого, более подходящего правила. Иными словами, любой шаблон, определенный в преобразовании, будет иметь больший приоритет, чем у встроенных правил.
Такое положение вещей позволяет переопределять преобразования, применяемые к узлам документа по умолчанию. Например, во многих случаях бывает весьма полезным идентичное преобразование, которое копирует узлы как есть. Мы уже встречались с ним, когда создавали шаблон для генерации таблицы ссылок XHTML-документа; теперь мы чуть более подробно разберем его работу.
Идентичное преобразование
Наличие в XSLT шаблонов, выполняемых по умолчанию, иногда приводит к тому, что процессоры ведут себя не совсем логично с человеческой точки зрения. Например, в простейшем случае может понадобиться переименовать все элементы с именами
bold
в элементы с именами b
. Однако результатом обработки документа
<а>
text a
text b
text c
преобразованием
version="1.0"
xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
будет документ вида
text a
text b
text c
Как можно заметить, в выходящем документе элементы
а
и с
"пропали", но при этом их содержимое осталось нетронутым. Все дело во встроенных шаблонах, которые по умолчанию рекурсивно обрабатывают содержимое элементов и копируют текстовые узлы, если иного не определено.
Для того чтобы избежать подобного рода казусов, можно использовать идентичное преобразование, которое в случае отсутствия шаблонов для обработки тех или иных узлов копирует их в выходящий документ как есть. Идентичное преобразование записывается в следующем виде.
Листинг 5.11. Идентичное преобразование
xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
Единственный шаблон этого преобразования при помощи элемента
xsl:copy
рекурсивно создает в выходящем документе копии узлов и атрибутов. На практике идентичное преобразование используется очень часто, и потому мы настоятельно рекомендуем сохранить его в отдельном файле и импортировать при потребности.
Поясним, что это преобразование выполняет не просто копирование документа (для этого было бы достаточно элемента
xsl:copy-of
). Идентичное преобразование переопределяет встроенные шаблоны; теперь, если для обработки какого-либо узла в преобразовании не определено подходящего шаблона, он вместе со всеми своими потомками будет скопирован в выходящий документ без изменений.
Идентичное преобразование очень полезно в тех случаях, когда требуется изменить только некоторые части документа, оставив остальное в неприкосновенности. Например, в предыдущем примере нам нужно было только переименовать все документы
bold
. Искомое преобразование, импортирующее идентичное преобразование из файла identity.xsl
, будет записано следующим образом.
Листинг 5.12
version="1.0"
xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
Результат будет иметь вид:
text a
text b
text c
Другим примером использования идентичного преобразования может послужить случай, когда нужно просто удалить из документа некоторые узлы. Например, нам необходимо избавиться от комментариев (быстро и без шума).
version="1.0"
xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
Разрешение конфликтов в шаблонах
Как правило, каждое преобразование в XSLT определяет, включает или импортирует множество шаблонов, которые обрабатывают указанные части документов. При этом один и тот же узел документа может соответствовать нескольким шаблонным правилам. К примеру, элемент
content
может быть обработан любым из следующих трех шаблонов.
Листинг 5.14. Конфликтующие шаблоны
Ситуация, когда для обработки узла может быть применено несколько правил, называется конфликтом шаблонов. Конфликты такого рода неизбежны практически в любом преобразовании, к примеру, большинство шаблонов будет вступать в конфликт со встроенными правилами преобразования.
Для того чтобы в конфликтной ситуации решить, какой именно из шаблонов должен быть применен к данному узлу, процессоры используют два простых правила.
□ Шаблоны, имеющие младший порядок импорта, исключаются из рассмотрения. Иными словами, из множества правил, подходящих для обработки текущего узла, остаются только правила, имеющие самый старший порядок импорта.
□ Из оставшегося множества выбирается шаблон с наивысшим приоритетом. Если таких шаблонов несколько, процессор может либо выдать ошибку, либо применить тот, который описан в преобразовании последним.
Во втором из этих двух правил, мы встретились с понятием приоритета шаблона. Приоритет шаблона это не что иное, как численное значение, которое может быть указано в атрибуте
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('арр')
— выбор дочерних инструкций по обработке, которые имеют вид
;
•
@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. Преобразование
version="1.0"
xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
xmlns:a="a">
1
2
3
4
5
template matched
.
Пять шаблонов этого преобразования могут соответствовать одним и тем же узлам, а значит, создавать множество конфликтов, которые будут разрешаться при помощи механизма приоритетов.
Приоритет первого шаблона, паттерн которого соответствует продукции QName, будет равен
0
. Приоритет второго шаблона будет равен 0.5
, поскольку его паттерн не удовлетворяет другим условиям. Паттерн третьего шаблона имеет вид NCName:*
, а значит, его приоритет равен -0.25
. Приоритет четвертого шаблона равен -0.5
, поскольку его паттерн является проверкой узла (NodeTest
). Приоритет последнего, пятого шаблона будет равен 0, поскольку паттерн b
соответствует продукции QName
.
Попробуем применить это преобразование к следующему документу:
Проследим за тем, как будет выполняться преобразование.
□ Инструкции по обработке
,
которая идет в документе первой, соответствует только один, четвертый шаблон.
□ Корневому элементу
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
. Например, если бы в предыдущем преобразовании четвертый шаблон был определен в виде
4
то его приоритет был бы выше, чем у всех остальных шаблонов, а поскольку он соответствует всем узлам в обрабатываемом документе, то во всех случаях применялся бы только он один. Сообщения процессора имели бы вид
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. Основное преобразование
xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
version="1.0"
xmlns:a="a">
1
2
3
5
Листинг 5.17. Преобразование b.xsl
xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
version="1.0"
xmlns:a="a">
4
template matched
.
Как уже было сказано ранее, четвертое преобразование, вынесенное теперь в импортируемый модуль, при разрешении конфликтов шаблонов будет самым младшим вследствие того, что порядок его импорта меньше, чем у других преобразований. Сообщения процессора будут иметь вид
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
можно использовать в шаблонах для применения правил, которые были импортированы во внешних модулях, но затем переопределены шаблонами основного преобразования.
Пример
Предположим, что в преобразованиях часто используется шаблон, который заменяет элементы
home
ссылками на сайт http://www.xsltdev.ru:
<а href="http://www.xsltdev.ru">www.xsltdev.ru
При необходимости этот шаблон может быть переопределен. К примеру, ссылка может выглядеть как
Visit <а href="http://www.xsltdev.ru">www.xsltdev.ru
Соответственно, шаблон будет иметь вид
Visit
www.xsltdev.ru
Можно заметить, что оба шаблона имеют общую часть, которая выводит гипертекстовую ссылку. Эта часть может быть вынесена во внешнее преобразование
home.xsl
.
Листинг 5.18. Преобразование home.xml
xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
www.xsltdev.ru
Для того чтобы использовать внешний шаблон, основное преобразование должно импортировать его при помощи
xsl:import
и применять посредством xsl:apply-imports.
Листинг 5.19. Основное преобразование base.xsl
xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
version="1.0">
Visit
Элемент
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 "www.xsltdev.ru";
}
}
Листинг 5.21. Класс base
public class base extends home {
public String home() {
return ("Visit " + super.home());
}
}
В этом примере вызов родительского метода
super.home()
соответствует применению элементом xsl:apply-imports
импортированного шаблона.
Тело шаблона
Фактически, элемент
xsl:template
, определяющий шаблонное правило, задает не более чем условия, при которых это правило должно выполняться. Конкретные же действия и инструкции, которые должны быть исполнены, определяются содержимым элемента xsl:template
и составляют тело шаблона.
Пример
Тело следующего шаблона (выделенное полужирным шрифтом):
Комментарии
состоит из литерального элемента
body
, текстового узла и элемента xsl:copy-of
. При выполнении этого шаблона элемент body
будет выведен как есть (при этом содержимое его будет вычислено); текстовый узел будет скопирован в выходящее дерево; элемент xsl:copy-of
будет заменен множеством дочерних комментариев текущего узла.
Следует заметить, что текстовый узел в данном случае состоит не только из строки "Комментарии". Он включает также все пробельные символы и символы переноса строки.
Тело шаблона может быть также и пустым. В этом случае результат обработки узлов, соответствующих этому шаблону будет пустым. Например, если в преобразовании содержится шаблон вида
то каждый раз, встретив узел комментария и обрабатывая его этим правилом, процессор будет получать пустой результат. Таким образом, используя пустые шаблоны совместно с идентичным преобразованием можно добиться эффекта удаления определенных узлов из шаблона, как это было показано ранее в этой главе.
Тело шаблона может содержать любые текстовые узлы, комментарии, инструкции по обработке и литеральные элементы результата при условии, что не будет нарушен синтаксис 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
, то есть, строго говоря, определение
Text
будет некорректным. На самом деле многие процессоры игнорируют эту ошибку, вполне разумно считая, что ничего смертельного в ней нет. Но, конечно, лучше использовать стандартный вариант:
Text
Переменные и параметры
Было бы слишком просто и слишком бесполезно лишь констатировать, что переменные и параметры в XSLT похожи между собой и сильно отличаются от переменных в других языках программирования. Мы попытаемся разобраться в этом вопросе несколько глубже — чем именно и ради чего конкретно переменные в XSLT обладают такими свойствами.
В классической книге Монти Бен-Ари "Языки программирования" [Бен-Ари 2000] приводится следующее определение переменной:
Переменная — это имя, присвоенное ячейке памяти или ячейкам, которые могут содержать представление конкретного типа (данных).
Затем следует комментарий:
Значение может изменяться во время выполнения программы.
Если немного сменить уровень абстракции, первая часть этого определения верна и по отношению к параметрам, и переменным XSLT (далее мы будем говорить просто "переменные", поскольку различия между ними на данный момент несущественны). Конечно, где-то там внутри реализации конкретного XSLT-процессора есть память, поделенная на ячейки, в которой процессор хранит информацию. Такие детали нас, естественно, не интересуют, ибо мы больше рассуждаем о логических, чем о физических моделях. В логической же модели переменная представляется как объект определенного типа, с которым связано имя, — по этому имени мы можем обращаться к объекту, использовать его значение и так далее. Иными словами, в XSLT под переменной понимается не более чем ассоциация между значением и именем, и если мы вдруг скажем, что переменная
x
имеет значение 5
, это будет означать, что имя "x
" связано объектом численного типа, значение которого равно 5
. Заметим небольшую разницу с определением Бен-Ари: мы не говорим о том, что число 5
лежит в какой-то ячейке памяти (хотя, несомненно, оно так и есть) и что этой ячейке присвоено имя "x
" — мы говорим об ассоциации между объектом и именем и только.
Теперь, когда более или менее ясно, что же мы имеем в виду под переменными, на новой строчке полужирным шрифтом напишем следующее:
Переменные в XSLT не могут быть изменены.
Разработчикам, которые использовали в своей практике только процедурные языки и не имеют опыта функционального или логического программирования будет очень нелегко смириться с такой ситуацией. То, что переменные не могут быть изменены дискредитирует само название — переменные, ибо они уже более похожи на константы.
Практически во всех процедурных языках оператор присваивания вида
переменная = выражение
с незначительными вариациями работает приблизительно следующим образом:
□ сначала вычисляется присваиваемое выражение;
□ затем вычисляется адрес переменной;
□ затем значение, полученное на первом шаге, копируется в ячейки памяти, начиная с адреса, полученного на втором шаге присваивания.
В XSLT нет оператора присваивания. Переменным и параметрам никогда не присваиваются значения в приведенном выше смысле, объявление переменной или параметра лишь связывает указанное имя со значением некоторого выражения. Иными словами, объявление переменной есть создание ассоциации между объектом и именем.
В конце этой главы мы вернемся к неизменяемым переменным и попытаемся объяснить, почему их нельзя изменить — но прежде мы должны научиться их использовать.
Элемент xsl:variable
Синтаксис этого элемента в XSLT определен так:
name="имя"
select="выражение">
Для объявления переменных в 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
следующим образом:
version="1.0"
xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
...
...
Несложно видеть, что здесь мы определили глобальную переменную, а значит, ее значение можно использовать в преобразовании в любом месте. Например, мы можем определить через нее другие глобальные переменные, либо использовать в шаблоне:
version="1.0"
xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
...
...
Причем, как уже было сказано, глобальная переменная может быть использована и до объявления: в нашем случае переменная
leaf
определяется через переменную ID
, a path
— через leaf
. Конечно же, не следует забывать и то правило, что переменные не могут объявляться посредством самих себя, явно или неявно. Очевидно, что объявление:
было бы некорректным ввиду явного использования переменной при собственном определении. Точно так же были бы некорректны определения:
поскольку переменная
ID
определяется через переменную id
, которая определяется через переменную ID
и так до бесконечности.
Дела с локальными переменными обстоят чуть-чуть сложнее. Для того чтобы объяснить, что же такое область видимости, обратимся к следующему преобразованию.
Листинг 5.22. Преобразование, использующее переменные i, j, k и gt
version="1.0"
xmlns:xsl="... ">
name="i"
select="2"/>
name="j"
select="$i - 1"/>
is greater than
В этом преобразовании определены три локальные переменные —
i
, j
и k
и одна глобальная переменная — gt
. На следующих четырех листингах мы выделим серой заливкой область видимости переменной (то есть область, где ее можно использовать), а само определение переменной отметим полужирным шрифтом.
Листинг 5.23. Области видимости переменных i, j, k и gt
Область видимости переменной
i
Область видимости переменной j
version="1.0" xmlns:xsl="... "> version="1.0" xmlns:xsl="... ">
select="2"/> select="2"/>
select="$i - 1"/> select="$i - 1"/>
is greater than is greater than
Область видимости переменной
k
Область видимости переменной gt
version="1.0" xmlns:xsl="... "> version="1.0" xmlns:xsl="... ">
select="2"/> select="2"/>
select="$i - 1"/> select="$i - 1"/>
is greater than is greater than
В XSLT действует то же правило, что и во многих других языках программирования: нельзя дважды определять переменную с один и тем же именем. Однако и тут есть свои особенности.
□ Имена двух глобальных переменных могут совпадать в том и только том случае, когда они имеют разный порядок импорта. Например, если переменные с одинаковыми именами определены в разных преобразованиях, одно из них может быть импортировано. В этом случае переменная будет иметь значение, которое задано элементом
xsl:variable
со старшим порядком импорта.
□ Допускается совпадение имен локальной и глобальной переменных — в этом случае в области видимости локальной переменной будет использоваться локальное значение, в области видимости глобальной (но не локальной) — глобальное значение. Иными словами, локальные переменные "закрывают" значения глобальных.
□ Две локальные переменные могут иметь совпадающие имена в том и только том случае, если их области видимости не пересекаются.
Первое правило мы уже упоминали, когда разбирали порядок импорта: тогда мы сказали, что переменные со старшим порядком импорта переопределяют переменные с младшим порядком импорта. Это довольно важное обстоятельство, поскольку оно добавляет некоторые интересные возможности, но при этом также может породить скрытые ошибки.
Пример
Предположим, что в следующем преобразовании в шаблоне с именем
choice
мы генерируем два элемента input
.
Листинг 5.24. Преобразование en.xsl
version="1.0"
xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
Результатом этого преобразования будет следующий фрагмент:
Для того чтобы перевести надписи на этих кнопках на другой язык достаточно просто переопределить переменные. Например, результатом выполнения следующего шаблона.
Листинг 5.25. Преобразование de.xsl
version="1.0"
xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
будет тот же фрагмент, но уже на немецком языке:
С другой стороны, переопределение переменных может быть и опасным: в случае, если отдельные модули разрабатывались независимо, совпадение имен глобальных переменных может привести к ошибкам. Для того чтобы такое было в принципе исключено, имя переменной следует объявлять в определенном пространстве имен, например:
В том случае, если префиксы
app
и db
(которые, конечно же, должны быть объявлены) будут указывать на разные пространства имен, никакого конфликта между этими двумя переменными не будет.
Возвращаясь к теме совпадений имен переменных, продемонстрируем "скрытие" локальной переменной значения глобальной:
version="1.0"
xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
i equals
i equals
Результатом выполнения этого шаблона будет:
i equals 1
i equals 2
Как можно видеть, объявление локальной переменной
i
"скрыло" значение глобальной переменной i
. Более того, это преобразование любопытно еще и тем, что локальная переменная объявляется через глобальную — такое тоже допускается.
Рассмотрим теперь случай двух локальных переменных. Попробуем объявить две локальные переменные — одну за другой в следующем шаблоне:
version="1.0"
xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
i equals
i equals
В тексте этого шаблона мы выделили две области видимости двух переменных: серой заливкой — область видимости первой и полужирным шрифтом — область действия второй переменной. Вследствие того, что эти области пересекаются, шаблон будет некорректным — процессор выдаст сообщение об ошибке вида:
Failed to compile style sheet
At xsl:variable on line 9 of file stylesheet.xsl:
Variable is already declared in this template
Приведем теперь другое преобразование, в котором элементы
xsl:variable
принадлежат двум братским элементам:
version="1.0"
xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
i equals
i equals
В этом случае никакого пересечения областей видимости нет, поэтому и ошибкой наличие в одном шаблоне двух локальных переменных с одинаковыми именами тоже не будет. Приведенное выше преобразование возвратит результат вида:
i equals 1
i equals 2
Использование переменных
Как правило, первой реакцией на известие о том, что переменные в XSLT нельзя изменять является реплика: "Да зачем они вообще тогда нужны?!".
Претензия со стороны процедурного программирования вполне серьезна и обоснованна — изменяемые переменные являются большим подспорьем в сложных многошаговых вычислениях. Тем не менее, переменные, даже в том виде, в каком они присутствуют в XSLT, являются очень важным и полезным элементом языка. Ниже мы перечислим наиболее типичные случаи использования переменных.
□ Переменные могут содержать значения выражений, которые много раз используются в преобразовании. Это избавит процессор от необходимости пересчитывать выражение каждый раз по-новому.
□ Переменной может присваиваться результат преобразования, что позволяет манипулировать уже сгенерированными частями документа.
□ Переменные могут использоваться для более прозрачного доступа к внешним документам.
Примеры
Первый случай использования совершенно очевиден: если в преобразовании многократно используется какое-либо сложное для вычисления или просто громоздкое для записи выражение, переменная может служить для сохранения единожды вычисленного результата. Например, если мы много раз обращаемся ко множеству ссылок данного документа посредством выражения вида:
//a[@href]
гораздо удобней и экономней с точки зрения вычислительных ресурсов объявить переменную вида
и использовать ее в преобразовании как
$a
. Фильтрующие выражения языка XPath (продукция FilterExpr
) позволяют затем обращаться к узлам выбранного множества так же, как если бы мы работали с изначальным выражением. Например, $a[1]
будет эквивалентно //a[@href][1]
, a $a/@href
— выражению //a[@href]/@href
. При этом при обращении к $a
процессор не будет заново искать все элементы a с атрибутом href
, что, по всей вероятности, положительно скажется на производительности.
Другой иллюстрацией этому же случаю использования переменной может быть следующая ситуация: в некоторых случаях выражения могут быть просты для вычисления, но слишком громоздки для записи. Гораздо элегантней один раз вычислить это громоздкое выражение, сохранить его в переменной и затем обращаться по короткому имени. Например, следующий элемент
xsl:variable
вычисляет и сохраняет в переменной 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
Второй типовой случай использования переменных также заметно облегчает создание выходящего дерева, делая этот процесс гибким и легко конфигурируемым. Примером формирования HTML-документа при помощи такого подхода может быть следующий шаблон:
Достоинство этого подхода в том, что переменные, содержащие фрагменты деревьев как бы становятся модулями, блоками, из которых в итоге собирается результирующий документ.
Более практичным применением возможности переменных содержать фрагменты деревьев является условное присвоение переменной значения. Представим себе следующий алгоритм:
если
условие1
то
присвоить переменной1 значение 1
иначе
присвоить переменной1 значение2
Для процедурного языка с изменяемыми переменными это не проблема. На Java такой код выглядел бы элементарно:
переменная1 = условие1 ? значение1 : значение2;
или чуть в более длинном варианте:
if (условие1)
переменная1 = значение1;
else
переменная1 = значение2;
Однако если бы в XSLT мы написали что-нибудь наподобие:
то требуемого результата все равно не достигли бы по той простой причине, что определенные нами переменные были бы доступны только в своей области видимости, которая заканчивается закрывающими тегами элементов
xsl:when
и xsl:otherwise
. Правильный шаблон для решения этой задачи выглядит следующим образом:
Конечно, это не точно то же самое — на самом деле мы получаем не значение, а дерево, содержащее это значение, но для строковых и численных значений особой разницы нет: дерево будет вести себя точно так же, как число или строка. Для булевых значений и множеств узлов приходится изыскивать другие методы. Булевое значение можно выразить через условие, например:
select="(значение 1 and условие1) or (значение2 and not(условие2))"/>
Для множества узлов можно использовать предикаты и операции над множествами:
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
, можно объявить переменную, которая будет содержать корневой узел этого документа, например:
name="a.xml"
select="document('http://www.xmlhost.com/docs/a.xml')"/>
После этого к документу
http://www.xmlhost.com/docs/a.xml
можно обращаться посредством переменной с именем a.xml
, например:
Параметры
Параметры в XSLT практически полностью идентичны переменным. Они точно так же связывают с объектом имя, посредством которого в дальнейшем можно к этому объекту обращаться. Главным различием является то, что значение, данное параметру при инициализации, является всего лишь значением по умолчанию, которое может быть переопределено при вызове.
До сих пор мы говорили о шаблонах, как о правилах, часто используя эти слова как синонимы. Попробуем теперь немного сменить угол зрения и представить их как функции, каждая из которых преобразует некоторый узел и возвращает фрагмент дерева в качестве результата. С этой точки зрения параметры шаблонов являются ни чем иным, как аргументами этих функций.
Работа с параметрами обеспечивается двумя элементами —
xsl:param
, который объявляет в шаблоне новый параметр и xsl:with-param
, который указывает значение параметра при вызове шаблона.
Элемент xsl:param
Синтаксически этот элемент задается как:
name="имя"
select="выражение">
Элемент
xsl:template
, задающий в преобразовании шаблонное правило, может включать несколько элементов xsl:param
, которые и будут определять параметры этого шаблона. Кроме этого, xsl:param
может указываться в виде элемента верхнего уровня — в этом случае он будет определять глобальный параметр.
Элемент
xsl:param
объявляет параметр с именем, которое задается обязательным атрибутом name
. Имя параметра может иметь расширенную форму, например "user:param"
, но чтобы не возиться с пространствами имен, на практике имена всегда дают простые — типа "i"
или "myParam"
.
Параметру может быть присвоено значение по умолчанию — то есть значение, которое будет использоваться в случае, если параметра с таким именем шаблону передано не было. Значение по умолчанию вычисляется следующим образом:
□ если в элементе
xsl:param
определен атрибут select
, то значением по умолчанию будет результат вычисления выражения, указанного в этом атрибуте;
□ если атрибут
select
не определен, но сам элемент xsl:param
имеет дочерние узлы, то значением определяемого параметра по умолчанию будет фрагмент дерева, полученного в результате выполнения содержимого xsl:param
;
□ если атрибут
select
не определен и при этом сам элемент xsl:param
пуст, то значением параметра по умолчанию будет пустая строка.
Примеры
Элемент
создаст параметр, значением которого по умолчанию будет
4
. Точно такой же эффект будет иметь элемент
25
" и тем более не множество, состоящее из текстового узла со значением 25
. Значением параметра x
по умолчанию будет результирующий фрагмент дерева, корень которого будет иметь единственный текстовый узел со значением "25
" (рис. 5.3).
Рис. 5.3. Фрагмент дерева, который будет значением параметра x по умолчанию
Не стоит пугаться такой структуры в качестве значения параметра. То, что параметр
x
вдруг будет содержать дерево, ничуть не ограничивает его использование, ведь дерево при потребности может быть приведено к числу или к строке; к множеству узлов же не может быть приведен ни один тип данных.
Предупреждение
Напомним, что при приведении дерева к булевому типу, результатом всегда будет истина. Дерево всегда содержит как минимум корневой узел, и поэтому оно никогда не будет считаться пустым.
Определение параметра вида:
то есть когда в нем нет ни атрибута
select
, ни содержимого, присвоит параметру пустую строку, то есть будет эквивалентно
Точно так же, как и в случае с переменными, значение заданного в шаблоне параметра можно использовать в выражениях, добавляя перед именем параметра префикс "
$
". К примеру, значение нашего параметра x может быть получено конструкцией вида $x
.
Для того чтобы передать в шаблон определенные значения параметров, элементы, которые вызывают этот шаблон, должны содержать один или несколько элементов
xsl:with-param
, который мы рассмотрим чуть ниже. Глобальные параметры, объявленные элементами xsl:param
верхнего уровня, также могут быть переданы преобразованию, однако конкретный механизм реализации этой передачи целиком и полностью зависит от реализации конкретного процессора.
Область видимости параметров
Область видимости параметров определяется в точности так же, как область видимости переменных. Единственным, на что следует обратить здесь внимание — это то, что элементы
xsl:param
, определяемые в шаблонах, должны всегда быть его первыми дочерними элементами. Поэтому область видимости локальных параметров определяется несколько легче, чем область видимости локальных переменных: после определения параметр может использоваться в том шаблоне где угодно.
Прямым следствием из этого является то, что один шаблон не может иметь двух параметров с одинаковыми именами, поскольку их области видимости будут обязательно пересекаться, ведь один из параметров в любом случае будет следовать за другим.
Элемент xsl:with-param
Синтаксис этого элемента выглядит следующим образом:
name="имя"
select="выражение">
Как можно заметить, элемент
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. Вывод названия дня недели по номеру
Mon
Tue
Wed
Thu
Fri
Sat
Sun
Hmm...
Результатом вызова:
будет текстовый узел "
Mon
". Рассмотрим теперь случай, когда параметра передано не было:
Шаблон выведет задумчивое
Hmm...
, поскольку значение параметра day-number
будет по умолчанию нулем (атрибут select
имеет вид select="0"
) и в операторе выбора xsl:choose
сработает условие xsl:otherwise
.
Параметры могут быть использованы как в именованных, так и в неименованных шаблонах. Именованные шаблоны с параметрами ведут себя как самые настоящие функции — они могут вызываться с определенными параметрами вне зависимости от контекста, только чтобы выполнить какие-либо действия с переданными значениями. В случае обычных, неименованных шаблонов параметры могут предоставлять некую дополнительную информацию.
Пример
Представим себе описание меню в следующем формате:
Для того чтобы при обработке особым образом выделять текущую страницу, определим в шаблоне параметр
current
и будем выводить название страницы в элементе b
(от англ. bold — полужирный), если значение current
равно индексу данного пункта меню; если текущая страница и индекс пункта меню не совпадают, то выводиться будет ссылка.
Результатом выполнения шаблона
будет фрагмент меню вида
Home
News
Profile
Contact
Попробуем теперь обработать элементы
menuitem
, не указывая значение параметра current
:
Результат будет получен в виде:
Home
<а href="news.htm">News
<а href="profile.htm">Profile
Contact
Этот фрагмент выходящего документа легко объяснить. Вследствие определения:
значением параметра
current
по умолчанию является 1
, и поэтому в меню был выбран пункт с индексом 1
.
Мы упомянули, что значением параметра может быть дерево. Попробуем пояснить эту концепцию на примере генерации HTML-документа.
Итак, предположим, что мы генерируем выходящий документ следующим именованным шаблоном:
Title one
content
Параметр
head
по умолчанию будет содержать дерево, состоящее из элемента head
и его дочернего элемента title
, который содержит текст "Title one
". Результат выполнения вызова
мы можем видеть на следующем листинге:
Title one
content
Выделенный фрагмент относится к части дерева, которая была создана копированием значения параметра
head
.
Попробуем теперь передать в качестве параметра дерево, сгенерированное следующим шаблоном:
Title two
Для того чтобы передать результат выполнения этого шаблона в виде значения параметра
head
именованному шаблону head
, воспользуемся следующей конструкцией:
Выходящий документ будет получен в виде:
Title two
content
Выделенный фрагмент, как и в предыдущем случае, соответствует части документа, полученной при копировании значения параметра
head
.
Приведенные выше примеры демонстрируют, как можно собрать выходящий документ по кусочкам из фрагментов деревьев. При умелом использовании изложенные подходы позволяют добиться очень высокой гибкости и универсальности преобразований.
Вместо того чтобы при помощи атрибута
matchИмя шаблонному правилу присваивается атрибутом name элемента
xsl:templatematchПри генерации HTML-страниц часто встречающейся задачей является создание элемента
headheadmetatitlelinkДля того чтобы упростить процедуру генерации
head content="This site is dedicated to XSLT and Xpath."/> XSLTdev.ru - XSLT developer resource Думается, этот шаблон не требует пояснений — он просто создает в входящем документе несколько элементов. Непонятным пока остается другое — как вызывать именованные шаблоны? Элемент
xsl:apply-templatesmatchxsl:call-templateЭлемент xsl:call-template
Приведем синтаксис этого элемента:
name="имя"> Обязательный атрибут name указывает имя шаблона, который вызывается этой инструкцией. Например, шаблон с именем "
headАтрибут
namemodexsl:apply-templatesПри вызове
xsl:call-templatexsl:call-templateПриведем пример.
Just a few words... version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform"> content="This site is dedicated to XSLT and Xpath."/> XSLTdev.ru - XSLT developer resource content="This site is dedicated to XSLT and Xpath."> XSLTdev.ru - XSLT developer resource Just a few words...Несколько более эффективным способом использования в документе статических частей (как содержимое элемента
headxsl:copy-ofdocumentВ этом примере шаблон, обрабатывающий корневой элемент, фактически эквивалентен шаблону вида:
content="This site is dedicated to XSLT and Xpath."/> XSLTdev.ru - XSLT developer resource В принципе именованные шаблоны не обязаны иметь атрибут
matchxsl:apply-templatesxsl:call-templateИзменим объявление нашего шаблона head следующим образом:
...Теперь, если входящий документ будет иметь вид
Just a few words... то результат выполнения следующих двух шаблонов будет одинаков.
Второе встроенное правило преобразования аналогично первому, с той лишь особенностью, что для каждого режима преобразования рекурсивная обработка происходит в том же самом режиме. В XSLT это правило выглядело бы следующим образом:
В XSLT также определяется встроенное правило для обработки текстовых узлов и атрибутов — это правило просто выводит их текстовые значения. Шаблон такого преобразования может быть записан в виде:
Четвертое правило касается обработки инструкций по обработке и комментариев. Это правило не делает ничего, то есть инструкции и комментарии просто опускаются в выходящем документе. Шаблон такого преобразования будет иметь вид
Последнее, пятое правило определяет обработку узлов пространств имен. Аналогично инструкциям и комментариям, с ними по умолчанию не следует делать ничего, то есть узлы пространств имен просто удаляются.
Встроенные шаблоны имеют наименьший приоритет импорта, а значит, будут использоваться лишь тогда, когда в преобразовании нет другого, более подходящего правила. Иными словами, любой шаблон, определенный в преобразовании, будет иметь больший приоритет, чем у встроенных правил.
Такое положение вещей позволяет переопределять преобразования, применяемые к узлам документа по умолчанию. Например, во многих случаях бывает весьма полезным идентичное преобразование, которое копирует узлы как есть. Мы уже встречались с ним, когда создавали шаблон для генерации таблицы ссылок XHTML-документа; теперь мы чуть более подробно разберем его работу.
Идентичное преобразование
Наличие в XSLT шаблонов, выполняемых по умолчанию, иногда приводит к тому, что процессоры ведут себя не совсем логично с человеческой точки зрения. Например, в простейшем случае может понадобиться переименовать все элементы с именами
boldb<а> text a text b text c преобразованием
version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform"> будет документ вида
text a text b text cКак можно заметить, в выходящем документе элементы
асДля того чтобы избежать подобного рода казусов, можно использовать идентичное преобразование, которое в случае отсутствия шаблонов для обработки тех или иных узлов копирует их в выходящий документ как есть. Идентичное преобразование записывается в следующем виде.
xmlns:xsl="http://www.w3.org/1999/XSL/Transform"> Единственный шаблон этого преобразования при помощи элемента
xsl:copyПоясним, что это преобразование выполняет не просто копирование документа (для этого было бы достаточно элемента
xsl:copy-ofИдентичное преобразование очень полезно в тех случаях, когда требуется изменить только некоторые части документа, оставив остальное в неприкосновенности. Например, в предыдущем примере нам нужно было только переименовать все документы
boldidentity.xsl version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform"> Результат будет иметь вид:
text a text b text c Другим примером использования идентичного преобразования может послужить случай, когда нужно просто удалить из документа некоторые узлы. Например, нам необходимо избавиться от комментариев (быстро и без шума).
version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
Разрешение конфликтов в шаблонах
Как правило, каждое преобразование в XSLT определяет, включает или импортирует множество шаблонов, которые обрабатывают указанные части документов. При этом один и тот же узел документа может соответствовать нескольким шаблонным правилам. К примеру, элемент
content
может быть обработан любым из следующих трех шаблонов.
Листинг 5.14. Конфликтующие шаблоны
Ситуация, когда для обработки узла может быть применено несколько правил, называется конфликтом шаблонов. Конфликты такого рода неизбежны практически в любом преобразовании, к примеру, большинство шаблонов будет вступать в конфликт со встроенными правилами преобразования.
Для того чтобы в конфликтной ситуации решить, какой именно из шаблонов должен быть применен к данному узлу, процессоры используют два простых правила.
□ Шаблоны, имеющие младший порядок импорта, исключаются из рассмотрения. Иными словами, из множества правил, подходящих для обработки текущего узла, остаются только правила, имеющие самый старший порядок импорта.
□ Из оставшегося множества выбирается шаблон с наивысшим приоритетом. Если таких шаблонов несколько, процессор может либо выдать ошибку, либо применить тот, который описан в преобразовании последним.
Во втором из этих двух правил, мы встретились с понятием приоритета шаблона. Приоритет шаблона это не что иное, как численное значение, которое может быть указано в атрибуте
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('арр')
— выбор дочерних инструкций по обработке, которые имеют вид
;
•
@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. Преобразование
version="1.0"
xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
xmlns:a="a">
1
2
3
4
5
template matched
.
Пять шаблонов этого преобразования могут соответствовать одним и тем же узлам, а значит, создавать множество конфликтов, которые будут разрешаться при помощи механизма приоритетов.
Приоритет первого шаблона, паттерн которого соответствует продукции QName, будет равен
0
. Приоритет второго шаблона будет равен 0.5
, поскольку его паттерн не удовлетворяет другим условиям. Паттерн третьего шаблона имеет вид NCName:*
, а значит, его приоритет равен -0.25
. Приоритет четвертого шаблона равен -0.5
, поскольку его паттерн является проверкой узла (NodeTest
). Приоритет последнего, пятого шаблона будет равен 0, поскольку паттерн b
соответствует продукции QName
.
Попробуем применить это преобразование к следующему документу:
Проследим за тем, как будет выполняться преобразование.
□ Инструкции по обработке
,
которая идет в документе первой, соответствует только один, четвертый шаблон.
□ Корневому элементу
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
. Например, если бы в предыдущем преобразовании четвертый шаблон был определен в виде
4
то его приоритет был бы выше, чем у всех остальных шаблонов, а поскольку он соответствует всем узлам в обрабатываемом документе, то во всех случаях применялся бы только он один. Сообщения процессора имели бы вид
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. Основное преобразование
xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
version="1.0"
xmlns:a="a">
1
2
3
5
Листинг 5.17. Преобразование b.xsl
xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
version="1.0"
xmlns:a="a">
4
template matched
.
Как уже было сказано ранее, четвертое преобразование, вынесенное теперь в импортируемый модуль, при разрешении конфликтов шаблонов будет самым младшим вследствие того, что порядок его импорта меньше, чем у других преобразований. Сообщения процессора будут иметь вид
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
можно использовать в шаблонах для применения правил, которые были импортированы во внешних модулях, но затем переопределены шаблонами основного преобразования.
Пример
Предположим, что в преобразованиях часто используется шаблон, который заменяет элементы
home
ссылками на сайт http://www.xsltdev.ru:
<а href="http://www.xsltdev.ru">www.xsltdev.ru
При необходимости этот шаблон может быть переопределен. К примеру, ссылка может выглядеть как
Visit <а href="http://www.xsltdev.ru">www.xsltdev.ru
Соответственно, шаблон будет иметь вид
Visit
www.xsltdev.ru
Можно заметить, что оба шаблона имеют общую часть, которая выводит гипертекстовую ссылку. Эта часть может быть вынесена во внешнее преобразование
home.xsl
.
Листинг 5.18. Преобразование home.xml
xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
www.xsltdev.ru
Для того чтобы использовать внешний шаблон, основное преобразование должно импортировать его при помощи
xsl:import
и применять посредством xsl:apply-imports.
Листинг 5.19. Основное преобразование base.xsl
xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
version="1.0">
Visit
Элемент
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 "www.xsltdev.ru";
}
}
Листинг 5.21. Класс base
public class base extends home {
public String home() {
return ("Visit " + super.home());
}
}
В этом примере вызов родительского метода
super.home()
соответствует применению элементом xsl:apply-imports
импортированного шаблона.
Как правило, каждое преобразование в XSLT определяет, включает или импортирует множество шаблонов, которые обрабатывают указанные части документов. При этом один и тот же узел документа может соответствовать нескольким шаблонным правилам. К примеру, элемент
content Ситуация, когда для обработки узла может быть применено несколько правил, называется конфликтом шаблонов. Конфликты такого рода неизбежны практически в любом преобразовании, к примеру, большинство шаблонов будет вступать в конфликт со встроенными правилами преобразования.
Для того чтобы в конфликтной ситуации решить, какой именно из шаблонов должен быть применен к данному узлу, процессоры используют два простых правила.
□ Шаблоны, имеющие младший порядок импорта, исключаются из рассмотрения. Иными словами, из множества правил, подходящих для обработки текущего узла, остаются только правила, имеющие самый старший порядок импорта.
□ Из оставшегося множества выбирается шаблон с наивысшим приоритетом. Если таких шаблонов несколько, процессор может либо выдать ошибку, либо применить тот, который описан в преобразовании последним.
Во втором из этих двух правил, мы встретились с понятием приоритета шаблона. Приоритет шаблона это не что иное, как численное значение, которое может быть указано в атрибуте
priorityxsl:template□ Прежде всего, шаблон, который обрабатывает несколько альтернатив, перечисленных через знак "
|match="b|bold|B"match="b"match="bold"match="B"□ Если паттерн состоит из имени (
QNameprocessing-instruction(литерал)ChildOrAttributeAxisSpecifier0•
QNamechild::QName•
@QNameattribute::QName•
processing-instruction(литерал)child::processing-instruction(литерал)Примеры паттернов с приоритетом, равным
0•
contentcontent•
fo:contentcontentfo•
child::processing-instruction('арр')•
@xsd:namexsd:name•
@selectselect□ Если паттерн состоит из конструкции
NCName:*ChildOrAxisSpecifier-0.25•
префикс:*child::префикс:*•
@префикс:*attribute::префикс:*Примеры паттернов с приоритетом, равным
-0.25•
fo:*fo•
attribute::xsl:*xsl□ Если паттерн состоит из проверки узла (
NodeTestChildOrAttributeAxisSpecifier-0.5•
NodeTestchild::NodeTest•
QNodeTestattribute::NodeTest□ Примеры паттернов с приоритетом, равным
-0.5•
text()•
child::comment()•
@*□ Если ни одно из предыдущих условий не выполняется, приоритет шаблона равен
0.5Для удобства использования составим таблицу (табл. 5.1) с приоритетами тех или иных паттернов.
Таблица 5.1. Приоритет паттернов
| Вид паттерна | Приоритет |
|---|---|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| Другие паттерны | |
Несмотря на то, что вычислением приоритета преобразований занимается процессор, полезно понимать механизм этого вычисления для того, чтобы уметь предсказывать, как будет решен конфликт тех или иных шаблонов. Довольно часто в преобразованиях допускаются ошибки, связанные с приоритетом применения шаблонов.
Вычислим в качестве упражнения приоритеты шаблонов для следующего примера.
version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform" xmlns:a="a"> 1 2 3 4 5 template matched . Пять шаблонов этого преобразования могут соответствовать одним и тем же узлам, а значит, создавать множество конфликтов, которые будут разрешаться при помощи механизма приоритетов.
Приоритет первого шаблона, паттерн которого соответствует продукции QName, будет равен
00.5NCName:*-0.25-0.5NodeTestbQNameПопробуем применить это преобразование к следующему документу:
Проследим за тем, как будет выполняться преобразование.
□ Инструкции по обработке
,□ Корневому элементу
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.Напомним, что приоритет преобразований может быть также явно указан в атрибуте
priorityxsl:template 4 то его приоритет был бы выше, чем у всех остальных шаблонов, а поскольку он соответствует всем узлам в обрабатываемом документе, то во всех случаях применялся бы только он один. Сообщения процессора имели бы вид
4 template matched ORA.4 template matched b.4 template matched a.4 template matched b.4 template matched b.4 template matched c.Между тем, явное указание приоритета шаблона не может изменить порядок его импорта. То есть, если бы в предыдущем примере четвертый шаблон был бы вынесен во внешний модуль и импортирован в основное преобразование, в любом случае он бы применялся только в отсутствие более подходящих правил.
xmlns:xsl="http://www.w3.org/1999/XSL/Transform" version="1.0" xmlns:a="a"> 1 2 3 5 xmlns:xsl="http://www.w3.org/1999/XSL/Transform" version="1.0" xmlns:a="a"> 4 template matched . Как уже было сказано ранее, четвертое преобразование, вынесенное теперь в импортируемый модуль, при разрешении конфликтов шаблонов будет самым младшим вследствие того, что порядок его импорта меньше, чем у других преобразований. Сообщения процессора будут иметь вид
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-templatesxsl:apply-importsЭлемент xsl:apply-imports
Синтаксис этого элемента:
Элемент
xsl:apply-importsПредположим, что в преобразованиях часто используется шаблон, который заменяет элементы
home <а href="http://www.xsltdev.ru">www.xsltdev.ruПри необходимости этот шаблон может быть переопределен. К примеру, ссылка может выглядеть как
Visit <а href="http://www.xsltdev.ru">www.xsltdev.ruСоответственно, шаблон будет иметь вид
Visit www.xsltdev.ruМожно заметить, что оба шаблона имеют общую часть, которая выводит гипертекстовую ссылку. Эта часть может быть вынесена во внешнее преобразование
home.xsl xmlns:xsl="http://www.w3.org/1999/XSL/Transform"> www.xsltdev.ru Для того чтобы использовать внешний шаблон, основное преобразование должно импортировать его при помощи
xsl:import xmlns:xsl="http://www.w3.org/1999/XSL/Transform" version="1.0"> Visit Элемент
xsl:apply-importsxsl:for-eachxsl:apply-importsxsl:apply-templatesxsl:for-eachxsl:apply-importsЭлемент
xsl:apply-importsxsl:apply-templates□ Шаблоны, определенные в основном преобразовании, применяться не будут, поскольку
xsl:apply-imports□ Элемент
xsl:apply-importsmodeВ текущей версии XSLT
xsl:apply-importsДля того чтобы лучше понять, зачем нужна такая сложная схема импорта, проведем аналогию с объектно-ориентированным программированием. Если рассматривать правила преобразований как методы классов, то импорт преобразований будет ни чем иным, как наследованием — все методы (шаблоны) класса-потомка (импортируемого преобразования) будут доступны в классе-наследнике (импортирующем преобразовании). При этом класс-наследник может переопределить методы класса потомка (шаблоны основного преобразования имеют порядок импорта старше, чем шаблоны импортированного преобразования). В этой схеме использование элемента
xsl:apply-importsПриведем пример Java-классов, которые будут аналогичны преобразованиям
home.xslbase.xslpublic class home { public String home() { return "www.xsltdev.ru"; }}public class base extends home { public String home() { return ("Visit " + super.home()); }}В этом примере вызов родительского метода
super.home()xsl:apply-importsТело шаблона
Фактически, элемент
xsl:templatexsl:templateТело следующего шаблона (выделенное полужирным шрифтом):
Комментарии состоит из литерального элемента
bodyxsl:copy-ofbodyxsl:copy-ofСледует заметить, что текстовый узел в данном случае состоит не только из строки "Комментарии". Он включает также все пробельные символы и символы переноса строки.
Тело шаблона может быть также и пустым. В этом случае результат обработки узлов, соответствующих этому шаблону будет пустым. Например, если в преобразовании содержится шаблон вида
то каждый раз, встретив узел комментария и обрабатывая его этим правилом, процессор будет получать пустой результат. Таким образом, используя пустые шаблоны совместно с идентичным преобразованием можно добиться эффекта удаления определенных узлов из шаблона, как это было показано ранее в этой главе.
Тело шаблона может содержать любые текстовые узлы, комментарии, инструкции по обработке и литеральные элементы результата при условии, что не будет нарушен синтаксис 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:paramxsl:variableЕсли элементы
xsl:paramxsl:template Text будет некорректным. На самом деле многие процессоры игнорируют эту ошибку, вполне разумно считая, что ничего смертельного в ней нет. Но, конечно, лучше использовать стандартный вариант:
Text
Переменные и параметры
Было бы слишком просто и слишком бесполезно лишь констатировать, что переменные и параметры в XSLT похожи между собой и сильно отличаются от переменных в других языках программирования. Мы попытаемся разобраться в этом вопросе несколько глубже — чем именно и ради чего конкретно переменные в XSLT обладают такими свойствами.
В классической книге Монти Бен-Ари "Языки программирования" [Бен-Ари 2000] приводится следующее определение переменной:
Переменная — это имя, присвоенное ячейке памяти или ячейкам, которые могут содержать представление конкретного типа (данных).
Затем следует комментарий:
Значение может изменяться во время выполнения программы.
Если немного сменить уровень абстракции, первая часть этого определения верна и по отношению к параметрам, и переменным XSLT (далее мы будем говорить просто "переменные", поскольку различия между ними на данный момент несущественны). Конечно, где-то там внутри реализации конкретного XSLT-процессора есть память, поделенная на ячейки, в которой процессор хранит информацию. Такие детали нас, естественно, не интересуют, ибо мы больше рассуждаем о логических, чем о физических моделях. В логической же модели переменная представляется как объект определенного типа, с которым связано имя, — по этому имени мы можем обращаться к объекту, использовать его значение и так далее. Иными словами, в XSLT под переменной понимается не более чем ассоциация между значением и именем, и если мы вдруг скажем, что переменная
x
имеет значение 5
, это будет означать, что имя "x
" связано объектом численного типа, значение которого равно 5
. Заметим небольшую разницу с определением Бен-Ари: мы не говорим о том, что число 5
лежит в какой-то ячейке памяти (хотя, несомненно, оно так и есть) и что этой ячейке присвоено имя "x
" — мы говорим об ассоциации между объектом и именем и только.
Теперь, когда более или менее ясно, что же мы имеем в виду под переменными, на новой строчке полужирным шрифтом напишем следующее:
Переменные в XSLT не могут быть изменены.
Разработчикам, которые использовали в своей практике только процедурные языки и не имеют опыта функционального или логического программирования будет очень нелегко смириться с такой ситуацией. То, что переменные не могут быть изменены дискредитирует само название — переменные, ибо они уже более похожи на константы.
Практически во всех процедурных языках оператор присваивания вида
переменная = выражение
с незначительными вариациями работает приблизительно следующим образом:
□ сначала вычисляется присваиваемое выражение;
□ затем вычисляется адрес переменной;
□ затем значение, полученное на первом шаге, копируется в ячейки памяти, начиная с адреса, полученного на втором шаге присваивания.
В XSLT нет оператора присваивания. Переменным и параметрам никогда не присваиваются значения в приведенном выше смысле, объявление переменной или параметра лишь связывает указанное имя со значением некоторого выражения. Иными словами, объявление переменной есть создание ассоциации между объектом и именем.
В конце этой главы мы вернемся к неизменяемым переменным и попытаемся объяснить, почему их нельзя изменить — но прежде мы должны научиться их использовать.
Элемент xsl:variable
Синтаксис этого элемента в XSLT определен так:
name="имя"
select="выражение">
Для объявления переменных в 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
следующим образом:
version="1.0"
xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
...
...
Несложно видеть, что здесь мы определили глобальную переменную, а значит, ее значение можно использовать в преобразовании в любом месте. Например, мы можем определить через нее другие глобальные переменные, либо использовать в шаблоне:
version="1.0"
xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
...
...
Причем, как уже было сказано, глобальная переменная может быть использована и до объявления: в нашем случае переменная
leaf
определяется через переменную ID
, a path
— через leaf
. Конечно же, не следует забывать и то правило, что переменные не могут объявляться посредством самих себя, явно или неявно. Очевидно, что объявление:
было бы некорректным ввиду явного использования переменной при собственном определении. Точно так же были бы некорректны определения:
поскольку переменная
ID
определяется через переменную id
, которая определяется через переменную ID
и так до бесконечности.
Дела с локальными переменными обстоят чуть-чуть сложнее. Для того чтобы объяснить, что же такое область видимости, обратимся к следующему преобразованию.
Листинг 5.22. Преобразование, использующее переменные i, j, k и gt
version="1.0"
xmlns:xsl="... ">
name="i"
select="2"/>
name="j"
select="$i - 1"/>
is greater than
В этом преобразовании определены три локальные переменные —
i
, j
и k
и одна глобальная переменная — gt
. На следующих четырех листингах мы выделим серой заливкой область видимости переменной (то есть область, где ее можно использовать), а само определение переменной отметим полужирным шрифтом.
Листинг 5.23. Области видимости переменных i, j, k и gt
Область видимости переменной
i
Область видимости переменной j
version="1.0" xmlns:xsl="... "> version="1.0" xmlns:xsl="... ">
select="2"/> select="2"/>
select="$i - 1"/> select="$i - 1"/>
is greater than is greater than
Область видимости переменной
k
Область видимости переменной gt
version="1.0" xmlns:xsl="... "> version="1.0" xmlns:xsl="... ">
select="2"/> select="2"/>
select="$i - 1"/> select="$i - 1"/>
is greater than is greater than
В XSLT действует то же правило, что и во многих других языках программирования: нельзя дважды определять переменную с один и тем же именем. Однако и тут есть свои особенности.
□ Имена двух глобальных переменных могут совпадать в том и только том случае, когда они имеют разный порядок импорта. Например, если переменные с одинаковыми именами определены в разных преобразованиях, одно из них может быть импортировано. В этом случае переменная будет иметь значение, которое задано элементом
xsl:variable
со старшим порядком импорта.
□ Допускается совпадение имен локальной и глобальной переменных — в этом случае в области видимости локальной переменной будет использоваться локальное значение, в области видимости глобальной (но не локальной) — глобальное значение. Иными словами, локальные переменные "закрывают" значения глобальных.
□ Две локальные переменные могут иметь совпадающие имена в том и только том случае, если их области видимости не пересекаются.
Первое правило мы уже упоминали, когда разбирали порядок импорта: тогда мы сказали, что переменные со старшим порядком импорта переопределяют переменные с младшим порядком импорта. Это довольно важное обстоятельство, поскольку оно добавляет некоторые интересные возможности, но при этом также может породить скрытые ошибки.
Пример
Предположим, что в следующем преобразовании в шаблоне с именем
choice
мы генерируем два элемента input
.
Листинг 5.24. Преобразование en.xsl
version="1.0"
xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
Результатом этого преобразования будет следующий фрагмент:
Для того чтобы перевести надписи на этих кнопках на другой язык достаточно просто переопределить переменные. Например, результатом выполнения следующего шаблона.
Листинг 5.25. Преобразование de.xsl
version="1.0"
xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
будет тот же фрагмент, но уже на немецком языке:
С другой стороны, переопределение переменных может быть и опасным: в случае, если отдельные модули разрабатывались независимо, совпадение имен глобальных переменных может привести к ошибкам. Для того чтобы такое было в принципе исключено, имя переменной следует объявлять в определенном пространстве имен, например:
В том случае, если префиксы
app
и db
(которые, конечно же, должны быть объявлены) будут указывать на разные пространства имен, никакого конфликта между этими двумя переменными не будет.
Возвращаясь к теме совпадений имен переменных, продемонстрируем "скрытие" локальной переменной значения глобальной:
version="1.0"
xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
i equals
i equals
Результатом выполнения этого шаблона будет:
i equals 1
i equals 2
Как можно видеть, объявление локальной переменной
i
"скрыло" значение глобальной переменной i
. Более того, это преобразование любопытно еще и тем, что локальная переменная объявляется через глобальную — такое тоже допускается.
Рассмотрим теперь случай двух локальных переменных. Попробуем объявить две локальные переменные — одну за другой в следующем шаблоне:
version="1.0"
xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
i equals
i equals
В тексте этого шаблона мы выделили две области видимости двух переменных: серой заливкой — область видимости первой и полужирным шрифтом — область действия второй переменной. Вследствие того, что эти области пересекаются, шаблон будет некорректным — процессор выдаст сообщение об ошибке вида:
Failed to compile style sheet
At xsl:variable on line 9 of file stylesheet.xsl:
Variable is already declared in this template
Приведем теперь другое преобразование, в котором элементы
xsl:variable
принадлежат двум братским элементам:
version="1.0"
xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
i equals
i equals
В этом случае никакого пересечения областей видимости нет, поэтому и ошибкой наличие в одном шаблоне двух локальных переменных с одинаковыми именами тоже не будет. Приведенное выше преобразование возвратит результат вида:
i equals 1
i equals 2
Использование переменных
Как правило, первой реакцией на известие о том, что переменные в XSLT нельзя изменять является реплика: "Да зачем они вообще тогда нужны?!".
Претензия со стороны процедурного программирования вполне серьезна и обоснованна — изменяемые переменные являются большим подспорьем в сложных многошаговых вычислениях. Тем не менее, переменные, даже в том виде, в каком они присутствуют в XSLT, являются очень важным и полезным элементом языка. Ниже мы перечислим наиболее типичные случаи использования переменных.
□ Переменные могут содержать значения выражений, которые много раз используются в преобразовании. Это избавит процессор от необходимости пересчитывать выражение каждый раз по-новому.
□ Переменной может присваиваться результат преобразования, что позволяет манипулировать уже сгенерированными частями документа.
□ Переменные могут использоваться для более прозрачного доступа к внешним документам.
Примеры
Первый случай использования совершенно очевиден: если в преобразовании многократно используется какое-либо сложное для вычисления или просто громоздкое для записи выражение, переменная может служить для сохранения единожды вычисленного результата. Например, если мы много раз обращаемся ко множеству ссылок данного документа посредством выражения вида:
//a[@href]
гораздо удобней и экономней с точки зрения вычислительных ресурсов объявить переменную вида
и использовать ее в преобразовании как
$a
. Фильтрующие выражения языка XPath (продукция FilterExpr
) позволяют затем обращаться к узлам выбранного множества так же, как если бы мы работали с изначальным выражением. Например, $a[1]
будет эквивалентно //a[@href][1]
, a $a/@href
— выражению //a[@href]/@href
. При этом при обращении к $a
процессор не будет заново искать все элементы a с атрибутом href
, что, по всей вероятности, положительно скажется на производительности.
Другой иллюстрацией этому же случаю использования переменной может быть следующая ситуация: в некоторых случаях выражения могут быть просты для вычисления, но слишком громоздки для записи. Гораздо элегантней один раз вычислить это громоздкое выражение, сохранить его в переменной и затем обращаться по короткому имени. Например, следующий элемент
xsl:variable
вычисляет и сохраняет в переменной 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
Второй типовой случай использования переменных также заметно облегчает создание выходящего дерева, делая этот процесс гибким и легко конфигурируемым. Примером формирования HTML-документа при помощи такого подхода может быть следующий шаблон:
Достоинство этого подхода в том, что переменные, содержащие фрагменты деревьев как бы становятся модулями, блоками, из которых в итоге собирается результирующий документ.
Более практичным применением возможности переменных содержать фрагменты деревьев является условное присвоение переменной значения. Представим себе следующий алгоритм:
если
условие1
то
присвоить переменной1 значение 1
иначе
присвоить переменной1 значение2
Для процедурного языка с изменяемыми переменными это не проблема. На Java такой код выглядел бы элементарно:
переменная1 = условие1 ? значение1 : значение2;
или чуть в более длинном варианте:
if (условие1)
переменная1 = значение1;
else
переменная1 = значение2;
Однако если бы в XSLT мы написали что-нибудь наподобие:
то требуемого результата все равно не достигли бы по той простой причине, что определенные нами переменные были бы доступны только в своей области видимости, которая заканчивается закрывающими тегами элементов
xsl:when
и xsl:otherwise
. Правильный шаблон для решения этой задачи выглядит следующим образом:
Конечно, это не точно то же самое — на самом деле мы получаем не значение, а дерево, содержащее это значение, но для строковых и численных значений особой разницы нет: дерево будет вести себя точно так же, как число или строка. Для булевых значений и множеств узлов приходится изыскивать другие методы. Булевое значение можно выразить через условие, например:
select="(значение 1 and условие1) or (значение2 and not(условие2))"/>
Для множества узлов можно использовать предикаты и операции над множествами:
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
, можно объявить переменную, которая будет содержать корневой узел этого документа, например:
name="a.xml"
select="document('http://www.xmlhost.com/docs/a.xml')"/>
После этого к документу
http://www.xmlhost.com/docs/a.xml
можно обращаться посредством переменной с именем a.xml
, например:
Было бы слишком просто и слишком бесполезно лишь констатировать, что переменные и параметры в XSLT похожи между собой и сильно отличаются от переменных в других языках программирования. Мы попытаемся разобраться в этом вопросе несколько глубже — чем именно и ради чего конкретно переменные в XSLT обладают такими свойствами.
В классической книге Монти Бен-Ари "Языки программирования" [Бен-Ари 2000] приводится следующее определение переменной:
Переменная — это имя, присвоенное ячейке памяти или ячейкам, которые могут содержать представление конкретного типа (данных).
Затем следует комментарий:
Значение может изменяться во время выполнения программы.
Если немного сменить уровень абстракции, первая часть этого определения верна и по отношению к параметрам, и переменным XSLT (далее мы будем говорить просто "переменные", поскольку различия между ними на данный момент несущественны). Конечно, где-то там внутри реализации конкретного XSLT-процессора есть память, поделенная на ячейки, в которой процессор хранит информацию. Такие детали нас, естественно, не интересуют, ибо мы больше рассуждаем о логических, чем о физических моделях. В логической же модели переменная представляется как объект определенного типа, с которым связано имя, — по этому имени мы можем обращаться к объекту, использовать его значение и так далее. Иными словами, в XSLT под переменной понимается не более чем ассоциация между значением и именем, и если мы вдруг скажем, что переменная
x5x55xТеперь, когда более или менее ясно, что же мы имеем в виду под переменными, на новой строчке полужирным шрифтом напишем следующее:
Разработчикам, которые использовали в своей практике только процедурные языки и не имеют опыта функционального или логического программирования будет очень нелегко смириться с такой ситуацией. То, что переменные не могут быть изменены дискредитирует само название — переменные, ибо они уже более похожи на константы.
Практически во всех процедурных языках оператор присваивания вида
переменная = выражениес незначительными вариациями работает приблизительно следующим образом:
□ сначала вычисляется присваиваемое выражение;
□ затем вычисляется адрес переменной;
□ затем значение, полученное на первом шаге, копируется в ячейки памяти, начиная с адреса, полученного на втором шаге присваивания.
В XSLT нет оператора присваивания. Переменным и параметрам никогда не присваиваются значения в приведенном выше смысле, объявление переменной или параметра лишь связывает указанное имя со значением некоторого выражения. Иными словами, объявление переменной есть создание ассоциации между объектом и именем.
В конце этой главы мы вернемся к неизменяемым переменным и попытаемся объяснить, почему их нельзя изменить — но прежде мы должны научиться их использовать.
Элемент xsl:variable
Синтаксис этого элемента в XSLT определен так:
name="имя" select="выражение"> Для объявления переменных в XSLT служит элемент
xsl:variablexsl:variableselectxsl:variableТаким образом, объявление переменной в XSLT происходит всего в два шага:
□ сначала вычисляется значение присваиваемого выражения;
□ затем полученное значение связывается с указанным именем.
Значение присваиваемого выражения вычисляется в зависимости от того, как был определен элемент
xsl:variable□ если в элементе
xsl:variableselect□ если атрибут
selectxsl:variablexsl:variable□ если атрибут
selectxsl:variableИспользовать значения, присвоенные переменным при инициализации, можно, указывая впереди имени переменной символ "
$x$xVariableReferenceИмя переменной соответствует синтаксическому правилу
QNameимяпрефикс:имяОбласть видимости переменных
Каждая из переменных имеет собственную область видимости (англ. scope) — область, в которой может быть использовано ее значение. Область видимости определяется следующим образом.
□ Областью видимости глобальной переменной является все преобразование, то есть значение переменной, объявленной элементом верхнего уровня, может быть использовано в преобразовании где угодно. К такой переменной можно обращаться даже до ее объявления, единственным ограничением является то, что переменная не должна определяться через собственное значение — явно или неявно.
□ Локальную переменную можно использовать только после ее объявления и только в том же родительском элементе, которому принадлежит объявляющий элемент
xsl:variablefollowing-sibling:node()/descendant-or-self:node()Для того чтобы до конца прояснить ситуацию, приведем несколько примеров.
Предположим, что мы определяем переменную с именем
ID4 version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform"> ... ...Несложно видеть, что здесь мы определили глобальную переменную, а значит, ее значение можно использовать в преобразовании в любом месте. Например, мы можем определить через нее другие глобальные переменные, либо использовать в шаблоне:
version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform"> ... ...Причем, как уже было сказано, глобальная переменная может быть использована и до объявления: в нашем случае переменная
leafIDpathleafбыло бы некорректным ввиду явного использования переменной при собственном определении. Точно так же были бы некорректны определения:
поскольку переменная
IDidIDДела с локальными переменными обстоят чуть-чуть сложнее. Для того чтобы объяснить, что же такое область видимости, обратимся к следующему преобразованию.
version="1.0" xmlns:xsl="... "> name="i" select="2"/> name="j" select="$i - 1"/> is greater than В этом преобразовании определены три локальные переменные —
ijkgtОбласть видимости переменной
ij version="1.0" xmlns:xsl="... "> version="1.0" xmlns:xsl="... "> select="2"/> select="2"/> select="$i - 1"/> select="$i - 1"/> is greater than is greater than Область видимости переменной
kgt version="1.0" xmlns:xsl="... "> version="1.0" xmlns:xsl="... "> select="2"/> select="2"/> select="$i - 1"/> select="$i - 1"/> is greater than is greater than В XSLT действует то же правило, что и во многих других языках программирования: нельзя дважды определять переменную с один и тем же именем. Однако и тут есть свои особенности.
□ Имена двух глобальных переменных могут совпадать в том и только том случае, когда они имеют разный порядок импорта. Например, если переменные с одинаковыми именами определены в разных преобразованиях, одно из них может быть импортировано. В этом случае переменная будет иметь значение, которое задано элементом
xsl:variable□ Допускается совпадение имен локальной и глобальной переменных — в этом случае в области видимости локальной переменной будет использоваться локальное значение, в области видимости глобальной (но не локальной) — глобальное значение. Иными словами, локальные переменные "закрывают" значения глобальных.
□ Две локальные переменные могут иметь совпадающие имена в том и только том случае, если их области видимости не пересекаются.
Первое правило мы уже упоминали, когда разбирали порядок импорта: тогда мы сказали, что переменные со старшим порядком импорта переопределяют переменные с младшим порядком импорта. Это довольно важное обстоятельство, поскольку оно добавляет некоторые интересные возможности, но при этом также может породить скрытые ошибки.
Предположим, что в следующем преобразовании в шаблоне с именем
choiceinput version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
Результатом этого преобразования будет следующий фрагмент:
Для того чтобы перевести надписи на этих кнопках на другой язык достаточно просто переопределить переменные. Например, результатом выполнения следующего шаблона.
version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform"> будет тот же фрагмент, но уже на немецком языке:
С другой стороны, переопределение переменных может быть и опасным: в случае, если отдельные модули разрабатывались независимо, совпадение имен глобальных переменных может привести к ошибкам. Для того чтобы такое было в принципе исключено, имя переменной следует объявлять в определенном пространстве имен, например:
В том случае, если префиксы
appdbВозвращаясь к теме совпадений имен переменных, продемонстрируем "скрытие" локальной переменной значения глобальной:
version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform"> i equals
i equals Результатом выполнения этого шаблона будет:
i equals 1i equals 2Как можно видеть, объявление локальной переменной
iiРассмотрим теперь случай двух локальных переменных. Попробуем объявить две локальные переменные — одну за другой в следующем шаблоне:
version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform"> i equals
i equals В тексте этого шаблона мы выделили две области видимости двух переменных: серой заливкой — область видимости первой и полужирным шрифтом — область действия второй переменной. Вследствие того, что эти области пересекаются, шаблон будет некорректным — процессор выдаст сообщение об ошибке вида:
Failed to compile style sheetAt xsl:variable on line 9 of file stylesheet.xsl:Variable is already declared in this templateПриведем теперь другое преобразование, в котором элементы
xsl:variable version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform"> i equals i equals В этом случае никакого пересечения областей видимости нет, поэтому и ошибкой наличие в одном шаблоне двух локальных переменных с одинаковыми именами тоже не будет. Приведенное выше преобразование возвратит результат вида:
i equals 1 i equals 2Использование переменных
Как правило, первой реакцией на известие о том, что переменные в XSLT нельзя изменять является реплика: "Да зачем они вообще тогда нужны?!".
Претензия со стороны процедурного программирования вполне серьезна и обоснованна — изменяемые переменные являются большим подспорьем в сложных многошаговых вычислениях. Тем не менее, переменные, даже в том виде, в каком они присутствуют в XSLT, являются очень важным и полезным элементом языка. Ниже мы перечислим наиболее типичные случаи использования переменных.
□ Переменные могут содержать значения выражений, которые много раз используются в преобразовании. Это избавит процессор от необходимости пересчитывать выражение каждый раз по-новому.
□ Переменной может присваиваться результат преобразования, что позволяет манипулировать уже сгенерированными частями документа.
□ Переменные могут использоваться для более прозрачного доступа к внешним документам.
Первый случай использования совершенно очевиден: если в преобразовании многократно используется какое-либо сложное для вычисления или просто громоздкое для записи выражение, переменная может служить для сохранения единожды вычисленного результата. Например, если мы много раз обращаемся ко множеству ссылок данного документа посредством выражения вида:
//a[@href]гораздо удобней и экономней с точки зрения вычислительных ресурсов объявить переменную вида
и использовать ее в преобразовании как
$aFilterExpr$a[1]//a[@href][1]$a/@href//a[@href]/@href$ahrefДругой иллюстрацией этому же случаю использования переменной может быть следующая ситуация: в некоторых случаях выражения могут быть просты для вычисления, но слишком громоздки для записи. Гораздо элегантней один раз вычислить это громоздкое выражение, сохранить его в переменной и затем обращаться по короткому имени. Например, следующий элемент
xsl:variablegv 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Второй типовой случай использования переменных также заметно облегчает создание выходящего дерева, делая этот процесс гибким и легко конфигурируемым. Примером формирования HTML-документа при помощи такого подхода может быть следующий шаблон:
Достоинство этого подхода в том, что переменные, содержащие фрагменты деревьев как бы становятся модулями, блоками, из которых в итоге собирается результирующий документ.
Более практичным применением возможности переменных содержать фрагменты деревьев является условное присвоение переменной значения. Представим себе следующий алгоритм:
если условие1то присвоить переменной1 значение 1иначе присвоить переменной1 значение2Для процедурного языка с изменяемыми переменными это не проблема. На Java такой код выглядел бы элементарно:
переменная1 = условие1 ? значение1 : значение2;или чуть в более длинном варианте:
if (условие1) переменная1 = значение1;else переменная1 = значение2;Однако если бы в XSLT мы написали что-нибудь наподобие:
то требуемого результата все равно не достигли бы по той простой причине, что определенные нами переменные были бы доступны только в своей области видимости, которая заканчивается закрывающими тегами элементов
xsl:whenxsl:otherwise Конечно, это не точно то же самое — на самом деле мы получаем не значение, а дерево, содержащее это значение, но для строковых и численных значений особой разницы нет: дерево будет вести себя точно так же, как число или строка. Для булевых значений и множеств узлов приходится изыскивать другие методы. Булевое значение можно выразить через условие, например:
select="(значение 1 and условие1) or (значение2 and not(условие2))"/>Для множества узлов можно использовать предикаты и операции над множествами:
select="значение1[условие1] | значение2[not(условие2)]"/>Заметим, что шаблон, содержащийся в элементе
xsl:variablexsl:call-templatexsl:apply-templatesИспользование внешних документов в преобразовании, как правило, сопровождается громоздкими выражениями вида:
document('http://www.xmlhost.com/docs/а.xml')/page/request/paramи так далее.
Для того чтобы при обращении к внешнему документу не использовать каждый раз функцию
document name="a.xml" select="document('http://www.xmlhost.com/docs/a.xml')"/>После этого к документу
http://www.xmlhost.com/docs/a.xmla.xml
Параметры
Параметры в XSLT практически полностью идентичны переменным. Они точно так же связывают с объектом имя, посредством которого в дальнейшем можно к этому объекту обращаться. Главным различием является то, что значение, данное параметру при инициализации, является всего лишь значением по умолчанию, которое может быть переопределено при вызове.
До сих пор мы говорили о шаблонах, как о правилах, часто используя эти слова как синонимы. Попробуем теперь немного сменить угол зрения и представить их как функции, каждая из которых преобразует некоторый узел и возвращает фрагмент дерева в качестве результата. С этой точки зрения параметры шаблонов являются ни чем иным, как аргументами этих функций.
Работа с параметрами обеспечивается двумя элементами —
xsl:param
, который объявляет в шаблоне новый параметр и xsl:with-param
, который указывает значение параметра при вызове шаблона.
Элемент xsl:param
Синтаксически этот элемент задается как:
name="имя"
select="выражение">
Элемент
xsl:template
, задающий в преобразовании шаблонное правило, может включать несколько элементов xsl:param
, которые и будут определять параметры этого шаблона. Кроме этого, xsl:param
может указываться в виде элемента верхнего уровня — в этом случае он будет определять глобальный параметр.
Элемент
xsl:param
объявляет параметр с именем, которое задается обязательным атрибутом name
. Имя параметра может иметь расширенную форму, например "user:param"
, но чтобы не возиться с пространствами имен, на практике имена всегда дают простые — типа "i"
или "myParam"
.
Параметру может быть присвоено значение по умолчанию — то есть значение, которое будет использоваться в случае, если параметра с таким именем шаблону передано не было. Значение по умолчанию вычисляется следующим образом:
□ если в элементе
xsl:param
определен атрибут select
, то значением по умолчанию будет результат вычисления выражения, указанного в этом атрибуте;
□ если атрибут
select
не определен, но сам элемент xsl:param
имеет дочерние узлы, то значением определяемого параметра по умолчанию будет фрагмент дерева, полученного в результате выполнения содержимого xsl:param
;
□ если атрибут
select
не определен и при этом сам элемент xsl:param
пуст, то значением параметра по умолчанию будет пустая строка.
Примеры
Элемент
создаст параметр, значением которого по умолчанию будет
4
. Точно такой же эффект будет иметь элемент
25
" и тем более не множество, состоящее из текстового узла со значением 25
. Значением параметра x
по умолчанию будет результирующий фрагмент дерева, корень которого будет иметь единственный текстовый узел со значением "25
" (рис. 5.3).
Рис. 5.3. Фрагмент дерева, который будет значением параметра x по умолчанию
Не стоит пугаться такой структуры в качестве значения параметра. То, что параметр
x
вдруг будет содержать дерево, ничуть не ограничивает его использование, ведь дерево при потребности может быть приведено к числу или к строке; к множеству узлов же не может быть приведен ни один тип данных.
Предупреждение
Напомним, что при приведении дерева к булевому типу, результатом всегда будет истина. Дерево всегда содержит как минимум корневой узел, и поэтому оно никогда не будет считаться пустым.
Определение параметра вида:
то есть когда в нем нет ни атрибута
select
, ни содержимого, присвоит параметру пустую строку, то есть будет эквивалентно
Точно так же, как и в случае с переменными, значение заданного в шаблоне параметра можно использовать в выражениях, добавляя перед именем параметра префикс "
$
". К примеру, значение нашего параметра x может быть получено конструкцией вида $x
.
Для того чтобы передать в шаблон определенные значения параметров, элементы, которые вызывают этот шаблон, должны содержать один или несколько элементов
xsl:with-param
, который мы рассмотрим чуть ниже. Глобальные параметры, объявленные элементами xsl:param
верхнего уровня, также могут быть переданы преобразованию, однако конкретный механизм реализации этой передачи целиком и полностью зависит от реализации конкретного процессора.
Область видимости параметров
Область видимости параметров определяется в точности так же, как область видимости переменных. Единственным, на что следует обратить здесь внимание — это то, что элементы
xsl:param
, определяемые в шаблонах, должны всегда быть его первыми дочерними элементами. Поэтому область видимости локальных параметров определяется несколько легче, чем область видимости локальных переменных: после определения параметр может использоваться в том шаблоне где угодно.
Прямым следствием из этого является то, что один шаблон не может иметь двух параметров с одинаковыми именами, поскольку их области видимости будут обязательно пересекаться, ведь один из параметров в любом случае будет следовать за другим.
Элемент xsl:with-param
Синтаксис этого элемента выглядит следующим образом:
name="имя"
select="выражение">
Как можно заметить, элемент
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. Вывод названия дня недели по номеру
Mon
Tue
Wed
Thu
Fri
Sat
Sun
Hmm...
Результатом вызова:
будет текстовый узел "
Mon
". Рассмотрим теперь случай, когда параметра передано не было:
Шаблон выведет задумчивое
Hmm...
, поскольку значение параметра day-number
будет по умолчанию нулем (атрибут select
имеет вид select="0"
) и в операторе выбора xsl:choose
сработает условие xsl:otherwise
.
Параметры могут быть использованы как в именованных, так и в неименованных шаблонах. Именованные шаблоны с параметрами ведут себя как самые настоящие функции — они могут вызываться с определенными параметрами вне зависимости от контекста, только чтобы выполнить какие-либо действия с переданными значениями. В случае обычных, неименованных шаблонов параметры могут предоставлять некую дополнительную информацию.
Пример
Представим себе описание меню в следующем формате:
Для того чтобы при обработке особым образом выделять текущую страницу, определим в шаблоне параметр
current
и будем выводить название страницы в элементе b
(от англ. bold — полужирный), если значение current
равно индексу данного пункта меню; если текущая страница и индекс пункта меню не совпадают, то выводиться будет ссылка.
Результатом выполнения шаблона
будет фрагмент меню вида
Home
News
Profile
Contact
Попробуем теперь обработать элементы
menuitem
, не указывая значение параметра current
:
Результат будет получен в виде:
Home
<а href="news.htm">News
<а href="profile.htm">Profile
Contact
Этот фрагмент выходящего документа легко объяснить. Вследствие определения:
значением параметра
current
по умолчанию является 1
, и поэтому в меню был выбран пункт с индексом 1
.
Мы упомянули, что значением параметра может быть дерево. Попробуем пояснить эту концепцию на примере генерации HTML-документа.
Итак, предположим, что мы генерируем выходящий документ следующим именованным шаблоном:
Title one
content
Параметр
head
по умолчанию будет содержать дерево, состоящее из элемента head
и его дочернего элемента title
, который содержит текст "Title one
". Результат выполнения вызова
мы можем видеть на следующем листинге:
Title one
content
Выделенный фрагмент относится к части дерева, которая была создана копированием значения параметра
head
.
Попробуем теперь передать в качестве параметра дерево, сгенерированное следующим шаблоном:
Title two
Для того чтобы передать результат выполнения этого шаблона в виде значения параметра
head
именованному шаблону head
, воспользуемся следующей конструкцией:
Выходящий документ будет получен в виде:
Title two
content
Выделенный фрагмент, как и в предыдущем случае, соответствует части документа, полученной при копировании значения параметра
head
.
Приведенные выше примеры демонстрируют, как можно собрать выходящий документ по кусочкам из фрагментов деревьев. При умелом использовании изложенные подходы позволяют добиться очень высокой гибкости и универсальности преобразований.
Параметры в XSLT практически полностью идентичны переменным. Они точно так же связывают с объектом имя, посредством которого в дальнейшем можно к этому объекту обращаться. Главным различием является то, что значение, данное параметру при инициализации, является всего лишь значением по умолчанию, которое может быть переопределено при вызове.
До сих пор мы говорили о шаблонах, как о правилах, часто используя эти слова как синонимы. Попробуем теперь немного сменить угол зрения и представить их как функции, каждая из которых преобразует некоторый узел и возвращает фрагмент дерева в качестве результата. С этой точки зрения параметры шаблонов являются ни чем иным, как аргументами этих функций.
Работа с параметрами обеспечивается двумя элементами —
xsl:paramxsl:with-paramЭлемент xsl:param
Синтаксически этот элемент задается как:
name="имя" select="выражение"> Элемент
xsl:templatexsl:paramxsl:paramЭлемент
xsl:paramname"user:param""i""myParam"Параметру может быть присвоено значение по умолчанию — то есть значение, которое будет использоваться в случае, если параметра с таким именем шаблону передано не было. Значение по умолчанию вычисляется следующим образом:
□ если в элементе
xsl:paramselect□ если атрибут
selectxsl:paramxsl:param□ если атрибут
selectxsl:paramЭлемент
создаст параметр, значением которого по умолчанию будет
4 2525x25Рис. 5.3. Фрагмент дерева, который будет значением параметра x по умолчанию
Не стоит пугаться такой структуры в качестве значения параметра. То, что параметр
xНапомним, что при приведении дерева к булевому типу, результатом всегда будет истина. Дерево всегда содержит как минимум корневой узел, и поэтому оно никогда не будет считаться пустым.
Определение параметра вида:
то есть когда в нем нет ни атрибута
selectТочно так же, как и в случае с переменными, значение заданного в шаблоне параметра можно использовать в выражениях, добавляя перед именем параметра префикс "
$$xДля того чтобы передать в шаблон определенные значения параметров, элементы, которые вызывают этот шаблон, должны содержать один или несколько элементов
xsl:with-paramxsl:paramОбласть видимости параметров
Область видимости параметров определяется в точности так же, как область видимости переменных. Единственным, на что следует обратить здесь внимание — это то, что элементы
xsl:paramПрямым следствием из этого является то, что один шаблон не может иметь двух параметров с одинаковыми именами, поскольку их области видимости будут обязательно пересекаться, ведь один из параметров в любом случае будет следовать за другим.
Элемент xsl:with-param
Синтаксис этого элемента выглядит следующим образом:
name="имя" select="выражение"> Как можно заметить, элемент
xsl:with-paramxsl:paramxsl:with-paramТаким образом, значение параметра, заданного в шаблоне, выбирается в соответствии со следующими положениями:
□ если в элементе, который вызывает этот шаблон, присутствует элемент
xsl:with-param□ если в элементе, который вызывает этот шаблон, элемента
xsl:with-paramЭлемент
xsl:with-paramxsl:apply-templatesxsl:call-templateВ качестве простого примера приведем шаблон, который выводит сокращение названия для недели по его номеру. Номер дня передается в шаблон параметром с именем
day-number Mon Tue Wed Thu Fri Sat Sun Hmm... Результатом вызова:
будет текстовый узел "
MonШаблон выведет задумчивое
Hmm...day-numberselectselect="0"xsl:choosexsl:otherwiseПараметры могут быть использованы как в именованных, так и в неименованных шаблонах. Именованные шаблоны с параметрами ведут себя как самые настоящие функции — они могут вызываться с определенными параметрами вне зависимости от контекста, только чтобы выполнить какие-либо действия с переданными значениями. В случае обычных, неименованных шаблонов параметры могут предоставлять некую дополнительную информацию.
Представим себе описание меню в следующем формате:
Для того чтобы при обработке особым образом выделять текущую страницу, определим в шаблоне параметр
currentbcurrent Результатом выполнения шаблона
будет фрагмент меню вида
HomeNewsProfileContactПопробуем теперь обработать элементы
menuitemcurrent Результат будет получен в виде:
Home<а href="news.htm">News<а href="profile.htm">ProfileContactЭтот фрагмент выходящего документа легко объяснить. Вследствие определения:
значением параметра
current11Мы упомянули, что значением параметра может быть дерево. Попробуем пояснить эту концепцию на примере генерации HTML-документа.
Итак, предположим, что мы генерируем выходящий документ следующим именованным шаблоном:
Title one content Параметр
headheadtitleTitle oneмы можем видеть на следующем листинге:
Title one contentВыделенный фрагмент относится к части дерева, которая была создана копированием значения параметра
headПопробуем теперь передать в качестве параметра дерево, сгенерированное следующим шаблоном:
Title two Для того чтобы передать результат выполнения этого шаблона в виде значения параметра
headhead Выходящий документ будет получен в виде:
Title two contentВыделенный фрагмент, как и в предыдущем случае, соответствует части документа, полученной при копировании значения параметра
headПриведенные выше примеры демонстрируют, как можно собрать выходящий документ по кусочкам из фрагментов деревьев. При умелом использовании изложенные подходы позволяют добиться очень высокой гибкости и универсальности преобразований.
ТЕЛЕГРАМКанал с обзорами, анонсами новинок и книжными подборками
Книжный Вестник
Бот для удобного поиска книг (если не нашлось на сайте)
Поиск книг
Свежие любовные романы в удобных форматах
Любовные романы
О психологии, саморазвитии и личностном росте
Саморазвитие
Детективы и триллеры, все новинки
Детективы
Фантастика и фэнтези, все новинки
Фантастика
Отборные классические книги
Классика
ВКОНТАКТЕБиблиотека с любовными романами, которая наверняка придётся по вкусу женской части аудитории
Любовные романы
Библиотека с фантастикой и фэнтези, а также смежных жанров
Фантастика
Самые популярные книги в формате фб2
Топ фб2
книги