Класс junction
Класс предназначен для хранения кода и контекста его выполнения.
При обращении к переменным, хранящим в себе junction, Parser выполняет код в сохраненном контексте.
Значение типа junction появляется в переменной…
…при присваивании ей кода:
$junction{Код,присваиваемый переменной: ^do_something[]}
…при передачи кода параметром:
@somewhere[]
^method{Код, передаваемый параметром: ^do_something_else[]}
…
@method[parameter]
#здесь в $parameter придет junction
…при обращении к имени метода класса:
$action[$user:edit]
#$action[$user:delete]
^action[параметр]
Здесь $action хранит ссылку на метод и его класс, вызов action теперь аналогичен вызову ^edit[параметр].
…при обращении к имени метода объекта:
$action[$person.show_info]
^action[full]
Здесь $action хранит ссылку на метод и его объект, вызов action теперь аналогичен вызову ^person.show_info[параметры].
junction выражений и кода
@possible_reminder[age;have_passport]
^myif($age>=16 && !$have_passport){
Тебе уже $age лет, пора сходить в милицию.
}
@myif[condition;action][age]
$age(11)
^if($condition){
$action
}
Напоминание: параметр с выражением, это код, вычисляющий выражение, он выполняется - вычисляется выражение - при каждом обращении к параметру внутри вызова.
Здесь оператору myif передан код, печатающий, среди прочего, $age. Выполнение проверки и кода оператор производит в сохраненном (внутри $condition и $action) контексте, поэтому наличие в myif локальной переменной age и ее значение никак не влияет на то, что будет проверено и что напечатано.
Пример проверки наличия метода
^if($some_method is junction){
^some_method[параметр]
}{
нет метода
}
Метод some_method, будет вызван только, если определен.
Что делать дальше: на этом создание
Удачи!
Что надо запомнить:
| · | наряду с методами объектов, создаваемых с помощью конструкторов класса, существуют статические методы. Вы можете непосредственно обращаться к этим методам без предварительного использования конструктора для создания объекта |
| · | в циклах for можно обращаться к счетчику как к переменной по имени и получать его текущее значение |
Поскольку код становится все объемнее, неплохо бы начать снабжать его комментариями, чтобы потом было легче разбираться. В Parser комментариями считается любая строка, начинающаяся со знака #. До сих пор мы не пользовались этим, но в дальнейшем нам пригодится комментирование кода. Следующая строка - пример комментария:
# весь этот текст Parser проигнорирует - это комментарий !!!!
Обязательно комментируйте свой код! В идеале он должен быть самодокументирующимся, а человек, читающий его, должен сразу же понимать о чем идет речь, что из чего следует и т.д. Если этого не сделать, то спустя какое-то время вспомнить что делает та или иная функция станет очень сложно даже вам самим, не говоря уже про остальных. Помните об этом!
Что надо запомнить: Parser использует
Синтаксис работы с объектами:
|
$переменная[значение] |
- задаем значение |
|
$переменная |
- получаем значение |
|
$переменная [^имя_класса::конструктор[параметры]] |
- создаем объекта класса имя_класса и присваиваем его переменной |
|
$переменная.имя_поля |
- получаем поле самого объекта, хранящегося в переменной |
|
^переменная.метод[] |
- вызываем действие (метод класса, к которому принадлежит объект, хранящийся в переменной) |
Что узнали:
| · | файл auto.p может содержаться не только в корневом каталоге сайта, но и в любом другом, при этом функции, в нем определенные, явно доступны только внутри этого каталога |
| · | переменная-хеш - это массив, нужный для построения ассоциативной связи одних объектов с другими. В нашем случае объектами выступали строки |
| · | статический метод calendar создает таблицу с календарем на текущий месяц |
| · | цикл for позволяет последовательно выполнить определенные действия заданное количество раз |
Что узнали:
| · | механизм взаимодействия Parser с СУБД MySQL |
| · | как осуществлять различные SQL-запросы к БД (статический метод sql класса void и конструктор sql класса table) |
| · | оператор untaint |
Что узнали:
| · | класс MAIN
|
| · | создание пользовательского класса |
| · | как передавать параметры методам |
Что узнали:
| · | класс xdoc
|
| · | как загружать XML, делать XSLT преобразования, выводить объекты класса xdoc в виде HTML |
Циклы
Цикл - процесс многократного выполнения некоторой последовательности действий.
В Parser существует два оператора циклов: for, в котором количество повторов тела цикла ограничивается заданными значениями счетчика, и while, где количество повторов зависит от выполнения условия. Для того, чтобы избежать зацикливания, в Parser встроен механизм обнаружения бесконечных циклов. Бесконечным считается цикл, тело которого выполняется более 10000 раз.
в Parser принадлежит конкретному классу,
Любой объект в Parser принадлежит конкретному классу, характеризуется полями и методами именно этого класса. Чтобы он появился, его нужно создать. Делает это конструктор данного класса. Разберитесь с этой терминологией, это основа.
Отвлеклись? Продолжим. Переменной $sections мы присвоили вот что:
^table::load[sections.cfg]
Буквально это означает следующее: мы создали объект класса table при помощи конструктора load. Общее правило для создания объекта записывается так:
^имя_класса::конструктор[параметры_конструктора]
Подробности в разделе «Передача параметров».
В качестве параметра конструктору мы передали имя файла с таблицей и путь к нему.
Теперь переменная $sections содержит таблицу с разделами нашего сайта. Parser считает ее объектом класса table и точно знает, какие действия с ней можно выполнить. Пока нам понадобится только один метод этого класса - menu, который последовательно перебирает все строки таблицы. Также нам потребуются значения из полей самой таблицы. Синтаксис вызова методов объекта:
^объект.метод_класса[параметры]
Получение значений полей объекта (мы ведь имеем дело с вполне определенной таблицей с заданными нами же полями):
$объект.имя_поля
Знания, полученные выше, теперь позволяют без труда разобраться в последней части нашего кода:
<table width="100%" border="1">
<tr>
^sections.menu{
<td align="middle">
<a href="$sections.uri"><nobr>$sections.name</nobr></a>
</td>
}
</tr>
</table>
Мы формируем HTML-таблицу, в каждый столбец которой помещаем значения, содержащиеся в полях нашей таблицы $sections: uri - адрес и name - имя. При помощи метода menu мы автоматически перебираем все строки таблицы. Таким образом, даже если у нас будет несколько десятков разделов, ни один из них не будет потерян или пропущен. Мы можем свободно добавлять разделы, удалять их и даже менять местами. Изменения вносятся только в файл sections.cfg. Логика работы не нарушится. Все просто и красиво.
Давайте подведем итоги первого урока.
Меню навигации
Давайте начнем с самого начала. Итак, вы хотите сделать сайт (узел, сервер). Первым делом, необходимо уяснить, каким образом на сайте будет упорядочена та или иная информация. Сколько будет категорий, подразделов т.д. Все эти вопросы возникают на первом этапе - "Организация сайта".
А какой должна быть навигация сайта? Требований к хорошей навигации много. Она должна быть понятна, легко узнаваема, единообразна, удобна в использовании, быстро загружаться, давать четкое понятие о текущем местоположении. При этом на сайте не должно возникать 404-й ошибки, т.е. все ссылки должны работать. Если у вас есть опыт создания сайтов, то вам, скорее всего, приходилось сталкиваться с проблемой создания грамотной навигации.
Не правда ли, хочется иметь какое-то решение, которое всегда будет под рукой и позволит автоматизировать весь этот процесс? Что-то такое, что даст возможность единственный раз написать код и потом, в одном месте, дописывать столько разделов, сколько нужно?
Создание меню, которое ориентирует пользователя на сайте, не дает ему заблудиться - вот задача, с которой нам хочется начать повествование о Parser. Почему именно это? Прежде всего потому, что большое количество тегов:
<ahref="страница_сайта.html">
трудно контролировать. А если вам понадобится добавить еще один раздел? Придется в каждую страницу вносить изменения, а человеку свойственно делать ошибки. При этом отнюдь не исключено, что после такой «модернизации» ваш ресурс в ответ на запросы пользователей сообщит о том что «данная страница не найдена». Вот где проблема, которую с помощью Parser можно решить очень легко.
Решение следующее. Мы создаем некую функцию на Parser, которая будет генерировать нужный нам фрагмент HTML-кода. В терминологии Parser функции называются методами. В тех местах, где этот код понадобится, будем просто давать указание «Вставить меню навигации» и сразу же будет создана страница, содержащая меню. Для этого сделаем несколько простых шагов:
1. Всю информацию о наших ссылках будем хранить в одном файле, что позволит впоследствии вносить необходимые изменения только в нем. В корневом каталоге будущего сайта создаем файл sections.cfg, в который помещаем следующую информацию:
|
section_id |
name |
uri |
|
1 |
Главная |
/ |
|
2 |
Новости |
/news/ |
|
3 |
Контакты |
/contacts/ |
|
4 |
Цены |
/price/ |
|
5 |
Ваше мнение |
/gbook/ |
Здесь используется так называемый формат tab-delimited. Столбцы разделяются знаком табуляции, а строки - переводом каретки. При копировании этой таблицы в текстовый редактор данное форматирование будет создано автоматически, но если вы будете создавать таблицу вручную, необходимо это учитывать. Для таблиц ВСЕГДА применяется формат tab-delimited.
2. В том же каталоге, где и sections.cfg, создаем файл auto.p
В нем мы будем хранить все те кирпичики, из которых впоследствии Parser соберет наш сайт. AUTO означает, что все эти кирпичики будут всегда доступны для Parser в нужный момент, а расширение ".p", как вы, наверное, догадались, это… правильно! Он самый!
3. В файл auto.p вставим следующий код:
@navigation[]
$sections[^table::load[sections.cfg]]
<table width="100%" border="1">
<tr>
^sections.menu{
<td align="middle">
<a href="$sections.uri"><nobr>$sections.name</nobr></a>
</td>
}
</tr>
</table>
Данные из этого файла и будут служить основой для нашего навигационного меню.
Вот и все, подготовительные работы закончены. Теперь открываем код страницы, где все это должно появиться (например, index.html), и говорим: «Вставить меню навигации». На Parser это называется «вызов метода» и пишется так:
^navigation[]
Осталось только открыть в браузере файл, в который мы вставили вызов метода и посмотреть на готовое меню навигации. Теперь в любом месте на любой странице мы можем написать заветное ^navigation[], и Parser вставит туда наше меню. Страница будет сформирована «на лету». Что хотели, то и получили.
Если у вас дела обстоят именно так, то поздравляем - вы вступили в мир динамических сайтов. Очень скоро вы также запросто будете использовать базы данных для формирования страниц и делать многое другое.
Однако не будем радоваться раньше времени. Давайте разберемся, что же мы сделали, чтобы добиться такого результата. Взгляните на код в auto.p. Если кажется, что все непонятно, не надо бежать прочь. Уверяем, через несколько минут все встанет на свои места. Итак, посмотрим на первую строчку:
@navigation[]
Она аналогична строке ^navigation[], которую мы вставили в текст страницы для создания меню. Различие только в первом символе: ^ и @. Однако логический смысл этого выражения совершенно иной - здесь мы определяем метод, который вызовем позже. Символ @ (собака) в первой колонке строки в Parser означает, что мы хотим описать некоторый блок, которым воспользуемся в дальнейшем. Следующее слово определяет имя нашего метода: navigation. Это только наше решение, как ее назвать. Вполне допустимы имена: а_ну_ка_вставь_меню_быстро. Но читаться такая программа будет хуже, впрочем, кому как понятнее, можете назвать и так.
Жизненно необходимо давать простые, понятные имена. Они должны точно соответствовать тому, что именуемый объект будет хранить и делать. Сохраните нервы и время себе и всем тем, кому придется разбираться в ваших текстах, отнеситесь, пожалуйста, к именам внимательно. Имена могут быть русские или латинские, главное соблюдать единообразие: или все по-русски, или по-английски.
Идем дальше.
$sections[^table::load[sections.cfg]]
Это ключевая строка нашего кода. Она достаточно большая, поэтому давайте разберем ее по частям.
Строка начинается символом $ (рубль) и следующим сразу за ним именем sections. Так в Parser обозначаются переменные. Это надо запомнить. Все просто: видим в тексте $var - имеем дело с переменной var. Переменная может содержать любые данные: числа, строки, таблицы, файлы, рисунки и даже часть кода. Присвоение переменной $parser_home_url значения www.parser3.ru на Parser выглядит так: $parser_home_url[www.parser3.ru]. После этого мы можем обратиться к переменной по имени, т.е. написать $parser_home_url и получить значение www.parser3.ru.
Еще раз тоже самое:
|
$var[…] |
- присваиваем |
|
$var |
- получаем |
В нашем случае переменная $sections будет хранить таблицу из файла sections.cfg.
Любую таблицу Parser рассматривает как самостоятельный объект, с которым он умеет производить только вполне определенные действия, например, добавить или удалить из нее строку. Поскольку переменная может хранить любые данные, необходимо указать, что присвоенное нами переменной значение является именно таблицей.
Лирическое отступление.
Пример из жизни. Всю автомобильную технику можно грубо разделить на несколько классов: легковые автомашины, грузовики, трактора и гусеничная техника. Любой автомобиль является объектом одного из этих классов. Вы легко можете определить, к какому классу относится автомобиль, поскольку их всех объединяют общие характеристики, такие как вес, масса перевозимого груза и т.д. Любой автомобиль может совершать действия: двигаться, стоять или ломаться. Каждый из автомобилей обладает своими собственными свойствами. И самое главное, автомобиль не может появиться сам собой, его нужно создать. Когда конструктор придумывает новую модель автомобиля, он точно знает, автомобиль какого класса он создает, какими свойствами будет наделено его творение и что оно сможет делать. Также и в Parser: каждый объект относится к определенному классу, объект класса создается конструктором этого класса и наделен характеристиками (полями) и методами (действиями), общими для всех подобных объектов.
Меню навигации и структура страниц
Предыдущий урок мы закончили тем, что определили недостатки в реализации меню. Давайте займемся их устранением. Наше меню выводит лишнюю ссылку на текущую страницу, что нисколько не украшает будущий сайт. Чтобы этого избежать, необходимо проверить, не является ли раздел, на который мы выводим ссылку, текущим. Иными словами, нам нужно сравнить URI раздела, на который собираемся ставить ссылку, с текущим URI. В случае если они совпадают, ссылку на раздел ставить не надо. Дополнительно для удобства пользователей мы изменим в меню навигации цвет столбца текущего раздела.
Открываем файл auto.p и меняем его содержимое на:
@navigation[]
$sections[^table::load[/sections.cfg]]
<tablewidth="100%" border="0" bgcolor="#000000" cellspacing="1">
<tr bgcolor="#FFFFFF">
^sections.menu{
^navigation_cell[]
}
</tr>
</table>
<br>
@navigation_cell[]
$cell_width[^eval(100\$sections)%]
^if($sections.uri eq $request:uri){
<td width="$cell_width" align="middle" bgcolor="#A2D0F2">
<nobr>$sections.name</nobr>
</td>
}{
<td width="$cell_width" align="middle">
<a href="$sections.uri"><nobr>$sections.name</nobr></a>
</td>
}
Что изменилось? На первый взгляд не так уж и много, но функциональность нашего модуля существенно возросла. Мы описали еще один метод - navigation_cell, который вызывается из метода navigation. В нем появилась новая структура:
^if(условие){код если условие "истина"}{код если условие "ложь"}
Что она делает, понять не сложно. В круглых скобках задается условие, в зависимости от того, какое значение возвращает условие, "ложь" или "истина", можно получить разный результат. Также, если в условии записано выражение, значение которого равно нулю, то результат - "ложь", иначе - "истина". Мы используем оператор if для того, чтобы в одном случае поставить ссылку на раздел, а другом нет. Осталось только разобраться с условием. Будем сравнивать на равенство две текстовых строки, в одной из которых - значение URI раздела из таблицы sections, в другой - текущий URI ($request:uri возвращает строку, содержащую URI текущей страницы). Тут возникает вопрос о том, какие же строки равны между собой? Несомненно, только те, которые полностью совпадают и по длине, и по символьному содержанию.
Для сравнения двух строк в Parser предусмотрены следующие операторы:
eq - строки равны (equal): parser eq parser
ne - строки не равны (not equal): parser ne parser3
lt - первая строка меньше второй (less than): parser lt parser3
gt - первая строка больше второй (greater than): parser3 gt parser
le - первая строка меньше или равна второй (less or equal)
ge - первая строка больше или равна второй (greater or equal)
С условием разобрались: если $sections.uri и $request:uri совпадают, ссылку не ставим (а заодно красим столбец в другой цвет - подумаем о наших пользователях, так им будет удобнее), если нет - ставим.
Идем дальше. Меню из первого урока выводило столбцы разной ширины. Ничего страшного, но некрасиво. Проблема решается очень просто: всю ширину меню (100%) делим на количество разделов, которое равно количеству строк в таблице sections. Для этого воспользуемся оператором ^eval() и тем, что можно использовать объекты класса table в математических выражениях. При этом их числовое значение равно числу записей в таблице. Обратите внимание также на то, что мы пользуемся целочисленным делением, используя обратный слеш вместо прямого.
На ^eval() остановимся чуть подробнее. Он позволяет получить результат математического выражения без введения дополнительных переменных, иными словами, хотим что-то посчитать - пишем:
^eval(выражение)[формат]
Использование [формат] дает возможность вывода результата выражения в том виде, который нужен. Форматная строка [%d] отбрасывает дробную часть, [%.2f] дает два знака после запятой, а [%04d] отводит 4 знака под целую часть, дополняя недостающие символы нулями слева. Форматированный вывод нужен, когда необходимо представить число в определенном виде (скажем, 12.44 $ смотрится куда лучше 12.44373434501 $).
Вот, собственно, и все, что касается меню. Теперь оно функционально и готово к использованию.
Наш первый кирпичик для будущего сайта готов. Теперь займемся структурой страниц. Давайте разобьем их на следующие блоки: header - верхняя часть страницы, body - основной информационный блок, включающий также наше меню и footer - нижняя часть страницы. Многие сайты имеют похожую структуру.
Footer будет для всех страниц одинаковым, header - для всех страниц одинаковый по стилю, но с разными текстовыми строками - заголовками страницы, а body будет разный у всех страниц, сохраняя только общую структуру (предположим, два вертикальных информационных блока, соотносящихся по ширине как 3:7). К body отнесем и наше меню.
Каждая из страниц будет иметь следующую структуру:
|
header | |
|
navigation body_additional (30%) |
body_main (70%) |
|
footer |
С footer все очень просто - в auto.p добавляем код:
@footer[]
<table width="100%" border="0" bgcolor="#000000" cellspacing="0">
<tr>
<td></td>
</tr>
</table>
$now[^date::now[]]
<font size="-3">
<center>Powered by Parser3<br>1997-$now.year</center>
</font>
</body>
</html>
Никаких новых идей здесь нет, разве что мы впервые использовали класс date с конструктором now для получения текущей даты, а затем из объекта класса date взяли поле year (год). Если это кажется вам непонятным, обязательно вернитесь к первому уроку, где рассказано о работе с объектами на примере класса table. Все идентично, только теперь мы имеем дело с объектом другого класса.
Немного сложнее с модулем header. С одной стороны, нам нужно формировать уникальный заголовок-приветствие для каждой страницы. В то же время он будет одинаковым с точки зрения внешнего вида, различие только в тексте, который будет выводиться. Как же быть? Мы предлагаем сделать следующее: определить в нашем auto.p новую функцию header, внутри которой будет вызываться другая функция - greeting. А функция greeting, в свою очередь, будет определяться на самих страницах сайта и содержать только то, чем отличаются заголовки страниц (в нашем случае строку-приветствие).
Дополняем auto.p следующим кодом:
@header[]
<html>
<head>
<title>Тестовый сайт Parser3</title>
</head>
<body bgcolor="#FAEBD7">
<table width="100%" border="0" bgcolor="#000000" cellspacing="1">
<tr bgcolor="#FFFFFF" height="60">
<td align="middle">
<font size="+2"> <b>^greeting[]</b></font>
</td>
</tr>
</table>
<br>
Теперь внимание, кульминация. Parser позволяет сделать очень интересный финт: определить один раз общую структуру страниц в файле auto.p, создать каркас, а затем, используя функции, подобные greeting, в тексте самих страниц, получать разные по содержанию страницы одинаковой структуры. Как это работает?
В самом начале файла auto.p мы определим функцию @main[], которая всегда, причем автоматически, исполняется первой. В нее включим вызовы функций, формирующих части страниц.
В начале auto.p пишем:
@main[]
^header[]
^body[]
^footer[]
А для получения уникального заголовка страниц в каждой из них определим функцию greeting, которая вызывается из header:
для главной страницы:
@greeting[]
Добро пожаловать!
для гостевой книги:
@greeting[]
Оставьте свой след…
и т.д.
Теперь при загрузке, например, главной страницы произойдет следующее:
1. Из файла auto.p автоматически начнет выполняться main.
2. Первой вызывается функция header, из которой вызывается функция greeting.
3. Поскольку функция greeting определена в коде самой страницы, будет выполнена именно она, вне зависимости от того, определяется она в auto.p или нет (происходит переопределение функции).
4. Затем выполняются функции body и footer из main.
В результате мы получаем страницу, у которой будут все необходимые элементы, а в верхней части дополнительно появится наше уникальное приветствие. Переопределяемые функции носят название виртуальных. Мы из файла auto.p вызываем функцию, которая может быть переопределена на любой из страниц и для каждой из них выполнит свой код. При этом общая структура страниц будет абсолютно одинаковой, и сохранится стилистическое и логическое единство.
Осталось описать только основной блок - body. Как мы договорились, он будет состоять из двух частей, каждую из которых будем создавать своей функцией, например, body_main и body_additional, а поскольку навигационное меню, по логике, относится к основной части страниц, вызовем navigation также из body. Снова воспользуемся механизмом виртуальных функций. Редактируем auto.p - дополняем:
@body[]
^navigation[]
<table width="100%" height="65%" border="0" bgcolor="#000000" cellspacing="1">
<tr bgcolor="#ffffff" height="100%">
<td width="30%" valign="top" bgcolor="#EFEFEF">
<b>^body_additional[]</b>
</td>
<td width="70%" valign="top">
^body_main[]
</td>
</tr>
</table>
<br>
Определение функций body_main и body_additional, также как и в случае с greeting вставим в страницы:
@body_additional[]
Главная страница сайта
@body_main[]
Основное содержание
Этот текст приводится как образец для index.html. Отлично! Структура окончательно сформирована. Мы описали все необходимые модули в файле auto.p, сформировали общую структуру и теперь можем запросто генерировать страницы. Больше не нужно помногу писать одни и те же куски HTML кода. Привычные HTML-страницы трансформируются примерно в следующее (примерное содержание index.html файла для главной страницы):
@greeting[]
Добро пожаловать!
@body_additional[]
Главная страница сайта
@body_main[]
Основное содержание
Просто и понятно, не правда ли? Все разложено по полочкам и легко доступно. При этом после обработки подобного кода Parser создаст HTML-код страницы, у которой будет уникальный заголовок, меню, основной информационный блок заданной структуры и footer, одинаковый для каждой страницы. Фактически, мы уже создали готовый сайт, который осталось только наполнить информацией. Это готовое решение для изящного сайта-визитки, который можно создать прямо на глазах. Естественно, это не единственное решение, но такой подход дает отличную структуризацию нашего сайта. Некоторые умственные усилия при разработке структуры с лихвой окупятся легкостью последующей поддержки и модернизации. Каркас хранится в auto.p, а все, что относится непосредственно к странице, - в ней самой.
Дальше открываются безграничные просторы для фантазии. Допустим, вам понадобилось поменять внешний вид заголовка страниц на сайте. Мы открываем auto.p, редактируем один единственный раз функцию @header[] и на каждой из страниц получаем новый заголовок, по стилю идентичный всем остальным. Для обычного HTML нам пришлось бы вручную переписывать код для каждой страницы. Та же самая ситуация и с остальными модулями. Если возникло желание или необходимость изменить общую структуру страниц, например, добавить какой-то блок, достаточно определить его новой функцией и дополнить функцию main в auto.p ее вызовом.
Подобная организация страниц сайта дополняет проект еще одним мощным средством. Предположим, на одной из страниц нам понадобилось получить footer, отличный от других страниц (напомним, изначально мы предполагали, что footer везде одинаковый). Единственное, что нужно сделать, это переопределить функцию footer на нужной странице. Например, такое наполнение /contacts/index.html:
@greeting[]
Наша контактная информация
@body_additional[]
Главная страница тестового сайта
@body_main[]
Основное содержание
@footer[]
Здесь у нас контакты
изменит привычный footer на обозначенный выше, т.е. если Parser находит в тексте страницы код для функции, вызываемой из auto.p, он выполнит именно его, даже если функция определена в самом auto.p. Если же функция не переопределена на странице, то будет использован код из auto.p.
В заключение немного теории для любознательных. Мы будем давать подобную информацию для тех, кто хочет глубже понимать логику работы Parser.
Помните, мы использовали в нашем коде конструкцию $request:uri? Она отличается по синтаксису от всего того, с чем мы имели дело раньше. Что же это такое? Внешне похоже на $объект.свойство (урок 1) - значение полей объекта, только вместо точки использовано двоеточие. На самом деле, это тоже значение поля, только не объекта, а самого класса request. В Parser не предусматриваются конструкторы для создания объектов этого класса. Поля подобных классов формируются самим Parser, а мы можем сразу напрямую обращаться к ним. Техническим языком это называется статическая переменная (поле) uri класса request. Она хранит в себе URI текущей страницы. Также, наряду со статическими переменными, существуют статические методы, с которыми мы столкнемся уже в следующем уроке. При этом можно сразу же вызывать их также без создания каких-либо объектов с помощью конструкторов. Запомните, что в синтаксисе статических полей и методов всегда присутствует двоеточие. Если встречается конструкция вида $класс:поле - мы получаем значение поля самого класса, а запись ^класс:метод является вызовом статического метода класса. Например, для работы с математическими функциями в Parser существует класс math. В нем используются только статические методы и переменные:
$math:PI - возвращает число p. Это статическая переменная класса math.
^math:random(100) - возвращает псевдослучайное число из диапазона от 0 до 100. Это статический метод класса math.
Отличие от записи методов и полей объектов состоит только в двоеточии.
Давайте подведем итоги второго урока.
Первый шаг - раздел новостей
На двух предыдущих уроках мы описали общую структуру нашего сайта. Сейчас это всего лишь каркас. Пора приступать к его информационному наполнению. Практически на каждом сайте присутствует раздел новостей, и наш не должен стать исключением. Также как и с разделами сайта, мы предлагаем начать работу над разделом новостей с создания меню к этому разделу. В качестве средства доступа к новостям будем использовать привычный глазу календарь на текущий месяц.
Создать календарь средствами одного HTML - задача достаточно нетривиальная, к тому же код получится очень громоздким. Сейчас Вы увидите, как легко это сделать на Parser. Приступаем.
Все файлы, относящиеся к разделу новостей, будем размещать в разделе /news/, что было указано нами в файле sections.cfg. Для начала создадим там (!) файл auto.p.Удивлены? Да, файлы auto.p можно создавать в любом каталоге сайта. Однако при этом надо иметь в виду, что функции, описанные в auto.p разделов, будут явно доступны только внутри этих разделов. Согласитесь, ни к чему загромождать корневой auto.p функциями, которые нужны для одного раздела. Логичнее вынести их в отдельный файл, относящийся именно к этому разделу.
Еще одно замечание: если в auto.p раздела переопределить функцию, ранее описанную в корневом auto.p, то будет исполняться именно эта, переопределенная функция. Сработает механизм виртуальных функций, описанный в предыдущем уроке.
Итак, в auto.p раздела news пишем такой код:
@calendar[]
$calendar_locale[
$.month_names[
$.1[Январь]
$.2[Февраль]
$.3[Март]
$.4[Апрель]
$.5[Май]
$.6[Июнь]
$.7[Июль]
$.8[Август]
$.9[Сентябрь]
$.10[Октябрь]
$.11[Ноябрь]
$.12[Декабрь]
]
$.day_names[
$.0[пн]
$.1[вт]
$.2[ср]
$.3[чт]
$.4[пт]
$.5[сб]
$.6[вс]
]
$.day_colors[
$.0[#000000]
$.1[#000000]
$.2[#000000]
$.3[#000000]
$.4[#000000]
$.5[#800000]
$.6[#800000]
]
]
$now[^date::now[]]
$days[^date:calendar[rus]($now.year;$now.month)]
<center>
<table bgcolor="#000000" cellspacing="1">
<tr>
<td bgcolor="#FFFFFF" colspan="7" align="middle">
<b>$calendar_locale.month_names.[$now.month]</b>
</td>
</tr>
<tr>
^for[week_day](0;6){
<td width="14%" align="middle" bgcolor="#A2D0F2">
<font color="$calendar_locale.day_colors.$week_day">
$calendar_locale.day_names.$week_day
</font>
</td>
}
</tr>
^days.menu{
<tr>
^for[week_day](0;6){
^if($days.$week_day){
^if($days.$week_day==$now.day){
<td align="middle" bgcolor="#FFFF00">
<font color="$calendar_locale.day_colors.$week_day">
<b>$days.$week_day</b>
</font>
</td>
}{
<td align="middle" bgcolor="#FFFFFF">
<font color="$calendar_locale.day_colors.$week_day">
$days.$week_day
</font>
</td>
}
}{
<td bgcolor="#DFDFDF"> </td>
}
}
</tr>
}
</table>
</center>
Мы определили функцию calendar, которая создает HTML-код календаря. Получился довольно громоздкий код, но ведь и задачи, которые мы ставим перед собой, тоже усложнились. Не волнуйтесь, сейчас во всем разберемся.
Самая объемная часть кода, начинающаяся с определения $calendar_locale, оказалась незнакомой. Посмотрите на эту структуру. Похоже, в ней мы определяем какие-то данные для календаря, напоминающие таблицу. То, что определено как $calendar_locale, в терминологии Parser называется «хеш», или ассоциативный массив. Зачем он нужен можно сказать, просто бегло просмотрев код примера: здесь мы сопоставляем русское написание месяца его номеру в году (3 - март), название дня недели его номеру, а также связываем шестнадцатиричное значение цвета с некоторым числом. Теперь идея хешей должна проясниться: они нужны для сопоставления (ассоциативной связи) имени с объектом. В нашем случае мы ассоциируем порядковые номера месяцев и дней с их названиями (строками). Parser использует объектную модель, поэтому строка тоже является объектом. Нам несложно получить порядковый номер текущего месяца, но намного нагляднее будет вывести в календаре «Ноябрь» вместо «11» или «пн» вместо «1». Для этого мы и создаем ассоциативный массив.
В общем виде порядок объявления переменных-хешей такой:
$имя[
$.ключ[значение]
]
Эта конструкция позволяет обратиться к переменной по имени с ключом $имя.ключ и получить сопоставленное значение. Обратите внимание, что в нашем случае мы имеем хеш, полями которого являются три других хеша.
После определения хеша мы видим уже знакомую переменную now (текущая дата), а вот дальше идет незнакомая конструкция:
$days[^date:calendar[rus]($date.year;$date.month)]
По логике работы она напоминает конструктор, поскольку в переменную days помещается таблица с календарем на текущий месяц текущего года. Тем не менее, привычного :: здесь не наблюдается. Это один из статических методов класса date. Статические методы наряду с уже знакомыми конструкторами могут возвращать объекты, поэтому в данном случае необходимо присвоить созданный объект переменной. Про статические переменные и методы уже было немного сказано в конце предыдущего урока. Своим появлением они обязаны тому факту, что некоторые объекты или их свойства (поля) существуют в единственном экземпляре, как, например, календарь на заданный месяц или URI страницы. Поэтому подобные объекты и поля выделены в отдельную группу, и к ним можно обращаться напрямую, без использования конструкторов. В случае если мы обращаемся к статическому полю, мы получаем значение поля самого класса. В качестве примера можно привести класс math, предназначенный для работы с математическими функциями. Поскольку существует только одно число p, то для того, чтобы получить его значение, используется статическое поле $math:PI - это значение поля самого класса math.
В результате исполнения этого кода в переменной days будет содержаться такая таблица:
Таб.1 (для ноября 2001 года)
|
0 |
1 |
2 |
3 |
4 |
5 |
6 |
|
|
|
01 |
02 |
03 |
04 | |
|
05 |
06 |
07 |
08 |
09 |
10 |
11 |
|
12 |
13 |
14 |
15 |
16 |
17 |
18 |
|
19 |
20 |
21 |
22 |
23 |
24 |
25 |
|
26 |
27 |
28 |
29 |
30 |
С ней мы и будем дальше работать. Нельзя сразу же выводить содержимое переменной $days, просто обратившись к ней по имени. Если мы обратимся к таблице просто как к переменной, будет непонятно, что мы хотим получить - строку, всю таблицу целиком или значение только из одного столбца. Также явно требуется доработка содержимого полученной таблицы. Но ведь не зря же мы создавали наш хеш с названиями дней недели и месяцев. Поэтому далее по коду средствами HTML создается таблица, в первой строке которой мы выводим название текущего месяца, пользуясь данными из хеша, связанными с номером месяца в году:
$calendar_locale.month_names.[$now.month]
Что здесь что? Мы выводим значение поля month_names хеша calendar_locale с порядковым номером текущего месяца, полученным как $now.month. Результатом выполнения этой конструкции будет название месяца на русском (или любом другом) языке, которое было определено в хеше.
В следующей строке календаря выведем названия дней недели, пользуясь данными хеша. Давайте чуть подробнее определимся с задачей. Нам надо последовательно перебрать номера дней недели (от 0 до 6) и поставить в соответствие номеру дня его название из поля day_names хеша calendar_locale. Для этой цели удобнее всего воспользоваться циклом: последовательностью действий, выполняющейся заданное количество раз. В данном случае мы используем цикл for. Его синтаксис такой:
^for[счетчик](диапазон значений, например 0;6){последовательность действий}
Одно из достоинств циклов - возможность использования значения счетчика внутри цикла, обращаясь к нему как к переменной. Этим мы и воспользуемся:
^for[week_day](0;6){
<td width="14%" align="middle" bgcolor="#A2D0F2">
<font color="$calendar_locale.day_colors.$week_day">
$calendar_locale.day_names.$week_day
</font>
</td>
}
Все просто и понятно, если знать, что такое цикл: последовательно меняя значение week_day от 0 до 6 (здесь week_day является счетчиком цикла), мы получаем семь значений:
$calendar_locale.day_colors.$week_day - для цвета шрифта
$calendar_locale.day_names.$week_day - для названия дня недели.
Идея получения данных та же, что и для получения названия месяца, только используются другие ключи хеша.
Возможно, возник вопрос: зачем в хеше ключ day_colors? Ответ прост - все должно быть красиво! Если есть возможность максимально приблизить наш календарь к реальному, то так и сделаем - перекрасим выходные дни в красный цвет.
Далее по тексту следует большой красивый блок. Чтобы в нем разобраться, определимся с задачами. Итак, нам нужно:
1. Последовательно перебрать строки таблицы days (Таб.1).
2. В каждой строке таблицы days последовательно перебрать и вывести значения столбцов (числа месяца).
3. Корректно вывести пустые столбцы (то есть проверить первую и последнюю недели месяца на полноту).
4. Как-то выделить текущее число, например другим цветом и жирным шрифтом.
Приступаем. Первый пункт решается с помощью знакомого метода menu класса table:
^days.menu{…}
Перебор столбцов логичнее всего сделать циклом for, с которым мы только что познакомились:
^for[week_day](0;6){…}
Для проверки столбцов на пустоту для вывода столбцов без чисел используем оператор if. Вообще, любые проверки условий всегда можно реализовать с помощью if:
^if($days.$week_day){
…
}{
<td bgcolor="#DFDFDF"> </td>
}
Обратите внимание, что в условии if мы ни с чем не сравниваем $days.$week_day. Так осуществляется проверка на неравенство нулю.
Parser это условие понимает так:
«Если существует $days.$week_day, то {…}, если нет, то вывести пустую ячейку таблицы серого цвета»
Основная часть работы выполнена. Осталось только выделить текущее число. Решается это использованием еще одного if, где условием задается сравнение текущего значения таблицы days с текущим числом ($days.$week_day==$now.day):
^if($days.$week_day==$now.day){
<td align="middle" bgcolor="#FFFF00">
<font color="$calendar_locale.day_colors.$week_day">
<b>$days.$week_day</b>
</font>
</td>
}{
<td align="middle" bgcolor="#FFFFFF">
<font color="$calendar_locale.day_colors.$week_day">
$days.$week_day
</font>
</td>
}
Обратите внимание на то, что здесь мы проверяем на равенство два числа, поэтому используем оператор == вместо eq, используемый для проверки равенства строк.
Еще раз посмотрим на общую структуру формирования календаря:
#перебираем строки таблицы с календарем
^days.menu{
#перебираем столбцы таблицы с календарем
^for[week_day](0;6){
^if($days.week_day){
^if($month.$week_day==$date.day){
число на другом фоне жирным шрифтом
}{
число
}
}{
пустой серый столбец
}
}
}
Эту конструкцию простой не назовешь. Здесь используются вложенные друг в друга конструкции. Однако она позволяет понять возможность комбинирования различных средств Parser для решения конкретной задачи. Есть более элегантное решение - вынести проверку текущей даты и ее раскрашивание нужным цветом в отдельную функцию, которую и вызывать внутри цикла. Похожее решение мы использовали во втором уроке. Это позволит разгрузить блок и сделать его более читабельным. Но поскольку в данном примере мы хотели показать вам возможность комбинирования нескольких логических структур, то оставляем эту возможность вам в качестве задания.
Если хотите убедиться в работоспособности этого модуля, создайте в разделе /news/ файл test.html и в нем наберите одну единственную строчку ^calendar[]. Теперь откройте этот файл из браузера и полюбуйтесь результатом своих трудов.
Подведем итоги третьего урока.
Шаг второй - переходим к работе с БД
Самое главное - не пугайтесь названия урока, даже если вы никогда не работали с базами данных. Без них просто невозможно построить гибкий, легко настраиваемый сайт. Отказ от использования БД не дает никаких преимуществ разработчику, а наоборот, здорово уменьшает возможности по созданию сайта и быстрому динамическому изменению содержимого. Построение серьезного ресурса без БД - это как рыбалка без удилища: вроде бы и можно кого-то поймать, однако делать это крайне неудобно. Иными словами, если вы пока не умеете работать с БД - обязательно научитесь и активно используйте их в своих проектах. На этом закончим агитацию, будем считать, что мы вас убедили в необходимости использования БД.
Работать с БД на Parser очень удобно. В Parser встроена мощная система взаимодействия с различными СУБД. В настоящее время Parser может работать с MySQL, Oracle, PgSQL, а также с любой СУБД через драйверы ODBC (в т.ч. MS SQL, MS Access). Поскольку исходные коды Parser3 являются открытыми, возможно добавление поддержки любых других знакомых вам СУБД после создания соответствующего драйвера. При этом работа с ними не требует практически никаких дополнительных знаний собственно Parser. Все, что нужно - это подключится к выбранной СУБД и работать, используя SQL в объеме и формате, поддерживаемом СУБД. При передаче SQL-запросов Parser может только заменить апострофы соответствующей конструкцией в зависимости от СУБД, для «защиты от дурака», а все остальное передается, как есть.
Существует еще специальная конструкция для записи больших строковых литералов. Oracle, PgSQL и, возможно, какие-то серверы, драйверы к которым будут написаны в будущем, не умеют работать с большими строковыми литералами. Если передаваемая, например, из формы, строка будет содержать больше 2000 [Oracle 7.x] или 4000 [Oracle 8.x] букв, сервер выдаст ошибку «слишком длинный литерал». Если пытаться хитрить, комбинируя «2000букв» + «2000букв», то также будет выдана ошибка «слишком длинная сумма». Для хранения таких конструкций используется тип данных CLOB[Oracle] и OID[PgSQL], а для того, чтобы SQL команды были максимально просты, при записи таких строк необходимо лишь добавить управляющий комментарий, который драйвер соответствующего SQL-сервера соответствующим образом обработает:
insertinto news text values (/**text**/'$form:text')
Слово text в записи /**text**/ - это имя колонки, в которую предназначен следующий за этой конструкцией строковый литерал. Пробелы здесь недопустимы!
Со всеми возможностями Parser по работе с различными СУБД в рамках данного урока мы знакомиться, конечно же, не будем. Остановимся на MySQL. Почему именно на ней? Прежде всего потому, что она очень распространена, и многие веб-проекты используют именно ее. Кроме того, практически все компании, занимающиеся сетевым хостингом, предоставляют клиентам возможность работы с этой СУБД. Ну и, несомненно, немаловажный фактор - она бесплатна, доступна и легка в освоении.
Давайте определимся, что будем хранить в базе данных. Очевидный ответ : будем хранить новости. Причем таблица СУБД с новостями должна содержать такие поля: уникальный номер новости в базе, который будет формироваться автоматически СУБД, дата внесения новости в базу, по которой мы будем проводить выборку новостей за конкретное число, заголовок новости и собственно ее текст. Просто, без тонкостей и премудростей, однако это эффективно работает.
Есть еще один вопрос, с которым нужно определиться: каким образом новости будут попадать в базу? Можно их заносить и из командной строки СУБД, но это не удобно. В случае если вы предполагаете строить сайт для intranet, есть вариант использовать в качестве СУБД или средства доступа к БД широко распространенную MS Access. Привычный GUI и copy+paste обеспечат вам любовь многих коллег по работе на долгие годы. Для маленьких баз данных это решение может оказаться оптимальным. Мы же предлагаем решение, ориентированное на Internet - создание на сайте раздела администрирования с формой для ввода новостей прямо из браузера.
Постановка задачи закончена, переходим к ее практическому решению. Для дальнейшей работы вам потребуется установленная СУБД MySQL, без которой рассматриваемый здесь пример просто не будет работать.
Прежде всего, средствами MySQL создаем новую базу данных с именем p3test, содержащую одну единственную таблицу news с полями id, date, header, body:
Теперь создадим раздел администрирования, который даст возможность заполнить созданную базу данных новостями. Для этого в корневом каталоге сайта создаем каталог admin, а в ней index.html, в который пишем следующее:
@greeting[]
Администрирование новостей
@body_additional[]
Добавление новостей
@body_main[]
$now[^date::now[]]
<center>
<form method="POST">
<p>
Date: <input name="date" value="${now.year}-${now.month}-${now.day}">
Header: <input name="header">
</p>
<p>Body:<br>
<textarea cols="50" name="body" rows="5"></textarea>
</p>
<p>
<input type="submit" value="Add New" name="posted">
<input type="reset" value="Cancel">
</p>
</form>
#начало обработки
^if(def $form:date && def $form:header && def $form:body){
^connect[$connect_string]{
^void:sql{insert into news
(date, header, body)
values
('$form:date', '$form:header', '$form:body')
}
…сообщение добавлено
}
}{
…для добавления новости необходимо заполнить все поля формы
}
</center>
Также требуется в корневом файле auto.p перед методом main добавить метод auto. Этот метод используется для инициализации глобальных переменных, т.е. переменных, которые будут доступны на всех страницах сайта. В нем мы зададим строку подключения к базе данных, о которой чуть позже.
@auto[]
$connect_string[mysql://root@localhost/p3test]
Как видите, структура этой страницы полностью соответствует придуманной нами структуре страниц сайта. Все элементы, как то: приветствие, две части body, footer и header присутствуют. Кстати, вы помните, откуда на этой странице появятся header и footer? Правильно, из функции main корневого auto.p).
Незнакомые конструкции только в основной части. Давайте с ней разберемся. В начале обычная HTML форма, с подстановкой текущей даты в поле date как значения по умолчанию. Сделано это исключительно для удобства пользователей.
Легкое недоумение может вызвать запись:
${now.year}-${now.month}-${now.day}
Фигурные скобки здесь используются для того, чтобы получить строку вида «2001-11-06» (в таком формате мы собираемся хранить дату новости в БД). Если скобки не ставить, то Parser выдаст ошибку при обработке этого кода, поскольку не сможет понять, что нужно делать. Для него «-» будет частью имени. Запомните, если вам нужно четко отделить имя переменной от следующей за ним буквы, скажем «-», как в нашем случае, нужно записать:
${имя_переменной}-
И в результате вы получите:
значение_переменной-
Обязательно прочитайте страницу, посвященную правилам составления имен.
Лучшим решением этой проблемы было бы использовать в этом месте конструкцию ^date.sql-string[]. Попробуйте самостоятельно доработать этот пример, пользуясь справочником. Если не получится - не расстраивайтесь, на следующем уроке мы покажем, как это сделать.
Продолжим. Если вам уже доводилось работать с формами, то вы знаете, что формы передают введенные в них значения на дальнейшую обработку каким-либо скриптам. Здесь обработчиком данных формы будет сама страница, содержащая эту форму. Никаких дополнительных скриптов нам не понадобится.
После закрывающего тега </form> начинается блок обработки. Вначале с помощью if мы проверяем поля формы на пустоту. Этого можно опять же не делать, но мы хотим создать нечто большее, чем учебный экспонат без практического применения. Для того чтобы осуществить проверку, необходимо получить значения полей этой формы. В Parser это реализуется через статические переменные (поля). Мы просто обращаемся к полям формы, как к статическим полям:
$form:поле_формы
Полученные таким образом значения полей мы и будем проверять на пустоту с помощью оператора def и логического «И»(&&). Мы уже проверяли объект на существование в третьем уроке, но там был опущен оператор def, поскольку проверяли на пустоту таблицу. Как вы помните, таблица в выражении имеет числовое значение, равное числу строк в ней, поэтому любая непустая таблица считается определенной. Здесь же необходимо использовать def, как и в случае проверки на def других объектов. Если в поле ничего не было введено, то значение $form:поле_формы будет считаться неопределенным (undefined). После того, как все значения полей заполнены, необходимо поместить их в базу данных. Для этого нужно сначала подключиться к базе данных, а затем выполнить запрос SQL для вставки данных в таблицу. Посмотрите, как мы это делаем:
^connect[$connect_string]{
^void:sql{insert into news
(date, header, body)
values
('$form:date', '$form:header', '$form:body')
}
…cообщение добавлено
}
Удобство Parser при работе с базами данных состоит в том, что он, за исключением редких случаев, не требует изучать какие-либо дополнительные операторы, кроме тех, которые предусмотрены в самой СУБД. Сессия работы с базой данных находится внутри оператора connect, общий синтаксис которого:
^connect[протокол://строка соединения]{методы, передающие запросы SQL}
Для MySQL это запишется так:
^connect[mysql://пользователь:пароль@хост/база_данных]{…}
В фигурных скобках помещаются методы, выполняющие SQL-запросы. При этом любой запрос может возвратить или не возвратить результат (например, в нашем случае нужно просто добавить запись в таблицу БД, не возвращая результат), поэтому Parser предусматривает различные конструкции для создания этих двух типов SQL-запросов. В нашем случае запрос записывается как:
^void:sql{insert into news
(date, header, body)
values
('$form:date', '$form:header', '$form:body')
}
Кстати, это статический метод класса void, помните про двоеточие?
То, что здесь не выделено цветом, является командами SQL. Ничего сложного здесь нет. Если вы знакомы с SQL, то больше ничего и не потребуется, а если почему-то пока не знакомы, мы вновь рекомендуем его изучить. Вам это многократно пригодится в дальнейшем. Время, потраченное на это изучение, не пропадет даром.
Оцените все изящество этого варианта взаимодействия с базой данных - Parser обеспечивает прозрачный доступ к СУБД и, за редким исключением, не требует каких-либо дополнительных знаний. При этом, как вы видите, мы можем помещать в запросы SQL еще и данные из нашей формы, пользуясь конструкциями Parser. Возможности этого симбиоза просто безграничны. СУБД решает все задачи, связанные с обработкой данных (она ведь именно для этого и предназначена и очень неплохо с этим справляется), а нам остается только воспользоваться результатами ее работы. Все аналогично и с другими СУБД, с которыми вы можете столкнуться в своей работе.
Теперь у нас есть форма, позволяющая помещать записи в нашу БД. Занесите в нее несколько записей. А теперь давайте их оттуда извлекать, но перед этим неплохо бы немного доработать функцию calendar, созданную на предыдущем уроке. Нужно, чтобы в календаре ставились ссылки на дни месяца, а выбранный день передавался как поле формы. Тогда по числам-ссылкам в календаре пользователь будет попадать в архив новостей за выбранный день. Модернизация эта неcложная, просто добавим немного HTML в auto.p раздела news: $days.$week_day в коде if обнесем ссылками таким образом:
<a href="/news/?day=$days.$week_day">$days.$week_day</a>
В результате мы получаем возможность использовать наш календарь в качестве меню доступа к новостям за определенный день.
Теперь займемся /news/index.html. В него заносим такой код:
@greeting[]
Страница новостей, заходите чаще!
@body_additional[]
<center>Архив новостей за текущий месяц:</center>
<br>
^calendar[]
@body_main[]
<b><h1>НОВОСТИ</h1></b>
$day(^if(def $form:day){
$form:day
}{
$now.day
})
^connect[$connect_string]{
$news[^table::sql{select
date, header, body
from
news
where
date='${now.year}-${now.month}-$day'
}]
^if($news){
^news.menu{
<b>$news.date - $news.header</b><br>
^untaint{$news.body}<br>
}[<br>]
}{
За указанный период новостей не найдено.
}
}
Структура обычная. В дополнительной части body помещаем меню-календарь вызовом ^calendar[] (напомним, что эта функция определена в auto.p раздела news). Основа информационной части страницы - выборка из базы данных новостей за тот день, по которому щелкнул пользователь (условие where в SQL-запросе). Это второй вариант SQL-запроса, при котором результат возвращается. Обратите внимание, здесь результатом запроса будет таблица, с которой в дальнейшем мы будем работать. Поэтому необходимо создать объект класса table.
Познакомимся с еще одним конструктором класса table - конструктором на базе SQL-запроса. Его логика абсолютно аналогична работе конструктора ^table::load[], только источником данных для таблицы является не текстовый файл, как в случае с пунктами меню, а результат работы SQL-запроса - выборка из базы данных:
$переменная[^table::sql{код SQL запроса}]
Воспользоваться этим конструктором вы можете только внутри оператора ^connect[], то есть когда имеется установленное соединение с базой данных, поскольку обработкой SQL-запросов занимается сама СУБД. Результатом будет именованная таблица, имена столбцов которой совпадают с заголовками, возвращаемыми SQL-сервером в ответ на запрос.
Небольшое отступление. При создании SQL-запросов следует избегать использования конструкций вида select * from … поскольку для постороннего человека, не знающего структуру таблицы, к которой происходит обращение, невозможно понять, какие данные вернутся из БД. Подобные конструкции можно использовать только для отладочных целей, а в окончательном коде лучше всегда явно указывать названия полей таблиц, из которых делается выборка данных.
Остальная часть кода уже не должна вызывать вопросов: if обрабатывает ситуацию, когда поле day (выбранный пользователем день на календаре, который передается из функции calendar) не определено, то есть человек пришел из другого раздела сайта через меню навигации. Если поле формы day определено (def), то используется день, переданный посетителем, в противном случае используем текущее число. Далее соединяемся с БД, также как мы это делали, когда добавляли новости, создаем таблицу $news, в которую заносим новости за запрошенный день (результат SQL-запроса), после чего с помощью метода menu последовательно перебираем строки таблицы news и выводим новости, обращаясь к ее полям. Все понятно и знакомо, кроме одного вспомогательного оператора, который служит для специфического вывода текста новости:
^untaint{$news.body}
Отвлекитесь немного и внимательно прочитайте раздел справочника, посвященный операторам taint и untaint, где подробно описана логика их работы. Это очень важные операторы и вы наверняка столкнетесь с необходимостью их использования. К тому же большой объем работы по обработке данных Parser делает самостоятельно, она не видна на первый взгляд, но понимать логику действий необходимо.
Прочитали? Теперь продолжим. Зачем он нужен здесь? У нас есть страница для администрирования новостей, и мы хотим разрешить использование тегов HTML в записях. По умолчанию это запрещено, чтобы посторонний человек не мог внести Java-скрипт, например, перенаправляющий пользователя на другой сайт. Как это сделать? Да очень просто: достаточно выборку записей из таблицы преобразовать с помощью оператора untaint:
^untaint{текст новости}
В нашем случае используется значение по умолчанию [as-is], которое означает, что данные будут выведены так, как они есть в базе. Мы можем позволить себе поступить так, поскольку изначально не предполагается доступ обычных пользователей к разделу администрирования, через который добавляются новости.
Теперь можно немного расслабиться - новостной блок нашего сайта завершен. Мы можем добавлять новости и получать их выборку за указанный пользователем день. На этом четвертый урок будем считать оконченным, хотя есть некоторые детали, которые можно доработать, а именно: научить календарь не ставить ссылки на дни после текущего, выводить в заголовке информационной части дату, за которую показываются новости, да и просто реализовать возможность доступа к новостям не только за текущий месяц, но и за предыдущие. Однако это уже задание вам. Знаний, полученных на предыдущих уроках вполне достаточно, чтобы доработать этот пример под свои требования и желания. Творите!
Подведем итоги четвертого урока.
Пользовательские классы Parser
Во всех предыдущих уроках мы оперировали классами и объектами, предопределенными в Parser. Например, есть уже хорошо знакомый нам класс table, у него существуют свои методы, которые мы широко использовали. Полный список всех методов этого класса можно посмотреть в справочнике. Однако ограничение разработчиков рамками только базовых классов в какой-то момент может стать сдерживающим фактором. «Неспособность не есть благодетель, а есть бессилие…», поэтому для удовлетворения всех потребностей пользователей необходимо иметь возможность создавать собственные (пользовательские) классы объектов со своими методами. На этом уроке мы и создадим средствами Parser новый класс объектов со своими собственными методами.
Объектом, в принципе, может быть все что угодно: форум, гостевая книга, различные разделы и даже целый сайт. Здесь мы подошли к очередному уровню структуризации - на уровне объектов, а не методов. Как мы поступали раньше? Мы выделяли отдельные куски кода в методы и вызывали их, когда они были необходимы. Но в качестве отдельных блоков сайта было бы намного удобнее использовать собственные объекты: для получения форума создаем объект класса «форум», после чего используем его методы, например «удалить сообщение», «показать все сообщения» и поля, например, «количество сообщений». При этом обеспечивается модульный подход на качественно ином уровне, чем простое использование функций. В единую сущность собираются код и данные (методы и поля). Разрозненные ранее методы и переменные объединяются воедино и используются применительно к конкретному объекту - «форуму». В терминах объектно-ориентированного программирования это называется инкапсуляцией. Кроме того, один раз создав класс форум, его объекты можно использовать в различных проектах, абсолютно ничего не меняя.
Работу с пользовательским классом мы покажем на примере гостевой книги, а для начала еще раз напомним порядок работы с объектами в Parser. Сначала необходимо создать объект определенного класса с помощью конструктора, после чего можно вызывать методы объектов этого класса и использовать поля созданного объекта. В случае пользовательского класса ничего не меняется, порядок тот же.
Как всегда начнем с определения того, что нам нужно сделать. Правильная постановка задачи - уже половина успеха. Перед началом создания класса нужно точно определить, что будет делать объект класса, то есть решить, какие у него будут методы. Предположим, что нашими методами будут: показ сообщений гостевой книги, показ формы для добавления записи, а также метод, добавляющий сообщение в гостевую книгу. Хранить сообщения будем в базе данных, так же как и новости.
Если с методами класса все более или менее ясно, то некоторая неясность остается с конструктором класса, что же он будет делать? Опираясь на прошлые уроки, мы помним, что для того, чтобы начать работать с объектом класса, его необходимо создать, или проинициализировать. Давайте с помощью конструктора будем получать таблицу с сообщениями, а затем в методе показа сообщений будем пользоваться данными этой таблицы.
С целями определились, займемся реализацией. Прежде всего, создадим таблицу gbook в базе данных p3test:
Теперь необходимо познакомиться еще с несколькими понятиями Parser - классом MAIN и наследованием. Как уже говорилось, класс является объединяющим понятием для объектов, их методов и полей. Класс MAIN объединяет в себя методы и переменные, описанные пользователями в файлах auto.p и запрашиваемом документе (например, index.html). Каждый следующий уровень вложенности наследует методы, описанные в auto.p предыдущих уровней каталога. Эти методы, а также методы, описанные в запрашиваемом документе, становятся статическими функциями класса MAIN, а все переменные, созданные в auto.p вверх по каталогам и в коде запрошенной страницы, - статическими полями класса MAIN.
Для пояснения рассмотрим следующую структуру каталогов:
/
|__ auto.p
|__ news/
| |___auto.p
| |___index.html
| |___details/
| |_______ auto.p
| |_______index.html
|__contacts/ |
|_______auto.p
|_______index.html
При загрузке страницы index.html из каталога /news/details/ класс MAIN будет динамически «собран» из методов, описанных в корневом файле auto.p, а также в файлах auto.p разделов /news/ и /news/details/. Методы, описанные в auto.p раздела /contacts/, будут недоступны для страниц из раздела /news/details/.
Как «собирается» класс MAIN теперь понятно, но, прежде чем приступить к созданию собственного класса, необходимо также выяснить, как из пользовательского класса вызывать методы и получать значения переменных класса MAIN. Методы класса MAIN вызываются как статические функции:
^MAIN:метод[],
а переменные являются статическими полями класса MAIN. К ним можно получить доступ так же, как к любым другим статическим полям:
$MAIN:поле
Теперь переходим к практике. В корневой auto.p добавляем еще один метод, с помощью которого можно будет не только соединяться с БД, но и передавать ей произвольный SQL-запрос:
@dbconnect[code]
^connect[$connect_string]{$code}
# connect_string определяется в методе @auto[]
# $connect_string[mysql://root@localhost/p3test]
Метод вынесен в корневой auto.p для того, чтобы впоследствии можно было бы легко подключаться к серверу баз данных с любой страницы, поскольку методы из корневого auto.p будут наследоваться всегда. Обратите внимание на то, что здесь используется передача методу параметра. В нашем случае он один - code, с его помощью мы и будем передавать код, выполняющий SQL-запросы. Параметров может быть и несколько, в этом случае они указываются через точку с запятой.
Дальше в каталоге нашего сайта создаем подкаталог, в которой будем хранить файл с нашим классом, например, classes. Далее в этом каталоге создаем файл gbook.p (пользовательские файлы мы предлагаем хранить в файлах с расширением имени .p) и в него заносим следующий код:
@CLASS
gbook
@load[]
^MAIN:dbconnect{
$messages[^table::sql{select author, email, date, body from gbook}]
}
@show_messages[]
^if($messages){
^messages.menu{
<table width="100%">
<tr>
<td align="left"><b>$messages.author
^if(def $messages.email){
$messages.email
}{
Нет электронного адреса
}</b>
</td>
<td align="right">$messages.date</td>
</tr>
</table>
<table width="100%">
<tr>
<td>$messages.body</td>
</tr>
</table>
}[<table width="100%" border="0" bgcolor="000000" cellspacing="0">
<tr><td> ^;</td></tr>
</table>]
}{
Гостевая книга пуста.
}
@show_form[]
<hr>
<br>
$date[^date::now[]]
<center>
<form method="POST">
<p>
Author<sup>*</sup><input name="author"><br>
E-mail <input name="email">
<br>text<br><textarea cols="50" name="text" rows="5"></textarea>
</p>
<p>
<input type="submit" value="Send" name="post">
<input type="reset" value="Cancel">
</p>
</form>
</center>
@test_and_post_message[]
^if(def $form:post){
^if(def $form:author){
^MAIN:dbconnect{
^void:sql{insert into gbook
(author, email, date, body)
values (
'$form:author',
'$form:email',
'${date.year}-${date.month}-${date.day}',
'$form:text'
)}
}
$response:location[$request:uri]
}{
<center>Поле автор обязательно для заполнения</center>
}
}
Посмотрите на код. В первой строке мы говорим, что в этом файле будем хранить пользовательский класс:
@CLASS
В том случае если в качестве родительского выступает другой пользовательский класс, его необходимо подключить, а также объявить базовым. Получится такая конструкция:
@CLASS
имя класса
@USE
файл родительского класса
@BASE
имя родительского класса
Следующей строкой пишем имя нашего класса gbook. Необходимо помнить, что Parser чувствителен к регистру букв в именах, поэтому классы gbook и Gbook являются разными. При этом имя не обязательно должно совпадать с именем файла, в котором храниться пользовательский класс, более того, может быть набрано русскими буквами.
Дальше определяются методы нашего нового класса. Делается это точно так же, как и определение обычных методов, которые мы создавали на предыдущих уроках.
Первый метод load будет конструктором нашего класса. При этом надо иметь в виду, что задача конструктора - создать объект. Кроме этого, он может объявить переменные и присвоить им значения. Эти переменные станут полями объекта пользовательского класса. В нашем случае мы при помощи конструктора sql класса table создаем нужную таблицу. Обратите внимание, что в методах нового класса мы свободно пользуемся методами системных классов и методом dbconnect класса MAIN:
@load[]
^MAIN:dbconnect{
$messages[^table::sql{select author, email, date, body from gbook}]
}
Как уже говорилось выше, поскольку мы находимся за пределами класса MAIN, для использования методов этого класса перед именем необходимо указать класс, к которому эти методы/поля относятся. Делается это таким образом:
^имя_класса:метод[параметры]
$имя_класса:переменная
В случае, если мы захотим использовать методы/поля другого пользовательского класса, а не класса MAIN, необходимо в начале кода выполнять инструкцию:
@USE
путь к файлу, описывающему класс
Она позволяет использовать модуль, определенный в другом файле. О работе Parser с путями к файлам, рассказано в приложении 1.
Итак, наш новый конструктор будет создавать таблицу с сообщениями, подключаясь к указанной БД. С конструктором разобрались, начинаем описание собственно методов нового класса. Метод show_messages нашего класса выводит на экран сообщения из таблицы gb, созданной в методе load. Строки перебираются при помощи метода menu класса table. Все знакомо, ничего нового нет и в других методах:
show_form - выводит на экран форму для добавления нового сообщения гостевой книги
test_and_post_message - проверяет, нажата ли кнопка post, заполнено ли поле author и, если все условия выполнены, заносит сообщение в базу данных, используя все тот же метод dbconnect, определенный в классе MAIN
На этом создание пользовательского класса, описывающего методы объектов класса gbook, завершено. Его осталось только подключить для использования на нашем сайте. Перед нами стоит задача сообщить Parser, что на некоторой странице мы собираемся использовать свой класс. Для этого в файле index.html каталога gbook в первой строке напишем следующее:
@USE
/classes/gbook.p
Теперь на этой странице можно создать объект класса gbook и использовать затем его методы. Сделаем это в основной информационной части:
@body_main[]
Гостевая книга тестового сайта<br>
<hr>
$gb[^gbook::load[]]
^gb.show_messages[]
^gb.show_form[]
^gb.test_and_post_message[]
# и конечно же не забываем про остальные части
@greeting[]
Оставьте свой след:
@body_additional[]
Нам пишут…
Здесь мы уже работаем с объектом созданного пользовательского класса, как с любым другим объектом: создаем его при помощи конструктора класса и вызываем методы, определенные в новом классе. Посмотрите, насколько изящным получилось наше решение. Читабельность кода очевидна и, глядя на этот фрагмент, сразу понятно, что он делает. Все, что относится к гостевой книге, находится в отдельном файле, где описано все, что можно с ней сделать. Если нам понадобится новый метод для работы с гостевой книгой, нужно просто дописать его в файл gbook.p. Все очень легко модернизируется, к тому же сразу понятно, где необходимо вносить изменения, если они вдруг понадобились.
В заключение хочется заметить, что изящнее было бы вынести методы вроде dbconnect из класса MAIN в отдельный класс. Это позволило бы не перегружать класс MAIN, улучшилась бы читаемость кода, а также легче стало бы ориентироваться в проекте. Там, где эти нужны методы этого класса, его можно было бы подключать с помощью @USE.
Подведем итоги пятого урока.
Работаем с XML
<?xmlversion="1.0" encoding="windows-1251" ?>
<article>
<author id="1" />
<title>Урок 6. Работаем с XML</title>
<body>
<para>Представьте, что вам позволено придумывать любые теги
с любыми атрибутами. То есть вы сами можете определять,
что означает тот или иной выдуманный вами тег или атрибут.</para>
<para>Такой код будет содержать данные, …</para>
</body>
<links>
<link href="http://parser.ru/docs/lang/xdocclass.htm">Класс xdoc</link>
<link href="http://parser.ru/docs/lang/xnodeclass.htm">Класс xnode</link>
</links>
</article>
…но не их форматирование. Подготовкой данных может заняться один человек, а форматированием другой. Им достаточно договориться об используемых тегах и можно приступать к работе… одновременно.
Идея эта не нова, существовали многочисленные библиотеки обработки шаблонов, а многие создавали собственные. Библиотеки были несовместимы между собой, зависели от используемых средств скриптования, порождая разобщенность разработчиков и необходимость тратить силы на изучение очередной библиотеки вместо того, чтобы заняться делом.
Однако прогресс не стоит на месте, и сейчас мы имеем не зависящие от средства скриптования стандарты XML и XSLT, позволяющие нам реализовать то, что мы только что представляли. А также стандарты DOM и XPath, открывающие для нас еще больше возможностей.
Parser полностью поддерживает все эти стандарты.
Сейчас откройте выбранную вами вчера в книжном магазине книгу, описывающую XML и XSLT. Используйте ее как справочник.
Посмотрим, как можно приведенную статью преобразовать из XML в HTML.
Запишем текст из начала статьи в файл article.xml
И создадим файл article.xsl, в котором определим выдуманные нами теги:
<?xml version="1.0" encoding="windows-1251" ?>
<xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform" version="1.0">
<xsl:template match="article">
<html>
<head><title><xsl:value-of select="title" /></title></head>
<body><xsl:apply-templates select="body | links" /></body>
</html>
</xsl:template>
<xsl:template match="body">
<xsl:apply-templates select="para" />
</xsl:template>
<xsl:template match="links">
Ссылки по теме:
<ul>
<xsl:for-each select="link">
<li><xsl:apply-templates select="." /></li>
</xsl:for-each>
</ul>
</xsl:template>
<xsl:template match="para">
<p><xsl:value-of select="." /></p>
</xsl:template>
<xsl:template match="link">
<a href="{@href}"><xsl:value-of select="." /></a>
</xsl:template>
</xsl:stylesheet>
Данные и шаблон преобразования готовы. Создаем article.html, в который заносим следующий код:
# входной xdoc документ
$sourceDoc[^xdoc::load[article.xml]]
# преобразование xdoc документа шаблоном article.xsl
$transformedDoc[^sourceDoc.transform[article.xsl]]
# выдача результата в HTML виде
^transformedDoc.string[
$.method[html]
]
Первой строкой мы загружаем XML-файл, получая в sourceDoc его DOM-представление.
Конструкция похожа на загрузку таблицы, помните ^table::load[…]? Только в этот раз мы загружаем не таблицу (получая объект класса table), а XML-документ (получаем объект класса xdoc).
Второй строкой мы преобразуем входной документ по шаблону article.xsl.
Из входного документа получаем выходной, применяя XSLT преобразование, описанное в шаблоне.
Последней строкой мы выдаем пользователю текст выходного документа в HTML формате (параметр method со значением html).
Здесь можно задать все параметры, допустимые для тега <xsl:output … />.
Рекомендуем также задать параметр "без отступов" (параметр indent со значением no: $.indent[no]), чтобы избежать известной проблемы с пустым местом перед </td>.
Обратившись теперь к этой странице, пользователь получит результат преобразования:
<html>
<head><title>Урок 6. Работаем с XML</title></head>
<body>
<p>Представьте, что вам позволено придумывать любые теги
с любыми атрибутами. То есть вы сами можете определять,
что означает тот или иной выдуманный вами тег или атрибут.
</p>
<p>Такой код будет содержать данные, …
</p>
Ссылки по теме:
<ul>
<li><a href="http://parser.ru/docs/xdocclass.htm">Класс xdoc</a></li>
<li><a href="http://parser.ru/docs/xnodeclass.htm">Класс xnode</a></li>
</ul>
</body>
</html>
Как вы заметили, тег <author … /> никак не был определен, как следствие, информация об авторе статьи не появилась в выходном HTML. Со временем, когда вы решите где и как будете хранить и показывать данные об авторах, достаточно будет дополнить шаблон - исправлять данные статей не потребуется.
Внимание: если вы не хотите, чтобы пользователи вашего сервера имели доступ к .xml и .xsl файлам, храните эти файлы вне веб-пространства (^xdoc::create[/../directory_outside_of_web_space/article.xml]), или запретите к ним доступ средствами веб-сервера (пример запрета доступа к .p файлам здесь: «Установка Parser на веб-сервер Apache. CGI скрипт»).
Подведем итоги шестого урока.
Abs, sign. Операции со знаком
Выполняют операции со знаком числа.
Число Пи
$math:PI - число p
Compact. Сборка мусора [3.1]
^memory:compact[]
Собирает так называемый «мусор» в памяти, освобождая ее для повторного использования вашим кодом.
Мусором считается память, более не используемая вашим кодом, т.е. та, на которую в вашем коде нет ссылок.
Например,
$table[^table::sql{запрос}]
$table[]
# освободит память, занимаемую результатом выполнения SQL-запроса
^memory:compact[]
Parser не собирает мусор автоматически, полагаясь в данном вопросе на кодера: поставьте вызов compact в той точке (точках), где ожидаете наибольшей выгоды, например, перед XSL преобразованием.
$status:memory поможет вам в отладке и поиске мест, наиболее выгодных для сборки мусора.
Важно: необходимо как можно более интенсивно использовать локальные переменные, и обнулить глобальные, которые вам не будут нужны для дальнейшей работы кода. Это поможет compact освободить больше.
Важно: не гарантируется, что будет освобождена абсолютно вся неиспользуемая память.
Crypt. Хеширование паролей
^math:crypt[password;salt]
Хеширует password с учетом salt.
Параметры:
| · | password - исходная строка; |
| · | salt - строка, определяющая алгоритм хеширования и вносящая элемент случайности в результат хеширования, состоит из начала и тела. Начало определяет алгоритм хеширования, тело вносит элемент случайности. Если тело не будет указано, Parser сформирует случайное. |
Неразумно хранить пароли пользователей, просто записывая их на диск или в базу данных - ведь если предположить, что злоумышленник украдет файл или таблицу с паролями, он легко сможет ими воспользоваться. Поэтому принято хранить не пароли, а их хеши - результат надежного однозначного необратимого преобразования строки пароля. Для проверки введенного пароля к нему применяют то же преобразование, передавая в качестве salt сохраненный хеш, а результат сверяют с сохраненным.
Вносить элемент случайности необходимо, поскольку иначе потенциальный злоумышленник может заранее сформировать таблицу хешей многих частоиспользуемых паролей. Вторая причина: элемент случайности вносится на начальном этапе алгоритма хеширования, что существенно осложняет подбор пароля даже при использовании специальных аппаратных ускорителей.
Внимание: обязательно задавайте случайное тело salt, или позвольте Parser сделать это за вас, попросту не указывая тело salt, указывая только начало salt.
Таблица доступных алгоритмов:
|
Алгоритм |
Описание |
Начало salt |
Тело "salt" |
|
MD5 |
встроен в Parser, доступен на всех платформах |
$apr1$ |
до 8 случайных букв (в любом регистре) или цифр |
|
MD5 |
если поддерживается операционной системой (UNIX) |
$1$ |
до 8 случайных букв (в любом регистре) или цифр |
|
DES |
если поддерживается операционной системой (UNIX) |
(нет) |
2 случайных буквы (в любом регистре) или цифры |
|
другие |
какие поддерживаются операционной системой (UNIX) |
читайте документацию на вашу операционную систему, функция crypt |
читайте документацию на вашу операционную систему, функция crypt |
Внимание: в Parser для использования в тексте символа '$' его необходимо предварить символом '^'.
Примечание: Веб-сервер Apache допускает в файлах с паролями (.htpasswd) использовать хеши сформированные по любому из алгоритмов, представленных в таблице, включая алгоритм, встроенный в Parser.
Degrees, radians. Преобразования градусы-радианы
Методы выполняют преобразования из градусов в радианы и обратно.
Exp, log. Логарифмические функции
Примечание (если вы совсем забыли родную школу):
логарифм по произвольному основанию base вычисляется как log(число)/log(base).
Класс mail
Класс предназначен для работы с электронной почтой. Описание настройки Parser для работы этого класса см. Конфигурационный метод.
Класс MAIN, обработка запроса
Parser обрабатывает запрошенный документ следующим образом:
1.
Считываются, компилируются и инициализируются Конфигурационный файл; затем все файлы с именем auto.p, поиск которых производится начиная от корня веб-пространства, и ниже по структуре каталогов, вплоть до каталога с запрошенным документом; наконец, сам запрошенный документ.
Все вместе они составляют определение класса MAIN.
Инициализация заключается в вызове метода auto каждого загруженного файла. Если определение этого метода содержит параметр, при вызове в нем будет передано имя загруженного файла.
Примечание: результат работы метода посетителю не выводится.
2.
Затем вызывается без параметров метод main класса MAIN.
Т.е. в любом из перечисленных файлов может быть определен метод main, и будет вызван тот, который был определен последним - скажем, определение этого метода в запрошенном документе перекрывает все остальные возможные определения, и будет вызван именно он.
Результат работы этого метода будет передан пользователю, если не был определен метод postprocess.
Если в файле не определен ни один метод, то все его тело считается определением метода main.
Примечание: задание $response:body[нестандартногоответа] переопределяет текст, получаемый пользователем.
3.
Если в классе MAIN определен метод postprocess, то результат работы метода main передается единственным параметром этому методу, и пользователь получит уже его результат работы.
Таким образом вы получаете возможность «дополнительной полировки» результата работы вашего кода.
Класс math
Класс math не имеет конструкторов для создания объектов, он обладает только статическими методами и предназначен для вычисления математических выражений. При работе с этим классом необходимо учитывать ограничения на разрядность для класса double.
Класс memory [3.1]
Класс предназначен для работы с памятью Parser.
Его использование поможет вам экономить память в ваших скриптах.
Для любознательных: в Parser используется известный и хорошо зарекомендовавший себя консервативный сборщик мусора Boehm-Demers-Weiser, см. http://www.hpl.hp.com/personal/Hans_Boehm/gc/.
Md5. MD5-отпечаток строки [3.0.8]
^math:md5[строка]
Из переданной строки получает «отпечаток» размером 16 байт.
Выдает его представление в виде строки - байты представлены в шестнадцатеричном виде без разделителей, в нижнем регистре.
Считается, что практически невозможно
| · | создать две строки, имеющие одинаковый «отпечаток»; |
| · | восстановить исходную строку по ее «отпечатку». |
Pow. Возведение числа в степень
^math:pow(число;степень)
Возводит число в степень.
получаем 90
|
^math:degrees($math:PI/2) |
- получаем 90 (градусов) |
|
^math:radians(180) |
- получаем p |
^math:abs
однозначное соответствие имени строке запроса,
В качестве имени cache-файла возьмем «отпечаток» строки $request:uri, это обеспечит взаимно- однозначное соответствие имени строке запроса, а также избавит нас от необходимости укорачивать строку запроса и очищать ее от спецсимволов.
^cache[$cache_directory/^math:md5[$request:uri]]($cache_time){
…
}
Подробная информация о MD5 доступна здесь: http://www.ietf.org/rfc/rfc1321.txt
получаем 1024
^math:pow(2;10) - получаем 1024 ( 210 =1024 )
Получим случайное число из диапазона
^math:random(1000)
Получим случайное число из диапазона от 0 до 999.
получаем 45
|
^math:round(45.50) |
- получаем 46 |
|
^math:floor(45.60) |
- получаем 45 |
|
^math:ceiling(45.20) |
- получаем 46 |
|
^math:round(-4.5) |
- получаем -4 |
|
^math:floor(-4.6) |
- получаем -5 |
|
^math:ceiling(-4.20) |
- получаем -4 |
^math:cos
^math:cos(^math:radians(180)) - получаем -1 (cos p = -1).
получаем 85
|
^math:trunc(85.506) |
- получаем 85 |
|
^math:frac(85.506) |
- получаем 0.506 |
В разных филиалах компании собираются
В разных филиалах компании собираются заказы, которые периодически отправляются в центральный офис. Чтобы обеспечить уникальность идентификатора заказа используем UUID.
# в разных филиалах происходит наполнение таблицы orders и order_details
# создаем уникальный идентификатор
$order_uuid[^math:uuid[]]
# добавляем запись о заказе
^void:sql{
insert into orders
(order_uuid, date_ordered, total)
values
('$order_uuid', '$date_ordered', $total)
}
#цикл по заказанным продуктам вокруг добавления записи о продукте
^void:sql{
insert into order_details
(order_uuid, item_id, price)
values
('$order_uuid', $item_id, $price)
}
# с какой-то периодичностью выбирается часть таблицы orders (и order_details)
# отправляется (^mail:send[…]) в центральный офис,
# где части таблиц попадают в общие таблицы orders и order_details
# БЕЗ проблем с повторяющимся order_id
Примечание: Parser создает UUID основываясь на случайных числах, а не времени. Параметры:
| · | variant = DCE; |
| · | version = DCE Security version, with embedded POSIX UIDs. |
xxxxxxxx-xxxx-4xxx-{8,9,A,B}xxx-xxxxxxxxxxxx
Подробная информация о UUID доступна здесь: http://www.opengroup.org/onlinepubs/9629399/apdxa.htm
если вы совсем забыли родную
^math:sqrt(16) - получаем 4
Примечание [ если вы совсем забыли родную школу]:
корень n-ной степени вычисляется как возведение в степень 1/n.
Пример проверки пароля
$right[123]
$from_user[123]
$crypted[^math:crypt[$right;^$apr1^$]]
#обратите внимание на то, что $crypted при каждом обращении разный
$crypted<br>
^if(^math:crypt[$from_user;$crypted] eq $crypted){
Казнить нельзя, помиловать
}{
Казнить, нельзя помиловать
}
Подробная информация о MD5 доступна здесь: http://www.ietf.org/rfc/rfc1321.txt
Пример создания .htpasswd файла
@main[]
$users[^table::create{name password
alice xxxxxx
bob yyyyyy
}]
$htpasswd[^table::create[nameless]{}]
^users.menu{
^htpasswd.append{$users.name:^math:crypt[$users.password;^$apr1^$]}
}
^htpasswd.save[nameless;.htpasswd-parser-test]
Простой пример
Добавление такого определения, скажем, в файл auto.p в корне вашего веб-пространства…
@postprocess[body]
^body.match[шило][g]{мыло}
…приведет к замене одних слов на другие в результатах обработки всех страниц.
Random. Случайное число
^math:random(верхняя_граница)
Метод возвращает случайное число, попадающее в интервал от 0 до заданного числа, не включая заданное.
Примечание: на некоторых операционных системах выдает псевдослучайное число.
Round, floor, ceiling. Округления
Методы возвращают округленное значение заданного числа класса double.
Send. Отправка сообщения по электронной почте
^mail:send[сообщение]
Метод отправляет сообщение на заданный адрес электронной почты. Можно указать несколько адресов через запятую.
Пример:
^mail:send[
$.from[Вася <vasya@hotmail.ru>]
$.to[Петя <petya@hotmail.ru>]
$.subject[как дела]
$.text[Как у тебя дела? У меня - изумительно!]
]
В результате будет отправлено сообщение для petya@hotmail.ru с содержимым "Как у тебя дела? У меня - изумительно!".
сообщение - хеш, в котором могут быть заданы такие ключи:
| · | поле_заголовка |
| · | text |
| · | html |
| · | file |
| · | charset |
| · | options [3.1.2]
|
Внимание: рекомендуется в поле заголовка errors-to задавать адрес, на который может придти сообщение об ошибке доставки письма. По-умолчанию «postmaster».
charset - если задан этот ключ, то заголовок и текстовые блоки сообщения будут перекодированы в указанную кодировку. По умолчанию сообщение отправляется в кодировке, заданной в $request:charset (т.е. не перекодируется).
Пример:
$.charset[koi8-r]
options - эти опции будут переданы в командную строку программе sendmail (только под UNIX).
Также можно задать все поля заголовка сообщения, передав их значение в таком виде (короткая форма):
$.поле_заголовка[строка]
или с параметрами (полная форма):
$.поле_заголовка[
$.value[строка]
$.параметр[строка]
]
Примеры:
$.from[Вася <vasya@hotmail.ru>]
$.to[Петя <petya@hotmail.ru>]
$.subject[Как у тебя дела? У меня - изумительно!]
$.x-mailer[Parser 3]
Кроме заголовка можно передать один или оба текстовых блока: text, html. А также любое количество блоков file и message (см. ниже).
Если будет передано оба текстовых блока, будет сформирована секция MULTIPART/ALTERNATIVE, при прочтении полученного сообщения современные почтовые клиенты покажут HTML, а устаревшие - простой текст.
Короткая форма:
$.text[строка]
Полная форма…
$.text[
$.value[строка]
$.поле_заголовка[значение]
]
…где value - значение тестового блока, и можно задать все поля заголовка сообщения, передав их как и в хеше сообщение (см. выше).
Внимание: можно не передавать заголовок content-type, он будет сформирован автоматически. Этот заголовок не влияет на перекодирование, а влияет только на ту кодировку, в которой почтовый клиент будет отображать сообщение.
Отправка HTML. Короткая форма:
$.html{строка}
Полная форма:
$.html[
$.value{строка}
$.поле_заголовка[значение]
]
Фигурные скобки нужны для переключения вида преобразования по умолчанию на HTML.
Вложение файла. Короткая форма:
$.file[файл]
Полная форма:
$.file[
$.value[файл]
$.name[имя_файла]
]
Файл - объект класса file, который будет прикреплен к сообщению. MIME-тип данных (content-type заголовок части) определяется по таблице MIME-TYPES (см. Конфигурационный метод).
Имя_файла - имя, под которым файл будет передан.
Файл будет передан в uuencode форме.
Вложение сообщения:
$.message[сообщение]
Формат сообщения такой же, как у параметра всего метода.
Вложений может быть несколько, для чего после имени следует добавить целое число. Пример:
$.file
$.file2
$.message
$.message2
Пример с альтернативными блоками и вложениями:
^mail:send[
$.from[Вася <vasya@hotmail.ru>]
$.to[Петя <petya@hotmail.ru>]
$.subject[как дела]
$.text[Как у тебя дела? У меня изумительно!]
$.html{Как у тебя дела? У меня <b>изумительно</b>!}
$.file[^file::load[binary;perfect_life1.jpg]]
$.file2[
$.value[^file::load[binary;perfect_life2.jpg]]
$.name[изумительная_жизнь2.jpg]
]
]
В результате будет отослано сообщение для petya@hotmail.ru с содержимым «Как у тебя дела? У меня - изумительно!» в простом тексте и HTML. К сообщению будут приложены две подтверждающие фотографии, на которых…
Sin, asin, cos, acos, tan, atan. Тригонометрические функции
Методы вычисляют значения тригонометрических функций от заданного числа.
Sqrt. Квадратный корень числа
^math:sqrt(число)
Вычисляет квадратный корень числа.
Trunc, frac. Операции с целой/дробной частью числа
Uid64. 64-битный уникальный идентификатор [3.0.8]
^math:uid64[]
Выдает случайную строку вида…
BA39BAB6340BE370
Примечание: на некоторых операционных системах выдает псевдослучайную строку.
См. ^math:uuid[].
Uuid. Универсальный уникальный идентификатор [3.0.8]
^math:uuid[]
Выдает случайную строку вида…
22C0983C-E26E-4169-BD07-77ECE9405BA5
Примечание: на некоторых операционных системах выдает псевдослучайную строку.
Удобно использовать, когда трудно обеспечить или вообще нецелесообразно использовать сквозную нумерацию объектов.
Например, при распределенных вычислениях.
UUID также известен как GUID.
