Подобным образом применяя автосоздание объектов, можно создать цепочку ссылок, указывающих на некоторое значение:
$$$$ref = 25; # при попытке присвоить значение # создаются 2 ссылочных переменных и 1 скалярная print "$ref $$ref $$$ref $$$$ref\n"; # выведет: REF(0x334dd8) REF(0x334e8c) SCALAR(0x334e98) 25
Все, что говорилось о ссылках на массивы, применимо к ссылкам на хэши. Ссылка на переменную типа "хэш" получается с помощью операции взятия ссылки:
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.
Аналогично созданию "массива массивов" создаются и другие разновидности ссылочных структур данных: массивы хэшей, хэши массивов и хэши хэшей. Ссылочные структуры применяются для структурированного представления взаимосвязанных данных. Для хранения в каждом элементе массива нескольких значений применяется массив хэшей (Array of Hashes, AoH). Вот пример массива, содержащий ссылки на анонимные хэши, в каждом из которых хранятся сведения о каком-либо объекте:
my $AoH = [ # этапы "Формулы-1" '2006 года {grandprix=>'Бахрейна', date=>'2006.03.12'}, {grandprix=>'Малайзии', date=>'2006.03.19'}, {grandprix=>'Австралии', date=>'2006.04.02'}, {grandprix=>'Сан-Марино', date=>'2006.04.23'}, # и так далее... ]; # напечатать хэш, на который ссылается 4-й элемент массива print "Гран-при $AoH->[3]->{grandprix} $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 приводится сводная информация о синтаксических конструкциях при работе со ссылками.
Таблица 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) для объекта ссылкиSCALARARRAYHASH
Программирующие на Perl на каждом шагу пользуются интерполяцией в строках скалярных переменных и массивов. Иногда требуется включить в строку результат вычисления какого-либо выражения. С помощью ссылок можно интерполировать любое выражение, например, вызов функции. Чтобы включить в строку значение скалярного выражения, его надо заключить в круглые скобки и взять на него ссылку операцией \, а затем разыменовать ссылочное выражение как скаляр с помощью префикса $. Вот таким образом:
$s = "localtime() ${\($x=localtime)} в скалярном контексте"; # значение выражения, например: 'Sun Mar 26 20:17:36 2006'
Чтобы включить в строку значение выражения, возвращающего список, его надо заключить в квадратные скобки, организуя ссылку на анонимный массив, а потом разыменовать ссылочное выражение как массив с помощью префикса @. Вот так:
$a = "localtime() @{[localtime()]} в списочном контексте"; # значение выражения, например: '36 17 20 26 2 106 0 84 1'
Ссылки, о которых до этого шла речь, называются жесткими ссылками. Жесткая ссылка (hard reference) - это программный объект, хранящий в памяти адрес референта и тип его значения. В Perl имеется еще одна разновидность ссылок, называемых символическими ссылками. Символическая ссылка (symbolic reference) - это строковое значение, которое хранится в скалярной переменной и представляет из себя имя глобальной переменной:
$referent1 = 'Референт'; # объект ссылки $symlink = 'referent'. 1; # символическая ссылка # доступ по символической ссылке к значению объекта print ${$symlink}; # будет выведено: 'Референт'
Символические ссылки используются значительно реже и бывают нужны, когда требуется во время выполнения программы программно создавать имена переменных в виде строк, чтобы затем получать доступ к их значениям. Использование символических ссылок может приводить к трудно обнаруживаемым ошибкам, поэтому лучше запрещать использование в программе символических ссылок с помощью прагмы use strict 'refs'.
В этой лекции изучены ссылки и средства построения с помощью ссылок динамических структур данных. Ссылки дают программисту мощные и гибкие средства доступа к программным объектам. Поэтому многие механизмы работы с данными в Perl организованы с использованием ссылок, и мы будем обращаться к ссылкам в следующих лекциях при изучении подпрограмм, библиотечных модулей и объектного программирования.
Лекция 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 объявляется несколько переменных, то все они должны заключаться в круглые скобки, как показано ниже:
studopedia.su - Студопедия (2013 - 2024) год. Все материалы представленные на сайте исключительно с целью ознакомления читателями и не преследуют коммерческих целей или нарушение авторских прав!Последнее добавление
