Автор Тема: Справка  (Прочитано 14747 раз)

0 Пользователей и 1 Гость просматривают эту тему.

Оффлайн FussesDemon

  • GODMODE
  • *******
  • Сообщений: 407
  • Авторитет +61/-12
    • Просмотр профиля
Справка
« : 25 Августа 2006, 10:01:17 »
SSI (Server Side Includes - директивы включения на стороне сервера)
SSI - это директивы, вставляемые прямо в HTML-код и служащие для передачи указаний Wев-серверу. Встречая такие директивы, которые, кстати, называются SSI-вставками, Web-сервер интерпретирует их и выполняет соответствующие действия. Какие, спросите Вы? А вот, например: вставка HTML-фрагмента из другого файла, динамическое формирование страничек в зависимости от некоторых переменных (например, типа броузера) и другие не менее приятные вещи.

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

Для того, чтобы сервер знал, что страничка не обычная, а содержит SSI-директивы, она имеет специальное расширение: *.shtml или *.shtm, наличие которого и заставляет web-сервер предварительно обрабатывать странички. Вообще-то, расширение может быть любое - в зависимости от конфигурации web-сервера, но в основном применяется именно *.shtml.



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

<!--#command param="value" -->

где # - признак начала SSI-вставки

command - SSI-команда

param - параметры SSI-команды



SSI-команд насчитывается около десятка, но я расскажу только о самых употребимых. Самая популярная команда - это команда включения содержимого одного файла в другой:

<!--#include virtual="/path/file.ssi" -->

где include - команда вставки

virtual - параметр, определяющий, как трактовать путь - как абсолютный file или как относительный virtual

"/path/file.ssi" - путь к включаемому файлу

Результатом ее выполнения будет вставка содержимого файла file.ssi в месте появления данной директивы. При просмотре сформированного исходника HTML-файла мы не увидим никаких признаков SSI, т.к. данный механизм действует абсолютно прозрачно для броузеров, они получают исключительно корректный HTML-код.



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

<!--#set var="pic" value="picture.gif" -->

где var - команда установки значения переменной

pic - имя переменной

"picture.gif" - значение переменной

В данном случае мы определили переменную с именем pic и присвоили ей строковое значение "picture.gif". Значение переменной pic теперь доступно внутри SSI-вставки, и мы можем его использовать по нашему усмотрению.

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




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

<!--#echo var="pic" -->

Ее выполнение приведет к тому, что в месте появления команды напечатается значение переменной pic, т.е. "picture.gif".

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

Вот пример:

<!--#set var="A" value="123" -->

<!--#set var="B" value="$A456" -->

После такого присвоения переменная B будет содержать строку "123456". Если же в текст понадобится просто вставить знак '$' или какой-нибудь из других специальных знаков, то его нужно предварить слешем, вот так: '\$'. В некоторых случаях для избежания двусмысленности значение переменной может быть заключено в фигурные скобки: "${A}".



Более сложное применение переменных возможно с использованием условных операторов, имеющих следующую форму написания:


<!--#if expr="condition" -->

<!--#elif expr="condition" -->

<!--#else -->

<!--#endif -->

где condition - условие для сравнения

В зависимости от результатов проверки мы можем подставить тот или иной фрагмент кода. Допустим, мы можем проанализировать тип броузера пользователя и в зависимости от этого выдать либо код для Netscape Navigator-а, либо Internet Explorer-а. Это может оказаться полезным в некоторых случаях, когда невозможно сделать страничку, которая корректно отображалась бы в обоих броузерах. Вот пример использования условного оператора:

<!--#set var="Monday" -->

<!--#if expr="$Monday " -->

Сегодня понедельник.

<!--#else -->

Что угодно, но не понедельник.

<!--#endif -->

В данном случае условием проверки является существование переменной $Monday и, в зависимости от этого, подстановка того или иного HTML-кода.



Теперь давайте рассмотрим реальный пример применения SSI для формирования сложного документа из нескольких SSI-вставок.

Вначале напишем текст основного HTML-документа, полагая, что SSI-вставки находятся в каталоге /ssi:



index.shtml

<!--#set var="title" value="Что такое SSI?" -->

<!--#set var="keywords" value="SSI, SHTML, CGI, Apache" -->

<!--#set var="description" value="Пример использования SSI." -->

<!--#include virtual="ssi/_header.shtml" -->



Здесь находится текст нашей странички.

<!--#include virtual="ssi/_footer.shtml" -->



Теперь напишем код для этих SSI-вставок:



_header.shtml

<html>

<head>

<title><!--#echo var="title" --></title>

<meta name="keywords" content="<!--#echo var="keywords" -->">

<meta name="description" content="<!--#echo var="description" -->">



_footer.shtml

</body>

</html>



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

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

Второе, не менее важное преимущество, - это возможность мгновенной замены дизайна сайта, не требующая переделывания страничек с информационным содержанием сайта. Для смены дизайна достаточно переписать SSI-вставки, формирующие внешний вид сайта. В нашем случае это файлы _header.shtml и _footer.shtml.

Оффлайн FussesDemon

  • GODMODE
  • *******
  • Сообщений: 407
  • Авторитет +61/-12
    • Просмотр профиля
Справка
« Ответ #1 : 25 Августа 2006, 10:02:14 »
CGI - Common Gateway Interface
Введение
CGI - Common Gateway Interface является стандартом интерфейса (связи) внешней прикладной программы с информационным сервером типа HTTP, Web сервер.

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

Программа-шлюз запускается WWW сервером в реальном масштабе времени. WWW сервер обеспечивает передачу запроса пользователя шлюзу, а она в свою очередь, используя средства прикладной системы, возвращает результат обработки запроса на экран пользователя. Программа-шлюз может быть закодирована на языках C/C++, Fortran, Perl, TCL, Unix Schell, Visual Basic, Apple Script. Как выполнимый модуль, она записывается в поддиректорий с именем cgi-bin WWW сервера.

Оригинал описания CGI интерфейса - инструмента связи программы-шлюз с WWW сервером находится в узле wist.ifmo.ru.

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


Запросы для различных методов
Информация шлюзам передается в следующей форме:

имя=значение&имя1=значение1&..,

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

На файловый дескриптор стандартного потока ввода посылается CONTENT_LENGTH байт. Так же сервер передает шлюзу CONTENT_TYPE (тип передаваемых данных). Сервер не обязан посылать символ конца файла после отсылки CONTENT_LENGTH байт данных и после того, как шлюз их прочитает.

Пример:

Возьмем результат работы формы с методом POST (METHOD="POST") в качестве примера.

Пусть получено 7 байт, закодированных примерно так:

a=b&b=c.

В этом случае, сервер установит значение CONTENT_LENGTH равным 7 и CONTENT_TYPE в application/x-www-form-urlencoded. Первым символом в стандартном потоке ввода для шлюза будет a, за которым будет следовать остаток закодированной строки.

Аргументы командной строки
Шлюз в командной строке от сервера получает:

остаток URL после имени шлюза в качестве первого параметра (первый параметр будет пуст, если присутствовало только имя шлюза), и
список ключевых слов в качестве остатка командной строки для скрипта поиска, или
чередующиеся имена полей формы с добавленным знаком равенства (на четных позициях) и соответствующих значений переменных (на нечетных позициях).
Ключевые слова, имена полей формы и значения передаются раскодированными (из HTTP URL формата кодирования) и перекодированными в соответствии с правилами кодирования Bourne shell, так что шлюз в командной строке получит информацию в том виде, как она есть, без необходимости осуществлять дополнительные преобразования.

Запросы оператора FORM
Запросы оператора FORM обрабатываются таким образом, что каждый параметр, отвечающий за имя поля, оканчивается знаком равенства, а остаток представляет собой значение этого параметра. Если присутствует что либо после имени скрипта (шлюза), то эта информация передается в качестве первого параметра. Иначе первый параметр будет пуст.

Примеры:

/htbin/foo/x/y/z?name1=value1&name2=value2

вызывается как:

/.../foo /x/y/z name1= value1 name2= value2

а

/htbin/foo?name1=value1&name2=value2

вызывается как:

/.../foo '' name1= value1 name2= value2

CGI переменные окружения
Следующие переменные окружения не являются специфичными по типу запросов и устанавливаются для всех запросов.


SERVER_SOFTWARE
Название и версия информационного сервера, который отвечает на запрос (и запускает шлюз). Формат: имя/версия
SERVER_NAME
Имя хоста, на котором запущен сервер, DNS имя, или IP адрес в том виде, в котором он представлен в URL.
GATEWAY_INTERFACE
Версия CGI спецификации на тот момент, когда компилировался сервер. Формат: CGI/версия

Следующие переменные окружения являются специфичными для разных запросов, и заполняются перед вызовом шлюза:


SERVER_PROTOCOL
Имя и версия информационного протокола, в котором пришел запрос. Формат: протокол/версия
SERVER_PORT
Номер порта, на который был послан запрос
REQUEST_METHOD
Метод, который был использован для запроса. Для HTTP, это GET, HEAD, POST, и т.д.
PATH_INFO
Дополнительная информация о пути, которую передал клиент. Другими словами, доступ к шлюзу может быть осуществлен по виртуальному пути, за которым следует некоторая дополнительная информация. Эта информация передается в PATH_INFO.
PATH_TRANSLATED
Сервер передает преобразованную версию PATH_INFO, которая включает в себя путь, преобразованный из виртуального в физический.
SCRIPT_NAME
Виртуальный путь к шлюзу, который должен выполняться, используемый для получения URL.
QUERY_STRING
Информация, следующая за ? в URL, к которому относится данный шлюз. Это информация представляет собой строку запроса. Она не должна быть декодирована никоим образом. Вне зависимости от командной строки эта переменная всегда должна быть установлена при наличии такой информации.
REMOTE_HOST
Имя хоста, производящего запрос. Если сервер не имеет такой информации, он должен установить REMOTE_ADDR, а это поле оставить не установленным.
REMOTE_ADDR
IP адрес хоста, производящего запрос.
AUTH_TYPE
Если сервер поддерживает идентификацию пользователя, и шлюз является защищенным от постороннего доступа, этот специфичный для протокола метод идентификации используется для проверки пользователя.
REMOTE_USER
Используется в ситуациях, аналогичных предыдущему случаю, для хранения имени пользователя.
REMOTE_IDENT
Если HTTP сервер поддерживает идентификацию пользователя согласно RFC 931, то эта переменная будет содержать имя пользователя, полученное от сервера.
CONTENT_TYPE
Для запросов, которые содержат дополнительную добавочную информацию, такие как HTTP POST и PUT, здесь содержится тип данных этой информации.
CONTENT_LENGTH
Длина данных, которую передает клиент.

В дополнение к этим, если запрос содержит дополнительные поля заголовка запроса, они помещаются в переменные окружения с префиксом HTTP_, за которым следует имя заголовка. Любые символы '-' в заголовке меняются на символы подчеркивания '_'. Сервер может исключить любые заголовки, которые он уже обработал, такие как Authorization, Content-type, и Content-length. Если необходимо, сервер может исключить любые (или вообще все) дополнительные поля заголовка в случае, когда их включение может привести к превышению предела размера переменных окружения.

Примером такой переменной может служить переменная HTTP_ACCEPT, которая была определена в спецификации CGI/1.0. Другим примером может служить заголовок User-Agent.


HTTP_ACCEPT
Список MIME типов, которые клиент может обработать, как задано в HTTP заголовках. Другие протоколы должны получить эту информацию из других мест (если она им необходима). Каждый тип в этом списке должен быть отделен запятой согласно HTTP спецификации. Формат: тип/подтип, тип/подтип
HTTP_USER_AGENT
Просмотрщик, который использует клиент для посылки запроса. Общий формат: программа/версия библиотека/версия.
Вывод информации шлюзом
Основные концепции

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

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

Заголовок выходного потока

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

Заголовки с синтаксическим разбором

Вывод шлюза начинается с маленького заголовка. Он содержит текстовые строки, в том же формате, как и в HTTP заголовке и завершается пустой строкой (содержащей только символ перевода строки или CR/LF).

Любые строки заголовка, не являющиеся директивами сервера, посылаются непосредственно клиенту. В настоящий момент, CGI спецификация определяет три директивы сервера:


Content-type
MIME тип возвращаемого документа.
Location
Это поле используется в случае, когда необходимо указать серверу, что возвращается не сам документ, а ссылка на него.

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


Status
Эта директива используется для задания серверу HTTP/1.0 строки-статус, которая будет послана клиенту. Формат: nnn xxxxx, где nnn - 3-х цифровой статус-код, и xxxxx строка причины, такая, как "Forbidden" (Запрещено).

Примеры

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

--- начало вывода ---

Content-type: text/html

--- конец вывода ---

Теперь рассмотрим шлюз, который, в некоторых случаях, должен выдать документ /path/doc.txt с данного сервера, как если бы он был непосредственно востребован клиентом через http://server:port/path/doc.txt

В этом случае вывод шлюза будет таков:

--- начало вывода ---

Location: /path/doc.txt

--- конец вывода ---

Наконец, предположим, что шлюз возвращает ссылки на gopher сервер, например на gopher://gopher.ncsa.uiuc.edu/

Вывод шлюза будет следующий:

--- начало вывода ---

Location: gopher://gopher.ncsa.uiuc.edu/

--- конец вывода ---

Non-parsed headers
Допустим теперь, что у нас имеется шлюз, который общается с клиентом непосредственно. Как уже отмечалось, его имя должно начинаться с префикса nph- и он должен возвращать допустимый HTTP заголовок. В этом случае, если доступ к шлюзу был осуществлен со значением SERVER_PROTOCOL равным HTTP/1.0, его вывод должен удовлетворять HTTP/1.0:

--- начало вывода ---

HTTP/1.0 200 OK

Server: NCSA/1.0a6

Content-type: text/plain

--- конец вывода ---

Оффлайн FussesDemon

  • GODMODE
  • *******
  • Сообщений: 407
  • Авторитет +61/-12
    • Просмотр профиля
Справка
« Ответ #2 : 25 Августа 2006, 10:04:18 »
Perl
Введение
Широкое распространение в качестве языка для CGI-приложений получил Perl. Его синтаксис унаследован в первую очередь от С, в него добавлены расширенные средства для работы со строками, регулярными выражениями, ассоциативными массивами и т. д. Это интерпретируемый язык, изначально созданный для Unix-систем, сейчас его интерпретаторы доступны для большинства популярных архитектур, что делает особенно легким перенос приложений. Было бы неверно говорить о Perl, как исключительно о средстве разработки CGI. Встроенные в язык возможности, великолепная переносимость, огромное количество существующих бибилиотек, доступных из Comprehensive Perl Archive Network (CPAN, http://www.perl.com/CPAN/), делают его исключительно удобным средством для системного администрирования, сетевогопрограммирования, обработки текстов и т.п.

Основы языка: скаляры, массивы, хэши, ссылки
Perl-программа представляет собой файл, содержащий набор Perl-операторов, и начинающийся со строчки вида #!/usr/bin/perl, указывающей путь до интерпретатора Perl. Это справедливо для Unix-систем, требующих, кроме того, установки бита исполнения в атрибутах данного файла, для windows-реализаций подобная строчка необязательна, но желательна из соображений переносимости (Apache/Win32, к примеру, не сможет запустить CGI-скрипт с некорректным путем до интерпретатора).

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

print "Hello, World\n";print ("Hello, World\n");Комментарием служит символ #, его действие распространяется до конца строки. Многострочных комментариев нет. Скалярные величины в Perl бывают двух типов- числового и строкового.Для всех чисел используется одно и то же внутреннее представление -- число с плавающей точкой двойной точности (то, чтокомпилятор С, которым компилировался Perl, понимал под double). Строки представляют собой последовательности символов, но не является массивом байтов и не ограничивается каким-то специальным символом типа нулевого, как это происходит в С. По мере необходимости существляется преобразование из одного типа в другой -- в зависимости от контекста строка может превратиться в число и наоборот:

print "2"*2; # выводит 4
Имя скалярной переменной всегда начинается с символа $:

$a = 1;
Скалярная величина может быть определенной и неопределенной, в последнем случае ее значение равно undef. В строковом контексте значение undef интерпретируется как пустая строка "", для проверки определенности переменной следует пользоваться функцией defined. При использовании в логических операциях ложными считаются число 0 и строки "" и "0".

Строки могут записываться с использованием одинарных и двойных кавычек.

При использовании одинарных кавычек их содержимое используется как есть:

print '12\n$a'; # печатает строку 12\n$a
При использовании двойных кавычек происходит так называемая интерполяция переменных и спецсимволов:

print "12\n$a";
# печатает 12, делает перевод строки, печатает значение переменной $a
Если в такой строке необходимо предотвратить подстановку значения вместо имени переменной, то перед знаком доллара необходимо поставить обратную косую черту: "\$a".

Операции над числовыми значениями ничем не отличаются от знакомых по С (за исключением возведения в степень **, операций not, and, or, дублирующих операции !, &&, ||, но имеющих меньший приоритет, чем операции присваивания, и операции xor, означающей логическое исключающее ИЛИ).

Для строковых переменных определены операция конкатенации "." (точка), операция повторения "x", операции ne (неравенство строк), eq (равенство), lt (строковое "больше чем") и gt (строковое "меньше чем"). Также определена операция сравнения двух строк cmp, возвращающая --1, 0 или 1, бъединяющая проверки равенства и сравнения, и аналогичная ей операция для чисел <=>.

Встроенная функция chop удаляет последней символ строки, встроенная функция chomp удаляет последний символ, если он является символом разделителя входных записей (значение по умолчанию -- символ новой строки \n, которое может быть заменено присваиванием нового значения встроенной переменной $\).

Поиск подстроки осуществляется функцией index($строка, $подстрока, $старт), возвращающей индекс первого вхождения подстроки в строку, большего чем $старт (третий параметр можно опустить) и функцией rindex, делающей то же самое, но просматривающей строку справа налево. Извлекается подстрока из строки функцией substr ($строка, $начало, $длина). При отсутствии третьего параметра будут извлечены все символы до конца строки. Эта функция может стоять в левой части оператора присваивания, позволяя тем самым изменять часть строки на лету.

Массивы в Perl могут хранить любое количество элементов и увеличиваются по мере необходимости. Имена массивов начинаются с символа @: @a, доступ к отдельному элементу массива записывается в виде $a[10] (нумерация элементов массива начинается с 0, причем последний элемент массива имеет индекс --1, предпоследний --2 и т.д.).

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

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

@a = (0, $a, 5, "123", @b);
При этом вставленные таким образом элементы массива @b находятся на том же уровне иерархии, что и другие элементы списка, т.е. просто дописываются в конец массива @a. Присваивание списков позволяет осуществлять довольно любопытные операции:

($a, $b, $c, @e) = ($b, $a, @g);
$a и $b обменяются значениями, $c будет присвоено значение первого элемента массива @g, остальные элементы будут скопированы в массив @e.

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

@a[0, 1, 10];
Эту же операцию можно применить к списку:

($a, $b, $c, $d)[0, 1];
Эта техника используется, к примеру, для получения информации о времени: функция localtime преобразует результат, возвращаемый функцией time (время в секундах от 1.01.1970), в зависимости от контекста, либо в строку вида "Fri Sep 15 11:12:13 2000", либо в массив из девяти элементов (секунды, минуты, часы, день, месяц, год, день недели, день года, признак летнего времени):

($day, $month, $year) = (localtime(time))[3, 4, 5];
Следует отметить, что месяцы, дни года и дни недели начинаются с нуля, причем нулевым днем недели считается воскресенье, а годы считаются от 1900 года. Таким образом, 2000 году соответствует значение 100 (из-за того, что многие программисты забыли этот факт, в начале 2000 года на разных страницах сети можно было наблюдать дату вида 1.01.100 или 1.01.19100). При записи списков вместо операции "," можно воспользоваться => : запись ("one", 1, "two", 2, "three", 3) эквивалентна (one => 1, two =>2, three => 3), что может сделать список более наглядным.

Для работы с массивом как со стеком используются функция push, добавляющая элементы (один или несколько) в конец массива, и функция pop, удаляющая последний элемент. Для работы с началом массива используются аналогичные функции unshift и shift. По умолчанию все эти функции работают с встроенным массивом @_. Функция reverse меняет порядок следования элементов списка-аргумента на обратный и возвращает результат. Функция sort по умолчанию сортирует аргументы по возрастанию, рассматривая их как строковые переменные. Помимо простых массивов, в Perl существуют ассоциативные массивы, или хэши. Их отличие от простых массивов в том, что индексами являются не последовательные целые числа, а произвольные скалярные величины. Инициализируются хэши списком, четные элементы которого (начиная с нуля), являются индексом, четные -- значением, и начинаются с символа %:

%a = (one => 1, two =>2, three => 3);
Доступ к элементу хэша записывается как $a{1} (в нашем примере вернет "one"). Функция key возвращает список ключей переданного ей хэша, функция values -- список значений. Функция each последовательно проходит по хэшу, возвращая пару ключ-значение в виде списка из двух элементов. Удалить элемент хэша можно функцией delete:

delete $a{1};
Представить себе современный язык программирования, не имеющий ссылочных типов данных, невозможно. Не обделен ими и Perl. Здесь можно получить ссылку на любой из встроенных типов, и присвоить ее некоторой скалярной переменной:

$ref1 = \$var;
$ref2 = \@array;
$ref3 = \%hash;
Для доступа к скалярным переменным, на которых ссылается ссылка, можно воспользоваться следующими конструкциями:

$$ref1;
${$ref1};

$ref2->[12];
${$ref2}[12];
$$ref2[12];

$ref3->{$key};
${$ref3}{$key};
$$ref3{$key};
Как правило, предпочитают использовать конструкции с оператором ->, делающие код более читабельным. Можно также создать ссылку на анонимный массив или хэш:

$aref = [1, 2, 3];
$href = {1 => One, 2 => Two, 3 => Three};
С помощью ссылок можно формировать довольно сложные структуры данных (например, массив ссылок на хэши).

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

if($a>$max) {$max = $a}
Общая форма оператора if:
if(условие 1)
{...}
elsif(условие 2)
{...}
elsif(условие 3)
{...}
...
else
{...}
Вместо конструкции if(!условие) можно использовать unless(условие), а для упрощения записи вместо конструкции if(условие){оператор} можно использовать оператор if условие.

В качестве управляющих структур часто используются операции && и ||: Запись if(выражение){оператор} эквивалентна записи выражение && оператор, а запись unless (выражение){оператор} -- записи выражение || оператор. Выбор той или иной формы полностью зависит от настроения программиста.

Операторы цикла также чуть более разнообразны, чем в С: вместо while(!условие){} можно записать until(условие){}, аналогично и для цикла с пост-условием. Для сокращения записи также используется конструкция оператор while выражение.

Помимо оператора for, ничем не отличающегося от С, существует оператор foreach, который записывается как

foreach $i(@список)
{}
В этом случае скалярная переменная $i последовательно принимает значения элементов списка. Например, перебрать все элементы хэша, отсортированные по ключам, можно так:

foreach $i(sort keys %a)
{
print $a{$i}."\n";
}
При проходе по большому хэшу эффективнее использовать функцию each -- ценой потери сортировки:

while(($key, $value) = each(%a))
{
}
Для всех операторов цикла, кроме цикла с пост-условием, существуют операторы last, прерывающий выполнение цикла, next, переходящий к следующей итерации, и redo, обеспечивающий переход в начало текущего блока без проверки условия. Их можно использовать в сочетании с метками:

OUTER: while(условие 1)
{
INNER: while(условие 2)
{
if(условие 3)
{
next OUTER; #переход на следующую итерацию внешнего цикла
}
}
}
Функции записываются следующим образом:

sub f
{
}
и вызываются как f();

Значение из функции возвращается оператором return, при отсутствии его возвращаемым значением является результат последней выражения, вычисленного в функции. При передаче параметров в функцию они заносятся во встроенную переменную @_, доступ к элементам которой можно получить как к элементам обычного массива: $_[0] и т.п., а также через функции shift, pop и т.п. Таким образом, функции могут иметь переменное количество параметров.

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

sub f
{
$a++;
}
$a = 1;
f();
print $a; # напечатает 2
Для того, чтобы сделать переменную локальной, надо объявить ее с помощью оператора my:

sub f
{
my $a;
$a++;
}
$a = 1;
f();
print $a; # напечатает 1
Распространенным приемом является инициализация параметров функции, имеющих осмысленные имена:

my($param1, $param2) = @_;
При наличии директивы use strict объявление переменных с помощью операции my является обязательным. Кроме директивы my существует похожая на нее директива local. Разница между ними следующая: my ограничивает область действия переменной текущим блоком, local же делает эту переменную доступной и во всех функциях, которые вызываются из текущего блока. Теперь, научившись работать с функциями, мы можем использовать сортировку с произвольным критерием.

sub by_num
{
return $a <=> $b;
}
foreach $i(sort by_num keys %a)
{
print $a{$i}."\n";
}
Функция by_num определяет критерий сортировки, а переменные $a и $b, передаваемые в нее, являются встроенными и локальными для нее переменными. То же самое можно записать еще короче, используя анонимную функцию:

foreach $i(sort {$a <=> $b} keys %a)
{
print $a{$i}."\n";
}
Можно создать ссылку на функцию:

sub func{...}
$fref1 = \&func;
$fref2 = sub {...}; # Ссылка на анонимную функцию
Используется эта ссылка как $fref1->(список аргументов).

Ввод-вывод

Оффлайн FussesDemon

  • GODMODE
  • *******
  • Сообщений: 407
  • Авторитет +61/-12
    • Просмотр профиля
Справка
« Ответ #3 : 25 Августа 2006, 10:07:03 »
Perl
Введение
Ввод-вывод
Ввод с консоли осуществляется с помощью оператора :

$a = ; # считывает следующую строку до символа
              #перевода строки
              # (точнее, до значения, присвоенного переменной $/)
              # либо undef, если строк больше нет

@a = ; # считывает все строки до завершения ввода (обычно --
              # нажатие Ctrl-Z); каждая строчка будет завершаться
              # символом перевода строки

while() {...} #последовательно считывает строки в
                           #встроенную переменную $_.
Вывод на консоль осуществляется с помощью функции print, форматированный вывод -- с помощью printf, полностью аналогичной соответствующей функции С. Если у print не указан параметр, выводится содержимое встроенной переменной $_.

Для ввода из файлов, перечисленных в командной строке скрипта, используется операция <>:

while(<>){...}
Если в качестве параметров передано несколько имен файлов, операция <> считает их всех последовательно. Для файлового ввода-вывода сначала необходимо связать с файлом дескриптор. Стандартные дескрипторы STDIN, STDOUT, STDERR уже связаны со стандартным вводом, стандартным выводом и стандартным выводом ошибок, кроме того, существует специальный дескриптор DATA, позволяющий считать текст, следующий после символов __END__ из файла, в котором находится сама программа.

Для открытия дополнительных дескрипторов используется функция open:

open(FILE1, "filename"); # открывает файл для чтения
open(FILE2 ">filename"); # открывает файл для записи
open(FILE3, ">>filename"); # открывает файл для добавления
При неудачном открытии файла функция open возвращает значение "ложь", так что правилом хорошего тона является проверка этого значения:

open (FILE, "filename") || die "cannot open file: $!";
Функция die вызывает аварийное завершение программы, переменная $! содержит строку с описанием последней ошибки.

После завершения работы файл необходимо закрыть:

close (FILE);
Имена дескрипторов не начинаются с каких-то специальных символов, и общепринято вводить их заглавными буквами -- просто, чтобы отличить от обычных переменных. Далее их можно использовать в сочетании с операцией <> для ввода:

@a = ; # Cкладывает все строчки файла в массив строк. Может
             # оказаться не самым лучшим решением, если файл имеет
             # большой размер
Для вывода в открытый файл его дескриптор записывается сразу после ключевого слова print. Запятой между дескриптором и другими аргументами быть не должно:

print FILE "some text\n";
Для проверки существования файла используется операция "-e":

if(-e $filename){...}.
Существуют также операции для проверки, доступен ли этот файл для чтения (-r), доступен ли для записи (-w), является ли он каталогом (-d) или обычным файлом (-f) и т.д.

Весьма удобной является встроенная в Perl поддержка DBM-файлом, позволяющая связать ассоциативный массив с DBM-базой. Родная для Unix-систем библиотека DBM предоставляет в распоряжение программиста простую и удобную базу данных. Существуют различные реализации DBM, различающиеся возможным размером записи, базы, скоростью работы и т.п. В простейшем варианте связь хэша с DBM-файлом осуществляется функцией dbmopen, а закрывается DBM-файл функцией dbmclose:

dbmopen(%A, "basename", 0644)
dbmclose(%A);
Третий параметр функции dbmopen указывает, с какими правами доступа создавать файл, если его не существует. Если нет необходимости создавать файл, вместо этого параметра можно передать undef.

Для более полной информации воспользуйтесь командой perldoc AnyDBM_File.

Регулярные выражения
Регулярные выражения хорошо знакомы опытным пользователям Unix, они используются для обработки текста во многих Unix-утилитах, таких как grep, awk, sed, в редакторах (vi, emacs), в некоторых командных оболочках и т. д. Регулярное выражение представляет собой образец, или шаблон, который сопоставляется со строкой. Это сопоставление, или поиск по шаблону, может закончиться успехом, или неудачей. Кроме того, совпадающий образец может быть заменен другой строкой или скопирован во внешнюю переменную. По умолчанию регулярные выражения используют встроенную переменную $_, но можно сопоставить с шаблоном любую другую скалярную переменную с помощью операторов =~ и !~:

/текст/;       # возвращает истину, если в $_ содержится
               # подстрока "текст"
$s =~ /текст/; # возвращает истину, если в $s содержится
               # подстрока "текст"
$s !~ /текст/; # возвращает истину, если в $s нет подстроки "текст"
Для замены подстроки, соответствующей шаблону, используется запись вида

s/текст1/текст2/;
Возможно использование модификаторов, например:

/текст/i;     # игнорировать регистр
s/$s/текст/g; # производить глобальную замену
В приведенных примерах мы использовали простейший образец, состоящий из последовательности обычных символов. Однако возможны и более сложные комбинации. Самый простой символ сопоставления -- точка ("."). Она соответствует любому одиночному символу, кроме символа новой строки. Можно задать класс символов сопоставления с помощью списка, заключенного в квадратные скобки:

/[абвгде]/;
Этому образцу соответствует строка, содержащая один из этих шести символов. Диапазон символов задается с помощью дефиса (сам дефис вставляет в список как \-), символ "^", стоящий сразу за открывающей скобкой, означает отрицание -- такому классу символов соответствует любой символ, отсутствующий в этом списке. Некоторые распространенные классы символов имеют предопределенные обозначения:

\d [0-9] цифра
\w [a-zA-Z0-9_] обычный символ
\s [ \r\t\n\f] пробельный символ
\D [^0-9] нецифровой символ
\W [^a-zA-Z0-9_] специальный символ
\S [^ \r\t\n\f] непробельный символ
Однако самое интересное начинается при работе с образцами для групп символов, или множителями. Два основных образца здесь -- звездочка "*" и плюс "+". Звездочке соответствует ни одного или более экземпляров стоящего перед ней символа или класса символов, плюсу -- один или более экземпляров. Образцу "?" соответствует ни одного или один символ, стоящий перед ним в шаблоне, наконец, с помощью фигурных скобок можно задать точное количество повторений этого символа, или диапазон.

/ab*/; # строки, содержащие а, ab, abb, abbb и т.д.
/ab+/; # ab, abb, abbb и т.д.
/ab?/; # а, ab
/ab{2}/; # abb
/ab{2,4}/; # abb, abbb, abbbb
/ab{2,}/; # abb, abbb, abbbb и т.д.
Поиск по шаблону с множителями характеризуется тремя особенностями: "жадностью", "торопливостью" и возвратом. "Жадность" означает, что если шаблон может совпасть со строкой в нескольких вариантах, то выбирается самый длинный:

$s = 'abbbbb';
$s =~ s/a.*b/c/; #результирующая строка будет содержать только "с".
Любой  множитель  можно  превратить из "жадного" в "ленивый",  поставив
сразу после него вопросительный знак:
$s = 'abbbbb';
$s =~ s/a.*?b/c/; #результирующая строка содержит "cbbbb".
"Торопливость" означает, что механизм поиска стремится обнаружить совпадение как можно скорее -- так, шаблону /a*/ будет соответствовать любая строка, поскольку * -- это 0 или более символов.

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

Если части шаблона заключены в круглые скобки, то включается механизм запоминания, и части строки, которые им соответствуют, будут последовательно присваиваться переменным $1, $2, $3 и т.п.:

$s = 'abbbbb';
$s =~ s/a(.*)b/c/; # в $1 будет находиться строка "bbbb"
Другой способ запоминания части строки -- использование кодов \1, \2 и т.п. непосредственно в шаблоне:

$s = 'abbbbb';
$s =~ s/a(.*)b/\1c/; # результирующая строка содержит "bbbbc"
Возможно использование одного из нескольких шаблонов:

/текст1|текст2|текст3/
а также их комбинация с помощью скобок:

/(a|b)c/;
Чтобы не включать здесь режим запоминания, используют запись

/(?:a|b)c/;
Образец может быть зафиксирован относительно позиции в строке: /^a.*b$/ соответствует строке, начинающейся с a и заканчивающейся b, а директива \b требует, чтобы совпадение с образцом происходила только на границе слова. Если в образце участвует переменная, то перед сопоставлением происходит ее интерполяция, таким образом, можно строить регулярное выражение на основании строки введенной пользователем. Чуть позже в этой главе будет показана опасность этого подхода, пока же отметим, что для отмены интерполяции используется управляющая последовательность \Q...\E, предваряющая все спецсимволы в строке обратной косой чертой и превращающая их тем самым в простые символы:

/\Q$var\E/
Директива tr позволяет заменить все вхождения символов из списка в строке на другие:

$s =~ tr/abcde/ABCDE/;
Параметр /e заставляет рассматривать заменяющую строку директивы s как Perl-выражение:

$s =~ s/(.)/sprintf("[%s]", $1)/eg;
(бесполезный пример, расставляющий квадратные скобки вокруг каждого символа строки и демонстрирующий работу функции форматного вывода в строку sprintf).

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

$s = 'abc:def:ghi';
@a = split(/:/, $s); # массив @a будет содержать три элемента -- "abc",
"def", "ghi".
Если не указан  второй параметр,  работа идет  с переменной $_. Если не
указан и первый параметр, используется образец /\s+/.
Обратная функция  -- join  -- берет список  значений  и  склеивает  их,
вставляя между ними строку-связку, переданную ей в первом параметре:
$s = join(":", @a);
Регулярные выражения являются, пожалуй, самым мощным средством Perl, предназначенным для обработки текстов, и в нашем кратком изложении мы далеко не исчерпали все их возможности.


Оффлайн FussesDemon

  • GODMODE
  • *******
  • Сообщений: 407
  • Авторитет +61/-12
    • Просмотр профиля
Справка
« Ответ #4 : 25 Августа 2006, 10:07:52 »
Perl
Введение
Пакеты, библиотеки, модули, классы и объекты
Пакеты предназначены для разделения глобального пространства имен. По умолчанию все программы выполняются в пакете main, пока директива package не выбирает другой пакет. Для доступа к именам, описанным в другом пакете, используется синтаксис

$ИмяПакета::ИмяПеременной.
Модули представляют собой отдельные файлы, содержащие набор взаимосвязанных функций. Каждый модуль имеет внешний интерфейс и, как правило, описывает свои глобальные переменные и функции в отдельном пакете. К основной программе модули подключаются с помощью директив use и require. Директива use подключает модуль на этапе компиляции программы (хотя Perl формально и является интерпретируемым языком, непосредственно перед исполнением происходит компиляция исходных текстов программы), директива require загружает модуль во время выполнения.

Формально в Perl нет средств для создания составных типов данных наподобие структур или классов в С++, но имеющихся в нем средств вполне достаточно для их довольно близкой имитации.

Обычные структуры имитируются в Perl с помощью анонимных хэшей:

$record = {
NAME => 'record1',
FIELD1 => 'value1',
FIELD2 => 'value2',
FIELD3 => 'value3',
};
print $record->{FIELD1};
$records{$record->{NAME}} = $record;
$records{"record1"}->{FIELD1} = 1;
Классы в Perl представляют собой пакеты, а объекты -- нечто (обычно все та же ссылка на анонимный хэш), приведенное с помощью функции bless к классу.

Внутри пакета обычно существует функция-конструктор, которая выполняет всю эту работу. Типичный конструктор выглядит как

sub new
{
my $class = shift; # получаем имя класса
my $self = {}; # выделяем новый хэш для объекта
bless($self, $class); # приводим хэш к классу
$self->{FIELD1} = "value1";# инициализируем поля объекта
$self->{FIELD2} = "value2";
return $self;
}
Если данный конструктор описан в пакете Class, то использовать его можно как

use Class;
$object1 = Class::new("Class");
$object2 = Class->new();
$object3 = new Class;
Все три записи эквивалентны.

В дальнейшем при вызове функций, описанных в пакете Class, через объекты, возвращенные конструктором, в первом параметре им будет передаваться ссылка на данные экземпляра:

sub f
{
my $self = shift;
$self->{FIELD1} = shift;
}
Фактически, Perl-программисту приходится вручную делать все то, что С++ от него скрывает за изящным синтаксисом.

Основные библиотеки, используемые в web-программировании
Одни и те же задачи web-программирования могут решаться на Perl различными способами, выбор подходящего для конкретного приложения -- в значительной степени дело вкуса. Главный лозунг Perl -- "Всегда есть больше одного решения" (There's more than one way to do it, TMTOWTDI). В приложении к материалу текущего раздела, одну и ту же работу вы можете сделать самостоятельно, вручную разбирая строки или отсылая пакеты, а можете доверить ее стандартным библиотекам, которые, впрочем, тоже можно использовать по-разному. Профессиональная черта программистов -- лень -- как правило, толкает нас по второму пути, но добросовестность и любопытство принуждают посмотреть, как же это все устроено внутри.

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

param1=value1¶m2=value2...¶mN=valueN
которая попадает в серверное приложение либо через переменную окружения QUERY_STRING, либо через стандартный ввод, в последнем случае переменная окружения CONTENT_LENGTH содержит ее размер. Метод, которым передавались данный, задается переменной окружения REQUEST_METHOD.

Доступ к переменным окружения в Perl осуществляется через ассоциативный массив %ENV, для чтения строки заданного размера из входного потока предпочтительней воспользоваться функцией read. Вся процедура получения входной строки выглядит так (в реальной программе стоило бы добавить ограничение на длину входной строки):

if($ENV{"REQUEST_METHOD"} eq 'POST')
{
read(STDIN, $query, $ENV{'CONTENT_LENGTH'});
}
else
{
$query = $ENV{'QUERY_STRING'};
}
Далее нам понадобится разбить входную строку на составляющие:

@params = split(/&/, $query);
Теперь @params содержит список строки вида param1=value1. Далее нам придется выделить из них имена и значения, не забывая о необходимости декодирования нестандартных символов:

foreach $p(@params)
{
($name, $value) = split(/=/, $);
$value =~ tr/+/ /;
$value =~ s/%([a-fA-F0-9][a-fA-F0-9])/pack("C", hex($1))/eg;
$in{$name} = $value;
}
Впервые встретившаяся нам функция hex занимается преобразованием "шестнадцатеричная строка->число", функция pack -- преобразует полученное значение в бинарную форму, осуществляя в нашем случае преобразование "код символа->символ".

По завершении цикла все параметры формы оказываются размещенными в ассоциативном массиве %in, и их значения можно получить как $in{'param1'}. Далее следует содержательная часть нашей программы, обработка входных параметров, выборка данных из баз и т.п. Наконец, обработанную информацию необходимо вернуть пользователю. В первую очередь необходимо сообщить клиенту, как именно он должен рассматривать передаваемую далее информацию. Как мы помним, это осуществляется с помощью HTTP-заголовков. Как правило, используется два способа -- перенаправление клиента на новый адрес, или формирование виртуального документа. В первом случае все,что от нас требуется -- вывести на стандартный вывод заголовок Location:

print "Location: http://... /text.html\n\n";
Во втором случае мы сообщаем клиенту, что вся последующая информация должна рассматриваться, к примеру, как html-файл:

print "Content-type: text/html\n\n";
print   'Results: ...';
Через HTTP-заголовки передается масса вспомогательной информации -- версия сервера, информация о клиенте, cookie, способ авторизации и т.п.

Как видите, ничего сложного в получении и передаче информации CGI-приложением нет, но действия при этом выполняются типовые, и возникает естественное желание написать их раз и навсегда и поместить в библиотеку. Мы не первые, у кого возникло такое желание, так что теперь вместо переноса из скрипта в скрипт типового кода можно воспользоваться стандартным (начиная с версии Perl 5.004) модулем CGI.pm:

use CGI;
$Query = new CGI;
$val1 = $Query->param('param1'); # получаем значение параметра
$cookie1 = $Query->cookie('cookie1'); # получаем значение cookie

# Подготавливаем новый cookie:
$newcookie = $Query->cookie(
-name=>'new', # имя
-value=>'value', # значение
-expires=>"+1y", # прекращает действие через год
-domain=>' .mydomain.ru' # определен для некоторого домена
);
Формируем и выводим HTTP-заголовки:

print $Query->header(
-type=>'text/html',
-cookie=>$newcookie,
-Pragma=>"no-cache"
# ...
);
Также CGI.pm содержит функции для формирования html-кода, сохранения результатов запроса в файле и т.п. Дополнительную информацию о модуле можно получить с помощью команды perldoc CGI.

Клиентские приложения
Написание клиентских web-приложений на Perl строится по обратной схеме -- формируем строку параметров и HTTP-заголовки, соединяемся с сервером, передаем ему запрос и ожидаем ответ. Как обычно, проделать это можно несколькими способами.

1. Рецепт для любителей ручной работы. Используем низкоуровневые функции для работы с сокетами, являющиеся минимальными обертками вокруг соответствующих функций на С.

use Socket;

# подготавливаем строчку с параметрами формы
$forminfo = 'param1=val1¶m2=val2';

# подготавливаем и осуществляем соединение:

# выбираем работу через TCP
$proto = getprotobyname('tcp');

# открываем потоковый сокет
socket(Socket_Handle, PF_INET, SOCK_STREAM, $proto);

# подготавливаем информацию о сервере
$port = 80;
$host = " .somehost.com";
$sin = sockaddr_in($port,inet_aton($host));

# соединяемся с сервером
connect(Socket_Handle,$sin) || die ("Cannot connect");

# передаем серверу команды, используя дескриптор сокета
# собственно команда GET
send Socket_Handle,"GET /cgi-bin/env.cgi?$forminfo HTTP/1.0\n",0;

# HTTP-заголовки
send Socket_Handle,"User-Agent: my agent\n",0;
send Socket_Handle,"SomeHeader: my header\n",0;
send Socket_Handle,"\n",0;

# начинаем чтение из дескриптора сокета аналогично
# тому, как читали из файла.
while ()
{
print $_;
}
close (Socket_Handle);
При использовании нестандартных символов в параметрах формы их следует преобразовать в вид %XX, где XX -- их шестнадцатеричное представление. Кодирование выполняется следующим кодом:

$value=~s/([^a-zA-Z0-9_\-.])/uc sprintf("%%%02x",ord($1))/eg;
2. Чуть меньше ручной работы -- использование модуля IO::Socket. Рассмотрим его на примере метода POST:

use IO::Socket;
$forminfo = 'param1=val1¶m2=val2';
$host = " .somehost.com";
$socket = IO::Socket::INET->new(Proto => "tcp",
PeerAddr => $host,
PeerPort => "http(80)")
or die ("Cannot connect");
$socket->autoflush(1);
$length = length($forminfo)+1;
$submit = "POST $path HTTP/1.1\n".
"Content-type: application/x-www-form-urlencoded\n".
"Content-length: $length\n".
"Host: $host\n\n"
"$forminfo\n";
print $socket $submit;
while(<$socket>)
{
print;
}
close $remote;
3. Наконец, наиболее комфортный для программиста вариант -- использование комплекса модулей libwww-perl, или LWP. LWP, как правило, входит во все последние дистрибутивы Perl, кроме того, последняя версия всегда доступна на CPAN и на .linpro.no/lwp/.

Основные модули, используемые при работе с LWP (для получения дополнительной инфомрации о каждом модуле воспользуйтесь командой perldoc <имя модуля>):

LWP::UserAgent
LWP::Simple
HTTP::Request
HTTP::Response
HTTP::Headers
HTTP::Cookies
LWP::Simple предназначен для простейших операций наподобие получения информации о документе или получении документа методом GET:

use LWP::Simple;
$content = get('http:// .....text.html');
LWP::UserAgent -- основной модуль для более тонкой работы с web. Его назначение -- создание виртуального броузера, выполняющего всю работу по взаимодействию с сервером:

# создание
$UserAgent = new LWP::UserAgent;
# задание строки с именем "броузера"
$UserAgent->agent("MoZilla 9.0 (non-compatible; MSIE 9.3; PalmOS)");
# работа через прокси
$UserAgent->proxy('http', $proxy);
HTTP::Request отвечает за формирование запроса серверу, HTTP::Headers -- за формирование заголовков запроса:

# формируем заголовки
$Headers = new HTTP::Headers(Referer => $referer);
# формируем запрос
$Request = new HTTP::Request(POST => $url, $Headers);
# говорим, что передаваться будут данные формы
$Request->content_type('application/x-www-form-urlencoded');
# передаем данные
$Request ->content($forminfo);
Взаимодействие с сервером осуществляется функцией request, возвращающей объект HTTP::Response:

$Response = $UserAgent->request($Request);
if($Response->is_success) # успешно выполненный запрос
{
# получаем информацию, возвращенную сервером
$text = $Response->content;
}
Для работы с cookie используется модуль HTTP::Cookie и функция cookie_jar, сообщающая нашему виртуальному броузеру о необходимости использовать объект Cookie:

my $СookieJar = new HTTP::Cookies;
$UserAgent->cookie_jar($CookieJar);
Для сохранения и загрузки cookie используются функции

$CookieJar->load($cookiefilename);
$CookieJar->save($cookiefilename);
Можно формировать их значения и вручную с помощью функции set_cookie.

Для доступа к ресурсам, защищенным средствами сервера, используется HTTP-заголовок Authorization. Его значение должно содержать тип авторизации (обычно BASIC) и строку вида "имя_пользователя:пароль", в случае basic-авторизации закодированную base64. Для кодирования можно воспользоваться модулем MIME::Base64:

use MIME::Base64;
$authorization = MIME::Base64::encode_base64("$name:$password");
$Request->header(Authorization => "BASIC $authorization");
Работа с базами данных
Для работы с базами данных в Perl используется стандартный интерфейс программирования DBI, обеспечивающий доступ к большинству существующих СУБД с помощью подключаемых драйверов. Схемы подключения к различным СУБД (точнее, правила формирования имени источника данных) могут незначительно различаться, мы рассмотрим работу с использованием mySQL.

В первую очередь необходимо подключить модуль DBI:

use DBI;
Далее подключаемся к базе данных:

my    $dbh   =    DBI->connect('DBI:mysql:hostname:base:port',   'user,
'password, { RaiseError => 1, AutoCommit => 1});
Здесь $dbh -- дескриптор базы данных, используемый в дальнейшей работе, DBI:mysql:hostname:base:port -- имя источника данных, включающее имя драйвера, имя хоста, базы, к которой мы подключаемся, и номер порта, на который настроен sql-сервер, user/password -- имя и пароль пользователя, имеющего доступ к базе, в последнем параметре передаются различные флаги.

По завершении работы желательно закрыть дескриптор:

$dbh->disconnect();
Возможно использование двух способов работы с базой. В случае, если нам нужно только передать информацию в базу, используется метод do, параметром которого является строка SQL-запроса:

$dbh->do("insert into mytable values (1,1)");
Если же необходимо получить информацию из базы, используется следующая процедура:

1. Получаем дескриптор команды с помощью метода prepare:

my $sth = $dbh->prepare ("select * from mytable where field1>1");
2. Выполняем команду:

$sth->execute();
3. Получаем данные. Используется один из четырех методов:

fetchrow_array
fetchrow_hash
fetchrow_arrayref
fetchrow_hashref
Методы возвращают соответственно массив, хэш, ссылку на массив, ссылку на хэш, в которых хранятся значения полей текущей записи. Для выборки всех записей используется цикл, после выборки всех записей функции возвращают пустой список, воспринимаемый как значение false:

while(my $hash_ref = $sth->fetchrow_hashref)
{
foreach my $fieldname(keys %$hash_ref)
{
print "$fieldname: $hash_ref->{$fieldname }\n";
}
print "\n";
}
4. Освобождаем ресурсы:

$sth->finish();
При передаче текстовой информации в базу рекомендуется предварительно обработать ее методом $dbh->quote(), расставляющим кавычки и управляющие символы в строке в соответствии с правилами используемой СУБД. Кроме того, возможно использование привязки параметров в виде:

$sth = $dbh->prepare("select * from mytable where field1=?");
$sth->bind_param(1, "значение параметра");
$sth->execute();
либо
$sth = $dbh->prepare("select * from mytable where field1=?");
$sth->execute("значение параметра");
В этом случае в методе quote необходимости нет, он вызывается автоматически.

Использование привязки параметров особенно эффективно при выполнении нескольких однотипных запросов подряд. В этом случае достаточно один раз подготовить запрос с помощью функции prepare, и выполнять его с помощью функции execute столько раз, сколько необходимо.
« Последнее редактирование: 22 Мая 2020, 19:53:56 от DeMoN »

Оффлайн FussesDemon

  • GODMODE
  • *******
  • Сообщений: 407
  • Авторитет +61/-12
    • Просмотр профиля
Справка
« Ответ #5 : 25 Августа 2006, 10:09:12 »
Ssh - Secure Shell
Что такое ssh
Ssh - это программа для удаленного входа в другой компьютер через сеть, удаленного исполнения команд и копирования файлов между компьютерами. "Ssh" расшифровывается как "Secure Shell". Ssh обеспечивает надежную авторизацию и безопасную передачу данных по открытым каналам связи. Ssh предназначена для замены программ rlogin, rsh, rcp и telnet.

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

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

Во-вторых, авторизация на основе паролей (telnet и ftp) и IP-адресов (rlogin) является крайне слабой.

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

Как ssh работает
Для того, чтобы объяснить принцип работы Ssh, воспользуемся аналогией со шпионской деятельностью (благо, общего очень много) на примере известного героя Штирлица.

Представим себе, что Штирлицу ("Юстас") надо передать в Центр ("Алекс") некое сообщение, но старый шифр раскрыт. Что делать? Самый очевидный ответ - организовать где-нибудь встречу для передачи Юстасу нового шифра ("договориться о новом коде"). Но что, если это невозможно, и единственный канал связи -- открытый? Казалось бы, безвыходная ситуация.

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

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

Таким образом, если бы действие "Семнадцати мгновений весны" происходило в наше время, то Алексу достаточно было бы открытым текстом отправить Юстасу новый публичный ключ, и Мюллеру и компании осталось бы только рвать на себе волосы.

Оффлайн FussesDemon

  • GODMODE
  • *******
  • Сообщений: 407
  • Авторитет +61/-12
    • Просмотр профиля
Справка
« Ответ #6 : 25 Августа 2006, 10:09:45 »
SSL - Secure Sockets Layer
Secure Sockets Layer (SSL) — это протокол, который защищает данные, пересылаемые между Web-браузерами и Web-серверами. SSL также гарантирует, что данные, получаемые с узла Web, приходят именно с предполагаемого узла и во время передачи они не были искажены. Любой Web-узел, чей адрес начинается с https, поддерживает SSL.

Компания Netscape Communications пришла к выводу о необходимости создания безопасного способа передачи данных по Internet. Поэтому компания предложила решение — Secure Sockets Layer (SSL) и встроила его в свой Web-браузер.

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

Чаще всего он применяется для защищенного обмена данными между Web-браузерами и Web-серверами. Основное назначение протокола защиты состоит в следующем.

Аутентификация сервера, гарантирующая пользователям, что они попали именно на тот узел Web, который хотели посетить.

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

Пользователи Web могут распознать узел, который поддерживает SSL, по тому, что адрес Web-страницы начинается с https. Буква s, добавленная к знакомому HTTP — Hypertext Transfer Protocol, означает secure, то есть «защищенный».

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

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

Оффлайн FussesDemon

  • GODMODE
  • *******
  • Сообщений: 407
  • Авторитет +61/-12
    • Просмотр профиля
Справка
« Ответ #7 : 25 Августа 2006, 10:10:12 »
Что такое PHP?
PHP (аббревиатура PHP рекурсивно расшифровывается как "PHP Hypertext Preprocessor") - это язык написания скриптов, которые встраиваются непосредственно в гипертекстовые файлы и исполняются на Web-сервере. Программа на PHP заключается в теги , а интерпретатор обрабатывает команды между этой парой тегов и формирует окончательный файл, передающийся на локальную машину.

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

Язык PHP был специально разработан для web-программирования, и вопросам безопасности приложений уделялось много внимания, однако некорректная настройка интерпретатора и собственные ошибки PHP-программиста могут поставить под угрозу ваши разработки.

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

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

Интерпретатор PHP4, который называется Zend Engine, имеет два компонента: компилятор и исполняющий модуль (как дополнительные модули существуют: сложная система буферизации, значительно ускоряющая частоповторяемые запросы, и многопроходный оптимизатор). Компилятор просматривает ваш скрипт за один проход (в PHP3 скрипт интерпретируется построчно), компилирует его и затем передает исполняющему модулю.

Компания "IHO Networks" предлагает вам разместить на своем хостинге IHO.RU свои сайты, построенные на основе технологии PHP. Используя наш хостинг с PHP вы получаете качественный сервис по доступным ценам!

Оффлайн FussesDemon

  • GODMODE
  • *******
  • Сообщений: 407
  • Авторитет +61/-12
    • Просмотр профиля
Справка
« Ответ #8 : 25 Августа 2006, 10:10:47 »
Зачем нужен FTP?
FTP — это аббревиатура от File Transfer Protocol, что означает — протокол передачи файлов. Этот протокол предназначен для того, чтобы переносить на сервер именно файлы. Это могут быть какие–то материалы, архивы, программы, которые размещаются на сайте только для того, чтобы пользователь их скачал и просмотрел на своем компьютере.

Используя протокол FTP, пользователь получает доступ к своему сайту на сервере. При этом система запрашивает логин и пароль.

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

Оффлайн FussesDemon

  • GODMODE
  • *******
  • Сообщений: 407
  • Авторитет +61/-12
    • Просмотр профиля
Справка
« Ответ #9 : 25 Августа 2006, 10:11:15 »
Что представляет собой MySQL?
Разработку и сопровождение MySQL, самой популярной SQL-базы данных с открытым кодом, осуществляет компания MySQL AB.

На веб-сайте MySQL (http://www.mysql.com/) представлена самая свежая информация о программном обеспечении MySQL и о компании MySQL AB.

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

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

Программное обеспечение MySQL - это ПО с открытым кодом.
ПО с открытым кодом означает, что применять и модифицировать его может любой желающий. Такое ПО можно получать по Internet и использовать бесплатно. При этом каждый пользователь может изучить исходный код и изменить его в соответствии со своими потребностями. Использование программного обеспечения MySQL регламентируется лицензией GPL (GNU General Public License), http://www.gnu.org/licenses/, в которой указано, что можно и чего нельзя делать с этим программным обеспечением в различных ситуациях. Если работа в рамках GPL вас не устраивает или планируется встраивание MySQL-кода в коммерческое приложение, есть возможность купить коммерческую лицензированную версию у компании MySQL AB.


В каких случаях следует отдавать предпочтение СУБД MySQL?
MySQL является очень быстрым, надежным и легким в использовании. Если вам требуются именно эти качества, попробуйте поработать с данным сервером. MySQL обладает также рядом удобных возможностей, разработанных в тесном контакте с пользователями. Сравнительные характеристики MySQL и других средств управления базами данных приведены на нашей странице тестов производительности (see section 5.1.4 Набор тестов MySQL (The MySQL Benchmark Suite)). Первоначально сервер MySQL разрабатывался для управления большими базами данных с целью обеспечить более высокую скорость работы по сравнению с существующими на тот момент аналогами. И вот уже в течение нескольких лет данный сервер успешно используется в условиях промышленной эксплуатации с высокими требованиями. Несмотря на то что MySQL постоянно совершенствуется, он уже сегодня обеспечивает широкий спектр полезных функций. Благодаря своей доступности, скорости и безопасности MySQL очень хорошо подходит для доступа к базам данных по Internet.

Технические возможности СУБД MySQL
Более детальную информацию по техническим возможностям MySQL можно получить в разделе section 6 Справочник по языку MySQL. ПО MySQL является системой клиент- сервер, которая содержит многопоточный SQL-сервер, обеспечивающий поддержку различных вычислительных машин баз данных, а также несколько различных клиентских программ и библиотек, средства администрирования и широкий спектр программных интерфейсов (API). Мы также поставляем сервер MySQL в виде многопоточной библиотеки, которую можно подключить к пользовательскому приложению и получить компактный, более быстрый и легкий в управлении продукт.

Доступно также большое количество программного обеспечения MySQL, разработанного сторонними разработчиками. Вполне возможно, что СУБД MySQL уже поддерживается вашим любимым приложением или языком.

MySQL правильно произносится как "Май Эс Кью Эль" (а не "майсиквел"), хотя никто не запрещает вам произносить эту аббревиатуру как "майсиквел" или еще каким-либо образом.