Спецификация языка Perl
Приложение 2. Спецификация языка
Perl
Содержание
П2.1Основные
особенности Perl
П2.1.1Введение
П2.2Cтруктуры
данных
П2.2.1Скалярные
величины
П2.2.2Простые
массивы
П2.2.3Ассоциативные
массивы
П2.3Синтаксис
языка Perl
П2.3.1Основные
понятия
П2.3.2Простые
операторы
П2.3.3Составные
операторы
П2.3.4Операторы
языка Perl
П2.3.4.1Термы и
операторы списка
П2.3.4.2Оператор
``стрелка''
П2.3.4.3Операторы
++ и - -
П2.3.4.4Экспоненциальный
оператор
П2.3.4.5Символьные
унарные операторы
П2.3.4.6Операторы
связки
П2.3.4.7Бинарные
операторы
П2.3.4.8Операторы
сдвига
П2.3.4.9Операторы
сравнения
П2.3.4.10Операторы
эквивалентности
П2.3.4.11Побитовое
И, побитовое ИЛИ и Исключающее ИЛИ
П2.3.4.12Логическое
И и логическое ИЛИ
П2.3.4.13Оператор
диапазона
П2.3.4.14Условный
оператор
П2.3.4.15Операторы
присваивания
П2.3.4.16Оператор
``запятая''
П2.3.4.17Логическое
НЕ
П2.3.4.18Логическое
И, ИЛИ и Исключающее ИЛИ
П2.3.4.19Оператор
чтения из файла
П2.3.4.20Оператор
замены строки
П2.3.4.21Оператор
замены множества символов
П2.4Языковые
конструкции Perl
П2.4.1Ссылки
П2.4.1.1Основные
понятия
П2.4.1.2Символьные
ссылки
П2.4.2Регулярные
выражения
П2.4.3Зарезервированные
переменные
П2.4.4Встроенные
функции
П2.4.5Подпрограммы
и модули
П2.4.5.1Подпрограммы
П2.4.5.2Пакеты
П2.4.5.3Таблицы
символов
П2.4.5.4Конструкторы
и деструкторы пакетов
П2.4.5.5Классы
П2.4.5.6Модули
П2.5Объектная
ориентация
П2.5.1Объекты
П2.5.2Классы
П2.5.3Методы
П2.5.4Вызов
метода
П2.5.5Деструкторы
П2.1 Основные особенности Perl
Perl - интерпретируемый
язык, приспособленный для
обработки произвольных текстовых
файлов, извлечения из них
необходимой информациии и выдачи
сообщений. Perl также удобен для
написания различных системных
программ. Этот язык прост в
использовании, эффективен, но про
него трудно сказать, что он
элегантен и компактен. Perl сочитает
в себе лучшие черты C, shell, sed
и awk, поэтому для тех, кто
знаком с ними, изучение Perl-а не
представляет особого труда.
Cинтаксис выражений Perl-а близок к
синтаксису C. В отличие от
большинства утилит ОС UNIX Perl не
ставит ограничений на объем
обрабатываемых данных и если
хватает ресурсов, то весь файл
обрабатывается как одна строка.
Рекурсия может быть произвольной
глубины. Хотя Perl приспособлен для
сканирования текстовых файлов, он
может обрабатывать так же двоичные
данные и создавать .dbm файлы,
подобные ассоциативным массивам.
Perl позволяет использовать
регулярные выражения, создавать
объекты, вставлять в программу на С
или C++ куски кода на Perl-е, а
также позволяет осуществлять
доступ к базам данных, в том числе Oracle.
Ниже приводится в качестве примера
небольшая программа, которая
осуществляет доступ к Oracle.
#! /usr/local/bin/perl -w
# запуск с ключом печати ошибок.
use Oraperl;
# подключение модуля для работы с Oracle
$system_id = 'T:bdhost.somwere.com:Base';
# описание имени базы данных
$lda = &ora_login($system_id, 'scott','tiger');
# подключение к базе данных пользователя
# scott с паролем tiger
$statement = 'create table MYTABLE
(NAME char(10), TITLE char(20),
ORGANIZATION varchar2(256))';
# SQL команда создания таблицы MYTABLE
$csr = &ora_open($lda, $statement)
|| die $ora_errstr;
# открытие курсора csr, если это невозможно,
# то осуществляется выход и печать сообщения об ошибке.
&ora_close($csr); # закрытие курсора
open(FL, '/home/my_home_directory/my_file')
|| die "Can't open file n";
# открытие файла, если это невозможно,
# то выход с печатью сообщения об ошибке
while ($string = <FL>) {
# чтение входного потока из файла с дескриптором FL
@array = split(///,$string);
# считанная строка разбивается в массив
# строк, разделителем служит слеш
$st = 'insert into MYTABLE values(:1,:2,:3)';
# SQL команда помещения в таблицу некоторых значений
$csr = &ora_open($lda,$st) || $ora_errstr;
# открытие курсора или печать
# сообщения об ошибке и выход
&ora_bind($csr,$array[0],$array[1],$array[2]);
# привязка значений переменных к величинам, которые
# требуется поместить в таблицу
&ora_close($csr); # закрытие курсора
}
close FL; # закрытие файла
&ora_commit($lda);
# завершение транзакции в базе данных
&ora_logoff($lda);
# отключение от базы данных
П2.2 Cтруктуры данных
Perl поддерживает три типа данных:
- скаляры
- массивы скаляров
- ассоциативные массивы
скаляров (так называемые хэши).
Обычные массивы, как и в языке C,
индексируются числами, начиная с
нуля. Ассоциативные массивы
индексируются строками. Простые
скаляры (в дальнейшем мы будем
также называть их переменными)
всегда начинаются со знака доллара:
$, даже в том случае, когда мы
обращаемся к элементу массива.
?
$day простая переменная day
$day[28] 29 элемент массива day
$day{'Feb'} значение 'Feb' из хэша %day
$#day последний индекс массива @day
Простой массив начинается со
знака @:
?
@day массив day - ($day[1],$day[2],...)
@day[3,4,5] то же, что и @day[3..5]
Ассоциативный массив (хэш)
начинается со знака процент %:
%day (key1, val1, key2, val2, ...)
Каждый тип данных имеет свое
именное пространство, поэтому вы
можете использовать одно и то же
имя одновременно для скалярной
переменной, массива или хэша (а
также для подпрограммы или метки)
без опасения, что произойдет
ошибка. Perl различает большие и
маленькие буквы: FOO, foo
и Foo будут рассматриваться
Perl-ом как разные переменные. Имена,
начинающиеся с буквы или знака
подчеркивания, могут в дальнейшем
содержать в себе цифры или знаки
подчеркивания. Имена, начинающиеся
с цифры, могут в дальнейшем
содержать только цифры. Имена,
начинающиеся не с буквы, цифры или
подчерка должны состоять только из
одного символа. Большинство таких
имен зарезервировано, например $$
является идентификатором текущего
процесса. Интерпретация команды
или величины часто зависит от
требований контекста. Существует
два основных контекста: скалярный и
списковый. Некоторые операции
возвращают список величин если в
контексте подразумевается список и
одну величину, если контекст
скалярный. Например, операция &ora_fetch
в скалярном контексте возвращает
количество выбранных строк:
$nfields = &ora_fetch($csr);
В списковом контексте она
возвращает массив выбранных строк:
@array = &ora_fetch($csr);
Левый аргумент определяет контекст
правого аргумента.
П2.2.1 Скалярные величины
Скалярные переменные могут
содержать различные простые типы
данных, такие как числа, строки или
ссылки. Они не могут содержать
сложные типы, но могут содержать
ссылку на массив или хэш. В
булевском контексте скаляр
принимает значение TRUE, если
он содержит не нулевое число или не
пустую строку. В Perl существует
несколько способов записи чисел:
?
12345
12345.67
.23E-10
0xffff шестнадцатеричная запись
0377 восьмеричная запись.
1_234_567_890 подчерк для удобства чтения.
Строки заключаются в одинарные
или двойные кавычки. Использование
кавычек в Perl такое же как в bourne
shell-е: строка в двойных кавычках
обрабатывается и вместо переменных
подставляются их значения, а также
обрабатываются
бакслэш-последовательности, строки
в одинарных кавычках
рассматривается просто как
последовательности символов.
Используются также:
?
t табуляция
n перевод строки
r возврат каретки
b пробел
e символ Escape
33 восьмеричный формат
x1b шестнадцатеричный формат
c[ управляющая последовательность (control)
a сигнал (alarm)
f переход на следующую страницу
П2.2.2 Простые массивы
Perl позволяет произвольно
удлинять массив путем обращения к
элементу, индекс которого больше,
чем последний индекс массива. Так
же можно произвольно уменьшить
длину массива.
@day = ('a','b');
$day[3] = 'c';
Теперь массив day содержит три
элемента: ('a','b','c').
@day = (); или, что то же самое: $#day
= -1;
Теперь массив day пуст.
(@day, @month, &SomeSub) содержит в
себе элементы массива day, за
ними следуют элементы массива month,
а за ними результат выполнения
подпрограммы SomeSub. Пустой
массив обозначается ().
Массив ((),(),(),()) эквивалентен
пустому массиву. Последний элемент
массива может быть массивом или
хэшэм:
($a, $b, @c)= split;
($a, $b, %c)= @_;
Любой элемент массива может быть
массивом.
П2.2.3 Ассоциативные массивы
Ассоциативные массивы или хэши
содержат пары ``ключ'' и ``значение''.
Например:
%map = ('red',0x00f,'blue',0x0f0,'green',0xf00);
Часто для удобства чтения между
``ключом'' и ``значением'' ставят
оператор =>.
%map = (
'red' => 0x00f,
'blue' => 0x0f0,
'green' => )xf00
);
П2.3 Синтаксис языка Perl
П2.3.1 Основные понятия
Программа на Perl-е состоит из
последовательности команд. В
отличие от типизированных языков
Perl не требует объявления типов
своих объектов. Все объекты,
определенные в программе, до
присваивания им какого-либо
значения по умолчанию принимают
значение ``0''. Последовательность
команд исполняется сразу, в отличие
от sed и awk, где
исполняется последовательно
каждая строка. Комментарии
выделяются знаком #, и вся
строка следующая за этим знаком
будет рассматриваться как
комментарий. Если вы написали
подпрограмму, то ее можно вызывать
только ниже по тексту программы.
Блоком называется
последовательность операторов,
логически составляющая единое
целое в теле программы, как правило,
блоки заключаются в фигурные
скобки. Каждая команда отделяется
от других точкой с запятой. Точка с
запятой не обязательна, только если
оператор является последним в
блоке.
П2.3.2 Простые операторы
Последовательность простых
операторов может следовать за
отдельным модификатором. В Perl-е
простыми модификаторами являются:
if (EXPR)
unless (EXPR)
while (EXPR)
until (EXPR) В операторах while
и until проверка условия
происходит перед выполнением тела
блока, за исключением одного
случая, когда используется
do-оператор:
do {
$_ = <STDIN>;
...
} until $_ eq ".n";
в котором проверка условия
происходит после выполнения блока.
Операторы цикла, которые будут
описаны далее, не будут работать в
этой конструкции, так как
отсутствует метка цикла.
П2.3.3 Составные операторы
if (EXPR) BLOCK
if (EXPR) BLOCK else BLOCK
if (EXPR) BLOCK eslif (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
В отличие от C и Pascal
все определяется в терминах блоков,
а не операторов: то есть фигурные
скобки являются обязательными.
Метка состоит из идентификатора и
двоеточия. Она ставится в начале
цикла и служит указателем для
операторов цикла next, last
и redo (их описание смотри
ниже). Если это continue блок, то
он выполняется перед тем, как
условие будет проверено снова, как
третья часть for оператора в C.
Правильность условия может
зависеть от результатов выполнения
блока, например:
$i = 1;
while ($i < 10){
...
} continue {
$i++;
}
или, что тоже самое:
for ($i = 1; $i < 10; $i++;) {
...
}
Foreach цикл присваивает переменной
по очереди каждое значение из
списка и выполняет над ней все
команды из блока. Переменная
является локальной и существует
только в пределах данного цикла.
Если список является массивом, то
его можно изменять в цикле,
посредством операций над
переменной. Если переменная
опускается, то по умолчанию в
качестве нее используется $_.
foreach $elem(@elements) {$elem = $elem * 2;}
-- цикл по всему содержимому
массива @items. Пример:
for ((1,2,3,4,5,6,7,8,9,10,'boom')) {
print $_,"n"; sleep(1); }
for (1..15) { print "Merry Christmasn"; }
foreach $item (split(/[/*\n]/,$ENV{'TERMCAP'})) {
print "Item: $itemn"; }
Блок семантически эквивалентен
циклу, который исполняется один
раз. Поэтому в него можно включать
операторы контроля цикла, чтобы
выйти из него или запустить его еще
раз.
П2.3.4 Операторы языка Perl
П2.3.4.1 Термы и операторы списка
Операторы в Perl-е имеют различный
приоритет. Операторы,
заимствованные из C,
сохранили между собой ту же
иерархию, что и в C. Термы
имеют самый большой приоритет, они
содержат переменные, кавычки,
выражения в скобках, функции с их
параметрами. Если за списковым
оператором ( например, print()) или
унарным оператором ( например, chdir())
следует список аргументов,
заключенный в скобки, то эта
последовательность имеет самый
высокий приоритет, подобно функции
с аргументами. Аналогично термам
обрабатываются последовательности
do{} и eval{}.
П2.3.4.2 Оператор ``стрелка''
Также, как в С и С++ ``->''
является инфиксным оператором
ссылки. Если правая часть является
[...] или {...} подпрограммой, тогда
левая часть должна быть символьной
ссылкой на массив или хэш. Если
правая часть - это имя метода или
скалярная переменная содержащая
имя метода, то левая часть должна
быть объектом или именем класса.
П2.3.4.3 Операторы ++ и - -
Эти операторы работают также как
и в С. То есть, если они стоят
перед переменной, то они
увеличивают или уменьшают
переменную до возвращения
значения. Если они стоят после
переменной, то увеличение или
уменьшение переменной происходит
после возврата значения. Если
переменная содержит в себе число
или употребляется в скалярном
контексте, то использование ++
дает обычное увеличение значения.
Если же переменная употреблялась
только в строковом контексте, не
является пустой строкой и содержит
символы a-z,A-Z,0..9, то
происходит строковое увеличение
значения переменной:
print ++($foo = '99'); - напечатает 100
print ++($foo = 'a0'); - напечатает a1
print ++($foo = 'Az'); - напечатает Ba
print ++($foo = 'zz'); - напечатает aaa
В Perl-е двойная
звездочка ** является
экспоненциальным оператором. Он
требует к себе даже больше
внимания, чем унарный минус: -2**4
это -(2**4), но не (-2)**4.
П2.3.4.5 Символьные унарные
операторы
Унарный ! означает
логическое отрицание. Унарный
минус, в случае числового значения
переменной, обозначает обычное
арифметическое отрицание. Если
операндом является идентификатор,
то возвращается строка, состоящая
из знака минус и идентификатора.
Если строка начинается со знака +
или -, то возвращается
строка, начинающаяся с
противоположного знака. Унарная
тильда ``~'' обозначает
побитовое отрицание.
Унарный плюс не имеет влияния даже
на строки. Он используется для
отделения имя функции от выражения
заключенного в скобки, которое
иначе рассматривается как список
аргументов.
rand (10) * 20; - (rand10) * 20;
rand +(10) * 20; - rand(10 * 20);
Унарный бэкслэш ``'' обозначает
ссылку на то, что стоит за ним.
П2.3.4.6 Операторы связки
Знак равенства с тильдой ``=~''связывает
выражение слева с определенным
шаблоном. Некоторые операторы
обрабатывают и модифицируют
переменную $_. Эти же
операции иногда желательно бывает
выполнить над другой переменной.
Правый аргумент это образец поиска,
подстановки или трансляции, левый
аргумент - это то, что должно быть
подставлено вместо $_.
Возвращаемая величина показывает
успех операции. Бинарное ``!~''
это тоже самое, что и ``=~'',
только возвращаемая величина
является отрицательной в
логическом смысле.
П2.3.4.7 Бинарные операторы
Звездочка * - умножение
двух чисел. Cлэш / - деление
числа на число. Процент % -
вычисляет модуль двух чисел, x
- оператор повторения. В скалярном
контексте возвращает строку,
состоящую из многократно
повторенного левого операнда,
причем повторяется он то
количество раз, которое стоит
справа. В списковом контексте он
многократно повторяет список. print
'a' x 80; напечатает букву a 80
раз.
@ones = (1) x 80; массив из
восьмидесяти единиц.
@ones = (5) x @ones сделает все
элементы равными пяти.
Бинарный плюс - операция сложения
двух чисел.
Бинарный минус - операция вычитания
двух чисел.
Бинарная точка - конкатенация
строк.
П2.3.4.8 Операторы сдвига
Двоичный сдвиг осуществляется,
как и во многих других языках
программирования, с помощью
операторов ``<<'' и ``>>''. При
применении этих операторов
значения левых аргументов
сдвигаются в соответствующую
сторону на количество разрядов,
указанное в правых аргументах.
Аргументы должны быть
целочисленными.
П2.3.4.9 Операторы сравнения
``<'' - возвращает TRUE если левый
аргумент численно меньше, чем
правый.
``>'' - возвращает TRUE если правый
аргумент численно меньше, чем
левый.
``<='' - возвращает TRUE если правый
аргумент численно меньше или равен
левому.
``>='' - возвращает TRUE если левый
аргумент численно меньше или равен
правому.
``gt'' - возвращает TRUE если левый
аргумент меньше (в строковом
контексте), чем правый.
``lt'' - возвращает TRUE если правый
аргумент меньше (в строковом
контексте), чем левый.
На поведение операторов lt и gt
влияют установки системного языка,
если операционная система способна
работать с несколькими языками. По
этой причине операторы должны
корректно работать со строками на
языках, отличных от US ASCII, что
в системе UNIX задается
указанием свойств LC_COLLATE
системного locale.
П2.3.4.10 Операторы эквивалентности
== возвращает TRUE,
если левый аргумент численно
эквивалентен правому.
!= возвращает TRUE, если
левый аргумент численно
неэквивалентен правому.
<=> возвращает -1, 0 или 1 в
зависимости от того, численно
меньше, равен или больше левый
аргумент правого.
eq возвращает TRUE, если
левый аргумент эквивалентен
правому (в строковом контексте).
ne возвращает TRUE, если
левый аргумент неэквивалентен
правому (в строковом контексте).
cmp возвращает -1, 0 или 1 в
зависимости от того, меньше равен
или больше левый аргумент правого
(в строковом контексте).
П2.3.4.11 Побитовое И, побитовое ИЛИ
и Исключающее ИЛИ
Бинарное & возвращает
объединенные побитово операнды.
Бинарное | возвращает
перемноженные побитово операнды.
Бинарное ^ возвращает
исключенные побитово операнды.
П2.3.4.12 Логическое И и логическое
ИЛИ
Бинарное && -
логическое И. Если левый аргумент FALSE,
то правый не проверяется.
Бинарное || - логическое ИЛИ. Если
левый аргумент TRUE, то правый
аргумент не проверяется.
||''и && отличаются от
подобных операторов в verbC| тем,
что вместо 0 или 1 они возвращают
последнюю обработанную величину.
Таким образом, наиболее удобным
способом определить домашний
каталог пользователя из переменной
окружения HOME будет (на
практике такой способ определения
домашнего каталога пользователя не
рекомендуется):
$home = $ENV{'HOME'} || $ENV{'LOGDIR'} ||
(getpwuid($<))[7] || die "You're homeless!n";
В качестве более удобной для
чтения альтернативы Perl
поддерживает операторы and и or,
которые будут описаны далее. Их
приоритет ниже, однако их можно с
удобством использовать, не
расставляя скобки, после
операторов, аргументами которых
являются списки:
unlink "alpha", "beta", "gamma"
or gripe(), next LINE;
Если писать в стиле C, то
это может быть записано так:
unlink("alpha", "beta", "gamma")
|| (gripe(), next LINE);
П2.3.4.13 Оператор диапазона
.. - оператор диапазона.
Реально это два разных оператора, в
зависимости от контекста. В
списковом контексте он работает
как оператор диапазона от левого
аргумента до правого.
for (1..10) {
#code
}
В скалярном контексте он
возвращает булевское значение.
Если левый операнд TRUE, то ..
принимает значение TRUE, если
правый операнд тоже TRUE.
if (101..200) { print 'hi;)';}
- напечатает вторую сотню строк
П2.3.4.14 Условный оператор
?: также как и в C
является условным оператором. Он
работает подобно if-then-else.
Если аргумент перед ? - TRUE,
то возвращается аргумент перед :,
в противоположном случае
возвращается аргумент после :.
Скалярный или списковый контекст
второго и третьего аргументов
передается по наследству.
($a_or_b ? $a : $b) = $c;
П2.3.4.15 Операторы присваивания
= - обычный оператор
присваивания. Вообще операторы
присваивания работают также как и в
C. $a += 2; - то же самое,
что и $a = $a + 2; Можно
использовать следующие сокращения:
**= += *= &= <<= &&=
-= /= |= >>= ||=
.= %= ^= x=
($a += 2) *= 3; - то же самое, что и
: $a = $a + 2; $a = $a * 3;
П2.3.4.16 Оператор ``запятая''
, - оператор запятая или
comma-оператор. В скалярном контексте
он обрабатывает левый аргумент и
отбрасывает его значение, потом
обрабатывает правый аргумент и
возвращает его величину. В этом он
подобен comma-оператору из C. В
списковом контексте он играет роль
разделителя аргументов и вставляет
оба аргумента в список. => является
синонимом comma-оператора.
П2.3.4.17 Логическое НЕ
Унарное NOT возвращает
отрицание аргумента. Оно
эквивалентно !, за
исключением более низкого
приоритета.
П2.3.4.18 Логическое И, ИЛИ и
Исключающее ИЛИ
and возвращает конъюнкцию
двух выражений. Он эквивалентен &&,
за исключением более низкого
приоритета. or возвращает
дизъюнкцию аргументов. Он
эквивалентен ||, за исключением
более низкого приоритета. xor
(eXclusive OR) - исключающее ИЛИ,
возвращает истину, если истинен
ровно один из аргументов.
П2.3.4.19 Оператор чтения из файла
В Perl есть несколько операций
ввода-вывода. Для вывода из файла
используется команда <>.
open(STDIN,"/etc/passwd");
while ($string = <STDIN>)
{
@a = split(/[:]/,$string);
}
Внутри этих скобок стоит
дескриптор файла. Считывание
происходит построчно. В конце файла
<STDIN> принимает значение FALSE
и цикл while завершается. По
умолчанию считывание происходит в
переменную $_. Нулевой
дескриптор файла используется
также как в sed и awk, то
есть считывается поток из файлов
перечисленных в командной строке.
П2.3.4.20 Оператор замены строки
Оператор s/PATTERN/REPLACEMENT/egimosx
производит поиск строки,
соответствующей шаблону PATTERN
и если строка найдена, то
подстановку на ее место текста REPLACEMENT.
Возвращает количество
произведенных подстановок. Если
перед этим не использовался
оператор =~ или !~ для
определения переменной, которая
будет обрабатываться, то будет
модифицироваться переменная $_.
Этот оператор используется со
следующими опциями:
- e интерпретирует правую часть
как выражение.
- g производит подстановку на
место каждой строки,
соответствующей шаблону.
- i производит поиск различающий
большие и маленькие буквы.
- m обрабатывает строку, как
состоящую из нескольких строк.
- o происходит подстановка
только на место первой
встреченной строки.
- s обрабатывает строку, как
состоящую только из одной
строки.
- x использует расширенные
регулярные выражения.
Например:
$path =~ s|/usr/local/bin|/usr/bin|;
($foo = $bar) =~ s/this/that/o;
$count = ($paragraf =~ s/Misterb/Mr./gm);
П2.3.4.21 Оператор замены множества
символов
tr/SEARCHLIST/REPLACEMENTLIST/cds
y/SEARCHLIST/REPLACEMENTLIST/cds Заменяет все
найденные символы из множества
символов SEARCHLIST на
соответствующие символы из
множества символов REPLACEMENTLIST.
Возвращает число символов, которые
были заменены или удалены. Если
посредством операторов =~, !~
не была указана никакая строка, то
обрабатывается переменная $_.
y является синонимом tr.
Если SEARCHLIST заключен в
скобки, то REPLACEMENTLIST тоже
заключается в скобки, которые могут
отличаться от тех, в которые
заключается шаблон, например:
tr[A-Z][a-z]
tr(+-*/)/ABCD/
Этот оператор употребляется со
следующими опциями:
- c заменяет символы, которые не
входят во множество
SEARCHLIST
на REPLACEMENTLIST, например: tr/a-zA-Z/ /cs;
заменит неалфавитные
символы.
- d Стирает символы, которые ни на
что не заменяются.
- s Переводит последовательность
символов, которые заменяются
на один и тот же символ в один
символ.
Например:
$a = 'CCCCCCCCC';
$a =~ tr/C/D/s;
теперь $a = 'D'
П2.4 Языковые конструкции Perl
П2.4.1 Ссылки
П2.4.1.1 Основные понятия
В предыдущих версиях Perl была
реализована возможность только
символьных ссылок. Perl версии 5 и
выше позволяет использовать не
только символьные ссылки на
переменные, но и ``жесткие'' ссылки
на любые данные. Так как любой
скаляр может быть ссылкой, а
массивы и хэши состоят из скаляров,
то можно с легкостью организовать
массив массивов, массив хэшей, хэш
массивов и так далее. ``Жесткие''
ссылки следят за счетчиком ссылки и
как только счетчик становится
равным нулю, автоматически удаляют
ссылку. Символьные ссылки содержат
только имя переменной, также как
символьная ссылка файловой системы
содержит просто имя файла. Ссылки
могут быть созданы несколькими
способами:
- Используя бэкслэш оператор
перед переменной,
подпрограммой или простой
константой. (Это работает почти
как
& - создается еще
одна ссылка, так как одна уже
существует в символьной
таблице.) $varref = $foo;
$arref = @ARGV;
$hashref = %ENV;
$coderef = &handler
- Ссылка на массив может быть
создана с использованием
квадратных скобок:
$arrayref = [1,2,['a','b','c']];
По адресу $arrayref[2][1]
будет храниться значение b.
- Ссылка на произвольный хэш
может быть создана с
использованием фигурных
скобок:
$hashref = {
'Earth' => 'Moon',
'Jupiter' => 'Kallisto',
...
};
- Ссылка на подпрограмму может
быть создана с использованием
слова
sub, без
определения имени
подпрограммы: $coderef = sub { print "Hello!n" };
- Ссылки часто возвращаются
конструкторами. Объекты Perl на
самом деле являются ссылками
на специальную сущность,
которая знает, какой пакет
ассоциировать с объектом.
Конструкторы это специальные
подпрограммы, которые умеют
создавать эту ассоциацию.
Чтобы извлечь информацию, на
которую указывает ссылка, тоже
существует несколько методов:
- Можно сделать идентификатор
ссылки частью имени переменной
или подпрограммы:
$bar = $$scalarref;
push(@$arrayref,$filename);
$$arrayref[0] = "January";
$$hashref{"key"} = "value";
&$coderef(1,2,3);
$refrefref = \"how are you?";
print $$$$refrefref;
- напечатает ``how are you?''.
Нужно понимать, что раскрытие
ссылки имеет более высокий
приоритет, чем извлечение
значения переменной.
- Можно поступить как и в
предыдущем случае, но
заключить выражение после
знака
$в фигурные
скобки. Приведенный пример
тогда будет выглядеть таким
образом: $bar = ${$scalarref};
push(@{$arrayref},$filename);
${$arrayref}[0] = "January";
${$hashref}{"key"} = "value";
&{$coderef}(1,2,3);
В данном случае
использование фигурных скобок
ничего не меняет, но в общем
случае в скобках может стоять
произвольное выражение, даже
подпрограмма:
&{ $dispatch{$index} }(1,2,3);
- В случае массива или хэша можно
использовать такую запись:
$arrayref->[0] = "January";
$hashref->{"key"} = "value";
Левая часть должна быть
выражением, возвращающим
ссылку, возможно также
являющуимся раскрытием ссылки:
$array[$x]->{"foo"}->[0] = "January";
- Если ссылка является ссылкой
на объект, то раскрытие данных
происходит также, как уже было
описано выше.
Функция ref() может быть
использована для определения типа
объекта, на который указывает
ссылка. Функция bless() может
быть использована для
ассоциирования ссылки с пакетом,
функционирующим как объектный
класс.
П2.4.1.2 Символьные ссылки
Мы рассмотрели, что происходит,
если величина, используемая в
качестве ссылки, не была определена
ранее. Что же происходит, если она
уже определена и не является
жесткой ссылкой? В таком случае она
обрабатывается как символьная
ссылка. То есть значение скаляра
рассматривается как имя
переменной, а не прямая ссылка на
переменную.
?
$name = "foo";
$$name = 1; - то же самое, что $foo = 1;
${$name} = 2; - то же самое, что $foo = 2;
${$name x 2 } = 3; -то же самое, что $foofoo = 3;
$name->[0] = 4; -то же самое, что $foo[0] = 4;
@$name = (); - обнуляет массив @foo
&$name(); - вызывает &foo
П2.4.2 Регулярные выражения
Perl позволяет использовать
регулярные выражения. Для того
чтобы пояснить, что же представляет
из себя регулярное выражение
приведем несколько примеров:
/SWAP.*/ - соответствуют все
слова начинающиеся со SWAP и
заканчивающихся произвольным
набором символов. Точка обозначает
произвольный символ, звездочка - то,
что символ, стоящий перед ней,
входит в слово 0 и более раз. Все
метасимволы, которые будут описаны
ниже, бозначают вхождение того, что
стоит перед ними.
/w*/ - соответствуют слова
состоящие только из алфавитных,
цифровых символов и символа
подчерк. w - соответствует
алфавитным, цифровым символам и
символу подчерк, звездочка - тому,
что эти символы могут входить
произволное количество раз. Здесь
мы приведем только основные
метасимволы. Для более подробной
информации смотрите
соответствующие страницы man по Perl.
?
* соответствует 0 или более вхождений
+ соответствует 1 или более вхождений
? соответствует 1 или 0 вхождений
{n} соответствует ровно n вхождений
{n,} соответствует по крайней мере n вхождений
{n,m} соответствует по крайней мере n,
но не более m вхождений
Метасимвол * эквивалентен {0,},
+ эквивалентен {1,} и ?
эквивалентен {0,1}.
Ограничений на величину m и n нет.
Эта стандартная конструкция
работает в ``жадном'' режиме, то есть:
регулярному выражению a.*b
будет соответствовать
всевозможный набор слов
начинающихся с символа a и
кончающихся символом b, в том
числе слова типа abcab. В таких
словах есть подпоследовательности
символов, которые также
удовлетворяют условиям
регулярного выражения. Если после
каждого из описанных метасимволов
поставить знак ?, то подобные
последовательности будут
опускаться. Шаблоны обрабатываются
как строка в двойных кавычках,
поэтому приведенные ниже
последовательности также будут
обрабатываться:
?
l - передвижение на символ вниз
u - передвижение на символ вверх
А также все перечисленные ранее
бакслэш-последовательности. В Perl-е
определены также:
?
w - соответствуют алфавитные и цифровые
символы а также символ подчерк
$W - соответствуют все символы не входящие
во множество символов w
s - символы пробела, табуляции, возврата каретки
S - все символы не входящие во множество символов
s
d - цифровые символы
D - нецифровые символы
Обратите внимание, что w
отмечает только отдельные символы,
а не все слово. Чтобы отметить все
слово нужно использовать w+.
Также определены следующие
команды:
?
b - соответствуют границы слова
B - соответствуют не-границы слова
A - соответствуют только начало строки
Z - соответствуют только конец строки
При использовании конструкции
типа ( ... ), <digit>
подставляет подстроку из скобок с
номером digit. Можно
использовать скобки для отделения
подшаблона. Если в скобках имеется
более, чем 9 подстрок, то переменные $10,
$11, ... содержат
соответствующие подстроки. $+
возвращает то, чему соответствует
последняя конструкция в скобках. $&
возвращает подставленную строку. $`
возвращает все перед подставленной
строкой, $' возвращает все
после подставленной строки.
$_ = 'abcdefghi';
/def/;
print "$`:$&:$'n"; - напечатает abc:def:ghi
На этом мы закончим описание
регулярных выражений, для более
подробной информации читайте manual
page.
П2.4.3 Зарезервированные
переменные
В Perl есть имена имеющие
специальное значение. Многие из них
аналогичны зарезервированным
именам в shell.
Если вы хотите использовать
длинные имена переменных, в
заголовке программы требуется
сказать:
use English;
Многие переменные доступны только
для чтения, то есть при попытке
присвоения такой переменной
какого-либо значения напрямую или
по ссылке происходит ошибка.
$_ В эту переменную по
умолчанию происходит ввод,
присваивание, в нее складываются
результаты поиска по заданному
образцу.
while(<>){...}
или, что то же самое:
while($_= <>) {...}
$<digit> Эта переменная
была описана в предыдущем
параграфе. Она доступна только для
чтения, так же как и переменные $&,
$`, $' и $+.
$. Эта переменная
содержит номер строки, которая была
почитана последней из файла,
который был прочитан последним. Она
также доступна только для чтения.
$/ Содержит символ по
которому разделяются вводимые
записи. По умолчанию содержит
символ перевода строки. Она похожа
на переменную RS из awk.
$| По умолчанию имеет
значение 0. Если содержит ненулевое
значение, то происходит сброс
буферов каждый раз после
осуществления вывода (на печать, на
экран и т.д.).
$, Содержит
символ-разделитель полей для
оператора печати. Подобна
переменной OFS в awk.
$ Содержит
символ-разделитель записей для
оператора печати. Подобна
переменной ORS в awk. (Вы
можете определить $ вместо того,
чтобы печатать n в конце печати.)
$" Подобна переменной $,.
Но используется при обращении к
списку величин в двойных кавычках
(или другой строке, которая требует
интерпретации). По умолчанию
содержит символ пробел.
$; Содержит
символ-разделитель для эмуляции
многомерных хэшей. Если ссылаться
на такой элемент хэша как $foo{$a,$b,$c}
то реально это будет происходить
так: $foo{join($;,$a,$b,$c)}. Не путайте
с @foo{$a,$b,$c}, так как это тоже
самое, что($foo{$a},$foo{$b},$foo{$c}). По
умолчанию содержит значение 34
такое же как переменная SUBSEP
в awk.
$# Формат для печати
чисел. Подобна переменной OFMT
в awk. Первоначально содержит
значение %.20g.
$% Содержит номер текущей
выводимой страницы.
$= Содержит длину текущей
страницы (количество печатных
срок), обычно содержит значение 60.
$- Содержит значение,
определяющее количество
оставшихся на странице строк,
например количество еще не
напечатанных строк для печатного
канала вывода.
$~ Содержит имя текущего
формата сообщений. Обычно имя
дескриптора файла.
$^ Содержит имя текущего
формата заголовка страницы. Обычно
содержит имя дескриптора файла с
добавлением в конце _TOP
$: Содержит множество
символов после которых вывод сроки
может быть прерван и начат снова
после перевода строки.
$! Если эта переменная
используется в числовом контексте,
то содержит текущее значение errno
(номер ошибки) со всеми обычными
сообщениями. В строковом контексте
содержит соответствующее
системное сообщение об ошибке.
$@ Содержит сообщение о
синтаксической ошибке, допущенной
во время исполнения последней
команды eval(). Если содержит
значение 0, то команда была
исполнена корректно. Но заметьте,
что сообщения не накапливаются в
этой переменной.
$$ Содержит
идентификатор текущего процесса.
$< Содержит
идентификатор пользователя (UID),
которому принадлежит текущий
процесс.
$> Содержит эффективный
UID текущего процесса.
$( Содержит
идентификатор группы (GID)
пользователя, которому принадлежит
текущий процесс.
$) Содержит эффективный
GID текущего процесса.
$0 Содержит имя файла, в
котором находится исполняемая
программа.
$ARGV Содержит имя
текущего файла, из которого
происходит чтение.
@ARGV Содержит массив
аргументов командной строки,
которые были переданы программе.
@INC Содержит список точек
входа в программу, в которых
используются конструкции do EXPR,
require и use.
%INC Содержит входы для
каждого файла, который включается
посредством использования
операторов do или require.
Ключами являются имена файлов, а
значениями места их расположения.
%ENV Содержит текущее
окружение процесса. Изменением
содержимого хэша можно изменить
окружение порожденного (дочернего)
процесса.
%SIG Этот хэш используется
для установки обработчиков
различных сигналов. Например:
sub handler {
local($sig) = @_;
print "Caught a SIG$sig - shutting downn";
close(LOG);
exit(0);
}
$SIG{'INT'} = 'handler';
$SIG{'QUIT'} = 'handler';
...
$SIG{'INT'} = 'DEFAULT';
$SIG{'QUIT'} = 'IGNORE';
П2.4.4 Встроенные функции
abs VALUE Возвращает
абсолютное значение аргумента.
accept NEWSOCKET, GENERICSOCKET
подобно системному вызову accept(2)
ждет соединения. Возвращает
запакованный адрес, если
соединение произошло успешно и FALSE
в противоположном случае.
atan2 Y,X Возвращает arctg(Y/X).
bind SOCKET, NAME Привязывает
сетевой адрес к сокету, также как
системный вызов bind в OS UNIX
или любой другой системе,
поддерживающей BSD Sockets. Если
привязка произошла успешно,
возвращает TRUE, в противном
случае - FALSE. Переменная NAME
должна содержать запакованный
адрес, соответствующего для сокета
типа. Тип адреса для разных видов
сокетов определяется в терминах
языка C структурой sockaddr,
которая представляет собой
абстрактный тип, содержащий все
данные, необходимые для сокета.
binmode FILEHANDLE Позволяет
читать или писать файл с
соответствующим дескриптором в
бинарном режиме.
bless REF, PACKAGE Эта функция
присоединяет объект на который
указывает ссылка REF, к пакету
PACKAGE, если он определен, если
же он опущен, то к текущему пакету.
Для удобства возвращает ссылку, так
как bless() часто является
последним оператором в
конструкторе.
caller EXPR Возвращает
контекст текущего вызова
подпрограммы. В скалярном
контексте возвращает TRUE,
если мы находимся внутри
подпрограммы, eval() или require().
FALSE в противоположном
случае. В списковом контексте
возвращает:
($package, $filename, $line) = caller;
С аргументом EXPR возвращает
более сложную информацию, которая
используется отладчиком для печати
карты стека. Значение EXPR
отмечает глубину стека до текущей
записи.
($package, $filename, $line,
$subroutine, $hasargs, $wantargs) = caller($i);
chdir EXPR Изменяет текущую
директорию на указанную в EXPR,
если это возможно. Если EXPR
опущено, то устанавливает в
качестве текущей директории
домашнюю директорию. Возвращает TRUE
в случае успеха и FALSE иначе.
chmod LIST Изменяет права
доступа к файлам указанным в LIST.
Первым аргументом должна быть
маска доступа в цифровом формате.
Возвращает число файлов права
доступа к которым были успешно
сменены.
$cnt = chmod 0700 'foo','bar';
chmod 700 @executables;
chown LIST Изменяет хозяина
или группу, которой принадлежит
список файлов. Первыми двумя
аргументами должны быть uid и gid.
Возвращает количество успешных
изменений.
chr NUMBER Возвращает символ,
представленный номером NUMBER
в наборе символов. Например, chr(65)
вернет A.
close FILEHANDLE Закрывает файл
с дескриптором FILEHANDLE. Для
более подробной информации читайте
manual page.
open(OUTPUT '/usr/home/petrov');
...
close OUTPUT;
closedir DIRHANDLE Закрывает
каталог открытый вызовом opendir().
connect SOCKET,NAME Пытается
соединиться с удаленным сокетом (по
аналогии с системным вызовом).
Возвращает TRUE в случае
успешного соединения и FALSE в
противоположном случае. Переменная
NAME должна содержать
запакованный адрес
соответствующего данному сокету
типа.
cos EXPR Возвращает косинус EXPR,
выраженного в радианах. Если EXPR
опущено, возвращает косинус $_.
dbmopen ASSOC, DBNAME, MODE
Связывает dbm(3) или ndbm(3)
файл с ассоциативным массивом. ASSOC
- имя ассоциативного массива. DBNAME
- имя базы данных (без .dir или .pag
расширения). Если база данных не
существует, то она создается с
правами доступа указанными в MODE.
dbmopen(%HIST,'/usr/lib/news/history', 0600);
while (($key, $val) = each %HIST){
print $key, '=', unpack('L',$val),n;}
dbmclose(%HIST);
dbmclose ASSOC Прерывает связь
между файлом и ассоциативным
массивом.
defined EXPR Возвращает TRUE
или FALSE, в зависимости от
того определено значение EXPR
или нет. Многие операции возвращают
неопределенное значение в случае
конца файла, неинициализированной
переменной, системной ошибки или
при подобной ситуации. Если речь
идет о хэше, то defined покажет только
определены ли ли величины, ничего
не говоря о существовании ключей.
Для определения существования
ключей используется функция exists().
delete EXPR Стирает указанную
величину. Возвращает удаленную
величину или значение не
определено в случае, если удаление
не произошло.
foreach $key (keys %array) {
delete $array{$key};
}
Но более быстро то же самое можно
сделать используя функцию undef().
die LIST Вне eval()
печатает значение LIST в STDERR
и выходит из программы с текущим
значением $!. Если значение $!
есть ноль, то принимает значение $?
>> 8. Если значение $? >> 8
есть ноль, то принимает значение 255.
Внутри eval() сообщение об
ошибке помещается в переменную $@
и eval() прерывается с
неопределенным значением.
open(FL, "/root/rm-rf") || die "Can't open file.n";
do BLOCK Функцией не
является. Возвращает значение
последней операции внутри блока.
do EXPR Использует величину
EXPR как имя файла и далее
запускает содержимое этого файла,
как программу на Perl. Обычно это
используется для включения
библиотечных подпрограмм.
do 'stat.pl';
Это то же самое, что:
eval 'cat stat.pl';
Однако подключать библиотечные
модули более удобно используя use
и require.
each ASSOC_ARRAY Возвращает
массив из двух элементов,
содержащий ключ и значение из хэша,
причем по очереди перебирает все
пары ($key, $value).
while (($key,$value) = each %ENV){
print " $key = $value n";
}
eof FILEHANDLE Возвращает 1,
если следующее считывание
возвращает конец файла или если FILEHANDLE
не был открыт. При опущении
аргумента eof обрабатывает
последний файл, из которого
происходило считывание. Но на
практике эта функция редко
используется, так как в Perl-е
операторы чтения возвращают
неопределенное значение в конце
файла.
eval EXPR EXPR
выполняется как маленькая
программа в контексте основной
программы. Определенные переменные
и подпрограммы остаются
определенными и в дальнейшем.
Возвращается значение, которое
возникает при обработке последнего
выражения. Если EXPR опущено,
то обрабатывается $_.
exec LIST Исполняет внешнюю
программу и НИКОГДА не возвращает
управление. На самом деле (в UNIX)
производится системный вызов
семейства exec, который
подменяет программу, исполняющуюся
в рамках текущего процесса. Если LIST
представляет собой список из более,
чем одного аргумента, то вызывается
execvp(3) с аргументами из LIST.
Если аргумент только один, то он
проверяется на метасимволы shell.
Если они присутствуют, то он далее
передается /bin/sh -c для
обработки. Если же их нет, то
аргумент передается напрямую execvp,
который более эффективен.
exists EXPR Возвращает TRUE,
если в хэше есть ключи и даже в том
случае, когда значения VALUE не
определены.
exit EXPR Обрабатывает EXPR
и осуществляет немедленный выход с
полученной величиной.
$ans = <STDIN>;
exit 0 if $ans =~ /^[Xx]/;
Если EXPR опущено, то
осуществляет выход с нулевым
статусом.
exp EXPR Возвращает е
(основание натурального логарифма e
= 2.718281828...) в степени EXPR. По
умолчанию обрабатывается $_.
fork Делает системный
вызов fork(2). Возвращает pid
(идентификатор процесса) дочернего
процесса родительскому процессу и 0
дочернему процессу. Значение не
определено в случае неуспешного
завершения команды. Неуспех может
произойти, например, в случае
установки в системе ограничения на
количество процессов данного
пользователя. Вот небольшой пример
использования этой функции.
unless ($pid = fork) {
unless (fork) {
exec "what you really wanna do";
die "no exec";
some_perl_code_here;
exit 0;
}
exit 0;
}
waitpid($pid,0);
getc FILEHANDLE Возвращает
следующий символ из файла чтения,
присоединенный к FILEHANDLE или
пустую строку в случае конца файла.
Если FILEHANDLE опущен, то
считывание происходит из STDIN.
goto LABEL Эта функция
осуществляет переход на точку
программы LABEL и продолжает
выполнение программы с этой точки.
Точка не может находиться внутри
подпрограммы или foreach цикла,
так как в этих случаях требуется
предварительная инициализация.
Использовать в качестве LABEL
выражение не рекомендуется, хотя
такая возможность и
предоставляется.
grep BLOCK, LIST
grep EXPR, LIST Обрабатывает BLOCK
или EXPR для каждого элемента LIST
и возвращает список элементов для
которых значение выражения TRUE.
В скалярном контексте возвращает
число элементов для которых EXPR
TRUE.
hex EXPR Возвращает
десятичное значение EXPR,
интерпретируемого как
шестнадцатеричная строка. По
умолчанию обрабатывает переменную $_.
kill LIST Посылает сигнал
списку процессов LIST, первым
элементом списка должен быть номер
сигнала. Возвращает число
процессов, которым сигнал был
послан успешно. В отличие от shell,
если номер сигнала отрицателен, то
он посылается группе процессов.
int EXPR Возвращает целую
часть EXPR, если EXPR
опущено, то обрабатывает
переменную $_.
join EXPR,LIST Соединяет в
единую строку строки из LIST.
При этом в качестве разделителей
между элементами LIST ставит
значение EXPR. Например:
$_ = join( ':',$login,$passwd,
$uid,$gid,$gcos,$home,$shell);
keys ASSOC_ARRAY Возвращает
обычный массив, состоящий из ключей
ассоциативного массива ASSOC_ARRAY.
В скалярном контексте возвращает
число ключей.
@keys = keys %ENV;
length EXPR Возвращает длину EXPR
в символах. По умолчанию
обрабатывает переменную $_.
link OLDFILE,NEWFILE Создает файл NEWFILE,
присоединенный к файлу OLDFILE.
(В OS UNIX создание нескольких
имен для одного файла) Возвращает 1
в случае успеха и 0 иначе.
listen SOCKET, QUEUESIZE Делает то
же самое, что и одноименный
системный вызов. Возвращает TRUE
в случае успеха, FALSE иначе.
local EXPR На самом деле
гораздо эффективнее использовать
функцию my. Функция local
делает перечисленные переменные
локальными в блоке, подпрограмме, eval
или do. Если переменных более,
чем одна, то они должны
объединяться скобками.
sub RANGEVAL{
local($min,$max,$thunk) = @_;
local $result = '';
local $i;
for ($i = $min; $i < $max; $i++) {
$result = eval $thunk;
}
$result;
}
log EXPR Возвращает
натуральный логарифм EXPR, по
умолчанию обрабатывает переменную $_.
map EXPR,LIST Подставляет
каждый элемент из списка LIST
в EXPR (которое может быть
блоком) и возвращает список
полученных после обработки
величин.
@chars = map(chr, @nums);
mkdir FILENAME,MODE Создает
директорию с именем FILENAME и
правами доступа указанными в
переменной MODE. В случае
успеха возвращает 1, в противном
случае возвращает 0 и устанавливает
значение переменной $!(errno).
my EXPR Эта функция (так же
как и описанная ранее функция local)
делает перечисленные переменные
локальными в пределах блока,
подпрограммы, eval или do. Если список
состоит более чем из одного
элемента, то он должен быть
заключен в скобки. Все элементы в
списке должны быть фактическими
параметрами. В отличие от local,
переменные локализованные
функцией my не видны снаружи
блока, подпрограммы или другой
конструкции, внутри которой my
употребляется.
next LABEL Употребляется
подобно continue оператору в C -
запускает следующую итерацию
цикла.
line: while (<STDIN>) {
next line if /^#/;
...
}
oct EXPR Возвращает
десятичное значение EXPR,
интерпретируемого как строка в
восьмеричном формате. (Если строка
начинается с 0x, то
интерпретируется, как строка в
шестнадцатеричном формате.)
open FILEHANDLE,EXPR Открывает
файл, имя которого описано в
переменной EXPR и привязывает
его к FILEHANDLE. Если EXPR
опущено, то переменная с таким же
именем как FILEHANDLE содержит
имя файла. Если имя файла
начинается со знака:
?
< файл открывается на чтение.
> файл открывается на запись.
>> файл открывается для добавления.
| имя файла расценивается как команда,
с которой будет организован программный канал,
то есть вывод в дескриптор FILEHANDLE будет
передаваться на вход программе EXPR.
Если знак | указывается
после имени команды, то вывод этой
команды будет ассоциирован с
дескриптором FILEHANDLE, из
которого будет производиться
чтение. Интересно, что нельзя
открыть двойной программный канал,
то есть ассоциировать ввод и вывод
команды с дескриптором файла (что
соответствовало бы системному
вызову popen в UNIX).
В случае, когда имя файла
оканчивается вертикальной чертой,
оно расценивается как имя команды,
вывод которой будет
интерпретироваться как ввод из
файла (аналог функции popen(3)).
open(LOG, '>>/usr/spool/news/twitlog');
open DIRHANDLE,EXPR Открывает
директорию с именем EXPR,
возвращает TRUE в случае
успеха.
ord EXPR Возвращает
числовое значение в таблице ASCII
первого символа EXPR. По
умолчанию обрабатывает переменную $_.
print FILEHANDLE,LIST Печатает
строку или несколько строк,
разделенных запятой. FILEHANDLE
может быть именем скалярной
переменной, содержащей дескриптор
файла. Если эта переменная опущена
то печать идет в выбранный канал
вывода. Если переменная LIST
тоже опущена, то печатает
переменную $_ в STDOUT.
printf FILEHANDLE, LIST
Эквивалентно print FILEHANDLE, sprintf(LIST).
Первый аргумент LIST
интерпретируется как формат
печати.
rand EXPR Возвращает
выбранное случайным способом
значение между 0 и EXPR. EXPR
должно быть положительным. По
умолчанию производит выборку в
диапазоне между 0 и 1. (Замечание:
если ваша функция постоянно
возвращает слишком большие или
слишком малые значения, то скорее
всего была допущена ошибка при
компиляции вашей версии Perl. Было
установлено неверное значение RANDBITS.)
read FILEHANDLE,SCALAR,LENGTH,OFFSET
Считывает LENGTH байт данных из
FILEHANDLE в переменную SCALAR.
Возвращает число считанных байт
или неопределенное значение в
случае ошибки. Если вы хотите
считать данные не с начала строки,
то для этого нужно установить
значение переменной OFFSET.
readlink EXPR Возвращает
значение символьной ссылки, если
она существует. Если же ее нет, то
выдает fatal error и устанавливает
значение переменной $!. По
умолчанию обрабатывает переменную $_.
redo LABEL Перезапускает
цикл без повторной обработки
условия. Блок continue, если он есть не
исполняется. Если LABEL
опущена, то команда выполняется для
внутреннего цикла.
line: while(<STDIN>) {
while ($_ ne '') {
if (ord $_ < 86) {
...
}
redo line;
}
print;
}
ref EXPR Возвращает TRUE,
если EXPR является ссылкой и FALSE
в противоположном случае.
Полученное значение зависит от
типа объекта на который указывает
ссылка. Существует несколько
встроенных типов данных:
- REF
- SCALAR
- ARRAY
- HASH
- CODE
- GLOB
Если объект, на который указывает
ссылка, находится в пакете (package),
то в таком случае возвращается имя
пакета.
if (ref($r) eq "HASH") {
print " Это ссылка на ассоциативный массив.n";
}
if (!ref($r)) {
print " А это не ссылка вовсе! n";
require EXPR Используется для
подключения модулей.
require "oraperl.pm";
reset EXPR Обычно
используется в continue блоке в
конце цикла для переустановки
значений переменных. EXPR
интерпретируется как список
отдельных символов. Значения
переменных и массивов, имена
которых начинаются с одного из этих
символов списка
переустанавливаются. Например:
?
reset 'X' переустановит все X переменные
reset 'a-z' переустановит все переменные,
имена которых состоят из маленьких букв.
rm FILENAME Удаляет файл или
директорию с заданным именем.
Возвращает 1 в случае успеха, 0 в
противоположном случае и
устанавливает значение переменной $!.
По умолчанию обрабатывает аргумент
$_.
scalar EXPR Выражение будет
трактоваться в скалярном
контексте. Возвращает значение EXPR.
seek FILEHANDLE, POSITION, WHENCE
Позволяет установить курсор в
файле, определенном в переменной FILEHANDLE,
на позицию POSITION в режиме,
указанном в переменной WHENCE.
Если переменная WHENCE
содержит значение 0, то позиция
отсчитывается от начала файла, если
1 то от текущей позиции и если 2, то
от конца файла. Возвращает 1 в
случае успеха и 0 иначе.
select FILEHANDLE Возвращает
текущий выбранный FILEHANDLE.
Направляет вывод в FILEHANDLE.
select RBITS,WBITS,EBITS,TIMEOUT
Вызывает системный вызов select(2)
с определенной аргументами битовой
маской.
shift ARRAY Сдвигает массив ARRAY
влево с удалением первого элемента
и возвращает удаленный элемент.
Если в массиве нет элементов, то
возвращает неопределенное
значение. Если ARRAY опущен, то
обрабатывает массив @ARGV в
главной программе и массив @_
в подпрограммах.
sin EXPR Возвращает синус
выражения EXPR (выраженного в
радианах). Если аргумент опущен, то
обрабатывается переменная $_.
sleep EXPR Дает процессу
команду остановки на EXPR
секунд. Если аргумент опущен, то
процесс зависает навсегда. В таком
случае ``сон'' можно прервать, послав
ему сигнал. Возвращает число
секунд, в течение которых процесс
был в состоянии остановки.
socket SOCKET,DOMAIN,TYPE,PROTOCOL
Создает сокет и привязывает его к
дескриптору файла SOCKET.
Остальные параметры описываются
так же, как и в одноименном
системном вызове. В начале
программы необходимо написать use
Socket;.
sort SUBROUTINE,LIST Сортирует
аргументы из LIST и возвращает
отсортированный список. Если
список является массивом, то
несуществующие элементы массива не
учитываются и не возвращаются. Ниже
приведено несколько примеров.
@articles = sort @files;
- Лексическая сортировка без
использования подпрограммы.
@articles = sort{$a cmp $b} @files;
- То же самое, но с использованием
подпрограммы.
@articles = sort{$a <=> $b} @files;
- Численная сортировка по
возрастанию.
splice ARRAY,OFFSET,LENGTH,LIST
Удаляет из массива ARRAY
элементы, отмеченные в переменных OFFSET
и LENGTH и заменяет их
элементами списка LIST, если
таковые имеются. Возвращает
удаленные из массива элементы.
Длина массива растет или
уменьшается, если это необходимо.
Если переменная LENGTH опущена,
то удаляет все, начиная с OFFSET.
split /PATTERN/,EXPR,LIMIT Разбивает
строку на массив строк и возвращает
его. В скалярном контексте
возвращает число полученных полей
и помещает полученный массив в @_.
Если EXPR опущено то
разбивается строка $_. Если PATTERN
тоже опущен, то разбиение
происходит по символу пробел.
Символы, указанные в PATTERN,
служат разделителями для полей.
Разделители могут быть длиннее, чем
один символ. Если переменная LIMIT
задана и имеет неотрицательное
значение, то разбиение будет
происходить на число полей не более
указанного в LIMIT. Если
переменная не определена, то пустые
поля отбрасываются, если имеет
отрицательное значение, то это
интерпретируется Perl-ом, как
отсутствие ограничения на длину
возвращаемого массива. Если
шаблону соответствует пустая
строка, то EXPR будет разбито
на отдельные символы. Например:
print join(':',split(/ */,'hi there'));
напечатает строку h:i:t:h:e:r:e.
sqrt EXPR Возвращает корень
квадратный из значения EXPR.
По умолчанию обрабатывает
переменную $_.
system LIST Делает то же
самое, что и функция exec LIST, за
одним исключением: вместо того,
чтобы просто начать выполнять
программу , как это делает exec,
system делает fork и
порождает еще один процесс, причем
родительский процесс ждет
завершения дочернего.
tell FULEHANDLE Возвращает
текущую позицию курсора в файле FILEHANDLE.
Если аргумент опущен, то
обрабатывает файл, который читался
последним.
tie VARIABLE,PACKAGENAME,LIST
Привязывает переменную к пакету,
который будет заносить значения в
эту переменную. Переменная VARIABLE
содержит имя переменной,
переменная PACKAGENAME содержит
имя пакета. Дополнительные
аргументы передаются методу new
этого пакета. Обычно это такие
аргументы, которые в дальнейшем
могут быть переданы в качестве
параметров dbm_open() функции из C.
tie(%HIST, NDBM_File,'/usr/lib/news/history', 1, 0);
while(($key,$val) = each %HIST) {
print $key, '= ', unpack('L',$val),"n";
}
untie(%HIST);
Пакет, реализующий ассоциативный
массив, должен содержать следующие
методы:
TIEHASH objectname, LIST
DESTROY this
FETCH this, key
STORE this, key, value
DELETE this, key
EXISTS this, key
FIRSTKEY this
NEXTKEY this, lastkey
Пакет, реализующий обычный массив,
должен содержать следующие методы:
TIEARRAY objectname, LIST
DESTROY this
FETCH this, key
STORE this, key, value
Пакет, реализующий скаляры, должен
содержать следующие методы :
TIESCALAR objectname, LIST
DESTROY this
FETCH this
STORE this, value
truncate FILEHANDLE, LENGTH Обрезает
файл FILEHANDLE до заданной длины.
undef EXPR Делает значение EXPR
неопределенной величиной, в случае,
когда аргумент опущен ничего не
меняет. Не следует пытаться
применять эту функцию к
зарезервированным переменным,
потому что результат может
оказаться непредсказуемым.
unlink LIST Удаляет список
файлов и возвращает число удачно
удаленных файлов. Если вы не
являетесь суперпользователем, то
эта функция не может удалять
каталоги. Даже в случае, когда
программа запускается с
привилегиями суперпользователя,
будьте осторожны, лучше
использовать функцию rmdir.
untie VARIABLE Разрывает связь
между переменной и пакетом.
unshift ARRAY, LIST Производит
действие противоположное действию
функции shift. Присоединяет LIST
к началу массива ARRAY и
возвращает новое количество
элементов в массиве.
use Module LIST Осуществляет
присоединение модуля к программе.
use strict qw(subs,vars,refs);
values ASSOC_ARRAY Возвращает
обычный массив, состоящий из
значений ассоциативного массива ASSOC_ARRAY.
В скалярном контексте возвращает
число элементов полученного
массива. Элементы массива могут
располагаться в произвольном
порядке.
wantarray Возвращает TRUE,
если контекст исполняющейся
подпрограммы списковый, FALSE
в противоположном случае.
write создает запись
(возможно состоящую из нескольких
строк) в соответствующем файле,
используя формат ассоциированный с
этим файлом. Формат для текущего
канала вывода может быть
установлен посредством
присваивания переменной $~{ }
имени формата.
П2.4.5 Подпрограммы и модули
П2.4.5.1 Подпрограммы
Описать и использовать
подпрограмму можно несколькими
способами:
sub NAME; - подразумевает
описание в дальнейшем тела
подпрограммы. sub NAME BLOCK -
непосредственное описание. $subref = sub BLOCK - анонимное
описание. use PACKAGE qw(NAME1, NAME2, NAME3) -
включение подпрограмм из
модулей.
Вызвать подпрограмму можно тоже
несколькими способами:
&NAME(LIST) - скобки
обязательны для &
формы. NAME(LIST) - & не
обязательно со скобками. NAME LIST - скобки можно
опустить в случае
предварительного описания или
включения подпрограммы из
модуля.
Аргументы передаются
подпрограмме в виде локального
массива @_, его элементы
являются ссылками на реальные
скалярные параметры. Подпрограмма
возвращает значение, полученное в
результате исполнения последнего
оператора подпрограммы. Как уже
говорилось, подпрограмма
вызывается использованием
префикса & перед ее именем,
в Perl 5 этот префикс не обязателен.
Пример:
sub MAX {
my $max = pop(@_);
foreach $foo (@_) {
$max = $foo if $max < $foo;
}
$max;
}
...
$bestmark = &MAX(1,2,3,4,5);
Подпрограмма может вызываться
рекурсивно. Если подпрограмма
вызывается с использованием &
формы, то список аргументов
необязателен. Если вы хотите
создать внутри модуля его
собственную, невидимую снаружи
подпрограмму, то описание должно
быть анонимным:
my $subref = sub {...}
&$subref(1,2,3);
П2.4.5.2 Пакеты
Perl поддерживает механизм
альтернативного именного
пространства для каждого
отдельного пакета. Обычная
программа является пакетом с
именем main. Можно ссылаться
на переменные или дескрипторы
файлов из других пакетов
посредством использования
префикса перед именем переменной,
состоящего из имени пакета и
двойного двоеточия: $Package::Variable.
Если имя пакета нулевое, то
предполагается использование
переменной из main пакета. То
есть $::sail эквивалентно $main::sail.
Пакеты могут включать в себя другие
пакеты, в таком случае чтобы
обратиться к переменной нужно
применить описанное обозначение
рекурсивно: $OUTER::INNER::var.
В пакете могут содержаться только
переменные, чьи имена начинаются с
буквы или подчерка, остальные
переменные содержатся в пакете main.
Кроме того зарезервированные
переменные, как то STDIN, STDOUT, STDERR,
ARGV, ARGVOUT, ENV, INC и SIG
также содержатся в главном пакете.
package mypack;
sub main::mysub {
...
}
П2.4.5.3 Таблицы символов
Таблицы символов пакета хранятся
в ассоциативном массиве с тем же
именем и двойным двоеточием в
конце. Для пакетов включенных в
пакет имя символьной таблицы
составляется аналогичным образом: %OUTER::INNER::.
П2.4.5.4 Конструкторы и деструкторы
пакетов
Существует две функции
специального вида - конструкторы и
деструкторы. Это BEGIN и END
программы в их описании
необязательно использование sub.
Подпрограмма BEGIN
исполняется сразу, как только это
возможно, то есть в момент, когда
она полностью определена, даже
перед тем как обрабатывается
остаток содержащего файла. В файле
может быть несколько блоков BEGIN.
Они исполняются в порядке
определения.
Подпрограмма END исполняется
в самом конце. В файле может
содержаться несколько END
блоков, они исполняются в обратном
порядке.
П2.4.5.5 Классы
В Perl 5 нет специального синтаксиса
для описания классов, но пакеты
могут функционировать как классы,
если они содержат подпрограммы
функционирующие как методы. Такие
пакеты могут также брать некоторые
методы из других пакетов-классов.
Для этого необходимо перечислить
имена других пакетов в массиве @ISA.
П2.4.5.6 Модули
В Perl 5 понятие пакетов расширено в
понятие модулей. Модули это пакеты
находящиеся в одноименном файле,
включенном в библиотеку. Модули
подключаются следующим образом:
use Module; или use Module LIST;
Это эквивалентно:
BEGIN { require "Module.pm"; import Module; }
Все модули имеют расширение .pm.
Если именное пространство модуля
пересекается с именным
пространством основной программы
то всегда используется use,
если не пересекается то можно
использовать require.
Стандартные модули Perl описаны в
документации.
П2.5 Объектная ориентация
Понятие объектной ориентации
зиждется на трех простых
определениях:
- Объект это просто ссылка.
- Класс это просто пакет, который
содержит методы для работы с
объектными ссылками.
- Метод это просто подпрограмма,
которая имеет своим первым
аргументом объектную ссылку
(или имя пакета для
статического метода).
П2.5.1 Объекты
В отличие от C++, Perl не имеет
специального синтаксиса для
описания конструкторов.
Конструктор, как уже говорилось
раньше, это просто подпрограмма,
которая возвращает ссылку
ассоциированную с классом (как
правило с тем, где определена
подпрограмма). Например, типичный
конструктор:
package Critter;
sub new { bless {} }
{} создает ссылку на
анонимный хэш.
В пределах класса методы как
правило работают с обычными
ссылками. Конструктор может
привязать объект к другому классу,
в таком случае предыдущая привязка
бывает забыта, так как объект не
может принадлежать одновременно
нескольким классам.
П2.5.2 Классы
В отличие от C++, Perl не имеет
специального синтаксиса для
описания классов. Классом является
пакет, чьи подпрограммы выступают в
качестве методов. Для каждого
пакета определен специальный
массив @ISA, в котором
перечислены пакеты, подключенные к
данному пакету. Таким образом в Perl
реализован механизм наследования
методов. Метод, принадлежащий
другому объекту, подключается как
подпрограмма.
П2.5.3 Методы
В Perl-е метод имеет синтаксис
простой подпрограммы. В качестве
первого аргумента метода выступает
объект или пакет. Существует два
типа методов: статические и
виртуальные методы.
Статические методы имеют первым
аргументом имя класса. Они
обеспечивают функциональность для
класса в целом, а не для отдельных
объектов принадлежащих классу.
Конструкторы являются, как правило,
статическими методами. Многие
статические методы просто
игнорируют свой первый аргумент,
так как заранее знают, какому
пакету они принадлежат. Другой
способ использования статических
методов состоит в том, что метод
работает с объектом, используя имя:
sub find {
my ($class, $name) = @_;
$objtable{$name};
}
Виртуальные методы имеют первым
аргументом ссылку на объект. Обычно
они помещают эту ссылку в
переменную self или this
и в дальнейшем используют ее как
обычную ссылку.
sub display {
my $self = shift;
my @keys = @_ ? @_ : sort keys %$self;
foreach $key (@keys) {
print "t$key => $self ->{$key}n";
}
}
П2.5.4 Вызов метода
Существует два способа
обратиться к методу. Во-первых,
можно вызвать его просто как
подпрограмму. Но в таком случае не
работает механизм наследования.
Второй способ лучше просто
проиллюстрировать примерами.
$fred = find Critter "Fred";
display $fred, 'Height', 'Weight';
Это можно записать так:
display {find Critter "Fred"} 'Height', 'Weight';
П2.5.5 Деструкторы
Когда удаляется последняя ссылка
на объект, этот объект
автоматически удаляется. Это может
произойти даже после завершения
программы, если ссылки на объект
содержались в глобальных
переменных. Если необходимо
контролировать процесс удаления
объекта, можно определить в объекте
специальный метод, называемый деструктором.
Деструктор объекта (в отличие от C++)
имеет фиксированное имя DESTROY
и вызывается перед удалением
объекта. В нем можно реализовать
дополнительные процедуры,
необходимые для корректного
завершения (например, удаление
временных файлов, используемых
объектом).
[Назад] [Содержание] [Вперед]
| 
