Справочник по Perl

Программирование Справочник по Perl

Помечено: 

В этой теме 0 ответов, 1 участник, последнее обновление  Васильев Владимир Сергеевич 2 мес., 1 неделя назад.

  • Автор
    Сообщения
  • #5094
    @admin

    Введение

    Perl — язык извлечения данных и отчетов созданный Ларри Уоллом. Это скриптовый язык широкого профиля. Может использоваться для написания как системных скриптов (более мощная альтернатива shell-скриптам), так и сgi-скриптов в web-программировании. Кроссплатформенный, распространяется по GNU лицензии.

    Типы данных

    Perl поддерживает следующие типы данных:

    • простой — совмещает в себе числа и строки,
      в терминологии perl также называется скалярным типом;
    • массивы;
    • отображения или ассоциативные массивы;
    • undef — пустое значение;
    • ссылки.

    преобразование типов

    Значение простого типа преобразуется автоматически в число или строку, в зависимости от
    контекста.

    В явном виде логического типа нет. Но он используется в логических операциях и в управляющих
    операторах с условиями как if. Пустая строка, число 0 или строка, содержащая только символ 0,
    значение undef в этих случаях преобразовываются в ложь.

    Переменные

    Имена переменных простого типа должны иметь префикс $,
    массивы префикс @, отображения %.

    В perl существует множество предопределенных переменных. Например, переменная по умолчанию
    $_, которую используют встроенные функции при отсутствии аргументов.

    Если в строке, указанной в двойных кавычках, встречается имя переменной с $ или @
    префиксом, то perl подставляет туда значение этой переменной.

    объявление переменных

    В свободном синтаксисе специально объявлять переменные не надо. Они создаются
    автоматически по мере использования. Область видимости таких переменных файл.

    Жесткий синтаксис задается с помощью директивы strict.
    В этом случае каждая переменная должна быть объявлена одним из следующих способов:

    • my — переменная будет доступна только внутри модуля (файла),
      в котором определена;
    • our — переменная будет доступна из вне, противовес для my начиная с perl 5.6.
      Переменная видна напрямую во всех вложенных пакетах;
    • use vars — отличие от our в том, что область видимости ограничивается пакетом
      в котором переменные объявлены, т.е. не доступна во вложенных пакетах
      (подробнее см. здесь).

    Жесткий синтаксис имеет два преимущества: сложнее описаться, код выполняется
    быстрее.

    # жесткий синтаксис
    use strict;
    my $v1="aaa";
    # свободный синтаксис
    no strict;
    $v2="bbb";

    Литералы

    Литералы служат для непосредственного представления значений базовых типов.
    Perl поддерживает следующие литералы:

    • вещественные числа — 3.14, -3.14е-10;
    • десятичные целые — 0, -1, 1;
    • шестнадцатиричные целые — 0xad;
    • восьмеричные целые — 023;
    • строки — «строка1», ‘строка2’. Строка в одинарных кавычках ограничена
      в числе возможных ESC-последовательностей и не может подставлять внутри себя
      значения вложенных переменных. Большой текст может указываться как here-doc:

      # без ; в конце
      print <<EOD
      ... текст
      EOD

    • undef — значение переменной до присваивания (аналог null-значений в других языках);
    • диапазон чисел — $а .. $b, 1 .. 20, 3.01 .. 3.14 (т.е. 3.01,3.02,…);
    • массив — задается перечислением элементов в круглых скобках, элемент не обязательно константа,
      например: (1, $varname, «строк»);

    esc-последовательности

    • \a — сигнал;
    • \b — пробел;
    • \c.. — управляющая последовательность, например, \cD — ctrl+D;
    • \e — escape символ;
    • \f — переход на следующую страницу;
    • \n — перевод строки;
    • \r — возврат каретки;
    • \t — табулятор;
    • \0.. — ASCII код символа в восьмеричной системе;
    • \x.. — ASCII код символа в шестнадцатиричной системе;
    • \l — следующий символ в нижний регистр;
    • \L — все символы в нижний регистр до \E;
    • \u — следующий символ в верхний регистр;
    • \U — все символы в верхний регистр до \E;
    • \Q — заключить в обратные косые все небуквенные и нецифровые символы до \Е;
    • \.. — для представления спец. символов, примеры см. ниже;
    • \\ — обратная косая;
    • — двойная кавычка.

    Строки

    Строки задаются текстом в одинарных или в двойных кавычках. Большой текст может быть указан с помощью here-doc (см. выше).

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

    Отдельного типа для строк нет. Простой тип совмещает в себе числа и строки,
    делая преобразование в зависимости от контекста.

    Пустая строка или строка, состоящая из символа 0, в логических выражениях
    рассматривается как ложь.

    операции

    В perl есть отдельные операции отношения над строковыми значениями:

    • eq — равенство;
    • != — неравенство;
    • lt — меньше чем;
    • gt — больше чем;
    • le — меньше либо равно;
    • ge — больше либо равно;

    Операция . соединяет строки в одну.

    print "hello "."world\n";
    $w="world";
    print "hello ".$w;
    # или так
    print "hello ", $w;

    регулярные выражения

    Одна из сильных сторон perl это регулярные выражения.

    Для сопоставления строки с шаблоном регулярного выражения используется операция =~

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

    print "hello"=~/he.{1,}/; # 1
    print "hello"=~/He/; # пустое значение

    функции

    • chomp($str) — удаляет символ конца строки из указанной строки или массива строк;
    • chop($str) — удаляет последний символ и указанной строки или массива строк;
    • eval($str) — выполняет строку как perl код;
    • index($str,$srch [,$pos]) — поиск первого вхождения $srch или -1,
      если ничего не найдено. Необязательный параметр $pos определяет начальную позицию поиска, по умолчанию
      это первый символ строки;
    • rindex($str,$srch [,$pos]) — поиск последнего вхождения $srch или -1,
      если ничего не найдено. Необязательный параметр $pos определяет начальную позицию поиска, по умолчанию
      это последний символ строки;
    • length($str) — размер строки в байтах;
    • lc($str) — все символы строки в нижний регистр;
    • lcfirst($str) — первый символ строки в нижний регистр;
    • substr($str,$pos [,$len [,$repl]]) — выделяет подстроку с указанной
      позиции и указанной длины (до конца строки по умолчанию).
      Если указан $repl, то происходит замена подстроки на это значение;
    • uc($str) — все символы строки в верхний регистр;
    • ucfirst($str) — первый символ строки в верхний регистр.

    Массивы

    В терминологии perl массивы часто называют списками или списочными
    значениями.

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

    Имя переменной массива начинается с символа @.

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

    @a = (1, 20..30);
    $varname = 3.14;
    @b = ("begin", @a,$varname,"end");

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

    # вместо  @a= ("string1", "string2", "string3");
    # можно так
    @a = qw(string1 string2 string3);

    операция индексации

    [] — операция индексации, т.е. доступа к элементу массива. Элементы нумеруются
    целыми числами от 0. Для выделения подмассива, в операции индексации можно
    указать сразу несколько индексов, даже используя диапазоны.

    @a = (0..30);
    @b = @a[2,15..20];
    print "b=@b";

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

    операция присвоения

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

    ($a,$b,$c)=(1,2,3);
    print " \$a=$a, \$b=$b, \$c=$c ";

    функции

    • push(@a,$val) — добавляет в конец массива a элемент со значение val;
    • pop(@a) — удаляет последний элемент массива;
    • shift(@a,$val) — добавляет элемент в начало массива;
    • unshift(@a) — удаляет первый элемент массива;
    • reverse(@a) — меняет порядок элементов на противоположный;
    • sort(@a) — сортирует массив, элементы рассматриваются как строки;
    • chomp(@a) — удаляет из элементов массива символ конца строки, обычно
      используется после клавиатурного ввода.

    ввод/вывод

    При выводе массивы выводятся как сплошная строка.

    print "array: @b";

    При вводе из стандартного потока ввода, элемента разделяются
    новой строкой, т.е. нажатием клавиши enter. А конец ввода массива
    определяется концом файла, т.е. нажатием ctrl+D (в некоторых системах ctrl+Z).
    Правда в windows у меня с этим была проблема.

    @a=<stdin>;
    # или так @a=<>
    print @a;

    Ссылки

    Ссылки perl схожи с указателями С++ в плане функциональности.
    Другими словами,

    • можно получить ссылку (адрес в С++) операцией \ и сохранить
      ее в переменной;
    • разыменовать ссылочную переменную, т.е. получить значение по ссылке;
    • обратиться к элементу массива или отображения по ссылке.

    ссылки и простые значения

    $str="hello world\n"; # переменная простого типа
    $ref=\$str; # ссылку на переменную $str
    $ref=\"hello world\n"; # ссылку на значение
    # два способоа разыменование 
    print $$ref, ${$ref};

    ссылки и массивы

    @lst = ("hello ", "world\n"); # массив
    $ref = ["hello ", "world\n"]; # ссылка на неименованный массив 
    $ref = \@lst; # ссылка на массив
    print @{$ref}; # разыменование массива
    # два способа доступа к элементу массива по ссылке
    print ${$ref}[0], $ref->[1];

    ссылки и отображения

    %map = ("color" => "blue", # отображение
            "weight" => "35");
    $ref = ("color" => "blue", # ссылка на неименованное отображение
            "weight" => "35");       
    $ref= \%map; # ссылка на отображение
    print %{$ref}, "\n"; # разыменование отображения
    # два способа доступа к элементу отображения по ссылке
    print ${$ref}{"color"},"\n", $ref->{"weight"},"\n";

    ссылки и файловые дескрипторы

    # ссылка на файловый дескриптор в общем 
    $ref = \*FILE;  	
    # например используем стандартное устройство ввода
    $ref = \*stdin;
    $a={$ref}; # разыменование дескриптора
    $b=<$ref>; # разыменование дескриптора как значение простого типа   	
    print "$a $b";

    ссылки и процедуры

    # ссылка на неименованную процедуру
    $ref=sub { # внутри таких функций ввод/вывод не работает
     "hello world";
    };
    print &$ref;

    Ассоциативные массивы

    В perl отображения реализованы в виде хеш-таблиц.

    Имена переменных отображений имеют префикс %.
    Проинициализировать отображение можно массивом, при этом
    каждая пара элементов будет рассматриваться как пара ключ/значение.
    Также можно разделить ключ и значение не запятой, а =>.

    %map=(1,"first","second",2);
    # или
    # %map=(1 => "first","second" > 2);
    print $map{"second"};

    индексация

    Префикс % используется при обращении к отображению вцелом. При индексации
    следует использовать префикс переменных $. Индексы указываются
    в фигурных скобках.

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

    %map=(1,"first","second",2);
    $map{"five"}=5;
    print $map{"five"};

    функции

    • keys(%m) — возвращает массив ключей;
    • values(%m) — возвращает массив значений;
    • each(%m) — возвращает массив из двух элементов ключ/значение. Последующие
      вызовы функции для того же отображения, будут возвращать следующий пары.
      Если пар нет, возвращается пустой массив;
    • delete($m{}) — удаяет указанные элементы из отображения.

    %map=("red","R","green","G","blue","B");
    #при инициализации следующим образом
    #все работало криво на моей версии perl
    #$map{"red","green","blue"}=("r","g","b");
    print keys(%map), "\n";
    delete $map{"blue"};
    print keys(%map),"\n";

    Выражения и операции

    Выражения представляют собой множество данных связанных между собой операциями — особыми
    операторами языка, возвращающих некоторое значение. Аргументы операций называют операндами.
    Большинство операций либо унарные (с одним операндом) или бинарные (с двумя операндами).
    Также операции характеризуются приоритетом (старшинством) выполнения в выражении.
    Например, результат выражения 4+5*2
    будет 14, а не 18, так как операция умножения имеет больший приоритет, чем сложение.
    Операции одинакового приоритета выполняются последовательно слева направо.

    алгебраические операции

    • — унарный минус, изменяет знак числа;
    • ++ — инкремент, увеличивает число на 1;
    • — декремент, уменьшает число на 1;
    • * — произведение;
    • / — деление;
    • % — остаток от деления;
    • + — сложение;
    • — вычитание.
    • ** — возведение в степень;

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

    print ++($i = "aZ"),"\n"; # "bA"
    print ++($i = "a9"),"\n";     # "b0"
    print ++($i = "09"),"\n";     # "10"

    логические операции

    • ! — отрицание (NOT);
    • && — логическая и (AND);
    • || — логическое или (OR).

    В отличие от С++, && и || возвращают значение выражения, а не истину и ложь,
    что позволяет использовать наподобие условной операции ?.

    операции отношения для чисел

    • < — меньше;
    • > — больше;
    • <= — меньше либо равно;
    • >= — больше либо равно;
    • == — равенство;
    • != — не равенство;
    • <=> — сравнение, возвращает -1 — левый операнд меньше правого,
      0 — операнды равны, 1 — левый операнд больше правого.

    операции отношения для строк

    • eq — равенство;
    • != — неравенство;
    • lt — меньше чем;
    • gt — больше чем;
    • le — меньше либо равно;
    • ge — больше либо равно;
    • cmp — сравнение, возвращает -1 — левый операнд меньше правого,
      0 — операнды равны, 1 — левый операнд больше правого.

    побитовые операции

    • & — и;
    • | — или;
    • ^ — исключающее или;
    • << — сдвиг влево;
    • >> — сдвиг вправо;
    • ~ — инверсия (отрицание);

    Без знакового сдвига нет.

    операции со строками и шаблонами

    • x — повторение строки n раз. Например, «1, » x 5, то же самое что «1, 1, 1, 1, 1,»;
    • . — объединение строк (конкатенация);
    • =~ — истина, если применение шаблона регулярного выражения,
      указанного в правом операнде, к левому операнду прошло удачно;
    • !~ — отрицание предыдущей операции;

    операции назначения

    • = — присваивает левому операнду значение правого операнда;
    • op= — выполняет операцию op над операндами и сохраняет результат в левом операнде.

    прочие операции

    • [] — операция индексации массива;
    • {} — операция индексации для ассоциативного массива;
    • (cond)?ret1:ret2 — условная операция, возвращающая ret1 если cond истина, и ret2 в противном случае;
    • , — запятая, позволяет вычислить последовательно несколько выражений, возвращается последнее выражение. Также
      используется как разделитель;
    • .. — задает диапазон чисел;
    • \ — получение ссылки на переменную;
    • -e — операция определения существования файла, например -e $fname
      (но лучше воспользоваться модуляем FILE);

    Управляющие операторы

    блоковый оператор

    Блоковый оператор {} обязателен при построении утверждений с использованием
    некоторых ниже приведенных операторов.

    условные операторы

    Условный оператор if позволяет выполнить оператор или блок операторов,
    если указанное выражение истинно. A если присутствует
    оператор else выполнить альтернативый оператор или блок операторов.

    Если указанное условие является отрицанием какого-то выражения, то можно
    воспользоваться другим оператором perl — unless.

    $a=25;
    # if($a==25) print "$a equal 25"; - было бы ошибкой 
    if($a==25) {print "$a equal 25";}
    else {print "$a not equal 25";}
    
    #вместо if(!($a==25))
    unless(a==25) {print "unless: $a not equal 25";}
    else {print "unless: $a equal 25";}

    Оператор if можно заменить оператором && (логическое И), если
    else и блок операторов не нужны. Аналогично для оператора unless можно воспользоваться
    оператором || (логическое или).

    $a=25;
    $a==25 && print "a=25";
    # ошибочные
    #$a==25 && print "a=25"; && print "====";
    #$a==25 && {print "a=25";}

    циклы с предусловием

    Оператор while выполняет блок операторов, пока указанное условие истинно.
    Оператор until выполняет блок операторов, пока указанное условие не истинно.

    $a=1; 
    while ($a > 0) {
    $a = <>
    chomp($a); # сравните результат без этой строчки 
    print "\$a=$a\n";
    }

    циклы с постусловием

    Оператор do {}while выполняет блок операторов, пока указанное условие истинно.
    Оператор do {}until выполняет блок операторов, пока указанное условие не истинно.
    В обоих случаях условие проверяется после выполнения блока, таким образом, тело цикла
    будет выполнено хотя бы один раз.

    print "input 0 for exit\n";
    do{
    print "input number: ";
    $a=<>;
    }while($a>0);

    цикл по счетчику

    Перед первой итерации выполняется ициализирующее выражение.
    В начале каждой итерации проверяется условие, если оно истинно, то тело цикла выполняется.
    В конце каждой итерации выполняется, завершающее выражение.

    # for(init_expr; cond; end_it;){
    #...
    #}
    for($i=0;$i<10;$i++){
    print "$i,";
    }

    цикл по элементам

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

    @a=(1,2,"str");
    $it=56;
    foreach $it (@a){
    print "$it\n";
    }
    print "after loop it=$it\n";

    метки

    Метки определяются как label_name:

    MYLAB:
    ...

    операторы last, next, redo

    Оператор last позволяет выйти из текущего блока.

    Оператор next позволяет перейти на следующую итерацию цикла.

    Оператор redo позволяет перезапустить текущую итерацию.

    Данным операторам можно явно указать метку перехода.

    Под текущим блоком понимается тело цикла, кроме циклов с предусловием, или
    независимый блок, т.е. определенный сам по себе.

    Функции

    создание функций

    Функция определяется с помощью ключевого слова sub. Имена функций не
    используют префикс. Таким образом, можно определять переменную $funcname и
    функцию funcname без каких-либо конфликтов.

    #объявление функции не обязательно
    sub funcname;
    
    #определение функции
    sub funcname {
    
    }

    аргументы

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

    sub sum {
    my $sum=0;
    foreach $it(@_) {$sum+=$it;}
    return $sum;
    }
    print sum(1,2,3,4);

    вызов функции

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

    Если функция была объявлена, то после имени функции можно сразу указать
    список аргументов без круглых скобок.

    В последних версиях perl для вызова функций можно использовать префикс &.
    В этом случае список аргументов не обязателен, и если он не указывается то внутри
    функции массив @_ не доступен. Типы переданных аргументов не проверяется. Вызов
    функции подобным образом, никогда не будет инлайновым.

    & обязателен при простом перечислении имен функций.
    & также используется для вызова функций по ссылке (&$subref(), &{$subref}(), $subref->()).

    #======================
    sub fn{
    @_[0]+@_[1]+@_[2];
    }
    &fn(1,2,3);        
    fn(1,2,3);
    print fn 1,2,3; # возможно если fn объявлена выше
    
    #======================
    fn1();
    &fn1();
    
    #======================
    &fn2; 
    fn2; # возможно если fn2 объявлена выше

    прототипы

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

    • $ — значение простого типа;
    • @ — массив;
    • % — отображение;
    • \$ — ссылка;
    • \@ — ссылка на массив;
    • \% — ссылка на отображение;
    • * — ссылка на элемент из таблицы символов, например файловые дескрипторы;
    • ; — разделитель между обязательными и не обязательными аргументами.

    Ниже приведены примеры объявлений функций с прототипом и их вызовы из
    документации по perl.

    sub mylink ($$)          mylink $old, $new
    sub myvec ($$$)          myvec $var, $offset, 1
    sub myindex ($$;$)       myindex &getstring, "substr"
    sub mysyswrite ($$$;$)   mysyswrite $buf, 0, length($buf) - $off, $off
    sub myreverse (@)        myreverse $a, $b, $c
    sub myjoin ($@)          myjoin ":", $a, $b, $c
    sub mypop (\@)           mypop @array
    sub mysplice (\@$$@)     mysplice @array, @array, 0, @pushme
    sub mykeys (\%)          mykeys %{$hashref}
    sub myopen (*;$)         myopen HANDLE, $name
    sub mypipe (**)          mypipe READHANDLE, WRITEHANDLE
    sub mygrep (&@)          mygrep { /foo/ } $a, $b, $c
    sub myrand ($)           myrand 42
    sub mytime ()            mytime

    локальные переменные

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

    # создаем две переменные и инициализируем их
    my($lvar1,$lvar2) = (3,4); 
    # если переменная одна можно без скобок
    my $lvar=25;

    возвращаемое значение

    Возвращаемое значение указывается в операторе return.
    Если его нет, то возвращается последнее вычисленное выражение.

    Пакеты. Модули

    шаблон модуля пакета

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

    # предполагается файл Some/Modulename.pm
    package Some::Modulename;  
    
        use strict;
        use warnings;
    
        BEGIN {
            # подключаем модуль Exporter для экспорта имен
            use Exporter   ();  
            
            # объявляем переменные доступные в модуле
            # до perl 5.6 использовалась директива vars
            #  use vars qw($VERSION, @ISA, @EXPORT, @EXPORT_OK, %EXPORT_TAGS);
            our ($VERSION, @ISA, @EXPORT, @EXPORT_OK, %EXPORT_TAGS);
            
            $VERSION = 1.00; #  указываем версию
            # если используется RCS/CVS, то можно так
            # $VERSION = sprintf "%d.%03d", q$Revision: 1.1 $ =~ /(\d+)/g;
    
            # в смысле ООП данный массив определяет родительские пакеты
            # в данном случае пакет Exporter
            @ISA = qw(Exporter);
            
            # в этот массив помещаются имена, которые будут добавлены
            # в пространство имен вызывающего пакета
            # не забываем, что в qw разделителем является пробел, а не запятая
            @EXPORT = qw(&func1 &func2 &func4);
            
            %EXPORT_TAGS = ( );     # eg: TAG => [ qw!name1 name2! ],
    
            # перечисляем доступные имена пакета
            @EXPORT_OK = qw($pvar %phash &func3);
            ...
        }
        # our @EXPORT_OK;
    
        # объявляем глобальные переменные пакета
        # эти будут экспортированы
        our ($pvar, %phash);
    
        # а эти не будут экспортированы
        our (@pvar2, %phash2);
    
        # инициализируем наши переменные
        $pvar="hello world";
        ...
    
        # все локальные имена должны быть объявлены
        # до их использования функциями
    
        # локальные переменные
        # или в смысле ООП приватные члены
        my $pscalar = "";
        my %phash = ();
    
        # приватная функция вызываемая как &$priv_func    
        my $priv_func = sub {...};
    
        # объявляем функции пакета с прототипом или без
        sub func1      {...}    
        sub func2()    {...}    
        sub func3($$)  {...}    
    
        # эта не экспортируемая функция
        # но доступна для вызова
        sub func4(\%)  {...}
    
        END { ... } # код очистки 
      
        1;  # при выходе из этого модуля будет возвращена истина 

    определение модуля

    Имя пакета указывается директивой package. Далее идет содержимое пакета — до конца
    блока или файла. По умолчанию каждый модуль (файл со скриптом) относится к пакету main.

    {package Nested; # это вложенный пакет 
    ...  
    }

    таблица символов

    С каждым пакетом связана одноименная хеш-таблица символов, содержащая
    ссылки на определенные в пакете имена.

    именованные блоки

    Модуль может иметь именованные блоки специального назначения:

    • BEGIN — данный блок выполняется как только это возможно, не дожидаясь разбора
      остальной части файла. Поэтому блок используется как конструктор в ООП;
    • END — данный блок выполняется как можно позже, т.е. перед самым
      выходом интерпретатора. Поэтому блок используется как деструкторв в ООП.
    • INIT — выполняется непосредственно перед
      запуском программы;
    • CHECK — выполняется после компиляции программы.

    Если определено несколько одноименных блоков, то они выполняются последовательно, по мере
    определения.

    подключение пакетов

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

    • use — импортирует все имена из указанных пакетов, так что они доступны
      без ::. При этом предполагается, что пакет находится в файле с расширением pm,
      так что указывать имя модуля в кавычках с расширением не обязательно.
      В большинстве случаев этот способ предпочтительней, так как наличие
      модуля проверяется сразу.
    • require — делает доступными указанные пакеты. Для доступа к именам, определенным
      в этих пакетах используется ::. Когда имя модуля указывается в кавычках, все :: в имени
      пакета отображаются в разделитель директорий /.

    require Cwd;              
    $here = Cwd::getcwd(); # ок
    
    use Cwd;                  
    $here = getcwd(); # ок
    
    require Cwd;              
    $here = getcwd(); # ошибка
    
    use Module;
       #эквивалентно
    BEGIN {require Module; import Module;}   
    
    use Module ();
       #эквивалентно
    BEGIN { require Module; }

    различия our и use vars

    Переменные объявленные с помощью директивы use vars видны только
    в том пакете модуля, в котором объявлены.

    use strict;
    # объявляем переменную в пакете по умолчанию, т.е. main
    # $main::str 
    use vars qw($str); 
    $str="56\n";
    { package Test; # это вложенный пакет в нем $str не виден
      
      # ошибка компиляции $Test::str не разрешен
      #print $str;
      
      # но можно так 
      print $main::str;
    }
    
    # мы опять в пакете main, так что можно без $main::
    print $str; 

    Переменные объявленные с помощью our видны во вложенных пакетах. Сравните
    следующий пример с предыдущим.

    use strict;
    our $strmain="hello "; 
    
    { package Test;
      our $strtest="world\n"; 
      print $strmain; # можно 
      print $strtest; # можно
    } 
    
    print $strmain; # ок
    
    # ошибка компиляции 
    # print $strtest; 
     
    print $Test::strtest; # но можно так

    инсталяция модуля

    Новый модуль нужно скопировать в директорию библиотек perl. Например, в ActivePerl для
    Windows это поддиректории lib и site/lib в месте инсталляции. Если есть менеджер пакетов
    как в ActivePerl, то можно воспользоваться им (запуск в командной строке ppm).

    Переменные окружения

    Переменные окружения хранятся в отображении %ENV,
    ниже приведены основные ключи и их значения:

    • CONTENT_TYPE — тип данных, используется когда клиент отсылает присоединенное
      содержимое на сервер (например, загрузка файла);
    • CONTENT_LENGTH — размер переданных данных методом post, считать эти данные можно из
      стандартного потока ввода;
    • HTTP_COOKIE — множество кукисов в форме ключ/значение
    • HTTP_USER_AGENT — значение поля User-Agent (например, какой-нибудь веб-браузер);
    • PATH_INFO — путь для cgi скрипта;
    • QUERY_STRING — информация, посылаемая методом get;
    • REMOTE_ADDR — ip адрес удаленного хоста, запросившего скрипт;
    • REMOTE_HOST — имя удаленного хоста запросившего скрипт;
    • REQUEST_METHOD — метод, по которому был запрошен скрипт (GET или POST);
    • SCRIPT_FILENAME — имя файла скрипта с полным путем;
    • SCRIPT_NAME — имя cgi скрипта;
    • SERVER_NAME — хост или ip адрес сервера;
    • SERVER_SOFTWARE — имя и версия сервера.

    Полный набор переменных можно посмотреть следующим скриптом:

    #!/usr/bin/perl
    print "Content-type: text/html\n\n";
    foreach (sort keys %ENV) {
      print "<i>$_</i>: $ENV{$_}<br/>\n";
    }
    
    1;

    Если скрипт будет запущен локально наподобие shell скрипта,
    то cgi переменных вы не обнаружите.

    Пример DBI для MySQL

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

    Если используется ActivePerl установить DBI и драйвер для MySQL (DBD-mysql пакет) можно через
    менеджер пакетов, который запускается в командной строке ppm.
    Драйвер можно скачать отдельно и установить в ручную.

    Ниже приведен пример для DBI версии 1.609.

    use strict;
    use warnings;
    use DBI; # подключаем dbi модуль
    my $dbh; # обработчик базы данных
    my $sth; # обработчик sql запроса
    my @rows; # для сохранения выборки из нескольких записей
    my $row; # для сохранения выборки из одной записи
    
    # соединение к локальному серверу MySQL
    $dbh = DBI->connect("DBI:mysql:test", 
             "root", "root1",
             { RaiseError => 1, AutoCommit => 0 }) 
             || die "Connection error: $DBI::errstr";
    
    # соединение к удаленному серверу
    #$dbh = DBI->connect("DBI:mysql:databasename;host=remotehost.com", 
    #                    "username", "password", { RaiseError => 1 }
    #	           );
    
    # запросы без возвращаемого значения
    # можно сделать через do
    #$dbh->do("CREATE TABLE tblname (id int, str varchar(45))");
    $dbh->do("INSERT INTO tblname VALUES(1, ?)",undef, ("anystr"));
    
    
    # выборка одной записи
    $sth = $dbh->prepare("SELECT * FROM tblname WHERE id=1");
    $sth->execute();
    $row = $sth->fetchrow_hashref();
    print "row: $row->{id} \n";
    
    # выборка массива записей
    $sth = $dbh->prepare("SELECT * FROM tblname WHERE id>?");
    $sth->execute(0); # 0 значение для параметра запроса
    # массив значений столбцов всех записей
    @rows = $sth->fetchrow_array(); 
    print "rows: @rows\n";
    
    # сбрасываем обработчик запроса
    # чтобы можно было закрыть соединение
    $sth=undef; 
    
    # закрываем соединение
    $dbh->disconnect();

Для ответа в этой теме необходимо авторизоваться.