От простого к сложному
Запуск Перл - программы
Синтаксис

• Декларации (объявления)
• простое предложение
• сложные предложения
• циклы
• POD операторы
• Документирование программ

Переменные

• Контекст
• скалярные значения
• конструкторы скаляров
• конструкторы списков
• тип typeglobs

Встроенные переменные
Регулярные выражения (шаблоны)
Операторы и приоритеты

• Термы и левосторонние списковые операторы
• унарные операторы, операторы "привязки" =~ и !=
• мультипликативные операторы
• аддитивные операторы
• операторы сдвига
• именованные унарные операторы
• операторы отношений
• операторы равенства
• операторы работы с битами
• логические операторы && (AND) и || (OR)
• оператор диаппазона '..'
• условный оператор '?:'
• операторы присваивания
• оператор ',' (запятая)
• логические not, and, or, xor
• операторы ограничители строк
• операторы ввода-вывода
• слияние констант
• целочисленная арифметика

• Private переменные
• переменные типа local
• прототипы (prototypes)
• ссылка как параметр
• переопределение встроенных функций
• автозагрузка

Модули

• Таблицы имен
• конструкторы и деструкторы
• классы
• создание библиотеки
• Pragma библиотеки
• стандартные библиотеки
• CPAN

Форматы отчетов
Отладка

От простого к сложному

Пример 1. Введите в файл test1.pl следующие строки:

#!/usr/local/bin/perl
# Содержимое файла test1.pl
print "Наше Вам с кисточкой!\n";

#!/usr/local/bin/perl

# Содержимое файла test1.pl

print "Наше Вам с кисточкой!\n";

Здесь слово print - это команда "вывести". Все что в кавычках - это символы, \n - перевод строки и ';' - признак конца команды. Он обязателен. В одной строке может быть несколько команд и все они должны завершаться символом ';'. После него может быть символ '#' - это значит остаток строки считается комментарием.

Над этой строкой автору пришлось больше всего поломать голову так как в нее постоянно лезли какие то странные "hello", "hello all", "Построемся и спасемся", "Строй наше спасение" и т.д и т.п.

Если вы никогда не работали с Перл, то бъюсь на спор в 10$, что данная программа сразу у вас не заработает! Не потому что она не верна, а потому что "Нельзя объять необъятное". Сразу, потом можно, да и то частями. Сначала сделайте ваш файл test1.pl исполняемым. Для этого введите команду:

chmod +x test1.pl

which perl

Если:

perl: Command not found.

test1.pl

./test1.pl

Пример 2. Данная программа выводит на экран все ваши секреты. А именно файл /etc/passwd.

#!/usr/local/bin/perl
open(PASS, "</etc/passwd") || die "Файл не найден!";
while(<PASS>)
{
  print;
}
close(PASS);

open(PASS, "</etc/passwd") || die "Файл не найден!";

while(<PASS>)

{

  print;

}

close(PASS);

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

Все последующие примеры будут развитием этой программы и она превратится из гадкого утенка в прекрасного лебедя (не генерала).

Пример 3. Разделенеие полей.

#!/usr/local/bin/perl
open(PASS, "</etc/passwd") || die "Файл не найден!";
while(<PASS>)
{
  ($login, $pass, $uid, $gid, $name, $home_dir, $shell) = split(':');
  print "$login \t $name\n";
}
close(PASS);

($login, $pass, $uid, $gid, $name, $home_dir, $shell) = split(':');

print "$login \t $name\n";

Пример 4. Вывести имена пользователей, отсортированных по группам.

#!/usr/local/bin/perl
open(PASS, "sort -n -t : +3 -4 +0 /etc/passwd|") || die "Файл не найден!";
while(<PASS>)
{
  ($login, $pass, $uid, $gid, $name, $home_dir, $shell) = split(':');
  print "$login \t $gid \t $name\n";
}
close(PASS);

open(PASS, "sort -n -t : +3 -4 +0 /etc/passwd|") || die "Файл не найден!";

Форматированный вывод. Ну а теперь напечатаем на экране все наши данные в удобной форме.

#!/usr/local/bin/perl
open(PASS, "sort -n -t : +3 -4 +0 /etc/passwd|") || die "Файл не найден!";
while(<PASS>)
{
  ($login, $pass, $uid, $gid, $name, $home_dir, $shell) = split(':');
  write();    # Форматированный вывод данных.
  }
close(PASS);
exit 0;         # Завершение программы

############ Описание формы вывода ##################

format STDOUT =

Пользователь: ^<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
                                $name
              ^<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
                                $name
              ^<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
                                $name
----------------------------------------------------------------------
Login:@<<<<<<<<   Uid:@<<<  Gid:@<<<  Home dir:@<<<<<<<<<<<<<<<<<<<<<
      $login,         $uid,     $gid,          $home_dir
----------------------------------------------------------------------

.       # Это последняя строка программы

Пользователь: Калужский ликеро-водочный завод. Лучшие водки и
              настойки. Звонить только перед праздником Кострикову
              Анатолию т. 2-23-06,,,
----------------------------------------------------------------------
Login:uucryst     Uid:1055  Gid:66    Home dir:/var/spool/uucppublic/
----------------------------------------------------------------------


Пользователь: Торговый Дом Дилен,,,


----------------------------------------------------------------------
Login:uudilen     Uid:1075  Gid:66    Home dir:/var/spool/uucppublic
----------------------------------------------------------------------

Запуск Перл - программы

perl [ключи] файл аргументы

1. В командной строке если указан ключ '-e'
2. Содержимое файла указанного в командной строке. В первой строке можно указывать #!/usr/bin/perl для "автоматического" запуска скрипта.
3. Стандартный ввод/вывод если не указан файл или аргументы содержащие имя файла. Для передачи аргументов скрипту из стандартного потока имя файла в командной строке обозначается символом '-'.

После "обнаружения" скрипта Перл компилирует его целиком во внутреннее представление. Если обнаруживаются ошибки то выполнение прекращается. Если ошибок нет он выполняется. Если скрипт заканчивается без команд exit() или die() то по умолчанию выполняется команда exit(0) обозначающая нормальное завершение программы.

Ключи:
 

-Oцифры	Код символа-разделителя записей. По умолчанию \0.
-a	Включает режим автоматического разделения (split) переменной $_ в массив $F. Применяется с ключами -n и -p.
-c	Выполняется синтаксическая проверка скрипта и выход без запуска.
-d	Запуск в режиме интерактивной отладки.  1 p Синтаксический разбор 2 s Состояние стека 4 l Состояние стека имен 8 t Трассировка исполнения 16 o Создание оператора узла 32 c Строковое/числовое преобразование 64 p Вывод команды препроцессора для -P 128 m Распределение памяти 256 f Обработка формата 512 r Синтаксический разбор регулярных выражений 1024 x Дамп синтаксического дерева 2048 u Проверка защиты 4096 L "Утечка" памяти 8192 H Дамп хеша 16384 X Распределение scratchpad 32768 D Очистка
-Dчисло или Dсписок	Установить флаги отладки Перл. Например -d14 проследить, как Перл исполняет вашу программу.
-e команда	Выполнение скрипта из одной строки указанного в командной строке.
-F шаблон	Указывает шаблон разделения в режиме работы с ключом -a
-iрасширение	Применяется для резервной копии файла обрабатываемого оператором '<>'. Оригинал хранится в файле с тем же именем что и исходный, но с указанным расширением. Пример: perl -p -i.old -e "s/рядовой/ефрейтор/" file - Поменять все слова "рядовой" на "ефрейтор" в файле file, а оригинал записать в файле file.old
-Iдиректория	Директория includ- файлов для С препроцессора. Применяется с ключом -P по умолчанию это /usr/include и /usr/lib/perl.
-lчисло	Автоматическая обработка символа конца строки. Работает в двух случаях.  Отбрасывает последний символ читаемых строк для режимов -n и -p  Присваивает указанное значение переменной $\. Таким образом  к концу каждой строки выводимой оператором print добавляется этот символ.
-n	Зацикливает скрипт и последовательно обрабатывает файлы указанные в командной строке. Позволяет создавать команды подобные sed или awk. Операторы BEGIN и END дают возможность делать начальные и конечные установки. Содержимое файлов не выводится.
-p	То же что и -n но печатает обрабатываемые строки файлов.
-P	Предварительная обработко препроцессором языка С. Будьте внимательны и не применяйте в комментариях слова 'if', 'else' или 'define' т.к. это команды С - препроцессора.
-s	Включение режима обработки ключей командной строки запуска скрипта. Все аргументы с символом '-' в начале, считаются ключом и переменным с таким же именем присваивается значение true.
-S	Использование системной переменной PATH для поиска скрипта. Данный ключ применяется в системах не воспринимающих последовательность "#!" в начале скрипта для указания интерпретатора.
-T	Режим проверки "дыр" в защите. Обычно это нужно для программ работающих в режиме повышенной привелегии (setuid, setguid). Желательно для CGI скриптов.
-u	Принудительный дамп памяти после компиляции скрипта. Этот дамп можно потом использовать для создания исполняемого файла с помощью программы undump.
-U	Разрешение выполнять опасные операции. Например стереть директорию или выполнять явно не закрытую программу.
-v	Вывод номера версии Перл.
-w	Вывод имен переменных используемых только один раз, имен скаляров используемых до их определения, имен переопределяемых подпрограмм, ссылок на неопределенный указатели файлов, попыток записи в файлы открытых только на "чтение", употребление не коретных записей чисел, использование массивов как скаляров, рекурсия более 100 уровней.
-x директория	Режим запуска скрипта вставленного в файл содержащий обычный текст. Началом скрипта считаестся строка с символами '#!' в начале и содержащия слово perl. Концом - строка с '__END__' Указанная директория становится текущей в момент исполнения. Если необходимо читать последующие строки то это лучше делать через указатель файла DATA.

Синтаксис

Декларации (объявления)

Декларации могут использоваться в любом месте программы так же как и предложения (statements) но действуют они только в фазе компиляции программы. Обычно их помещают или в начале или в конце программы.

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

Пример:

sub test;       # Декларация подпрограммы test
$var1 = test $0; # Использование как оператора списка.

Простое предложение

Любое простое предложение может содержать single модификатор перед ';'. Существуют следующие single модификаторы:

if EXPR
unless EXPR
while EXPR
until EXPR

Модификаторы while и until вычисляются в начале предложения кроме блока do который выполняется первым.

if EXPR - модификатор "если". Предложение выполняется если EXPR возвращает true.

Пример:

$var = 1;
$var2 = 3 if $var > 0; # Результат: $var2 = 3

Пример:

$var = 1;
print $var++ while $var < 5; # Печать $var с инкрементом

until EXPR - модификатор "до ". Предложение выполняется до тех пор, пока EXPR = false

Пример:

$var = 1;
print $var++ until $var > 5; # Печать $var с инкрементом

unless EXPR - модификатор "если не". Обратный к if. Выражение выполняется есле EXPR = false.

Пример:

$var = 1;
print $var++ unless $var > 5; # Печать $var с инкрементом

Сложные предложения

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

if (EXPR) BLOCK
if (EXPR) BLOCK else BLOCK
if (EXPR) BLOCK elsif (EXPR) BLOCK ... else BLOCK

LABEL while (EXPR) BLOCK
LABEL while (EXPR) BLOCK continue BLOCK
LABEL for (EXPR; EXPR; EXPR) BLOCK
LABEL foreach VAR (LIST) BLOCK
LABEL BLOCK continue BLOCK

if (EXPR) BLOCK - вычисляется логическое выражение EXPR и если true блок выполняется.

Пример:

$var =1;
if ($var == 1)
{
  print $var,"\n";
}

if (EXPR) BLOCK else BLOCK2 - если EXPR=true выполняется BLOCK иначе BLOCK2.

Пример:

$var =2;
if ($var == 1)
{
  print "\$var = 1\n";
} else {
  print "\$var не равно 1\n";
}

if (EXPR1) BLOCK1 elsif (EXPR2) BLOCK2 ... else BLOCK - если EXPR1=true выполняется BLOCK1 иначе если EXPR2=true выполняется BLOCK2 иначе ... иначе BLOCK.

Пример:

$var = 1;
if ($var == 0)
{
  print "\$var = 0\n";
} elsif ($var == 1)
  {
    print "\$var = 1\n";
  } else {
    print "Не известное \$var\n";
  }

Циклы

Блок после continue выполняется всегда перед тем как вычисляется логическое выражение EXPR. Это подобно EXPR3 в предлжении for, поэтому в этом блоке удобно изменять счетчики и флаги цикла даже, если применяестя оператор next.

Операторы управления циклом

Пример:

M1: while ($i < 6) { ++$i; # Увеличиваем счетчик на 1 next M1 if $i < 3; # Переходим в начало если $i < 3 ++$i; # иначе увеличиваем счетчик еще раз на 1 } continue { print "$i "; # Печатаем $i }

Результат: 1 2 4 6

last - подобен оператору break в языке С. Немедленно прерывает цикл. Блок continue пропускается.

Пример:

M1:
while ($i < 6)
{
  ++$i;       # Увеличиваем счетчик на 1
  last M1 if $i > 3; # Выход из цикла если $i > 3
  ++$i;       # иначе увеличиваем счетчик еще раз на 1
} continue {
  print "$i "; # Печатаем $i
}

redo - начать новый цикл не вычисляя EXPR и не выполняя continue блок.

Пример:

M1:
while ($i < 6)
{
  ++$i;       # Увеличиваем счетчик на 1
  redo M1 if $i == 3; # Далее пропустить для $i = 3
  ++$i;       # иначе увеличиваем счетчик еще раз на 1
} continue {
  print "$i "; # Печатаем $i
}

Цикл for

LABEL for (EXPR1; EXPR2; EXPR3) BLOCK

Пример:

for ($i = 2; $i < 5; ++$i)
{
  print $i, " ";
}
print "\nПосле цикла i = $i\n";

2 3 4
После цикла i = 5

Цикл foreach

LABEL foreach VAR (LIST) BLOCK

Пример:

@месяц = ("январь","февраль","март");  # Создали массив
foreach $i (@месяц)
{
  print $i," ";       # Печать $i
}

Пример:

@месяц = ("январь","февраль","март");  # Создали массив
foreach $i (@месяц)
{
  $i = uc($i); # Перевели в верхний регистр
}
print @месяц;

Пример:

for $i (3,5,7)
{
  print "$i ";
}

Блоки и оператор switch

SWITCH:
{
  if ($i ==1 ) { .....; last SWITCH; }
  if ($i ==2 ) { .....; last SWITCH; }
  if ($i ==3 ) { .....; last SWITCH; }
  $default = 13;
}

Оператор goto

В Перл реализовано три формы goto. goto - метка, goto - выражение и goto - подпрограмма.

goto - метка выполняет непосредственный переход на указанную метку.

goto - выражение - Вычисляет имя метки и делает соответсвующий переход.

Например если мы хотим сделать переход на одну из трех меток "M1:", "M2:" или "M3:" в зависимости от значений переменной $i равной 0, 1 или 2 то это лучше сделать следующим образом:

goto ("M1", "M2", "M3")[$i];

goto подпрограмма - довольно редкий случай т.к. всегда проще и надежней вызвать подпрограмму "естественным" образом.

POD операторы. Документирование программ.

= head Набор стандартных процедур

Переменные

Имена скалярных переменных всегда начинаются с символа '$' даже когда обозначают элемент массива.

Пример:

$var1           # Простой скаляр 'var1'
$var1[0]        # Первый элемент массива 'var1'
$var1{'first'}  # Элемент с индексом 'first'

Пример:

@var1 # Все элементы массива var1 ( $var1[0], $var1[1], ... $var1[n])
@var1[1,3,10]   # Элементы $var1[1], $var1[3], $var1[10]
@var1{'first','last'} # то же что и ( $var1{'first'}, $var1{'last'} )

Пример:

%var, %key, %years

Пример:

&sub1, &test_prog, test(12)

Каждый тип переменных имеет свою область памяти поэтому $var1 и $var1[0] совершенно разные переменные, хотя $var1[0] часть массива @var1. Так же @var1 и %var1 - разные массивы переменных.

Имена переменных могут содержать любые буквенно-цифровы символы за исключением пробела и табуляции. Эти смволы используются в качестве разделителей. Большие и малые буквы различаются поэтому $var1 и $Var1 - разные переменные. В Перл по умолчанию имена меток и указателей файлов пишут большими буквами.

Контекст

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

Пример:

$var1 = <>;     # Прочитать одну строку файла
@var1 = <>;     # Прочитать все строки файла в массив @var1
$var1 = (1,2,3); # $var = 3 - количество элементов
@var1 = (1,2,3); # Создание массива @var1 с элементами 1,2,3

Скалярные значения

В Перл не существует типов "строка" или "число" или "файл" или что то еще. Это контекстно зависимый полиморфный язык для работы с текстами.

Скаляр имеет логическое значение "TRUE" (истина) если это не нулевая строка или число не равное 0.

В Перл существует два типа нулевых (null) скаляров - определенные (defined) и не определенные (undefined). Не определенное значение возвращается когда что-то не существует. Например не известная переменная, конец файла или ошибка. С помощью функции defined() вы можете заранее обнаружить подобное состояние.

Количество элементов массива так же является скаляром и начинается символами $# подобно интерпретатору csh. Фактически $#var1 - это индекс последнего элемента массива. Нужно помнить что первый элемент имеет индкес 0 поэтому количество элементов определяется как $#var1+1 . Присвоение значения $#var1 - изменит длину массива и разрушит "оставленные" значения. Присвоение значения элементу массива с индексом больше чем $#var1 - увеличит размер массива, а присвоение ему нулевого списка - обнулит.

В скалярном контексте имя массива возвращает его длину (для списка возвращается последний елемент).

Пример:

@var1 = (4, 3, 2, 1);   # Присвоение значения элементам массива
$i = @var1;             # Использование скалярного контекста
print $i;               # Печать результата 4 - кол-во элементов
print @var1;            # Списковый контекст, печать всех элементов.

Пример:

print scalar(@var1);    # Вывод длины массива а не его значений

Конструкторы скаляров

123
123.123
0.12
.12E-10
0xABCD          # Шестнадцетиричная запись
0377            # Если 0 в начале - восьмеричная
123_456_123     # Так тоже можно для удобства чтения.

'Ровняйсь, смирно!'
"Построемся и спасемся."

В хеше можно опускать кавычки если индекс не содержит пробелов.

Пример:

$var1{first} то же что и $var1{'first'}

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

Запрещается в кавычках применять зарезервированные литералы __LINE__ (номер текущей строки программы), __FILE__ (текущий файл).

Для обозначения конца программы можно применять литерал __END__. Весь последующий текст игнорируется, но его можно прочитать, используя указатель файла DATA.

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

В Перл есть возможность вставлять текст документа прямо в программу. Так называемый "here-doc" (здесь текст) метод. Обозначается символами << за которым идет слово-ограничитель.

Пример:

print <<EOF;    # Все строки до EOF - текст для печати.

Эй вы трое, идите двое сюда!

Полковник Савонькин.
EOF

Конструкторы списков

Пример:

@var1 = (1, 2, 'привет', 1.2); # Присвоить значение элементам.

$var1[0] = 1,
$var1[1] = 2,
$var1[2] = 'привет'
$var1[3] = 1.2

$var1 = (1, 2, 'привет', 1.2);

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

Пример:

@s1 = (1, 2, 3); #      Первый список
@s2 = (6, 7, 8);        # Второй
@s = (0, @s1, 4, 5, @s2, 9, 10); # Включаем списки @s1 и @s2
print @s;       # Результат: 012345678910  - значения без пробелов.

Пример:

print ('январь','февраль','март')[1];

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

Пример:

($a, $b, $c) = (1, 2, 3); # $a = 1, $b = 2, $c = 3

Пример:

$x = (($a, $b, $c) = (1,2));  # Результат $x=2

Пример:

%дни_месяца = ('январь', 31, 'февраль', 30);

Для удобства записи можно использовать выражение с => .

Пример:

%дни_месяца = (
               январь => 31,
               февраль => 30,
);

Тип typeglobs

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

sub new_sub
{ local *IN; # Ссылка на файл
open (IN, "test") || return undef; #Открыть файл. Возврат при ошибке.
......... 
return;
}

Встроенные переменные Перл

use English;

use FileHandle;

метод указатель выражение

указатель -> метод(выражение)

$_
$ARG

$цифра

$&
$MATCH

$`

$'
$POSTMATCH

$+
$LAST_PAREN_MATCH

$*
$MULTILINE_MATCHING

$.
$INPUT_LINE_NUMBER
$NR

$/
$RS
$INPUT_RECORD_SEPARATOR

$|
$OUTPUT_AUTOFLUSH

$,
$OFS
$OUTPUT_FIELD_SEPARATOR

$\
$ORS
$OUTPUT_RECORD_SEPARATOR

$"
$LIST_SEPARATOR

$;
$SUBSEP
$SUBSCRIPT_SEPARATOR

$#
$OFMT

$%
$FORMAT_PAGE_NUMBER

$=
$FORMAT_LINES_PER_PAGE

$-
$FORMAT_LINES_LEFT

$~
$FORMAT_NAME

$^
$FORMAT_TOP_NAME

$:
$FORMAT_LINE_BREAK_CHARACTERS

$^L
$FORMAT_FORMFEED

$^A
$ACCUMULATOR

$?
$CHILD_ERROR

$!
$ERRNO
$OS_ERROR

$@
$EVAL_ERROR

$$
$PID
$PROCESS_ID

$<
$UID
$REAL_USER_ID

$>
$EUID
$EFFECTIVE_USER_ID

$(
$GID
$REAL_GROUP_ID

$)
$EGID
$EFFECTIVE_GROUP_ID

$O
$PROGRAM_NAME

$[

$]
$PERL_VERSION

$^D
$DEBUGGING

$^F
$SYSTEM_FD_MAX

$^I
$INPLACE_EDIT

$^P
$PERLDB

$^T
$BASETIME

$^W
$WARNING

$^X
$EXECUTABLE_NAME

$ARGV

@ARGV

@INC

%INC

$ENV{выражение}

$SIG{выражение}

Регулярные выражения (шаблоны)

Как правило все эти операторы имеют схожие опции такие как:

i - не различать строчные и заглавные буквы
m - считать строку многострочной
s - однострочная строка
x - расширенный синтаксис ( использование пробелов и комментариев)

Обычно все эти опции обозначают как '/x'. Их можно использовать даже внутри шаблонов использую новую конструкцию (?...)

Регулярные выражения или шаблоны (pattern) то же самое что и regexp процедуры в Юниксе. Выражения и синтаксис заимствован из свободно распространяемых процедур V8 Генри Спенсера (Henry Spencer) там же они подробно и описаны.

В шаблонах используются следующие метасимволы (символы обозначающие группы других символов) часто называемых egrep - стандартом:

\ - считать следующий метасимвол как обычный символ
^ - начало строки
. - один произвольный символ. Кроме '\n' - конец строки
$ - конец строки
| - альтернатива (или)
() - группировка
[] - класс символов

Метасимволы имеют модификаторы (пишутся после метасимвола):

* - повторяется 0 или большее число раз
+ - повторяется 1 или большее число раз
? - 1 или 0 раз
{n} - точно n раз
{n,} - по меньшей мере раз
{n,m} - не менше n, но и не больше m

Во все других случаях фигурные скобки считаются обычными (регулярными) символами. Таким образом '*' эквивалентна {0,} , '+' - {1,} и '?' - {0,1}. n и m не могут быть больше 65536.

По умолчанию действие метасимволов "жадно" (greedy). Совпадение распространяется столько раз сколько возможно не учитывая результат действия следуюющих метасимволов. Если вы хотите "уменьшить их аппетит" то используйте символ '?'. Это не изменяет значение метасимволов просто уменьшает распространение. Таким образом:

*? - станет 0 и более
+? - 1 и более
?? - 0 или 1 раз
{n}? - точно n раз
{n,}? - не меньше n раз
{n,m}? - больше или равно n и меньше m раз

Шаблоны работают так же, как и двойные кавычки поэтому в них можно использовать `\` - символы (бакслэш-символы):

\t - символ табуляции
\n - новая строка
\r - перевод каретки
\а - перевол формата
\v - вертикальная табуляция
\a - звонок
\e - escape
\033 - восьмеричная запись символа
\x1A - шестнадцатеричная
\c[ - control символ
\l - нижний регистр следующего символа
\u - верхний регистр следующего символа
\L - все символы в нижнем регистре до \E
\U - в верхнем регистре до \E
\E - ограничитель смены регистра
\Q - отмена действия как метасимвола

Дополнительно в Перл добавлены следующие метасимволы:

\w - алфавитно-цифровой или '_' символ
\W - не алфавитно-цифровой или '_' символ
\s - один пробел
\S - один не пробел
\d - одна цифра
\D - одна не цифра

Обратите внимание что все это "один" символ. Для обозначения последовательности применяйте модификаторы. Так:

\w+ - слово
\d+ - целое число
[+-]?\d+ - целое со знаком
[+-]?\d+\.?\d* - число с точкой

Кроме того существуют мнимые метасимволы. Обозначающие не существующие символы в месте смены значения. Такие как:

\b - граница слова
\B - не граница слова
\A - начало строки
\Z - конец строки
\G - конец действия m//g

Граница слова (\b) - это мнимая точка между символами \w и \W. Внутри класса символов '\b' обозначает символ backspace (стирания). Метасимволы \A и \Z - аналогичны '^' и '$' но если началостроки '^' и конец строки '$' действуют для каждой строки в многосторочной строке, то \A и \Z обозначают начало и конец всей многосторчной строки.

Если внутри шаблона применяется группировка (круглые скобки) то номер подстроки группы обозначается как '\цифра'.

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

$+ - обозначает последнее совпадение
$& - все совпадение
$` - все до совпадения
$' - все после совпадения

Пример:

$s = "Один 1 два 2 и три 3";
if ($s =~ /(\d+)\D+(\d+)/)
{
  print "$1\n";   # Результат '1'
  print "$2\n";   # '2'
  print "$+\n";   # '2'
  print "$&\n";   # '1 два 2'
  print "$`\n";   # 'Один '
  print "$'\n";   # ' и три 3'
}

(?#комментарий) - комментарий в теле шаблона.
(?:шаблон) - группировка как и '( )' но без обратной ссылки
(?=шаблон) - "заглядывание" вперед.

Например /\w+(?=\t)/ соответствует слову, за которым идет табуляция, но символ '\t' не включается в результат.

Пример:

$s = "1+2-3*4";
if ($s =~ /(\d)(?=-)/)  # Наити цифру за которой стоит '-'
{
  print "$1\n";   # Результат '2'
} else {
  print "ошибка поиска\n";
}

Пример:

$s = "1+2-3*4";
if ($s =~ /(\d)(?!\+)/) # Наити цифру за которой не стоит '+'
{
  print "$1\n";   # Результат '2'
} else {
  print "ошибка поиска\n";
}

Правила регулярного выражения. (regex)

1. Любой символ обозначает себя самого если это не метасимвол. Если вам нужно отменить действие метасимвола то поставьте перед ним '\'.
2. Строка символов обозначает строку этих символов.
3. Множество возможных символов (класс) заключается в квадратные скобки '[]' это значит что в данном месте может стоять один из указанных в скобках символ. Если первый символ в скобках это '^' - значит не один из указанных символов не может стоять в данном месте выражения. Внутри класса можно употреблять символ '-' обозначающий диаппазон символов. Например a-z один из малых букв латинского алфавита, 0-9 - цифра и т.д.
4. Все символы, включая специальные можно обозначать с помощью '\' как в языке С.
5. Альтернативные последовательности разделяются символом '|' Заметьте, что внутри квадратных скобок это обычный символ.
6. Внутри регулярного выражения можно указыват "подшаблоны", заключая их в крунлые скобки и ссылаться на них как '\номер' Первая скобка обозначается как '\1'.

Операторы и приоритеты

Термы и левосторонние списковые операторы

Если после любого спикового оператора ( print(), и т.д.) или унарного оператора (chdir(), и т.д.) следует левая круглая скобка, то операторы внутри скобок имеют наивысший приоритет. Так же как и обычные функции.

Если скобки отсутсвуют то приоритет списковых операторов или наивысший или наименьший в отношении операторов справа или слева от него.

Например:

@i = ('a ','b ', print 'c ', 'd ');
print "\n",@i,"\n";

c d
a b 1

Оператор '->'

Операторы ++ (инкремент) и -- (декремент)

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

Пример:

print ++($i = "09");    # Результат "10"
print ++($i = "a9");    # "b0"
print ++($i = "az");    # "ba"
print ++($i = "aZ");    # "bA"

Оператор ** (возведение в степень)

print 4**2      # Результат 16
print -4**2     # Результат -16 т.е. -(4**2)

Унарные операторы

Операторы "привязки" =~ и !=

Мультипликативные операторы

В скалярном контексте возвращает строку левой части повторенную величиной указанной в правой части. В списковом контексте, если в левой части список в круглых скобках - повторенный список.

Пример:

print '*' x 5;  # Результат '*****'
print (1,2) x 3; # Результат 121212

Аддитивные операторы

Операторы сдвига

'>>' - сдвигает побитно вправо значение выражения в левой части на количество бит указанное в правой.

Именованные унарные операторы

Операторы отношений

Операторы равенства

Операторы работы с битами

Логические операторы && (AND) и || (OR)

Отличие от подобных операторов в С заключается в том, что в С возращаемое значение либо 0 либо 1. Тогда как в Перл возвращается результат выражения.

Оператор диаппазона '..'

Пример:

for $i (1..4)
  {
    print "$i ";
  }

В скалярном контексте результат - логическое значение. Каждая '..' операция устанавливает свое собственное состояние. Это false до тех пор пока левый операнд false. Как только левый операнд стал true результат - true до тех пока правый true, после чего результат опять - false. Если вы не хотите проверять правый операнд то используйте оператор '...'.

Правый операнд не вычисляется пока результат false и левый операнд не вычисляется пока пока результат true. Приоритетность оператора '..' немного ниже чем '&&' и '||'. Возвращаемое значение если flase - нулевая строка, если true - порядковый номер начиная с 1. Порядковый номер обнуляется для каждого нового диаппазона. Последний порядковый номер добавляется строкой "E0" которая не изменяет его значение но позволяет фиксировать последнее значение.

Пример:

@алфавит = ('a'..'z'); # Массив малых букв латинского алфавита
@цифры = (0..9);       # Массив цифр

Условный оператор '?:'

Пример:

$i = 1;
$i > 1 ? print "больше" : print "меньше";

Операторы присваивания

Вся эта группа операторов подобна операторам С т.е.

$i += 2;

$i = $i + 2;

**=
+=      -=      .=
*=      /=      %=      x=
&=      |=      ^=
<<=>>=
&&=     ||=

Оператор ',' (запятая)

Оператор логическое not (орицание)

Оператор логическое and (И)

Логическое or (ИЛИ)

Логическое xor (исключающее ИЛИ)

С операторы, отсутсвующие в Перл

Операторы ограничители строк

По умолчанию  Полное  Функция     Интерполяция
  ----------  ------  ------------    ----
      ''      q{}     Literal         нет
      ""      qq{}    Литерал         да
      ``      qx{}    Команда         да
              qw{}    Список слов     нет
      //      m{}     Шаблон          да
              s{}{}   Подстановка     да
              tr{}{}  Трансляция      нет

Данные последовательности символов имеют специальное значение:
 

\t	символ табуляции
\n	символ новой строки
\r	возврат
\f	перевод формата
\v	вертикальная табуляция
\b	backspace (забой)
\a	звонок
\e	escape
\034	восьмеричный символ
\x1a	шестьнадцатеричный символ
\c[	символ управления
\l	нижний регистр следующего символа
\u	верхний регистр следующего символа
\L	нижний регистр для всех символов до \E
\U	верхний регистр для всех символов до \E
\E	ограничитель смены регистра
\Q	отмена действия метасимволов до \E

Шаблоны интерполируются как регулярные выражения. Это выполняется вторым проходом после интерполяции переменных поэтому в шаблоны можно вставлять переменные. Для отмены интерполяции используйте '\Q'. Если вы применяете вложенные ограничители то внутренние ограничители работать не будут.

?PATERN?

m/PATERN/gimosx
/PATERN/gimosx

Опции:

g - Глобальный поиск. Поиск всех вхождений.
i - Сравнение не зависит от регистра (верхний или нижний)
m - Строка многострочна
o - однопроходная компиляция
s - однострочная строка
x - используеются расширенные регулярные выражения

Если '/' - ограничитель то начальное 'm' можно опустить. С помощью него в качестве ограничителя может быть любой символ кроме пробела.

PATTERN может содержать переменные которые будут интерполироваться (перекомпилироваться) каждый раз в момент вычисления. Переменные $) и $| не интерполируются. Если вы хотите что бы такой шаблон интерполировался один раз - добавьте /o. Это необходимо делать в циклах поиска для увеличения быстродействия однако если вы измените значение переменной Перл этого даже не заметит.

Если PATERN - нулевая строка то используется последнее регулярное выражение.

В скалярном контексте возвращается список элементы которого результаты выполнения выражений в скобках патерна ($1, $2, $3...). Обратите внимание что первый елемент $1.

Пример:

$a = "/usr/local/perl/perl.bin"; # Анализируемая строка

Решение: Самый простой способ воспользоваться split('\/') но в качестве примера используем скобки.

@dirs =~ m[/(\w*)/(\w*)/(\w*)/(\w*)]

В результате @dirs равен ('usr', 'local', 'perl')

q/строка/
'строка'

Пример:

print q#Привет.#;       # Результат Привет.
print 'O\'K';           # O'K

qq/строка/
"строка"

Пример:

$var = 13;
print "\$var = $var";

qx/строка/
`строка`

Пример:

print `date`;

qw/строка/

Пример:

print qw/Построемся и спасемся!/; # ('Построемся','и','спасемся!')

Часто применяется как:

use POSIX qw( setlocale localeconv )
@EXPORT = qw( proc1 var );

s/шаблон/подстрока/egimosx

Если строка в которой ведестя поиск не указана (операторы =~ или != ) то используется переменная $_ .

Если в качестве раделителя '/' исрользовать одинарную кавычку (') то интерполяции не будет иначе можно применять переменные в шаблоне или подстроке.

Опции:
e - Расмматривать правую часть как выражение
g - Глобальный поиск
i - Без различия регистра букв
m - многосточная переменная
o - компилировать шаблон один раз
s - однострочная переменная
x - расширенное регулярное выражение

Разделитель '/' можно заменить на любой алфавитно-цифровой символ кроме пробела.

Пример:

$var = "12345"; # исходная строка
$var =~ s/1/0/; # Заменить '1' на '0'. Результат 02345
$var =~ s(5)(.); # Заменить '5' на '.' Результат 0234.

$var =~ s/\d*/каламбур/; Заменить все цифры. Результат 'каламбур.'
$var =~ s/а/о/g; # Заменить все 'а' на 'о'. Результат 'коломбур.'
$var = "12 34"; # Новое значение
$var =~ s/(\d\d) (\d\d)/$2 $1/; # Поменять местами числа.
                                # Результат '34 12'.

tr/таблица1/таблица2/cds
y/таблица1/таблица2/cds

Опции: c - дополнение "таблица1"
d - стереть найденные но не замененные символы
s - "сжать" повторяющиеся замененные символы.

Если указана опция /d таблица2 всегда интерпретируется как положено. Другими словами если таблица2 короче чем таблица1 то символ из таблицы1 интерпретируется всегда. Если таблица2 - null то все символы строки остаются не изменненные. Это удобно для подсчета количества сиволов в строке определенного класса или для сжатия повторяющихся символов например пробелов.

Пример:

$s = "hello";   # Исходная строка
$s =~ tr/a-z/A-Z/;      # Заменить малые буквы на большие. Результат
                        # 'HELLO'
$s = 'Hel....lo';
$s =~ tr/a-zA-z/_/c;    # Заменить все не буквы на '_'
                        # Результат 'Hel____lo'
$s =~ tr/_/ /s;         # Заменить '_' на ' ' и сжать. 
                        # Результат 'Hel lo'
$s =~ tr/a-zA-Z /a-zA-Z/d; # Удалить все не буквы. Результат 'Hello'

Операторы ввода-вывода

Следующая команда ввода вывода выглядит как '<файл>'. Вычисление <файл> приводит к чтению строки из файла. Обратите внимание что 'файл' здесь не имя файла а указатель файла который создается функцией open(). В скалярном контексте читается одна строка вместе с символом '\n' - перевода строки, а в списковом весь файл читается в список элементы которого суть строки файла.

В случае обнаружения конца файла результат оператора не определен и воспринимается как false. Если не указана переменная результата то по умолчанию это $_. Указатель файла по умолчанию STDIN - стандартный ввод.

Пример:

while(<>) { print; }; # Прочитать и вывести весь файл STDIN

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

Пример:

while(<*.pl>) { print;}; # То же что и ls *.pl
@files = <*>;   # Массив @files содержит имена файлов в директории

Слияние констант

Целочисленная арифметика

use integer;

no integer;

Встроенные функции

Аргумент унарного оператора воспринимается обычно в скалярном контексте а спискового как в скалярном так и списковом причем скалярные аргументы идут первыми. В дальнешем списковые аргументы мы будем обозначать словом 'LIST' это значит что функция имеет список аргументов разделенных запятой. Аргументы функций можно заключать в круглые скобки и таким образом обозначать что "это функция" и приоритет не имеет значения иначе это списковый или унарный оператор с определенным фиксированным приоритетом. Пробел после имени функции и скобкой значения не имеет. Поэтому будьте внимательны!

Пример:

print 1 + 2 + 3; # результат 6
print(1+2)+3;   # результат 3
print (1+2)+3;  # опять 3
print (1+2+3);  # 6

Запомните правило:

Не существует общего правила преобразования списка в скаляр!

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

Оператор '-X'

-X указатель файла
-X выражение
-X

Результат 1 если true и '' если false или неопределенное значение если файл не найден. Несмотря на странный вид это унарный оператор с соответсвующим приоритетом. Аргумент можно заключать в круглые скобки. 'X' имеет следующие значения:

-r  Файл разрешен на чтение эффективным uid/gid
-w  на запись -//-
-x  исполнение -//-
-o  принадлежит эффективному uid

-R  Файл разрешен на чтение реальным uid/gid
-W  на запись -//-
-X  исполнение -//-
-O  принадлежит реальному uid

-e  файл существует
-z  пустой
-s  не пустой

-f  обычный текст
-d  директория
-l  символическая ссылка
-p  pipes (конвейер)
-S  socket (гнездо)
-b  специальное блочное устройство
-c  -//- символьное -//-
-t  указатель на уст-во tty

-u  установлен бит setuid
-g  -//- setgid
-k  -//- sticky

-T  текстовой файл
-B  двоичный

-M  "возраст" файла в днях на момент старта скрипта
-A  дней с последнего чтения
-C  дней с последней модификации inode

abs выражение

accept NEWSOCKET, GENERICSOCKET

alarm секунды

atan2 Y, X

bind сокет, имя

binmode файл

bless ссылка, класс
bless ссылка

caller выражение
caller

Если указано выражение то возвращается список:

($package, $filename, $line, $subroutine, $hasargs, $wantargs)

$subroutine - имя подпрограммы
$hasargs - имеющиеся аргументы
$wantargs - необходимые аргументы

chdir выражение

chmod список

Пример: chmod 0666 'f1', 'f2', 'f3';

chomp переменная
chomp список
chomp

chop переменная
chop список
chop

chown список

chr число

chroot директория

close файл

closedir директория

connect сокет, имя

cos выражение

crypt текст, salt

dbmclose хеш

dbmopen хеш, база, режим

defined выражение

delete выражение

die список

do BLOCK

do подпрограмма

do выражение

dump метка

each хеш

eof файл
eof()
eof

eval выражение
eval блок

Ворзвращается результат последнего оператора в блоке или значение оператора return. Если обнаружится синтаксическая ошибка или выполнится оператор die возвращается не определенное значение а переменная $@ содержит сообщение об ошибке. Если ошибки не было то $@ содержит нулевую строку. При отсутсвии аргумента берется значение переменной $_.

exec список

exists выражение

exit выражение

exp выражение

fcntl файл, функция, скаляр

fileno файл

flock файл, операция

fock

format

formline формат, список

getc файл
getc

getlogin

getpeername сокет

getpgrp PID

getppid

getpriority WHICH, WHO

getpwnam NAME
getgrnam NAME
gethostbyname NAME
getnamebyname NAME
getprotobyname NAME
getpwuid UID
getgrid GID
getservbyname NAME, PROTO
gethostbyaddr ADDR, ADDRTYPE
getnetbyaddr ADDR, ADDRTYPE
getprotobynumber NUMBER
getservbyport PORT, PROTO
getpwent
gethostent
getnetent
getprotoent
getservent
setpwent
setgrent
sethostent STAYOPEN
setnetent STAYOPEN
setprotoent STAYOPEN
setservent STAYOPEN
endpwent
endgrent
endhostent
endnetent
endprotoent
endservent

($name, $passwd, $uid, $gid, $quota, $comment, $gcos, $dir, $shell) = getpw*
($name, $passwd, $gid, $members) = getgr*
($name, $aliases, $addrtype, $length, @addrs) = gethost*
($name, $aliases, $addrtype, $net) = getnet*
($name, $aliases, $proto) = getproto*
($name, $aliases, $port, $proto) = getserv*

Элемент $members в вызове getgr содержит разделенные пробелом имена членов группы.

@addrs содержит IP адреса компьютеров в сети Интернет в упакованном виде. Для распаковки применяйте: ($a, $b, $c, $d) = unpack('C4',$addr[0]);

getsockname сокет

getsockopt сокит, уровень, опция

glob выражение

gmtime выражение

($sec,$min,$hour,$mday,$mon,$year,$wday,$yday,$isdst)=gmtime(time);

goto метка
goto выражение
goto &подпрограмма

Например:

goto ('метка1', 'метка2', 'метка3')[$i];

Третья форма (goto &подпрограмма) довольно "хитрый" метод подмены имени вызываемой подпрограммы именем текущей. Это используется в методе автозагрузки когда нужно запустить другую процедуру но под именем текущей как-будто та была вызвана раньше.

grep блок, список
grep выражение, список

hex выражение

import

index строка, подстрока, позиция
index строка, подстрока

int выражение

ioctl FILEHANDLE, FUNCTION, SCALAR

join выражение, список

keys хеш

kill список

last метка
last

lc выражение

lcfirst выражение

length выражение

link OLDFILE, NEWFILE

listen SOCKET, QUEUESIZE

local список

localtime выражение

($sec,$min,$hour,$mday,$mon,$year,$wday,$yday,$isdst)=localtime(time);

log выражение

lstat файл
lstat выражение

m//

map блок, список
map выражение, список

mkdir директория, права

msgctl ID, CMD, ARG

msgget KEY, FLAGS

msgsnd ID, MSG, FLAGS

msgrcv ID, VAR, SIZE, TYPE, FLAGS

my список

next метка
next

no Module список

oct выражение

open файл,выражение
open файл

Если имя файла начинается с символа '|' то имя считается системной командой на вход которой выводятся данные (поток). Имя '-' - стандартный вход (STDIN), '>-' - стандартный вывод (STDOUT). Функция возвращает true при успехе и false - неудаче.

Если имя (выражение) начинается с символов ">&" то остаток имени считается именем указателя файла который окрывается повторно. Символ '&' может стоять после '<', '>>', '+>', '+>>' и '+<'. Режим повторного открытия должен соответсвовать первому. Выражение вида "<&=N" где N -число, эквивалентно системному вызову fdopen().

Если имя "|-" или "-|" то происходит "расщепление" (fork) процесса на потомка и родителя. При этом возвращается номер процесса потомка (PID) внутри родительского процесса и 0 - внутри потомка. При этом запись/чтение в файл родительским процессом воспринимается как чтение/запись потомком. Для потомка это стандартный ввод/вывод. Родительский процесс ждет завершения потомка после закрытия потока и получает код завершения в переменной $?.

Имя файла не должно содержать пробелов как в начале так и в конце.

opendir указатель, выражение

ord выражение

pack шаблон, список

A - текстовая строка, добавляется пробелами.
a - текстовая строка, добавляется 0 символом.
b - битовая строка (возрастающая нумерация бит)
B - битовая строка (убывающая нумерация бит)
h - шестнадцатеричная строка ( младший байт - первый)
H - шестнадцатеричная строка (старший байт первый)
c - символ со знаком
C - символ без знака.
s - короткое целое (один байт) со знаком.
S - короткое целое без знака.
i - целое (два байта) со знаком.
I - целое без знака.
l - длинное целое (4 байта) со знаком.
L - длинное целое без знака.
n - короткое в "сетевом" формате
N - длинное в "сетевом" формате.
v - короткое в "VAX" формате.
V - длинное в "VAX" формате.
f - single float.
F - double float.
p - указатель на строку ограниченную 0.
P - указатель на структуру с фиксированной длиной.
u - упаковка uuencode.
x - нуль-байт
X - резервный байт.
@ - заполнить нулями позицию.

За каждой буквой может стоять число означающее количество повторов. Для всех типов за исключением 'a', 'A', 'b', 'B', 'h' и 'H', упаковывается максимально возможное количество значений из списка. Символ '*' после типа означает использовать оставшиеся параметры. Тип 'a' и 'A' использует только одно значение из списка и добавляет остаток поля либо нуль-символами либо пробелами (при распаковке по типу 'A' пробелы и нули отбрасываются, а по 'a' - нет). Типы 'b' и 'B' упаковывают строку в указанное число бит. Так же как и 'h' и 'H' в число ниблов (байт).

'P' - упаковывает указатель на структуру с указанной длиной. Числа с плавающей запятой (floats и double) записываются в стандартном для каждой машины формате и могут быть разными для разных типов машин. Заметьте, что Перл всегда использует двойную точность (double) поэтому упаковка и распаковка по типу 'f' приведет к потере точности. Шаблоны для распаковки и упаковки совершенно одинаковы.

Примеры:

print(pack("ccc",65,66,67)); # Результат ABC
print(pack("A4A3","ab","cdefg")); # "ab  cde"
print(pack("a4a3","ab","cdefg")); # "ab\0\0cde"

pipe READHANDLE, WRITEHANDLE

pop массив

pos скаляр

print файл список
print список
print

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

printf файл список
printf список

push массив, список

q/строка/
qq/строка/
qx/строка/
qw/строка/

quotemeta выражение

rand выражение
rand

read файл, скаляр, длина, смещение
read файл, скаляр, длина

readdir директория

readlink выражение

recv SOCKIT, SCALAR, LEN, FLAGS

redo метка
redo

ref выражение

REF, SCALAR, ARRAY, HASH, CODE, GLOB

Если аргумент - ссылка на класс то возвращается имя класса. Функция ref() аналогична функции typeof().

rename старое_имя, новое_имя_файла

require выражение
require

Если расширение имени файла отсутсвует то по умолчанию принимается ".pm" В данной функции можно указывать путь расположения файла, а если библиотека расположена в стандартной системной области Перл то вместо require предпочтительней использовать use().

reset выражение
reset

Все переменные и массива начинающиеся с этих символов обнуляются. Если выражение отсутсвует то обнуляестя поиск ?шаблон? для повторного поиска. Сбрасываются только переменные текущего модуля.

Пример:

reset 'a';      # очистить все переменные начинающиеся
                # буквой 'a'
reset 'a-z'     # все переменные с малых букв.

return список

reverse список

rewindir директрия

rindex строка, подстрока, позиция
rindex строка, подстрока

rmdir директория

s///

scalar выражение

seek файл, позиция, отсчет

seekdir директория, позиция

select файл
select

select RBITS, WBITS, EBITS, TIMEOUT

semctl ID, SEMNUM, CMD, ARG

semget KEY, NSEMS, FLAGS

semop KEY, OPSTRING

send SOCKET, MSG, FLAGS, TO
send SOCKET, MSG, FLAGS

setpgrp PID, PGRP

setpriority WHICH, WHO, PRIORITY

setsockopt SOCKET, LEVEL, OPTNAME, OPTVAL

shift массив
shift

shmctl ID, CMD, ARG

shmget KEY, SIZE, FLAGS

shmread ID, VAR, POS, SIZE
shmread ID, STRING, POS, SIZE

shutdown SOCKET, HOW

sin выражение

sleep выражение
sleep

socket SOCKET, DOMAIN, TYPE, PROTOCOL

socketpair SOCKET1, SOCKET2, DOMAIN, TYPE, PROTOCOL

sort подпрограмма список
sort блок список
sort список

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

splice массив, смещение, длина, список
splice массив, смещение, длина
splice массив, смещение

split /шаблон/, выражение, предел
split /шаблон/, выражение
split /шаблон/
split

Если выражение отсутсвует то обрабатывается содержимое переменной $_. Если шаблон отсутсвует то разделителем является пробел.

Все что подходит по шаблону считается разделителем. Если указан предел то это максимальное число разделений. Отрицательное значение предела воспринимается как неограниченно большой предел.

Если пустая строка походит под шаблон разделителя то исходное значение разделяется по символьно.

Предел удобно использовать для частичного разделения строки.

Пример:

($a, $b, $остаток) = split(/ /, "Один Два Три Четыре",3);

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

Пример:

@a = split(/([,.])/, "Один,Два.Три");

sprintf формат, список

sqrt выражение

srand выражение

stat файл
stat выражение

($dev,$ino,$mode,$nlink,$uid,$gid,$rdev,$size,$atime,$mtime,$ctime,
$blksize,$blocks) = stat($filename);

Если указан аргумент '_' то возвращается результат предыдущего вызова stat().

study скаляр
study

Функция работает следующим образом:
Для указанного скаляра (если аргумент отсутсвует берется значение переменной $_) строится список указателей на каждый символ строки. Затем когда начинается поиск первыми просматриваются символы которые наиболее редко встречаются в английском языке.

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

substr выражение, смещение, длина
substr выражение, смещение

symlink старый_файл, новый_файл

syscall список

sysread файл, скаляр, длина, смещение
sysread файл, скаляр, длина

system список

syswrite файл, скаляр, длина, смещение
syswrite файл, скаляр, длина

tell файл
tell

telldir директория

tie переменная, класс, список

Для создания объекта ассоциативного типа необходимо определение следующих методов:

TIEHASH classname, LIST
DESTROY this
FETCH this, key
STORE this, key, value
DELETE this, key
EXISTS this, key
FIRSTKEY this
NEXTKEY this, lastkey

TIEHASH classname, LIST
DESTROY this
FETCH this, key
STORE this, key, value
[others TBD]

TIEHASH classname, LIST
DESTROY this
FETCH this, key
STORE this, key, value

time

times

($user, $system, $cuser, $csystem) = times;

tr///

truncate файл, длина
truncate выражение, длина

uc выражение

ucfirst выражение

umask выражение
umask

undef выражение
undef

unlink список

unpack шаблон, выражение

Символ '%' в шаблоне означает что вы хотите получить вместо значения его контрольную сумму. По умолчанию 16 битовую.

untie переменная

unshift массив, список

use модуль список
use модуль

BEGIN { require модуль; import модуль список; }

utime список

values хеш

vec выражение, смещение, бит

wait

waitpid PID, FLAGS

wantarray

warn список

write файл
write выражение
write

По умолчанию имя формата заголовка листа состоит из имени указателя файла и добавленной строки "_TOP". Динамически это млжно делать присваивая формат переменной $^. Количество оставшихся строк листа содержится в переменной $- и если присвоить ей 0 то произойдет смена листа. Подробно описание форматов смотри в главе "Форматы".

y///

Подпрограммы

sub имя;             # Только декларация. Определение ниже.
sub имя (прототипы); # То же но с декларацией параметров.
sub имя блок;        # Декларация и определение.
sub имя (прототипы) блок; # То же, но с парамметрами.

$переменная = sub блок;

use модуль qw(подпрограмма1 подпрограмма2);

имя(список параметров); # символ '&' можно не указывать.
имя список;     # Если подпрогрмма уже декларирована.
&имя;           # Параметры в @_

Возвращаемое значение подпрограммы - результат последнего оператора. Это может быть как скаляр так и массив. Можно принудительно возвращать результат используя функцию return().

Подпрограмму можно вызвать используя префикс '&' перед именем подпрограммы. Если подпрограмма предварительно продекларирована, то префикс и скобки можно опустить.

Private переменные

my() декларирует private переменные в пределах текущей подпрограммы, блока, функции eval() или do/require/use файлов. Private переменные аналогичны auto переменным в С.

Пример:

# Программа вычисления факториала.
print fact(3);  # вычислить факториал 3*2*1
sub fact        # Определяем подпрограмму.
{ my $m;                # private переменная но не local !
  $m = $_[0];
  return 1 if $m <= 1;
  return($m * fact($m -1));
}

my(список) = выражение;

my($m) = $_[0];

Переменные типа local

Прототипы (prototypes)

Здесь:
 

\'символ'	параметр с типом 'символ'
'@' или '%'	все оставшиеся параметры как список
'$'	скаляр
'&'	безымянная подпрограмма
'*'	ссылка на таблицу имен
';'	разграничитель обязательных и не обязательных параметров

Ссылка как параметр

Для скаляров употряблять '*' не имеет смысла т.к. они и так передаются ссылкой и вы можете изменять значение параметра изменяя например переменную $_[0].

Переопределение встроенных функций

use subs 'функция1', 'функция2' ....;

Автозагрузка

Модули (packages)

packages имя_модуля;

Например:

$main::var1 - переменная в головном модуле
::var1 - то же самое. Имя main можно опускать
$модуль1::var1 - переменная в модуле 'модуль1'
$модуль1::модуль2::var1 - Модуль2 содержится в модуле 1

Кроме этого имена STDIN, STDOUT, STDERR, ARGV, ARGVOUT, ENV, INC и SIG так же хранятся в головном модуле.

Таблицы имен

Например:

*pi = \3.14159;

Конструкторы и деструкторы

Конструктор BEGIN выполняется сразу как только возможно, т.е. как только он определен даже не завершая дальнейший разбор программы. Можно указать несколько блоков BEGIN. Они будут выполняться один за другим в порядке определения.

Деструктор END выполняется последним как только возможно, т.е. при завершении работы интерпрератора. Можно указать несолько блоков END при этом они будут выполняться в обратном определению порядке.

Классы

Создание библиотеки

package имя_модуля;  # Такое же как и имя этого файла без
                     # расширения '.pm'
require Exporter;    # Обязательная строка для экспорта имен
@ISA = qw(Exporter); # -//-
@EXPORT = qw(func1 func2) # Перечисляем имена функций.
                          # Внимание ! нет запятой!
@EXPORT_OK = qw( $переменная @массив );  # Указать публичные
                # переменные, массивы и т.д. если необходимо
{  # Начало блока модуля
..... 
sub func1
........
sub func2
........
1;
}

В головной программе вы указываете:

use имя_модуля;

Стандартные Перл библиотеки

Pragma библиототеки

use имя;

no имя;

В стандартный набор входят следующие pragma:
 

diagnostics	Включить режим расширенной диагностики
integer	Использовать целочисленную арифметику
less	Режим минимальной загрузки компилятора
overload	Режим переопределения операторов
sigtrap	Режим слежения за прерываниями
strict	Режим ограниченного использования "опасных" операторов
subs	Режим обязательного декларирования подпрограмм

Стандартные библиотеки

Подробное описание каждой библиотеки записано в самом файле.

CPAN

Форматы отчетов

С помощью оператора format вы описываете заголовки, размеры полей, указываете положение данных на листе в удобной текстовой форме. Затем выполняете команду write(файл) которая выводит отформатированные данные в указанный файл.

Оператор формат имее следующий синтаксис:

format имя =
FORMLIST
.

FORMLIST - это строки формата. Они бывают трех типов:

1. Комментарий. Строка начинается символом '#'
2. Описатель полей данных (picture)
3. Строка аргументов используемых описателем.

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

Размер и вид поля в описателе обозначается следующими символами:

">>>>" - выровнить значение по правому краю.
"<<<<" - выровнить значение по левому краю.
"||||" - выровнить значение по центру.
"####.###" - формат числа с точкой.
"@*" - многострочная строка. Данные выводятся в колонку.

Символ '^' в начале поля имеет специальное значение. Так: "^####" - пусто если переменная не определена.

Для строчного скаляра: "^<<<<<" - Выводится сколько возможно символов, а значение переменной меняется на остаток вывод которого можно продолжить на следующих строках которые могут иметь свои поля.

Пример:

#!/usr/local/bin/perl
#
#       Программа печати пригласительного билета
#
$кому = "Чапаеву Василию Ивановичу";

$от_кого = "Компания МММ";

$адрес = "Москва, ул. Петровка, д 38";

$текст = "Уважаемый Василий Иванович! Компания МММ имеет честь
пригласить Вас и Ваших близких на презентацию наших новых хромовых
сапог, сделанных на уровне мировых стандартов качества и дизайна.";

format STDOUT =

        П Р И Г Л А С И Т Е Л Ь Н Ы Й      Б И Л Е Т
----------------------------------------------------------------------
Кому: @<<<<<<<<<<<<<<<<<<<<<<<<<<  | ^|||||||||||||||||||||||||||||||
      $кому,                            $текст
                                   | ^|||||||||||||||||||||||||||||||
                                        $текст
От кого: @<<<<<<<<<<<<<<<<<<<<<<<  | ^|||||||||||||||||||||||||||||||
      $от_кого,                         $текст
                                   | ^|||||||||||||||||||||||||||||||
                                        $текст
Адрес:@<<<<<<<<<<<<<<<<<<<<<<<<<<  | ^|||||||||||||||||||||||||||||||
      $адрес,                           $текст
                                   | ^|||||||||||||||||||||||||||||||
                                        $текст
                                   | ^|||||||||||||||||||||||||||||||
                                        $текст
                                   | ^|||||||||||||||||||||||||||||||
                                        $текст
----------------------------------------------------------------------
Отпечатано в типографии ИТУ 38
.

write();        # Вывод данных.
exit 0;         # Конец программы

        П Р И Г Л А С И Т Е Л Ь Н Ы Й      Б И Л Е Т
----------------------------------------------------------------------
Кому: Чапаеву Василию Ивановичу    |   Уважаемый Василий Иванович!
                                   |     Компания МММ имеет честь
От кого: Компания МММ              |  пригласить Вас и Ваших близких
                                   |    на презентацию наших новых
Адрес:Москва, ул. Петровка, д 38   |   хромовых сапог, сделанных на
                                   |    уровне мировых стандартов
                                   |       качества и дизайна.
                                   |
----------------------------------------------------------------------
Отпечатано в типографии ИТУ 38

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

use FileHandle; # Указать в начале программы
format_name файл имя_формата; # Формат содержимого листа
format_top_name файл имя_формата; # Формат заголовка листа
write(файл);    # вывод данных

Если вам нужно в теле листа выводить разного рода форматы (например заголовки групп или отбивку листа) то применяйте format_name.

Отладка Перл программ

Команды отладчика.
 

h	Получить справку по командам
T	Просмотреть стек программы
s	Выполнить одну команду и остановиться
n	Выполнить подпрограмму и остановиться
r	Выполнить текущую подпрограмму и остановиться
c	Продолжить выполнение до сдедующей точки остановки
c номер	Продолжить выполнение до строки с данным номером
<CR>	Повторить последнию команду n или s
l min+incr	Вывести incr+1 строк программы начиная со строки min
l min-max	Вывести строки начиная с min до max
l номер	Вывести строку с указанным номером
l	Вывести следующий экран строк
-	Вывести предыдущий экран строк
w строк	Вывести экран строк. Текущая в середине
l подпрограмма	Вывести строки указанной подпрограммы
/шаблон/	Найти строку в тексте программы
?шаблон?	Обратный поиск строки в тексте программы
L	Вывести строки с точками останова и активами
S	Вывести имена всех подпрограмм
t	Включить или выключить трассировку
b строка [ условие]	Установить точку остановки
b подпрограмма [ условие ]	Установить точку остановки в начале указанной подпрограммы и если указано при данном условии
d	Убрать точку остановки
D	Убрать все точки остановки
a строка команда	Установить актив (команду которая выполнится вместе с указанной строкой. "команда" - обычныая команда Перл
A	Стереть все активы
< команда	Выполнять команду перед каждой остановкой
> команда	Выполнить команду после остановки отладчика
V модуль [имена]	Вывести значение всех или указанных имен в модуле. Внимание! Символ '$' не вводится
X [имена]	То же что и V , но только для текущего модуля
! номер	Выполнить одну строку программ
! -номер	Выполнить одну команду с номером предшествующим текущей строке
H - n	Вывести n последних выполненных команд
q или ^D	Выход из программы
команда	Выполнить команду Перл
p выражение	Вывести значение выражения

Конструктор BEGIN не отслеживается отладчиком, но можно в теле конструктора указать:

$DB::single =1;