Perl для CGI / Основы языка Perl

Вы наверное обратили внимание что CGI скрипты пишутся обычно на языке Perl (Practical Extraction and Report Language)- очень удобном языке, впитавшем из других все лучшие черты. Может у вас возникнет сомнение: "Ну вот! Изучать новый язык программирования!?". Спешу вас успокоить, изучение Perl не будет в тягость (я сужу по своему опыту!). Вы даже сами не заметите как выучите его. Хотя, наверное не стоит делать его своим первым языком программирования. Для начала изучите хотя-бы Basic, как наиболее логичный для понимания (но наименее удобный для программирования). Perl - НЕ объектно ориентированный язык, так как в CGI нет динамики (за редким исключением), а работа интерфейса построена на режиме: запрос-ответ.

Если вы хоть когда-нибудь программировали скажем на C и использовали утилиту grep для поиска регулярных выражений в тексте, то вам будет еще легче. Для Perl родной платформой является Unix поэтому пользователям PC он мало известен. Мое целенаправленое доведение Perl до широкой общественности началось с того что я скачал Perl под Windows (фирмы ActiveWare) К нему прилагается отличная гипертекстовая HTML-документация, даже быстрого просмотра которой хватит, чтобы начать хорошо и широко использовать его. Хоть он значительно уступает и по скорости и по эффективности своему Unix'ному аналогу, все равно самый лучший способ изучить язык это программировать на нем. Если вы как я дома используете большую часть времени не Windows а Unix то с изучением Perl у вас вообще не должно быть особых сложностей. Я же от себя могу сказать, что даже после небольшого опыта изучения его, он стал моим любимым языком программирования. Все в нем сделано для удобства программиста (в отличии например от Java ;( ).

Начнем с переменных, они в Perl бывают 3-х типов скаларные, списковые(массивы) и хэши(ассоциативные массивы). В отличии от других языков описывать переменные перед использованием не нужно. Любые переменные, списки массивов, элементы массивов добавляются налету, что открывает широкое поле для деятельности. Для указания компилятору (да и для немалого удобства программиста) перед именем скалярной переменной стоит знак '$', перед массивом '@', перед хешем '%'. т.е. например $scalar_var, @array_var, %hash_var. Скалярные переменные могут быть как числовые так и строковые, но это не надо указывать, Perl сам по контексту в зависимости от операций может привести одно к другому. Например: "123"+"4" будет 127 (или "127") так как операция '+' действует над числами, а вот если применить операцию конкатенации строк '.' то строковое "test" . 1 будет "test1".

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

$x='qwerty';
print 'my var is $x'; #выведет my var is $x
print "my var is $x"; #выведет my var is qwerty

Списочные переменные начинаются с символа '@' и конструктуируются следующим образом:

@List1=(1,2,5,70);
@List2=(12,23,@List1); #12,23,1,2,5,70
@Rgb=($r,$g,$b);

Также можно список использовать как lvalue:

@List=(1,2,3..8,15);
($x,$y,$z)=@List; #$x=1,$y=2,$z=3
($x,$y,$z,@list2)=@List; #$x=1,$y=2,$z=3,@list2=(4,5,6,7,8,15);
($r,$g,$b)=@Rgb;

Можно обращаться к нескольким выбраным элементам массива (срезу массива):

@list=(1..10);
@list[2,3,5,9]=(100,200,300,400); #@list=(1,100,200,4,300,6,7,8,400,10)
@list[1,10]=@list[10,1];#меняет местами элементы №1 и №10

Обратится к скаларному значению элемента массива можно как $имя_массива[индекс], здесь обратите внимание на знак '$'- мы ведь обращаемся к скаляру-элементу. А вот при помощи конструкции '$#' можно узнать номер (индекс) последнего элемента массива. То есть если в массиве @list нет элементов, то $#list=-1, если один элемент, то $#list=0, если два, то $#list=1 и т.д.

Теперь немного о хешах. Хеш - это такой массив, который состоит из пар ключ-значение. Весь хеш обозначается как %хеш. К отдельным элементам доступ $хеш{скалярное выражение} конструктуируется хеш так:

$my_hash{1}="doom";
$my_hash{'quake'}="www.idsoftware.com";
$my_hash{1+2}=100;

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

%hash=(1,20,2,100);#аналогично $hash{1}=20;$hash{2}=100;

удаление из хеша -операция delete:

delete $hash{1};

есть функции выдающие ключи и значения соответственно:

%hash=(1,20,2,100,3,'doom');
@k=keys %hash; #@k=(1,2,3);
@v=values %hash; #@v=(20,100,'doom');

Набор операторов в Perl очень широк. Многие из них прямые аналоги имеющихся в других языках, например if, for, while. Но есть и значительные улучшения имеюшихся и конечно новые.

Тот же самый оператор if имеет две формы (как когда удобнее):

if (условие) {оператор;}
оператор if (условие);

В пару к оператору if имеется оператор unless - означающий if с отрицанием:

unless(($method eq 'GET')||($method eq 'POST')){print "Unsupported method";}
print "Ok" unless ($x < $y);

Также в пару while существует until. Вообще синтаксис Perl заключается в использовании операторных скобок {}, то есть имеет конструкцию оператор {Набор операторов, команд и функций}. Все что находится внутри операторных скобок относится к оператору. После операторов не нужно ставить точку с запятой (;), а после команд обязательно. Например после команды print;

В Perl5 появилось еще несколько улучшений оператора условий if - elsif и else. Синтаксис такой:

if (основное условие) {
# основная ветка;
} elsif (второе условие) {
# вторая ветка;
} elsif (третье условие) {
# третья ветка;
}...
else {
# выполняется если ни одно из условий не подходит;
}

или можно так:

$fam='Ельцин';
if ($fam eq "Ельцин") {
print "Условие выполнено";
} else {
print "Условие не выполнено";
}

Синтаксис оператора for полностью аналогичен C:

for($i=0;$i<10;$i++) {
print $i;
}

Здесь мы печатаем значение переменной $i, которая принимает значения от 0 до 10 (при $i=10 цикл заканчивается, то есть последний раз распечатается 9) с шагом 1.

Новшеством (и приятным) является foreach позволяющий пройтись по всем элементам массива, присваивая по очереди его элементы какой-то переменной, его синтаксис такой:

foreach $переменная (@массив) {
блок операторов;
}

или

foreach (@массив){
операторы;
}

Последний пример особенно важен для упрощения вашего тяжкого труда програмиста и демонтстрирует интересную особенность Perl - переменную по умолчанию $_: в огромном количестве операторов и функций при опускании аргумента она подразумевается по умолчанию. Она также по умолчанию сопоставляется с регулярным выражением. Этот пример:

@Data=<STDIN>;
foreach(@Data){
chomp;
print if /^From:/;
}

аналогичен такому:

@Data=<STDIN>;
foreach $_ (@Data){
chomp($_);
print $_ if $_ =~ /^From:/;

Как видите затраты труда значительно сокращаются, благодаря этому маленькому трюку. Так же в Perl имеется массив по умолчанию - @_. Он может использоваться для передачи значений процедуре как например:

&addvalue ("3","4");
print "$sum"; # получим 7, благодаря передаче процедуре addvalue значений для сложения (3+4=7)

sub addvalue {
$sum=$_[0]+$_[1];
}

Отсюда видно, что процедура в Perl имеет синтаксис sub Имя_процедуры {Набор операторов;}, а вызывается &Имя_процедуры;, если нужно передать параметры: &Имя_процедуры (параметр1, параметр2,...); Так же это можно использовать и в функциях. Например функция перевода русских букв в верхний регистр:

$word="Ельцин";
$word=&up_case("$word");
print "$word"; # Получим: ЕЛЬЦИН

sub up_case {
$_[0] =~ s/а/А/g;
$_[0] =~ s/б/Б/g;
$_[0] =~ s/в/В/g;
$_[0] =~ s/г/Г/g;
$_[0] =~ s/д/Д/g;
$_[0] =~ s/е/Е/g;
$_[0] =~ s/ё/Ё/g;
$_[0] =~ s/ж/Ж/g;
$_[0] =~ s/з/З/g;
$_[0] =~ s/и/И/g;
$_[0] =~ s/й/Й/g;
$_[0] =~ s/к/К/g;
$_[0] =~ s/л/Л/g;
$_[0] =~ s/м/М/g;
$_[0] =~ s/н/Н/g;
$_[0] =~ s/о/О/g;
$_[0] =~ s/п/П/g;
$_[0] =~ s/р/Р/g;
$_[0] =~ s/с/С/g;
$_[0] =~ s/т/Т/g;
$_[0] =~ s/у/У/g;
$_[0] =~ s/ф/Ф/g;
$_[0] =~ s/х/Х/g;
$_[0] =~ s/ц/Ц/g;
$_[0] =~ s/ч/Ч/g;
$_[0] =~ s/ш/Ш/g;
$_[0] =~ s/щ/Щ/g;
$_[0] =~ s/ы/Ы/g;
$_[0] =~ s/ъ/Ъ/g;
$_[0] =~ s/ь/Ь/g;
$_[0] =~ s/э/Э/g;
$_[0] =~ s/ю/Ю/g;
$_[0] =~ s/я/Я/g;

return "$_[0]";
}

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

Регулярное выражение записывается между двух слэшей /рег_выр/ :

if(/abc/){
print '$_ содержит abc\n';
}

это самый простой пример применения регулярного выражения. А теперь посложнее вот тут в табличке (из того что я помню наизусть):

Для того чтоб поместить в выражение любой специальный символ, поставьте перед ним обратный слэш (\). Так например:

/(http://)?.*.cgi/ # вызовет ошибку, а
/(http:\/\/)?.*\.cgi/ # правильно

или

print "<a href="$url">$url</a>"; # вызовет ошибку из-за лишних кавычек, а
print "<a href=\"$url\">$url</a>; # правильно

Заставить Perl игнорировать регистр можно поставив i после регулярного выражения:

print "Are you sure?:";
$answer=<STDIN>;
if($answer=~/Y/i){
#че-нибудь сделаем...
}

но это работает только с латинскими буквами.

В Perl очень много различных функций, как говорится на все случаи жизни. Все их я конечно не опишу, но обо многих. Начну с тех, которые больше относятся к предыдущему параграфу. Операция замены s/рег.выражение/строка/. Игнорировать регистр позволяет опция i (только для латинских букв). Глобальная (по всей строке) замена - опция g. Пример:

$x="This is test";
$x=~s/ /_/;
print $x; #This_is test
$x=~s/ /_/g;
print $x; #This_is_test

Очень полезная опция у s/// e - она означает что вторая строка не строка а выражение, результат которого и будет подставлен. Например, у вас есть файл в котором все записи о возрасте через год надо менять:

open(OLD,"oldfile.txt") || die "Cannot open oldfile.txt $!\n";
open(NEW,">newfile.txt") || die "Cannot open newfile.txt $!\n";
foreach(){
s/(\d+)(\s+год)/($1+1).$2/gie;
s/(\d+)(\s+лет)/($1+1).$2/gie;
print NEW $_;
}
close(NEW);
close(OLD);

или так будет понятнее:

$var="Sam";
$reg="theSamuele";
if ($reg =~ /Sam/) {print "найдено вхождение";}
# а можно так:
if ($reg =~ /sam/i) {print "найдено вхождение";} # игнорируем регистр
if ($reg =~ /$var/e) {print "найдено вхождение";} # в качестве регулярного выражения
# подставляем значение переменной $var

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

sub urldecode{
local($val)=@_;
$val=~s/\+/ /g;
$val=~s/%([0-9a-hA-H]{2})/pack('C',hex($1))/ge;
return $val;
}

Функции split и join. split - разбивает строку из переменной в массив по указанным разделителям, а join - объединяет в переменной элементы массива, разделяя их указанными символами:

@Список=split(/рег.выр/,$скаляр);
$скаляр=join(строка,@Список);

#Разбить строку слов,разделенных пробелами в список вы можете
@WordList=split(/ /,$String);
#После обработки снова обьединить
$String=join(' ',@WordList);

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

print if "x=%d",$x;
print if ("x=%d",$x);# аналогично

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

Напоследок еще пара функций Perl: Функция rand возвращает псевдослучайное число от 0. Аргумент функции задает верхнюю границу для случайного числа. То есть rand(5) выбирает число от 0 до 5, но с очень мелким шагом, это может быть 0.776548654, или 3.679643213345901. Если вам нужно целое число, то применяйте функцию int, которая округляет числа до целого. Например так: int(rand($max));

Функция sleep вызывает задержку выполнения программы в секундах в качестве аргумента. Задержка происходит в фоновом режиме, то есть на момент задержки управление передается системе.

А вот функции для работы со строками. length() возвращает длину строки: length("Вот это")=7. substr($str, Start, Len), где $str-строка или переменная, Start-с какого символа выводить, Len-сколько символов выводить - возвращает часть строки: substr("Программируем на CGI", 1, 3)=рог.

Также важным удобством в Perl являются операции для работы с файлами. Для выполнения схожих функций в других языках приходится проделывать огромную массу работы. Аргументами могут быть как Файловые переменные, так и строки, представляющие имя файла.

Еще есть и другие.

функция open открывает файл:

open(ИДЕНТИФИКАТОР,"<имя файла"); #открыть файл для чтения (можно опустить значок '<')
open(ИДЕНТИФИКАТОР,">имя файла"); #для записи
open(ИДЕНТИФИКАТОР,">>имя файла");#для записи в конец
open(ИДЕНТИФИКАТОР,"+<имя файла");#для чтения и записи
open(ИДЕНТИФИКАТОР,"|команда"); #направить информацию на вход программы
open(ИДЕНТИФИКАТОР,"команда|"); #считать информацию с выхода программы
open(ИДЕНТИФИКАТОР,"|команда|"); #и то и другое вместе

Вообще часто скрипту требуется хранить данные во внешних файлах. Для этого создают поддиректорию в директории cgi-bin/ (например data) и делают ее доступной для чтения и записи (chmod 777). Например создайте файл test.txt и запишите туда: "Вот этот текст внутри файла". Переместите его в директорию cgi-bin/data и откройте при помощи простенького Perl-скрипта:

#!/usr/bin/perl
#opener_file.cgi

$data_dir="data";
$data_file="test.txt";
if (-e "$data_dir/$data_file") {
open (TEST, "<$data_dir/$data_file");
$t=<TEST>;
close TEST;
print "Content-type: text/html\n\n";
print "В файле записано: $t";
} else {
print "Content-type: text/html\n\n";
print "Файл $data_file не найден!";
}

Что касается открытия файлов, то вам, как програмистам все очевидно, но с командами тоже все здорово, что пояснит хороший пример (из практики):

open(MAIL,"|mail paaa@uic.nnov.ru");#Пошлем информацию по почте
print MAIL "Hello\n";
print MAIL "...\n";
print MAIL "...\n";
close(MAIL);

или более правильная процедура отправки почты:

$mail_path='/usr/sbin/sendmail'; # Путь к программе отправки почты на сервере
$emailTO="isety@orc.ru"; # Адрес получателя
$FromEmail="isety@mail.ru"; # Адрес отправителя
$FromName="Сергей"; # Имя отправителя (появится в адресной книге получателя)
open(MAIL,"|$mail_path -t");
print MAIL "To: $emailTO\n";
print MAIL "From: $FromEmail ($FromName)\n";
print MAIL "Subject: Письмо от Perl\n\n"; # Тема сообщение
print MAIL "Собственно сам текст сообщения\n";
print MAIL "HTTP User Agent: ".$ENV{'HTTP_USER_AGENT'}."\n"; #Можно считать некоторые данные отправителя
print MAIL "Remote Addresse: ".$ENV{'REMOTE_ADDR'}."\n";
close MAIL;

когда вы открыли файл вы можете считать из него строку в скалярную переменную вот так: $str=<FILE>. Избавиться от символа новой строки на конце поможет функция chomp, ведь этот символ может помешать например в имени файла или при выводе на экран:

print "Введите имя файла:";
$fname=<STDIN>;
chomp($fname);
open(F,$fname)|| die "Cannot open $fname $!\n";
.....

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

print "Что искать:";
$search=<STDIN>;
chomp($search);
@L=<F>;
foreach(@L){
print if /$search/;
}

а можно и так:

print "Что искать:";
$search=<STDIN>;
chomp($search);
foreach(<F>){
print if /$search/;
}

Бинарный файл можно читать и писать функциями sysread и syswrite:

sysread(ИДЕНТИФИКАТОР,$скалярная_переменная,сколько_байт)
syswrite(ИДЕНТИФИКАТОР,$скалярная_переменная,сколько_байт)

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

print $x+5; # Ответ стандартной консоли в виде числа, после вычисления выражения
print "Hello!"." "."Dolly!"; # строка после объединения трех строк
print ID "Hello!"; # Ответ консоли с идентификатором 'ID' в виде строки...

С командой return вы уже встречались. Ее назначение прерывать выполнение процедуры до достижения конца и возвращать управление вызвавшей процедуре. Так же может возвращать значение:

return; # без значения (NULL)
return 1; # вернет целое число 1
return "yes"; # вернет строку yes

Подобная команда - exit. Ее отличие от return в том, что она завершает все процедуры и прерывает выполнение программы в целом.

Команда time возвращает абсолютное время в виде длинного целого числа. Если хотите преобразовать его в нормальное представление даты и времени воспользуйтесь функцией localtime. Так выражение: localtime(time) вернет текущую дату и время на сервере. Время по команде time изменяется посекундно. Можете проверить сколько циклов успеет обработать сервер, прежде чем пройдет секунда (если раньше не сработает ограничение ресурсов):

$first=time;
for ($i=1; $first==time; $i++;) {
}
print "За секунду обработано циклов: $i";

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

# Допустим значение времени строки считано в переменную $time
$min=time-$time*60
$hour=time-$time*60*60;
$sut=time-$time*60*60*24;
print "Минут: $min";
print "Часов: $hour";
print "Суток: $sut";

Вобщем команда time в Perl5 возвращает количество секунд, прошедьших с 01.01.1970г. 00:00часов.

Как уже говорилось выше, переменные в Perl не нуждаются в описании. То есть если в вашей программе впервые встречается строка: $var=$var+1; то Perl создаст переменную $var со значением NULL, а затем прибавит к ней еденицу. То есть результатом приведенного выражения получится: $var=1;. Эта переменная имеет период жизни на весь срок работы программы, то есть она доступна любым другим процедурам, модулям и скриптам на период, пока программы, использующие эту переменную не завершаться. Период работы Perl-сценария редко превышает 3 секунды, но за это время программа может проделать уйму операций. Соответственно переменные, созданные в Perl, занимают довольно много аппаратных ресурсов, если выполняются сложные программы (например WWW-чат). Но далеко не всегда нужна глобальная переменная. Ведь если она нужна только в текущей процедуре (например - счетчик цикла), зачем ее значение держать в памяти, когда уже выполняются другие процедуры? Для снижения аппаратных затрат служит команда my, перед переменной. Она позвлояет создать локальную переменную, хранящуюся только на период выполнения процедуры. Причем, если она создана как счетчик цикла, то видна только в теле цикла, за циклом она уже не существует. Другим процедурам такая переменная не видна, но и памяти для ее хранения требуется гораздо меньше. Вышеприведенный пример можно записать как: my $var=$var+1. Результат будет тот же, но в другой процедуре $var не будет видна, то есть будет иметь значение NULL, при обращении к ней. Но если процедура, в которой была создана локальная переменная, еще не завершила свою работу (то есть из нее была вызвана другая процедура), то при возврате к ней значение переменной будет правильным. Например:

for (my $i=0; $i<10; $i++) {
}
&nether_sub;
print $i; # получим 9
sub nether_sub {
print $i; # ничего не увидим, поскольку $i=null в данной процедуре
}

Следующая программа переводит текстовый файл в формат HTML (вспомните сколько хлопот вам доставит отлов во всем файле '<', '>' и '&' чтоб заменить их на &tl; , &gt; и &amp; а как неплохо чтоб автоматически все http://www.... превратились в <A href="http://www...." >http://www....</A>):

#!/usr/bin/perl
#txt2html
die "Usage: txt2html Infile OutFile\n" unless(@ARGV);
open(IN,"$ARGV[0]")|| die "Cannot open $ARGV[0] $! \n";
open(OUT,">$ARGV[1]")|| die "Cannot open $ARGV[1] $! \n";
while(<IN>){
s/&/&amp;/g;
s/</&lt;/g;
s/>/&gt;/g;
s/(http:\/\/\S+)/<A href="$1">$1<\/A>/g;
print OUT $_;
}
close(IN);
close(OUT);

Более подробную информацию о Perl вы можете получить по адресам:
http://www.perl.com/
http://www.metronet.com/0/perlinfo/perl5/manual/perl.html
http://www.ActiveWare.com/

или обращайтесь с вопросами в форум.