Пользовательская функция, чаще называемая подпрограммой, определяется в Perl-программе с помощью следующей конструкции:

Здесь имя

Блок операторов, следующий за именем подпрограммы, становится ее определением. Когда эта подпрограмма вызывается, то блок операторов, входящих в нее, выполняется, и вызывающему объекту выдается соответствующее возвращаемое значение (как будет описано ниже).

Вот, например, подпрограмма, которая выдает знаменитую фразу:

print "hello, world!\n";

Определения подпрограмм могут стоять в любом месте текста программы (при выполнении они пропускаются), но обычно их размещают в конце файла программы, чтобы основная часть программы находилась в начале. (Если вам часто приходилось писать программы на языке Паскаль, можете по привычке поставить свои подпрограммы в начало, а выполняемые операторы

Определения подпрограмм глобальны*; локальных подпрограмм не бывает. Если у вас вдруг появились два определения подпрограмм с одинаковым именем, то второе определение заменяет первое без предупреждения**.

В теле подпрограммы вы можете обращаться к переменным, используемым в других частях программы (глобальным переменным), и присваивать им значения. По умолчанию любая ссылка на переменную в теле подпрограммы относится к глобальной переменной. Об исключениях из этого правила мы расскажем в разделе "Локальные переменные в функциях" .

В следующем примере:

print "hello, $what\n";

Для вызова подпрограммы из любого выражения необходимо поставить после ее имени круглые скобки, например:

Одна подпрограмма может вызывать другую подпрограмму, которая, в свою очередь, может вызывать третью подпрограмму и т.д., пока вся наличная память не будет заполнена адресами возврата и не полностью вычисленными выражениями. (Ведь настоящего программиста вряд ли удовлетворят какие-то

Вызов подпрограммы почти всегда является частью некоторого выражения. Результат, полученный после выполнения подпрограммы, называется возвращаемым значением. Возвращаемое значение представляет собой результат выполнения оператора

Давайте, например, определим такую подпрограмму:

sub sum_of_a and_b (return $a + $b;

Последнее выражение, вычисляемое в теле этой подпрограммы (фактически единственное вычисляемое выражение),

При вычислении в списочном контексте подпрограмма может возвращать список значений. Рассмотрим такую подпрограмму и ее вызов:

sub Ii st_o f_a_and_b {

@c = list_of_a_and_b(); # @c

Последнее вычисленное выражение действительно означает последнее вычисленное выражение, а не последнее выражение, определенное в теле подпрограммы. Например, следующая подпрограмма возвращает $а, если $а

sub gimme a_or_b (if ($a > 0) (

print "choosing a ($a)\n";

print "choosing b ($b)\n";

Все это довольно тривиальные примеры. Однако будет гораздо лучше, если вместо того, чтобы полагаться на глобальные переменные, мы сможем передавать в подпрограмму значения, разные для каждого вызова. Именно к этому мы сейчас и перейдем.

Несомненно, подпрограммы, выполняющие одно определенное действие, полезны, однако перед вами откроются совершенно новые горизонты, когда вы сможете передавать в подпрограмму аргументы.

sub say_hello_to (

print "hello, $_!\n" #

say_hello_to("world"); #

say_hello_to($x); #

В последней строке возвращаемые значения явно использованы не были, однако для определения суммы

Вот пример с использованием более одного параметра:

print "$_, $_[!]!\n";

say("hello","world"); #

say ("goodbye", "cruel world"); # goodbye cruel world -

Избыточные параметры игнорируются, т.е. если вы никогда не заглядываете в

Переменная @_ является локальной для подпрограммы. Если для @_ установлено глобальное значение, то оно перед вызовом подпрограммы сохраняется, а после возврата из подпрограммы восстанавливается. Это также означает, что подпрограмма может передавать аргументы в другую подпрограмму, не боясь "потерять" собственную переменную @_; вложенный вызов подпрограммы точно так же получает собственную переменную @_.

Давайте вернемся к программе сложения а и

return $_ + $_[!];

print add_two(3,4);

Давайте обобщим эту подпрограмму. Что, если нам нужно сложить

Что, если бы переменная с именем

Мы уже говорили о переменной @_ и о том, как для каждой подпрограммы, вызываемой с параметрами, создается локальная копия этой переменной. Вы можете создавать собственные скалярные переменные, переменные-массивы и хеш-переменные, которые будут работать точно так же. Это делается с помощью операции ту, которая получает список имен переменных и создает их локальные версии (или реализации, если вам так больше нравятся). Вот снова функция

Когда выполняется первый оператор в теле подпрограммы, текущее значение глобальной переменной

Вот способ создания списка всех элементов массива, значения которых превышают число

Что, если бы нам понадобились все элементы, значения которых превышают

sub bigger_than (

my($n,@values); #

# и элементы массива

foreach $_ (@values) (#

# примеры вызова

@new = bigger_than(100,@list); # @new

Обратите внимание: в этот раз мы использовали еще две локальные переменные, чтобы присвоить имена аргументам. Это

my($n,@values) ;

заменить на

my($n,@values)= @_;

$values = "original";

Операцию my

push @b, qw(wilma); #

В Perl заложено огромное количество возможностей, которые на первый взгляд выглядят лишними, а в неопытных руках могут вообще приводить к выдаче багов. Доходит до того, что многие программисты, регулярно пишущие на Perl, даже не подозревают о полном функционале данного языка! Причина этого, как нам кажется, заключается в низком качестве и сомнительном содержании литературы для быстрого старта в области программирования на Perl. Это не касается только книг с Ламой, Альпакой и Верблюдом (“Learning Perl”, “Intermediate Perl” и “Programming Perl”) - мы настоятельно рекомендуем их прочитать.

В этой статье мы хотим подробно рассказать о маленьких хитростях работы с Perl, касающихся необычного использования функций, которые могут пригодится всем, кто интересуется этим языком.

Как работают функции Perl?

В большинстве языков программирования описание функций выглядит так:

Function myFunction (a, b) { return a + b; }

А вызывается так:

MyFunction(1, 2);

На первый взгляд всё просто и понятно. Однако вызов данной функции в таком виде:

MyFunction(1, 2, 3);

… приведёт к различным ошибкам, суть которых будет сведена к тому, что в функцию передано неверное количество аргументов.

Функция в Perl может быть записана так:

Sub mySub($$;$) : MyAttrubyte { my ($param) = @_; }

Где $$;$ - это прототип, а MyAttribute - это атрибут. Прототипы и атрибуты будут рассмотрены далее в статье. А мы пока рассмотрим более простой вариант записи функции:

Sub mySub { return 1; }

Суть этой записи сводится к тому, что мы написали функцию, которая возвращает 1.

Но в этой записи не указано, сколько аргументов принимает данная функция. Именно поэтому ничего не мешает вызвать её вот так:

MySub("Туземец", "Бусы", "Колбаса", 42);

И всё прекрасно выполняется! Это происходит потому, что в Perl передача параметров в функцию
сделана хитро. Perl славится тем, что у него много «непонятных» специальных переменных.
К тому же, в Perl параметры передаются по ссылке. В каждой функции доступна специальная переменная @_, которая является массивом входящих параметров. Очень часто в функциях пишут следующее:

Sub mySub { my $param = shift; ...; }

Дело в том, что в Perl многие функции при вызове без аргументов используют переменные по умолчанию. Shift же по умолчанию достаёт данные из массива @_. Поэтому записи:

My $param = shift;

My $param = shift @_;

… совершенно эквивалентны, но первая запись короче и очевидна для Perl-программистов, поэтому используется именно она.

Второй способ получения данных - присваивание списком. В Perl мы можем сделать так:

My ($one, $two, $three) = (shift, shift, shift);

Что есть обычное списочное присваивание.

Другая запись

My ($one, $two, $three) = @_;

… работает точно так же. А теперь внимание! Грабли, на которые рано или поздно наступает каждый Perl-программист:

Sub mySub { my $var = @_; print $var; }

Если вызвать данную функцию как mySub(1, 2, 3) в $var мы внезапно получим не 1, а 3.
Это происходит потому, что в данном случае контекст переменной определяется как скалярный (в Perl не существует типов «строка», или «число», или «файл», или что-то ещё. Это контекстно зависимый полиморфный язык для работы с текстами). Чтобы исправить ошибку, достаточно взять $var в скобки, чтобы контекст стал списочным. Вот так:

Sub mySub { my ($var) = @_ }

И теперь, как и ожидалось, при вызове mySub(1, 2, 3) в $var будет 1.

Как мы уже говорили, в Perl параметры передаются по ссылке. Это значит, что мы можем из функции модифицировать параметры, которые в неё переданы.

Например:

My $var = 5; mySub($var); print $var; sub mySub { # вспоминаем, что доступ к элементам массива выполняется в скалярном контексте # т. е. доступ к нулевому элементу массива @arr будет выглядеть как $arr, то же самое и с # @_. $_++; }

Результат будет 6. Однако в Perl можно сделать в каком-то роде «передачу по значению» вот так:

My $var = 5; mySub($var); print $var; sub mySub { my ($param) = @_; $param++; }

А вот теперь результат будет 5.

И последние два нюанса, которые очень важны. Во-первых, Perl возвращает из функции результат последнего выражения.

Возьмём код из предыдущего примера и немного его модифицируем:

My $var = 5; my $result = mySub($var); print $result; sub mySub { my ($param) = @_; ++$param; }

Функция вернёт 6.

И второй важный момент, хотя, скорее, предостережение. Потенциальная проблема звучит так: «если в теле функции вызывается другая функция с амперсандом и без скобок, то эта другая функция получает на вход параметры той функции(@_), в теле которой она вызывается».

Use strict; use Data::Dumper; mySub(1, 2, 3); sub mySub { &inner; } sub inner { print Dumper @_; }

Результат:
$VAR1 = [
1,
2,
3
];

Однако, если ЯВНО указать, что функция вызывается без параметров, то всё в порядке.

Sub mySub { &inner(); }

И вывод будет выглядеть вот так:
$VAR1 = ;

Анонимные функции

Анонимные функции объявляются в месте использования и не получают уникального идентификатора для доступа к ним. При создании они либо вызываются напрямую, либо ссылка на функцию присваивается переменной, с помощью которой затем можно косвенно вызывать данную функцию.

Элементарное объявление анонимной функции в Perl:

My $subroutine = sub { my $msg = shift; printf "I am called with message: %sn", $msg; return 42; }; # $subroutine теперь ссылается на анонимную функцию $subroutine->("Oh, my message!");

Анонимные функции можно и нужно использовать как для создания блоков кода, так и для замыканий, о которых речь дальше.

Замыкания

Замыкание - это особый вид функции, в теле которой используются переменные, объявленные вне тела этой функции (не в качестве её параметров, а в окружающем коде) в лексической области видимости.

В записи это выглядит как, например, функция, находящаяся целиком в теле другой функции.

# возвращает ссылку на анонимную функцию sub adder($) { my $x = shift; # в котором x - свободная переменная, return sub ($) { my $y = shift; # а y - связанная переменная return $x + $y; }; } $add1 = adder(1); # делаем процедуру для прибавления 1 print $add1->(10); # печатает 11 $sub1 = adder(-1); # делаем процедуру для вычитания 1 print $sub1->(10); # печатает 9

Замыкания использовать полезно, например, в той ситуации, когда необходимо получить функцию с уже готовыми параметрами, которые будут в ней сохранены. Или же для генерации функции-парсера. Колбеков.

Неизменяемый объект

Нет ничего проще, чем реализовать неизменяемый объект на Perl. Немногие современные языки могут похвастаться настолько простым и изящным решением. В Perl для этого используется state.

Фактически state работает как my - у них одинаковая область видимости. Но при этом переменная state никогда не будет переинициализирована в рамках программы. Это иллюстрируют два примера.

Use feature "state"; gimme_another(); gimme_another(); sub gimme_another { state $x; print ++$x, "n"; }

Эта программа напечатает 1, затем 2.

Use feature "state"; gimme_another(); gimme_another(); sub gimme_another { my $x; print ++$x, "n"; }

А эта 1, затем 1.

Бесскобочные функции

На наш взгляд, это самый подходящий перевод термина parenthesis-less.

Например, print часто пишется и вызывается без скобок. Возникает вопрос, а можем ли мы тоже создавать такие функции?

Безусловно. Для этого у Perl есть даже специальная прагма - subs. Предположим, что мы хотим напечатать OK, если определенная переменная true. В Perl (как и в C) нет такого типа данных, как Boolean, вместо него выступает неложное значение, например, 1.

Use strict; use subs qw/checkflag/; my $flag = 1; print "OK" if checkflag; sub checkflag { return $flag; }

Данная программа напечатает OK. Но это не единственный способ. Perl хорошо продуман, поэтому, если мы реструктуризируем нашу программу и приведём её к такому виду:

Use strict; my $flag = 1; sub checkflag { return $flag; } print "OK" if checkflag;

… то результат будет тот же. Закономерность здесь следующая: мы можем вызывать функцию без скобок в нескольких случаях:

Используя прагму subs;
- написав функцию ПЕРЕД её вызовом;
- использовать прототипы функций.

Обратимся к последнему варианту.

Прототипы функций

Стоит пояснить, как функции работают в Perl.

Зачастую разное понимание цели этого механизма приводит к холиварам с адептами других языков, утверждающих, что «у перла плохие прототипы». Так вот, прототипы в Perl не для жёсткого ограничения типов параметров, передаваемых функциям. Это подсказка для языка: как разбирать то, что передаётся для функции.

Есть, к примеру, абстрактная функция, которая называется my_sub:

Sub my_sub { print join ", ", @_; }

Мы её вызываем следующим образом:

My_sub(1, 2, 3, 4, 5);

Функция напечатает следующее:
1, 2, 3, 4, 5,

Получается, что в любую функцию Perl можно передать любое количество аргументов. И пусть сама функция разбирается, что мы от неё хотели.

В функцию передается «текущий массив», контекстная переменная. Поэтому запись вида:

Sub ms { my $data = shift; print $data; }

… означает то же самое, что и:

Sub ms { my $data = shift @_; print $data; }

Предполагается, что должен быть механизм контроля переданных в функцию аргументов. Эту роль и выполняют прототипы.

Функция Perl с прототипами будет выглядеть так:

Sub my_sub($$;$) { my ($v1, $v2, $v3) = @_; $v3 ||= "empty"; printf("v1: %s, v2: %s, v3: %sn", $v1, $v2, $v3); }

Прототипы функций записываются после имени функции в круглых скобках. Прототип $$;$ означает, что в качестве параметров необходимо присутствие двух скаляров и третьего по желанию, «;» отделяет обязательные параметры от возможных.

Если же мы попробуем вызвать её вот так:

My_sub();

… то получим ошибку вида:
Not enough arguments for main::my_sub at pragmaticperl.pl line 7, near "()"
Execution of pragmaticperl.pl aborted due to compilation errors.

А если так:

&my_sub();

… то проверка прототипов не будет происходить.

Резюмируем. Прототипы будут работать в следующих случаях:

Если функция вызывается без знака амперсанда (&). Perlcritic (средство статического анализа Perl кода), кстати говоря, ругается на запись вызова функции через амперсанд, то есть такой вариант вызова не рекомендуется.
- Если функция написана перед вызовом. Если мы сначала вызовем функцию, а потом её напишем, при включённых warnings получим следующее предупреждение:
main::my_sub() called too early to check prototype at pragmaticperl.pl line 4

Ниже пример правильной программы с прототипами Perl:

Use strict; use warnings; use subs qw/my_sub/; sub my_sub($$;$) { my ($v1, $v2, $v3) = @_; $v3 ||= "empty"; printf("v1: %s, v2: %s, v3: %sn", $v1, $v2, $v3); } my_sub();

В Perl существует возможность узнать, какой у функции прототип. Например:

Perl -e "print prototype("CORE::read")"

выдаст:
*$$;$

Локальные переменные или динамическая область видимости

Допустим, у нас есть скрипт, который что-то считает. Вдруг нам в функции, например, понадобилась локальная переменная, которая должна быть копией глобальной.

Мы можем это сделать следующим образом:

Use strict; use warnings; my $x = 1; print "x: $xn"; do_with_x(); print "x: $xn"; sub do_with_x { my $y = $x; $y++; print "y: $yn"; }

Вывод ожидаемый:
x: 1
y: 2
x: 1

Однако в данном случае мы можем обойтись без y. Решение выглядит так:

Use strict; use warnings; use vars "$x"; $x = 1; print "x: $xn"; do_with_x(); print "x: $xn"; sub do_with_x { local $x = $x; $x++; print "x: $xn"; }

Эта штука и называется динамической областью видимости. Очень хорошо этот пример помогает понять представление переменной в виде карточек: local - это когда мы закрываем то, что написано на карточке, другой карточкой, а как только выходим из блока, всё возвращается на круги своя. Другая аналогия от perlmonks: my - in space, local - in time. Также очень часто эта конструкция используется внутри блоков кода, в которых необходим автосброс буфера. Тогда можно сделать:

Local $| = 1;

Или, если лень писать в конце каждого print n:

Local $ = "n";

Оверрайд методов

Оверрайд - часто довольно полезная штука. Например, у нас есть модуль, который писал некий N. И всё в нём хорошо, а вот один метод, допустим, call_me, должен всегда возвращать 1, иначе беда, а метод из базовой поставки модуля возвращает всегда 0. Код модуля трогать нельзя.

Пусть программа выглядит следующим образом:

Use strict; use Data::Dumper; my $obj = Top->new(); if ($obj->call_me()) { print "Purrrrfectn"; } else { print "OKAY:(n"; } package Top; use strict; sub new { my $class = shift; my $self = {}; bless $self, $class; return $self; } sub call_me { print "call_me from TOP called!n"; return 0; } 1;

Которая выведет:
call_me from TOP called!
OKAY:(

И снова у нас есть решение:

Допишем перед вызовом $obj->call_me() следующую вещь:

*Top::call_me = sub { print "Overrided subroutine called!n"; return 1; };

Однако для временного оверрайда мы можем воспользоваться ключевым словом local. И тогда оверрайд будет выглядеть так:

Local *Top::call_me = sub { print "Overrided subroutine called!n"; return 1; };

Это заменит функцию пакета Top - call_me в лексической области видимости (в текущем блоке).
И теперь наш вывод будет выглядеть примерно следующим образом:
Overrided subroutine called!
Purrrrfect

Код модуля не меняли, функция теперь делает то, что нам надо.

На заметку: если приходится часто использовать данный приём в работе - налицо архитектурный косяк и вообще эта ситуация уже описывалась картинкой. Хороший пример использования - добавление дебаг-информации в функции.

Wantarray

В Perl есть такая полезная штука, которая позволяет определить, в каком контексте
вызывается функция. Например, мы хотим, чтобы функция вела себя следующим образом:
когда надо возвращала массив, а иначе - ссылку на массив. Это можно реализовать, и
к тому же очень просто, с помощью wantarray. Напишем простую программу для демонстрации:

#!/usr/bin/env perl use strict; use Data::Dumper; my @result = my_cool_sub(); print Dumper @result; my $result = my_cool_sub(); print Dumper $result; sub my_cool_sub { my @array = (1, 2, 3); if (wantarray) { print "ARRAY!n"; return @array; } else { print "REFERENCE!n"; return @array; } }

Что выведет:
ARRAY!
$VAR1 = 1;
$VAR2 = 2;
$VAR3 = 3;
REFERENCE!
$VAR1 = [
1,
2,
3
];

Также хотелось бы напомнить про интересную особенность Perl. %hash = @аrray; В этом случае Perl построит хэш вида
($array => $array, $array => $array);

Посему, если применять my %hash = my_cool_sub(), будет использована ветка логики wantarray. И именно по этой причине wanthash нет.

Autoload

В Perl одна из лучших систем управления модулями. Мало того что программист может контролировать ВСЕ стадии исполнения модуля, так ещё существуют интересные особенности, которые делают жизнь проще. Например, Autoload.

Суть Autoload в том, что когда функции в модуле не существует, Perl ищет функцию Autoload в этом модуле, и только затем, когда не находит, активируется исключение. Это значит, что мы можем описать обработчик ситуаций, когда вызывается несуществующая функция.

Например:

#!/usr/bin/env perl use strict; Autoload::Demo::hello(); Autoload::Demo::asdfgh(1, 2, 3); Autoload::Demo::qwerty(); package Autoload::Demo; use strict; use warnings; our $AUTOLOAD; sub AUTOLOAD { print $AUTOLOAD, " called! with params: ", join (", ", @_), "n"; } sub hello { print "Hello!n"; } 1;

Очевидно, что функций qwerty и asdfgh не существует в пакете Autoload::Demo. В функции Autoload специальная глобальная переменная $AUTOLOAD устанавливается равной функции, которая не была найдена.

Вывод этой программы:
Hello!
Autoload::Demo::asdfgh called! with params: 1, 2, 3
Autoload::Demo::qwerty called! with params:

Генерация функций на лету

Допустим, мы хотим сделать функцию, которая должна что-то возвращать. Затем функцию, которая должна возвращать что-то другое. У объекта. Getter, так сказать. Это Perl. «Лень, нетерпение, надменность» (Л. Уолл). Я думаю, что написание кода следующего вида никому не доставляет удовольствия.

Sub getName { my $self = shift; return $self->{name}; } sub getAge { my $self = shift; return $self->{age}; } sub getOther { my $self = shift; return $self->{other}; }

Функции можно генерировать. В Perl есть такая штука как тип данных typeglob. Наиболее точный перевод названия - таблица имён. Typeglob имеет свой сигил(*).

Для начала посмотрим код:

#!/usr/bin/env perl use strict; use warnings; package MyCoolPackage; sub getName { my $self = shift; return $self->{name}; } sub getAge { my $self = shift; return $self->{age}; } sub getOther { my $self = shift; return $self->{other}; } foreach (keys %{*MyCoolPackage::}) { print $_." => ".$MyCoolPackage::{$_}."n"; }

getOther => *MyCoolPackage::getOther
getName => *MyCoolPackage::getName
getAge => *MyCoolPackage::getAge

В принципе, глоб - это хэш с именем пакета, в котором он определен. Он содержит в качестве ключей элементы модуля + глобальные переменные (our). Логично предположить, что если мы добавим в хэш свой ключ, то этот ключ станет доступен как обычная сущность. Воспользуемся генерацией функций для генерации данных геттеров.

И вот что у нас получилось:

#!/usr/bin/env perl use strict; use warnings; $ = "n"; my $person = Person->new(name => "justnoxx", age => "25", other => "perl programmer",); print "Name: ", $person->get_name(); print "Age: ", $person->get_age(); print "Other: ", $person->get_other(); package Person; use strict; use warnings; sub new { my ($class, %params) = @_; my $self = {}; no strict "refs"; for my $key (keys %params) { # __PACKAGE__ равен текущему модулю, это встроенная # волшебная строка # следующая строка превращается в, например: # Person::get_name = sub {...}; *{__PACKAGE__ . "::" . "get_$key"} = sub { my $self = shift; return $self->{$key}; }; $self->{$key} = $params{$key}; } bless $self, $class; return $self; } 1;

Эта программа напечатает:
Name: justnoxx
Age: 25
Other: perl programmer

Атрибуты функций

В Python есть такое понятие как декоратор. Это такая штуковина, которая позволяет «добавить объекту дополнительное поведение».

Да, в Perl декораторов нет, зато есть атрибуты функций. Если мы откроем perldoc perlsub и посмотрим на описание функции, то увидим любопытную запись:

Sub NAME(PROTO) : ATTRS BLOCK

Таким образом, функция с атрибутами может выглядеть так:

Sub mySub($$;$) : MyAttr { print "Hello, I am sub with attributes and prototypes!"; }

Работа с атрибутами в Perl - дело нетривиальное, потому уже довольно давно в стандартную поставку Perl входит модуль Attribute::Handlers.

Дело в том, что атрибуты из коробки имеют довольно много ограничений и нюансов работы, так что, если кому-то интересно, можно обсудить в комментариях.

Допустим, у нас есть функция, которая может быть вызвана только в том случае, если пользователь авторизован. За то что пользователь авторизован отвечает переменная $auth, которая равна 1, если пользователь авторизован, и 0, если нет. Мы можем сделать следующим образом:

My $auth = 1; sub my_sub { if ($auth) { print "Okay!n"; return 1; } print "YOU SHALL NOT PASS!!!1111"; return 0; }

И это приемлемое решение.

Но может возникнуть такая ситуация, что функций будет становиться больше и больше. А в каждой делать проверку будет всё накладнее. Проблему можно решить на атрибутах.

Use strict; use warnings; use Attribute::Handlers; use Data::Dumper; my_sub(); sub new { return bless {}, shift; } sub isAuth: ATTR(CODE) { my ($package, $symbol, $referent, $attr, $data, $phase, $filename, $linenum) = @_; no warnings "redefine"; unless (is_auth()) { *{$symbol} = sub { require Carp; Carp::croak "YOU SHALL NOT PASSn"; goto &$referent; }; } } sub my_sub: isAuth { print "I am called only for auth users!n"; } sub is_auth { return 0; }

В данном примере вызов программы будет выглядеть так:
YOU SHALL NOT PASS at myattr.pl line 18. main::__ANON__() called at myattr.pl line 6

А если мы заменим return 0 на return 1 в is_auth, то:
I am called only for auth users!

Не зря атрибуты представлены в конце статьи. Для того чтобы написать этот пример, мы воспользовались:

Анонимными функциями;
- оверрайдом функций;
- специальной формой оператора goto.

Несмотря на довольно громоздкий синтаксис, атрибуты успешно применяются в Catalyst. К тому же не стоит забывать, что они, всё-таки, являются экспериментальной фичей Perl, а потому их синтаксис может меняться.

Статья написана в соавторстве и по техническому материлу от Дмитрия Шаматрина АКА justnoxx и при содействии программистов REG.RU : Тимура Нозадзе, Виктора Ефимова, Полины Шубиной, Andrew Nugged