Текст книги "Язык программирования Perl"
Автор книги: Михаил Шохирев
сообщить о нарушении
Текущая страница: 12 (всего у книги 19 страниц)
Лекция 12. Подпрограммы
В этой лекции будут изучены подпрограммы – единицы структурирования программного кода на Perl, которые также имеют свои особенности: в формах определения и вызова, в способах передачи и обработки параметров, в вариантах возврата значений. Кроме того, в этой лекции будут рассмотрены принципы определения видимости имен переменных в Perl-программе.
Цель лекции: получить знания, необходимые для разработки на Perl структурированных модульных программ, учитывая своеобразие реализации в нем механизма подпрограмм. Научиться использовать на практике особенности работы с подпрограммами. Изучить способы задания области видимости переменных.
Для моделирования в программе внешнего мира программист создает необходимые сущности в виде переменных, подобно тому как человек обозначает существительными предметы и явления. Подпрограммы позволяют программисту создавать собственные глаголы для именования серии повторяющихся действий или для замены длинной последовательности действий одним идентификатором. Определение подпрограммы напоминает определение термина в словаре, например: «сортировать – расположить элементы набора данных в определенной последовательности путем их сравнения и перестановки». Затем все, кто знает определение термина, могут пользоваться им для указания выполнить соответствующее действие, например: «сортировать список книг по возрастанию названий».
Кроме того, подпрограммы – это средство структурирования программы. Довольно часто программный комплекс разрабатывается методом "сверху вниз", когда сначала определяются крупные части программы и порядок их выполнения без уточнения деталей реализации. Затем в ходе проектирования выясняются способы взаимодействия этих частей и фиксируются их интерфейсы (входные и выходные данные). После чего каждая крупная часть программного проекта подвергается аналогичной декомпозиции на более мелкие составляющие. В результате такого процесса "пошагового уточнения" (stepwise refinement) определяются программные компоненты в виде подпрограмм, выполняющих определенные действия. После чего пишется код подпрограмм, реализующий конкретные алгоритмы. Ну и конечно, применение подпрограмм дает возможность повторного использования (code reuse) готовых и проверенных программ, которые оформляются в виде библиотек модулей проекта.
В процедурных языках программирования традиционно выделяют две разновидности подпрограмм: функции, возвращающие сформированное в результате своей работы значение, и процедуры, не возвращающие значения и вызываемые ради побочного эффекта. В Perl существует только одна разновидность структурных единиц – подпрограммы, всегда возвращающие значение.
Подобно определению термина в словаре, при определении подпрограммы (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, располагают определения подпрограмм в начале исходного текста.
В 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).
Пока что в приведенных примерах подпрограммы использовали значение глобальных переменных, но сама идея применения подпрограмм предполагает применение заложенного в них алгоритма для обработки передаваемых им параметров. Когда подпрограмма вызывается с набором аргументов, ей передается специальный массив с предопределенным именем @_, содержащий список переданных аргументов. В теле подпрограммы переданные значения доступны в виде элементов массива @_, что видно из следующего примера:
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).
При необходимости можно объявить подпрограмму до ее использования (forward declaration), а определение ее отнести в конец программного файла. При объявлении тело подпрограммы не записывается. Например:
sub factorial; # вычислить факториал числа
В объявлении подпрограмм могут указываться прототипы, о которых речь пойдет немного позднее в этой лекции.
Подпрограммы в 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; # объявление пользовательской функции
$area_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);
}
Для разработки универсальных подпрограмм программисту нужно знать, в каком контексте была вызвана подпрограмма – какого возвращаемого значения от нее ожидают. Для этого в 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(); # вызов в скалярном контексте
В 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.
Таблица 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 переменные по умолчанию видимы в пределах всей программы (точнее, в пределах пакета, но об этом будет рассказано позднее). Практика доказала, что использование глобальных переменных противоречит принципу модульности, поскольку связывает части программы зависимостями от глобальных данных. Поэтому во всех языках программирования предусмотрены средства ограничения видимости переменных. Как уже упоминалось в лекции 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'; # изменена $var из 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, будет рассмотрена в следующей лекции.
В 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'
}
Сравнивая эту программу с предыдущим примером, можно отметить следующие отличия.
1 Переменную $var в главной программе пришлось сделать глобальной, так как local не может скрывать лексические переменные.
2 Действие local распространяется до конца подпрограммы sub1, а также на вызываемую подпрограмму sub2.
3 При выходе из подпрограммы sub1 действие local заканчивается и восстанавливается значение, которое содержала глобальная переменная $var до применения к ней local.
В современных программах в основном используют функцию my для задания переменным лексической области видимости. Оправданное применение функции local в Perl обычно сводится к следующим случаям:
1 Временное скрытие значения глобальных переменных, в том числе у специальных переменных.
2 Временная модификация отдельных элементов массивов и хэшей, даже имеющих лексическую область видимости.
3 Создание локальных файловых манипуляторов в версиях Perl до 5.6, не поддерживающих использование лексических переменных для хранения файловых манипуляторов.
С помощью ссылок, подпрограмм и лексических переменных создаются очень интересные информационные объекты, называемые замыканиями (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.
perldoc perlsub
