Форматы отчета
Внешний вид отчета и расположение данных в нем описывается с помощью формата. Формат - это шаблон отчета, который состоит из литеральных строк (заголовков, пояснительных надписей, констант) и описания полей, куда при выводе отчета будут подставляться значения данных. Формат описывается с помощью ключевого слова format, после которого указывается имя формата и знак равенства. Далее со следующей строки располагается описание строк формата отчета (хотя они могут и отсутствовать). Описание формата заканчивается отдельной строкой, состоящей из единственной точки. Например, описание формата с именем FORMAT_NAME будет выглядеть так:
format FORMAT_NAME = описание формата отчета .
Форматы не исполняются, поскольку являются описаниями, как и определения подпрограмм, поэтому они могут помещаться в любом месте программного файла. Обычно они располагаются в конце исходного текста программы перед определением подпрограмм. Имя формата представляет собой правильный идентификатор. Его принято записывать заглавными буквами, и оно обычно совпадает с именем файлового дескриптора выходного потока, куда будет выводиться отчет. Имена форматов хранятся в отдельном пространстве имен, поэтому они не конфликтуют с именами переменных, подпрограмм, меток и файловых манипуляторов. Имя текущего формата для каждого потока хранится в специальной переменной $~ (или $FORMAT_NAME при включенной прагме use English). Если имя формата в описании не указано, подразумевается STDOUT.
Кроме основного формата, часто требуется описание отдельного формата для шапки страницы, которая будет выводиться в начале каждой страницы отчета. Формат заголовка страницы отчета отличается от основного формата тем, что к имени формата добавляется '_TOP'. Он описывается так:
format FORMAT_NAME_TOP = описание формата шапки отчета .
Имя текущего формата для шапки страницы, связанного с текущим выходным потоком, хранится в специальной переменной $^ ($FORMAT_TOP_NAME). При выводе отчета, если очередная строка не помещается на текущей странице, в выходной поток выводится символ прогона страницы, счетчик страниц увеличивается на единицу, и в начале следующей страницы в текущий поток выводится заголовок страницы отчета.
В описании формата отчета применяется несколько видов строк. Строка шаблонов (или строка полей) описывает поля отчета для заполнения данными. За каждой строкой шаблона следует одна или несколько строк аргументов (или строк значений), содержащих список источников данных (литералов, имен переменных и выражений, разделенных запятыми) для заполнения полей. Литеральная строка содержит информацию, без изменения выводимую в отчет. После литеральной строки строка значений не указывается. Строка комментариев, начинающаяся с символа #, служит для записи в формате примечаний и не выводится в отчет. В следующем примере приводятся образцы разных типов строк в описании формата:
format STDOUT = 1. Строка шаблонов содержит поля: @<<<<< и @###.## 'поле1', $field2 # 3. Комментарий: во 2-й строке данные для вставки в 1-ю 4. Литеральная строка выводится "как есть". .
В комментариях и литеральных строках нет ничего особенного, самое интересное содержится в строках шаблонов, содержащих описания полей отчета.
Многострочные значения
Есть несколько способов описать в формате данные, занимающие в отчете несколько строк. Если нужно поместить на странице отчета многострочное текстовое значение, то можно воспользоваться поледержателем @*, который просто выведет значение полностью, сохраняя имеющиеся в нем все символы перевода строки, кроме последнего. Например, так делается в этой программе:
format STDOUT = Гамлет: @* $multi_line_text (У. Шекспир) . $multi_line_text = "Быть\nИли не быть?\nВот в чем вопрос."; write STDOUT;
В результате ее выполнения будет выведено известное высказывание с сохранением его разбивки на несколько строк:
Гамлет: Быть Или не быть? Вот в чем вопрос. (У. Шекспир)
Поледержатель ^* описывает в формате текстовое поле, значение которого должно выводиться на несколько строк определенной ширины. В строке аргументов такому полю должно соответствовать имя переменной: скаляра, элемента массива или хэша. Когда значение этой переменной помещается в поле отчета, из переменной извлекается часть текстового значения до первого разделителя строк. Если переменная употребляется в формате несколько раз, то ее значение уменьшается на число извлеченных символов при каждом обращении к ней. Вот как это выгладит на примере:
# выводимое многострочное значение $text = "Что значит имя?\nРоза пахнет розой\n" . "Хоть розой назови ее, хоть нет."; write STDOUT; # описание формата отчета format STDOUT = ^* $text ^* $text ^* ~ $text ^* ~ $text У.Шекспир, "Ромео и Джульетта" .
Обратите внимание, что в формате для вывода значения переменной $text предусмотрены четыре строки. Причем первые две строки отчета (с шаблоном ^*) будут выводиться в любом случае: даже если $text содержит только одну строку текста, вторая строка будет заполнена пробелами. Чтобы не выводить пробельных строк, в описании третьей и четвертой строк указан шаблон подавления пустых строк (одна тильда, ~), который может располагаться в любом месте строки шаблона. После выполнения приведенной программы текст будет выведен в таком виде:
Что значит имя? Роза пахнет розой Хоть розой назови ее, хоть нет. У.Шекспир, "Ромео и Джульетта"
Если заранее неизвестно минимальное количество выводимых строк, можно применить шаблон повторения многострочного поля (две тильды подряд в любом месте строки, ~~). В этом случае строка шаблона будет применяться многократно, пока не будет исчерпано многострочное значение, при этом пустые строки выводиться не будут. Тильды в шаблоне подавления пустых строк и в шаблоне повторения строк при выводе отчета заменяются на пробелы. Таким образом, формат в последнем примере можно заменить на следующий:
format STDOUT = ^* ~~ $text У.Шекспир, "Ромео и Джульетта" .
В результате будет выведен точно такой же отчет, как и с использованием предыдущего формата, но последний формат гораздо короче и выводит любое количество строк.
Для описания в формате текстового значения, которое должно выводиться на несколько строк, применяется поледержатель следующего вида: ^<<<<<. Это специальное поле иногда называется "заполняемым полем". Оно предназначается для форматирования текстового значения, которое при выводе в отчет делится на строки, не превышающие ширину шаблона. Деление на строки производится по границам слов. Источником выводимого текста обязательно должна быть переменная со скалярным значением, из которой при каждом ее употреблении в формате извлекается столько слов, сколько поместится в соответствующем поле отчета. Заполнение шаблона текстом и вывод отчета в несколько строк иллюстрирует следующий пример:
my $shakespeare = 'Две равно уважаемых семьи ' . 'В Вероне, где встречают нас событья, ' . 'Ведут междоусобные бои ' . 'И не хотят унять кровопролитья.'; my $text = $shakespeare; write STDOUT; # описание формата вывода format STDOUT = ~~ ^<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<< $text У.Шекспир, "Ромео и Джульетта" .
В этом примере для организации неявного цикла вывода также применяется шаблон повторения строк, поскольку неизвестно, сколько строк будет заполнено выводимым текстом. При выполнении примера будет выведен текст в таком виде:
Две равно уважаемых семьи В Вероне, где встречают нас событья, Ведут междоусобные бои И не хотят унять кровопролитья. У.Шекспир, "Ромео и Джульетта"
Подобным образом в отчет выводятся блоки текстовой информации: примечания, описания, адрес и т. п.
Обычные и специальные поля
Пока что в примерах использовались только обычные поля (regular fields), которые описываются поледержателями, начинающимися с символа @. Поледержатели, описание которых начинается с символа ^, представляют так называемые специальные поля (special fields), обладающие возможностью дополнительной обработки данных. Так, специальные числовые поля (например, ^###), содержащие неопределенное значение (undef), заполняются пробелами. Обычные числовые поля (например, @###) в этом случае выводят нули. Это демонстрирует следующий пример:
format STDOUT = обычное:'@##.##' специальное:'^####' undef, undef . write STDOUT; # вывод данных по формату в STDOUT # выведет: обычное:' 0.00' специальное:' '
Специальные текстовые поля (например, ^<<<) используются для вывода в отчет данных, располагающихся на нескольких строках.
Отчеты
Вся информация, хранящаяся в компьютерных системах, в конечном счете предназначена для людей, а людям нравится видеть ее упорядоченной и аккуратно представленной. Представление данных, специально подготовленное для просмотра на экране или на бумаге, принято называть отчетом. Отчеты создаются для отображения информации в удобном для восприятия виде, поэтому при формировании отчета данные сортируются, обобщаются, снабжаются пояснительными заголовками и располагаются по возможности компактно и эстетично. Все мы постоянно сталкиваемся с отчетами, когда видим данные в "причесанном" отформатированном виде: это списки, реестры, таблицы, формы, карточки и другие документы. Одной из целей разработки Perl было создание удобного инструмента для подготовки отчетов. Perl предоставлял механизм для создания простых отчетов и диаграмм, начиная с самых ранних версий, и он незначительно изменился с тех пор. Хотя имеющиеся в нем средства работы с отчетами весьма лаконичны, они достаточны, чтобы в большинстве ситуаций приготовить данные для форматированного постраничного вывода на экран, печатающее устройство или в файл. Подготовка отчета начинается с описания его формата.
Переключение потоков и форматов
Без указания файлового манипулятора вывод отчета функцией write() и обычный вывод данных функцией print() происходит в выходной поток по умолчанию (STDOUT). С помощью функции select() можно назначить другой выходной поток по умолчанию. При вызове ей передается файловый манипулятор, и она переключается на новый поток, который становится текущим выходным потоком по умолчанию. Функция select() возвращает имя ранее выбранного манипулятора, и это значение используется для восстановления предыдущего выходного потока. Это происходит таким образом:
$old_handle = # сохранить файловый манипулятор select $new_handle; # переключиться на новый поток write; # вывести в новый поток select $old_handle; # восстановить предыдущий поток
При формировании сложного отчета может потребоваться возможность переключаться на разные форматы отчета. Установить для какого-либо потока определенный формат отчета можно путем присваивания имени формата переменной $~ ($FORMAT_NAME). Подобным же образом для конкретного потока устанавливается нужный формат заголовка страницы отчета: переменной $^ ($FORMAT_TOP_NAME) присваивается имя формата для шапки страницы. Это делается так:
$old_handle = select $out; # выбрать поток для отчета $^ = 'REPORT_TOP'; # назначить формат для шапки отчета $~ = 'REPORT'; # назначить формат для отчета write $out; # вывести в $out по формату REPORT select $old_handle; # вернуться к предыдущему потоку
Назначать для определенного потока формат отчета и заголовок страницы гораздо удобнее с помощью функций format_name() и format_top_name() из стандартного библиотечного модуля FileHandle. Это выглядит так:
use FileHandle; # подключить модуль работы с файлами
# назначить для потока $report формат отчета REPORT format_name $report REPORT; # назначить для потока $report формат заголовка PAGE format_top_name $report PAGE; # используя назначенные форматы, write $report; # вывести строку отчета в $report
Обратите внимание, что при обращении к функциям format_name() и format_top_name() после файлового манипулятора не ставится запятая, так же как при вызове функции print().
Поля отчета
Поле отчета - это пространство указанной ширины, расположенное в определенном месте отчета, куда помещаются данные в нужном представлении. (Например, конкретное поле в отчете может быть описано таким образом - "в начале первой строки заголовка каждой страницы должна выводиться текущая дата в следующем виде: день (две цифры с ведущим нулем), месяц (две цифры с ведущим нулем) и год (четыре цифры с ведущим нулем), разделенные точками".) Поля отчета в описании формата представлены в виде так называемых поледержателей (fieldholders). Поледержатель (или переменная поля) представляет из себя шаблон, описывающий тип поля, его ширину в символах, выравнивание значения внутри поля и другие преобразования, которые нужно выполнить над данными при размещении их в этом поле во время формировании отчета. Поледержатель начинается с символа начала шаблона (@ или ^), за которым следуют символы описания шаблона. Число символов в шаблоне, включая символ начала шаблона, определяет ширину помещаемых в отчет данных. Несколько примеров поледержателей с пояснениями приведены в таблице 10.1:
| @<<<<<<<<<<< | Вывести текстовое значение в поле шириной в 12 символов. Выровнять его по левому краю, дополнив при необходимости пробелами справа до ширины поля. Слишком длинное значение усечь до ширины поля |
| @<<<<<<<<... | Аналогично предыдущему примеру, но с выведением в конце поля многоточия, если значение усечено |
| @####.### | Вывести числовое значение в поле шириной в 9 символов, отведя 5 цифр под целую и 3 цифры - под дробную часть числа. Выровнять его по правому краю и дополнить при необходимости целую часть числа пробелами слева до ширины поля и округлить дробную часть до 3 знаков. При попытке вывести число, целая часть которого не умещается в ширину поля, заполнить поле символом '#' как признак |
| @0###.### | Так же, как в предыдущем примере, но с дополнением целой части значения ведущими нулями до ширины поля |
Полный список символов, применяемых для описания полей и форматов, приводится в таблице 10.2.
| @ | начало обычного поля | @ @<< @||| @>> @## |
| ^ | начало специального поля | ^ ^<< ^||| ^>> ^## |
| < | текстовое поле с выравниванием значения влево и добавлением пробелов справа | @<<<<< ^<<< |
| | | текстовое поле с центрированием значения и добавлением пробелов с обеих сторон | @||||| ^||| |
| > | текстовое поле с выравниванием значения вправо и добавлением пробелов слева | @>>>>> ^>>> |
| # | числовое поле с выравниванием значения вправо с добавлением пробелов слева | @#### ^### |
| 0 | (вместо первого #) числовое поле с выравниванием значения вправо и добавлением нулей слева | @0### ^0## |
| . | десятичная точка в числовом поле | @.### @0##.## |
| ... | закончить текстовое поле многоточием, чтобы показать усечение значения | @<<<<<... |
| @* | поле переменной ширины со значением, состоящим из нескольких строк | @* |
| ^* | поле переменной ширины для следующих строк многострочного значения | ^* |
| ~ | подавление вывода строки с пустыми значениями полей | ^* ~ |
| ~~ | повторять строку, пока все значения полей не станут пустыми | ~~ ^* |
| {} | группировка списка значений, который располагается на нескольких строках аргументов | {$one, $two, $three } |
| # | (первым символом в строке) строка комментария в описании формата (не может располагаться между строкой шаблонов и строкой аргументов) | # это комментарий |
| . | (единственным символом на отдельной строке) конец формата | format REPORT = описание формата . |
format STDOUT = Учетная карточка пользователя N @0### $number --------------------------------------------------------- Фамилия @<<<<<<<<<<<<<< | Login @<<<<<<< $last_name, $login Имя @<<<<<<<<<<< | Группа @<<<<<<<<<<<<<<<<< $first_name, $group Отчество @<<<<<<<<<<<<<<<<<< | $middle_name E-mail @<<<<<<<<<<<<<<<<<< | Телефон @>>>>>>>>> $email, $phone Ограничение дискового пространства @####.## Мегабайт $quota --------------------------------------------------------- Дата регистрации @# @<<<<<<<<< @### года {$day, $month_name,$year} .
Из примера понятно, что формат отчета записывается в виде, максимально похожем на представление страницы отчета на экране или на бумаге. Каждому полю в строке шаблонов должно соответствовать скалярное значение в строке аргументов. Имена переменных в строке аргументов для наглядности часто располагаются под соответствующими поледержателями в предыдущей строке шаблонов, хотя это совсем не обязательно. Список переменных может находиться на нескольких строках аргументов (как это сделано в описании последней строки формата); в этом случае он должен заключаться в фигурные скобки. Имейте в виду, что скалярные переменные и массивы в строке аргументов разворачиваются в единый список скаляров, из которого по порядку берутся значения для заполнения полей.
Специальные переменные форматов
Кроме переменных, в которых хранятся имена формата ($~) и заголовка страницы формата ($^), есть еще несколько специальных переменных для хранения информации о форматах. Номер текущей страницы выводимого отчета содержится в переменной $% ($FORMAT_PAGE_NUMBER), и ее часто включают в формат отчета. В переменной $= ($FORMAT_LINES_PER_PAGE) хранится число строк на странице: по умолчанию - 60, но его можно изменить на нужное значение перед выводом отчета. В переменной $- ($FORMAT_LINES_LEFT) содержится число оставшихся на странице строк. Переменная $^L ($FORMAT_FORMFEED) хранит символ перевода страницы (formfeed character), который используется в отчетах для прогона принтера до новой страницы.
Специальная переменная $: ($FORMAT_LINE_BREAK_SEPARATOR) содержит набор символов разрыва строки, после которых строка может быть разделена при заполнении в формате специальных полей продолжения. Специальная переменная $^A ($ACCUMULATOR) является аккумулятором выводимых данных для функций formline() и write(), в котором накапливаются данные отчета перед их отправкой в выходной поток. При считывании данных для отчета из файла может пригодиться переменная $. ($INPUT_LINE_NUMBER), в которой хранится номер прочитанной из входного файла строки, что можно использовать для нумерации строк в отчете.
Дополнительные сведения о форматах и отчетах в Perl можно узнать из стандартной документации, обратившись за помощью к утилите
perldoc perlform
В завершение лекции приведем пример законченной программы (с образцом исходных данных), выводящей отчет о книгах по языку Perl.
open my $report, '>', '/report.txt' or die; $old_handle = select $out; # выбрать поток для отчета select $report; $^ = 'HEAD'; $~ = 'REPORT'; # описание форматов для отчета while(<DATA>) { # чтение одной записи данных ($authors, $title, $year, $nick) = split ':'; write $report; # вывод одной строки отчета } close $report or die; # формат для заголовка страницы format HEAD = Классические книги по языку Perl издательства O'Reilly Лист @# $% ---------------+--------------------+----+------------ Авторы | Заглавие |Год | Прозвище ---------------+--------------------+----+------------ . format REPORT = ^<<<<<<<<<<<<<<|^<<<<<<<<<<<<<<<<<<<|@###|@>>>>>>>>>>> $authors, $title, $year, $nick ^<<<<<<<<<<<<<<|^<<<<<<<<<<<<<<<<<<<| | ~~ $authors, $title ---------------+--------------------+----+------------ . __DATA__ Cozens S.:Advanced Perl Programming,2nd ed.:2005:Panther Book Friedl J.E.F.:Mastering Regular Expressions:1997:Owls Book ...
Результатом работы этой программы будет такой отчет, размещенный в файле report.txt:
Классические книги по языку Perl издательства O'Reilly Лист 1 ---------------+--------------------+----+------------ Авторы | Заглавие |Год | Прозвище ---------------+--------------------+----+------------ Cozens S. |Advanced Perl |2005|Panther Book |Programming,2nd ed. | | ---------------+--------------------+----+------------ Friedl J.E.F. |Mastering Regular |1997| Owls Book |Expressions | | ---------------+--------------------+----+------------ Schwartz R.L., |Learning Perl, 4th |2005| Llama Book Phoenix T., |ed. | | brian d foy | | | ---------------+--------------------+----+------------
Конечно, изученные в этой лекции средства отчетов не могут сравниться с современными специализированными построителями отчетов, но во многих случаях бывает достаточно форматирования выходных данных в виде простых отчетов, которое в Perl делается достаточно легко, просто и наглядно. Эта лекция была "лирическим отступлением" перед тем как начать углубленное изучение техники программирования на языке Perl.
Вывод отчетов
Для форматированного вывода отчетов применяется функция write(), которая оформляет очередную порцию данных в соответствии с форматом отчета и выводит их в указанный выходной поток. Обращение к функции write() иногда называют вызовом формата. В качестве аргумента функции write() может передаваться файловый манипулятор выходного потока. Вызванная без аргументов, она направляет отчет в текущий выходной поток. Перед обращением к ней нужно заполнить новыми данными переменные, перечисленные в строках аргументов текущего формата. Обычно write() вызывается в цикле для вывода в отчет очередной строки. По историческим причинам для заполнения полей отчета часто используются глобальные переменные. Лексические переменные, объявленные с помощью my(), доступны в формате только тогда, когда формат и лексические переменные объявлены в одной области видимости. Подробно об областях видимости переменных будет рассказано в лекции 12.
Если для выходного потока описан формат начала страницы отчета, то перед выводом строк отчета функцией write() в начале каждой страницы автоматически размещаются данные шапки страницы в соответствии с форматом начала страницы. Программа для вывода данных по формату, заданному в предыдущем примере, может выглядеть таким образом:
# данные в записи входного файла разделены запятыми open my $in, '<', 'users.txt' or die; while (my $line = <$in>) { local ($last_name, $first_name, $middle_name, $login, $group, $email, $phone, $quota, $number, $day, $month_name, $year) = split ',', $line; # данные для отчета помещены в переменные write STDOUT; # данные выводятся в STDOUT по формату } close $in or die; # здесь располагается описание формата...
В результате выполнения этой программы в поток STDOUT будет выведен отчет, состоящий вот из таких карточек:
Учетная карточка пользователя N 00001 --------------------------------------------------------- Фамилия Wall | Login larry Имя Larry | Группа root Отчество | E-mail larry@wall.org | Телефон +123456789 Ограничение дискового пространства 9876,54 Мегабайт --------------------------------------------------------- Дата регистрации 18 декабря 1987 года
В каждую из выводимых в отчет карточек помещаются данные из одной записи входного файла.
Автосоздание объекта ссылки
Если попытаться разыменовать ссылку на несуществующий объект, то он автоматически будет создан. В этом случае работает удивительный механизм, называемый автосозданием объекта ссылки (буквально: "автооживление" - autovivification). Например, во время обращения по ссылке к элементу массива автоматически создается массив из пяти элементов, ссылка на него присваивается в переменную $array_ref, а пятый элемент получает начальное значение:
$array_ref->[4] = '5-й элемент'; # присваивание значения print ref($array_ref); # вызывает к жизни массив print scalar(@{$array_ref}); # из 5 элементов! print $$array_ref[4]; # печатаем значение
Подобным образом применяя автосоздание объектов, можно создать цепочку ссылок, указывающих на некоторое значение:
$$$$ref = 25; # при попытке присвоить значение # создаются 2 ссылочных переменных и 1 скалярная print "$ref $$ref $$$ref $$$$ref\n"; # выведет: REF(0x334dd8) REF(0x334e8c) SCALAR(0x334e98) 25
Интерполяция выражений с помощью ссылок
Программирующие на Perl на каждом шагу пользуются интерполяцией в строках скалярных переменных и массивов. Иногда требуется включить в строку результат вычисления какого-либо выражения. С помощью ссылок можно интерполировать любое выражение, например, вызов функции. Чтобы включить в строку значение скалярного выражения, его надо заключить в круглые скобки и взять на него ссылку операцией \, а затем разыменовать ссылочное выражение как скаляр с помощью префикса $. Вот таким образом:
$s = "localtime() ${\($x=localtime)} в скалярном контексте"; # значение выражения, например: 'Sun Mar 26 20:17:36 2006'
Чтобы включить в строку значение выражения, возвращающего список, его надо заключить в квадратные скобки, организуя ссылку на анонимный массив, а потом разыменовать ссылочное выражение как массив с помощью префикса @. Вот так:
$a = "localtime() @{[localtime()]} в списочном контексте"; # значение выражения, например: '36 17 20 26 2 106 0 84 1'
Разыменование ссылок
Чтобы получить доступ к значению, на которое указывает ссылка, нужно выполнить разыменование ссылки (dereference). Для этого переменная, содержащая ссылку, заключается в фигурные скобки и перед ней ставится нужный разыменовывающий префикс: $ для скаляра, @ для массива, % для хэша, & для подпрограммы. (Другими словами, после разыменовывающего префикса, определяющего тип хранящегося в переменной значения, вместо имени переменной записывается содержащая ссылку переменная или выражение, возвращающее ссылку.) Если не возникает неоднозначности в интерпретации выражения, то переменную, хранящую ссылку, в фигурные скобки можно не заключать. Вот примеры разыменования ссылок на скалярные значения:
print "${$ref2scalar} "; # или: $$ref2scalar print "${$ref2literal} "; # или: $$ref2literal print "${$ref2expression} "; # или: $$ref2expression
Значение скалярной переменной при доступе по ссылке, естественно, может изменяться, но попытка с помощью ссылки изменить литерал вызовет ошибку при выполнении программы ("Modification of a read-only value attempted"):
${$ref2scalar} = 'Новый скаляр'; # вполне законно ${$ref2literal} = 'Новый литерал'; # ОШИБКА!!!
Когда на какое-то значение ссылается несколько ссылочных переменных, то обращаться к этому значению можно с помощью любой из них. Значение доступно до тех пор, пока на него имеется хотя бы одна ссылка. Например:
my $ref2scalar = \$scalar; # ссылка на скаляр my $one_more_ref = $ref2scalar; # копия ссылки на скаляр # будет выведено одно и то же значение $scalar: print "${$ref2scalar} ${$one_more_ref}";
На рис. 11.2 показана ситуация, когда несколько ссылок указывают на одну скалярную переменную.
Рис. 11.2. Несколько ссылок на скаляр
Если переменная $ref2scalar перестанет ссылаться на $scalar (например, после undef $ref2scalar), то значение $scalar все еще будет доступно через переменную $one_more_ref.
Значением объекта ссылки также может быть ссылка (косвенная ссылка) на другой объект, возможно, тоже на ссылку. Ссылка даже может содержать ссылку на саму себя! Таким образом при необходимости можно построить цепочку ссылок любой длины. Например:
$value = 'Полезное значение'; $ref1 = \$value; # ссылка на значение $ref2 = \$ref1; # ссылка на ссылку на значение $ref3 = \$ref2; # ссылка на ссылку на ссылку на значение
Можно организовать многоуровневые косвенные ссылки без использования промежуточных переменных, несколько раз применяя операцию взятия ссылки на значение. Например, создадим такую цепочку ссылок:
$ref_chain = \\\$value; # цепочка из трех ссылок
Для доступа по такой цепочке ссылок к исходному значению правило разыменования применяется нужное число раз. Например, в цепочке из трех ссылок с помощью трех префиксов $ мы последовательно получаем доступ к ссылочным переменным, а еще один префикс нужен для доступа к полезному значению:
# выведем исходное значение через $ref3: print ${${${$ref3}}}; # или короче: print $$$$ref3; # или через $ref_chain: print $$$$ref_chain;
Если применить функцию ref() к переменной, содержащей ссылку на другой объект, то она вернет строку 'REF'. Если преобразовать в строку значение ссылки на ссылку, то будут выведено обозначение ссылочного типа и адрес объекта ссылки, например:
print ref($ref_chain); # выведет: 'REF' print $ref_chain; # выведет, например: 'REF(0x334e8c)'
Символические ссылки
Ссылки, о которых до этого шла речь, называются жесткими ссылками. Жесткая ссылка (hard reference) - это программный объект, хранящий в памяти адрес референта и тип его значения. В Perl имеется еще одна разновидность ссылок, называемых символическими ссылками. Символическая ссылка (symbolic reference) - это строковое значение, которое хранится в скалярной переменной и представляет из себя имя глобальной переменной:
$referent1 = 'Референт'; # объект ссылки $symlink = 'referent' . 1; # символическая ссылка # доступ по символической ссылке к значению объекта print ${$symlink}; # будет выведено: 'Референт'
Символические ссылки используются значительно реже и бывают нужны, когда требуется во время выполнения программы программно создавать имена переменных в виде строк, чтобы затем получать доступ к их значениям. Использование символических ссылок может приводить к трудно обнаруживаемым ошибкам, поэтому лучше запрещать использование в программе символических ссылок с помощью прагмы use strict 'refs'.
В этой лекции изучены ссылки и средства построения с помощью ссылок динамических структур данных. Ссылки дают программисту мощные и гибкие средства доступа к программным объектам. Поэтому многие механизмы работы с данными в Perl организованы с использованием ссылок, и мы будем обращаться к ссылкам в следующих лекциях при изучении подпрограмм, библиотечных модулей и объектного программирования.
Ссылки
Ссылки явно или неявно применяются во всех языках программирования. Они позволяют гибко создавать динамические структуры данных неограниченной сложности. Ссылки являются одним из скалярных типов данных языка Perl, наряду с числами и строками. Ссылка (reference) - это информация о том, где при выполнении программы располагается в памяти объект определенного типа. Эту информацию можно использовать для доступа к объекту ссылки (referent). Ссылка - это возможность обратиться к какой-то информации не по имени, которое известно при компиляции, а по ее расположению в памяти при выполнении программы. В отличие от указателей в некоторых других языках, в Perl ссылки реализованы надежно и эффективно. Программист не должен заботиться о явном удалении из памяти объектов ссылок, поскольку занимаемая память автоматически освобождается встроенным сборщиком мусора, когда объекты ссылок перестают использоваться (то есть когда на них больше не указывает ни одна ссылка). Для создания ссылки на существующий программный объект предусмотрена операция взятия ссылки, обозначаемая обратной косой чертой (backslash), которая ставится перед объектом ссылки. В следующем примере показано, как можно получить ссылку на скалярную переменную и сохранить ее в другой переменной:
my $scalar = 'Скаляр'; # объект ссылки my $ref2scalar = \$scalar; # ссылка на скаляр
На рис. 11.1 показан результат сохранения ссылки на значение скалярной переменной в другой скалярной переменной.
Рис. 11.1. Ссылка на скалярное значение
При помощи операции '\' можно брать ссылку на любые объекты, например, на литерал или на любое другое выражение, только при этом значение объекта ссылки нельзя будет изменить. В этом случае при выполнении программы выражение вычисляется, а результат сохраняется в анонимной области памяти, ссылка на которую и возвращается. Например:
my $ref2literal = \'Литерал'; # ссылка на литерал my $ref2expression = \($n1*$n2); # ссылка на выражение
Анонимные данные - это значения, не связанные ни с одной переменной, доступ к которым происходит только по ссылке. Ссылка всегда указывает на значение конкретного типа: скаляр, массив, хэш, подпрограмму (или элемент таблицы символов, о которых речи пока не было). На какой именно тип объекта указывает ссылка, можно узнать с помощью функции ref(), которая возвращает строку, описывающую тип значения объекта ссылки. Например:
print ref($ref2scalar); # выведет: 'SCALAR'
А что получится, если вывести значение самой ссылки? Ее значение будет преобразовано в строку, содержащую тип объекта ссылки и его адрес в виде шестнадцатиричного числа, например:
print $ref2scalar; # выведет, например: 'SCALAR(0x335b04)'
Обратно преобразовать в ссылку это строковое представление адреса не удастся.
Ссылки на хэши
Все, что говорилось о ссылках на массивы, применимо к ссылкам на хэши. Ссылка на переменную типа "хэш" получается с помощью операции взятия ссылки:
my %hash = ('Хэш' => 'ассоциативный массив'); my $ref2hash = \%hash; # ссылка на весь хэш print ref($ref2hash); # вернет: HASH
Ссылка на анонимный хэш создается с помощью фигурных скобок, в которых записываются начальные значения хэша:
my $ref2anon = { # ссылка на анонимный хэш 'language' => 'Perl', 'author' => 'Larry Wall', 'version' => 5.8 }; # конец присваивания ссылки
При помощи анонимного хэша удобно создавать копию существующего хэша, чтобы затем работать с ним через ссылку:
my $ref2copy = {%hash}; # ссылка на копию хэша
Разыменование ссылки на хэш записывается так же, как разыменование ссылки на массив, но с префиксом хэша %. При разыменовании ссылки на хэш переменную, содержащую ссылку, для наглядности можно обрамлять фигурными скобками:
# будет выведено одно и то же значение %hash: print %{$ref2hash}, %$ref2hash;
При помощи ссылок с хэшами можно выполнять любые действия, обращая внимание на правильное разыменование ссылки:
%hash_copy = %{$ref2hash}; # копия хэша @hash_slice= @{$ref2hash}{$key1, $key2}; # срез хэша (массив) @hash_keys = keys %{$ref2hash}; # ключи хэша (массив)
Разыменование ссылки на элемент хэша также записывается уже знакомым нам способом, когда перед ссылочной переменной ставится префикс скаляра $, а после нее - ключ элемента хэша в фигурных скобках. Ссылочная переменная может заключаться в фигурные скобки:
${$ref2hash}{'ключ'} = 'значение'; # изменение значения print $$ref2hash{'ключ'}; # доступ к значению элемента хэша
В другой форме разыменования ссылки к переменной, содержащей ссылку на хэш, применяется операция "стрелка", после которой в фигурных скобках указывается ключ элемента хэша. Вот так:
$ref2hash->{'термин'} = 'определение'; # добавим элемент $value = $ref2hash->{'Хэш'}; # найдем значение по ключу
Если ссылка используется как ключ хэша, она, как и любой ключ хэша, автоматически преобразуется в строку. Такие строки невозможно применять для доступа к объектам ссылки, но они могут служить отличными уникальными ключами хэша, поскольку строковое значение ссылки содержит адрес объекта в памяти, например, 'SCALAR(0x335b04)' или 'ARRAY(0x334dd8)'. Если все-таки требуется использовать ссылки в качестве ключей хэша, то можно воспользоваться модулем Tie::RefHash.
Ссылки на массивы
Подобным же образом можно работать со ссылками на массивы. Ссылка на переменную типа "массив" также создается с помощью операции взятия ссылки:
my @array = ('Это', 'список', 'в', 'массиве'); my $ref2array = \@array; # ссылка на массив
Если обращение к массиву будет происходить только по ссылке, то можно обойтись без переменной типа "массив", а создать анонимный массив и присвоить ссылку на него в скалярную переменную. Ссылка на анонимный массив создается с помощью квадратных скобок, в которые заключается список начальных значений безымянного массива:
my $ref2anon = [ # ссылка на анонимный массив 'Это', 'анонимный', 'массив' ]; # конец присваивания ссылки my $ref2empty = []; # ссылка на пустой анонимный массив
Анонимные массивы удобно использовать для создания ссылки на копию массива. Для этого существующий массив помещается в квадратные скобки, и его значение будет скопировано в созданный анонимный массив:
my $ref2copy = [@array]; # ссылка копию массива
Ссылка на именованный массив и ссылка на анонимный массив изображены на рис. 11.3.
Рис. 11.3. Ссылки на обычный и анонимный массивы
Разыменование ссылки на массив производится аналогично разыменованию ссылки на скалярную переменную, только с использованием префикса массива @:
# будет выведено одно и то же значение @array: print "@{$ref2array} @$ref2array\n";
Естественно, что, обращаясь к массиву по ссылке, можно выполнять с ним любые действия, как и с именованным массивом, например:
my @array_copy = @{$ref2array}; # копия массива @{$ref2array}[0,1] = ('Новый', 'список'); # срез массива
Разыменование ссылки на элемент массива оформляется так: перед ссылочной переменной, которая может заключаться в фигурные скобки, указывается префикс скалярного значения $, а после ссылочной переменной указывается индекс элемента в квадратных скобках. Другими словами, для обращения к элементу массива по ссылке имя массива заменяется ссылочной переменной:
print ${$ref2array}[0]; # или: $$ref2array[0]
Обращение по ссылке к элементу массива более наглядно записывается с помощью инфиксной операции ->, слева от которой записывается имя переменной, содержащей ссылку на массив, а справа - индекс элемента массива в квадратных скобках. Операция "стрелка" наглядно представляет ссылку, символы -> в ней записываются без пробела между ними. Вот пример:
# доступ по ссылке к значению элемента массива: my $element_value = $ref2array->[0]; # изменение значения элемента массива: $ref2array->[0] = $new_value;
Как к обычным скалярным значениям можно обращаться по ссылке к отдельным элементам массива, например:
$ref2element = \$array[0]; # ссылка на элемент массива ${$ref2element} = $new_value; # изменение элемента массива
В элементах массива можно хранить ссылки на другие массивы: это позволяет создавать в Perl многомерные массивы или "массивы массивов", как это делается в языке Java. В этом случае доступ к элементам многомерного массива также обычно записывается с использованием операции "стрелка", которая употребляется нужное количество раз:
@{$ref2NxM->[$n]} # вложенный массив $ref2NxM->[$n]->[$m] # скалярный элемент двумерного массива $ref2NxMxP->[$n]->[$m]->[$p] # элемент 3-мерного массива
Для удобства чтения программы допускается не записывать операцию "стрелка" между парами индексов массива в квадратных скобках:
$ref2NxM->[$n][$m] # так гораздо симпатичнее! $ref2NxMxP->[$n][$m][$p] # а тем более так...
Для примера приведем программу создания двумерного массива из трех строк по пять элементов в каждой строке:
my $ref2RxC = []; # ссылка на анонимный массив массивов for (my $row = 0; $row < 3; $row++) { # цикл по строкам $ref2RxC->[$row] = []; # строка: вложенный массив for (my $col = 0; $col < 5; $col++) { # по колонкам $ref2RxC->[$row]->[$col] = ($row+1).'.'.($col+1); } }
Небольшие многомерные массивы удобно создавать, используя вложенные анонимные массивы. Это присваивание создаст такой же массив, что и в предыдущем примере:
$ref2RxC = [ # ссылка на двумерный анонимный массив [1.1, 1.2, 1.3, 1.4, 1.5], # 1-я "строка" [2.1, 2.2, 2.3, 2.4, 2.5], # 2-я "строка" [3.1, 3.2, 3.3, 3.4, 3.5] # 3-я "строка" ]; # конец присваивания ссылки
На рис. 11.4 изображен получившийся в результате "массив массивов" (Аrray of Аrrays, AoA), представляющий собой многомерный массив.
Рис. 11.4. Организация многомерного 'массива массивов'
Для вывода значений многомерного массива обычно используется нужное число вложенных циклов for или других циклических конструкций:
# цикл по строкам (элементам массива верхнего уровня) for (my $row = 0; $row < @{$ref2RxC}; $row++) { # цикл по столбцам (элементам вложенных массивов) for (my $col = 0; $col < @{$ref2RxC->[$row]}; $col++) { print "$ref2RxC->[$row][$col] "; } print "\n"; }
В результате выполнения этой программы построчно будет выведено значение всех элементов из массива массивов:
1.1 1.2 1.3 1.4 1.5 2.1 2.2 2.3 2.4 2.5 3.1 3.2 3.3 3.4 3.5
В любой массив можно поместить список ссылок на другие программные объекты, например, таким образом:
@reference_list = (\$scalar, \@array, \%hash);
Можно записать то же самое более простым способом, поставив операцию взятия ссылки перед списком объектов в круглых скобках:
@reference_list = \($scalar, @array, %hash);
Списки ссылок на объекты могут, например, передаваться в подпрограмму для изменения перечисленных в списке объектов. Передача аргументов в подпрограммы по ссылке и по значению будет рассмотрена в следующей лекции.
Ссылочные структуры данных
Аналогично созданию "массива массивов" создаются и другие разновидности ссылочных структур данных: массивы хэшей, хэши массивов и хэши хэшей. Ссылочные структуры применяются для структурированного представления взаимосвязанных данных. Для хранения в каждом элементе массива нескольких значений применяется массив хэшей (Array of Hashes, AoH). Вот пример массива, содержащий ссылки на анонимные хэши, в каждом из которых хранятся сведения о каком-либо объекте:
my $AoH = [ # этапы "Формулы-1" '2006 года {grand-prix=>'Бахрейна', date=>'2006.03.12'}, {grand-prix=>'Малайзии', date=>'2006.03.19'}, {grand-prix=>'Австралии', date=>'2006.04.02'}, {grand-prix=>'Сан-Марино', date=>'2006.04.23'}, # и так далее... ]; # напечатать хэш, на который ссылается 4-й элемент массива print "Гран-при $AoH->[3]->{grand-prix} $AoH->[3]->{date}"; # выведет: Гран-при Сан-Марино 2006.04.23
Для того чтобы ассоциировать с каждым ключом хэша список скалярных значений, применяется хэш массивов (Нash of Аrrays, HoA). Приведем пример хэша массивов, где в каждом элементе хэша хранится ссылка на анонимный список ассоциированных значений:
my $HoA = { # годы создания языков программирования 1964 => ['SIMULA', 'BASIC', 'PL/1'], 1970 => ['Forth', 'Pascal', 'Prolog'], 1979 => ['Ada', 'Modula-2'], 1987 => ['Perl', 'Haskell', 'Oberon'], 1991 => ['Python', 'Visual Basic'] }; # напечатать список, ассоциированный с 1987 годом foreach my $language (sort @{$HoA->{1987}}) { print "$language "; } # выведет: Haskell Oberon Perl
Элементы хэша также могут хранить ссылки на другие хэши, образуя хэш хэшей (Нash of Нashes, HoH). Вот пример описания хэша хэшей, где с каждым поисковым ключом ассоциируется анонимный хэш с информацией об объекте:
my $HoH = { # авторы и годы создания языков программирования 'Pascal' => {author=>'Niklaus Wirth', year=>1970}, 'Perl' => {year=>1987, author=>'Larry Wall'}, 'C' => {author=>'Dennis Ritchie', year=>1972} }; # в каком году был создан Pascal? print $HoH->{'Pascal'}->{'year'}; # выведет: 1970 # кто создал язык Си? print $HoH->{'C'}->{'author'}; # выведет: Dennis Ritchie
Имеющиеся в других языках программирования записи (record) или структуры (struct), в Perl чаще всего представляются в виде хэшей, в которых ключи используются в качестве имен полей и применяются для доступа к значениям полей записи. Для завершающего примера создадим набор записей с информацией о людях. Каждая запись будет анонимным хэшем, а ссылки на записи будут храниться в массиве. В каждой записи дату рождения представим в виде анонимного массива, содержащего год, месяц и день. Вот таким образом:
my $family = [ # массив записей о семье[ {name => 'Михаил', birthday => [1958, 11, 12]}, {name => 'Ирина', birthday => [1955, 03, 23]}, {name => 'Маша', birthday => [1980, 07, 27]}, {name => 'Миша', birthday => [1981, 11, 28]}, {name => 'Лев', birthday => [1988, 06, 24]} ]; # напечатаем год рождения Маши: print "$family->[2]->{birthday}->[0]"; # или проще: print "$family->[2]{birthday}[0]"; # выведет: 1980
Подобные структуры легко динамически модифицировать при выполнении программы. Например, добавим в каждую запись новое поле - 'address', в котором сохраним ссылку на запись о месте проживания человека. Адрес оформим в виде анонимного хэша из нескольких полей:
# адрес в виде анонимного хэша, в $address - ссылка на него: $address = {country => 'Россия', index => 641870}; # и т.д.
# добавить поле адреса и поместить туда $address: foreach my $person (@{$family}) { # пропишем всех $person->{address} = $address; # по одному адресу } # выведем почтовый индекс для Ирины print "$family->[1]->{address}->{index}\n"; # 641870
На рис. 11.5 приведена ссылочная структура данных, которая получилась в результате выполнения программы. Для доступа по ссылкам ко всем элементам этой структуры используется единственная именованная переменная $family.
Рис. 11.5. Пример ссылочной структуры данных
С помощью ссылок создаются и другие динамические структуры данных: связные списки, деревья и графы. Подытоживая все сказанное о ссылках, в таблице 11.1 приводится сводная информация о синтаксических конструкциях при работе со ссылками.
| Взятие ссылки на объект | $sref = \$scalar; | $aref = \@array; | $href = \%hash; |
| Создание ссылки на анонимный объект | $sref = \'Литерал'; | $aref = [$a, $b]; | $href = {$a => $b}; |
| Доступ к значению объекта ссылки | ${$sref} $$sref | @{$aref} @$aref | %{$href} %$href |
| Доступ к значению элемента объекта ссылки | $aref-> [$index] ${$aref}[$index] | $href->{$key} ${$href}{$key} | |
| Доступ к срезу объекта ссылки | @{$aref}[$i1, $i2] | @{$href}{$k1, $k2} | |
| Значение функции ref($ref) для объекта ссылки | SCALAR | ARRAY | HASH |
Контекст вызова
Для разработки универсальных подпрограмм программисту нужно знать, в каком контексте была вызвана подпрограмма - какого возвращаемого значения от нее ожидают. Для этого в Perl предусмотрена функция wantarray(). Она возвращает истинное значение, если подпрограмма вызвана в списочном контексте, ложное значение, если подпрограмма вызвана в скалярном контексте, и неопределенное значение, если подпрограмма вызвана в пустом контексте. Проверка ожидаемого значения в подпрограмме и примеры ее вызова могут выглядеть так:
sub list_or_scalar { my @result = fill_result(); # формируем результаты if (!defined wantarray) { # пустой контекст - return; # не возвращаем значения } elsif (wantarray) { # списочный контекст - return @result; # возвращаем список } else { # скалярный контекст - return "@result"; # возвращаем скаляр } } list_or_scalar(); # вызов в пустом контексте my @list = list_or_scalar(); # вызов в списочном контексте my $scalar = list_or_scalar(); # вызов в скалярном контексте
Объявление подпрограмм
При необходимости можно объявить подпрограмму до ее использования (forward declaration), а определение ее отнести в конец программного файла. При объявлении тело подпрограммы не записывается. Например:
sub factorial; # вычислить факториал числа
В объявлении подпрограмм могут указываться прототипы, о которых речь пойдет немного позднее в этой лекции.
Области видимости переменных
В Perl переменные по умолчанию видимы в пределах всей программы (точнее, в пределах пакета, но об этом будет рассказано позднее). Практика доказала, что использование глобальных переменных противоречит принципу модульности, поскольку связывает части программы зависимостями от глобальных данных. Поэтому во всех языках программирования предусмотрены средства ограничения видимости переменных. Как уже упоминалось в лекции 2, в Perl это делается с помощью объявления переменных. Чтобы ограничить видимость переменных рамками блока или подпрограммы, нужно объявить для них лексическую область видимости с помощью функции my(), как это уже делалось в приводимых ранее примерах. Когда при помощи my объявляется несколько переменных, то все они должны заключаться в круглые скобки, как показано ниже:
my ($var1, $var2, $var3) = (1, 2, 3); # правильно # запись my ($var1=1, $var2=2, $var3=3) ошибочна my $var4 = 4, $var5 = 5; # $var5 - глобальная, а не my
Чтобы проследить, как изменяются значения переменных, объявленных в главной программе и подпрограммах, внимательно прочитайте следующий пример (скучный, но полезный для понимания):
use strict; my $var = 'm'; # лексическая $var в main print "1(main)='$var'\n"; # выведет: 1(main)='m' sub1(); print "7(main):'$var'\n"; # выведет: 7(main):'z'
sub sub1 { print "2(sub1)='$var'"; $var = 's'; # изменяется $var из main! print "-->'$var'\n"; # выведет: 2(sub1)='m'-->'s' my $var = '1'; # изменена $var1 из sub1 print "3(sub1)='$var'\n"; # выведет: 3(sub1)='1' sub2(); # снова видима $var1 из sub1 print "6(sub1):'$var'\n"; # выведет: 6(sub1):'1' } sub sub2 { # снова видима $var из main print "4(sub2):'$var'"; $var = 'z'; # изменяется $var из main!! print "-->'$var'\n"; # выведет: 4(sub2):'s'-->'z' my $var = '2'; # изменена $var1 из sub2 print "5(sub2)='$var'\n"; # выведет: 5(sub2)='2' }
Обратите внимание, что лексическая переменная $var, объявленная в главной программе, видима в обеих подпрограммах sub1 и sub2, поскольку они статически объявлены в рамках той же программы. Но при выполнении программы в подпрограмме sub2 не видима переменная $var, объявленная в процедуре sub1. Из приведенного примера видно, что после объявления в подпрограмме лексических переменных с помощью my(), изменения этих переменных не затрагивают других переменных с теми же именами. Поэтому, чтобы избежать нежелательного изменения значений переменных в других частях программы, рекомендуется всегда объявлять для переменных лексическую область видимости. Проконтролировать наличие объявлений для переменных в программе поможет прагма use strict. Другая разновидность лексических переменных, описываемых с помощью функции our, будет рассмотрена в следующей лекции.
Определение подпрограмм
Подобно определению термина в словаре, при определении подпрограммы (subroutine definition) с ее именем сопоставляется последовательность действий, которую нужно выполнить. Подпрограммы определяются с помощью ключевого слова sub, за которым следует имя подпрограммы и блок, называемый телом подпрограммы, в котором содержатся исполняемые предложения подпрограммы. Имя подпрограммы - это идентификатор, который записывается по тем же правилам, что и имя переменной. В соответствии со сложившимся стилем программирования на Perl имена подпрограмм записываются строчными буквами, а логические составляющие имени разделяются символами подчеркивания. Часто для имен подпрограмм выбирают подходящие по смыслу глаголы. Вот пример определения подпрограммы и ее вызова:
# определение подпрограммы: sub say_hello { # имя подпрограммы if ($language eq 'ru') { # тело подпрограммы print 'Здравствуйте!'; } elsif ($language eq 'ja') { print 'Konnichi-wa!'; } else { print 'Hello!'; } }
$language = 'ru'; # напечатать приветствие по-русски say_hello; # вызов подпрограммы
Определение подпрограмм может располагаться в любом месте программного файла. (Можно даже перемежать определения подпрограмм выполняемыми предложениями программы, поскольку определения пропускаются при выполнении. Но разбираться в логике такой программы будет непросто!) Из соображений практического удобства, определения подпрограмм часто располагают в исходном тексте после основной программы, чтобы вначале ознакомиться с общей логикой программы. Но это дело вкуса: например, разработчики, привыкшие программировать на Pascal или C, располагают определения подпрограмм в начале исходного текста.
Параметры подпрограммы
Пока что в приведенных примерах подпрограммы использовали значение глобальных переменных, но сама идея применения подпрограмм предполагает применение заложенного в них алгоритма для обработки передаваемых им параметров. Когда подпрограмма вызывается с набором аргументов, ей передается специальный массив с предопределенным именем @_, содержащий список переданных аргументов. В теле подпрограммы переданные значения доступны в виде элементов массива @_, что видно из следующего примера:
sub cube { # вычислить куб числа return $_[0] * $_[0] * $_[0]; # умножить аргумент } print cube(2); # будет напечатано 8
Количество переданных аргументов можно выяснить, запросив число элементов массива @_. Для обработки списка аргументов переменной длины часто используется встроенная функция shift(), которая извлекает из массива параметров очередное значение, переданное подпрограмме:
print2files($message, $file1, $file2, $file3); sub print2files { # вывести текст в несколько файлов my $text = shift; # 1-й параметр - текст while (@_) { my $file = shift; # очередное имя файла open my $fh, ">>$file" or die; print $fh, $text; close $fh or die; } }
Если переданные аргументы заданы переменными, то массив параметров @_ совмещается с переданными аргументами. Это означает, что изменение элементов массива приведет к изменению значений соответствующих переменных в вызывающей программе. Это можно проиллюстрировать следующим (несколько искусственным) примером:
sub sum2 { # вычислить сумму 2-х чисел $_[0] = $_[1] + $_[2]; # поместить сумму в 1-й аргумент return; } my $a = 1, $b = 2, $sum = 0; sum2($sum, $a, $b); print "$a+$b=$sum"; # будет напечатано: 1+2=3
Опыт показывает, что изменение значения аргументов ведет к трудно обнаруживаемым ошибкам и осложняет сопровождение программы, поэтому должно использоваться в исключительных случаях и всегда оговариваться в комментариях. Общепринятым способом работы с параметрами подпрограммы является присваивание значения аргументов списку переменных: это предохраняет аргументы от изменения и позволяет работать не с элементами массива, а с удобно названными переменными. Это видно из следующего примера:
sub get_file { # считать данные из файла my ($path, $file) = @_; # присвоить аргументы в переменные return unless -e "$path/$file"; # авария: файла нет open my $fh, '<', "$path/$file" or return; my @lines = <$fh>; # прочитать все строки файла в массив close $fh or return; return @lines; # вернуть массив строк файла } my @data = get_file('/tmp', 'log.txt');
Хотя подпрограмма может изменять значения глобальных переменных в вызывающей программе, требования надежности предписывают всегда передавать исходные данные в подпрограмму в виде аргументов, а результат ее работы получать в виде возвращаемого значения.
По той же причине, по которой подпрограмма не может возвращать несколько списков, она не может получать несколько отдельных списков в виде аргументов. Например, если подпрограмма вызвана так: subr1(@array1, @array2), то ей будет передан объединенный список из элементов двух массивов @array1 и @array2. Поэтому если необходимо передать несколько списочных объектов, то передаются ссылки на них, например: subr1(\@array1, \@array2).
Прототипы
В Perl программисту предоставляется возможность выполнить во время компиляции ограниченную проверку количества и типов параметров у подпрограммы. Это делается с помощью прототипа списка параметров. Для этого в определении и в объявлении подпрограммы после ее имени в круглых скобках указывается прототип. Прототип представляет из себя последовательность разыменовывающих суффиксов, определяющих количество параметров подпрограммы и типы их контекстов. Вот несколько примеров определения подпрограмм с прототипами:
# определение подпрограммы с 1-м параметром-скаляром sub list_mp3 ($) { my $path = $_[0]; # ... } # определение подпрограммы c 2-мя скалярными параметрами sub translate ($$@) { # и списком скаляров my ($from_lang, $to_lang, @words) = @_; # ... } sub generate_test(); # объявление подпрограммы без параметров
Для подпрограмм, определенных с прототипами, компилятор контролирует количество передаваемых аргументов и устанавливает ожидаемый подпрограммой контекст для каждого из аргументов. В приведенном далее вызове подпрограммы вместо массива ей будет передано количество элементов массива, поскольку прототип подпрограммы устанавливает скалярный контекст для единственного аргумента:
list_mp3 @dirs; # будет передан 1 скаляр: scalar @dirs
Перечень символов, применяемых для описания прототипов, с примерами определения подпрограмм приведен в таблице 12.1.
| () | отсутствие аргументов | sub mytime () | mytime; |
| $ | скалярное значение | sub myrand ($) sub myrename ($$) | myrand 100; myrename $old, $new; |
| @ | список скалярных значений (поглощает остальные параметры, поэтому употребляется последним в списке) | sub myreverse (@) sub myjoin ($@) | myreverse $a, $b, $c; myjoin ':', $x, $y, $z; |
| & | подпрограмма | sub mygrep (&@) | mygrep {/pat/} $a, $b, $c; |
| * | элемент таблицы символов (например, дескриптор файла) | sub myopen (*$) | myopen HANDLE, $name; |
| \ | взятие ссылки на следующий за ней прототип | sub mykeys (\%) sub mypop (\@) sub mypush(\@@) | mykeys %hash; mypop @array; mypush @stack, $a, $b; |
| ; | разделитель обязательных параметров от необязательных (в конце списка) | sub mysubstr ($$;$) | mysubstr $str, $pos; mysubstr $str, $pos, $length; |
Проверки на соответствие прототипам не выполняются, если подпрограмма вызывается устаревшим способом (с префиксом &), а также для методов и подпрограмм, вызываемых через ссылки.
Ссылки на подпрограммы
Скалярные переменные могут хранить ссылки не только на данные, но и на подпрограммы. В операции взятия ссылки имя подпрограммы должно использоваться с разыменовывающим префиксом &, как это показано в следующем примере:
$ref2max = \&max; # взятие ссылки на подпрограмму sub max { # вычисляет максимум из списка значений my $maximum = shift; foreach (@_) { $maximum = $_ if ($_ > $maximum); } return $maximum; } print ref($ref2max); # будет выведено: CODE
Первый способ обращения к подпрограмме через ссылочную переменную оформляется аналогично обращению к элементу массива или хэша: после имени переменной, содержащей ссылку на подпрограмму, записывается операция разыменования ссылки (->), за которой обязательно указываются круглые скобки (со списком аргументов или без него), которые показывают, что это обращение к подпрограмме:
$max_of_list = $ref2max->(@list_of_numbers);
Другая форма обращения к подпрограмме с использованием ссылочной переменной предполагает использование префикса &:
$max_of_list = &$ref2max(@list_of_numbers); # можно окружить ссылочную переменную фигурными скобками $max_of_list = &{$ref2max}(@list_of_numbers);
Вызов подпрограммы без параметров в этом случае можно записывать без круглых скобок, а при использовании -> скобки обязательны (иначе как узнать, что это обращение к подпрограмме?):
&$reference_to_procedure; # с префиксом подпрограмм $reference_to_procedure->(); # с операцией разыменования
Если предполагается, что доступ к подпрограмме будет происходить не по имени, а только по ссылке, то можно определить анонимную подпрограмму и присвоить ссылку на нее в скалярную переменную, через которую будет осуществляться вызов подпрограммы.
my $ref2sum = sub { # определение анонимной подпрограммы my $sum = 0; # вычисляет сумму списка значений $sum += $_ foreach (@_); return $sum; }; # конец операции присваивания переменной $ref2sum print $ref2sum->(1..5), " \n";
Ссылки на подпрограммы бывает удобно хранить в массивах, например, когда над одними и теми же данными нужно выполнить целый список преобразований. Примерно так:
my @refs = ($ref2read, $ref2calc, $ref2format); for (my $i = 0; $i < @refs; $i++) { @data = $refs[$i]->(@data); # обработать данные }
В других случаях ссылки на подпрограммы предпочтительнее поместить в хэш, чтобы в каждом его элементе подпрограмма ассоциировалась с нужным поисковым ключом. Как в этом примере:
my %refs2subs = ('SUM' => $ref2sum, 'MAX' => $ref2max); print $refs2subs{'SUM'}->(1..3), " \n";
Возврат значений
В Perl все подпрограммы всегда возвращают значения. Если не указано ничего иного, возвращаемым значением будет значение последнего вычисленного в подпрограмме выражения. В следующем примере функция dice() возвращает список из двух случайных чисел от 1 до 6, имитируя бросок игральных костей:
sub dice { # бросаем игральные кости: (int(rand 6)+1, int(rand 6)+1); # два случайных числа }
Также в Perl есть встроенная функция возврата из подпрограммы return, которая завершает выполнение подпрограммы и возвращает значение указанного выражения. Так делается в пользовательской функции приветствия:
sub greeting { # приветствие в зависимости от времени суток my $hours = (localtime)[2]; # текущие часы if ($hours >= 4 and $hours < 12) { return 'Доброе утро'; } elsif ($hours >= 12 and $hours < 18) { return 'Добрый день'; } elsif ($hours >= 18 and $hours < 22) { return 'Добрый вечер'; } else { return 'Доброй ночи'; } } print greeting(), '!';
Если выражение не указано, возвращается пустой список в списочном контексте и неопределенное значение undef - в контексте скалярном. В следующем примере функция проверки размера файла get_file_size() возвращает неопределенное значение как сигнал об отсутствии файла.
sub get_file_size { # узнать размер файла return -s $file # вернуть размер, в т.ч. 0, if -e $file; # если файл существует return; # файла нет, вернуть undef }
Использование return в подпрограммах относится к хорошим привычкам программиста, поскольку делает исходный текст более понятным для того, кто будет читать программу и заниматься ее сопровождением. Ведь хорошо известно, что даже автору потребуются значительное время и усилия, чтобы вспомнить в деталях логику давно написанной им программы.
Помня о том, что списки в Perl - одномерные, становится понятным, что подпрограмма в Perl может возвращать только один список. Например, если в ней записано return (@array1, @array2), будет возвращен объединенный список из элементов @array1 и @array2. Поэтому при необходимости вернуть несколько списочных объектов возвращаются ссылки на них, например: return (\@array1, \@array2).
Временные значения переменных с помощью local
В Perl имеется функция local(), также влияющая на область видимости переменных. Многие считают, что более удачным названием для нее было бы save(), потому что ее основное назначение - скрыть текущее значение глобальных переменных. Эта функция не создает локальных переменных, а делает "локальными" значения существующих глобальных переменных в текущей подпрограмме, блоке, eval или программном файле. Это значит, что после выполнения local текущие значения указанных переменных сохраняются в скрытом стеке, и новые значения переменных будут видимы вплоть до выхода из выполняемой подпрограммы, блока или файла, после чего восстанавливаются сохраненные значения переменных. На время действия local переменные остаются глобальными, поэтому новые временные значения переменных будут видимы и в вызываемых подпрограммах. Из-за временного характера действия функции local иногда говорят, что она описывает динамическую область видимости. Несколько переменных, чьи значения делаются временно скрытыми при помощи local, должны заключаться в круглые скобки, как показано ниже:
local $_; # временно скрыть значение буферной переменной local ($global1, $equant) = (1, 2); # правильно
Посмотрите, как изменится результат, если переписать предыдущий пример с использованием local вместо my в подпрограмме sub1:
$var = 'm'; # ГЛОБАЛЬНУЮ $var можно скрыть через local print "1[main]='$var'\n"; # выведет: 1[main]='m' sub1(); print "7[main]:'$var'\n"; # выведет: 7[main]:'s'
sub sub1 { print "2[sub1]='$var'"; $var = 's'; # изменена $var из main! print "-->'$var'\n"; # выведет: 2[sub1]='m'-->'s' local $var = '1'; # значение ГЛОБАЛЬНОЙ $var скрывается print "3[sub1]#'$var'\n"; # выведет: 3[sub1]#'1' sub2(); print "6[sub1]:'$var'\n"; # выведет: 6[sub1]:'1' } sub sub2 { # видна ГЛОБАЛЬНАЯ $var из sub1 print "4[sub2]:'$var'"; $var = 'z'; # изменена $var из sub1! print "-->'$var'\n"; # выведет: 4[sub2]:'1'-->'z' my $var = '2'; # изменена $var из sub2 print "5[sub2]='$var'\n"; # выведет: 5[sub2]='2' }
Сравнивая эту программу с предыдущим примером, можно отметить следующие отличия.
Переменную $var в главной программе пришлось сделать глобальной, так как local не может скрывать лексические переменные.Действие local распространяется до конца подпрограммы sub1, а также на вызываемую подпрограмму sub2.При выходе из подпрограммы sub1 действие local заканчивается и восстанавливается значение, которое содержала глобальная переменная $var до применения к ней local.
В современных программах в основном используют функцию my для задания переменным лексической области видимости. Оправданное применение функции local в Perl обычно сводится к следующим случаям:
Временное скрытие значения глобальных переменных, в том числе у специальных переменных.Временная модификация отдельных элементов массивов и хэшей, даже имеющих лексическую область видимости.Создание локальных файловых манипуляторов в версиях Perl до 5.6, не поддерживающих использование лексических переменных для хранения файловых манипуляторов.
Вызов подпрограмм
Подпрограммы в Perl вызываются, когда их имя употребляется в каком-либо выражении. В этот момент выполняются определенные в подпрограмме действия, а выражение получает возвращенный подпрограммой результат. Хотя довольно часто возвращаемое подпрограммой значение игнорируется. Про такое обращение к подпрограмме говорят, что она вызвана в пустом контексте (void context). Минимальное выражение для вызова подпрограммы состоит из одного имени подпрограммы, и это выражение превращается в предложение программы, когда после него стоит точка с запятой. Вот пример выражения, состоящего только из вызова подпрограммы в пустом (безразличном) контексте:
yellow_submarine('We all live in a');
Кстати, в пустом контексте можно употреблять любые другие выражения, хотя, конечно, смысл в этом есть далеко не всегда:
2 * 2; # результат отброшен, есть смысл, если стоит... 'Истина где-то рядом'; # ...в конце подпрограммы $x++; # используется ради побочного эффекта
Обращение к подпрограмме может записываться различными способами - главное, чтобы компилятор Рerl мог определить, что встретившийся идентификатор - это имя вызываемой подпрограммы. Дать подсказку об этом компилятору можно по-разному. В ранних версиях Perl при вызове перед именем подпрограммы требовался разыменовывающий префикс &. Например:
&sub_without_parameters; # вызов подпрограммы без параметров &sub_with_parameters($arg1, $arg2); # и с параметрами
В современном Perl эта устаревшая форма вызова с префиксом & допустима и иногда используется. Гораздо чаще обращение к подпрограмме обозначается использованием круглых скобок после имени подпрограммы, даже если она вызывается без параметров. Как в этих примерах:
format_c(); # вызов подпрограммы без параметров format_text($text, $font, $size); # и с параметрами
Чтобы обращаться к пользовательской подпрограмме в стиле встроенных функций без круглых скобок, нужно чтобы определение или объявление подпрограммы было известно компилятору раньше ее вызова.
sub circle; # объявление пользовательской функции $square_of_circle = circle $radius; # вызов функции
sub circle { # определение пользовательской функции return 3.141592653*$_[0]*$_[0]; # площадь круга }
В Perl эффективно реализована рекурсия, поэтому традиционные рекурсивные алгоритмы можно оформлять в виде вызова в подпрограмме самой себя. Например, как в классической функции вычисления факториала:
sub factorial ($) { # вычислить N! my $n = shift; return ($n <= 1) ? 1 : $n * factorial($n-1); }
Замыкания
С помощью ссылок, подпрограмм и лексических переменных создаются очень интересные информационные объекты, называемые замыканиями (closure). Они основаны на известном принципе, что объект ссылки сохраняется до тех пор, пока на него указывает хотя бы одна ссылка. А переменная может хранить ссылку на значение лексической переменной, динамически создаваемой при входе в блок и автоматически уничтожаемой при выходе из него. Это видно из следующего примера:
my $ref; # переменная для хранения ссылки { # в блоке создается my $lex_var = 'Суслик'; # переменная $lex_var $ref = \$lex_var; # в $ref помещена } # ссылка на переменную # $lex_var освобождается при выходе из блока print "Ты суслика видишь? И я не вижу. А он есть: "; print ${$ref}; # объект ссылки доступен через $ref
Подобным образом можно хранить ссылку на анонимную подпрограмму, из которой будут доступны динамически созданные лексические переменные. Такая подпрограмма, вызванная по ссылке, будет иметь доступ к области видимости этих переменных. Приведем пример простого замыкания:
my $ref; # переменная для хранения ссылки { # в блоке создается my $lex_var = 'Верблюд'; # переменная $lex_var $ref = sub { return $lex_var }; # в $ref помещена } # ссылка на подпрограмму # $lex_var освобождается при выходе из блока print &$ref; # объект возвращается подпрограммой по $ref
Замыкания можно создавать динамически при выполнении программы. Приведем пример функции, которая при каждом вызове создает замыкание и возвращает ссылку на него. При этом каждый раз создается новый экземпляр лексической переменной, замкнутый от доступа извне:
sub make_closure { # функция создания замыканий: my ($animal) = @_; # В лексической переменной # сохраняется аргумент функции my $ref2closure = sub { # и ссылка на # анонимную подпрограмму, return $animal; # которая имеет доступ }; # к лексической переменной. return $ref2closure; # возвращает ссылку на подпрограмму } # создаем 2 замыкания, сохраняя в них разные значения: my $camel1 = make_closure('дромадер'); # одногорбый верблюд my $camel2 = make_closure('бактриан'); # двугорбый верблюд print &$camel1, ' ', $camel2->(); # доступ по ссылкам
В этой лекции изложены основные сведения о подпрограммах в Perl. Мы продолжим изучение подпрограмм в лекции 13, где будет рассказано о библиотечных модулях, и в лекции 14, посвященной объектному программированию на Perl. Конечно, осталось еще много нерассмотренных тонкостей, касающихся работы с подпрограммами, которые можно узнать из книг [43] и [55] или из стандартной документации, обратившись к старой доброй утилите
perldoc perlsub
В этой лекции изложены основные сведения о подпрограммах в Perl. Мы продолжим изучение подпрограмм в лекции 13, где будет рассказано о библиотечных модулях, и в лекции 14, посвященной объектному программированию на Perl. Конечно, осталось еще много нерассмотренных тонкостей, касающихся работы с подпрограммами, которые можно узнать из книг [43] и [55] или из стандартной документации, обратившись к старой доброй утилите
perldoc perlsub
| © 2003-2007 INTUIT.ru. Все права защищены. |
Библиотеки
Современные языки программирования предоставляют программистам средства для того, чтобы упорядочить свои наработки. Нетривиальная программа обычно представляет из себя некоторое количество файлов с исходными текстами, расположенных в нескольких каталогах. А большие программные комплексы образуют внушительную иерархию подкаталогов, содержащих десятки и сотни программных файлов. Универсальные подпрограммы принято сохранять в отдельных библиотечных файлах, чтобы обращаться к ним из разных программ. Сходные по назначению процедуры и функции объединяются в библиотеки подпрограмм. Библиотека программ на Perl - это файл, обычно с суффиксом .pl, где хранится произвольный набор подпрограмм для использования в других программах. (Этот суффикс иногда применяется для прикладных программ на Perl, но для них рекомендуется использовать суффикс .plx.) Для примера напишем небольшую программную библиотеку для работы с данными о музыкальных дисках и сохраним ее в файле 'lib/music_lib.pl':
# библиотека подпрограмм 'music_lib.pl' sub albums_by_artist { # найти альбомы указанного артиста my ($artist) = @_; # аргумент поиска: артист my @albums = (); # возвращаемый список seek DATA, 0, 0; # ищем с начала файла while (<DATA>) { # просматриваем альбомы в файле push @albums, $1 if /$artist;(.+?);/; # и выбираем } # все подходящие return @albums; # результат: список альбомов } # ... другие подпрограммы библиотеки... __DATA__ # конец библиотечного файла
Рассмотрим, как происходит обращение к библиотечным подпрограммам во время выполнения программы.
Модули
Модуль - это специальным образом оформленная библиотека подпрограмм, предназначенных для многократного использования. Модули появились в Perl, начиная с версии 5, и с тех пор подавляющее большинство универсальных Perl-программ оформляются в виде модулей. В отличие от обычных библиотек, модули имеют внешний интерфейс - ограниченный набор переменных и функций, предназначенных для использования другими программами. Доступ к внешнему интерфейсу модуля в вызывающей программе организуется с помощью механизма импортирования имен, реализованному в стандартном модуле Exporter. Приведем пример оформления типичного модуля (сохраненного в файле Module.pm):
package Module; # пространство имен модуля use 5.006001; # использовать версию Perl не ниже указанной use strict; # включить дополнительные проверки use warnings; # и расширенную диагностику our $VERSION = '1.00'; # версия модуля
require Exporter; # загрузить стандартный модуль Exporter our @ISA = qw(Exporter); # неизвестные имена искать в нем our @EXPORT = qw( subroutine ); # имена, экспортируемые по умолчанию our @EXPORT_OK = qw( $variable ); # имена, экспортируемые по запросу
$Module::variable = 'переменная 1'; # скаляр из модуля Module sub subroutine { # подпрограмма из модуля Module return "'подпрограмма 1 $Module::variable'"; } 1; __END__
Автоматически сгенерировать скелет нового модуля (а также сопутствующие файлы, необходимые для подготовки модуля к распространению) можно с помощью утилиты h2xs, входящей в состав дистрибутива Perl. Например, создать модуль с именем 'Module::Name' версии 1.00 можно такой командой:
h2xs -AX -n Module::Name -v 1.00
Если программа, которая обращается к этому модулю, использует только экспортированные по умолчанию имена, то используется форма команды use только с именем модуля:
use Module; # подключить модуль и # импортировать из него имена по умолчанию subroutine(); # вызвать подпрограмму &Module::subroutine()
В программе, в которой нужно явно затребовать перечисленные имена (с помощью метода import), применяется форма команды use со списком импортируемых имен:
use Module qw($variable); # затребовать импорт нужных имен print "$variable\n"; # скаляр $Module::variable
Антонимом команды use является команда no, которая неявно выполняет вызов метода unimport для отмены импортированных имен. В команде use также можно проверить, что версия подключаемого модуля соответствует требованиям. Для этого после имени модуля указывается минимальная требуемая версия:
use Module 1.00; # подключить модуль не ниже указанной версии
Помимо процедурного, модули могут иметь объектно-ориентированный интерфейс, который будет рассмотрен в следующей лекции.
Пакеты
Пакеты используются в Perl для разделения глобального пространства имен на задаваемые программистом подпространства. Отдельные пространства имен позволяют использовать в каждом из них собственный набор идентификаторов, не конфликтующих с одноименными идентификаторами в других пространствах. Пакет объявляется с помощью команды package, за которой указывается имя пакета. Имена пакетов, задаваемые программистом, принято начинать с заглавной буквы, в отличие от системных, которые записываются строчными буквами. Например:
package Package; # объявить пакет с именем Package
Подпрограммы и глобальные переменные, определенные после команды package, относятся к объявленному пакету. Действие команды package распространяется до конца текущего блока, файла, блока eval или до следующей команды package, начинающей или продолжающей указанный в ней пакет. Каждое употребление команды package означает переключение на соответствующее пространство имен, идентификаторы которого хранятся в собственной таблице имен. Специальная лексема __PACKAGE__ содержит имя текущего пакета. Поясним сказанное таким примером:
package Package; # начало пакета Package $variable = 'переменная'; # скаляр из пакета Package sub subroutine { # подпрограмма из пакета Package return "$variable"; } package Another; # начало пакета Another $variable = 'переменная'; # скаляр из пакета Another sub subroutine { # подпрограмма из пакета Another return "$variable"; } package Package; # продолжение пакета Package @array = (1..5); # массив из пакета Package
В любом пакете можно обратиться к переменной или подпрограмме из другого пакета, указав ее полное имя. Полное имя (или квалифицированное имя) каждого нединамического программного объекта в Perl состоит из имени пакета и идентификатора. Символы :: разделяют эти две части таким образом:
$Package::variable - скалярная переменная из пакета Package $Another::variable - скалярная переменная из пакета Another &Package::subroutine - подпрограмма из пакета Package Package::subroutine - префикс подпрограммы можно не писать
Если глобальные имена не описаны явно в составе какого-либо пакета, то по умолчанию они относятся к пакету main. Можно считать, что объявление этого пакета неявно присутствует в начале любой Perl-программы. Поэтому упоминавшиеся до сих пор глобальные переменные, в том числе большинство специальных, на самом деле относятся к этому пакету. Имя пакета main обычно не указывается, но при необходимости принадлежность к нему можно указать явно:
%pseudo_name = ('Marylin Monroe' => 'Norma Jean'); print $main::pseudo_name{'Marylin Monroe'};
Следующие варианты записи имени обозначают одну и ту же переменную из пакета по умолчанию:
@main::array # с явным именем пакета main @::array # с пустым именем пакета @array # без имени пакета
Имена пакетов не применяются к лексическим переменным, объявленным с помощью функций my() и our() и существующим в собственном пространстве имен. Причем область действия переменных, определенных с помощью my(), не может распространяться за пределы исходного файла, а переменные, определенные с помощью our(), видны в пределах пакета, даже если части пакета определены в разных программных файлах. Вот пример сосуществования одноименных переменных из лексической области видимости и пространства имен пакета:
$variable = 'глобальная'; # переменная из пакета main my $variable = 'лексическая'; # переменная из текущего блока print "$main::variable $variable"; # будет напечатано: 'глобальная лексическая'
В Perl допускается использование пакетов, которые имеют составные имена следующего вида: Package::Subpackage. В этом случае имен пакетов образуют иерархию, а исходные файлы должны храниться в соответствующих вложенных каталогах. Составные имена пакетов соответствуют пути, по которому компилятор будет искать файл с исходным текстом программы. Загружать командой require исходный файл можно по полному имени файла с указанием подкаталогов, например:
use lib("$path/lib"); # добавить путь к списку поиска # загрузить внешнюю программу по имени файла require 'Package/Subpackage/Program.pm';
Если в команде require указано полное имя пакета в виде "голого слова" (bareword), а не в виде строки или переменной, то имя загружаемого файла формируется по следующему правилу. Разделитель пакетов '::' в имени пакета заменяется на разделитель каталогов в используемой операционной системе, а к имени файла добавляется суффикс .pm. Суффикс .pm используется для файлов, содержащих Perl-модули, и подразумевается по умолчанию командами require и use. Тогда предыдущую команду можно переписать так:
# загрузить внешнюю программу по имени пакета require Package::Subpackage::Program; # вызвать подпрограмму из загруженного пакета print Package::Subpackage::Program::subroutine(), "\n";
Теперь рассмотрим другой способ обращения к внешним программам - подключение их на этапе компиляции, что часто дает дополнительные преимущества.
Подключение программ при компиляции
Хотя есть немало случаев, когда нужно загружать внешние программы во время выполнения программы, гораздо чаще библиотеки модулей подключаются во время компиляции. Это делается с помощью команды use. Преимущество использования use по сравнению с require заключается в том, что все возможные ошибки выявляются до выполнения программы на этапе компиляции. Кроме того, команда use выполняет импорт имен, определенных в подключаемом модуле, после чего их можно удобно употреблять без имени пакета.
use Package::Subpackage::Module; # подключить модуль
С помощью команды use также подключаются многие стандартные модули Perl. Другие примеры использования команды use встретятся по ходу этой лекции при обсуждении работы с модулями.
Команды require и use также применяются для контроля версии Perl, требуемой для компиляции и выполнения программы. Для этого параметром каждой из этих команд должно быть число, интерпретируемое как минимальный номер версии, который нужен, чтобы программа корректно выполнялась. Например:
use 5.005; # использовать версию Perl не ниже указанной require 5.008007; # использовать Perl 5.8.7 и выше
Если не выполняется требование, заданное в use, то компиляция завершится аварийно. Невыполнение требования, указанного в require, приведет к ошибке во время выполнения программы.
Репозитарий модулей CPAN
В лекции 1 уже шла речь о Comprehensive Perl Archive Network (CPAN), что можно перевести как "Всеобъемлющая сеть Perl-библиотек", зеркальные сайты которой имеются по всему миру. Среди российских зеркал CPAN можно упомянуть http://cpan.sai.msu.ru/ и ftp://ftp.chg.ru/pub/lang/perl/CPAN/. CPAN - это огромный архив, где хранятся дистрибутивы Perl для разных операционных систем, документация, программы, библиотеки и модули по самой разной тематике, распространяемые бесплатно. На сайте имеется хорошая система поиска модулей. Кроме того, все модули расклассифицированы по логическим категориям и по именам пакетов, что облегчает поиск схожих модулей. В репозитарии CPAN на первом уровне иерархии насчитывается более 600 каталогов, в каждом из которых хранятся сотни модулей. Среди основных категорий модулей можно упомянуть важнейшие:
интерфейсы операционных систем (такие как Win32);интерфейсы к системам управления базами данных;пользовательские интерфейсы;интерфейсы к другим языкам программирования;работа с файлами и файловыми системами;обработка строк и текстовой информации;интернационализация и локализация;аутентификация, безопасность и криптография;работа с сетями, WWW, HTML, HTTP, CGI, e-mail;архивирование и сжатие данных;работа с изображениями, чертежами, векторной и растровой графикой;работа с мультимедийными данными;и многое другое.
Поэтому прежде, чем написать свою программу, имеет смысл поискать на CPAN модуль, подходящий для решения возникшей задачи. Во многих случаях "изобретать велосипед" не придется: найденный модуль либо можно сразу использовать, либо взять за основу своей разработки. Поскольку большинство современных Perl-модулей - объектно-ориентированные, они предполагают довольно легкую адаптацию путем определения подклассов, расширяющих возможности описанных в модуле классов. Даже если нужный модуль не найден, можно почерпнуть решения, реализованные в сходных модулях, изучив тексты программ, поскольку все модули распространяются в исходных кодах. CPAN является выдающимся собранием культурных ценностей, коллективной сокровищницей программистской мысли, реализованной в виде готовых к эксплуатации модулей.
Специальные блоки
В каждой Perl-программе могут присутствовать исполняемые блоки, фактически являющиеся специальными подпрограммами, которые обрабатываются особым образом. Они имеют зарезервированные имена и записываются заглавными буквами: BEGIN, END, CHECK, INIT. Каждый из таких блоков может присутствовать несколько раз в любом месте программы. Эти блоки вызываются автоматически в определенное время в начале и в конце выполнения Perl-программы.
Блок BEGIN выполняется как можно раньше: во время компиляции сразу после того, как он полностью определен. Если определено несколько блоков BEGIN, то они выполняются в порядке их описания. Они используются командой use для загрузки внешних файлов во время компиляции программы.
Блок END выполняется как можно позже: после того как perl закончил выполнение программы, перед завершением работы интерпретатора. Он выполняется даже в случае аварийного завершения программы. Несколько блоков END выполняются в порядке, обратном их размещению в файле. Блоки END не выполняются, если при запуске Рerl заказана только компиляция (опцией -c), или если компиляция завершается аварийно. При работе END доступна специальная переменная $?, содержащая код завершения программы, который можно изменить.
Блок CHECK выполняется после того, как Рerl закончил компиляцию программы. Можно определить несколько блоков CHECK, тогда они будут выполняться в порядке, обратном их описанию. Блоки CHECK не выполняются, если Рerl запущен с опцией -c только для компиляции программы.
Блок INIT выполняется перед тем, как интерпретатор начнет выполнение программы, поэтому могут использоваться для инициализации модулей. Несколько блоков INIT выполняются в порядке их описания. Поясним последовательность выполнения специальных блоков на коротком примере:
print " 8. выполнение 1\n"; END { print "14. (1-й END)\n" } INIT { print " 5. (1-й INIT)\n" } CHECK { print " 4. (1-й CHECK)\n" } print " 9. выполнение 2\n"; BEGIN { print " 1. (1-й BEGIN)\n" } END { print "13. (2-й END)\n" } CHECK { print " 3. (2-й CHECK)\n" } INIT { print " 6. (2-й INIT)\n" } print "10. выполнение 3\n"; END { print "12. (3-й END)\n" } BEGIN { print " 2. (2-й BEGIN)\n" } INIT { print " 7. (3-й INIT)\n" } print "11. выполнение 4\n";
Сравните результаты запуска этого примера при обычном выполнении и только при компиляции:
Обычное выполнение: Только компиляция (perl -c) 1. (1-й BEGIN) 1. (1-й BEGIN) 2. (2-й BEGIN) 2. (2-й BEGIN) 3. (2-й CHECK) 3. (2-й CHECK) 4. (1-й CHECK) 4. (1-й CHECK) 5. (1-й INIT) 6. (2-й INIT) 7. (3-й INIT) 8. выполнение 1 9. выполнение 2 10. выполнение 3 11. выполнение 4 12. (3-й END) 13. (2-й END) 14. (1-й END)
Использование специальных блоков позволяет программисту гибко организовать контроль над программой на всех этапах ее жизненного цикла - от компиляции до завершения.
Стандартные библиотеки модулей
В поставке Perl имеется большое число стандартных библиотек модулей. Их описание можно прочитать в документации, обратившись к известной утилите:
perldoc perlmodlib
Стандартные модули находятся в библиотечных каталогах дистрибутива Perl и подключаются с помощью команды use. Встроенные системные функции находятся в специальном пакете CORE, поэтому, если в области видимости находится одноименная функция, то чтобы обратиться встроенной функции, нужно вызвать ее по полному имени, например:
use Cwd 'chdir'; # подключить стандартный модуль chdir '/temp'; # вызвать Cwd::chdir() CORE::chdir '/temp'; # вызвать встроенную функцию chdir
Стандартные модули подразделяются на несколько групп. Одна из них - это модули прагм (pragmatic modules), которые контролируют поведение компилятора и исполняющей системы Perl. В качестве примера таких модулей можно привести constant, lib, locale, strict, utf8, warnings и другие. Другая группа - стандартные модули (standard modules), поставляемые вместе с системой программирования Perl. Приведем примеры стандартных модулей: AutoLoader, CPAN, Cwd, Encode, Exporter, File::Find, Math::BigInt, Time::localtime, Win32 и многие другие.
Следующая группа - это модули расширения (extension modules), написанные на языке C и предназначенные для взаимодействия с операционной системой. Примерами модулей расширения могут служить Socket, Fcntl и POSIX.
Установка модулей
Когда требуемый модуль отсутствует в вашей системе, его можно установить из репозитария CPAN. Для этого нужно обратиться к одному из зеркал этого архивного сайта и загрузить с него последнюю версию модуля, которые по традиции распространяются в виде архивов в формате tar.gz.
Программисты, работающие с одной из операционных систем семейства Unix, могут устанавливать модули несколькими способами. Самый простой из них - воспользоваться утилитой cpan из дистрибутива Perl. Тогда для установки модуля прямо с ближайшего из зеркал сайта CPAN нужно выполнить, например, такую команду:
cpan -i Module::Name
При первом запуске этой утилиты задаются вопросы, касающиеся настроек программы. Затем она загружает и устанавливает указанный модуль. Другой способ - установить модуль вручную, особенно если он уже загружен с сайта CPAN и в данный момент нет доступа в Internet. Для этого нужно распаковать архив с модулем во временный каталог, например такой командой:
tar -zxvf Module-Name-1.00.tar.gz
Затем нужно выполнить в этом каталоге несколько команд, которые подготовят, протестируют и установят требуемый модуль. Эти команды всегда описаны в файле readme, поставляемом с модулем. В большинстве случаев нужно выполнить такие команды:
perl Makefile.PL make make test make install
Если все команды установки отработали без ошибок, модуль будет установлен и зарегистрирован в вашей системе.
То же самое можно выполнить и в среде Microsoft Windows. Для распаковки архивов нужно воспользоваться Windows-версиями архиваторов tar и gzip или WinRAR. Установка модулей, полностью написанных на Perl, выполняется так же, как в Unix-системах, только утилита компоновки называется не make, а nmake (ее можно загрузить с сайта Microsoft). Но для некоторых модулей в процессе установки может потребоваться компиляция исходных программ на языке C, а для этого нужно, чтобы в системе был установлен компилятор C (что в Unix-системах является нормой). Можно воспользоваться бесплатно распространяемыми средствами разработки Visual C++ Toolkit и Platform SDK, загрузив их с сайта компании Microsoft (http://msdn.microsoft.com/visualc/vctoolkit2003/). Другой вариант - установить свободно распространяемый компилятор Free MinGW GCC for Windows (http://www.mingw.org/download.shtml). После установки C-компилятора также можно пользоваться утилитой cpan.
Еще проще под ОС Windows устанавливать готовые бинарные дистрибутивы модулей от компании ActiveState, ориентированные на систему программирования ActivePerl. В ее комплект входит менеджер пакетов ppm, который выполняет все необходимые действия по загрузке модуля с сервера и его установке. Установка модуля из Internet запускается примерно такой командой ('::' в имени модуля заменяются на '-'):
ppm install Module-Name
Или можно загрузить архив с модулем вручную, после чего запустить установку из локального каталога без подключения к Internet. Адрес сервера для загрузки готовых Perl-модулей в формате ppd можно узнать на сайте http://aspn.activestate.com/ASPN/Perl/Modules/.
Библиотеки, пакеты и модули, изученные в этой лекции, позволяют программисту рационально организовать собственные программы, когда они начинают разрастаться в объеме. А изученные приемы работы со стандартными библиотеками и дополнительными модулями помогут рационально воспользоваться компонентами, которые создали, отладили и протестировали другие разработчики.
ppm install Module-Name
Или можно загрузить архив с модулем вручную, после чего запустить установку из локального каталога без подключения к Internet. Адрес сервера для загрузки готовых Perl-модулей в формате ppd можно узнать на сайте http://aspn.activestate.com/ASPN/Perl/Modules/.
Библиотеки, пакеты и модули, изученные в этой лекции, позволяют программисту рационально организовать собственные программы, когда они начинают разрастаться в объеме. А изученные приемы работы со стандартными библиотеками и дополнительными модулями помогут рационально воспользоваться компонентами, которые создали, отладили и протестировали другие разработчики.
| © 2003-2007 INTUIT.ru. Все права защищены. |
Загрузка программ при выполнении
Чтобы воспользоваться подпрограммой из библиотечного файла, нужно в вызывающей программе загрузить библиотеку командой do 'file.pl'. Команда do загружает любую Perl-программу из внешнего файла во время выполнения программы. Причем в библиотеке в свою очередь могут загружаться программные файлы по команде do. Кроме этого, do регистрирует загруженные программы в специальном хэше %INC. Если do не может найти или прочитать файл, она возвращает неопределенное значение undef и присваивает специальной переменной $! признак ошибки. Если do прочитала файл, но не может его скомпилировать, она возвращает undef и помещает сообщение об ошибке в специальную переменную $@. Если файл успешно скомпилирован, do возвращает значение последнего вычисленного выражения.
После того как внешний файл был успешно загружен, можно вызывать подпрограммы из загруженного библиотечного файла, как если бы они были описаны в текущей программе. В нашем случае это будет выглядеть так:
do 'lib/music_lib.pl'; # загрузить библиотеку # вызвать библиотечную подпрограмму my @albums = albums_by_artist('Elton John'); print "$_\n" foreach(@albums); # напечатать найденный список
Обратите внимание, что в нашем примере явно указан путь к подкаталогу с библиотекой, что предполагает запуск программы из определенного каталога. Гораздо лучше сделать так, чтобы расположение библиотек не зависело от местонахождения вызывающей программы. Для этого в Perl имеется специальный массив @INC, в котором хранится список каталогов для поиска загружаемых исходных файлов. В этот массив по умолчанию включаются каталоги, где находятся системные библиотеки Perl. Чтобы на время выполнения программы добавить в этот список свои каталоги с библиотеками, можно воспользоваться опцией -I, указываемой в командной строке при запуске компилятора perl. Например, запустим на выполнение программу и укажем дополнительно искать файлы в каталоге /Shock/Mike/lib и его подкаталогах:
perl -I/Shock/Mike/lib program.pl
Тогда в программе можно указывать путь к библиотекам относительно одного из перечисленных в массиве @INC каталогов:
do 'music_lib.pl'; # искать библиотеку в списке @INC
Другой способ добавить в массив @ INC каталог для поиска загружаемых файлов - использовать директиву (прагму) use lib. Для этого в программе перед командой загрузки библиотеки нужно указать ее расположение, например так:
use lib('/Shock/Mike/lib'); # добавить путь к списку @INC
Команда загрузки внешних программ do считается устаревшей и употребляется все реже и реже. Вместо нее применяется команда require, имеющая целый ряд преимуществ. Эта команда вызывает ошибку, если загружаемая программа не найдена в массиве @INC, компилируется с ошибками или не возвращает истинного значения. Поэтому в конце загружаемого файла должно быть любое выражение, возвращающее истинное значение. По устоявшейся традиции выражение '1;' помещается в последней исполняемой строке файла. Поэтому, чтобы библиотека в нашем примере без ошибок загружалась командой require, в конце библиотечного файла добавим требуемую строку:
# ... другие подпрограммы библиотеки... 1; # вернуть истинное значение для require __DATA__ # конец библиотечного файла
Команда require также регистрирует загруженные программы в специальном хэше %INC, поэтому не загружает их повторно. Однако использование библиотек и прочих внешних файлов в таком виде рано или поздно приводит к проблеме совпадения имен глобальных переменных и подпрограмм. Разные библиотеки, созданные разными программистами, неизбежно будут содержать одинаковые идентификаторы. Конфликт между совпадающими именами в разных программных файлах можно разрешить с помощью механизма пакетов.
Деструктор
В классе может быть описан специальный метод, автоматически вызываемый исполняющей системой при уничтожении каждого объекта. Такой метод называется деструктор (destructor), и он должен иметь зарезервированное имя - DESTROY. Деструктор вызывается при освобождении памяти, занимаемой объектом: это происходит при выходе из блока, где был создан объект, при удалении последней ссылки на объект функцией undef($object) или при окончании программы. Приведем пример шуточного деструктора для класса Person, который при удалении объекта направляет прощание в поток STDERR, называя имя объекта методом say_name():
sub DESTROY { warn('Прощайте, я ухожу... ' . shift->say_name); }
Деструктор может использоваться, если при окончании работы с объектом нужно выполнить какие-то завершающие действия: например, удалить динамически созданные структуры или сохранить данные объекта в файле. Конструктор в этом случае может считывать сохраненные значения из файла, чтобы присвоить объектам начальные значения.
Методы и атрибуты класса
В классе могут быть определены методы, не предназначенные для работы с конкретными объектами. Такие методы называются методами класса или статическими методами. Для обращения к ним, так же как для обращения к конструктору, используется имя класса, а не ссылка на объект. Часто эти методы обслуживают данные, общие для всех объектов класса (то есть объявленные глобально на уровне класса). Подобные данные называются атрибутами класса. В качестве примера опишем класс Magic::Ring, где метод класса count() будет использоваться для доступа к значению атрибута класса $Magic::Ring::count, в котором будет храниться количество созданных волшебных колец.
package Magic::Ring; # класс "Магическое Кольцо" sub new { # конструктор my ($class, $owner) = @_; # имя класса и значение атрибута $Magic::Ring::count++; # сосчитать новое Кольцо bless({owner => $owner}, $class); # "благословить" хэш }
sub owner { # метод чтения и записи атрибута owner my $self = shift; # извлечь ссылку на объект $self->{owner} = shift if @_; # изменить значение атрибута return $self->{owner}; # вернуть значение атрибута }
$Magic::Ring::count = 0; # атрибут класса: число Колец sub count { # метод класса return $Magic::Ring::count; } 1; # конец описания класса Magic::Ring
В программе, использующей класс Magic::Ring, создается набор объектов. При каждом обращении к конструктору увеличивается счетчик созданных магических колец $Magic::Ring::count.
package main; use Magic::Ring; # использовать класс "Магическое Кольцо"
my @rings = (); for (1..3) { # "Три кольца - премудрым эльфам..." push @rings, new Magic::Ring('эльф'); } for (1..7) { # "Семь колец - пещерным гномам..." push @rings, new Magic::Ring('гном'); } for (1..9) { # "Девять - людям Средиземья..." push @rings, new Magic::Ring('человек'); } # "А Одно - всесильное - Властелину Мордора..." push @rings, new Magic::Ring('Саурон'); # Сколько всего было сделано колец? print Magic::Ring->count, "\n"; # будет выведено: 20
Модуль Class::Struct
В стандартную библиотеку модулей Perl входит модуль Class::Struct, который облегчает жизнь программистам по описанию классов, предоставляя для объявления класса функцию struct(). Эта функция генерирует описание класса в указанном пакете, включая методы для доступа к атрибутам класса. Причем помимо имени атрибута она позволяет задавать его тип с помощью разыменовывающего префикса: скаляр ($), массив (@), хэш (%), ссылка на подпрограмму (&) или объект. Насколько просто и удобно пользоваться функцией struct, можно судить по такому примеру:
use Class::Struct; # подключаем стандартный модуль
# описываем класс Performer ("Исполнитель") struct Performer => { # атрибуты класса: name => '$', # "имя" - скаляр country => '$', # "страна" - скаляр artists => '%', # "артисты" - хэш }; my $performer = new Performer; # создаем исполнителя $performer->name('Pink Floyd'); # задаем значения атрибутов $performer->country('Great Britain'); # заполняем атрибут-хэш: $performer->artists('David Gilmour', 'гитары, вокал'); $performer->artists('Roger Waters', 'бас-гитара, вокал'); $performer->artists('Nick Mason', 'ударные'); $performer->artists('Richard Wright', 'клавишные');
# описываем класс Album ("Альбом") struct Album => { # атрибуты класса: title => '$', # "название" - скаляр year => '$', # "год выхода" - скаляр tracks => '@', # "композиции" - массив performer => 'Performer', # "исполнитель" - объект }; my $album = Album->new; # создаем альбом $album->title('Dark Side of the Moon'); $album->year(1973); # заполняем атрибут-массив: $album->tracks(0, 'Breathe'); $album->tracks(1, 'Time'); # и так далее... $album->performer($performer); # задаем атрибут-объект
Чтобы добавить к полученному описанию класса дополнительный метод, достаточно описать его в соответствующем пакете. Вот пример добавления метода Album::print и его использования в главной программе:
package Album; # переключаемся на нужный пакет sub Album::print { # и описываем дополнительный метод my $self = shift; printf("%s '%s' (%d)\n", $self->performer->name, $self->title, $self->year); foreach my $artist (keys%{$self->performer->artists}) { printf("\t%s - %s\n", $artist, $self->performer->artists($artist)); } } package main; # переключаемся на основную программу $album->print; # и вызываем метод объекта
Наследование
Наследование - это мощный механизм конструирования нового класса, позволяющий уточнить существующий класс, изменить его поведение родительского класса или добавить к нему новые свойства. В Perl это делается легко и просто: нужно упомянуть имя родительского класса в специальном массиве @ISA текущего класса. Исполняющая система, не найдя вызванного метода в текущем модуле, продолжает его поиск в пакетах, перечисленных в массиве @ISA. Приведем пример описания класса Wizard, производного от класса Person:
package Wizard; # класс "Маг" our @ISA = qw(Person); # является подклассом Person use Person; # и использует пакет Person # ... описание методов класса Wizard... 1; # вернуть истину для use
Смысл наследования - в создании подклассов, изменяющих поведение базового класса. Для этого в дочерних классах описываются новые методы или переопределяются существующие. В качестве примера опишем для класса Wizard новый метод для работы со свойством 'magic' ("тип магии" - белая или черная):
sub magic { # магия - вот что отличает волшебника my $self = shift; # извлечь ссылку на объект $self->{magic} = shift if @_; # изменить значение return $self->{magic}; # вернуть значение }
Кроме того, переопределим конструктор объектов класса new() так, чтобы он принимал два аргумента для инициализации свойств 'name' и 'magic'. Для создания объекта воспользуемся конструктором родительского класса, затем зададим начальные значения свойств, и, наконец, "дадим благословение" объекту ссылки быть магом:
sub new { # конструктор объектов my $class = $_[0]; # имя класса в 1-м аргументе my $self = new Person; # маг - это личность $self->{name} = $_[1]; # задать имя из 2-го аргумента $self->{magic} = $_[2]; # и тип магии из 3-го bless($self, $class); # "благословить" мага return $self; # вернуть ссылку на объект }
Вызывающая программа, использующая производный класс, будет выглядеть следующим образом:
use Wizard; # подключить производный класс
# создать нового черного мага - Сарумана my $wizard = new Wizard('Саруман', 'black'); my $name = say_name $wizard; # "назови себя, маг" print $name, ' ', $wizard->magic(); # 'Саруман black' print ref($wizard); # тип объекта ссылки - 'Wizard'
Естественно, что у объекта класса Wizard можно вызывать не только методы собственного класса, но и любые методы, унаследованные из родительского класса Person.
Объектно-ориентированная терминология
Технология объектно-ориентированного программирования представляет из себя современный подход к созданию информационных систем, основанный на применении программных объектов, моделирующих состояние и поведение реальных сущностей. Не углубляясь в теорию, можно дать такие неформальные определения основным терминам, применяемым в объектно-ориентированном программировании:
Класс (class) - это именованное описание для однотипных сущностей их неотъемлимых характеристик (атрибутов) и их поведения (методов). Примеры классов: "Личность", "Хоббит", "Маг".Объект (object) - это сущность, относящаяся к определенному классу, хранящая набор конкретных значений данных и предоставляющая для их обработки методы, предусмотренные классом. Примеры объектов: "хоббит по имени Фродо Бэггинс", "маг по имени Гэндальф". Синоним термина "объект": экземпляр (instance) класса.Атрибут (attribute) - описание характеристики объекта, значение которой будет храниться в объекте. Примеры атрибутов: "имя", "рост". Набор конкретных значений атрибутов является текущим состоянием (state) объекта. Пример значения атрибута: "имя - Гэндальф". Синонимы термина "атрибут": свойство (property), переменная объекта (object variable), переменная экземпляра (instance variable), данные-элементы (member data).Метод (method) - это действие объекта, изменяющее его состояние или реализующее другое его поведение. Пример методов: "назвать свое имя", "стать невидимым". Синонимы термина "метод": операция (operation), функция-элемент (member function).Инкапсуляция (encapsulation) - это (1) объединение в объекте набора данных и методов работы с ними; (2) принцип ограничения доступа к данным объекта, когда работать с ними можно только через его методы (скрытие данных).Наследование (inheritance) - это создание нового класса на основе существующего с целью добавить к нему новые атрибуты или изменить его поведение. Пример наследования: на основании класса "Личность" создаются его подклассы "Хоббит", "Маг", "Эльф" и "Человек", каждый из которых обладает свойствами и поведением "Личности", но добавляет собственные свойства и меняет поведение.Полиморфизм (polymorphism) - это различное поведение объектов, принадлежащих к различным классам, при обращении к одинаково названному методу. Пример полиморфизма: в ответ на призыв "К оружию!" гном схватит боевой топор, эльф приготовит лук и стрелы, а хоббит спрячется за дерево.
Но программистам, пишущим на Perl, можно не запоминать эти труднопроизносимые термины. Объектный подход к программированию реализуется в Perl изящно и легко - при помощи уже известных нам понятий и конструкций.
Объектное программирование в Perl
В нынешней версии Perl нет специальных синтаксических конструкций для выражения идей объектно-ориентированной технологии. Поэтому Perl нельзя назвать объектно-ориентированным языком, но он поддерживает объектный подход при разработке программ. Для создания программ с использованием объектов применяются имеющиеся в языке средства, которые сводятся к нескольким простым соглашениям:
Класс - это пакет, в котором описаны методы, реализующие поведение создаваемых объектов.Объект - это переменная (или замыкание), на которую указывает ссылка, связанная с именем пакета.Метод - это подпрограмма из пакета, доступ к которой происходит по ссылке на объект, которую он получает в качестве первого аргумента.Атрибуты объекта хранятся в динамически создаваемых переменных, чаще всего - в анонимных хэшах. Наследование - это поиск методов, не найденных в текущем пакете, в пакетах, перечисленных в специальном массиве @ISA.
Теперь рассмотрим примеры описания классов средствами языка Perl и приемы работы с объектами.
Описание классов
Класс описывается в виде одноименного пакета, в котором размещаются определения методов, реализующих поведение объектов этого класса. Описания одного или нескольких классов сохраняются в виде модуля. Как минимум один из методов класса отвечает за создание объектов класса. Такой метод называется конструктором (constructor) и обычно носит имя new (или его имя совпадает с именем класса). Для хранения атрибутов объекта очень часто применяется анонимный хэш, ключи которого задают имена атрибутов. Первым аргументом конструктор получает имя класса, которое он использует для преобразования ссылки на анонимный хэш в ссылку на объект указанного класса. Это "магическое" превращение выполняется с помощью встроенной функции bless ("благословить"), благодаря которой каждый созданный объект помечается принадлежащим к определенному классу. После этого при обращении к методам объекта они отыскиваются в пакете с таким же именем. Вот как происходит превращение объекта "ссылка" в объект определенного класса:
my $class = 'Hobbit'; # имя класса в виде строки my $object = { }; # ссылка на анонимный хэш, # где будут храниться данные объекта, bless($object, $class); # "благословляется" указывать # на объект класса $class
Для примера опишем класс "Личность" (Person), сохранив его в файле Person.pm. Начало описания класса будет выглядеть так:
package Person; # класс - это пакет
sub new { # метод-конструктор объектов my $class = shift; # 1-й параметр ссылка на имя класса my $self = {}; # контейнер для атрибутов объекта $self->{name} = ''; # начальные значения атрибутов bless($self, $class); # "благословить" объект ссылки return $self; # вернуть ссылку на созданный объект }
Затем в описании класса обычно определяются методы для доступа к атрибутам объекта. Для примера определим метод для доступа (accessor) к атрибуту 'name' ("имя") и метод для изменения его значения (modifier).
sub say_name { # метод доступа (accessor) к атрибуту name my ($self) = @_; # получить ссылку на объект return $self->{name}; # вернуть значение атрибута }
sub give_name { # метод изменения (modifier) атрибута name my $self = $_[0]; # 1- й аргумент: ссылка на объект $self->{name} = $_[1]; # 2-й аргумент: новое значение } 1; # истинное значение требуется для use __END__ # конец описания класса
В классе описываются методы для работы с атрибутами объектов класса, причем часто один метод используется для чтения и для изменения значения атрибута. В примере опишем метод для чтения и записи (mutator) свойства 'height' ("рост"):
sub height { # метод чтения и записи атрибута height my $self = shift; # извлечь ссылку на объект $self->{height} = shift # присвоить новое значение, if @_; # если передан аргумент return $self->{height}; # вернуть значение атрибута }
Обратите внимание, что описание класса значительно проще, чем описание традиционного модуля. Для работы с классом не требуется никаких списков экспортирования имен. Вместо этого описываются методы, которые можно рассматривать как сервисы, предоставляемые классом для взаимодействия с каждым из конкретных экземпляров класса. Набор методов для управления поведением объекта называют его интерфейсом. Для работы с объектами класса достаточно знать этот интерфейс, не вдаваясь в детали реализации поведения объектов.
Приемы работы с объектами
В заключение рассмотрим несколько распространенных приемов для работы с классами и объектами.
Функции bless() не обязательно передавать имя класса: если второго аргумента нет, она помечает объект ссылки именем текущего пакета. Поскольку bless() возвращает значение своего первого аргумента, а подпрограмма возвращает последнее вычисленное значение, то минимальный конструктор может выглядеть так:
sub new { # конструктор экземпляров класса my $self = {}; # контейнер для атрибутов объекта bless($self); # "благословить" объект ссылки } # и вернуть ссылку (1-й аргумент bless)
При создании объекта удобно сразу задавать начальные значения его атрибутов, передавая аргументы конструктору. Если для инициализации атрибутов использовать хэш, то атрибуты можно задавать в любом порядке, а в конструкторе можно определить значения по умолчанию для незаданных атрибутов. Например, так:
my $language = Programming::Language->new( NAME => 'Perl', # имя VERSION => '5.8.7', # версия AUTHOR = 'Larry Wall' # автор );
Весьма полезно иметь в классе метод, который преобразовывает значения атрибутов объекта в строку. Такой метод обычно называется as_string() или to_string() и может применяться для отладочной печати состояния объекта. А если его определить в классе-"прародителе", то его можно будет применять к объектам всех унаследованных классов. Если использовать анонимный хэш для хранения значений атрибутов, то такой метод может выглядеть так:
sub to_string { # преобразование значений атрибутов в строку my $self = shift; my $string = '{ '; foreach (keys %{$self}) { $string .= "$_: '$self->{$_}' "; } $string .= '}'; return $string; }
Благодаря тому, что Perl - это динамический язык, в нем легко создать класс, в котором свойства объектов добавляются во время выполнения программы. Для этого в классе описываются универсальные методы для работы со свойствами объекта, а затем в ходе выполнения задаются нужные свойства. Например, так:
package Human; # класс "Человек" our @ISA = qw(Person); # это подкласс класса Person use Person;
sub set { # универсальный метод доступа к атрибутам объекта my ($self, $name, $new_value) = @_; my $old_value = $self->{$name}; $self->{$name} = $new_value; return $old_value; }
sub get { # универсальный метод изменения атрибутов объекта my ($self, $name) = @_; return $self->{$name}; } 1;
package main; # главная программа use Human; # подключить класс my $hero = Human->new; # создать героя-человека $hero->set ('имя', 'Арагорн'); # дать ему имя $hero->set ('оружие', 'меч'); # и вооружить
В этой лекции мы научились работать с объектами. Объектный подход реализован в Perl весьма своеобразно, но понятно и эффективно. Использование этой технологии дает программисту возможность создавать приложения, соответствующие современным требованиям. А сочетание объектного программирования с динамической природой языка позволяет реализовывать оригинальные и эффективные решения.
sub set { # универсальный метод доступа к атрибутам объекта my ($self, $name, $new_value) = @_; my $old_value = $self->{$name}; $self->{$name} = $new_value; return $old_value; }
sub get { # универсальный метод изменения атрибутов объекта my ($self, $name) = @_; return $self->{$name}; } 1;
package main; # главная программа use Human; # подключить класс my $hero = Human->new; # создать героя-человека $hero->set ('имя', 'Арагорн'); # дать ему имя $hero->set ('оружие', 'меч'); # и вооружить
В этой лекции мы научились работать с объектами. Объектный подход реализован в Perl весьма своеобразно, но понятно и эффективно. Использование этой технологии дает программисту возможность создавать приложения, соответствующие современным требованиям. А сочетание объектного программирования с динамической природой языка позволяет реализовывать оригинальные и эффективные решения.
| © 2003-2007 INTUIT.ru. Все права защищены. |
Работа с объектами
В программе, в которой применяются объекты описанного класса, мы увидим вполне знакомую нотацию, когда подпрограммы вызываются при помощи ссылочных переменных и операции ->. В объектной терминологии это называется обращением к методам объектов (или отправка сообщения объекту). Приведем пример создания двух объектов одного класса, каждый из которых обладает собственными значениями свойств:
# способ обращения к методам через ссылки на объекты use Person; # будем использовать этот класс # создать объект класса, my $hobbit = Person->new(); # вызвав его конструктор # задать значение свойства, обратившись к методу объекта $hobbit->give_name('Фродо Бэггинс'); # создать другой объект my $dwarf = Person->new; # () не обязательны $dwarf->give_name('Гимли'); # задать значение свойства # запросить значения свойств, обратившись к методам print $hobbit->say_name(), ' ', $dwarf->say_name, "\n";
Взаимодействие с объектом строится на обращении к его методам. Обращение к методу происходит при помощи ссылки на экземпляр конкретного объекта, и при этом первым аргументом в метод автоматически передается ссылка на этот объект. Например:
$hobbit->give_name('Бильбо Бэггинс'); # соответствует вызову: Person::give_name($hobbit, 'Бильбо Бэггинс');
Внутри метода ссылка на экземпляр объекта используется для доступа к данным этого экземпляра и обращения к другим методам. Для обращения к конструктору используется имя класса, так как во время работы конструктора уже существует класс, а экземпляр объекта только должен быть создан конструктором.
Если к ссылке на объект класса Person применить функцию ref(), то она вернет значение не 'HASH', как можно было бы предположить, а 'Person'! Это результат "благословения" объекта ссылки функцией bless().
print "Класс объекта: '", ref($hobbit), "'\n"; # 'Person'
Кроме нотации с оператором "стрелка" ->, традиционно используемой при работе со ссылками, для доступа к методам применяются синтаксические конструкции с использованием косвенных объектов. При использовании этого стиля имя метода стоит перед именем класса или ссылкой на объект, после которой идет список аргументов, иногда заключаемый в круглые скобки. Использование косвенных объектов может сделать текст программы более наглядным и понятным. Приведем пример обращения к объектам в новом стиле:
# способ обращения к методам через косвенные объекты use Person; # используем класс Person my $magician = new Person; # "этот маг - новая личность" give_name $magician 'Гэндальф'; # "назовем мага 'Гэндальф'" my $name = say_name $magician; # "назови себя, маг" print $name, "\n";
В качестве иллюстрации к сказанному на рис. 14.1 изображены языковые конструкции, применяемые при работе с объектами, и их взаимосвязи.
Рис. 14.1. Конструкции объектного программирования в Perl
Способы хранения атрибутов
Анонимные хэши - это самый распространенный, но не единственный способ хранить значения атрибутов объекта. Для этого может применяться массив или даже скалярная переменная, лишь бы при создании объекта в конструкторе это хранилище значений было связано с именем класса функцией bless(). Недостатком этого подхода можно считать то, что ограничение доступа к свойствам достигается лишь на уровне соглашения пользоваться только методами объекта. И поскольку существует возможность изменить значение атрибута напрямую, это может нарушить корректную работу программы. Ведь в методе изменение состояния объекта сопровождается необходимыми проверками, чего не происходит при непосредственном изменении атрибута. Тем более, что в некоторых случаях атрибуты вообще должны быть доступны только для чтения (read-only attribute). Например, при использовании хэша для хранения атрибутов вполне возможно такое некорректное присваивание:
$hobbit->{magic} = 'пёстрая'; # добавлен ошибочный атрибут
Для того чтобы надежно обеспечить ограничение доступа к данным, которые хранятся в объекте, применяются замыкания. Чтобы показать, как можно организовать полностью закрытые атрибуты (private attributes) с помощью замыканий, напишем класс Private::Person. В новой версии класса значения атрибутов также хранятся в анонимном хэше, но при создании объекта возвращается ссылка не на него, а на анонимную подпрограмму доступа к данным. Этой функции будет передаваться имя атрибута (и, возможно, новое значение), а она будет возвращать значение атрибута, используя имя атрибута как ключ поиска в анонимном массиве. Это выглядит так:
package Private::Person; # класс "Личность"
sub new { # прототипом может быть my $invocant = shift; # класс или объект my $class = ref($invocant) || $invocant; my $self = { # значения атрибутов: NAME => '', # имя и HEIGHT => 0.0 # рост }; my $closure = sub { # функция доступа к данным my $field = shift; # по имени атрибута $self->{$field} = shift if @_; # изменим и return $self->{$field}; # вернем значение }; # объектом будет bless($closure, $class); # ссылка на функцию }
# метод доступа к атрибуту name sub name { my $self = shift; # ссылка на объект-функцию &{$self}("NAME", @_); # доступ к скрытому значению }
# метод доступа к атрибуту height sub height { # то же, что выше, но несколько короче: &{ $_[0] }("HEIGHT", @_[1 .. $#_ ] ) } 1;
Методы доступа к свойствам объектов получают первым аргументом ссылку на функцию доступа к значениям атрибутов и вызывают ее, передавая ей имя поля и остальные свои аргументы. Приведем пример создания объектов нового класса и обращения к их методам. В вызывающей программе все выглядит так, как будто данные по-прежнему хранятся в анонимном массиве:
package main; # вызывающая программа use Private::Person; # использовать этот класс
my $elf = Private::Person->new; # создать объект и $elf->name("Леголас"); # задать значения $elf->height(189); # его атрибутам # получить доступ к значениям атрибутов объекта print $elf->name, ' ', $elf->height, ' '; print ref($elf), "\n"; # тип референта: 'Private::Person'
Из примера видно, что имя класса может быть составным, отражая иерархию классов. Поскольку классы - это пакеты, хранящиеся в файле-модуле, то все, что говорилось в предыдущей лекции об именовании модулей, относится и к классам.
Обратите также внимание на то, что конструктор класса Private::Person определен так, что он может вызываться с использованием либо имени класса, либо ссылки на существующий объект. Это проверяется в следующей строке:
my $class = ref($invocant) || $invocant;
Если первым аргументом передана ссылка на объект, то определяется имя его класса, иначе считается, что передано имя класса. Поэтому в программе можно создавать однотипные объекты, обращаясь к методу new() существующего объекта. Например, так:
my $hobbit = Private::Person->new; # вызов с именем класса $hobbit->name("Bilbo Baggins");
my $frodo = $hobbit->new; # вызов со ссылкой на объект $frodo->name("Frodo Baggins");
