Замыкание — когда функции представляют собой комбинацию кода и области видимости, в которой этот код исполняется.
Все JavaScript функции являются замыканиями. Основной фан при экспорте вложенной функции за пределы области видимости, в которой она была определена.

Теоретическую информацию можно прочесть в блоге Дмитрия Сошникова о замыканиях в ECMA.

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

1. Что окажется в консоли?
   var i;
   for(i=0; i<10; i++) {
       setTimeout(function(){console.log(i);}, 1000);
   }
2. Каким будет результат?
   var x = "глобальная";
   function g_func() {
       var x = "локальная";
       function l_func() { alert(x); }
       return l_func;
   }
   func = g_func();
   func();
   Почему?
3. Какое значение будет у arr[2](), arr[arr.length]()?
   function create(number) {
       var arr = [];
       for (var i=1; i<number; i++) {
           arr[i] = function() { alert(i*i) };
       }
       return arr;
   }
   var arr = create(100);

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

1. Обрабатывать элементы в дефолтном пространстве имён (namespace). Если исходный XML-документ содержит декларацию дефолтного пространства имён xmlns="something", то каждый раз, когда вы ссылаетесь на имя элемента в XPath-выражении или значении атрибута match, вы должны ясно давать понять, что вы имеете в виду элементы из этого пространства имён. В XSLT 1.0 вы должны связать префикс с этим пространством имён (например xmlns:p="something" в элементе xsl:stylesheet) и затем везде использовать этот префикс, напимер, match="p:chapter/p:section". В XSLT 2.0 есть альтернатива — задекларировать в элементе xslt:stylesheet default-xpath-namespace="something".
2. Использование относительных путей. xsl:apply и xsl:for-each принимают текущий узел; в рамках «цикла» пути должны быть написаны относительно текущего узла. Например,
   <xsl:for-each select="chapter"><xsl:value-of select="title"/></xsl:for-each>
   Распространённая ошибка — использование абсолютных путей внутри цикла (например select="//title") или повторение имени контекстного узла в относительном пути (select="chapter/title").
3. Переменные содержат значения, а не фрагменты синтаксических выражений. Некоторые люди думают, что ссылка на переменную $x подобна макросу, распространяющемуся и на синтаксис xPath-выражений путйм буквального замещения — как в языках типа shell. Это не так: вы можете использовать переменные только там, где вы можете использовать значение. Например, если $N содержит строку 'para', то выражение chapter/$N не означает того же, что и chapter/para. Вместо этого вам нужно chapter/*[name()=$N]. Если переменная содержит что-то более сложное, чем просто имя (например, запись xPath-пути), вам понадобится расширение, подобное saxon:evaluate(), чтобы вычислить это.
4. Шаблонные правила xsl:apply-templates — это не расширенные возможности языка для подвинутых пользователей. Это самые основные, фундаментальные конструкции в XSLT. Не откладывайте тот день, когда вы начнёте их использовать. Если вы не используете их, вы делаете свою жизнь излишне сложной.
5. XSLT принимает дерево на вход и отдаёт дерево на выходе. Непонимание этого является причиной многих разочарований, которые возникают у новичков в XSLT. XSLT не может обработать вещи, которые не представлены в дереве, предоставленном XML-парсером (области CDATA, ссылки на сущности (entity), XML-декларация), и не может сгенерировать эти вещи на выходе. Если вы думаете, что вам это необходимо, спросите «почему?». Возможно что-то не так с вашими требованиями или замыслом.
6. Пространства имён (namespace) — это трудно. Нет лёгкого способа опровергнуть это. Возможно, это требует отдельной статьи. Разгадка в понимании модели пространств имён. Пространства имён проявляются в двух ипостасях:
   1. Каждый элемент или атрибут имеет имя, состоящее из префикса, собственно имени и URI.
   2. Элементы обладают узлами пространств имён, представляющими все префикс-uri соответствия в границах этого элемента.
   Когда вы поймёте это, вы сможете понять особенности различных правил и их влияние на пространства имён в результирующем дереве. Чаще всего, всё, что вам нужно делать, это гарантировать, что создаваемые вами элементы находятся в верном пространстве имён, всё остальное произойдёт само собой.
7. Не используйте disable-output-escaping. Некоторые люди используют эту магическую приправу, но не понимают, что она делает. Они надеются, что это может заставить код работать лучше. Этот атрибут только для профессионалов, и профессионалы используют это только как последнее средство спасения. В 95% случаях, если вы встретили в преобразовании disable-output-escaping, это говорит о том, что автор был новичком, не понимающим, что он делает.
8. Инструкция создаёт точную копию исходного дерева, пространств имён и всего остального. (Есть исключение — в XSLT 2.0 вы можете сказать copy-namespaces="no"). Если вы хотите скопировать дерево с изменениями, вы не можете использовать xsl:copy-of. Вместо этого используйте шаблон идентичного преобразования: шаблон, который использует создание поверхностной копии элемента и применяет applies-templates ко всем его потомкам, дополненный шаблонами, переопределяющими это поведение для отдельных элементов.
9. Не используйте
   <xsl:variable name="x"><xsl:value-of select="y"/></xsl:variable>

   Вместо этого используйте

   <xsl:variable name="x" select="y"/>
   Последняя запись короче, более действенна при исполнении, и в любом случае она корректна.
10. Когда вам нужно найти информацию, используйте ключи. Также как и в случае с шаблонами, не откладывайте изучение использования ключей и не выбрасыйте их из головы как «продвинутую» возможность. Это важнейший инструмент разработки. Поиск информации без использования ключей сродни забиванию гвоздей отвёрткой.

Я использовала последнюю на данный момент версию 0.9a1, которая заявлена как «альфа». Но это не имеет значения, потому что предыдущая версия тоже альфа. Но у 0.9 нет опубликованных Embedded-архивов, так что собирать свой редактор придётся самостоятельно. Исходники можно скачать с их сайта.

Для сборки необходимо создать .json-файл, например, mybespin.json. В этом файле декларируются необходимые настройки собираемого редактора.

Мой вариант позволяет иметь белую тему и подсветку html. Также обязательно необходимо указать плагины для подсветки js и css, т.к. этот код может входить в html.

Затем необходимо запустить следующую команду:

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

2.4.1 Элемент <xsl:stylesheet>

Элемннт xsl:stylesheet — это обычно корневой элемент XSLT-преобразования.

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

2.4.2 Элемент <xsl:output>

Далее мы определяем метод вывода. Спецификация XSLT задаёт три метода вывода: xml, html и text. Мы создаём HTML-документ, поэтому мы ходим использоваться метод вывода html. Вдобавок к этим трём методам XSLT-процессор может задавать свои собственные методы вывода, так что посмотрите документацию вашего XSLT-процессора на предмет каких-либо альтернатив.

С разными методами вывода используются разные атрибуты. Например, если мы используем метод xml, мы можем использовать doctype-public и doctype-system, чтобы определить его как публичный или локальный для использования в DTD (Document Type Declaration). Если вы используете методы xml или html, вы можете воспользоваться атрибутом indent, чтобы задать возможность ставить или нет дополнительные пробелы при выводе. Обсуждение элемента xsl:output в приложении A рассматривает все эти детали.

2.4.3 Наш первый <xsl:template>

Наш первый шаблон будет на "/", это XPath выражение для корневого элемента документа.

2.4.4 <xsl:template> для <greeting>

Второй <xsl:template> элемент обрабатывает люой элемент <greeting> в нашем исходном XML-документе.

2.4.5 Встроенные правила шаблонов

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

2.4.5.1 Встроенное правило для элементов и корневого узла

Этот шаблон преобразует корневой элемент и любой из его потомков. Это преобразование гарантирует, что рекурсивное преобразование будет продолжено, даже если для данного элемента не определён никакой шаблон.

Это означает, что если содержание документа выглядит так:

2.4.5.2 Встроенные правила для mode

Этот шаблон гарантирует, что элемент или корневой узел обрабатывается, невзирая на то, что любой mode может иметь влияние. (Смотрите пункт 4.3.2 в главе 4 для подробной информации об атрибуте mode).

2.4.5.3 Встроенный шаблон для текстовых узлов и атрибутов

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

2.4.5.4 Встроенный шаблон для комментариев и управляющих инструкций

Этот шаблон не делает ничего.

Встроенный шаблон для пространств имён (namespace)

Этот шаблон не делает ничего.

Эффективное и рациональное использование XSL-преобразований требует понимания, как использовать XSL в качестве функционального языка, что означает понимание рекурсии. Эта статья знакомит с ключевыми идеями рекурсии и особенностей её использования в XSL. Также объяснены приёмы для оптимизации преобразования XML и избегания ошибок при использовании рекурсии. Каждая идея или метод сопровождаются примерами кода.

Сейчас в мире преобладают императивные языки программирования. Наиболее популярные языки — Java, C (и его различные виды), Visual Basic и другие — на высоком абстрактном уровне работают, в основном, одинаково: вы задаёте некоторые переменные, вызываете функции или операторы, которые меняют эти переменные, и возвращаете результат. Это сильное приближение к программированию, и это, конечно, не всё.

Языки программирования другой породы, пока менее привычной, по крайней мере также сильны как их процедурные «коллеги». Эти языки названы функциональными или декларативными языками. Программы, написанные на этих языках, могут только однажды определить переменные, и никогда не могут поменять хранимое значение однажды определённой переменной. Язык программирования XSL и функциональный, и декларативный. Это означает, что разработчики, привыкшие писать на Java или C, и изучающие XSL часто чувствуют себя не в своей тарелке, применяя самые передовые особенности XSL.

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

Введение в рекурсию на примере

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

Рассмотрим функцию, которая высчитывает факториал от некоторого положительного целого. Вкратце, факториал числа — это число, полученное путём умножения всех предшествующих ему чисел. Так, факториал от 4 (или 4!) — 1*2*3*4 = 24. Распечатка 1 показывает один из способов написать эту функцию на Java:

Распечатка 1. Решение задачи про факториал с использованием цикла на Java

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

Распечатка 2. Решение задачи про факториал с использованием рекурсии на Java

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

В общем случае, рецепт создания рекурсивной функции включает в себя три ингредиента: условие выхода, код операции и рекурсивный вызов самого себя. В случае факториала, я вычисляю его для n путём вычисления факториала для n-1, n-2, n-3 и т.д. пока функция не достигнет условия выхода из серии — значения 1.

Так, если сейчас идея рекурсии ещё кажется немного смущающей, вы могли бы прервать чтение этой статьи и либо проследовать по некоторым ссылкам на эту тему в разделе Ресурсы, либо попробовать написать несколько функций самостоятельно (например, напишите функцию для расчёта n-го числа из ряда Фибоначчи).

Общие использования рекурсии в XSL

Два общих сценария использования рекурсии в XSL такие:

• Когда у вас есть набор повторяющихся значений в исходном XML, и вы хотите, чтобы результат преобразования отражал что-то, касающееся всех этих значений. Например, если у вас есть каталог товаров в XML, и вы хотите представить эти товары в соответствии с общей ценой, вы захотите найти совокупную цену, используя рекурсивный шаблон.
• Когда исходный XML содержит число x в теге, например <countTo number="5"/>, и вы хотите представить некоторую информацию x раз в результирующей выдаче. Факториал — типичный пример такого случая, но я рассмотрю более сложный пример немного позже.

Я покажу рекурсивное решение, написанное на XSL для обоих сценариев, но сначала давайте взглянем на пример про факториал, решенный на XSL:

Распечатка 3. Решение задачи про факториал с использованием рекурсии на XSL

Этот шаблон содержит все «игредиенты» из рецепта для Java-рекурсии. Здесь есть условие выхода (проверка на равенство единице или нет): если условие выхода не выполняется, шаблон делает рекурсивный вызов самого себя (хранимый в переменной recursive_result). Наконец, для получения конечного результата совершается операция умножения между исходным числом и рекурсивно полученным значением. Вы также могли заметить, что XSL частно требует намного больше кода, чем решение той же задачи в других языках. Это всего лишь часть неоднозначностей в языке преобразования, который согласовывается с XML.

Рекурсия, вариант 1: Суммирование сквозь множество элементов

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

Предположим, у вас есть каталог товаров, который выглядит походим на XML в Распечатке 4 (кстати, вы можете скачать весь XML и XSL, и весь другой код из этой статьи по ссылке в Ресурсах).

Распечатка 4. Пример XML с продуктами

Цель в том, чтобы добавить первую цену из этого списка товаров к сумме всех других цен, пока вы не получите суммарный результат. Вы можете осуществить это при помощи XSL, показанного в Распечатке 5.

Распечатка 5. Проход по узлам с использованием обычной XSL-рекурсии

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

Рекурсия, вариант 2: Итерация на числе

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

Решение, как правило используемое разработчиками, незнакомыми с рекурсивными методами — это написать программу, которая разбирает XML и дополняет элементами для каждого ряда или столбца. Однажды написанный элемент <xsl:for-each> может решить задачу без рекурсивных шаблонов. Несмотря на то, что это решение обеспечивает подходящую выдачу, у него есть большой недостаток. Этот метод на самом деле удваивает объём работы для обеспечения финального результата преобразования. Этот недостаток чрезвычайно заметен в клиент-серверной модели, когда сервер посылает XML и XSL для преобразования на клиентской стороне. В таком случае всё продуктивности, обычно реализованные на сервере, теряются за счёт увеличения XML.

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

Цель состоит в том, чтобы преобразовать это в HTML, представляющий таблицу, похожую на:

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

Распечатка 6. Повторение по числу с использованием основной XSL-рекурсии

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

Оптимизация паттернов рекурсии в XSL

К сожалению, использование рекурсии во многих XSL-процессорах имеет один значительный недостаток при работе с большими объемами данных. Также слишком легко достигнуть переполнения стека (Stack Overflow) или нехватки памяти (Out of Memory) с функциями, которые достигают глубины порядка 10000. Если вы пытаетесь суммировать цены в каталоге с более чем 10000 товарами, вы можете столкнуться с проблемами.

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

Оптимизация рекурсии 1. Разделяй и властвуй

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

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

Используя подход «разделяй и властвуй», вы не ощутите никакой экономии, в цифрах, по числу операций сложения, которые должны быть выполнены. Экономия будет заключаться в том, что операции сложения не ожидают того, чтобы все числа были получены и поставлены в очередь в стек рекурсии для выполнения операции. XSL-код в Распечатке 7 показывает такой способ.

Распечатка 7. Прохождение по узлам с использованием метода «разделяй и властвуй»

Операция сложения происходит каждый раз, когда разделённый список достигает длины 1 (это является условием выхода), и производится до того, как какая-нибудь обработка произойдёт со второй частью листа. При использовании этой техники глубина рекурсии никогда не превысит log₂ от количества элементов в списке, что, конечно, экспоненциально увеличивает возможное число товаров в списке для этого подсчёта.

Оптимизация рекурсии 2. Сегментация

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

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

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

Вы можете видеть пример техники Сегментации в шаблоне Распечатки 8, который берёт список узлов и длину сегмента и использует оригинальный шаблон для цен на этих маленьких частях.

Распечатка 8. Обход узлов с использованием техники сегментации

Использование подхода Сегментации лучше, чем подхода «Разделяй и властвуй» уменьшает накладные расходы в большинстве случаев, но не предлагает особенной выгоды по глубине рекурсии. Какой же следует использовать? Ответ — как вы можете увидеть по следующей оптимизации — оба.

Оптимизация рекурсии 3. Сочетание Сегментации и «Разделяй и властвуй»

Вы можете объединить техники «Разделяй и властвуй» и Сегоментации, чтобы

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

В этом способе пороговый уровень передаётся в рекурсивный шаблон, через список узлов (или другие данные, которыми опрерируют). Здесь «Разделяй и властвуй» изменён, чтобы работать как менеджер сегментации. Если размер переданного списка больше, чем пороговое значение, список делится надвое и шаблон рекурсивно вызывается для обеих половин. Другими словами, вы используете основной рекурсивный шаблон, чтобы вычислять результаты, как и в Сегментации.
Распечатка 9 показывает этот способ на следующих XSL-шаблонах.

Распечатка 9. Обход узлов с использованием составной техники «Разделяй и властвуй» и Сегментации

Оптимизация рекурсии 4. Tail Recursion

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

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

Основная идея Tail Recursion — это избавление от хранения какой-либо статической информации в рекурсивных шагах. Вся информация, которая нужна, на каждом шаге передаётся как параметры функции вместо того, чтобы храниться на более высоком уровне в стеке рекурсии. Это позволяет XSLT-процессору работать с рекурсивной функцией как с циклом в процедурном языке.

Взгляните на Распечатку 10 примера с ценами с Tail Recursion.

Распечатка 10. Проход по узлам с использованием Tail Recursion

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

Заключение

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

Вообще, задачи, работающие для малых объёмов данных, не требуют применения какой-либо из этих оптимизационных техник. Хотя, если малость объёма данных не гарантирована, выбор ограничен технологией, используемой в преобразовании. Если ваш XSLT-процессор распознаёт Tail Recursion, то лучше всего использовать этот способ. Если вы не можете убедиться, что преобразовательня технология умеет распознавать Tail Recursion, то наиболее предпочтительна комбинированная техника. Пороговое значение обычно лежит в диапазоне от 5 до 30 в зависимости от задачи.

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

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

Эта статья представляет список лучших приемов, используемых для написания XSLT-преобразований. Эта статья может быть использована как направление к лучшему пути достижения нужных результатов в XSL. Она предназначается для разработчиков, которые знакомы с основами XSL, но нуждаются в указателе на действенный путь программирования на XSL. Информация в этой статье основана на моём собственном опыте в XML и XSL. Список лучших приемов составлен по различным источникам, чтобы сделать всеобъемлющий документ, который будет расти, если найдётся больше хороших приемов. Если у вас есть несколько очень хороших приёмов, которым вы следуете и которых нет в этом списке, скиньте мне на email pboundre@gr.com.

Подключение внешних файлов — правильный путь

Есть три способа включения внешних файлов в ваш xsl:

1. Если у вас есть дополнительные HTML-файлы, которые вы хотите включить в ваш результат без изменений, возможно самый простой путь получить его в вашем результирующем дереве — это включить его как внешнюю синтаксическую сущность (entity) в преобразование. Это влечет за собой объявление сущности и обращение к ней в вашем преобразовании.

   header.html:

   <table>
     <tr>
       <td><a href="/">Home</a></td>
       <td><a href="/movies/">Movies</a></td>
       <td><a href="/shop/">Shop</a></td>
     </tr>
   </table>

   data.xsl:

   <?xml version="1.0"?>
   <!DOCTYPE xsl:stylesheet [
   <!-- declares header.html as an external parsed entity
   -->
   <!ENTITY header SYSTEM "header.html">
   ]>
   <xsl:stylesheet version="1.0"
   xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
       <xsl:template match="/">
           <html>
               <head><title>People</title></head>
               <body>
               <!-- includes header.html directly -->
               &header;
               <xsl:apply-templates />
               </body>
           </html>
       </xsl:template>
   </xsl:stylesheet>
2. У вас есть дополнительные XML-файле, которые вы хотели бы преобразовать и включить в документ, над которым вы работаете.
   Если у вас есть XML-файл, который вы хотели бы включить в результат, вам нужно использовать функцию document(), чтобы поучить доступ к информации, и вам нужны шаблоны в вашем преобразовании, чтобы обработать их и включить в результирующее дерево:

   header.xml:

   <menu>
       <item href="/">Home</item>
       <item href="/movies/">Movies</item>
       <item href="/shop/">Shop</item>
   </menu>

   data.xsl:

   <?xml version="1.0"?>
   <xsl:stylesheet version="1.0"
   xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
       <xsl:template match="/">
           <html>
               <head><title>People</title></head>
               <body>
                   <!-- applies templates to the information contained in header.xml -->
                   <xsl:apply-templates select="document('header.xml')"/>
   
                   <!-- applies templates to the input file -->
                   <xsl:apply-templates />
               </body>
           </html>
       </xsl:template>
      
       <!-- transforms the XML in header.xml into the table we want -->
       <xsl:template match="menu">
           <table>
               <tr>
                   <xsl:for-each select="item">
                       <td><a href="{@href}"><xsl:value-of select="."/></a></td>
                   </xsl:for-each>
               </tr>
           </table>
       </xsl:template>
   </xsl:stylesheet>
3. У вас есть внешние дополнительные XSLT-файлы, которые вы бы хотели использовать, чтобы формировать результирующее дерево:
   Пусть у вас есть входящий XML-документ, который включает включает некоторую информацию, нужную вам как и остальные данные на странице, вы захотите импортировать (import) или включить (include) преобразования для них, так чтобы шаблоны, определённые в них использовались будто они часть основного преобразования. То, что вам нужно: xsl:import или xsl:include — зависит от того, хотите ли вы переопределять шаблоны (или часть из них), которые заданы во включаемом преобразовании. Если хотите, используйте xsl:import, в противном случае — xsl:include.

   data.xml

   <?xml version="1.0"?>
   <doc>
       <menu>
           <item href="/">Home</item>
           <item href="/movies/">Movies</item>
           <item href="/shop/">Shop</item>
       </menu>
       <people>
           <person age="50" name="larry"/>
           <person age="50" name="larry"/>
       </people>
   </doc>

   header.xsl:

   <?xml version="1.0"?>
   <xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
       <xsl:template match="menu">
           <table>
               <tr>
                   <xsl:for-each select="item">
                        <td><a href="{@href}"><xsl:value-of select="." /></a></td>
                    </xsl:for-each>
                 </tr>
             </table>
         </xsl:template>
   </xsl:stylesheet>

   data.xsl:

   <?xml version="1.0"?>
   <xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
   <!-- includes the templates from theheader.xsl stylesheet -->
   
       <xsl:include href="header.xsl" />
   
       <xsl:template match="/">
           <html>
               <head><title>People</title></head>
               <body>
                   <!-- applies templates to the menu definition to create the header - the templates come from header.xsl -->
                   <xsl:apply-templates select="doc/menu" />
                   <!-- applies templates to the data to create the rest of the document -->
                   <xsl:apply-templates select="doc/people" />
               </body>
            </html>
         </xsl:template>
         ...
   </xsl:stylesheet>

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

Используйте XSL шаблоны проектирования (patterns)

Метод Кая для нахождения пересечения, разности и дизъюнкции множеств

Единственная операция над множествами, предоставляемая XSLT, — это объединение. Оно может быть описано с использованием оператора объединения из XPath и XSLT — «|». Можно выразить пересечение двух наборов узлов (node set) на чистом XPath. Этот способ был открыт Майклом Каем (Michael Kay) и известен как метод Кая (Kaysian method).

Пример:

Результат:

Метод Вендела Пая для нерекурсивного цикла

Метод Вендела Пая (Wendell Pie) демонстрирует способ избежать XSLT-рекурсии при применении циклов.

Пример:

Требующийся результат:

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

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

где $st определено как document(''), то есть корневой узел преобразования.

Метод условной выборки Оливера Беккера

Воможность XPath выбирать список узлов, основываясь на сложных условиях, очень мощная. Хотя ей недостаёт возможностей для определения строки как противоположного набору узлов. Вам часто нужно использовать навороченную xsl:choose конструкцию только чтобы определить, что-то вроде «в случае 1 используй строку 1, в случае 2 — строку 2, ..., в случае N — строку N.?

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

Теперь о том, как это сделать:
Мы хотим получить XPath-выражение, которое возвращает строку, когда некоторое заданное условие истинно, и возвращает пустую строку, если это условие ложно. Можно условиться, что true — это „1“, а false — это „0“. Но как подогнать „1“ к какой-то строке? Какую функцию для работы со строкой мы могли бы использовать? substring() кажется достаточно удобной. А вот и трюк: мы можем использовать substring() только с двумя аргументами: substring(str, nOffset) возвратит остаток строки str, начинающийся с позиции nOffset.

В частности:
substring(str, 1) возвращает целую строку
substring(str, [очень большое число]) возвратит пустую строку, если это большое число гарантированно больше, чем длина строки.

Таким образом, выражение, которое мы могли бы использовать, будет:

и мы хотим, чтобы exp(условие) было 1, если условие истинное и Infinity, если условие ложное.

Мы выражаем exp(условие) так:
1 div условие, потому что булево значение сначала преобразуется в число (true — в 1, а false — в 0), мы получим в точности:

Итог:
XPath-выражение, возвращающее одну строку, если условие истинно и другую, если оно ложно, такое:

Впервые это было использовано Оливером Беккером (Oliver Becker) и названо как метод Беккера.

Например:
Я хочу написать темплейт, который создаёт текст: „My department“, если передан параметр „IT“ и текст „Some other department“, если значение параметра другое.

Конечно, никаких xsl:if или xsl:when не допускается.

Пример кода:

Используйте метод Мюнха для группировки

Группировка часто плохо осуществляется в XSL. Обычно эта задача возникает, когда вы получаете XML-вывод (несгруппированный) из базы данных и должны сгруппировать его средствами XSL. База данных обычно выдаёт вам результаты, структурированные согласно записям в ней. Например, давайте рассмотрим таблицу служащих, из которой получается такой XML:

Требуется такой вывод:
Finance
Adheet Bondre
Jeremy King

IT
Prathit Bondre
Sinan Edil

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

Есть два шага на пути к решению:

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

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

Определив таких сотрудников, легко найти их департаменты и собрать вместе всех сотрудников из одного и того же департамента:

Проблема этого метода в том, что он включает в себя два XPath-выражения, вычисление которых потребует много ресурсов для больших XML-документов. Поиск по всем предыдущим братьям с осью 'preceding-sibling' занимает много времени, если вы ближе к конце записей. Кроме того, получение всех контактов определённых департаментов каждый раз включает в себя поиск одного сотрудника.

Метод Мюнха

Этот метод разработан Стивом Мюнхом (Steve Muench) для представления этих функций более эффективным способом с использованием ключей. Ключи работают путём назначения значения ключа узлу и дают прямой доступ к узлу через такое значение. Если элементов, у которых один и тот же ключ, много, то все эти элементы найдутся, когда вы воспользуетесь этим ключом. В сущности, это означает, что если вы хотите сгруппировать множество узлов согласно какому-то свойству узла, вы можете использовать ключи.

В примере выше мы хотим сгруппировать сотрудников согласно их департаментам, поэтому мы создаём ключ, который назначает каждому сотруднику значение ключа, которое берётся из департамента этого сотрудника. Узлы, которые мы хотим сгруппировать должны быть подставлены в атрибут „match“. Значение ключа, которые мы хотим использовать записывается в атрибут „use“.

Однажды определив ключ, зная департамент, мы можем быстро получить доступ ко всем сотрудникам этого департамента.
Например, ключ key('employees-by-department', 'IT') даст записи с департаментом „IT“.

Однако, первое, что нам надо сделать, — это определить, какие бывают департаменты, что включает в себя нахождение первого сотрудника в XML для каждого департамента. Здесь мы снова можем использовать ключи. Мы знаем, что сотрудник будет частью списка узлов, которые можно получить по ключу данного департамента: вопрос в том, будет ли он первым в этом списке (который упорядочен как записи в XML-документе) или ниже? Нас интересуют только записи, идущие первыми в списке.
Выяснение, является ли сотрудник первым в списке, возвращённом по ключу, подразумевает сравнение узла employee с первым узлом в списке. Этот способ также может быть использован для получения отдельных элементов в XML-файле. Есть пара характерных способов проверки, идентичны ли два узла:

1. Сравнить уникальные идентификаторы, сгенерированные для узлов (используя generate-id()):
   employee[generate-id() = generate-id(key('employees-by-department', department)[1])]
2. Посмотреть, сколько узлов включает в себя результат объединения двух узлов: один или два — узлы не могут повторяться во множестве, так что если там только один узел, то они должны быть одним и тем же узлом:
   employee[count(.|key('employees-by-department', department)[1]) = 1]

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

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

Использование xsl:import

Используйтер <xsl:import>, чтобы подключить общие, основные правила в преобразование, задуманное для определённых трансформаций. Если можете, не импортируйте больше шаблонов, чем вам нужно.

Использование статического HTML

Для любых „неизменных“ порций html на странице (таких как шапка, подвал, элементы навигации) определённо более эффективно хранить фрагменты как внешние xml-файлы и копировать их в результирующее дерево используя xsl:copy-of и функцию document(), чем использовать именованные шаблоны или xsl:import.

Разница между call и apply templates

Call-template, в отличие от aplly-templates, не меняет контекстный (текущий) узел. И атрибут select имеет значение только в aplly-templates, и не имеет в call-template.

Повторное использование кода и рефакторинг

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

Например. Допустим, вы хотите обработать элементы item, имея один шаблон для узлов со значением атрибута type — 'Book', один — для 'CD', и один для всех остальных.

И они переопределят шаблон, привязанный к „*“ (любой элемент). Шаблоны с более точной адресацией будут иметь более высокий приоритет для сопоставления.

Автоматизируйте XSL-документацию

Программисты обычно ненавидят документацию и поэтому обычно не пишут её. Javadocs в Java даёт большое утешение программистскому сообществу, обеспечивая способ автоматически генерировать документацию. Есть похожий инструмент, который написан для XSL и называется xsldoc. Его можно бесплатно скачать на www.xsldoc.org.
Этот инструмент обеспечит автоматизированный, стандартизированный и надежный способ создания документации о ваших XSL-файлах, и поскольку он управляется из командной строки, то может стать частью процесса сборки.

Не изобретайте велосипед, используйте XSLT-библиотеку

XSLT-библиотека — это open source репозиторий XSL-шаблонов, которые были написаны и проверены. В библиотеке множество шаблонов для работы со строками, датами, обработки узлов и т.п., что может быть эффективно использовано в ваших xsl-файлах. Так что сэкономьте своё время с этой библиотекой. Её можно посмотреть по адресу http://xsltsl.sourceforge.net.

Уменьшайте размер ваших HTML-документов

Уменьшайте размер вашего HTML, используя indent=»no" в теге <xsl:output/>. Этот атрибут сообщает XSLT-процессору не делать отступы в HTML-документе, что делает файлы меньше и они грузятся быстрее.

2.1. Цели этой главы

К концу этой главы вы будете знать:

• Как создать основной шаблон
• Как использовать шаблон для преобразования XML-длкумента
• Как XSLT-процессор использует шаблон для преобразования документа
• Структуру XSLT-шаблона

2.2 Преобразование «Hello, world»

Продолжая традицию примера «Hello, world», начатую Брайаном Керниганом (Brian Kernighan) и Денисом Ритчи (Dennis Ritchie) в кгиге «Язык программирования C» (The C Programming Language (Prentice Hall, 1988), мы будем преобразовывать «Hello, world» XML-документ.

2.2.1 Наш пример документа

Сначала мы посмотрим на наш пример документа. Это простой XML-документ, учитывающий XML-спецификацию версии 1.0, включающий в себя знаменитое дружественное приветствие к миру:

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

2.2.2 Пример шаблона

Это XSLT-шаблон, который определяет, как преобразовать XML-документ:

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

2.2.3 Преобразование XML-документа

Чтобы преобразовать XML-документ, используя XSLT-шаблон, запустите эту команду:

Эта команда преобразует документ greeting.xml, используя шаблоны, найденные в файле greeting.xsl. Результаты преобразования записываются в файл greeeting.html. Проверьте получившийся файл в вашем любимом браузере, чтобы удостовериться, что преобразование работает верно.

2.2.4 Результаты преобразования

XSLT-процессор свормировал следующие результаты:

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

Поздравляю! Вы только что использовали XSLT для преобразования XML-документа.

2.3 Как обрабатываются шаблоны

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

2.3.1 Разбор шаблона

До того как XSLT-процессор сможет обработать ваш шаблон, ему нужно прочесть его. По большому счету не имеет значения, как XSLT-процессор считывает информацию из вашего шаблона. Для наших целей, мы будем только притворяться, что XSLT-процессор может волшебным образом находить всё, что ему нужно, в нашем файле. (Если вам действительно нужно знать, Xalan использует оптимизированную табличную структуру для представления шаблона; другие процессоры могут использовать этот подход или что-то другое.)

Наше преобразование включает три вещи: элемент <xsl:output>, который определяет HTML в качестве выходного формата и два элемента <xsl:template>, которые определяют, как части нашего XML-документа будут преобразованы.

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

2.3.3 Намылить, прополоскать, повторить

Наконец, мы готовы начать саму работу преобразований XML-документа. XSLT-процессор может определить несколько свойств, основываясь на вашем преобразовании (в первом примере это было определение метода вывода как HTML), тогда он начнёт обработку следующим образом:

• У меня есть какие-нибудь узлы для обработки? Узлы, предназначающиеся для обработки представлены как контекст (context). Вначале контекстом является корень XML-документа, но он изменяется по ходу преобразования. Мы поговорим о контексте более подробно в следующей главе.

Пока в контексте есть какие-либо узлы, делается следующее:

• Получаю следующий узел из контекста. Есть ли у меня какой-нибудь шаблон <xsl:template>, чтобы сопоставить с ним? (в нашем примере следующий узел в корневом элементе, представленным в XPath синтаксическим выражением «/».) Шаблон, которые соответствует узлу — это что-то, начинающееся с <xsl:template match="/">.
• Если один или более шаблонов <xsl:template> подходят, беру нужный и обрабатываю его. (Нужный — это наиболее уточнённый шаблон. Например, <xsl:template match="/html/body/h1/p"> более точен, чем <xsl:template match="p">.) Если подходящих шаблонов нет, XSLT-процессор использует некоторые встроенные правила. Об этом позже.

Заметим, что это рекурсивная модель обработки. Мы обрабатываем текущий узел, находя подходящий шаблон xsl:template для него. Этот шаблон xsl:template может в свою очередь вызывать другие шаблоны xsl:template, которые вызывают следующие. Эта модель вырабатывается привычкой, и пока к ней привыкать.

Если поможет, вы можете думать о корневом элементе (<xsl:template match="/">) как о методе main в C, C++ и Java. Не имеет значения, сколько кода вы написали, всё начинается с main. Также не имеет значения, сколько шаблонов <xsl:template> вы определили в своём преобразовании, всё начинается с <xsl:template match="/">.

2.3.4 Прогулка по нашему примеру

Давайте мысленно возвратимся к нашему примеру и посмотрим, как XSLT-процессор преобразует документ:

1. XSLT-пеобразование разбирается и превращается в древовидную структуру
2. XML-документ также разбирается и превращается в древовидную структуру. (Не слишком беспокойтесь о том, на что похожа древовидная структура и как это работает; пока достаточно помнить, что XSLT-процессор знает всё о том, что есть в XML-документе и XSLT-преобразовании.)
3. XSLT-процессор сейчас на корневом элементе. Это исходный контекст.
4. Есть шаблон xsl:template, который подходит корню документа:
   <xsl:template match="/">
   <xsl:apply-templates select="greeting"/>
   </xsl:template>
   Один обратный слеш (/) в XPath выражении означает «корень документа».
5. Сейчас обработка началась снова внутри шаблона xsl:template. Наша единственная инструкция здесь — применить какой-либо шаблон, могущий быть примененным к некоторому элементу greeting в текущем контексте. Текущий контексте в рамках этого шаблона определяется значением атрибута match элемента xsl:template. Это означает, что XSLT-процессор ищет какие-либо элементы greeting и шаблон xsl:template, что применить второй шаблон из нашего преобразования:
   <xsl:template match="greeting">
       <html>
           <body>
               <h1>
                   <xsl:value-of select="."/>
               </h1>
           </body>
        </html>
   </xsl:template>
6. Сейчас мы в шаблоне xsl:template для элемента greeting. Первые три элемента в этом шаблоне (<html>, <body> и <h1>) — это HTML-элементы. Поскольку они не определены в декларации пространств имён, XSLT-процессор прогоняет эти HTML-элементы через выходной поток неизменными.
7. В середине нашего шаблона есть элемент xsl:value-of. Этот элемент выводит значение чего-либо в выходной поток. В этом случае, мы использует XPath выражение . (одиночная точка), чтобы определить текущий узел. XSLT-процессор смотрит на текущий узел (элемент greeting, который мы сейчас обрабатываем) и выводит его текст.
   Поскольку наше преобразование — это XML-документ (мы постоянно твердим об этом, так?), мы должны закрыть теги <h1>, <body>, и <html>. На этой стадии мы закончили с этим шаблоном, так что контроль возвращается к шаблону, который вызвал нас.
8. Сейчас мы вернулись в шаблон для корневого элемента. Мы обработали всё greeting элементы, так что мы закончили с этим шаблоном.
9. В текущем контексте больше нет никаких элементов (существует только один корневой элемет), так что XSLT-преобразование закончено.
   ]]> http://toivonen.ru/books-articles/xslt-by-orelly/hello_world_example/introduction/obligatory-hello-world.html/feed http://toivonen.ru/notes/master_class/xslt_hello_world.html http://toivonen.ru/notes/master_class/xslt_hello_world.html#comments Sun, 12 Jul 2009 19:25:48 +0000 admin http://toivonen.ru/?p=148 Первый написанный XSLT-шаблоны — это страница, выводящая надпись «Hello, world!». Для работы с кодом используем программу IntelliJIDEA. В блоге Вадима Макишвили о работе с ней рассказано достаточно подробно.

   Свой первый шаблон мы ассоциируем с главной страницей. Каждая страница в нашем проекте представляется отдельным xml-файлом (сейчас — статическим, но в последствии они будут генерироваться на сервере). «Рыба» выглядит так:

   <?xml version="1.0" encoding="utf-8"?>
   <?xml-stylesheet type="text/xsl" href="../index.xsl"?>
   <page name="index">
       <!-- Содержание страницы -->
   </page>

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

   Чтобы написать XSLT-преобразование для этой страницы, нужно создать файл index.xsl. Содержание файла поначалу следующее:

   <?xml version="1.0" encoding="utf-8"?>
   <xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
       <!-- Здесь будет преобразование -->
   </xsl:stylesheet>

   XSL-шаблоны записываются в виде XML-файлов, поэтому для них действуют те же правила, что и для любых других XML-документов. Файл начинается с XML-декларации (первая строка). Всё теги заключены в один корневой тег xsl:stylesheet. Поскольку используется пространство имён (namespace) xsl, оно объявлено в корневом теге.

   Для того, чтобы после наложения XSLT получился бы вывод какой-либо информации, необходимо написать шаблон (template). Начнём с шаблона на корневой узел page:

   <xsl:template match="/page">Hello, world!</xsl:template>

   Этот код необходимо поместить в файл index.xsl в тег xsl:stylesheet. Запись match="/page" означает, что процессор применит перечисленные в шаблоне инструкции с корневому элементу с именем «page». То, что это должен быть именно корневой элемент, говорит знак слеш перед его именем.
   Значение атрибута match — это XPath — путь, описывающий положение узла (или узлов) в документе. Об XPath можно почитать на zvon.org.

   Предложенный шаблон выводит вместо корневого тега page то, что у него внутри. То есть надпись «Hello, world!»
   Более осмысленные шаблоны мы будем писать в следующий раз. Это будут шаблоны для формы авторизации и приветствия авторизованного пользователя.

   ]]> http://toivonen.ru/notes/master_class/xslt_hello_world.html/feed http://toivonen.ru/notes/master_class/xslt-site-preparing.html http://toivonen.ru/notes/master_class/xslt-site-preparing.html#comments Sat, 11 Jul 2009 18:03:39 +0000 admin http://toivonen.ru/?p=134 Итак, мы делаем сайт и учим XSLT.
   Сайт у нас будет на тему «календарь менструального цикла», потому что мы типа профессионалы, и для нас нет запретных тем.
   Движок на PHP, а шаблоны на XSLT. Их я и буду описывать.
   Для того, чтобы всё заработало, нам потребовалось установить модуль под Apache для выполнения XSLT-преобразований. Мы выбрали xslt_filter. Однако, выяснилось, что скомпилированный из предложенных исходников модуль не работает с EXSLT-функциями.
   Сначала мы убедились, что EXSLT-функции есть в нашей библиотеке libxslt. Для этого в консоли нужно написать
   xsltproc --dumpextensions

   Эта команда выводит список расширений, доступных в libxslt. Нужные нам EXSLT-функции были. Но xslt_filter с ними не работал. О том, как зарегистрировать функции мы узнали по этой ссылке. После перекомпиляции всё стало как надо.

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

   ]]> http://toivonen.ru/notes/master_class/xslt-site-preparing.html/feed http://toivonen.ru/notes/problems/prime-numbers-xpath.html http://toivonen.ru/notes/problems/prime-numbers-xpath.html#comments Sun, 21 Jun 2009 16:40:54 +0000 admin http://toivonen.ru/?p=128 Иногда мы на работе решаем интересные задачки. Вот, например, одна (почти первая) в постановке nop`а:

   Частный случай:
   Дан такой xml:

   <items>
      <item>1</item>
      <item>2</item>
      ...
      <item>N-1</item>
      <item>N</item>
   </items>

   т.е. выписаны все натуральные числа от 1 до N включительно. Про N ничего заранее не известно —
   большое, маленькое, еще какое-то — мы не знаем.

   Нужно. Написать xpath, выбирающий все item'ы с простыми числами.
   Подчеркиваю — xpath.
   Т.е. внутри тега xsl:stylesheet должен быть один примерно такой шаблон:

   <xsl:template match="/">
      <xsl:copy-of select="......."/>
   </xsl:template>

   и больше ничего — ни переменных, ни других шаблонов, ни функций.

   На выходе будет что-то типа:

   <item>2</item>
   <item>3</item>
   <item>5</item>
   <item>7</item>
   ...

   Решение следующее:

   <xsl:template match="/">
          <items>
              <xsl:copy-of select="items/item[not(preceding-sibling::item[(last() + 1) mod . = 0 and . != 1]) and . != 1]"/>
          </items>
   </xsl:template>

   Общая задача
   Усложненный вариант — все тоже самое, но в xml просто набор item'ов с какими-то натуральными числами
   в каком-то порядке, например:

   <items>
      <item>142</item>
      <item>73</item>
      <item>10000341</item>
      <item>10</item>
      ...
   </items>

   Решение:

   <xsl:template match="/">
          <items>
              <xsl:copy-of select="items/item[not(
                 str:tokenize(str:padding(. - 1, '1'), '')[(last() + 1 ) mod position()= 0 and position() != 1]
             )
             and . != 1]"/>
          </items>
   </xsl:template>

   Чтобы понять, что тут делается, надо прочитать про функции padding и tokenize на EXSLT.org.

   ]]> http://toivonen.ru/notes/problems/prime-numbers-xpath.html/feed