Функции работы с массивами
Для работы с таким популярным типом данных, как массивы, в Perl существует много удобных функций. Когда требуется организовать обработку списка, поочередно извлекая из него элементы, начиная с первого, применяется встроенная функция shift. Она удаляет из массива первый элемент, возвращая его значение. Когда shift применяется к пустому списку, она возвращает неопределенное значение:
$first = shift @array; # извлечь первый элемент в $first # синоним: ($first, @array) = @array;
С помощью этой функции можно организовать цикл обработки массива, который закончится после извлечения из него последнего элемента, например:
while (my $first = shift @array) { # пока @array не опустеет print "Обработан элемент $first."; print "Осталось ", scalar @array, " элементов\n"; }
Обратите внимание, что для вывода текущего размера массива нужно использовать scalar @array потому, что иначе print воспримет @array как список для печати и выведет значения массива. Существует противоположная shift функция unshift, которая вставляет свои аргументы в массив перед первым элементом, сдвигая существующие элементы вправо.
unshift @array, $e1,$e2,$e3; # вставить значения в начало # синоним: @array = ($e1,$e2,$e3, @array);
С помощью массива можно организовать стек, данные в котором обрабатываются по алгоритму LIFO ("last in, first out", "последним пришел - первым ушел"). Для добавления данных в стек применяется операция push, которая добавляет элементы в конец массива:
push @stack, $new; # добавить элемент в конец массива # синоним: @stack = (@stack, $new);
Для извлечения одного значения из стека служит встроенная функция pop, которая удаляет последний элемент массива, возвращая его значение:
$last = pop @stack; # изъять последний элемент массива
При помощи комбинации функций push и shift можно организовать список, реализующий очередь данных, у которой элементы добавляются в конец, а извлекаются из начала (в соответствии с алгоритмом FIFO, "first in, first out", "первым пришел - первым ушел").
Для удаления или замены подсписка в массиве можно использовать функцию splice, которая удаляет идущие подряд элементы массива, заданные индексом первого элемента и количеством удаляемых элементов, и заменяет их новым списком (если он указан), возвращая список удаленных элементов.
@array = (1..7); # исходный массив $offset = 2; $size = 4; # смещение и размер удаляемого списка @deleted = splice @array, $offset, $size, qw(новый список); # в @array теперь (1, 2, 'новый', 'список', 7) # в @deleted попали 4 удаленных элемента (3, 4, 5, 6)
Если список для вставки не указан, то подсписок от элемента с индексом $offset в количестве $size элементов просто удаляется.
Операция сортировки списка выполняется встроенной функцией sort, которая, не изменяя своего аргумента, возвращает список, отсортированный по возрастанию строковых значений элементов исходного списка. Поясним на примере:
@unsorted = (12, 1, 128, 2, 25, 3, 400, 53); @sorted = sort @unsorted; # в @sorted будет (1, 12, 128, 2, 25, 3, 400, 53)
Если нужно упорядочить список другим образом, то нужно в качестве первого аргумента функции указать блок, выполняющий сравнение двух элементов сортируемого списка и возвращающий значения -1, 0, 1 - они означают, что первый элемент меньше, равен или больше второго. При сравнении чисел это проще всего сделать с помощью операции <=>, например:
@sorted = sort {$a <=> $b } @unsorted; # в @sorted будет (1, 2, 3, 12, 25, 53, 128, 400)
В блоке сравнения переменные $a и $b содержат значения двух текущих сравниваемых элементов. Для выполнения сортировки по убыванию достаточно поменять переменные местами {$b <=> $a }. Помните, что для сортировки в обратном порядке строковых значений нужно применить операцию сравнения строк {$b cmp $a }. Вместо блока можно вызвать пользовательскую подпрограмму, выполняющую сколь угодно сложные сравнения элементов сортируемого списка.
Перестановку всех элементов списка в обратном порядке выполняет встроенная функция reverse, возвращающая инвертированный список, не меняя исходного:
@array = qw(Do What I Mean); # исходный список @backwards = reverse @array; # остается неизменным # в @backwards будет ('Mean', 'I', 'What', 'Do')
Вложенный вызов функций позволяет сначала отсортировать список, а потом переставить элементы в обратном порядке:
@backwards = reverse(sort(@array)); # в @backwards будет ('What', 'Mean', 'I', 'Do')
Обратите внимание, что во всех приведенных примерах по желанию программиста аргументы функций можно указывать в круглых скобках, но делать это не обязательно. Имея в своем распоряжении мощные примитивы для работы с массивами, подобные reverse или splice, программист может легко решать весьма нетривиальные задачи. Это подтверждает короткая программа на Perl, выполняющая циклический сдвиг массива тремя вызовами функции reverse:
my @array = qw/Н А Ч А Л О К О Н Е Ц/; # исходный массив my $i = 3; # сдвиг массива ВЛЕВО на 3 элемента my $n = @array; # число элементов массива # алгоритм сдвига Кена Томпсона (1971) @array[0 ..$i-1] = reverse @array[0 .. $i-1]; @array[$i .. $n-1] = reverse @array[$i .. $n-1]; @array[0 .. $n-1] = reverse @array[0 .. $n-1]; print "@array\n"; # результат: А Л О К О Н Е Ц Н А Ч
Функция map позволяет выполнить действия над всеми элементами массива, поэтому ее нередко используют вместо цикла. У этой функции есть две формы вызова:
@result = map ВЫРАЖЕНИЕ, СПИСОК @result = map БЛОК СПИСОК
Она вычисляет выражение или блок для каждого элемента списка и возвращает список результатов. С ее помощью, например, можно выполнить арифметическое действие над всеми элементами списка:
@result = map $_*10, (11, 32, 55); # работа со списком # в @result будет (110, 320, 550)
При работе map специальная переменная $_ локально устанавливается как синоним текущего элемента списка, поэтому изменение переменной $_ приводит к изменению соответствующего элемента массива. Таким способом можно изменять значения элементов массива. В этом примере воспользуемся блоком, куда поместим операторы вычисления нового значения (если значение элемента больше 20, оно будет удесятеряться):
@array = (11, 32, 55); # исходный массив @result = map {if ($_ > 20) {$_*=10;} else {$_;} } @array; # в @result будет (11, 320, 550)
Список можно преобразовать в строку с помощью встроенной функции join, которая преобразует каждый элемент списка к строке, объединяет отдельные элементы списка в одну строку, вставляя между элементами указанный разделитель, и возвращает полученную строку в качестве результата. Например:
@array = (5..10); # объединяемый список $delimiter = ':'; # разделитель элементов списка в строке $string = join $delimiter, @array; # объединение в строку # теперь $string содержит '5:6:7:8:9:10'
Обратную операцию разделения строки по образцу на список строк выполняет встроенная функция split. Она разделяет строку по указанному разделителю и возвращает список составляющих строк. Можно ограничить число разделяемых подстрок, тогда строка будет разделена не более, чем на это число элементов. Например:
$string = '5:6:7:8:9:10'; # исходная строка $delimiter = ':'; # разделитель подстрок $limit = 3; # число элементов @strings = split $delimiter, $string, $limit; # разделение # в @strings содержится ('5', '6', '7:8:9:10')
Функция split имеет гораздо больше возможностей, о которых будет сказано в лекции, посвященной регулярным выражениям. Подробно познакомиться с которыми можно из системной документации с помощью утилиты perldoc (после флага -f указывается имя искомой функции):
perldoc -f split
Пользовательские функции и процедуры, как встроенные функции, тоже могут обрабатывать списки: принимать списки параметров и возвращать список значений. Об этом будет подробнее рассказано в лекции 12.
Элементы массива
Элементы массива - это скалярные величины, доступ к которым происходит по их порядковому номеру (индексу). Поскольку элемент массива - это скаляр, то его обозначение состоит из разыменовывающего префикса $ перед именем массива, за которым в квадратных скобках стоит индекс. Индексы элементов массива задаются целыми числами, начиная с нуля. (Номер начального индекса массивов раньше мог задаваться значением специальной переменной $[, но сейчас эта возможность считается устаревшей, поэтому поступать так не рекомендуется.) Вот так выглядит в программе обращение к элементам массива:
@array # переменная-массив, хранящая список $array[0] # первый элемент массива с индексом 0 $array[1] # второй элемент массива с индексом 1 $array[$i] # i-й элемент массива, считая с 0 $array # скаляр, не имеющий отношения к массиву @array
Если требуется обращаться к элементам массива, начиная с последнего, то используются отрицательные значения индексов:
$array[-1] # последний элемент, то есть 1-й от конца $array[-2] # предпоследний элемент, то есть 2-й от конца $array[-$n] # n-й элемент массива, считая с конца
Индекс последнего элемента массива, который всегда на единицу меньше размера массива, можно узнать, указав специальный префикс $# перед именем массива:
$last_index = $#array; # индекс последнего элемента @array
Так, например, можно выбрать элемент массива с помощью встроенного генератора случайных чисел rand, который возвращает дробное число от 0 до числа, указанного ему в качестве аргумента. Ограничим случайные числа номером последнего индекса в массиве и будем округлять их до целых значений функцией int:
$random_element = $array[int(rand($#array))];
В $#array можно присвоить новое значение последнего индекса, при этом размер массива изменится. Но такое действие обычно не требуется, так как массив при необходимости увеличивается автоматически. Размер массива в Perl не ограничивается, то есть массив может занимать всю отведенную программе память.
В операции присваивания отдельные элементы массива рассматриваются как обычные скаляры. Ниже приведены примеры, по-разному выполняющие одно и то же присваивание элементам массива:
$birthday[0] = 18; $birthday[1] = 12; $birthday[2] = 1987; ($birthday[0], $birthday[1], $birthday[2]) = (18, 12, 1987);
( Хотя более естественно для подобного присваивания воспользоваться срезом массива: @birthday[0, 1, 2] = (18, 12, 1987), но о срезах пойдет речь чуть позже в этой лекции.)
Если попытаться присвоить значение элементу с индексом больше текущего размера массива, массив автоматически увеличивается до необходимой длины, а добавленные элементы получают неопределенное значение:
$birthday[5] = 'Perl'; # размер @birthday теперь 5 # значение $birthday[3] и $birthday[4] не определено
При попытке обратиться к элементу массива с несуществующим индексом будет возвращено неопределенное значение, но ошибки во время выполнения программы не возникнет.
$array[$#array+100] # неопределенно
При использовании в качестве индекса массива дробного числа будет взята его целая часть, то есть $array[3.5] рассматривается как $array[3].
Часто требуется последовательно перебрать все элементы массива, от первого до последнего, для обработки или вывода их значений. Это можно сделать вполне традиционным образом, с помощью цикла for, как это записывается в языках C или Java, а именно:
for (my $i = 0; $i < scalar @array; $i++) { print "$array[$i] "; }
Perl предлагает для подобных действий более удобный способ с использованием цикла foreach, в котором все элементы массива поочередно совмещаются с указанной скалярной переменной. Эта переменная на время выполнения цикла становится синонимом очередного элемента массива, поэтому ее значение доступно не только для чтения, но и для изменения. Только что приведенный пример можно переписать так:
foreach my $element (@array) { # $element это синоним print "$element "; # очередного элемента $array[$i] }
Можно то же самое записать еще более кратко с помощью модификатора foreach, который поочередно перебирает все элементы массива, рассматривая специальную переменную $_ как синоним текущего элемента массива (то есть переменная $_ совмещается с очередным элементом массива):
print "$_ " foreach @array;
Так что каждый Perl- программист выбирает свой способ перебора всех элементов массива в полном соответствии с лозунгом TIMTOWTDI.
Обратите внимание, что значения элементов массива, будучи обычными скалярами, интерполируются в строках, заключенных в двойные кавычки. Целые массивы тоже интерполируются, если имя массива появляется в строке, обрамленной двойными кавычками. При этом значения элементов массива разделяются символом, хранящимся в специальной переменной $" (по умолчанию - пробелом). Вот еще один способ напечатать значения всех элементов массива, разделяя их двоеточиями:
$" = ':'; # установим разделитель элементов print "@array";
С помощью индексов можно обращаться не только к элементам массива, но и к элементам списка, в том числе и литерального. Для этого после закрывающей скобки списка указывается значение индекса в квадратных скобках:
$fifth = (10..15)[5]; # то же, что $fifth = 15;
Обращение по индексу к элементу в списке констант приобретает смысл, если индекс динамически вычисляется при выполнении программы. Вот, например, один из способов преобразовать десятичное число в шестнадцатеричное:
$hex = (0..9,'A'..'F')[$dec]; # при $dec==12 в $hex будет 'C'
Подобным же образом удобно обращаться к элементу списка, возвращаемого функцией. Например, так можно извлечь день месяца, зная, что у него 3-й индекс в результирующем списке функции localtime:
$month_day = (localtime)[3]; # элемент списка с индексом 3
Массивы
Значение списка может храниться в переменной, называемой массив. Перед именем переменной-массива стоит разыменовывающий префикс @ (напоминающий своим видом, что это array - "массив"). Одновременно с переменной-массивом в программе может существовать скалярная переменная с таким же именем, но с префиксом $, так как имена скаляров и массивов хранятся в разных таблицах имен (symbol tables).
@variable # массив для хранения списка $variable # скаляр для хранения строки или числа
Списочное значение помещается в массив с помощью операции присваивания. Присваивание выполняется по-разному в зависимости от контекста, который определяется левым операндом присваивания. Если в левой части присваивания стоит массив или список, то и в правой части ожидается список. Например:
@empty = (); # пустой массив после присвоения пустого списка @months = (1 .. 12); # массив со списком номеров месяцев @days = qw(Пн Вт Ср Чт Пт Сб Вс); # массив дней недели @week = @days; # копирование значения массива @days в @week @array = 25; # литерал 25 рассматривается как список (25) ($first) = @array; # в $first скопируется 1-й элемент массива @first = @second = (1, 2, 3); # каскадное присваивание
Если в левой части присваивания стоит скалярная переменная, то устанавливается скалярный контекст и в правой части операции ожидается скалярное значение. Например, если попытаться присвоить скалярной переменной массив, то ее значением станет размер массива. Того же результата можно добиться, явно задав для массива скалярный контекст встроенной функцией scalar:
$array_size = @months; # число элементов (размер) массива $array_size = scalar @months; # размер массива
В зависимости от контекста, системная функция localtime возвращает разные значения: в скалярном контексте она вернет строку с текущей датой и временем, а в списочном - список из девяти значений с данными о дате и времени:
$date_and_time = localtime; ($sec, $min, $hour, # секунды, минуты, часы $mday, $mon, $year, # день, месяц, год, $wday, $yday, $isdst) # день недели, день года, часовая зона = localtime;
В состав списочного литерала могут входить массивы и другие списочные литералы - тогда они заменяются списком своих значений. Но результирующий массив будет одномерным, так как вложенные списки в Perl не предусмотрены. Массивы массивов организуются с помощью ссылок, что будет изучено в лекции 11. Вот примеры такой инициализации массива:
@small = (3, 4, 5); # этот массив будет вставлен в список @big = (1, 2, @small, 6 .. 9); # то же, что @big = (1 .. 9); @big = ((1, 2), (3 .. 5), (6 .. 9)); # то же, что и выше
С помощью списка можно легко добавить новые элементы в начало или в конец существующего массива:
@array = ($new_element, @array); # добавить элемент в начало @array = (@array, $new_element); # добавить элемент в конец @all = (@first, @second); # объединить два массива в один
Присваивая массив списочному литералу, можно извлечь начальные элементы из массива в скалярные переменные, поместив оставшиеся элементы в исходный массив:
($element1, @array) = @array; # извлечь элемент из начала
Массив в левой части присваивания имеет смысл ставить только в конце списка, поскольку он поглощает все значения, и стоящие после него переменные получат неопределенные значения:
(@array,$a,$b) = (1,2,3,4,5); # все 5 чисел попадут в @array
Операции в скалярном и списочном контекстах
Рассмотренные ранее операции могут вести себя иначе, если они применяются не в скалярном, а в списочном контексте. Так, операция повторения (репликации), чаще всего применяемая к строкам, может также использоваться и для многократного повторения значений списка. Обратите внимание, что она работает именно со списками, поэтому если необходимо размножить значения массива, то его следует поместить в списочный литерал. Например:
@two = ('A', 'B') x 2; # будет: ('A', 'B', 'A', 'B') @three = (@one) x 3; # в @three трижды повторится @one
С помощью операции повторения можно присвоить одинаковые значения всем элементам массива, например, сделать их неопределенными. Таким образом результат функции undef() можно повторить по числу элементов массива:
@array = (undef()) x @array; # или (undef) x scalar(@array)
При необходимости ввести данные в массив можно воспользоваться упомянутой ранее операцией ввода строк <>, читающей строки из входного потока. В скалярном контексте операция "кристалл" считывает одну строку в переменную. Вот так можно в диалоге ввести значения в массив из пяти строк:
for (@stdin = (), $n = 0; $n < 5; $n++) { print 'Введите значение N ', $n+1, ':'; $stdin[$n] = <>; # считать строку в $n-й элемент массива }
В списочном контексте "кристалл" читает в массив за одну операцию все строки файла. Например, так можно заполнить массив данными, вводимыми с консоли:
print "Введите значения - по одному в строке.", "Для окончания ввода нажмите Ctrl-Z (или Ctrl-D).\n"; @stdin = <>; # считать все строки и поместить их в массив print "Вы ввели ", scalar @stdin, " значений.\n";
Операция <> вводит строки полностью, включая завершающий символ перевода строки, который часто не нужен при дальнейшей обработке. Функция chomp удаляет символы перевода строки в конце строки (в скалярном контексте) или в конце каждого элемента списка (в списочном контексте) и возвращает общее число удаленных символов.
chomp @stdin; # убрать \n в конце всех элементов массива $n_count = chomp $string; # убрать \n в конце строки
Похожая функция chop отсекает любой последний символ у строки (в скалярном контексте) или у каждого элемента списка (в списочном контексте) и возвращает последний отсеченный символ.
$last_char = chop $string; # отсечь последний символ строки chop @array; # отсечь последний символ в элементах массива
Если нужно избавиться только от символов перевода строки, то применение функции chomp более безопасно, поскольку она никогда не удаляет значащие символы в конце строки.
Специальные массивы
При выполнении Perl-программы ей доступны значения специальных массивов, в которых хранится полезная служебная информация. Вот некоторые из специальных массивов:
@ARGV аргументы командной строки для выполняемой программы @INC список каталогов для поиска внешних Perl-программ @_ массив параметров для подпрограмм или буфер для split
Рассмотренные в этой лекции материалы по работе со списками и массивами предоставляют программисту мощные и выразительные средства эффективной обработки больших объемов данных. Обобщением идеи массивов стали ассоциативные массивы, которые будут рассмотрены в следующей лекции.
Списки и списочные литералы
Помимо уже изученных скалярных данных, в Perl широко применяется другой тип данных - списки. Если скаляры представляют в программе единичные объекты реального мира, то списки, как и в жизни, позволяют представить набор объектов, однотипных или совершенно разных, которые для решаемой задачи удобно рассматривать как единое целое (например, "список работников", "перечень документов", "опись товаров" и так далее). В то же время, всегда можно обратиться к любому элементу списка и обработать хранящуюся в нем информацию нужным образом, при необходимости повторяя действия для каждого элемента массива.
Итак, список - это упорядоченная последовательность отдельных скалярных данных в виде одного программного объекта. Способом представления значения списка в программе является списочный литерал, который записывается в виде последовательности значений, разделенных запятыми и заключенных в круглые скобки. Вот примеры списочных литералов:
(256, 512, 1024, 2048, 4096) # список из 5 чисел ('John', 'Paul', 'George', 'Ringo') # список из 4 строк ("Perl", 5.8) # список из строковых и числовых значений
Для записи списка текстовых строк, состоящих из одного слова, предусмотрена специальная форма списочного литерала, в которой после ключевого слова qw (сокращение от quoted words - "слова в кавычках") в скобках записываются строки, не заключенные в кавычки и разделяемые пробельными символами. В качестве скобок могут использоваться традиционные символы: (), {}, //, \\, [] , <> и даже просто парные символы, такие как !! или ##. Например:
qw(это очень удобно) # вместо ('это', 'очень', 'удобно') qw/John Paul George Ringo/ # список слов, расположенный на 2 строках
Элементами списочного литерала могут быть не только строки и числа, но также скалярные переменные и выражения. Пустой список не содержит элементов и представляется списочным литералом без значений (одними круглыми скобками).
('One', $x, $x+$y-$z, 2*5) # список литералов и выражений () # пустой список
Списочный литерал может содержать операцию диапазона, которая записывается в виде двух скалярных значений, разделенных двумя точками:
начальное_значение .. конечное_значение
В списочном контексте эта операция возвращает список значений. Возвращаемый список начинается со значения левого операнда, которое в цикле увеличивается на единицу, пока не будет достигнуто значение правого операнда. Приведем примеры:
5 .. 10 # возвратит список (5, 6, 7, 8, 9, 10) 5.3 .. 7.1 # возвратит список (5.3, 6.3), т. к. 7.3 > 7.1 7 .. 5 # возвратит пустой список (), т. к. 5 < 7 $m .. $n # диапазон, заданный значениями от $m до $n
Если операция диапазона применяется к строкам, то значения списка генерируются по правилам операции автоинкремента. С ее помощью удобно записывать различные списочные литералы:
(-2 .. 2) # список чисел (-2, -1, 0, 1, 2) (25, 53, 77 .. 79) # список (25, 53, 77, 78, 79) ('A'..'Z','a'..'z') # список заглавных и строчных букв ($start .. $finish) # список значений от $start до $finish
Если списочный литерал состоит только из имен переменных, то он может стоять в левой части операции присваивания, в правой части которой будет список присваиваемых значений. Переменным, стоящим слева от знака "равно", последовательно присваиваются значения соответствующих элементов списка из правой части операции.
($a, $b, $c) = (10 .. 12); # $a = 10; $b = 11; $c = 12; ($day, $month, $year) = (18, 12, 1987); # день рождения Perl ($m, $n) = ($n, $m); # поменять местами значения $n и $m
Если в списке слева от знака присваивания переменных больше, чем значений в списке в правой части, то оставшиеся переменные получают неопределенные значения:
($hh, $mm, $ss, $ms) = (10, 20, 30); # $ms не определено
Если в левой части присваивания переменных меньше, чем значений в правой, то лишние значения не используются.
($hh, $mm, $ss) = (10, 20, 30, 400); # 400 отброшено
Если в левой части присваивания стоит не список, а скалярная переменная, то устанавливается скалярный контекст, в котором литеральный список возвращает значение своего последнего элемента:
$scalar = (10, 20, 30, 400); # то же, что $scalar = 400;
Срезы
В Perl есть удобная форма обращения к нескольким элементам массива одновременно, называемая срезом массива. Срез (slice) - это набор элементов массива, заданный списком индексов этих элементов. Срез обозначается квадратными скобками после имени массива, в которых перечислены индексы элементов. Поскольку значение среза - это список, при записи среза перед именем массива сохраняется префикс @. Срез массива в частном случае может состоять из одного значения, заданного одним индексом. Вот примеры срезов массивов:
@array[0,1] # то же, что ($array[0], $array[1]) @array[5..7] # то же, что ($array[5],$array[6],$array[7]) @array[3,7,1] # то же, что ($array[3],$array[7],$array[1]) @array[@indexes] # срез, заданный массивом индексов @array[5] # список ($array[5]), а не скаляр $array[5]
С помощью срезов удобно одновременно манипулировать значениями нескольких элементов, находящихся в любом месте массива:
# присвоить значения пяти элементам: @array[5..9] = qw(FreeBSD Linux MacOS NetWare Windows); # поменять местами значения 1-го и последнего элементов: @array[0,-1] = @array[-1,0]; # напечатать элементы с индексами от $start до $finish print @array[$start .. $finish];
Срезы могут применяться не только к массивам, но и к любым спискам, в том числе литеральным.
Ассоциации и хэши
В программировании ассоциативные связи являются одним из основных видов связей между информационными объектами наряду с наследованием (связями типа "предок-потомок") и агрегацией (связями типа "часть-целое"). Ассоциации позволяют устанавливать необходимые логические связи между сущностями по избранному программистом критерию. Ассоциативная связь подобна стрелке на схеме, направленной от одного объекта к другому. Часто ассоциации используются для нахождения по заданной величине соответствующего значения. В этом случае две части ассоциативной связи соответственно называют поисковым ключом (key) и значением (value), ассоциированным с этим ключом. На этом принципе основана классическая структура данных, называемая словарем (dictionary).
В языке Perl для выражения ассоциаций имеются ассоциативные массивы или хэш-таблицы, которые для краткости принято называть хэшами. Хэш (hash) представляет из себя набор ассоциативных связей. Ключом хэша может быть любая скалярная величина: строка, ссылка, целое или дробное число, автоматически преобразуемое в строку. Причем значения всех ключей в хэше уникальны, поскольку внутренняя организация хэша не допускает ключей с одинаковыми значениями. Ассоциированное с ключом значение может быть любой скалярной величиной. Хэши сочетают в себе ряд привлекательных качеств: гибкость, мощь, быстроту и удобство работы. Поэтому они весьма часто используются при программировании на Perl самых различных задач. С помощью хэшей можно моделировать понятия из математики, информатики, лингвистики и других областей знаний: множества, словари, фреймы, семантические сети, программные объекты и простые базы данных. Размер хэша в Perl ограничен только доступной программе памятью, поэтому хэши позволяют эффективно обрабатывать большие объемы данных, в которых требуется выполнять быстрый поиск. Примечательно то, что в других языках ассоциативные массивы реализованы в виде коллекций объектов в библиотечных модулях, а в языке Perl хэши встроены в ядро языка, что обеспечивает их максимально эффективную работу.
Функции работы с хэшами
При обработке данных в хэше часто возникает необходимость проверить наличие в нем элемента с определенным ключом. Функция exists проверяет, содержится ли указанный ключ в хэше. Если ключ найден, она возвращает истинное значение ('1'), - и ложное значение (пустую строку), если такого ключа в хэше нет. При этом ассоциированное с ключом значение не проверяется и может быть любым, в том числе и неопределенным. Так можно проверить наличие ключа в хэше:
print "ключ $key найден" if exists $hash{$key};
При помощи функции defined(), возвращающей истинное или ложное значение, можно проверить, было ли задано значение в элементе хэша, ассоциированное с указанным ключом, или оно осталось неопределенным. Например:
print "с ключом $key связано значение" if defined $hash{$key};
Проверка с помощью функции defined($hash{$key}) отличается от проверки значения элемента на истинность значения $hash{$key}, так как значение элемента может быть определено, но равно нулю или пустой строке, что тоже воспринимается как ложь.
Воспользовавшись функцией undef(), можно удалить из хэша только значение элемента, не удаляя его ключа, то есть сделать его неопределенным:
undef $hash{$key }; # сделать значение неопределенным
После того как значение элемента было удалено функцией undef(), проверки наличия в хэше ключа и значения указанного элемента хэша дадут следующие результаты:
$hash{$key} # неопределенное значение - это ложь defined $hash{$key} # ложь, ибо значение не определено exists $hash{$key} # истина, ибо ключ есть
Неопределенное значение, хранимое в элементе хэша, означает, что необходимый поисковый ключ присутствует, но с ним не ассоциировано никакого значения.
Добавление элементов в хэш выполняется операцией присваивания, а удаление - функцией delete. Эта функция по указанному элементу удаляет из хэша соответствующую пару "ключ - значение" и возвращает только что удаленное значение. Это делается так:
$deleted_value = delete $hash{$key}; # удалить элемент
Если аргументом функции delete будет несуществующий элемент массива, то она просто вернет неопределенное значение, не вызвав ошибки при выполнении программы.
При работе с элементами хэша очень удобно иметь список всех его ключей. Его возвращает функция keys. Полученный список можно сохранить в массиве для дальнейшей обработки:
@hash_keys = keys %hash; # поместить список ключей в массив
Возможно также использовать список ключей для доступа в цикле ко всем значениям хэша. Так можно напечатать частотный словарь из предыдущего примера:
foreach my $word (keys %hash) { # для каждого ключа хэша print "$word встретилось $hash{$word} раз\n"; }
Элементы хэша, как и другие скалярные величины, помещенные в обрамленную двойными кавычками строку, заменяются своими значениями. Кстати, можно переписать последний пример, добавив сортировку ключей для вывода слов в алфавитном порядке. А для организации цикла можно применить модификатор foreach, совмещающий очередной элемент списка с переменной по умолчанию $_:
print "$_ встретилось $hash{$_} раз\n" foreach (sort keys %hash);
Следует помнить, что если размер хэша велик, то и полученный с помощью функции keys массив ключей тоже будет занимать большой объем памяти. В скалярном контексте функция keys возвращает количество ключей в хэше, поэтому с ее помощью можно легко проверить, не пустой ли хэш:
if (keys %hash) { # если scalar(keys(%hash)) != 0 # обработать элементы хэша, если он не пуст }
Пустой хэш в скалярном контексте возвращает ложное значение (строку '0'), а непустой - истинное. Поэтому проверить, пуст ли хэш, можно еще проще - употребив имя хэша в скалярном контексте, что часто используется в конструкциях, проверяющих условие:
while (%hash) { # или scalar(%hash) != 0 (не пуст ли хэш?) # обработать элементы хэша }
Встроенная функция values, дополняющая функцию keys, возвращает список всех значений элементов хэша в том же порядке, в каком функция keys возвращает ключи. С полученным списком можно поступать обычным образом: например, сохранить в массиве или обработать в цикле:
@hash_values = values %hash; # сохранить все значения хэша print "$_\n" foreach (values %hash); # вывести значения
В скалярном контексте функция values возвращает количество значений в хэше, так что ее можно использовать для того, чтобы узнать размер хэша. Например:
$hash_size = values %hash; # число значений в хэше
Функция each является встроенным итератором - программной конструкцией, контролирующей последовательную обработку элементов какой-либо коллекции данных. Она предоставляет возможность последовательно обработать все ассоциативные пары в хэше, организуя перебор всех его элементов. При каждом вызове она возвращает двухэлементный список, состоящий из очередного ключа и значения из хэша. Пары элементов возвращаются в неизвестном заранее порядке.
($key, $value) = each %hash; # взять очередную пару элементов
После того как будет возвращена последняя пара элементов хэша, функция each возвращает пустой список. После этого следующий вызов each начнет перебор элементов хэша сначала. С ее помощью удобно организовать обработку всех элементов хэша в цикле, который закончится, когда each вернет пустой список, означающий "ложь":
while (my ($key, $value) = each %hash) { # пока есть пары # обработать очередные ключ и значение хэша print "с ключом $key связано значение $value\n"; }
Иногда требуется искать ключи хэша по их значениям. Для этого нужно создать обратный ассоциативный массив (или инвертированный хэш), поменяв местами значения и ключи хэша. Это можно сделать так:
while (my ($key, $value) = each %hash_by_key) { # ключи хэша $hash_by_value{$value} = $key; # становятся значениями }
Этого же результата можно достичь с помощью функции reverse, воспользовавшись тем, что она воспринимает хэш как список, в котором за каждым ключом идет значение, и меняет порядок всех элементов этого списка на обратный. Функция reverse возвращает список, в котором в каждой паре элементов за значением следует ключ, и этот список присваивается новому хэшу:
%hash_by_value = reverse %hash_by_key; # переворот списка $key = $hash_by_value{$value}; # поиск по бывшему значению
Нечетные элементы инвертированного списка становятся ключами, а четные - значениями хэша %hash_by_value.
Хэши и контекст
Рассмотренный в этой лекции тип данных - хэш - не добавляет нового типа контекста: ключи и значения отдельных элементов хэша - это скалярные величины, а перечень всех элементов хэша, срезы хэша, выборки всех его ключей и всех его значений - это списки. Хотя переменная-хэш хранит особое значение - ассоциативный массив, но когда она применяется в левой части операции присваивания, она создает списочный контекст. На этом основаны приемы инициализации хэшей значениями списков. Поэтому же, например, при присваивании хэшу скалярной величины она рассматривается как список, состоящий из одного элемента, и этот элемент становится единственным ключом в хэше, с которым ассоциируется неопределенное (не присвоенное) значение:
%hash = $scalar; # то же, что %hash = ($scalar) # defined($hash{$scalar}) будет ложно: значения не было # exists($hash{$scalar}) будет истинно: ключ есть
В этой лекции завершается изучение основных типов данных в языке Perl: скаляров, списков и хэшей. В таблице 6.1 для сравнения приведены контексты и форматы обращения к скалярным переменным, элементам массивов и хэшей и их срезам.
| @variable | список | весь массив @variable | списочный |
| %variable | хэш | весь хэш %variable | списочный |
| $variable | скаляр | просто скалярная переменная | скалярный |
| $variable[$index] | скаляр | элемент массива @variable, заданный индексом $index | скалярный |
| @variable[@list] | список | срез массива @variable, заданный списком индексов @list | списочный |
| @variable[$index] | список (из одного элемента) | срез массива @variable, заданный списком из одного индекса $index | списочный |
| $variable{$key} | скаляр | элемент хэша %variable | скалярный |
| @variable{@list} | список (значений) | срез хэша %variable, заданный списком ключей @list | списочный |
| @variable{$key} | список (из одного значения) | срез хэша %variable, заданный списком из одного ключа $key | списочный |
Дополнительные сведения о хэшах можно узнать из справочной документации, обратившись к разделу о типах данных:
perldoc perldata
Хэши - это, наверное, самая популярная структура данных при программировании на Perl. Без них не обходится ни одна серьезная программа, ведь их применение делает многие алгоритмы проще, а программу - понятнее. Материал этой лекции показывает, насколько удобно и просто пользоваться хэшами. Особенный интерес представляет возможность хранения в ассоциативных массивах ссылок на другие структуры данных: массивы, хэши, объекты, подпрограммы. Это позволяет создавать сложные динамические структуры данных, о чем будет сказано в лекции 11, посвященной ссылкам.
perldoc perldata
Хэши - это, наверное, самая популярная структура данных при программировании на Perl. Без них не обходится ни одна серьезная программа, ведь их применение делает многие алгоритмы проще, а программу - понятнее. Материал этой лекции показывает, насколько удобно и просто пользоваться хэшами. Особенный интерес представляет возможность хранения в ассоциативных массивах ссылок на другие структуры данных: массивы, хэши, объекты, подпрограммы. Это позволяет создавать сложные динамические структуры данных, о чем будет сказано в лекции 11, посвященной ссылкам.
| © 2003-2007 INTUIT.ru. Все права защищены. |
Хэши и списки
Так как весь хэш, его ключи или значения можно легко преобразовать в список, то для обработки хэшей можно применять любые функции, работающие со списками. Именно поэтому в предыдущем примере была применена функция reverse. Например, вывести ключи и значения хэша на печать можно так:
{ # организовать блок, где объявить временный массив my @temp = %hash; # сохранить в нем хэш print "@temp"; # и передать его функции print } # по выходе из блока временный массив будет уничтожен
Можно напечатать хэш по-другому, построчно и в более облагороженном виде, при помощи функции map, которая также выполняет роль итератора:
print map {"Ключ: $_ значение: $hash{$_}\n" } keys %hash;
В этом примере на основании списка ключей, возвращенного функцией keys, функция map формирует список нужных строк, вставляя из хэша в каждую из них ключ и значение. Она возвращает сформированный список функции print, которая выводит его в выходной поток. Кстати, это типичный для Perl прием - обрабатывать данные при помощи цепочки функций, когда результат работы одной функции передается на обработку другой, как это принято делать с помощью конвейеров команд в операционных системах семейства Unix.
В приведенных выше примерах при необходимости обработки ключей хэша в алфавитном порядке они сортировались с помощью функции sort. Вот пример обработки хэша в порядке возрастания не его ключей, а его значений:
foreach $key ( # каждый элемент списка, sort # отсортированный по порядку {$hash{$a} cmp $hash{$b}}# значений, ассоциированных keys %hash) { # с ключами хэша print "значение:$hash{$key} ключ:$key\n"; # обработать } # в цикле
Здесь в блоке сравнения функции sort сопоставляется значения хэша, ассоциированные с очередными двумя ключами из списка, который предоставлен функцией keys.
Хэши - переменные и литералы
В программе хэш представляется в виде переменной, имеющей тип хэша, которая записывается с разыменовывающим префиксом % перед именем. Этот префикс обозначает, что это переменная-хэш, в которой хранится набор ассоциативных связей, иначе говоря, пар "ключ - значение":
%hash # переменная-хэш
Непосредственные величины ключей и значений хэша могут быть представлены в виде списочного литерала, который записывается как список в круглых скобках, состоящий из элементов хэша. Каждый элемент в литерале состоит из двух частей: поискового ключа и связанного с ним значения, разделенных символами =>, например:
('версия' => 5.8, 'язык' => 'Perl') # ключ - строка (3.14 => 'число Пи') # ключ - дробь (1 => 'one', 2 => 'two', 3 => 'three') # ключ - целое ($key1 => $value1, $key2 => $value2) # ключ в переменной
Операция => эквивалентна запятой, за исключением того, что она создает строковый контекст, так что ее левый операнд автоматически преобразуется к строке. Именно поэтому числа в этом примере записаны без кавычек. Литеральные списки, содержащие ассоциативные пары, обычно применяются для присваивания хэшам начальных значений:
%quarter1 = (1 => 'январь', 2 => 'февраль', 3 => 'март'); %dns = ($site => $ip, 'www.perl.com' => '208.201.239.36'); %empty = (); # пустой список удаляет все элементы хэша
Если в качестве ключа хэша используется переменная с неопределенным значением, то оно преобразуется в пустую строку, которая и станет поисковым ключом. Значения ключей в хэше уникальны, поэтому хэш часто используется для моделирования множества или простой базы данных с уникальным поисковым индексом. При добавлении нескольких элементов с одинаковыми ключами в хэше остается только последний добавленный:
%num2word = (10 => 'десять', 5 => 'пять', 10 => 'ten'); # в %num2word останется только (5 => 'пять', 10 => 'ten')
Ситуация, когда с поисковым ключом хэша ассоциируется неопределенное значение, считается нормальной. Это чаще всего означает, что связанное с ключом значение будет добавлено позднее.
Начальные значения элементов хэша могут браться из любого списка, при этом значения нечетных элементов списка становятся в хэше ключами, а четных - ассоциированными с этими ключами значениями. Так что два следующих присваивания эквивалентны:
%dictionary = ('я' => 'I', 'он' => 'he', 'она' => 'she'); %dictionary = ('я', 'I', 'он', 'he', 'она', 'she');
И конечно, для заполнения хэша элементами вместо списочного литерала можно использовать массив, содержащий пары "ключ - значение":
%dictionary = @list_of_key_value_pairs; # массив пар
В повседневной работе хэш заполняется данными из списка, который считывается из файла или генерируется при помощи пользовательской функции.
Следует иметь в виду, что, в отличие от массивов, элементы в хэше не упорядочены, и порядок следования элементов при добавлении элементов в хэш и при выборке их из хэша обычно не совпадает. Все значения, хранящиеся в хэше, можно преобразовать в список, если употребить переменную-хэш в списочном контексте в правой части операции присваивания. Вот так:
@key_value_list = %hash; # список ключей и значений
При этом в список будут помещены все ассоциативные пары из хэша, и ключи станут нечетными элементами списка, а значения - четными. Порядок копирования в массив ассоциативных пар заранее не известен.
Элементы хэшей
Хэши можно рассматривать как обобщение идеи массива, элементы которого индексируются не только целыми числами, а любыми скалярными значениями. При обращении к элементу хэша в фигурных скобках после имени переменной указывается значение поискового ключа. Поскольку значение элемента хэша - это скалярная величина, при обращении к элементу хэша перед именем переменной ставится префикс $, как у прочих скалярных значений.
$hash{$key} = $value; # добавление значения в хэш по ключу $value = $hash{$key}; # извлечение значения из хэша по ключу
Начинающие осваивать Perl могут думать про хэши, что это такие странные массивы ("ассоциативные"), у которых индексы могут быть не только числами, но и строками, и поэтому записываются эти необычные индексы не в квадратных скобках, а в фигурных (по-английски "curly braces" - "кучерявые скобки"). Вот примеры использования элементов хэша:
$month = 'January'; $days_in_month{$month}= 31; # со строкой связано число $ru{$month}= 'январе'; # со строкой связана строка print "В $ru{$month} $days_in_month{'January'} день";
В некоторых программах можно встретить при записи элементов хэша строковые ключи, не заключенные в кавычки: это допускается, если ключ - одно слово, записанное по правилам написания идентификаторов, так называемое "голое слово" ("bare word").
Имена хэшей компилятор располагает в другой таблице имен, чем имена массивов или скаляров, поэтому три приведенные ниже переменные абсолютно разные:
$variable # скалярная переменная @variable # переменная-массив %variable # переменная-хэш
Типичным применением хэша можно считать составление частотного словаря, в котором со значением каждого слова ассоциируется счетчик его появления в тексте. Для простоты предположим, что слова в файле, содержащем текст, разделены только пробелами:
while (my $line = <>) { # считать строку из входного потока chomp($line); # удалить из строки символ '\n' @words = split(' ', $line); # разбить строку на слова foreach my $word (@words) { # для каждого найденного слова $hash{$word}++; # увеличить счетчик } } # теперь в %hash содержатся счетчики слов
Позднее, в лекции, посвященной регулярным выражениям, будет сказано, как выделять из строки слова не только по пробелам. Как это было сделано в последнем примере, программисты часто пользуются уникальностью ключей в хэше, чтобы исключить дублирование данных. Для удаления из данных повторений достаточно поместить их в хэш в качестве ключей. При этом даже не обязательно ассоциировать с ключами какие-либо значения. В результате набор ключей хэша будет гарантированно содержать только неповторяющиеся значения из обработанного набора данных.
Специальные хэши
Исполняющая система Perl предоставляет программисту доступ к специальным ассоциативным массивам, в которых хранится полезная служебная информация. Вот некоторые из специальных хэшей:
%ENV перечень системных переменных окружения (например, PATH) %INC перечень внешних программ, подключаемых по require или do %SIG используется для установки обработчиков сигналов от процессов
Например, так при выполнении программы можно использовать значения переменных окружения: перечислить все их значения или выбрать нужные.
foreach my $name (keys %ENV) { print "$name=$ENV{$name}\n"; } ($who, $home) = @ENV{"USER", "HOME"}; # под Unix ($who, $home) = @ENV{"USERNAME", "HOMEPATH"}; # и Windows XP
Срезы хэшей
Подобно тому, как при работе с массивами срезы позволяют работать со списком элементов, в Perl есть возможность обращаться сразу с несколькими элементами хэша. Это делается с помощью среза хэша. Срез хэша (hash slice) - это список значений хэша, заданный перечнем соответствующих ключей. Он записывается в виде имени хэша с префиксом @ (так как срез - это список), за которым в фигурных скобках перечисляются ключи. Список ключей в срезе хэша можно задать перечислением скалярных значений, переменной-списком или списком, возвращенным функцией. Например, так:
@hash{$key3, $key7, $key1} # срез хэша задан списком ключей @hash{@key_values} # срез хэша задан массивом @hash{keys %hash} # то же, что values(%hash)
Если в срезе хэша список ключей состоит из единственного ключа, срез все равно является списком, хотя и из одного значения. Сравните:
@hash{$key} # срез хэша, заданный списком из одного ключа $hash{$key} # значение элемента хэша, заданное ключом
Поскольку переменная-хэш в составе строки не интерполируется, для вставки в строку всех значений хэша можно воспользоваться срезом хэша:
%hash = ('0' => 'false', '1' => 'true'); "@hash{keys %hash}"; # будет "false true" или "true false"
Срез хэша, как и любой другой список, может стоять в левой части операции присваивания. При этом списку ключей среза должен соответствовать список присваиваемых значений в правой части присваивания. Воспользовавшись срезом, можно добавить в хэш сразу несколько пар или объединить два хэша, добавив к одному другой. Например:
@hash{$k1, $k2, $k3}= ($v1, $v2, $v3); # добавить список @old{keys %new}= values %new; # добавить хэш %new к %old
С помощью среза хэша и функций keys и values можно поменять в хэше местами ключи и значения, то есть сделать значения ключами, а ключи - значениями.
@hash_keys = keys %hash; # сохранить ключи в массиве @hash_values = values %hash; # сохранить список значений %hash = (); # очистить хэш @hash{@hash_values}=@hash_keys; # срезу хэша присвоить список
Функции для работы с символами
Иногда требуется работать не со строками и словами текста, а с его отдельными символами. В Perl есть необходимые средства работы с символами, хотя в нем нет специального типа данных, представляющих один символ, подобно типу char в других языках. Один символ из строки можно скопировать функцией substr($string, $index, 1).
С помощью заимствованных из языка Pascal функций ord() и chr() выполняются преобразования символа (а точнее односимвольной строки) в его ASCII-код и наоборот:
$code = ord($char); # ord('M') вернет число 77 $char = chr($code); # chr(77) вернет строку 'M' # синоним: $char = sprintf("%c", $code);
Разбить строку на отдельные символы и поместить их в массив можно с помощью уже знакомой функции split() с пустой строкой в качестве разделителя:
@array_of_char = split('', $string);
С помощью списков и нескольких вызовов функции substr() можно поменять в строке местами символы с указанными индексами, например, 1 и 11:
$s = 'кОт видел кИта'; (substr($s, 1, 1), substr($s, 11, 1)) = (substr($s, 11, 1), substr($s, 1, 1)); # в $s будет 'кИт видел кОта'
Известная по лекции о списках функция reverse() в скалярном контексте возвращает значение текстового выражения, в котором символы переставлены в обратном порядке, например:
$palindrom = 'А РОЗА УПАЛА НА ЛАПУ АЗОРА'; $backwards = reverse($palindrom); # в $backwards будет 'АРОЗА УПАЛ АН АЛАПУ АЗОР А'
Обрабатывать отдельные байты, в том числе и символы, можно также при помощи функций pack() и unpack(), которые предназначены для преобразования любых данных и будут рассмотрены в лекции, посвященной вводу-выводу.
Функции для работы со строками
В предыдущих лекциях уже упоминались функции, обрабатывающие символьную информацию:
chomp(), удаляющая в конце строки символ-разделитель записей;chop(), отсекающая любой последний символ строки;join(), объединяющая элементы массива в одну строку;split(), разделяющая строку на список подстрок.
В этой лекции мы познакомимся с другими встроенными функциями для работы с текстом. Хотя в приведенных далее примерах аргументы функций заключены в круглые скобки, использование скобок при вызове встроенных функций необязательно, если не возникает неоднозначности определения аргументов функции.
Часто требуется выяснить, содержит ли строка ту или иную подстроку. Функция index() выполняет поиск подстроки в строке, начиная с определенного смещения, и возвращает номер позиции найденной подстроки. Функция rindex() ищет подстроку от конца строки и возвращает позицию последней подстроки в строке перед указанным смещением. Смещение можно не указывать, тогда поиск производится во всей строке. Номера позиций подстроки и смещения начинаются с нуля. Если подстрока не найдена, возвращается -1. Например:
$pos = index($string, $sub_string, $offset); # с начала $last_pos = rindex($string, $sub_string, $offset); # с конца print "есть правда!" if(index($life, 'правда') != -1);
В следующей главе будет рассказано о регулярных выражениях, с помощью которых можно гибко управлять поиском подстроки, задавая шаблоны приблизительного соответствия и расположение подстрок относительно друг друга.
Определение длины текста - также весьма распространенная операция. Функция length() возвращает длину в символах значения строки или выражения, возвращающего строку или преобразованного к строке:
$string_length = length($string); # строка в переменной $n *= 2 until(length($n)>10); # длина числа print 'Текст слишком длинный' if length($s1 . $s2) > $limit;
Функция substr(), выполняющая выделение подстроки из строки, всегда была очень популярной в большинстве языков (кроме Perl, в котором это действие чаще выполняется с помощью регулярных выражений). Она копирует из строки подстроку заданной длины, начиная с указанного смещения. Если смещение отрицательное, то оно отсчитывается от конца строки. Если длина подстроки не задана, то копируется строка после смещения до самого конца:
$sub = substr($string, # копировать в $sub из $string, $offset, # отступив $offset символов, $length); # подстроку длиной $length $e = substr($s, rindex($s,'.')); # от последней '.' до конца $last_char = substr($string, -1, 1); # последний символ
Необычность функции substr() в Perl состоит в том, что она может применяться для изменения строки, относясь к группе так называемых левосторонних функций, которые могут употребляется в левой части операции присваивания. В этом случае значение, стоящее в правой части присваивания, заменяет подстроку, которая извлекается из строки функцией substr(), стоящей слева от знака присваивания. Например, вот так можно подстроку длиной в два символа, начинающуюся с символа с индексом 5, заменить новой строкой:
$string = 'Perl 5 нравится программистам.'; $new_string = '6 тоже по'; substr($string, 5, 2) = $new_string; # в $string будет: 'Perl 6 тоже понравится программистам.'
Подобным же образом можно удалить последние 5 символов строки, заменив их пустой строкой:
substr($string, -5) = ''; # удалить последние 5 символов
Сочетая уже известные функции, можно выполнять разные манипуляции с текстовой информацией. Например, чтобы переставить слова в строке, можно воспользоваться функциями split(), reverse() и join() в списочном контексте:
$reverse_words = join(' ', reverse(split(' ', $text)));
В Perl есть набор функций для преобразования букв из заглавных в строчные и наоборот. Для правильного преобразования русских букв нужно включить поддержку национальных установок операционной системы с помощью прагмы use locale. Преобразовать текст к нижнему регистру (lower case) можно с помощью функции lc(), которая возвращает значение текстового выражения, преобразованное к строчным буквам:
use locale; # учитывать национальные установки $lower_case = lc($text); # преобразовать к маленьким буквам
К верхнему регистру ( upper case) преобразовать текст можно с помощью функции uc(), которая возвращает значение символьного выражения, преобразованное к заглавным буквам.
use locale; $upper_case = uc($text); # преобразовать к большим буквам
Функция ucfirst() возвращает значение строкового выражения, в котором только первый символ преобразован к верхнему регистру. Так, например, можно записать имя собственное с заглавной буквы:
$capitalized = ucfirst($name); # 'ларри' станет 'Ларри'
Встроенная функция crypt() выполняет шифрование строки, переданной ей в качестве аргумента, используя второй аргумент в качестве "затравки" (salt) для шифрования:
# незашифрованная строка из $plain шифруется в $crypted $crypted = crypt($plain, $salt);
Эта функция не имеет парной расшифровывающей функции и чаще всего используется для сравнения открытого текста с существующей зашифрованной строкой, как это делается в следующем примере:
if (crypt($plain, $salt) eq $crypted) { # открытый текст совпал с зашифрованным }
Функция quotemeta() находит в символьном выражении метасимволы (о которых пойдет речь в следующей лекции) или escape-последовательности и возвращает строку, где у всех специальных символов отменено их особое значение: для этого перед каждым из них ставится символ обратной косой черты '\'.
$string_with_meta = '\n \032 \x00 text \t \v "'; $quoted = quotemeta($string_with_meta); # в $quoted будет '\\n\ \\032\ \\x00\ text\ \\t\ \\v\ \"'
В Perl имеется несколько функций преобразования строкового представления числа в числовое значение. Функция hex() возвращает десятичное значение выражения, представленного как шестнадцатиричное число в виде строки:
$hexadecimal_as_string = '0x2F'; $decimal_number = hex($hexadecimal_as_string); # будет 47
Функция oct() возвращает десятичное значение строкового выражения, представляющего запись восьмеричного числа:
$octal_as_string = '0777'; $decimal_number = oct($octal_as_string); # будет 511
С помощью oct() можно также преобразовать к десятичному значению двоичное или шестнадцатиричное число, записанное в виде строки:
$binary_as_string = '0b011001'; $decimal_number = oct($binary_as_string); # будет 25 $hexadecimal_as_string = '0x19'; $decimal_number = oct($hexadecimal_as_string); # будет 25
Ну а строку, содержащую число в десятичной системе счисления, можно преобразовать к числу, поместив ее в числовой контекст:
$pi_as_string = '3.141592653'; # число Пи в виде строки $circle_length = 2 * $pi_as_string * $radius;
Функция sprintf() возвращает строку, которая сформирована в соответствии с правилами форматирования, заимствованными из языка C: на основе формата преобразования, заданного первым аргументом, в результирующую строку подставляются отформатированные значения из списка остальных аргументов функции. В общем виде вызов этой функции выглядит так: sprintf(ФОРМАТ, СПИСОК АРГУМЕНТОВ). В формате преобразования располагается любой текст, в котором могут присутствовать указания преобразования. Каждое указание начинается с символа процента (%) и заканчивается символом, определяющим преобразование. Основные преобразования приведены в таблице 7.2.
| %% | Знак процента | % | |
| %c | Символ с указанным номером в кодовой таблице | Character | |
| %s | Строка | String | |
| %d | %i | Целое со знаком в десятичном виде | Decimal, Integer |
| %u | Целое без знака в десятичном виде | Unsigned | |
| %b | Целое без знака в двоичном виде | Binary | |
| %o | Целое без знака в восьмеричном виде | Octal | |
| %x | %X | Целое без знака в шестнадцатеричном виде | heXadecimal |
| %e | %E | Целое с плавающей точкой в научной нотации | Exponential |
| %f | %F | Число с плавающей точкой в виде десятичной дроби | Float |
| %g | %G | Число с плавающей точкой в формате %e или %f |
| число | Минимальная ширина поля вывода для результата преобразования; если она не задана или меньше ширины значения, то устанавливается равной ширине выводимого значения | '<%5s>', 25 | < 25> |
| .число | Количество цифр после десятичной точки в дробном числе | '<%.5f>', 0.25 | <0.25000> |
| Максимальная ширина поля вывода, до которой усекается длинная строка | '<%.5s>', '5' x 10 | <55555> | |
| пробел | Вывод пробела перед положительным числом | '<% d>', 25 | '< 25>' |
| + | Вывод плюса перед положительным числом | '<%+d>', 25 | '<+25>' |
| 0 | Вывод нулей, а не пробелов при выравнивании по правому краю поля | '<%05s>', 25 | '<00025>' |
| - | Выравнивание значения по левому краю поля | <%-5s>, 25 | '<25 >' |
| # | Вывод перед восьмеричным числом 0, перед шестнадцатеричным числом 0x, перед двоичным числом 0b | '<%#x>',25 | '<0x19>' |
При выполнении sprintf() к очередному значению из списка аргументов применяется преобразование, результат которого вставляется в форматирующую строку на место указания преобразования. Например, если шаблон форматирования и аргументы функции sprintf() заданы так:
$format = "'%12s' агента <%03d> = '%+-10.2f'"; @list = ('Температура', 7, 36.6); $formatted_string = sprintf($format, @list);
то после выполнения приведенного предложения в переменной $formatted_string будет содержаться такая отформатированная строка:
' Температура' агента <007> = '+36.60 '
Преобразования в формате этого примера обозначают следующее:
%12s - преобразовать аргумент в строку (string) и поместить в поле шириной в 12 символов с выравниванием вправо (т. к. ширина поля положительная);%03d - преобразовать аргумент в десятичное целое (decimal) и поместить в поле шириной в 3 цифры с ведущими нулями (т. к. ширина поля задана с ведущим нулем) и выравниванием вправо (поскольку ширина положительная);%+-10.2f - преобразовать аргумент в дробное число (float) с явным знаком (т.к. указан +) и поместить в поле шириной в 10 цифр, из которых 2 отводятся на дробную часть, с выравниванием влево (поскольку ширина поля отрицательная).
Функция sprintf() часто применяется для округления чисел - например, до трех знаков в дробной части:
$rounded = sprintf("%.3f", 7/3); # в $rounded будет 2.333
Полное описание форматов с самыми разными примерами их употребления можно прочитать в официальной документации:
perldoc -f sprintf
В дополнение к функции sprintf() имеется функция printf(), которая использует тот же самый формат преобразования, но выводит отформатированный результат в указанный выходной поток.
Поддержка Unicode
В современном мире уже не работает формула "один символ - это один байт". Необходимость представления текстов, одновременно содержащих символы разных естественных языков, привела к появлению ряда стандартов, часто объединяемых под общим названием Unicode и разработанных международным Консорциумом Unicode. Многочисленные национальные символы языков мира кодируются последовательностями из нескольких байтов. Unicode предлагает несколько форм представления символов в виде форматов преобразования Unicode (Unicode Transformation Format, UTF) и наборов символов Unicode (Unicode Character Set, UCS). Стандарты UCS-2 и UCS-4 представляют из себя кодировки фиксированной длины по два и четыре байта. Из кодировок переменной длины самым популярным стал стандарт UTF-8, использующий для кодирования одного символа от одного до шести байт. Начиная с версии 5.6, Perl поддерживает обработку символов в кодировках Unicode. В Perl применяется кодирование символов последовательностями чисел переменной длины на основе представления UTF-8. Есть возможность записывать многобайтовые (multi-byte) символы в виде литералов, а также выполнять ввод-вывод Unicode-символов.
Для записи в исходной программе символов Unicode в представлении UTF-8 нужно включить обработку строк в этом формате прагмой use utf8. После этого многобайтовые символы могут использоваться наравне с однобайтовыми, например, в качестве ключей в хэшах:
use utf8; # включить поддержку UTF-8 $hash{'?'} = 3.141592653; # пи (код \x{03C0}) print "$hash{'?'}\n"; # будет выведено: 3.141592653
Можно даже использовать национальные алфавиты для записи идентификаторов переменных. Например, кириллицу или греческий:
use utf8; $скаляр = 25; # имя скаляра на русском $? = $скаляр + 53; # имя скаляра на греческом print "$скаляр $?\n"; # будет выведено: 25 78 @массив = ($?, $скаляр); # имя массива на русском print "@массив\n"; # будет выведено: 78 25
Для ввода текста подобной программы понадобится редактор, поддерживающий работу с Unicode. Например, в операционной системе MS Windows это можно сделать с помощью программы Notepad. А в ОС GNU/Linux для редактирования этого текста можно воспользоваться редактором KWrite или Kate. Если такой возможности нет, то символы Unicode можно записывать в программе с помощью escape-последовательностей, о чем было рассказано в лекции 2. Примеры escape-кодов для записи символов Unicode приведены во фрагменте программы далее в этой лекции.
Скалярные значения в Perl имеют специальный "признак utf8" (utf8 flag), который устанавливается, когда значение представлено в UTF-8. В этом случае правильно выполняется обработка многобайтовых символов встроенными функциями chr(), index(), length(), ord(), rindex(), substr(). Это видно на таком примере:
use utf8; $u = "€500"; # знак евро (escape-код \x{20AC}) print "Длина=", length($u), "\n"; # Длина=4 $u = '???'; # коды \x{221E}, \x{2260}, \x{221E} print "Бесконечности не равны\n" if $u eq reverse '???';
Переключить встроенные функции на работу не с символами, а с байтами можно с помощью прагмы use bytes. Снова переключиться на работу функций не с байтами, а с символами можно с помощью прагмы no bytes. Подключив прагмой use Encode стандартный модуль преобразования можно преобразовать обычную строку в строку символов Unicode с помощью функции encode(), возвращающей символьную строку в представлении UTF-8. Обратное преобразование выполняет функция decode():
use Encode; my $cp1251 = 'Привет!'; # строка в кодировке windows-1251 my $utf8 = encode('utf8', $cp1251); # преобразуется в UTF-8 my $win_ru = decode('utf8', $utf8); # и наоборот
Поддержка наборов символов Unicode в Perl имеет свои особенности, связанные с обеспечением совместимости со старыми байт-ориентированными программами, но эти особенности заслуживают отдельного продолжительного разговора за рамками данного учебного курса.
В этой лекции рассмотрены средства работы с символьной информацией в Perl, достаточные для решения типичных задач обработки текста. Но вся прелесть языка Perl и его мощь открываются только тем, кто освоит регулярные выражения, о которых пойдет речь в следующей лекции.
Преобразующие escape-последовательности
Кроме escape-последовательностей, описанных в лекции 2, в Perl есть особые управляющие последовательности, предназначенные для преобразования символов в строковом литерале. Они приведены в таблице 7.1. С их помощью преобразуется либо один символ, следующий за escape-последовательностью, либо несколько символов до отменяющей последовательности.
| \u | Upper case | преобразовать следующий символ к верхнему регистру |
| \l | Lower case | преобразовать следующий символ к нижнему регистру |
| \U | Upper case | преобразовать символы до \E к верхнему регистру |
| \L | Lower case | преобразовать символы до \E к нижнему регистру |
| \Q | Quote | отменить специальное значение символов вплоть до \E |
| \E | End | завершить действие \U или \L |
Применение этих преобразующих escape-последовательностей можно проиллюстрировать такими примерами:
use locale; # для правильной обработки кириллицы $name = 'мария'; # будем преобразовывать значение переменной print "\u$name"; # будет выведено: Мария print "\U$name\E"; # будет выведено: МАРИЯ print "\Q$name\E"; # будет выведено: \м\а\р\и\я
Аналогичного результата можно достигнуть при использовании некоторых строковых функций, о которых пойдет речь далее в этой лекции.
Строковые литералы
Уже известные из лекции 2 строковые литералы, заключаемые в апострофы и двойные кавычки, могут записываться в альтернативной форме:
'строка в апострофах' или q(строка в апострофах) "строка в кавычках" или qq(строка в кавычках)
Подобно литеральному списку слов qw(), упомянутому в лекции лекции 5, строковые литералы в этом формате могут ограничиваться разными скобками и практически любыми парными символами: (), {}, [] , <>, //, \\, !! и так далее. Конечно, применение в качестве ограничителей строк таких символов, как &&, ||, %%, ##, '' или $$, допустимо, но не рекомендуется, поскольку может ввести в заблуждение читателя программы. Правила интерполяции действуют и на эту форму записи строковых литералов.
В Perl есть особенные строки, очень похожие на литералы: это строки, заключенные в обратные апострофы (back-quotes, backticks) ``, для которых также есть эквивалентная запись в виде qx(). Особенность таких строк заключается в том, что их содержимое рассматривается как синхронный вызов внешней программы или команды операционной системы, которая выполняется во время работы Perl-программы. Фактически это операция выполнения программы. Результат выполнения указанной внешней программы становится значением конструкции qx(). При этом в ней производится интерполяция. Так, например, в среде MS Windows или Linux с помощью команды dir можно получить список MP3-файлов и поместить его в переменную:
$music_files = `dir *.mp3`; # или qx(dir .\*.mp3)
Таким же образом можно легко воспользоваться услугами любой другой программы. Недаром Perl часто называют "склеивающим языком" (glue language): с помощью Perl-программы можно обращаться к имеющимся программам, получать результат их выполнения и обрабатывать его по усмотрению программиста. Так, упомянутый в лекции 1 прием использования программ-фильтров получил в Perl дальнейшее развитие. Другие примеры использования операции выполнения программы приведены в лекции 16.
Встречается еще один тип строковых литералов, называемых V-строки ("V-strings" - строки версий), хотя он считается устаревшим и может не поддерживаться в будущем.
v1.20.300.4000 # то же, что "\x{1}\x{14}\x{12c}\x{fa0}" v9786 # "смайлик" ? (символ Unicode \x{263A}) v79.107.33 # строка 'Ok!' 79.107.33 # в литерале с несколькими точками можно без "v"
V-строки полезны для сравнения "номеров" версий с помощью операций строкового сравнения, например:
$version = v5.8.7; print "Версия подходит\n" if $version ge v5.8.0;
V-строки иногда также применяются для записи сетевых адресов IPv4, например: v127.0.0.1.
Текст и строки
Язык программирования Perl, в первую очередь, получил широкую известность как средство обработки текстовой информации - удобное, быстрое, мощное, гибкое. Ларри Уолл создал Perl, чтобы облегчить свою жизнь, когда ему, молодому системному администратору, пришлось заниматься обработкой больших объемов данных, преимущественно текстовых. Удобство работы с текстом заложено практически во всех языковых конструкциях: например, строковый контекст включает автоматическое преобразование чисел и ключей хэша к строкам. В систему программирования Perl встроены необходимые функции для работы с символьной информацией. Наверное, самое мощное средство работы с текстовой информацией - обработка регулярных выражений - эффективно реализована в ядре Perl. Дополнительные средства обработки текста реализованы в стандартных библиотеках. Еще больше функций и классов для работы с текстовыми данными можно найти в модулях из репозитория CPAN.
Текстовая информация хранится в Perl-программе в скалярных переменных. Поскольку Perl не накладывает искусственных ограничений на использование ресурсов компьютера, обычная практика в программах на Perl - считывание всего текста из файла вместе с разделителями строк в одну скалярную переменную, чтобы затем эффективно обработать его. Поэтому в Perl переменные, содержащие символьные данные, называют "строковыми" лишь для краткости, чтобы не говорить "скалярная переменная, содержащая строковое значение".
Встроенные документы
Еще одним видом непосредственной записи в программе текстовой информации являются так называемые встроенные документы (here-documents). Эта конструкция, заимствованная из командного языка Unix, представляет из себя встроенный в программу произвольный текст. Встроенный документ начинается символами <<, за которыми без пробелов указывается ограничитель, отмечающий конец документа. Все строки, начиная со следующей, рассматриваются как содержимое этого документа до тех пор, пока не встретится строка, состоящая только из указанного ограничителя. Обозначающий конец встроенного документа ограничитель должен записываться на отдельной строке с самого ее начала.
$here_document = <<END_OF_DOC; Здесь располагается текст встроенного документа, ограничитель которого записывается с начала на отдельной строке. END_OF_DOC
Если желательно записывать ограничитель с пробелами, то его нужно заключить в кавычки, а если он записан кириллицей, то нужно прагмой use locale включить учет национальных установок:
use locale; $here_document = <<'КОНЕЦ ДОКУМЕНТА'; ЭТО НЕ КОНЕЦ ДОКУМЕНТА КОНЕЦ ДОКУМЕНТА
Во встроенных документах производится интерполяция переменных, если только ограничитель here-документа не заключен в одинарные апострофы. Поэтому встроенные документы часто применяются для комбинирования предварительно отформатированного текста со значениями переменных, как это сделано в следующем примере:
$here_document = <<"END_OF_DOCUMENT"; # присваивание строке Уважаемый $guests[$n]! Приглашаем Вас на презентацию книги "$title", которая состоится $date в $time. Оргкомитет. END_OF_DOCUMENT print $here_document, '-' x 65, "\n";
Например, с помощью here-документа легко и удобно программно создать HTML-страницу, вставляя в нее нужную информацию:
$web_page = <<HTML; # поместить here-документ в переменную <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"> <html> <head> <meta http-equiv="content-type" content="text/html; charset=$encoding"/> <meta name="author" content="$author"/> <title>$title</title> </head> <body> <h3 style="text-align: center;">$header</h3> <div align="justify">$article{$number}</div> <p><a href="$hyperlink">Вернуться к разделу $topic</a><p> <hr/><small>Copyright © $year, $author.</small> </body> </html> HTML
Это один из способов динамического создания на web-сервере гипертекстовых страниц в ответ на запрос информации, например, хранимой в базе данных.
Извлечение соответствий
Когда операция сопоставления находит в строке соответствие указанному регулярному выражению, она присваивает результаты своей работы нескольким специальным переменным:
в переменную $` помещается часть строки до найденного соответствия;в переменную $& помещается часть строки, соответствующая образцу;в переменную $' помещается часть строки после найденного соответствия;в переменную $+ помещается последнее найденное совпадение для последнего шаблона в скобках.
Если поиск окончился неудачей, то этим переменным новые значения не присваиваются. Посмотрим на примере, что сохранится в этих переменных после поиска такого соответствия:
$htm= "<A HREF='http://regexp.ru/'>Регулярные выражения</A>"; $htm =~ m|HREF=["'](\S+?)["']>|; # поиск URL сайта
При успешном совпадении с шаблоном в специальные переменные будут помещены такие значения:
$` = '<A ' $& = 'HREF='http://regexp.ru/'>' $' = 'Регулярные выражения</A>' $+ = 'http://regexp.ru/'
Значениями этих переменных можно пользоваться при успешном сопоставлении с образцом, например:
print $& if $text =~ m/$pattern/; # выведет соответствие
В регулярном выражении можно указать, что при успешном сопоставлении строки с шаблоном найденные соответствия нужно сохранить для дальнейшей обработки. С этой целью запоминаемые части шаблона нужно заключить в круглые скобки. Это также называется захватом значений. Найденные совпадения для всех заключенных в скобки частей шаблона будут доступны через специальные переменные с именами $1, $2 и так далее. Составим регулярное выражение для поиска и сохранения в служебных переменных информации о сайте в том же тексте:
$pattern = q|HREF=["'](\S+?)["']>([^<]+?)</A>|; # шаблон $htm =~ m/$pattern/; # поиск соответствия в $htm # в $1 = 'http://regexp.ru/' # в $2 = 'Регулярные выражения'
Сохраненные совпадения доступны и во время обработки регулярного выражения, но через переменные с именами \1, \2 и так далее. Эти переменные называются обратными ссылками (backreference) на найденные соответствия. Так, например, можно найти два одинаковых слова, стоящих в тексте друг за другом через пробелы (возможно, по ошибке):
my $string = "Уже скоро скоро наступит весна!"; my $pattern = '(\S+)\s+\1'; # (\S+) сохранит значение 'скоро' в \1 $string =~ m/$pattern/; # соответствие: 'скоро скоро'
Операция сопоставления, употребленная в списочном контексте, возвращает список найденных соответствий, для которых было предусмотрено сохранение значений. Поэтому удобно сохранять найденные значения в массиве или в списке скалярных переменных. Например, извлечем из текстовой строки последовательность цифр, похожую на время:
my $text = 'Начало в 12:25:00.'; # строка с данными my $pattern = '(\d\d):(\d\d):(\d\d)'; # образец для поиска my @time = $text =~ m/$pattern/; # сохраним в массиве my ($hh, $mm, $ss) = $text =~ m/$pattern/; # и в списке
Можно находить любое количество соответствий образцу в одной операции сопоставления. Это делается с помощью модификатора глобального поиска.
Классы символов
С помощью метасимволов можно обозначить в шаблоне один символ из заданного набора. Для этого нужно определить класс символов, указав в квадратных скобках набор символов, включаемых в класс. Классы символов похожи на шаблон с вариантами, в котором альтернативами могут быть только отдельные символы. Ради примера запишем шаблон для слов, отличающихся первой буквой из указанного набора:
/[вклрт]от/ # соответствуют: 'вот','кот','лот','рот','тот'
Вот пример шаблона с несколькими классами символов, каждый из которых представляет одну букву в последовательности из четырех символов:
/[мс][ул][хо][ан]/ # соответствуют: 'муха', 'слон' # а также: 'суоа', 'млхн', 'слоа' и так далее
В классе символов вместо перечисления можно указывать диапазон от начального до конечного символа, разделенных минусом:
[0-9] вместо [0123456789] [A-Z] вместо [ABCDEFGHIJKLMNOPQRSTUVWXYZ]
Указывая несколько диапазонов в одном классе, запишем шаблон для шестнадцатеричной цифры:
/[0-9a-fA-F]/# соответствуют: '5', 'b', 'D' и так далее
Чтобы включить в символьный класс знак '-', нужно поместить его в начале или в конце перечисленных в классе символов или экранировать обратной чертой. Помещенные в символьный класс, все метасимволы (кроме ']') рассматриваются как обычные символы. Поэтому так могут выглядеть шаблоны для поиска знака препинания или одной из скобок:
[-.,;:!?] # знаки препинания [()[\]{}] # скобки: \] представляет скобку ']'
Иногда требуется выразить понятие "все, кроме указанных символов": для этого в описании класса символов сразу после открывающей квадратной скобки ставится метасимвол отрицания ('^'). Например, так можно записать шаблоны для "любого символа, кроме знаков препинания" или "любого нецифрового символа":
[^-.,;:!?] # все, кроме этих знаков препинания [^0-9] # не цифры
Чтобы включить в символьный класс символ '^', нужно поставить его не первым в списке символов или отменить его специальное значение с помощью символа '\':
[*^] или так: [\^]
Для сокращенной записи классов символов в регулярных выражениях предусмотрены специальные обозначения, состоящие из латинской буквы с обратной косой чертой перед ней. Вот они:
\d - любая десятичная цифра, то есть [0-9] \D - любой символ, кроме цифры: [^0-9] или [^\d] \w - символ, пригодный для записи идентификатора:[a-zA-Z0-9_] \W - противоположность символа \w, то есть [^\w] \s - пробельный символ: пробел, \t, \n, \r или \f \S - любой не пробельный символ, то есть [^\s]
С помощью этих метасимволов можно составлять гораздо более интересные образцы. Например, проверим, содержится ли в тексте число из четырех цифр, окруженное любыми пробельными символами:
$text = "Альбом 'Dire Straits'\tГод 1978\tВремя 41:21"; $text =~ m{\s\d\d\d\d\s}; # найдет ' 1978\t'
Записывать несколько метасимволов подряд для указания в шаблоне последовательности из однотипных символов утомительно и неудобно, да и ошибиться при этом легко. Облегчить жизнь составителям регулярных выражений помогают квантификаторы.
Квантификаторы
Квантификатор (quantifier) - это обозначение числа повторений предыдущего шаблона при поиске соответствия. Количество повторений может задаваться одним или парой десятичных чисел в фигурных скобках:
{n} повторяется точно n раз {n,} повторяется n и более раз {n,m} повторяется от n до m раз включительно
Квантификатор, также иногда называемый множителем, указывается сразу после конструкции в шаблоне, которую нужно повторить несколько раз, например:
/\d{5}/ # ровно пять цифр, то есть: \d\d\d\d\d /\s{1,}/ # один и более пробельных символов /[A-Z]{1,8}/ # от 1 до 8 заглавных латинских букв
Опишем с применением квантификаторов шаблон для поиска в тексте последовательности, похожей на телефонный номер, в следующем формате:
символ + \+ код страны: не менее 1 цифры \d{1,} открывающая скобка ( \( код города: 3 цифры и более \d{3,} закрывающая скобка ) \) номер абонента: от 4 до 7 цифр \d{4,7}
Перед знаками "+", "(" и ")" ставится обратная наклонная черта, чтобы они не воспринимались как метасимволы. Вот какое регулярное выражение получится в результате:
m"\+\d{1,}\(\d{3,}\)\d{4,7}"
Для наиболее часто встречающихся квантификаторов предусмотрены удобные односимвольные сокращения:
* повторяется 0 или более раз: то же, что {0,} ? повторяется не более 1 раза: то же, что {0,1} + повторяется как минимум 1 раз: то же, что {1,}
Составим регулярное выражение с использованием односимвольных квантификаторов, чтобы найти в тексте "идентификатор, перед которым могут стоять пробельные символы и за которым стоит хотя бы один из перечисленных знаков препинания":
m/\s*\w+[-.,;?]+/ # соответствует, например: ' count--;'
Если квантификатор нужно применить к нескольким шаблонам, то нужно сгруппировать шаблоны, заключив их в круглые скобки. Составим регулярное выражение для поиска IP-адреса, которое находит число, состоящее из одной цифры и более (\d+), за которой может стоять точка (\.?), причем эта последовательность повторяется ровно четыре раза ({4}):
$pattern = '(\d+\.?){4}'; # шаблон для IP-адреса $text = 'address=208.201.239.36,site=www.perl.com'; $text =~ m/$pattern/; # соответствие: '208.201.239.36'
Программисты шутят: " При составлении шаблона главное, чтобы регулярное выражение соответствовало тому, что нужно, и не соответствовало тому, что не нужно". В следующем примере мы будем искать "более одного символа, за которыми идет буква 'й' и пробел", ожидая, что будет найдено слово 'Какой '. Но нас ожидает неприятный сюрприз:
my $text = 'Какой хороший компакт-диск!'; $text =~ /.+й\s/; # жадный квантификатор # найдено соответствие: 'Какой хороший '
Это произошло потому, что по умолчанию квантификаторы подразумевают максимальную последовательность символов, соответствующих указанному шаблону. Такое поведение квантификаторов называется "жадным" (greedy quantifier). Чтобы заставить квантификатор вести себя не "жадно", а "лениво" (lazy quantifier), нужно поставить сразу после него символ '?'. Тогда квантификатор будет описывать минимальную последовательность символов, соответствующих образцу. Исправленный с учетом этого образец найдет то, что нужно:
$text =~ /.+?й\s/; # ленивый квантификатор # найдено соответствие: 'Какой '
Таким же образом можно ограничивать "жадность" и других квантификаторов, заставляя их прекращать поиск как можно раньше, что обычно и требуется в большинстве ситуаций.
Модификаторы
До сих пор операция сопоставления прекращала работу и возвращала результат, когда находилось первое соответствие строки указанному шаблону. Если для операции сопоставления указать модификатор /g (global), то она будет искать в строке все соответствия образцу, организуя неявный цикл обработки регулярного выражения. Например, так можно найти все числа в строке с помощью одного шаблона:
my @numbers = 'Не 12.5, а 25!' =~ /(\d+)/g; # глобальный поиск # в @numbers будет (12, 5, 25)
Ранее в этой лекции уже упоминался модификатор /i, устанавливающий поиск с игнорированием разницы между заглавными и строчными буквами. Перечислим модификаторы для операции сопоставления:
/g - искать в тексте все соответствия образцу (Global);/i - искать соответствие образцу без учета регистра букв (case-Insensitive);/s - рассматривать текст как одну строку (Single-line);/m - рассматривать текст как многострочный (Multi-line) с учетом \n ;/o - один раз откомпилировать регулярное выражение (Once);/x - использовать расширенный синтаксис регулярных выражений (eXtended).
Из всех модификаторов, пожалуй, самый интересный - последний, который позволяет записывать регулярные выражения в структурированном и понятном для человека виде и даже сопровождать комментариями! Так, например, можно более понятно и красиво переписать регулярное выражение, приведенное в начале лекции:
m/ # начало регулярного выражения <A # начало тега: <A [^>]+? # далее могут быть любые символы, кроме > HREF # определение гиперссылки \s*=\s* # знак =, возможно окруженный пробелами ["']? # может быть открывающая кавычка или апостроф ( # начало захвата значения [^'" >]+? # адрес ссылки: все, кроме ',",пробела и > ) # конец захвата значения ['"]? # может быть закрывающая кавычка или апостроф \s* # за которым могут быть пробелы > # конец тега /igx; # конец регулярного выражения # соответствует, например: <a id='ru' href="index.html">
Записанное в таком виде, регулярное выражение становится доступным для понимания, анализа и модификации. А поскольку регулярные выражения компилируются, то пробельные символы и комментарии не влияют на быстродействие программы.
Поиск соответствий
Наверное, чаще всего регулярные выражения используются в операции сопоставления (match operator), которая проверяет, соответствует ли текст указанному образцу. Образец (pattern) - это символьная последовательность для сопоставления, записанная в специальной нотации. Простейший образец - это строковый литерал, представляющий собой последовательность символов, которая будет отыскиваться в тексте. В скалярном контексте операция сопоставления возвращает '1', если образец в строке найден, и пустую строку "', если соответствие образцу не найдено. Для указания, к какой строке применить операцию сопоставления, используется операция привязки =~ к строке:
'В строке образец есть' =~ /образец/; # образец найден
Обычно поиск образца выполняется с учетом регистра, но можно игнорировать регистр при сопоставлении строки с образцом, если в операции сопоставления задать модификатор /i (ignore case). Для корректной обработки национальных букв должна быть включена прагма use locale. Например:
use locale; 'В строке образец есть' =~ /Образец/; # образец НЕ найден! 'В строке образец есть' =~ /Образец/i; # образец найден
Результат операции сопоставления в тексте можно присвоить скалярной переменной или использовать в любой из условных конструкций, например:
$text = 'Черный кот в темной комнате'; # ищем в этом тексте $found = $text =~ /кот/; # в $found будет '1' print 'Кошки нет!' unless $text =~ /кошка/; # вернет ''
Последнее предложение можно переписать, применив операцию отрицательной привязки к строке (!~), которая инвертирует (меняет на обратный) результат операции сопоставления:
print 'Кошки нет!' if $text !~ /кошка/; вернет '1'
Если операция привязки к строке не используется, образец отыскивается в переменной по умолчанию $_. Выражение перед поиском интерполируется, поэтому весь образец поиска или его часть может содержаться в переменной. Например:
$_ = 'Счастье - это когда тебя понимают.'; # переменная поиска $pattern = 'Счастье'; # образец для сопоставления print "$pattern найдено!" if /$pattern/;
В составе образца поиска могут применяться не только переменные, но и escape-последовательности, известные нам из лекции 2, например:
print 'В строке обнаружена табуляция' if $string =~ m{\t};
Для успешного сопоставления строки образцу достаточно найти в строке первое совпадение. В этом примере образец совпадет с началом подстроки 'которого':
$text = 'У которого из котов зеленые глаза?'; # ищем здесь $any = $text =~ /кот/; # образец совпал с 'которого'
Чтобы найти именно подстроку 'кот', перед которой стоит пробел, нужно задать более точный образец для сопоставления:
$cat = $text =~ / кот/; # образец совпадет с ' кот'
В операции сопоставления программист может задавать ограничители для образца: в этом случае перед ограничителями указывается буква m// (Операцию сопоставления часто именно так и называют: операция m//.) В качестве ограничителей могут выступать различного вида скобки или парные небуквенные символы, например:
m($pattern) m{$pattern} m[$pattern] m<$pattern> m|$pattern| m!$pattern! m"$pattern" m#$pattern#
Задать собственные ограничители бывает особенно полезно, когда в шаблон поиска входит наклонная черта. Из двух приведенных вариантов второй смотрится гораздо понятнее:
/\/usr\/bin\/perl/ m{/usr/bin/perl}
Недаром обилие левых и правых наклонных черт в первом варианте называют "ученическим синдромом зубочисток" (LTS - Learning Toothpick Syndrome). В приводимых до сих пор примерах операцию сопоставления с литералом в качестве образца вполне можно заменить вызовом функции index(). Самое интересное начинается тогда, когда в образце поиска применяются метасимволы для сопоставления с шаблоном.
Применение регулярных выражений
Регулярные выражения применяются во многих конструкциях. В функции split() первым параметром может использоваться регулярное выражение, которое будет служить для поиска разделителей при разделении строки на части. Так, например, можно разбить строку на подстроки по любому из пробельных символов:
@substrings = split /\s+/, $text; # разбить на части
Регулярные выражения часто применяются в функциях, работающих с массивами для фильтрации нужных элементов. Например, функция grep() возвратит список элементов массива, соответствующих указанному образцу:
@result = grep /$pattern/, @source; # отобрать элементы
С помощью функции map можно применить операцию замены в соответствии с регулярным выражением ко всем элементам массива, например:
@hrefs = ('http://regex.info', 'http://regexp.ru'); map s{http://}{}, @hrefs; # убрать 'http://' из ссылок
Регулярные выражения дают программисту новый взгляд на текстовые данные: вместо отдельных символов и простых подстрок он начинает мыслить обобщенными шаблонами, что помогает ему находить более простые и эффективные решения. В таблице 8.1 для справки приведены основные обозначения, применяемые для записи регулярных выражений в Perl. Дополнительные сведения о регулярных выражениях можно почерпнуть из стандартной документации по Perl и перевода уникальной книги Джеффри Фридла "Регулярные выражения".
| // | ограничители регулярного выражения по умолчанию | /$pattern/ |
| \ | отмена специального значения следующего символа | m{C:\\windows} |
| () | группировка шаблонов или сохранение значения | /(\w\w\w)+/ |
| | | выбор из нескольких альтернатив | /кошелек|жизнь/ |
| [] | класс символов: любой символ из перечисленных | /[0-9a-fA-F]/ |
| [^] | инвертированный класс символов: любой символ, кроме перечисленных | /[^0-9]/ |
| Метасимволы | ||
| . | любой символ, кроме \n (соответствует любому символу, включая \n с модификатором /s) | /(.+)/ |
| \d | десятичная цифра | m{Время=\d+ сек} |
| \D | не десятичная цифра | /(\D*)\d+/ |
| \w | алфавитно-цифровой знак | /\s+\w+\s+/ |
| \W | не алфавитно-цифровой знак | /\W\W\W/ |
| \s | пробельный символ | s/\s+/ / |
| \S | любой символ, кроме пробельного | /\S+/ |
| Утверждения | ||
| ^ | начало строки (соответствует началу каждой строки с модификатором /m) | /^\w+/ |
| $ | конец строки (соответствует концу каждой строки с модификатором /m) | /\d+$/ |
| \b | граница слова (между \w и \W или \W и \w) | /stop\b/ |
| \B | любая позиция, кроме границы слова | /stop\B/ |
| \A | только начало строки, даже с модификатором /m | /\A[#]/ |
| \z | только конец строки, даже с модификатором /m | /\w+\z/ |
| \Z | только конец строки или перед \n в конце строки, даже с модификатором /m | /\w+\Z/ |
| \G | позиция в строке, равная значению функции pos() | |
| Escape-последовательности | ||
| \t \n \r \f \a \b | управляющие символы: \b в классе символов выступает как символ Backspace (0x08), вне его - как граница слова | /[\a\b\f\r\n\t]/ |
| \0 \x \c \N | коды символов | /\033\x1F\cZ/ /\x{263a}/ |
| \l \L \u \U \Q \E | преобразующие последовательности | /\Q$pattern\E/ |
| Квантификаторы | ||
| * *? | любое число повторений, включая 0 (максимальный и минимальный квантификаторы) | /\s*/ /\S*?/ |
| + +? | одно и более повторений (максимальный и минимальный квантификаторы) | /\d+/ /\D+?/ |
| ? ?? | ноль или одно повторение (максимальный и минимальный квантификаторы) | /.?/ /[.a-z]??/ |
| {n} {n}? | ровно n повторений (максимальный и минимальный квантификаторы) | /\w{8}/ /\w{5}?/ |
| {n,} {n,}? | n и более повторений (максимальный и минимальный квантификаторы) | /\d{2,}/ /\d{5,}?/ |
| {n,m} {n,m}? | от n до m повторений включительно (максимальный и минимальный квантификаторы) | /[A-Z]{1,12}/ /[a-z]{0,3}?/ |
Из этой лекции вы узнали о регулярных выражениях далеко не все, но достаточно, чтобы начать свободно пользоваться ими. По мере накопления опыта применения языка Perl, регулярные выражения станут вашим привычным и надежным инструментом. И тогда задачи, при другом подходе требующие много времени и больших усилий, с помощью регулярных выражений будут решаться быстро, элегантно и эффективно.
Из этой лекции вы узнали о регулярных выражениях далеко не все, но достаточно, чтобы начать свободно пользоваться ими. По мере накопления опыта применения языка Perl, регулярные выражения станут вашим привычным и надежным инструментом. И тогда задачи, при другом подходе требующие много времени и больших усилий, с помощью регулярных выражений будут решаться быстро, элегантно и эффективно.
| © 2003-2007 INTUIT.ru. Все права защищены. |
Регулярные выражения
Когда некоторые говорят, что программы на Perl похожи на бессмысленную кучу символьного мусора, то это впечатление, скорее всего, возникло от вида какого-нибудь длинного регулярного выражения, а они действительно могут выглядеть как загадочный или бессмысленный набор символов, например:
m/<A[^>]+?HREF\s*=\s*["']?([^'" >]+?)['"]?\s*>/ig
(Это всего-навсего шаблон для поиска гиперссылок в HTML-странице.) Но в этой лекции вы узнаете, что регулярные выражения - совсем не ужасные и отнюдь не хаотичные, а наоборот, очень даже логичные и упорядоченные, что употреблять их не так уж сложно, а записывать их можно вполне наглядным способом. Как сказал Джеффри Фридл в своей знаменитой книге, переведенной на русский язык: "Регулярные выражения также можно сравнить с иностранным языком - когда вы начинаете изучать язык, он перестает казаться белибердой".
Начнем с того, что регулярные выражения (regular expression, сокращенно - regexp, regex или RE) - это отдельный язык описания образцов для обработки текста, не имеющий непосредственного отношения к Perl. Регулярные выражения использовались в Unix задолго до создания Perl, а сейчас библиотеки для работы с ними имеются в C++, C#, Java, JavaScript, PHP, Python, Ruby, Visual Basic и других языках. Поддержка регулярных выражений есть в некоторых редакторах, почтовых программах и системах управления базами данных. Другое дело, что широкое распространение Perl в свое время сделало регулярные выражения популярными на разных платформах. А в ходе развития языка Perl была отточена система обозначений для регулярных выражений, ставшая фактическим стандартом. Многие считают, что благодаря Perl регулярные выражения из математической теории превратились в рабочий инструмент тысяч и тысяч программистов. Это произошло потому, что в Perl механизмы работы с регулярными выражениями встроены в ядро языка, поэтому применять их естественно, легко и удобно. А благодаря эффективной реализации "движка" регулярных выражений, в Perl они обрабатываются чрезвычайно быстро. Регулярные выражения выполняют львиную долю работ по обработке текстовой информации и используются в Perl несколькими способами:
для поиска в тексте строк по определенному образцу;для разделения текста на части по указанному набору разделителей;для извлечения из строки подстрок, соответствующих заданному шаблону;для замены в тексте найденных соответствий на новые значения.
Основная идея регулярных выражений состоит в нахождении в тексте соответствия определенному образцу, который может задаваться литералом или шаблоном. Вся текстовая строка считается соответствующей образцу, если ему соответствует какая-то ее часть.
Шаблоны и метасимволы
Очень часто требуется искать в тексте не конкретные строки, а символьные последовательности, определенные приблизительно: "число в скобках", "четвертое слово сначала строки", "список из пар имя = значение, разделенных запятыми" и тому подобное. В таких случаях в качестве аргумента поиска задается шаблон, который описывает такую последовательность. Шаблон - это образец, в котором, помимо литеральных значений, содержатся метасимволы. Метасимволы (metacharacter) - это знаки, имеющие специальное значение при записи образцов. Вот какие метасимволы применяются при записи регулярных выражений:
{} [] () ^ $ . | * + ? \
При необходимости включить в образец поиска один из этих знаков не как метасимвол, а как обыкновенный символ, нужно отменить его особое значение ("экранировать"), поставив перед ним обратную косую черту (backslash):
$text =~ m"\." # содержится ли в тексте точка?
Как метасимвол точка обозначает в регулярном выражении один любой символ, кроме перевода новой строки (\n). Например, для поиска похожих слов можно составить такой шаблон:
/само.а./ # соответствуют: 'самовар', 'самокат', 'самосад'... # НЕ соответствуют: 'самолюб', 'самогон', 'самоход'...
В регулярном выражении можно задать несколько вариантов образца, любой из которых будет считаться соответствием строки образцу. Варианты образца - это набор возможных альтернатив, разделенных знаком "вертикальная черта" ('|'), который называется "метасимвол альтернатив" (alternation metacharacter). Поиск считается успешным, если найдено соответствие любой из альтернатив, например:
$text = 'Черная кошка в темной комнате'; # будем искать здесь print "Нашли кошку!" if $text =~ /кот|кошка|котенок/;
Сравнение текста с вариантами образца выполняется слева направо, поэтому, если начало альтернатив совпадает, более длинную альтернативу нужно помещать в начало списка вариантов. Иначе всегда будет найдена более короткая. Значит шаблон в предыдущем примере правильнее записать в виде /котенок|кот|кошка/, чтобы в первую очередь поискать котенка, а затем - кота:
$text = 'Черный котенок в темной комнате'; # ищем здесь print "Нашли котенка!" if $text =~ /кот.нок|кот|кошка/;
Чтобы сделать образец более универсальным, в первой альтернативе литерал заменен на шаблон с метасимволом "точка", чтобы находились соответствия слову "котенок" в любом написании - через "е" и через "е". Часто применение регулярного выражения с альтернативами выглядит гораздо изящнее, чем длинное условное выражение:
return if $command =~ /exit|quit|stop|bye/i;
Если в образце после выбора из нескольких альтернатив применяются другие шаблоны или литералы, то конструкцию выбора нужно заключить в круглые группирующие скобки. Например:
$lotr =~ /(Bilbo|Frodo) Baggins/; # один из хоббитов
Утверждения
Часто нам бывает небезразлично, в каком месте содержимое строки совпадет с шаблоном. Мы бы хотели уточнить: "в начале строки", "в конце слова" и так далее. Для того чтобы более точно задать положение в тексте, где должно быть найдено соответствие, в регулярных выражениях можно указывать так называемые утверждения. Утверждение (assertion) не соответствует какому-либо символу, а совпадает с определенной позицией в тексте. Поэтому их можно воспринимать как мнимые символы нулевого размера. Чаще всего используются следующие утверждения (другие приведены в таблице 8.1):
^ позиция в начале строки $ позиция в конце строки (или перед \n в конце строки) \b граница слова: позиция между \w и \W или \W и \w \B любая позиция, кроме границы слова \b
Вот пример шаблонов поиска, где уточняется, что нужно проверить наличие числа в определенном месте строки:
$log = '20060326 05:55:25 194.67.18.73 ... 200 797'; print "Число в начале\n" if $log =~ /^\d+/; print "Число в конце\n" if $log =~ /\d+$/;
Утверждение, которое используется для фиксирования части образца относительно положения в строке, иногда называется якорем (anchor). Якори применяются, чтобы указать, в каком именно месте строки нужно искать соответствие образцу.
Замена строк
Кроме поиска, регулярные выражения часто применяются для замены найденных совпадений на новые значения. Для этого существует операция замены (substitution), которая пытается найти в строковой переменной соответствие образцу, а если находит, то заменяет найденную подстроку на указанное значение. Операция замены выглядит так:
$variable =~ s/образец/замена/; # в переменной $variable отыскивается строка 'образец', # и если найдена, то она заменяется на 'замена'
Все, что говорилось до этого про операцию сопоставления, применимо для левой части операции замены, в которой указывается образец поиска. Левая и правая части операции замены интерполируются, поэтому там могут использоваться escape-последовательности и переменные.
$pattern = 'шило'; # образец $replacement = 'мыло'; # замена $text =~ s/$pattern/$replacement/; # поменять 'шило' на 'мыло'
В правой части операции замены могут использоваться обратные ссылки на найденные значения. Так, например, можно поменять местами два крайних слова в тройке слов, разделенных пробельными символами:
$text = 'мать любит дочь'; $text =~ s/(\S+)\s+(\S+)\s+(\S+)/\3 \2 \1/; # в $text будет 'дочь любит мать'
Для операции замены s/// можно применять все модификаторы, упомянутые для операции сопоставления m//. Например, модификатор /g указывает, что должны быть заменены все найденные в тексте соответствия. Например:
$our_computers =~ s/Windows/Linux/g;
У операции замены есть дополнительный модификатор /e (expression evaluation), при включении которого заменяющая часть вычисляется как выражение. При этом в заменяющей части можно использовать ссылки на захваченные при помощи круглых скобок соответствия. Это можно применять для более "интеллектуальной" замены найденных соответствий. Так, например, можно перевести температуру из шкалы Цельсия в шкалу Фаренгейта:
$text = 'Бумага воспламеняется при 233C.'; $text =~ s/(\d+\.?\d*)C\b/int($1*1.8+32).'F'/e; # в $text будет: 'Бумага воспламеняется при 451F.'
Функции работы с файлами
В Perl есть целый набор встроенных функций для работы с файлами, с помощью котрых можно манипулировать с самими файлами, а не с данными, хранящимися в них.
Функция rename() переименовывает файл, возвращая логическое значение: 1 при успешном изменении имени и 0 - в противном случае. Ей передаются старое и новое имя файла с абсолютным или относительным путем.
$ok = rename("$path/$old_name", "$path/$new_name");
Функция unlink() удаляет файл или список файлов, возвращая число 1 при успешном удалении и 0 - при ошибке.
unlink($list, $of, $files); # удалить список файлов unlink $file if -e $file; # удалить файл, если он существует
Функция truncate() усекает файл до указанного размера и возвращает число 1 в случае успешного выполнения усечения и неопределенное значение undef - при возникновении ошибки. Файл может задаваться именем или файловым манипулятором. Например:
$ok = truncate($file, $size);
Функция stat() возвращает информацию о файле в виде списка или пустой список при неудаче. Файл может задаваться манипулятором файла или выражением со значением имени файла:
@info = stat($file); # получить всю информацию о файле $size = $info[7]; # размер файла в байтах $modified = localtime($info[9]); # время изменения файла
Подробное описание всех элементов информационного списка можно найти в документации, указав утилите чтения документов имя функции следующим образом:
perldoc -f stat
Функция utime() изменяет у файла (или нескольких файлов из заданного списка) время доступа и время модификации, задаваемые числовыми значениями.
utime($access_time, $modified_time, @list_of_files);
Кроме упомянутых, есть еще встроенные функции для изменения прав доступа и владельца файла, для чтения и создания символических и жестких ссылок. Немало разных функций для работы с файлами имеются в стандартной библиотеке модулей Perl, еще больше можно найти в хранилище модулей CPAN.
Функции работы с каталогами
Помимо работы с файлами, в Perl есть необходимый набор встроенных функций для работы с каталогами. Нужно иметь в виду, что успешность выполнения операций с каталогами зависит от набора прав пользователя, от лица которого выполняется Perl-программа.
Функция mkdir() создает каталог с указанным именем. Вторым аргументом функции можно задавать права доступа для создаваемого каталога (в соответствии со стандартом POSIX). Возвращает число 1 при успешном создании или 0 при ошибке. Причину неудачи при создании каталога можно узнать из специальной переменной $!, которая содержит сообщение об ошибке.
$ok = mkdir $directory_name; # создать каталог mkdir $dir, $access_rights; # создать каталог, задав права
Функция rmdir() удаляет каталог по его имени, если он пуст, возвращает число 1 при успешном удалении каталога или 0 в случае ошибки. Тогда из переменной $! можно выяснить подробности неудачи:
$ok = rmdir $directory_name; # удалить каталог
Функция chdir() изменяет текущий каталог на значение строкового выражения, содержащего имя нового текущего каталога. Если имя каталога не задано, она переходит в домашний каталог пользователя, используя значение элемента $ENV{"HOME"} или $ENV{"LOGNAME"} из специального хэша %ENV, который содержит значения переменных окружения операционной системы. Возвращает число 1 при успешном переходе в другой каталог или 0 в случае возникновения ошибки.
$ok = chdir $new_dir; # перейти в каталог $new_dir chdir; # перейти в домашний каталог
Много других возможностей по работе с каталогами предоставляют функции из стандартной библиотеки модулей Perl. Например, функция cwd() из стандартного модуля Cwd возвращает имя текущего (рабочего) каталога во время выполнения программы:
use Cwd; # подключить библиотечный модуль Cwd my $current_work_directory = cwd; # запросить текущий каталог
Иногда при выполнении программы нужно определить каталог, откуда она была запущена, чтобы организовать доступ к его подкаталогам. Переменная Bin, устанавливаемая в модуле FindBin из стандартной библиотеки, содержит имя каталога, из которого программа была запущена, например:
use FindBin; # подключить библиотечный модуль FindBin my $program_start_dir = $FindBin::Bin; # стартовый каталог
Perl также предоставляет набор функций, организующий чтение содержимого каталога, подобно чтению записей файла. Элементами каталога могут быть обыкновенные файлы и другие каталоги, включая вложенные подкаталоги, текущий каталог (обозначаемый одной точкой) и родительский каталог (обозначаемый двумя точками).
Перед чтением содержимого каталога его необходимо открыть. Функция opendir() открывает каталог по его имени и ассоциирует его с указанным манипулятором каталога. Функция возвращает число 1 при успешном открытии, undef - при неудаче. Вот так, например, открывается каталог и создается манипулятор каталога DIR_HANDLE:
$ok = opendir DIR_HANDLE, $directory_name;
Современный стиль программирования рекомендует при открытии каталога сохранять манипулятор каталога в скалярной переменной. Это ограничивает область его видимости текущим блоком или подпрограммой и предотвратит случайное изменение манипулятора в других частях программы. Например, так:
$ok = opendir my $dir_handle, $directory_name;
Функция closedir() закрывает каталог, открытый функцией opendir(), используя манипулятор каталога. Возвращает число 1 при успешном закрытии или undef - при неудаче. Хотя открытые каталоги автоматически закрываются по окончании программы, рекомендуется все же делать это явно:
$ok = closedir $dir_handle; # закрыть каталог
Функция readdir() в скалярном контексте читает очередной элемент каталога, возвращая неопределенное значение undef, когда будет прочитан последний элемент. Например:
my $file_name = readdir $dir_handle;
Таким образом можно организовать обработку всех элементов каталога в цикле, исключая текущий и родительский каталоги:
while (my $file_name = readdir $dir_handle) { if ($file_name ne '.' && $file_name ne '..') { print "каталог $file_name\n" if -d $file_name; print "файл $file_name\n" if -f $file_name; } }
В списочном контексте функция readdir() возвращает список всех элементов каталога, что часто бывает весьма удобно:
@file_names = readdir $dir_handle; # считать весь каталог
Иногда требуется, не закрывая каталога, начать его обработку сначала. Функция rewinddir() устанавливает позицию чтения в начало открытого каталога, после чего чтение начнется с первого элемента:
rewinddir $dir_handle; # 'перемотать' на начало каталога
Функция telldir() возвращает текущую позицию в каталоге, которую можно использовать для перемещения в эту позицию с помощью функции seekdir():
$dir_position = telldir $dir_handle; # позиция чтения
Используя возвращенное функцией telldir() значение, встроенная функция seekdir() устанавливает новую позицию для чтения каталога с помощью функции readdir():
seekdir $dir_handle, $dir_position; # вернуться к позиции
После изучения представленных в этой лекции средств ввода-вывода вполне можно писать законченные и полезные программы на Perl. Но пройдена только половина пути: в следующих лекциях курса будет рассказано о важных конструкциях и механизмах системы программирования Perl, без которых невозможно разрабатывать современные программы на профессиональном уровне.
Операции проверки файлов
Перед выполнением операций ввода-вывода часто требуется узнать информацию об объектах файловой системы. В Perl есть набор унарных операций для удобной проверки различных характеристик файлов и каталогов. Они имеют вид флагов из одной латинской буквы с предшествующим знаком минус, после которого указывается имя проверяемого файла. Полный перечень операций проверки файлов приведен в таблице 9.3.
| -r -w -x | Файл доступен для чтения / записи / исполнения (по effective UID+GID) |
| -R -W -X | Файл доступен для чтения / записи / исполнения (по real UID+GID) |
| -o -O | Файл принадлежит текущему пользователю по effective / real UID |
| -e -z | Файл существует (exists) / имеет нулевую длину (zero) |
| -s | Файл имеет ненулевой размер: возвращает размер в байтах (size) |
| -f -d | Файл является обычным файлом (file) / каталогом (directory) |
| -l -S -p | Файл является ссылкой / сокетом / именованным FIFO-каналом (pipe) |
| -b -c | Файл является блочным / символьным специальным файлом |
| -u -g -k | Для файла установлен бит setuid / setgid / sticky |
| -t | Файловый манипулятор связан с терминалом (tty) |
| -T -B | Файл является текстовым (text) / двоичным (binary) |
| -M -A -C | Время изменения (modification) / доступа (access) / изменения (change) индексного узла (inode) файла в днях относительно времени начала выполнения программы ($^T) |
Вот несколько типичных примеров использования операций проверки файлов для контроля доступности данных:
open($f1, "<$file1") # открыть файл на чтение, if (-e $file1) && # если он существует и (-r $file1); # он доступен на чтение open $f2, ">$file2" # открыть файл на запись, if -w $file2; # если в него можно писать $file_size = -s $file; # узнать размер файла print "$file - является каталогом!" if -d $file;
Построчный ввод-вывод
В огромном числе случаев ввод данных в Perl-программу и вывод из нее результатов производится построчно, а для разделения строк файла используется разделитель входных записей, хранящийся в специальной переменной $/ ($INPUT_RECORD_SEPARATOR). Для чтения одной строки из входного потока используется операция "кристалл" (diamond), которой в качестве аргумента передается файловый манипулятор или переменная, содержащая манипулятор. Если аргумент не указан, данные читаются из стандартного входного потока.
$input = <>; # чтение строки в $input из STDIN $line = <FILE>; # чтение строки в $line из потока FILE $in = <$handle>; # чтение строки в $in из потока $handle
Операция чтения "кристалл" в скалярном контексте возвращает одну строку вместе с разделителем записей, а когда достигается конец файла, она возвращает неопределенное значение undef, которое воспринимается как ложное. Поэтому типичный цикл построчного чтения данных проверяет прочитанное значение и заканчивается, когда оно становится неопределенным:
open my $fh, "< $file" or die "Ошибка открытия: $!"; while (my $line = <$fh>) { # чтение строки в переменную $line chomp $line; # удаление разделителя строк print length $line, " $line\n"; # обработка строки } close $fh or die "Ошибка закрытия: $!";
Операция чтения "кристалл" в списочном контексте возвращает список всех строк с разделителями записей. Так, например, можно считать файл в массив, попутно отсортировав его:
@lines= sort(<$fh>); # в @lines отсортированные строки из $fh
Построчный вывод данных выполняет функция print(), которая по умолчанию выводит список значений в текущий поток вывода, по умолчанию - в STDOUT. Если требуется направить информацию в другой поток, то перед списком выводимых данных указывается файловый дескриптор. Обратите внимание, что между файловым дескриптором и списком выводимых значений запятая не ставится. Вот примеры вывода данных:
print($list, $of, $output, $values); # вывод в STDOUT print STDOUT $list, $of, $output, $values; # вывод в STDOUT print(STDERR $list, $of, $output, $values); # вывод в STDERR print FILE $list, $of, $output, $values; # вывод в FILE print($file $list, $of, $output, $values); # вывод в $file
Для форматирования выводимой информации применяется функция printf(), которая преобразует выходные данные при помощи форматов преобразования, подробно объясненных в лекции 7 при описании функции sprintf(). Например, так можно вывести отформатированное текущее время в разные выходные потоки:
my ($hh, $mm, $ss) = (localtime)[2, 1, 0]; # выбрать из списка нужные значения: часы, минуты, секунды my $format = "%02d:%02d:%02d\n"; # формат вывода
printf $format, $hh, $mm, $ss; # вывод в STDOUT printf(STDERR $format, $hh, $mm, $ss); # вывод в STDERR printf $file $format, $hh, $mm, $ss; # вывод в $file
Задавая различные форматы преобразования, можно выводить данные в требуемом представлении или в виде колонок указанной ширины. Более тонкое управление выводимыми данными организуется средствами форматирования отчетов, которые будут изучены в следующей лекции.
Потоки ввода-вывода
Система ввода-вывода Perl основана на принципах, заложенных в системе Unix и распространившихся на все современные операционные системы. Одним из основных понятий работы в программе с внешними данными являются потоки ввода-вывода. В программе обращение к потоку ввода-вывода производится через файловый манипулятор (file handle), иногда неправильно называемый дескриптором файла. При запуске любой программы автоматически открывается три потока: стандартный ввод (stdin), стандартный вывод (stdout) и стандартный протокол (stderr). Поток стандартного ввода в диалоговой операционной среде связывается с клавиатурной, а потоки стандартного вывода и стандартного протокола - с дисплейной частью консоли операционной системы. Со стандартными потоками в Perl связываются три предопределенных файловых манипулятора: соответственно STDIN, STDOUT и STDERR. Связывание имени файла с пользовательским файловым манипулятором в программе выполняется с помощью операции open(), открывающей поток обмена данными с указанным файлом. Требования надежности рекомендуют обязательно проверять все операции ввода-вывода на успешное завершение. Поэтому в случае возникновения ошибки при открытии файла программа обычно аварийно завершается с помощью функции die(), которая может выводить диагностическое сообщение в стандартный поток протокола. Например, так открывается файл и создается файловый манипулятор FILE_HANDLE:
# открыть для чтения файл по имени, взятом из $file_name open(FILE_HANDLE, $file_name) # или аварийно завершить программу с выдачей сообщения or die("Ошибка открытия файла $file_name: $!\n"); #
В случае успешного открытия файла функция open() помещает в свой первый аргумент готовый к использованию файловый манипулятор. Имя файлового манипулятора записывается без разыменовывающего префикса и по традиции выделяется заглавными буквами. Рекомендуется при открытии файла сохранять файловый манипулятор в скалярной переменной, что позволяет локализовать файловый манипулятор для использования только в текущем блоке или подпрограмме. Кроме того, скалярную переменную с файловым манипулятором можно удобно передавать в подпрограммы для выполнения в них операций ввода-вывода. Итак, вот предпочтительный способ открытия файла:
open my $file_handle, $file_name or die "Ошибка открытия файла $file_name: $!\n";
(Как и при вызове других функций в Perl, если не возникает неоднозначности, программист решает, заключать аргументы функций в круглые скобки или нет. Среди пишущих на Perl широко распространен стиль программирования без использования круглых скобок.)
При открытии файла функции, помимо файлового манипулятора и имени файла в файловой системе (абсолютного или относительного), указывается режим открытия файла. Он обозначается такими же символами, как переназначение потоков ввода-вывода в командном интерпретаторе операционной системы. Основные режимы открытия потоков ввода-вывода приведены в таблице 9.1.
| < | Чтение (существующего файла с начала) | open($fh, '</temp/buffer.txt') |
| > | Перезапись (с начала файла) | open($fh, '>/temp/buffer.txt') |
| >> | Дозапись (в конец файла) | open($fh, '>>/temp/buffer.txt') |
| +< | Чтение и запись (файл должен существовать) | open($fh, '+</temp/buffer.txt') |
| +> | Запись и чтение (файл усекается) | open($fh, '+>/temp/buffer.txt') |
| +>> | Дозапись и чтение | open($fh, '+>>/temp/buffer.txt') |
open $fh, '</temp/buffer.txt'; open $fh, '<', '/temp/buffer.txt';
Программисты, знающие язык C, могут воспользоваться для открытия потоков функцией sysopen(), которая аналогична функции открытия потоков в C, и к тому же позволяет более тонко настраивать режимы открытия файлов. А вообще в комплекте с Perl идет целый учебник по функции open(), который можно прочитать утилитой чтения документации:
perldoc perlopentut
Связь файлового манипулятора в программе с обрабатываемым файлом разрывается функцией закрытия потока close(), закрывающей поток ввода-вывода. Ей передается файловый манипулятор открытого файла:
close(FILE) or die("Ошибка при закрытии файла: $!\n"); close $handle or die "Ошибка закрытия файла: $!\n";
В новой многоуровневой подсистеме ввода-вывода Perl предусматривает при открытии потока вместе с режимом открытия указывать кодировку читаемых и записываемых данных, что позволяет автоматически преобразовывать информацию из одной кодировки в другую, например, так:
open my $in, "<:encoding(UTF-8)", 'utf8.txt' or die; open my $out, ">:encoding(cp1251)", 'cp1251 .txt' or die; while(<$in>){ print $out $_; } close $in or die; close $out or die;
В некоторых операционных системах (например, в MS-DOS), после открытия файла, но перед чтением двоичных данных требуется установить для файлового манипулятора режим работы с двоичными данными с помощью функции binmode($file_handle). При работе в операционных системах, не требующих установки этого режима, вызов функции binmode() не оказывает никакого действия.
Встроенный файл данных
В файле с исходным текстом программы на Perl может располагаться встроенный файл с данными, которые помещаются в конце программного файла после специальной лексемы __END__ (в основной программе) или __DATA__ (в программном модуле). При выполнении программы данные из этого встроенного файла доступны для чтения при помощи специального файлового манипулятора DATA. Во встроенном файле удобно хранить тестовые данные для проверки работы программы после ее модификации. Вот пример чтения данных из встроенного файла:
while (my $line = <DATA>) { # читаем построчно данные print $line; # обрабатываем данные } __END__ Это данные из встроенного файла
Ввод-вывод двоичных данных
Двоичные данные обычно хранятся в файлах без разделителей записей в блоках фиксированной длины. После открытия двоичного файла функцией open() нужно установить режим обработки двоичных данных с помощью функции binmode().
open(my $fh, ">$file") or die("Ошибка открытия: $!"); binmode($fh);
Запись двоичных данных или данных фиксированной длины может выполняться с помощью функции print($fh $record). Также имеется функция небуферизованного вывода syswrite(), которой при вызове указываются три аргумента: файловый манипулятор, скалярная переменная с выводимыми данными и размер записываемого блока данных. Эта функция возвращает число фактически записанных байт, что можно использовать для проверки успешности записи. Это делается так:
syswrite($fh, $record, length($record)) == length($record) or die("Ошибка записи: $!");
Преобразование данных к двоичному виду производит функция pack(), которая упаковывает в скалярную переменную список значений в соответствии с указанным шаблоном. В шаблоне каждое преобразуемое поле обозначается с помощью латинской буквы. Полный перечень шаблонов преобразования для функций pack() и unpack() приводится в таблице 9.2. За каждым символом в шаблоне может следовать десятичное число, которое рассматривается как ширина преобразуемого поля. Поля в шаблоне могут разделяться пробелами для удобства чтения.
| a | Arbitrary | произвольная последовательность байтов, дополненная нулевым байтом \0 |
| A | ASCII | строка символов ASCII, дополненная пробелами |
| b / B | Bit string | строка битов с возрастающим / убывающим порядком битов |
| c / C | Character | однобайтовые символы со знаком / без знака |
| f / d | Float / Double | число с плавающей точкой одинарной / двойной точности |
| F | Float | число с плавающей точкой одинарной точности во внутреннем представлении (NV) |
| D | long Double | длинное число с плавающей точкой двойной точности |
| h / H | Hex string | шестнадцатеричная строка с младшим / старшим полубайтом (nybble) в начале |
| i / I | Integer | целое (>=32 бита) число со знаком / без знака |
| j / J | целое во внутреннем представлении со знаком (IV) / без знака (UV) | |
| l / L | Long | длинное (32 бита) целое со знаком / без знака |
| n / N | Network | беззнаковое короткое (16 битов) / длинное (32 бита) целое с сетевым порядком байтов (big endian) |
| p / P | Pointer | указатель на строку, оканчивающуюся \0 / фиксированной длины |
| q / Q | Quad | сверхдлинное (64 бита) целое число со знаком / без знака |
| s / S | Short | короткое (16 битов) целое со знаком / без знака |
| u | uuencoded | строка, кодированная по алгоритму uuencode |
| U | Unicode | строка символов Unicode |
| v / V | VAX | беззнаковое короткое (16 битов) / длинное (32 бита) целое с VAX-порядком байтов (little endian) |
| w | целое, сжатое в соответствии с кодировкой BER | |
| x | вставка \0 (pack) / пропуск байта по направлению вперед (unpack) | |
| X | пропуск байта по направлению назад | |
| Z | ASCIIZ | строка ASCIIZ (оканчивающаяся \0), дополненная \0 |
| @ | заполнение \0 до указанной позиции |
Например, целочисленное значение, возвращаемое функцией time(), и дробное значение, возвращаемое функцией rand(), можно упаковать в переменную $record с помощью шаблона 'l1 d1', который означает: "одно длинное целое число (long) и одно число с плавающей точкой двойной точности (double)".
$record = pack 'l1 d1', time(), rand(); #
Вот еще несколько несложных примеров использования разных шаблонов для функции pack():
$bin = pack('a5', 'Yes'); # в $bin будет: 'Yes\0\0' $bin = pack('A5', 'Yes'); # в $bin будет: 'Yes ' $bin = pack('a4', 'abcd','x','y','z'); # в $bin: 'abcd' $bin = pack('aaaa', 'abcd','x','y','z'); # в $bin: 'axyz' $bin = pack('C2', 65,66,67); # в $bin будет: 'AB' $bin = pack('U2', 0x263A, 0x263B); # в $bin будет: '??' $bin = pack ('cxxc', 65,66); # в $bin будет: 'A\0\0B'
Для преобразования данных из двоичного вида применяется функция unpack(), которая распаковывает из скалярной переменной в список или массив значения двоичных данных в соответствии с указанным шаблоном.
@list_of_values = unpack($template, $binary_record);
Кроме того, с помощью функции unpack() можно из строки извлекать подстроки фиксированной длины. Например, так можно извлечь из записи файла поля определенной длины в переменные:
# Поля данных в записи файла: # c 1 по 7 байт - номер телефона # с 8 длиной 30 - фамилия, имя, отчество абонента # с 38 длиной 25 - адрес # 1234567Бендер Остап Ибрагимович РСФСР, Черноморск ($phone, $name, $address)= unpack('A7A30A25', $record);
Чтобы пропустить ненужные поля, достаточно указать в шаблоне пропуск определенного количества байтов. Например, так можно не извлекать поле с телефонным номером:
($name, $address)= unpack('x7A30A25', $record);
Подробное описание шаблонов и работы функций pack() и unpack() можно найти в стандартной документации с помощью все той же утилиты чтения документации:
perldoc perlpacktut
Для чтения двоичных данных или текстовых данных фиксированной длины применяется функция read(), которой в качестве аргументов передаются файловый манипулятор, скалярная переменная для вводимых данных и размер считываемого блока данных. Вот так, например, выглядит типичный цикл чтения двоичных данных:
until(eof($fh)) { # читать до достижения конца файла # считать очередной блок данных и проверить его длину read($fh, $record, $record_size) == $record_size or die('Неправильная длина данных'); # распаковать данные по шаблону из $record в @data @data = unpack($template, $record); # обработать введенные данные... }
Ввод-вывод с произвольным доступом
При работе с данными фиксированной длины обычной практикой является считывание или запись данных в произвольном месте файла, например, при изменении только что считанного блока данных. Для этого нужно позиционировать позицию чтения или записи. Это делается с помощью функции seek(), которой передается три аргумента: файловый манипулятор, смещение в байтах и указатель позиции отсчета. Позиция отсчета задается числами: 0 - от начала файла, 1 - от текущей позиции, 2 - от конца файла. Например:
seek($handle, 64, 0); # переместиться на 64 байта от начала seek($handle, 25, 1); # сместиться на 25 байт вперед seek($handle, -10, 2); # установиться на 10 байт до конца seek($handle, 0, 0); # установить позицию в начало файла
С помощью функции tell(), которая возвращает смещение относительно начала файла, можно узнать текущую позицию чтения-записи и использовать ее для дальнейших перемещений по файлу.
$pos = tell($handle); # запомнить текущую позицию в $pos seek($handle, $pos-5, 1); # сместиться на 5 байт назад
В следующем примере увеличивается поле счетчика длиной 2 байта, расположенное в файле с позиции $new_pos:
seek($file, $new_pos, 0); # установить позицию чтения $pos = tell($file); # и запомнить ее в переменной read($file, $number, 2); # прочитать 2-байтовое поле seek($file, $pos, 0); # установить в исходную позицию syswrite($file, ++$number, 2); # записать новое значение
Операции ввода-вывода с произвольным доступом часто используются для работы с базами данных, основанных на записях фиксированной длины, например, с файлами в формате DBF. Они позволяют организовать быструю выборку данных и запись измененных данных на прежнее место.
