3. Унарные и бинарные операторы

3. Унарные и бинарные операторы

123

123

6789901233889012467782222233333333444444441111111111111111111116789901233889012467782222233333333444444441111111111111111111114. Операторы и объявления4. Операторы и объявления149149

678990123388901246778

222223333333344444444

111111111111111111111

678990123388901246778

222223333333344444444

111111111111111111111

4. Операторы и объявления

4. Операторы и объявления

149

149

Термы и списковые операторы (слева) Оператор «стрелка» Автоинкрементирование и автодекрементирование Возведение в степень Идеографические унарные операторы Операторы связывания Мультипликативные операторы Аддитивные операторы Операторы сдвига Именованные унарные операторы и операторы проверки файлов Операторы сравнения Операторы равенства Операторы поразрядного действия Логические операторы в стиле С (короткого действия) Оператор диапазона Условный оператор Операторы присваивания Оператор запятой Списковые операторы (справа) Логические and, or, not и xor Операторы С, отсутствующие в Perl

Простые операторы150

Составные операторы151

Операторы if и unless 153

Операторы Loop 154

Голые блоки 162

goto 165

Глобальные объявления166

Объявления с областью видимости168

Прагмы176

Поиск по шаблону179

Бестиарий регулярных выражений 180

Операторы поиска по шаблону183

Метасимволы и метазнаки 199

Классы символов208

Квантификаторы

Позиции

Захват и кластеризация

Чередование

Управление процессом

Сложные шаблоны

Подпрограммы

Синтаксис

Семантика

Передача ссылок

Прототипы

Атрибуты подпрограмм

Форматы

Переменные форматов

Нижние колонтитулы

Ссылки

Что такое ссылка?

Создание ссылок

Использование жестких ссылок

Символические ссылки

Фигурные скобки, квадратные скобки и кавычки

Структуры данных

Массивы массивов

Хеши массивов

Массивы хешей

Хеши хешей

Хеши функций

Более сложные записи

Сохранение структур данных

Пакеты

Таблицы имен

Автозагрузка

Модули

Использование модулей

Создание модулей

9 2 5 0 2 7 2 2 4 9 1712 2 3 3 4 6 6 6 6 7 72 2 2 2 2 2 2 2 2 2 2 29 2 5 0 2 7 2 2 4 9 1712 2 3 3 4 6 6 6 6 7 72 2 2 2 2 2 2 2 2 2 2 20 4 68 8 82 2 20 4 68 8 82 2 288889 17 0 18 9 9 112 2 2 3 39 17 0 18 9 9 112 2 2 3 35135136 3 5 7 0 1412 2 2 3 3 33 3 3 3 3 3 36 3 5 7 0 1412 2 2 3 3 33 3 3 3 3 3 3533533о 4 6 6 9 34 4 4 4 4 53 3 3 3 3 3о 4 6 6 9 34 4 4 4 4 53 3 3 3 3 3Замещение встроенных функций

9 2 5 0 2 7 2 2 4 9 17

12 2 3 3 4 6 6 6 6 7 7

2 2 2 2 2 2 2 2 2 2 2 2

9 2 5 0 2 7 2 2 4 9 17

12 2 3 3 4 6 6 6 6 7 7

2 2 2 2 2 2 2 2 2 2 2 2

0 4 6

8 8 8

2 2 2

0 4 6

8 8 8

2 2 2

88

88

9 17 0 1

8 9 9 11

2 2 2 3 3

9 17 0 1

8 9 9 11

2 2 2 3 3

5

1

3

5

1

3

6 3 5 7 0 14

12 2 2 3 3 3

3 3 3 3 3 3 3

6 3 5 7 0 14

12 2 2 3 3 3

3 3 3 3 3 3 3

5

3

3

5

3

3

о 4 6 6 9 3

4 4 4 4 4 5

3 3 3 3 3 3

о 4 6 6 9 3

4 4 4 4 4 5

3 3 3 3 3 3

ОбъектыОбъектыКраткая памятка по объектно-ориентированному жаргону Система объектов Perl Вызов методов Создание объектов Наследование классов Деструкторы экземпляров Управление данными экземпляров Управление данными класса Резюме Краткая памятка по объектно-ориентированному жаргону Система объектов Perl Вызов методов Создание объектов Наследование классов Деструкторы экземпляров Управление данными экземпляров Управление данными класса Резюме ПерегрузкаПрагма overloadОбработчики перегрузки Перегружаемые операторыКонструктор копий (=)Когда обработчик перегрузки отсутствует (nomethod и fallback) Константы перегрузкиОткрытые функции перегрузкиНаследование и перегрузкаПерегрузка на этапе исполненияДиагностика перегрузкиПерегрузкаПрагма overloadОбработчики перегрузки Перегружаемые операторыКонструктор копий (=)Когда обработчик перегрузки отсутствует (nomethod и fallback) Константы перегрузкиОткрытые функции перегрузкиНаследование и перегрузкаПерегрузка на этапе исполненияДиагностика перегрузки5 578498014 5 6 75 555667899 9 9 93 333333333 3 335 578498014 5 6 75 555667899 9 9 93 333333333 3 338 5 6 79 0 0 03 4 4 48 5 6 79 0 0 03 4 4 49 9 0 0о о 1 14 4 4 49 9 0 0о о 1 14 4 4 4Связанные переменныеСвязывание скаляровСвязывание массивовСвязывание хешейСвязывание указателей файлов Тонкая ловушка при отвязывании Модули для связывания в CPANСвязанные переменныеСвязывание скаляровСвязывание массивовСвязывание хешейСвязывание указателей файлов Тонкая ловушка при отвязывании Модули для связывания в CPAN1 3 17 3 4 71 12 2 3 4 44 4 4 4 4 4 41 3 17 3 4 71 12 2 3 4 44 4 4 4 4 4 4Часть III. Perl как технологияЧасть III. Perl как технология944944Байты и символы453Действие символьной семантики 455Осторожно, работают 人459Байты и символы453Действие символьной семантики 455Осторожно, работают 人45916. Межпроцессное взаимодействие16. Межпроцессное взаимодействие461461

Объекты

Объекты

Краткая памятка по объектно-ориентированному жаргону Система объектов Perl Вызов методов Создание объектов Наследование классов Деструкторы экземпляров Управление данными экземпляров Управление данными класса Резюме

Краткая памятка по объектно-ориентированному жаргону Система объектов Perl Вызов методов Создание объектов Наследование классов Деструкторы экземпляров Управление данными экземпляров Управление данными класса Резюме

Перегрузка

Прагма overload

Обработчики перегрузки Перегружаемые операторы

Конструктор копий (=)

Когда обработчик перегрузки отсутствует (nomethod и fallback) Константы перегрузки

Открытые функции перегрузки

Наследование и перегрузка

Перегрузка на этапе исполнения

Диагностика перегрузки

Перегрузка

Прагма overload

Обработчики перегрузки Перегружаемые операторы

Конструктор копий (=)

Когда обработчик перегрузки отсутствует (nomethod и fallback) Константы перегрузки

Открытые функции перегрузки

Наследование и перегрузка

Перегрузка на этапе исполнения

Диагностика перегрузки

5 578498014 5 6 7

5 555667899 9 9 9

3 333333333 3 33

5 578498014 5 6 7

5 555667899 9 9 9

3 333333333 3 33

8 5 6 7

9 0 0 0

3 4 4 4

8 5 6 7

9 0 0 0

3 4 4 4

9 9 0 0

о о 1 1

4 4 4 4

9 9 0 0

о о 1 1

4 4 4 4

Связанные переменные

Связывание скаляров

Связывание массивов

Связывание хешей

Связывание указателей файлов Тонкая ловушка при отвязывании Модули для связывания в CPAN

Связанные переменные

Связывание скаляров

Связывание массивов

Связывание хешей

Связывание указателей файлов Тонкая ловушка при отвязывании Модули для связывания в CPAN

1 3 17 3 4 7

1 12 2 3 4 4

4 4 4 4 4 4 4

1 3 17 3 4 7

1 12 2 3 4 4

4 4 4 4 4 4 4

Часть III. Perl как технология

Часть III. Perl как технология

9

4

4

9

4

4

Байты и символы453

Действие символьной семантики 455

Осторожно, работают 人459

Байты и символы453

Действие символьной семантики 455

Осторожно, работают 人459

16. Межпроцессное взаимодействие

16. Межпроцессное взаимодействие

461

461

Сигналы462

Файлы469

Каналы477

System VIPC485

Сокеты 489

Потоки497

Модель процессов 498

Модель потоков499

Компиляция 515

Жизненный цикл программ на Perl516

Компилирование кода 518

Выполнение кода 524

Серверы компиляторов 527

Генераторы кода 528

Средства разработки кода530

Компилятор и интерпретатор: авангардизм и ретро 532

Интерфейс командной строки537

Обработка команд 537

Переменные окружения 554

Отладчик Perl 557

Использование отладчика558

Команды отладчика 560

Настройка отладчика569

Автоматическое выполнение 573

Поддержка отладчика 575

Профайлер Perl 578

Внутри и снаружи582

Как работает Perl583

Внутренние типы данных 583

Расширение Perl (использование С из Perl) 584

Вызов Perl из С591

Мораль «сей басни»596

Часть IV. Perl как культура597

CPAN599

Каталог modules архива CPAN601

Использование модулей CPAN604

Создание модулей CPAN606

Защита данных 609

Обработка ненадежных данных610

Обработка ошибок синхронизации622

Работа с ненадежным кодом629

Распространенные приемы программирования639

Обычные промахи новичков639

Эффективность648

Стиль программирования658

Свободный разговор на Perl 662

Генерирование программ 672

Переносимость программ Perl677

Перевод строки678

Остроконечники, тупоконечники и ширина чисел 680

Файлы и файловые системы681

Взаимодействие с системой682

Межпроцессное взаимодействие (IPC)683

Внешние подпрограммы (XS)683

Стандартные модули684

Дата и время684

Многоязычность 685

Стиль685

Документация в формате POD 686

О pod в двух словах686

Трансляторы и модули Pod695

Создание собственных инструментов для работы с pod697

Ловушки pod700

Документирование программ Perl 701

Культура Perl703

История развития 703

Поэзия Perl 706

Часть V. Справочный материал709

Специальные имена 711

Специальные имена, сгруппированные по типам712

Специальные переменные в алфавитном порядке 714

Функции736

Функции Perl по категориям739

Функции Perl в алфавитном порядке741

Стандартная библиотека Perl895

Библиотековедение895

Обзор библиотеки Perl 897

Модули прагм 900

use attributes901

use autouse902

use base903

use blib 904

use bytes904

use charnames905

use constant906

use diagnostics908

use fields910

use filetest 912

use integer 913

use less 914

use lib 914

use locale916

use open917

use overload917

use re918

use sigtrap 919

use strict922

use subs925

use vars925

use warnings 926

Стандартные модули930

Перечень по типу931

Benchmark941

Carp943

CGI944

CGI::Carp944

Class: :Struct 945

Config946

CP AN947

Cwd 947

Data::Dumper 948

DB_File948

Dumpvalue950

English 950

Errno951

Exporter951

Fatal952

Fcntl 953

File::Basename 953

File::Compare 954

File:: Copy955

File::Find 955

File::Glob 956

File::Spec 959

File::stat960

File::Temp 960

FileHandle 961

Getopt::Long 964

Getopt::Std965

IO::Socket966

IPC::Open2967

IPC::Open3967

Math::BigInt 968

Math::Complex 969

Math::Trig 969

Net::hostent969

POSIX970

Safe 972

Socket 973

Symbol974

Sys::Hostname975

Sys::Syslog976

Term:: Cap977

Text:: Wrap978

Time::Local 978

Time: :local time 979

User::grent980

User::pwent980

Диагностические сообщения982

Глоссарий1045

Алфавитный указатель1084

Предисловие

В погоне за счастьем

Perl - язык, с помощью которого вы сделаете свою работу.

Конечно, если эта работа - программирование, то теоретически ее можно сделать с помощью любого «полного» компьютерного языка. Но опыт показывает, что компьютерные языки различаются не столько возможностью что-либо сделать, сколько легкостью, с которой это достигается. На одном полюсе находятся так называемые языки четвертого поколения, с помощью которых можно легко делать одни вещи и почти невозможно другие. На другом полюсе - так называемые языки с промышленными возможностями (industrial-strength languages), посредством которых одинаково трудно делать почти все.

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

Что это за «простые задачи», которые должны решаться легко? Разумеется, те, которые мы решаем изо дня в день. Нам нужен язык, с помощью которого легко работать с числами и текстом, файлами и каталогами, компьютерами и сетями, а в особенности - с программами. Он должен позволять легко запускать внешние программы и просматривать результаты их работы в поиске интересных данных. Он должен позволять легко отправлять эти интересные данные другим программам, способным обрабатывать их особым образом. Он должен также позволять нам легко разрабатывать собственные программы, изменять их и производить отладку. И, конечно, наши собственные программы должны легко компилироваться и запускаться, а также быть переносимыми на любую современную операционную систему.

Все это, а также многое другое, делает Perl.

Первоначально разработанный как интегрирующий язык для Unix, Perl давно распространился на большинство других операционных систем. Поскольку Perl выполняется почти везде, он является одной из наиболее переносимых сред программирования, имеющихся на сегодняшний день. Чтобы написать переносимые программы на С или C++, необходимо расставить все эти странные пометки #ifdef для каждой операционной системы. Для обеспечения переносимости программ на Java нужно разбираться в индивидуальных особенностях всех новых реализаций. Для создания переносимых

сценариев командного процессора нужно помнить синтаксис всех команд каждой версии операционной системы и пытаться найти общий знаменатель, благодаря которому они, как можно надеяться, будут работать всюду. А чтобы создавать переносимые программы на Visual Basic потребуется дать более гибкое определение понятию «переносимость».:-)

В Perl удается избежать таких проблем, сохраняя при этом многие преимущества других языков и добавляя собственные чудеса. Чудеса связаны с рядом причин: практичностью набора его функций, изобретательностью сообщества разработчиков Perl и богатством, которое предоставляет движение open source в целом. Однако в значительной мере чудеса обусловлены гибридной природой Perl. У Perl смешанное происхождение, и многообразие средств всегда рассматривалось в нем как сила, а не слабость. Perl - это язык, говорящий: «Дайте мне вашу усталость, вашу бедность». Если вы чувствуете себя словно стиснутым в толпе и стремитесь «дышать свободой», то Perl - для вас.

Perl охватывает различные культуры. Его взрывное распространение в значительной мере питалось стремлением бывших системных Unix-программистов взять с собой как можно больше из «старого мира». Для них Perl является квинтэссенцией культуры Unix, оазисом в пустыне «невозможности перейти из одного места в другое». Существует, однако, и движение в обратном направлении: веб-дизайнеры, работающие под Windows с удовольствием обнаруживают возможность запустить свои Perl-программы на Unix-cep- вере своей компании без их дополнительной переработки.

Хотя Perl особенно популярен среди системных программистов и разработчиков для Интернета, это связано лишь с тем, что они первыми его открыли; аудитория Perl значительно шире. Получивший при создании скромный статус языка обработки текста, Perl превратился в сложный язык программирования общего назначения с богатой средой разработки программ, укомплектованной отладчиками, профайл ерами, формировщиками перекрестных ссылок, компиляторами, библиотеками, синтаксически-ориенти- рованными редакторами и всеми остальными атрибутами «настоящего» языка программирования - если они вам требуются. Но все они относятся к поддержке возможностей решения сложных задач, с чем справляются многие другие языки. Уникальность Perl в том, что он никогда не терял из виду возможность легко решать задачи простые.

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

тельность генов ДНК, веб-страницы или фьючерсы на свиные внутренности. В самом деле в сообществе Perl бытует шутка, что очередной крупный кризис на рынке ценных бумаг может разразиться из-за ошибки, сделанной кем-нибудь в своем сценарии Perl. (Светлой стороной окажется то, что безработные рыночные аналитики окажутся, так сказать, востребованными.)

Существует много слагаемых успеха. Perl как проект open source достиг его еще до того, как это движение получило свое название. Perl свободно распространяется, и так будет всегда. Каждый может работать с Perl так, как сочтет удобным, и на основе очень либеральной политики лицензирования. Если вы занимаетесь коммерческой деятельностью и хотите воспользоваться Perl, можете смело идти вперед. Разрешается применять Perl в разрабатываемых коммерческих приложениях бесплатно и без ограничений. А для тех, у кого возникнет проблема, которую сообщество Perl не сможет решить, существует последняя инстанция: сам исходный код. Сообщество Perl не занимается продажей своих профессиональных тайн под видом «обновлений». Сообщество Perl никогда не «выйдет из дела» и не оставит вас с брошенным на произвол судьбы продуктом.

Безусловно, популярности Perl способствует его бесплатное распространение. Но этого недостаточно для объяснения феномена Perl, поскольку многие бесплатно распространяемые пакеты не преуспели. Дело не в том, что он бесплатен; он доставляет удовольствие. Люди чувствуют желание творить на Perl, поскольку он дает свободу самовыражения: можно выбирать между целями оптимизации - скоростью работы компьютера или скоростью программирования, между многословием и выразительностью, между «читабельностью» и возможностью поддержки или повторного использования, или переносимости, или обучаемости, или поучительности. Можно оптимизировать даже непонятность, если принять участие в конкурсе на самую непонятную программу 一 Obfuscated Perl Contest.

Perl может предоставить все эти степени свободы, поскольку это язык с раздвоением личности. Это одновременно очень простой язык и очень богатый язык. Perl собрал отовсюду хорошие идеи и поместил их в простую в использовании логическую структуру. Для тех, кому он просто нравится, Perl 一 это Practical Extraction and Report Language (практический язык извлечения данных и создания отчетов). Для тех, кто любит его, Perl 一 это Pathologically Eclectic Rubbish Lister (паталогически эклектичный язык для распечатки чепухи). А для многочисленных минималистов Perl кажется проявлением бесцельной избыточности. Но это хорошо. Редукционисты должны существовать (в основном среди физиков). Редукционисты стремятся разъять целое на части. Мы, все остальные, пытаемся собрать их вместе.

Во многих отношениях Perl is a simple language (простой язык). Не требуется знать множества особых заклинаний, чтобы скомпилировать программу на Perl - ее можно просто выполнить как пакетный файл или сценарий оболочки. Типы и структуры Perl просты в использовании и понимании. Perl не налагает свои произвольные ограничения на данные 一 строки и массивы мо-

гут быть сколь угодно велики, лишь бы хватило оперативной памяти, и их организация позволяет им легко увеличиваться по мере надобности. Perl не требует изучения новых синтаксиса и семантики, в значительной мере заимствуя их из других языков, с которыми вы можете быть знакомы (например, С, awk, BASIC, Python, английский и греческий). На практике почти любой программист может прочесть хорошо написанный код Perl и составить себе представление о том, что он делает.

Очень важно, что нет необходимости изучить Perl полностью, чтобы начать писать полезные программы. Можно начать изучение Perl с «тонкого конца». Вы можете программировать на языке «детский лепет Perl», и мы обещаем не смеяться над этим. Точнее, мы обещаем смеяться не более, чем над первыми творческими попытками ребенка. Многие идеи Perl заимствованы из естественного языка, и одна из лучших состоит в том, что можно использовать лишь подмножество языка, если его достаточно для того, чтобы передать мысль. В культуре Perl приемлема любая степень владения языком. Полицию по охране языка мы к вам не пришлем. Сценарий Perl будет «правильным», если выполнит задачу прежде, чем начальник вас уволит.

Будучи во многих отношениях простым, Perl является и богатым языком, который нужно долго изучать. Это расплата за возможность решать сложные задачи. Хотя понадобится некоторое время на освоение всех средств Perl, вы будете рады иметь в своем распоряжении расширенные возможности, когда настанет момент и они вам понадобятся.

Благодаря своему происхождению Perl был богатым языком даже тогда, когда служил «просто» языком преобразования данных, предназначенным для перемещения по файлам, просмотра больших объемов текста, создания и получения динамических данных и вывода легко форматируемых отчетов, основанных на этих данных. Но в какой-то момент начался расцвет Perl. Он стал также и языком для работы с файловой системой, управления процессами, администрирования баз данных, программирования в архитектуре клиент-сервер, создания безопасных программ, управления данными в Сети и даже для объектно-ориентированного и функционального программирования. Эти возможности не были просто механически присоединены к Perl - каждая новая синергически работает с остальными, поскольку с самого начала Perl проектировался как интегрирующий язык.

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

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

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

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

Парадоксально, но самая большая помощь, которую Perl может оказать программисту, связана не столько с самим Perl, сколько с людьми, которые с ним работают. Сообщество Perl составляют люди, которые более чем кто-либо другой готовы прийти на помощь. Если считать, что в движении Perl есть что-то благочестивое, то оно лежит в самой его сердцевине. Ларри хотел, чтобы сообщество было чем-то вроде рая, и в целом его желание пока осуществляется. Внесите и свой вклад в то, чтобы оно таким и оставалось.

Возможно, вы изучаете Perl, поскольку хотите спасти мир либо просто из любопытства, либо вам приказал делать это ваш начальник - в любом случае этот учебник позволит познакомиться как с основами, так и со сложными вопросами. И хотя мы не намереваемся учить вас программированию, проницательный читатель что-то приобретет как от искусства, так и от науки программирования. Мы подстрекаем вас развивать в себе три великие добродетели программиста: лень, нетерпение и самомнение (laziness, impatience, hubris). Мы надеемся, что, читая эту книгу, вы найдете ее местами довольно занимательной (и местами очень занимательной). Если этого окажется недостаточно для того, чтобы вы не заснули, то постоянно напоминайте себе, что изучение Perl повысит ценность вашего резюме. Так что читайте дальше.

Что обновилось в этом издании

Пожалуй, почти все.

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

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

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

Часть 1 «Общий обзор»

Начать всегда труднее всего. В этой части базовые идеи Perl излагаются в неформальном виде - устройтесь поудобнее в вашем любимом кресле. Не будучи полным учебным руководством, эта часть просто предлагает быстрое начало, которое может потребоваться не каждому читателю. Поищите в разделе «Печатная документация)> книги, которые могут лучше соответствовать вашему стилю учебы.

Часть 2 «Анатомия Perl»

В этой части проводится глубокое и ничем не сдерживаемое обсуждение внутреннего устройства языка на всех уровнях абстракции - от типов данных, переменных и регулярных выражений до подпрограмм, модулей и объектов. Читатель получит хорошее представление о том, как работает язык, а также несколько советов по правильному проектированию программ. (А тех, кто никогда не использовал язык с поиском по шаблону, ждет особое удовольствие.)

Часть 3 «Perl как технология»

Многое можно делать с помощью одного только Perl, но в этой части вы достигнете более высокого уровня мастерства. Узнаете о том, как заставить Perl пройти через все препятствия, которые поставит перед ним ваш компьютер, - от обработки, взаимодействия процессов и многопоточное-

ти до компилирования, вызова, отладки и профилирования, а также создания собственных внешних расширений на С или C++ или интерфейсов к имеющимся API. Perl будет счастлив побеседовать с любым интерфейсом на вашем компьютере да, пожалуй, и любом другом компьютере в Интернете, если позволят погодные условия.

Часть 4 «Perl как культура»

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

Часть 5 Справочный материал

Здесь мы собрали главы, в которых читатель сможет найти что-либо в алфавитном порядке - от специальных переменных и функций до стандартных модулей и прагм. Глоссарий окажется особенно полезен тем, кто не знаком с жаргоном, используемым в вычислительной технике. Например, те, кто не знает, что такое «прагма», могут прямо сейчас посмотреть значение этого слова. (А тем, кто не знает значение слова «такое», мы не можем помочь ничем.)

Стандартный дистрибутив

В настоящее время большинство поставщиков операционных систем включают Perl в качестве стандартной составляющей своей системы. На момент написания данной книги Perl входит в стандартные дистрибутивы AIX, BeOS, BSDI, Debian, DG/UX, DYNIX/ptx, FreeBSD, IRIX, LynxOS, Mac OS X, OpenBSD, RedHat, SINIX, Slackware, Solaris, SuSE и Tru64. Некоторые компании поставляют Perl на отдельных CD с бесплатным программным обеспечением или через группы обслуживания клиентов. Сторонние поставщики, такие как ActiveState, предоставляют откомпилированные дистрибутивы для ряда операционных систем, в том числе производимых Microsoft.

Даже если поставщик включил Perl в стандартный дистрибутив, в конечном итоге, возможно, понадобится откомпилировать и установить Perl самостоятельно. В результате вы будете знать, что ваша версия является самой свежей, и сможете сами выбрать, куда установить библиотеки и документацию. Также можно будет решить, следует ли скомпилировать Perl с поддержкой дополнительных расширений, таких как многопоточность, большие файлы или множество низкоуровневых опций отладки, доступ к которым осуществляется через ключ командной строки <option>-D</option>. (Отладчик уровня пользователя поддерживается всегда.)

Проще всего загрузить комплект исходного кода Perl, указав броузеру домашнюю страницу на www.perLcom, где находятся также ссылки на компи-

лированные двоичные модули для платформ, компиляторы С для которых затерялись.

Можно также направиться прямо в СР AN (Comprehensive Perl Archive Network, архив Perl, описанный в главе 22 《CPAN») по адресу http:// wwiv.perLcom/CPAN или http://www.cpan.org. Если работа с ними окажется слишком медленной (а это может случиться, поскольку они очень популярны), следует найти зеркальный сервер CPAN поблизости от себя. Ниже приведены URL лишь некоторых из зеркал, разбросанных по всему свету и числом превышающих сотню:

http://www.funet.fi/pub/languages/perl/CPAN

ftp: / /ftp.funet.fi/pub/languages /perl/CPAN /

ftp: / /ftp.cs,colorado,edu/pub/perl/CPAN /

ftp://ftp.cise.uf Ledu/pub/perl/CPAN/

ftp://ftp.perl.org/pub/perl/CPAN/

http://www.perl.com/CPAN-local

http://www.cpan.org/

http://www.perLorg/CPAN/

http://www.cs.uu.nl/mirror/CPAN /

http: //CPAN ,pactfic,net,hk /

Первая парочка из этого списка на сайте funet.fi указывает на основное хранилище CPAN. Список всех остальных сайтов CPAN находится в файле МIRRORED.BY, поэтому лучше сначала скачать этот файл, а затем выбрать понравившееся зеркало. Доступ к одним осуществляется через FTP, к другим -через HTTP (если вы спрятались за корпоративным брандмауэром, это может иметь значение). Редиректор http://wwiv.perl.com/CPAN пытается сделать этот выбор вместо вас. При желании можно изменить свой выбор позже.

Получив исходный код и распаковав его в каталог, нужно прочесть файлы README и INSTALL, чтобы узнать, как скомпилировать и скомпоновать Perl. Может иметься и файл INSTALL.platform, где platform представляет платформу вашей операционной системы.

Если данная платформа является разновидностью Unix, то команды, необходимые для получения, конфигурирования, сборки и установки Perl, могут быть примерно следующие. Во-первых, необходимо выбрать команду, с помощью которой будет получен исходный код. Можно воспользоваться ftp :

% ftp ftp://ftp.funet.fi/pub/languages/perl/CPAN/src/latest.tar.gz

(He бойтесь заменить адрес на ближайшее зеркало CPAN. Конечно, если вы живете в Финляндии, то это и есть ваше ближайшее зеркало CPAN.) При невозможности воспользоваться ftp можно осуществить загрузку через Интернет с помощью броузера или средства командной строки:

% wget http://www.funet.fi/pub/languages/perl/CPAN/src/latest.tar.gz

Теперь нужно распаковать, сконфигурировать, собрать и установить:

% tar zxf latest.tar.gz% cd perl-5.6.0% sh Configure -des% make test && make install% tar zxf latest.tar.gz% cd perl-5.6.0% sh Configure -des% make test && make installИли сначала gunzip, tar xf.

% tar zxf latest.tar.gz

% cd perl-5.6.0

% sh Configure -des

% make test && make install

% tar zxf latest.tar.gz

% cd perl-5.6.0

% sh Configure -des

% make test && make install

Или 5.* для других версий.

Принимает ответы по умолчанию.

Установка обычно производится

суперпользователем.

При этом используется обычная среда разработки на С, так что если компилятора С на машине нет, скомпилировать Perl не удастся. Посмотрите в каталоге CPAN ports самые свежие данные по каждой платформе относительно поставки Perl вместе с дистрибутивом (и если так, то какой версии), возможности обойтись стандартным комплектом исходного кода или необходимости специального переноса. Ссылки для загрузки даются для тех систем, которые обычно требуют специальных переносов, или систем от поставщиков, для которых отсутствие компилятора С - нормальная практика (правильнее было бы сказать, «ненормальная» практика).

Электронная документация

Обширная электронная документация по Perl входит в состав его стандартного дистрибутива. (О бумажной документации говорится в следующем разделе.) Дополнительная документация появляется, как только устанавливается новый модуль из СР AN.

Упоминая в этой книге «страницу руководства Perl», мы имеем в виду комплект электронных страниц руководства по Perl, который находится на вашем компьютере. Под страницей электронного руководства (manpage) будем понимать просто файл с документацией, для чтения которого не обязательно иметь Unix-программу man. Страницы руководства Perl могут быть установлены даже как страницы HTML, особенно на системах, отличных от Unix.

Электронные страницы руководства по Perl разделены на несколько секций, поэтому можно легко найти нужное, не продираясь через сотни страниц текста. Поскольку страница верхнего уровня называется просто perl, то в Unix команда man perl должна привести именно на нее.1 Эта страница, в свою очередь, ведет на более специальные страницы. Например, man perlre выведет страницу руководства по регулярным выражениям Perl. Команда perldoc часто работает в тех системах, в которых не работает команда man. На компьютерах Macintosh следует выполнить команду Shuck. Конкретный перенос может также предоставлять страницы руководства по Perl в формате HTML или родном для системы формате подсказки. Уточните этот вопрос у своего системного администратора - если, конечно, сами не являетесь им.

Если при этом открывается нечто необозримое, то, вероятно, вы обращаетесь к древнему руководству версии 4. Проверьте, не указывает ли MANPATH на места, где можно производить археологические раскопки. (Введите perldoc perl, чтобы узнать, как настроить MANPATH соответственно выдаче команды perl -V:man,dir,)

Навигация по стандартным страницам руководства

В незапамятные времена (если говорить о Perl, то имеется в виду 1987 год) страница руководства perl была кратким документом объемом около 24 печатных страниц. Например, раздел по регулярным выражениям занимал всего два абзаца. (Этого было достаточно при условии знакомства с egrep.) В некоторых отношениях с тех пор изменилось почти все. Если считать стандартную документацию, различные утилиты, сведения о переносах на различные платформы и множество стандартных модулей, то наберется свыше 1500 печатных страниц документации, разбросанных по многим отдельным страницам электронного руководства. (И это без учета модулей из CPAN, которые могут быть у вас установлены, и в немалом количестве.)

Но в других отношениях не изменилось ничего: по-прежнему жива страница руководства perl и по-прежнему это лучшее место для начала, когда не известно, откуда начать. Разница в том, что, попав туда, нельзя остановиться. Документация 一 это больше не кустарное производство, это торговый пассаж с сотнями магазинов. Войдя в дверь, необходимо найти плакат, который поможет определить, где находится лавка или универсальный магазин, продающие то, зачем вы пришли. Конечно, освоившись в торговом центре, как правило, заранее знаешь, куда направиться.

Вот некоторые вывески:

Страница руководства

Что освещает

perl perldata perlsyn perlop perlre perlvar perlsub perlfunc perimod perlref perlobj perlipc perlrun perldebug perldiag

Какие страницы руководства по Perl имеются

Типы данных

Синтаксис

Операторы и их приоритеты

Регулярные выражения

Предопределенные переменные

Подпрограммы

Встроенные функции

Как использовать модули Perl

Ссылки

Объекты

Межпроцессное взаимодействие

Как выполнять команды Perl плюс ключи

Отладка

Диагностические сообщения

Это лишь небольшой отрывок, но он состоит из важных частей. Как видно, если нужны сведения об операторе, то для этого подойдет perlop. А если ну ж-

но что-то выяснить о предопределенных переменных, следует искать в perl- var. Если получено непонятное диагностическое сообщение, идите на perl- diag. И так далее.

В стандартное руководство по Perl входит список часто задаваемых вопросов (FAQ). Он разбит на следующие девять разных страниц:

Страница руководстваperlfaqlperlfaq2perlfaq3perlfaq4perlfaq5perlfaq6perlfaq7perlfaq8perlfaq9Страница руководстваperlfaqlperlfaq2perlfaq3perlfaq4perlfaq5perlfaq6perlfaq7perlfaq8perlfaq9Что освещает

Страница руководства

perlfaql

perlfaq2

perlfaq3

perlfaq4

perlfaq5

perlfaq6

perlfaq7

perlfaq8

perlfaq9

Страница руководства

perlfaql

perlfaq2

perlfaq3

perlfaq4

perlfaq5

perlfaq6

perlfaq7

perlfaq8

perlfaq9

Общие вопросы по Perl

Получение Perl и сведения о нем Инструменты программирования Обработка данных Файлы и форматы Регулярные выражения Общие вопросы языка Perl Взаимодействие с системой Сетевое взаимодействие

Некоторые страницы руководства содержат замечания по специфике платформ:

Страница руководства perlamiga perlcygwin perldos perlhpux perlmachten perlos2 perlos390 perlvms perlwin32Страница руководства perlamiga perlcygwin perldos perlhpux perlmachten perlos2 perlos390 perlvms perlwin32Что освещает

Страница руководства perlamiga perlcygwin perldos perlhpux perlmachten perlos2 perlos390 perlvms perlwin32

Страница руководства perlamiga perlcygwin perldos perlhpux perlmachten perlos2 perlos390 perlvms perlwin32

Перенос на Amiga

Перенос на Cygwin

Перенос на MS-DOS

Перенос на HP-UX

Перенос на Power MachTen

Перенос на OS/2

Перенос на OS/390

Перенос на DEC VMS

Перенос на MS-Windows

(Относительно переносов см. также главу 25 «Переносимость программ Perl» и каталог CPANports, описанный выше.)

Поиск на страницах электронного руководства

Нет необходимости читать все 1500 печатных страниц, чтобы найти иголку в стоге сена. Старая поговорка гласит, что нельзя «грепнуть» (grep) мертвое дерево.1 Кроме обычных средств поиска, присутствующих в большинстве

Не забудьте, что при необходимости можно заглянуть в глоссарий.

программ просмотра документов, в версии 5.6.1 каждая основная страница руководства имеет собственные средства поиска и отображения. Можно осуществлять поиск в отдельных страницах, используя имя страницы руководства в качестве команды и передавая регулярное выражение Perl (см. главу 5 «Поиск по шаблону») в качестве шаблона для поиска:

% perlop comma

% perlfunc split

% perlvar ARGV

% perldiag 'assigned to typeglob'

Если не известно точно, в каком месте документации находятся требующиеся сведения, можно расширить поиск. Например, для поиска во всех FAQ воспользуйтесь командой perlfaq (которая тоже является страницей руководства):

% perlfaq round

Команда perltoc (которая тоже является страницей руководства) осуществляет поиск в общем для всех страниц руководства оглавлении:

% perltoc typeglob

perl5005delta: Undefined value assigned to typeglob perldata: Typeglobs and Filehandles

perldiag: Undefined value assigned to typeglob

Можно также проводить поиск во всем электронном руководстве по Perl, включая заголовки, описания и примеры, используя команду perlhelp:

% perlhelp CORE::GLOBAL

Подробности см. в странице руководства по perldoc.

Страницы руководства, не принадлежащие Perl

Когда мы ссылаемся на документацию, не принадлежащую Perl, как в getiti- тег(2), ссылка указывает на страницу руководства getitimer из раздела 2 Unix Programmer s Manual. Страницы руководства для системных вызовов, таких как getitimer, могут отсутствовать на системах, отличных от Unix, но это может быть и правильно, потому что системные вызовы на них все равно нельзя использовать. Для тех, кому действительно требуется документация

по команде, системному вызову или библиотечной функции Unix, скажем, что многие организации поместили свои страницы руководства в Интернете. Задав поиск «+crypt(3)+manual» на AltaVista, можно найти много адресов.

Хотя страницы руководства по Perl верхнего уровня обычно устанавливаются в секции 1 стандартных каталогов тал, мы не будем добавлять (1) к названиям таких страниц руководства в нашей книге. Их легко узнать, поскольку они имеют вид «рег1бубубу».

Печатная документация

Тем, кто хочет больше узнать про Perl, рекомендуем некоторые издания:

Perl 5 Pocket Reference, 3d ed., by Johan Vromans, O'Reilly, 2000 (Карманный справочник no Perl, 3-е изд., Йохан Вроманс). Эта маленькая брошюра служит удобным справочником по Perl.

Perl Cookbook, by Tom Christiansen and Nathan Torkington, O'Reilly, 1998 («Perl: библиотека программиста», T. Кристиансен, Н. Торкингтон, изд- во «Питер», 2000). Эта книга дополняет ту, которую вы сейчас держите в руках.

Elements of Programming with Perl, by Andrew L. Johnson Manning, 1999 (Программирование на Perl, Эндрью Л. Джонсон). Эта книга предназначена для обучения с азов непрограммистов тому, как нужно программировать вообще и делать это с помощью Perl в частности.

Learning Perl, 2d ed., by Randal Schwartz and Tom Christiansen, O'Reilly, 1997 («Изучаем Perl», P. Шварц, T. Кристиансен, BHV-Киев). Эта книга научит системных администраторов и программистов для Unix 30 основным процентам Perl, которые им понадобятся в 70 процентах случаев. Эрик Олсон (Erik Olson) переработал эту книгу, создав вариант для программистов на системах Microsoft под названием Learning Perl for Win32 Systems.

Perl: The Programmer s Companion, by Nigel Chapman, Wiley, 1997 (Perl: спутник программиста, Найджел Чапмен). Эта чудесная книга предназначена для профессионалов в вычислительной технике и программировании безотносительно к используемой платформе. Perl освещается кратко, но полно.

Mastering Regular Expressions, by Jeffrey Friedl, O'Reilly, 1997 («Регулярные выражения. Библиотека программиста», Д. Фридл, изд-во «Питер», 2001). Хотя в книге не освещены последние нововведения в регулярных выражениях Perl, она является ценным справочником для всех, кто хочет знать, как в действительности работают регулярные выражения.

Object Oriented Perl, by Damian Conway, Manning, 1999 (Объектно-ориентированный Perl, Дамиан Конвей). Для начинающих и опытных разработчиков объектно-ориентированных программ. Эта удивительная книга

излагает обычные и тайные приемы создания мощных объектных систем на Perl.

Mastering Algorithms with Perl, by Jon Orwant, Jarkko Hietaniemi, and John Macdonald, O'Reilly, 1999 (Perl: алгоритмы, Джон Орвант, Йаркко Хьетаниеми н Джон Макдональд). Все полезные приемы из курса вычислительных алгоритмов, но без тягостных доказательств. Книга освещает фундаментальные и полезные алгоритмы, относящиеся к графам, текстам, множествам и ряду других областей.

Writing Apache Modules with Perl and C, by Lincoln Stein and Doug MacEac- hern, O'Reilly, 1999 (Разработка модулей Apache на Perl и С, Л. Штайн). Это руководство по веб-программированию учит тому, как расширить возможности веб-сервера, особенно с использованием модуля mod_perl для создания быстро выполняющихся сценариев CGI и доступа из Perl к Apache API.

The Perl Journal, редактируемый Джоном Орвантом (Jon Orwant). Этот ежеквартальный журнал, издаваемый программистами и для программистов, регулярно публикует глубокие материалы по программированию, технические приемы, последние новости и прочее.

Существует много других книг и публикаций по Perl, и по старческой дряхлости мы наверняка позабыли упомянуть некоторые хорошие. (Из милосердия мы пренебрегли обязанностью отметить некоторые плохие издания.)

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

The Art of Computer Programming, by Donald Knuth, vol. 1, Fundamental Algorithms; vol. 2, Seminumerical Algorithms; vol. 3, Sorting and Searching, Addison-Wesley, 1998.

Introduction to Algorithms, by Cormen, Leiserson, and Rivest MIT Press and McGraw-Hill, 1990 (Введение в алгоритмы, Кормен, Лейзерсон и Рай- вест).

Algorithms in С: Fundamental Data Structures, Sorting, Searching, 3d ed., by Robert Sedgewick, Addison-Wesley, 1997 («Фундаментальные алгоритмы на C++. Анализ, структуры данных, сортировка, поиск», 3-е издание, Р. Седжвик, изд-во «Диасофт»).

The Elements of Programming Style, by Kernighan and Plauger, PrenticeHall, 1988 (Элементы стиля программирования, Керниган и Плаугер).

The Unix Programming Environment, by Kernighan and Pike, PrenticeHall, 1984 (Среда разработки Unix, Керниган и Пайк).

POSIX Programmer s Guide, by Donald Lewine, O'Reilly, 1991 (Posix: руководство программиста, Д. Левин).

Advanced Programming in the UNIX Environment, by W. Richard Stevens, Addison-Wesley, 1992 (Профессиональное программирование в среде Unix, У. Сивенс).

TCP/IP Illustrated, vols. 1-3, by W. Richard Stevens, Addison-Wesley, 1994-1996 (Иллюстрированный TCP/IP, У. Стивенс).

The Lord of the Rings, by J. R. R. Tolkien (последнее издание: Houghton Mifflin, 1999).

Дополнительные источники

Интернет - чудесное изобретение, и все мы продолжаем открывать возможности его наиболее полного использования. (Конечно, некоторые предпочитают «открывать» Интернет так, как Толкиен открывал Центр Земли.)

Perl в Сети

Посетите домашнюю страницу Perl http://www.perl.coml. На ней рассказывается, что нового есть в мире Perl, содержатся исходные коды и переносы, тематические статьи, документация, расписания конференций и многое другое. Посетите также веб-страницу Perl Mongers http://www.perl.org, чтобы взглянуть на Perl с точки зрения широких масс, так сказать, на «корни», которые бурно разрастаются во всех частях света, за исключением Южного полюса, где их приходится держать в закрытом помещении. Местные группы РМ проводят регулярные небольшие встречи, на которых можно обменяться профессиональным опытом с другими хакерами Perl, живущими в той же части света.

Телеконференции (группы новостей Usenet)

Телеконференции Perl служат огромным, хотя подчас беспорядочным, источником сведений о Perl. Начать можно с compdang.perLmoderated 一 модерируемой телеконференции с невысоким потоком сообщений, содержащей объявления и технические дискуссии. Благодаря модерированию телеконференция вполне читаема.

Группа comp.lang.perl.misc с интенсивным потоком сообщений обсуждает все ~ от технических вопросов до философии Perl, игр Perl и поэзии Perl. Как и сам Perl, compdang.perl.misc предназначена для пользы, и в ней можно задать любой глупый вопрос.

В группе complang.perl.tk обсуждается, как применять в Perl популярный комплект Тк. Группа comp.lang.perl.modules обсуждает разработку и использование модулей Perl, которые служат лучшим способом создания повторно используемого кода. Когда вы будете читать эту книгу, могут появиться новые телеконференции сотрЛапё.регкнечто^ поэтому поищите их.

Если для доступа в Usenet используется не обычная программа чтения новостей, а веб-броузер, введите "news:" и имя телеконференции, чтобы получить доступ к одной из указанных здесь телеконференций. (Это возможно, только если у вас есть доступ к серверу новостей.) В другом варианте, если для поиска в Usenet используются такие службы, как AltaVista или Deja, укажите "*perl*" в качестве телеконференций, которые нужно найти.

Другой телеконференцией, материалы которой могут понадобиться, по крайней мере, тем, кто занимается CGI-программированием для Интернета, является comp.infosystems.www.authoring.cgi. Хотя, строго говоря, это не группа Perl, большинство обсуждаемых в ней программ написаны на Perl. К ней полезно обратиться по вопросам Perl, связанным с Сетью, если только вы не используете mod_perl под Apache; тогда можно подписаться на сотрлп- fosystems.www.servers.unix.

Сообщения об ошибках

В том маловероятном случае, если ошибка обнаружена в самом Perl, а не в вашей программе, нужно постараться воспроизвести ее в минимальном по объему контрольном примере и сообщить о ней с помощью программы perl- bug^ поставляемой с Perl. Дополнительные сведения можно найти на http:// bugs,perl.org.

Соглашения, принятые в этой книге

Некоторые из принятых нами соглашений более подробно обсуждаются в соответствующих местах. Соглашения по коду обсуждаются в разделе «Стиль программирования» главы 24 «Распространенные приемы программирования». В некотором смысле наши лексические соглашения представлены в глоссарии (наш словарь).

В книге приняты следующие типографские соглашения:

Курсив

Предназначен для URL, страниц руководства, маршрутов и программ. Новые термины тоже выделяются курсивом при первом появлении в тексте. Для многих из этих терминов можно найти альтернативные определения в глоссарии, если недостаточно тех, которые имеются в тексте.

Моноширинный

Используется в примерах и в обычном тексте для вывода кода. Данные обозначаются моноширинным шрифтом и заключаются в кавычки (””), не являющиеся частью значения.

Моноширинный полужирный

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

Моноширинный курсив

Служит для обозначения общих элементов кода, вместо которых необходимо подставить конкретные значения.

Мы приводим массу примеров, большинство из которых представляют собой фрагменты более крупных программ. Некоторые примеры являются завершенными программами, что можно увидеть по начальной строке #!. Почти все наши более длинные программы начинаются со строки:

#!/usr/bin/perl

В других примерах приводится текст, который следует ввести в командной строке. Мы используем % для обозначения приглашения оболочки:

% perl -е 'print "Hello, world.\n"' Hello, world.

Этот стиль - типичный образец стандартной командной строки Unix, в которой одиночные кавычки представляют «наиболее закавыченный» формат. На других системах соглашения по использованию кавычек и символов заполнителей могут быть иными. Например, многие интерпретаторы команд в MS-DOS и VMS требуют двойные, а не одиночные кавычки при задании аргументов, содержащих пробелы и символы-заполнители.

Благодарности

Здесь мы публично приносим благодарность нашим рецензентам, что должно компенсировать все грубости, сказанные им в частном порядке. Это: Тод Миллер (Todd Miller), Шэрон Хопкинс Рауэзан (Sharon Hopkins Rauenzahn), Рич Рауэнзан (Rich Rauenzahn), Пол Маркес (Paul Marquess), Пол Грасси (Paul Grassie), Натан Торкингтон (Nathan Torkington), Йохан Вроманс (Johan Vromans), Джефф Хемер (Jeff Haemer), Гурусами Сарати (Gurusamy Sarathy), Глория Уолл (Gloria Wall), Дэн Сугальский (Dan Sugalski) и Эби- гайл (Abigail).

Хотим выразить особую благодарность Тиму О'Рейли (Tim O'Reilly) и его Associates за побуждение авторов к написанию книг, которые читателям приятно читать.

Хотим услышать ваши отзывы

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

O'Reilly & Associates, Inc.

101 Morris Street Sebastopol, CA 95472

1-800-998-9938 (в США и Канаде)

1-707-829-0515 (международный/местный)

1-707-829-0104 (факс)

Можно также посылать сообщения электронной почтой. Чтобы быть включенным в наш лист почтовой рассылки или запросить каталог, посылайте письма по адресу info@oreilly.com. Чтобы задать технический вопрос или сообщить свои комментарии по поводу этой книги, шлите почту по адресу bookquestions@oreilly.com.

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

http://www.oreillii.com/catalog/pperl3

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

Общий обзор

1

Обзор Perl

Введение

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

print "Howdy, world!\n";

и программа это сделает.

Таким языком и является Perl. На практике этот пример представляет собой законченную программу, и если послать ее интерпретатору Perl, тот выведет на экран "Howdy, world". (\п в этом примере обеспечивает перевод строки в конце вывода.)

Вот и все. После того как вы сказали то, что хотели, тоже не требуется произносить много слов. В отличие от многих языков программирования, Perl считает» что «вывалиться» из программы 一 нормальный способ ее завершения. Конечно, при желании вы можете явно вызвать функцию exit, как можете и объявить некоторые переменные, либо даже сделать обязательным объявление всех переменных. Но право выбора принадлежит вам. В Perl можно поступать «так, как должно», как бы вы это ни определили.

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

Эта глава представляет собой обзор, поэтому мы не пытаемся представить Perl с рациональной стороны. Равно как не претендуем на полноту изложения или логичность. Для этого предназначены следующие главы. Вулканическим натурам, андроидам и другим аналогично настроенным лицам следует пропустить этот обзор и перейти сразу к главе 2 «Всякая всячина», где плотность информации выше. С другой стороны, тем, кому нужен учебник с тщательно выстроенным продвижением вперед, возможно, следует обратиться к прекрасной книге Рэндала Шварца (Randal Schwartz) «Learning Perl» (опубликованную O'Reilly & Associates). Но и данную книгу пока не выбрасывайте.

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

Естественные и искусственные языки

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

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

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

Когда кто-то произносит слово «лингвистика», у многих возникает одно из двух представлений: либо они начинают думать о словах, либо начинают думать о предложениях. Но слова и предложения являются лишь двумя удобными способами членения речи. Те и другие можно разбить на более мелкие смысловые единицы или объединить в более крупные. А смысл каждой единицы существенно зависит от синтаксического, семантического и практического контекста, в котором находится эта единица. В естественном языке есть слова разных видов: существительные, глаголы и т. д. Если произнести слово «dog» (собака) изолированно, в отрыве от контекста, представляется существительное, хотя можно использовать это слово и в другом смысле. Это значит, что существительное может выполнять функции глагола, прилагательного или наречия, в зависимости от контекста. If you dog a dog during the dog days of summer, you11 be a dog tired dogcatcher.1

Perl также по-разному оценивает слова в зависимости от контекста. Далее мы увидим, как он это делает. Помните просто, что Perl пытается понять, о чем идет речь, как это делает любой хороший слушатель. Perl усиленно старается соблюсти со своей стороны условия сделки. Скажите просто, чего вы хотите, и Perl обычно «сообразит». (Если только вы не говорите чепухи - анализатор Perl понимает Perl значительно лучше, чем английский или суахили.)

Но вернемся к существительным. Существительное может быть именем конкретного объекта или родового класса объектов без указания того, на который из них производится ссылка в данный момент. Это различие проводится в большинстве языков программирования, когда конкретная величина называется значением, а общая 一 переменной. Значение где-то существует,

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

Синтаксис переменных

Переменная является просто удобным способом хранения чего-либо, именованным местонахождением, в котором программист может найти нечто требующееся ему, когда оно позднее понадобится. Как и в реальной жизни, есть разного типа места для хранения, одни из которых достаточно скрыты, а другие открыты для всех. Некоторые хранилища временные, а другие - более постоянные. Ученые в области вычислительной техники любят говорить об «области видимости» переменных, подразумевая под этим выражением именно то, что в нем сказано. В Perl имеются достаточно удобные средства решения проблем области видимости, с которыми читатель в свое время будет иметь удовольствие познакомиться. Оно еще не наступило. (Те, кто испытывает любопытство, могут поискать прилагательные local, my и our в главе 29 «Функции», либо заглянуть в раздел «Объявления, ограниченные областью видимости» главы 4 «Операторы и объявления».)

В данный момент полезнее провести классификацию переменных по типу данных, которые они могут содержать. Как и в английском языке, в Perl основное различие проводится между данными в единственном и во множественном числе. Строки и числа являются данными в единственном числе, а списки строк или чисел - во множественном. (А когда мы доберемся до объектно-ориентированного программирования, вы обнаружите, что типичный объект выглядит единичным снаружи, но множественным изнутри - как группа студентов.) Переменную в единственном числе мы называем скаляром, а во множественном - массивом. Поскольку строка может храниться в скалярной переменной, можно написать такую несколько более длинную (и снабженную комментариями) версию нашего первого примера:

$phrase = "Howdy, world!\n"; # Присвоить значение переменной.

print $phrase; # Вывести переменную

Обратите внимание, что нам не пришлось предварительно определять, какой тип имеет переменная $phrase. Символ $ указывает Perl на то, что phrase представляет собой скалярную переменную, т. е. содержит единственное значение. Напротив, массив должен начинаться с символа @・(Запоминание облегчается тем, что $ является стилизованным «s», от «scalar», тогда как @ 一 это стилизованное «а», от «array».)

В Perl имеются некоторые другие типы переменных с такими непривлекательными именами, как «хеш» (hash), «дескриптор» (handle) и «запись таблицы имен» (typeglob). Подобно скалярам и массивам, переменным этих типов также предшествуют разыменовывающие префиксы (funny characters - забавные символы). Вот полный список разыменовывающих префиксов, которые могут вам встретиться:

Тип

Символ

Пример

Что обозначает

Скаляр

$

$cents

Отдельное значение (число или строку)

Массив

@

@1агде

Список значений с числовым ключом

Хеш

%

%interest

Группа значений, ключом доступа к которым служит строка

Подпрограмма

&

&how

Фрагмент кода Perl, который может быть вызван

Typeglob

★

★struck

Все, что имеет имя struck

Некоторые пуристы языка указывают на эти разыменовывающие префиксы как на причину отвращения к Perl. Это поверхностный взгляд. У этих символов много достоинств, не последним из которых является возможность подстановки, или интерполяции (interpolation), этих символов в строки без всякого дополнительного синтаксиса. Кроме того, сценарии Perl легко читать (тем, кто взял на себя труд изучить Perl!), поскольку существительные отличаются от глаголов. В язык могут добавляться новые глаголы без ущерба для старых сценариев. (Мы уже говорили, что в Perl на этапе проектирования была заложена возможность развития.) И аналогия с существительными приведена не зря: есть масса примеров в английском и других языках, когда требуются грамматические маркеры существительных. Вот так мы думаем! (Мы думаем.)

Единственное число

В приведенном выше примере мы видели, что скаляру можно присваивать новое значение с помощью оператора 二 подобно тому, как это делается во многих других языках программирования. Скалярным переменным можно присваивать скалярные значения любого вида: целые числа, числа с плавающей запятой, строки и даже такие таинственные вещи, как ссылки на другие переменные или объекты. Есть много способов создания этих значений, которые должны присваиваться.

Как и в оболочке Unix, можно использовать различные механизмы расстановки кавычек для создания значений разного вида. Двойные кавычки (double quotes) производят интерполяцию переменных и интерполяцию обратной косой черты (например, превращение \п в символ перевода строки), тогда как одиночные кавычки подавляют интерполяцию. А обратные

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

$answer 二 42;$pi 二 3.14159265;$avocados = 6.02e23;$pet = "Camel";$sign = "I love my $pet";$cost = 'It costs $100';$thence 二 $whence;$salsa 二 $moles * Savocados;$exit 二 system("vi $file");$cwd 二 'pwd':$answer 二 42;$pi 二 3.14159265;$avocados = 6.02e23;$pet = "Camel";$sign = "I love my $pet";$cost = 'It costs $100';$thence 二 $whence;$salsa 二 $moles * Savocados;$exit 二 system("vi $file");$cwd 二 'pwd':целое число

$answer 二 42;

$pi 二 3.14159265;

$avocados = 6.02e23;

$pet = "Camel";

$sign = "I love my $pet";

$cost = 'It costs $100';

$thence 二 $whence;

$salsa 二 $moles * Savocados;

$exit 二 system("vi $file");

$cwd 二 'pwd':

$answer 二 42;

$pi 二 3.14159265;

$avocados = 6.02e23;

$pet = "Camel";

$sign = "I love my $pet";

$cost = 'It costs $100';

$thence 二 $whence;

$salsa 二 $moles * Savocados;

$exit 二 system("vi $file");

$cwd 二 'pwd':

"действительное" число

научное обозначение

строка

строка с интерполяцией

строка без интерполяции

значение другой переменной

гастрохимическое выражение

числовой статус выполнения команды

строка выдачи команды

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

$агу 二

\@myarray;#

ссылка

на

именованный массив

$hsh 二

\%myhash;#

ссылка

на

именованный хеш

$sub =

\&mysub;#

ссылка

на

именованную подпрограмму

$агу =

[123,4,5];#

ссылка

на

анонимный массив

$hsh =

{Na => 19, Cl => 35}; #

ссылка

на

анонимный хеш

$sub 二

sub { print $state }; #

ссылка

на

анонимную подпрограмму

$fido :

二 new Camel "Amelia"; #

ссылка

на

объект

Если используется переменная, которой еще ни разу не присваивалось значение, то неинициализированная переменная автоматически начинает существовать, когда в ней возникает необходимость. В соответствии с принципом минимизации неожиданности переменная создается с нулевым значением: ""или 0. В зависимости от контекста использования, переменные автоматически интерпретируются как строки, числа или значения «true» (истина) или «false» (ложь), обычно называемые булевыми значениями. Вспомните, как важен контекст в естественном языке. В Perl разные операторы предполагают получение в качестве параметров различного вида одиночных значений, и мы будем говорить, что данные операторы предоставляют для этих параметров скалярный контекст. Иногда мы будем более конкретно говорить, что оператор предоставляет числовой, строковый или булев контекст для этих параметров. (Ниже мы расскажем о списочном контексте, который противопоставляется скалярному.) Perl автоматически преобразует данные к виду, требуемому текущим контекстом, в соответствии со здравым смыслом. Предположим, например, что вы сказали следующее:

$camels 二'123';

print $camels + 1, "\n";

Первоначальным значением $camels является строка, но она преобразуется в число, чтобы прибавить к ней единицу, а затем обратно в строку, чтобы вы-

вести ее как 124. Символ перевода строки, представленный "\п", тоже находится в строковом контексте, но поскольку он изначально является строкой, преобразование не требуется. Обратите, однако, внимание на двойные кавычки: использование одиночных кавычек, т. е. '\п', привело бы к появлению строки из двух символов, а именно косой черты и «п», которая никак не может представлять перевод строки.

Итак, в некотором смысле двойные и одиночные кавычки предоставляют еще один способ задания контекста. Интерпретация содержимого закавыченной строки зависит от того, какого вида кавычки используются. (Далее мы рассмотрим некоторые другие операторы, синтаксически работающие как кавычки, но использующие строку некоторым особым способом, например, для поиска по шаблону или подстановки. Все они тоже действуют как строки в двойных кавычках. Контекст двойных кавычек является в Perl «интерполирующим» и предоставляется многими операторами, которые не напоминают двойные кавычки.)

Аналогично ссылка ведет себя как ссылка в «разыменовывающем» контексте и как обычная скалярная величина в других случаях. Например, можно сказать так:

$fido = new Camel "Amelia";

if (not $fido) { die "dead camel"; } $fido->saddle();

Здесь создается ссылка на объект Camel, которая помещается в переменную $fido. В следующей строке мы проверяем значение $fido как булевой величины на равенство «true» и возбуждаем исключительную ситуацию (т. е. жалуемся, что она не истинна); в данном случае это означает, что конструктор new Camel не смог создать требуемый объект Camel. Однако в последней строке мы обращаемся с $fido как со ссылкой, запрашивая метод saddle() для объекта, содержащегося в $fido и представляющего собой Camel, поэтому Perl ищет метод saddle() для объектов Camel. Подробнее об этом сказано ниже. Сейчас просто запомните, что в Perl важен контекст, поскольку благодаря ему Perl узнает, что вам требуется, без ваших явных указаний, необходимых во многих других языках программирования.

Множественное число

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

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

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

Массивы. Массив 一 это упорядоченный список скаляров, к которым обращаются по их местоположению в списке. Список может содержать числа, строки или смесь того и другого. (Он может также содержать ссылки на вложенные массивы (субмассивы) и вложенные хеши (субхеши).) Чтобы присвоить массиву значение в виде списка, нужно просто объединить вместе значения с помощью круглых скобок:

@home 二("кушетка", "стул", "стол", "печка");

И наоборот, используя @home в списочном контексте, например, с правой стороны присвоения списку, мы получим на выходе тот самый список, который ввели. Например, присвоить значения, взятые из массива, четырем скалярным переменным можно так:

($potato, $lift, $tennis, $pipe) = @home;

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

($alpha,$omega) = ($omega,$alpha);

Как и в языке С, нумерация массивов начинается с нуля (zero-based), поэтому, работая с элементами массива с первого по четвертый, следует обращаться к ним по индексам от 0 до З. Индексы массивов заключаются в квадратные скобки [вот такие], поэтому при выборе отдельного элемента массива нужно ссылаться на него так - $home[n], где п является значением индекса (на единицу меньшим номера элемента), который нам нужен. Посмотрите на следующий пример. Поскольку мы имеем дело со скалярным элементом, ему обязательно должен предшествовать символ $.

Если вы хотите присваивать значения элементам массива по одному, предшествующее присвоение можно записать так:

$home[0] = "кушетка";

$home[1] = "стул";

$home[2] = "стол";

$home[3] = "печка";

Поскольку массивы упорядочены, над ними можно выполнять полезные действия, такие как операции со стеком push и pop. Стек, в сущности, является просто упорядоченным списком с началом и концом. С концом в особенности. Perl рассматривает конец массива как вершину стека. (Хотя большинство программистов на Perl представляют себе массивы горизонтальными, с вершиной стека, находящейся справа.)

Хеши, Хеш представляет собой неупорядоченный набор скаляров, к которым обращаются по некоторому строковому значению, связанному с каждым скаляром. По этой причине хеши часто называют ассоциативными массивами. Но это слишком длинное название для ввода с клавиатуры, а говорится о них так часто, что мы решили дать им какое-нибудь краткое и броское название. Другой причиной, по которой мы выбрали название 《хеш», является желание подчеркнуть тот факт, что они неупорядочены. (Так совпало, что в их внутренней реализации используется поиск по хеш- таблице, в результате чего работа с ними происходит столь быстро вне зависимости от числа помещенных в них значений.) Однако применить к хешу push или pop нельзя: это не имеет смысла. У хеша нет начала и конца. Тем не менее, хеши являются очень мощным и полезным средством. Пока вы не начали думать на языке хешей, вы, в сущности, не начали думать на Perl. На рис. 1.1 показаны упорядоченные элементы массива и неупорядоченные (но поименованные) элементы хеша.

%longday

Рис, 1 Л. Массив и хеш

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

Предположим, вы хотите перевести сокращенные названия дней в соответствующие полные. Можно записать такое присвоение списка:

%longday = ("Вс", "Воскресенье", "Пн", "Понедельник", "Вт", "Вторник", "Ср", "Среда", "Чт", "Четверг", "Пт", "Пятница'', ''Сб", ''Суббота");

Но это довольно трудно читается, поэтому Perl предоставляет последовательность => (знак «равно», знак «больше») в качестве разделителя, альтернативного запятой. С использованием этой синтаксической поблажки (и творческого форматирования) становится значительно легче различить, какие строки являются ключами, а какие - связанными с ними значениями:

%longday =(

"Вс" => "Воскресенье",

"Пн" => "Понедельник",

"Вт" => "Вторник",

“Ср” => "Среда",

"Чт" => "Четверг", "Пт" => "Пятница", "Сб" => "Суббота", )；

Можно не только присваивать список хешу, как мы сделали выше, но, если хеш упоминается в списочном контексте, последний преобразует хеш обратно в список пар «ключ/значение», правда, в причудливом порядке. Иногда это оказывается полезным. Чаще требуется извлечь список, состоящий только из ключей, для чего применяется функция, уместно названная keys. Список ключей тоже неупорядочен, но при желании его легко можно отсортировать с помощью столь же удачно названной функции sort. После этого упорядоченные ключи можно использовать для извлечения соответствующих значений в требуемом порядке.

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

ние, ассоциированное со средой (Ср), следует использовать $longday{"Cp"}. Снова обратите внимание на то, что мы имеем дело со скалярной величиной, поэтому идентификатор начинается символом $, а не %, что указывало бы на весь хеш целиком.

Лингвистически, закодированная в хеше связь аналогична родительному падежу или притяжательному местоимению, как слово «of» в английском языке или как «s». Женой Адама является Ева, поэтому мы пишем:

$wife{"AflaM"} = "Ева";

Сложности

Массивы и хеши являют собой прелестные, простые, плоские структуры данных. К несчастью, окружающий мир не всегда идет навстречу нашим попыткам чрезмерного упрощения. Иногда приходится создавать не столь прелестные, простые и плоские структуры данных. Perl позволяет осуществлять это, «делая вид», что сложные величины на самом деле являются простыми. Или другими словами, Perl позволяет манипулировать простыми скалярными ссылками, которые указывают на сложные массивы и хеши. В естественном языке мы занимаемся этим постоянно, когда используем простое существительное в единственном числе, например, «правительство» для обозначения объекта, который совершенно «закручен» и непостижим. Помимо всего прочего.

Расширим наш предыдущий пример, предположив, что вместо жены Адама мы хотим поговорить о жене Иакова. Известно, что у Иакова было четыре жены. (Проверять на себе это не нужно.) Пытаясь представить это на Perl, мы оказываемся в необычном положении, в котором хотим изобразить, что четыре жены Иакова в действительности являются одной женой. (Это тоже не надо проверять на себе.) Читатель может решить, что допустима такая запись:

$wife{"Иаков"} = ("Лия", "Рахиль", "Валла", Зелфа"); # НЕВЕРНО

Но в результате мы не получим того, что требуется, потому что в Perl даже скобки и запятые бессильны превратить список в скаляр. (Скобки предназначены для синтаксического объединения, а запятые - для синтаксического разделения.) Вместо этого необходимо явно сообщить Perl, что список требуется представить в виде скаляра. Оказывается, что достаточной силой для этого обладают квадратные скобки:

$wife{"HaKOB"} = ["Лия", "Рахиль", "Валла", Зелфа"]; # ок

Эта команда создает анонимный массив и помещает ссылку на него в элемент хеша $wife{"MaKOB"}. В результате получаем именованный хеш, содержащий анонимный массив. Таким способом Perl работает с многомерными массивами и вложенными структурами данных. Как и в обычных массивах и хешах, можно присваивать значения отдельным элементам наподобие следующего:

$wife{"HaKOB"}[0] = "Лия";

$wife{"HaK0B"}[1] 丁 "Рахиль''

$wife{"HaK0B"}[2] = "Валла";

$wife{"HaK0B"}[3] = "Зелфа";

Как видите, это похоже на многомерный массив, одним индексом которого является строка, а другим - число. Чтобы показать нечто более похожее по структуре на дерево, типа вложенных структур данных, предположим, что мы хотим перечислить не только жен Иакова, но и всех сыновей каждой из его жен. В этом случае надо обращаться с хешем как со скаляром. Для этого можно использовать скобки. (Внутри каждого значения хеша мы, как и раньше, будем применять для представления массивов квадратные скобки. Но теперь у нас массив, содержащийся в хеше, содержащемся в хеше.)

Завулон"],Завулон"],$kids_of_wife{"Иаков"} = {

Завулон"],

Завулон"],

"Лия" => ["Рувим", "Симеон", "Левий", "Иуда", "Иссахар", "Рахиль" => ["Иосиф", "Вениамин"],

"Валла" => ["Дан", "Неффалим"], "Зелфа" => ["Гад", "Асир"],

｝；

Это более или менее эквивалентно следующему:

$kids_of_wife{

'Иаков'

}{"Лия"}[0]=

"Рувим";

$kids_of_wife{

'Иаков'

}{"Лия"}[1]=

"Симеон";

$kids_of_wife{

'Иаков'

}{"Лия"}[2]=

"Левий";

$kids_of_wife{

'Иаков'

}{"Лия"}[3]=

"Иуда";

$kids_of_wife{

'Иаков'

}{"Лия"}[4] 二

"Иссахар";

$kids_of_wife{

'Иаков'

}{"Лия"}[5]=

"Завулон";

$kids_of_wife{

'Иаков'

} {"Рахиль"}[0]=

"Иосиф";

$kids_of_wife{

'Иаков'

}{"Рахиль"}[1]二

"Вениамин;

$kids_of_wife{

'Иаков'

}{"Валла"}[0]二

"Дан";

$kids_of_wife{

'Иаков'

}{"Валла"}[1]二

"Неффалим"

$kids_of_wife{

'Иаков'

}{"Зелфа"}[0]=

"Гад";

$kids_of_wife{

'Иаков'

}{"3елфа"}[1]二

"Асир";

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

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

$fido = new Camel "Amelia";

то создавали объект Camel, представляемый скаляром $fido. Но внутреннее строение Camel является более сложным. Как воспитанные объектно-ориентированные программисты, мы не должны интересоваться содержимым

объектов Camel (если только перед нами не поставлена задача реализации методов класса Camel). Но обычно объект типа Camel состоит из хеша, содержащего атрибуты конкретного объекта Camel, такие как кличка (в данном случае "Amelia", а не "fido") и количество горбов (которое мы не задали, но по умолчанию, вероятно, установлен один: смотри обложку).

Простые вещи

Если у вас не закружилась слегка голова после чтения предыдущего параграфа, значит ваша голова необычная. Обычно люди не любят иметь дело со сложными структурами данных, будь они правительственными или генеалогическими. Поэтому в естественных языках есть много способов сделать вид, что никаких сложностей нет. Многие из них относятся к категории задания темы (topicalizatioii), что служит причудливым лингвистическим термином, означающим соглашение с кем-то относительно того, о чем пойдет речь (или путем исключения, о чем речь, вероятно, не пойдет). В языке это происходит на нескольких уровнях. На верхнем уровне мы разделяемся на различные субкультуры, заинтересованные в различных подтемах и устанавливающие субъязыки, говорящие преимущественно об этих подтемах. Жаргон медицинской клиники («нерастворимый фактор асфиксии» - indissoluble asphyxiant) отличен от жаргона шоколадной фабрики («долгоиграющий гобстоппер» - everlasting gobstopper). Большинство из нас автоматически переключает контекст при переходе с одного жаргона на другой.

На разговорном уровне переключение контекста должно производиться более явным образом, поэтому в нашем языке есть много способов сообщить, о чем мы собираемся говорить. Мы озаглавливаем книги и параграфы, из которых они состоят. В свои предложения мы вставляем витиеватые фразы типа «по поводу вашего последнего запроса» или «для каждого X». Обычно, однако, мы просто произносим нечто вроде: «Ну, знаешь, эта висюлька, которая болтается у тебя на шее? »

В Perl есть несколько возможностей задать тему. Одним из важных способов является объявление пакета (package declaration). Предположим, что мы хотим поговорить на Perl о верблюдах. Скорее всего, следует начать модуль Camel словами:

package Camel;

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

package Camel;

$fido = &fetch();

то настоящим именем $fido будет $Camel:: fido (а настоящим именем &fetch будет &Camel: :fetch, но пока мы не будем говорить о глаголах). Это означает, что если в другом модуле сказано:

package Dog;

$fido = &fetch();

то Perl не напутает, поскольку настоящим именем этой $fido будет $Dog:: fido, а не SCamel:: fido. «По-научному» говорится, что пакет устанавливает пространство имен (namespace). Количество пространств имен не ограничено, но поскольку одновременно нельзя находиться сразу в нескольких, то можно притвориться, что остальных пространств имен не существует. Благодаря этому пространства имен упрощают жизнь. Упрощение основывается на притворстве. (Так же, конечно, как и чрезмерное упрощение, которым мы занимаемся в данной главе.)

Содержать в порядке существительные важно, но так же важно содержать в порядке глаголы. Прекрасно, что &Camel:: fetch нельзя спутать с &Dog:: fetch в пространствах имен Camel и Dog, но действительно замечательно в пакетах то, что они классифицируют глаголы так, что ими могут пользоваться другие пакеты. Когда мы говорим:

$fido = new Camel "Amelia";

то фактически вызываем глагол &new в пакете Camel, полным именем которого является &Camel:: new. А когда мы говорим:

$fido->saddle();

то вызываем метод &Camel:: saddle, поскольку переменная $fido помнит, что она указывает на Camel. Вот так действует объектно-ориентированное программирование.

Словами package Camel мы начинаем новый пакет. Но иногда требуется взять существительные и глаголы из уже существующего пакета. Perl позволяет сделать это посредством объявления use (использовать), которое обеспечивает не только заимствование глаголов из другого пакета, но и загрузку указанного модуля с диска. На деле, необходимо сказать что-то вроде:

use Camel;

перед тем, как сказать:

$fido 二 new Camel "Amelia";

потому что иначе Perl не будет знать, что такое Camel.

Интересно, что разработчику, в сущности, не требуется знать, что такое Camel, при условии, что кто-то другой может написать модуль Camel вместо него. Еще лучше, если кто-то уже написал модуль Camel. Можно утверждать, что мощь Perl заключается не в самом Perl, а в СР AN (Comprehensive Perl Archive Network) 一 архиве, содержащем мириады модулей, выполняющих

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

use Some::Cool::Module;

После этого можно использовать глаголы из этого модуля так, как описывается в излагаемой здесь теме.

Подобно тому как это происходит в естественном языке, установка темы в Perl «искажает» язык, который будет использоваться с данного места и до конца программы. На практике некоторые встроенные модули вообще не вводят в действие новые глаголы, а только деформируют язык Perl разными полезными способами. Эти особые модули мы называем прагмами (pragmas). Например, часто применяется прагма strict:

use strict;

Действие модуля strict состоит в ужесточении некоторых правил, в результате чего чаще приходится указывать различные вещи, о которых в другом случае Perl догадывался бы сам, например, об областях видимости переменных. Явные указания выгодны при работе над большими проектами. По умолчанию Perl оптимизирован для маленьких проектов, но в случае применения прагмы strict хорошо использовать Perl и в больших проектах, требующих лучшего сопровождения. Поскольку прагму strict можно добавить в любой момент, Perl хорошо справляется с разрастанием маленьких проектов в большие, даже если поначалу это не предполагалось. Как обычно и бывает.

Глаголы

Как это свойственно и обычным «повелительным» языкам программирования, многие глаголы Perl являются командами: они приказывают интерпретатору Perl что-либо выполнить. С другой стороны, что характерно для естественных языков, значения глаголов Perl имеют тенденцию «разбегаться» в разных направлениях в зависимости от контекста. Высказывание, начинающееся с глагола, обычно является чисто повелительным и выполняется исключительно ради своих побочных эффектов. (Иногда мы называем такие глаголы процедурами (procedures), особенно если они определяются пользователем.) К часто встречающимся встроенным командам относится команда print (мы ее уже видели):

print "Женой Адама является $wife{'Адам'}.\п";

Ее побочный эффект выражается в появлении желаемого вывода:

Женой Адама является Ева.

Но кроме повелительного существуют и другие «наклонения». Некоторые глаголы служат для задания запросов и полезны в условных операторах, таких как оператор if. Другие глаголы транслируют свои входные параметры

в возвращаемые значения, подобно тому как рецепт описывает способ превращения исходных ингредиентов в нечто (желательно) съедобное. Мы склонны называть такие глаголы функциями (functions) из уважения к поколениям математиков, которым неизвестно значение слова «функциональный» в обычном языке.

Примером встроенной функции служит экспоненциальная функция:

$е = ехр(1); # 2.718281828459 или около того

Однако в Perl не проводится жесткого разделения между процедурами и функциями. Читатель обнаружит, что эти термины используются взаимозаменяемым образом. Иногда глаголы называются также операторами (если они встроенные) или подпрограммами (если они определены пользователем). Но назовите их как хотите - все они возвращают значение, которое может быть осмысленным или нет и которое можно игнорировать или нет.

По мере нашего изложения вы увидите и другие примеры того, как Perl ведет себя аналогично естественным языкам. Но можно взглянуть на Perl и с других точек зрения. Мы уже «втихомолку» ввели некоторые обозначения из языка математики, такие как индексы, сложение, экспоненциальная функция. Но Perl является также языком управления, связующим (glue) языком, языком создания прототипов, языком обработки текста, обработки списков и объектно-ориентированным языком - помимо всего прочего.

Perl - это также старый добрый язык программирования (plain old computer language). С этой точки зрения мы и рассмотрим его теперь.

Стандартный пример

Предположим, что вы преподаете Perl группе студентов и хотите решить, как их оценивать. У вас есть набор результатов сдачи экзаменов каждым студентом, составленный в произвольном порядке. Требуется получить список, объединяющий оценки каждого студента и дополненный средним баллом. И у вас есть текстовый файл (оригинально названный grades 一 оценки), который выглядит так:

Nonl 25

Ben 76

Clementine 49

Norm 66 Chris 92 Doug 42 Carol 25 Ben 12 Clementine 0 Norm 66

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

Кстати, номера строк не являются частью программы, несмотря на возможное сходство с BASIC в другом.

1 #!/usr/bin/perl

2

3 open(GRADES, "grades") or die "Невозможно открыть grades: $!\n";

4 while ($line = <GRADES>) {

5 ($student, $grade) = split(" ", $line);

$grades{$student} .= $grade ."";

}

8

foreach $student (sort keys %grades) {

$scores = 0;

$total = 0;

@grades = split(" ", $grades{$student});

foreach $grade (@grades) {

$total += $grade;

$scores++;

}

$average = $total / $scores;

print "$student: $grades{$student}\tCpeflHee: $average\n";

}

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

Мы бы посоветовали вам попробовать запустить этот пример на выполнение, но вы, вероятно, еще не знаете, как это делается.

Как это делается

Ну, сейчас вы, наверное, размышляете, как же запустить программу Perl. Короткий ответ состоит в том, что нужно подать ее на вход интерпретатора языка Perl, который, по счастливому совпадению, носит название perl. Длинный ответ начинается так: «There's More Than One Way To Do It» - есть несколько способов сделать это.

Первый способ запустить perl (как правило, работающий в любой операционной системе) 一 это просто вызвать perl явным образом из командной строки. Если вы выполняете что-то очень простое, можно использовать ключ -е (в следующем примере символ % представляет стандартное приглашение оболочки, поэтому его вводить не надо). В Unix можно ввести:

% perl -е 'print "Hello, world!\n";'

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

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

% perl gradation

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

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

сценария Perl с интерпретатором perl. В системах Unix, поддерживающих нотацию #! (нотация «shebang»), а таковыми в наше время является большинство систем Unix, можно с помощью специальной первой строки сценария указать операционной системе, какую программу она должна запустить. Введите в качестве первой строки нашего примера нечто аналогичное

#!/usr/bin/perl

(Если perl находится не в /usr/Ып, то нужно соответствующим образом изменить строку #!.) После этого вам требуется лишь сказать:

% gradation

Разумеется, это не сработало, поскольку вы забыли сделать сценарий исполняемым модулем (см. страницу руководства по chmod(l)) и поместить его в свой маршрут поиска PATH. Если его нет в переменной PATH, необходимо задать полное имя файла, чтобы операционная система знала, где найти ваш сценарий, например так:

% /home/sharon/bin/gradation

Наконец, если вам настолько не везет, что у вас стоит древняя система Unix, которая не поддерживает магическую строку #!, или путь к вашему интерпретатору длиннее 32 символов (предел, устанавливаемый на многих системах), вы можете обойти эти ограничения таким способом:

#!/bin/sh - - # perl, остановить цикл eval 'exec /usr/bin/perl -S $0 ${1+"$@"}' if 0;

В некоторых операционных системах требуется какая-нибудь разновидность этого приема, чтобы справиться с /Ып/csh, DCL, COMMAND.COM или другим интерпретатором командной строки, устанавливаемым по умолчанию. Посоветуйтесь с Местным Экспертом.

На протяжении всей этой книги мы будем использовать просто #! /usr/bin/ perl для представления всех этих обозначений, но теперь вы знаете, что под этим имеется в виду.

Случайный совет: когда будете писать контрольный сценарий, не называйте его test. В системах Unix имеется встроенная команда test, которая, скорее всего, и будет выполнена вместо вашего сценария. Попробуйте лучше назвать сценарий try.

А вот не столь случайный совет: изучая Perl, даже если вам кажутся понятными ваши действия, используйте ключ -w, особенно в процессе разработки. С помощью этой опции включается вывод всевозможных полезных и интересных предупредительных сообщений (не обязательно именно в такой очередности). Ключ -w можно указать и в первой строке:

#!/usr/bin/perl -w

Теперь, когда вы знаете, как запустить свою собственную программу Perl (не путать с программой perl), вернемся к нашему примеру.

Дескрипторы файлов

Если только вы не занимаетесь моделированием философа-солипсиста с помощью методов искусственного интеллекта, вашей программе требуются какие-то средства общения с внешним миром. В строках 3 и 4 нашего Стандартного примера есть слово GRADES, которое иллюстрирует еще один из типов данных Perl, а именно дескриптор файла (filehandle). Дескриптор файла 一 это просто имя, которое присваивается файлу, устройству, сокету или конвейеру и которое просто помогает вспомнить, о чем из перечисленного вы говорите, а также скрыть некоторые сложные вещи типа буферизации. (Во внутренней реализации дескрипторы файлов аналогичны потокам (streams) языков типа C++ или каналам ввода/вывода в BASIC.)

Дескрипторы файлов облегчают получение входных данных и отправку выходных в различные места. Хорошим связующим языком (glue language) делает Perl отчасти то, что он может одновременно общаться с многими файлами и процессами. Наличие удобных символических имен для различных внешних объектов является частью того, что составляет хороший связующий язык.

Создание дескриптора файла и закрепление его за файлом выполняется с помощью функции open. Функция open принимает по меньшей мере два параметра: дескриптор файла и имя файла, с которым его нужно связать. Perl предоставляет также несколько предварительно определенных (и предварительно открытых) дескрипторов файлов. STDIN - это обычный канал ввода для вашей программы, a STDOUT - это для нее обычный канал вывода. STDERR представляет собой дополнительный канал вывода, позволяющий программе отпускать ехидные ремарки, пока она преобразует (или пытается преобразовать) ваши входные данные в выходные.

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

open(SESAME,' open(SESAME,' open(SESAME,' open(SESAME,' open(SESAME,' open(SESAME,'open(SESAME,' open(SESAME,' open(SESAME,' open(SESAME,' open(SESAME,' open(SESAME,'имя_файла")<имя_файла")>имя_файла") »имя_файла")имя_файла")<имя_файла")>имя_файла") »имя_файла")# # # ## # # #чтение из имеющегося файла(то же, явным образом)создать файл и производить в него запись дописывание к существующему файлучтение из имеющегося файла(то же, явным образом)создать файл и производить в него запись дописывание к существующему файлуI выходная_программа_конвейера") # организовать выходной фильтр входная_программа_конвейера |")# организовать входной фильтрI выходная_программа_конвейера") # организовать выходной фильтр входная_программа_конвейера |")# организовать входной фильтр

open(SESAME,' open(SESAME,' open(SESAME,' open(SESAME,' open(SESAME,' open(SESAME,'

open(SESAME,' open(SESAME,' open(SESAME,' open(SESAME,' open(SESAME,' open(SESAME,'

имя_файла")

<имя_файла")

>имя_файла") »имя_файла")

имя_файла")

<имя_файла")

>имя_файла") »имя_файла")

# # # #

# # # #

чтение из имеющегося файла

(то же, явным образом)

создать файл и производить в него запись дописывание к существующему файлу

чтение из имеющегося файла

(то же, явным образом)

создать файл и производить в него запись дописывание к существующему файлу

I выходная_программа_конвейера") # организовать выходной фильтр входная_программа_конвейера |")# организовать входной фильтр

I выходная_программа_конвейера") # организовать выходной фильтр входная_программа_конвейера |")# организовать входной фильтр

Как можно видеть, имя для дескриптора файла выбирается произвольно. После открытия дескриптор файла SESAME можно использовать для доступа к файлу или конвейеру, пока он не будет явно закрыт (с помощью, как можно догадаться, close(SESAME)) либо пока дескриптор файла не будет связан с новым файлом посредством нового вызова open с тем же самым дескриптором.1

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

print STDOUT "Введите число: ";# запрос числа

$number = <STDIN>;# ввод числа

print STDOUT "Вы ввели число $number.\п"; # вывод числа

Заметили, что мы только что вам подкинули? Что там делает STDOUT в этих командах print? Это всего лишь один из способов использования дескриптора файла выходных данных. Дескриптор файла можно передать в качестве первого параметра команды print, и если он указан, то определяет, куда должна быть направлена выдача. В данном случае указание дескриптора файла излишне, поскольку и без него выдача была бы направлена на STDOUT. Совсем как STDIN устанавливается по умолчанию для ввода, STDOUT устанавливается по умолчанию для вывода. (В строке 18 нашего Стандартного примера мы опустили его, чтобы не привести вас раньше времени в замешательство.)

Запустив предыдущий пример на исполнение, можно заметить, что выводится лишняя пустая строка. Это происходит потому, что операция чтения строки не удаляет автоматически символ перевода строки из строки ввода (пользователь мог ввести, например, "9\п"). Для тех случаев, когда нужно удалить символ перевода строки, в Perl есть функции chop и chomp. Функция chop удаляет без разбора (и возвращает) последний символ строки, в то время как chomp удаляет только маркер конца записи (обычно "\п") и возвращает число удаленных символов. Часто можно видеть такую идиому для ввода отдельной строки:

chop($number 二 <STDIN>);# ввести число и удалить перевод строки

что равносильно следующему:

$number = <STDIN>;# ввести число

chop($number);# удалить перевод строки

Операторы

Как уже упоминалось выше, Perl является и математическим языком. Это справедливо для нескольких уровней: от нижнего уровня поразрядных логических операций на уровне разрядов, вверх до операций над числами и множествами и вплоть до больших предикатов и абстракций разного типа. А как нам известно из школьного курса математики, в ней любят употреблять необычные символы. Хуже, что специалисты по вычислительной технике придумали свои варианты этих странных символов. В Perl тоже есть несколько таких странных символов, но, по правде сказать, в большинстве своем они непосредственно заимствованы из С, FORTRAN, sed(l) или awk(l), поэтому пользователям этих языков они должны быть знакомы.

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

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

Некоторые бинарные арифметические операторы

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

Пример

Название

Результат

$а + $Ь

Сложение

Сумма $а и $Ь

$а * $Ь

Умножение

Произведение $а и $Ь

$а % $Ь

Взятие по модулю

Остаток от деления $а на $Ь

$а ** $Ь

Возведение в степень

$а в степени $Ь

Да, мы опустили вычитание и деление 一 полагаем, что читатель сообразит, как они действуют. Поработайте с ними и проверьте, правы ли вы. (Или смошенничайте и посмотрите в главе 3 «Унарные и бинарные операторы».) Арифметические операторы выполняются в том порядке, которому вас учил школьный учитель математики (возведение в степень раньше умножения; умножение раньше сложения). Для изменения очередности всегда можно воспользоваться скобками.

Строковые операторы

Существует также оператор «сложения» для строк, осуществляющий конкатенацию (т. е. соединяющий концы строк). В отличие от языков, в которых эта операция выглядит так же, как сложение чисел, в Perl для конкатенации строк определен отдельный оператор (.):

$а = 123;

$Ь = 456;

print $а + $Ь;# выводит 579

print $а • $Ь;# выводит 123456

Есть также оператор «умножения» для строк, называемый оператором повторения (repeat). Опять же, это самостоятельный оператор (х), отличный от умножения чисел:

$а = 123;

$Ь = 3;

print $а * $Ь;# выводит 369

print $а х $Ь;# выводит 123123123

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

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

конкатенация строк. В результате три следующие команды дают одинаковый вывод:

print $а . ' равно ' . $Ь . ".\п";# оператор "точка"

print $а, ' равно ', $Ь, ".\п";# список

print "$а равно $Ь.\п";# интерполяция

Которую из них использовать в конкретной ситуации, зависит целиком от вас. (Однако имейте в виду, что интерполяция часто читается легче всего.)

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

print "-" х $scrwid, "\n";

В результате поперек экрана вычерчивается линия, если только $scrwid содержит ширину экрана (screen width), а не идентификатор вашего штопора (screw identifier).

Операторы присваивания

Хотя этот оператор является не совсем математическим, мы уже широко пользовались простым оператором присваивания =. Постарайтесь запомнить, что = означает «устанавливается равным», а не «равно». (Существует и математический оператор равенства ==, который означает «равно», и если вы с самого начала усвоите разницу между ними, то убережетесь от возникновения проблем в будущем. Оператор == действует как функция, возвращающая булево значение, тогда как = больше похож на процедуру, которая выполняется для получения побочного эффекта модификации переменной.) Как и операторы, описанные выше, операторы присваивания представляют собой бинарные инфиксные операторы; это значит, что их операнды расположены по обеим сторонам оператора. Правый операнд может быть произвольным выражением, но левый должен быть допустимым 1-значением (lvalue), что в переводе на обычный язык означает допустимую область памяти типа переменной или элемента массива. Чаще всего используется простой оператор присваивания. Он вычисляет значение выражения, находящегося в правой части, а затем делает переменную в левой части равной этому значению:

$а 二 $b;

$а — $Ь + 5

$а = $а * 3;

Заметьте, что последнее присваивание дважды ссылается на одну и ту же переменную: один раз при вычислении, и один раз при присваивании. В этом нет ошибки, но такая операция выполняется столь часто, что для нее существует сокращенное обозначение (заимствованное из С). Операция вида:

1-значение оператор= выражение

выполняется так, как если бы было записано:

1-значение = 1-значение оператор выражение

за исключением того, что 1-значение не вычисляется дважды. (Разница есть лишь тогда, когда вычисление 1-значения имеет побочные эффекты. Но в тех случаях, когда разница есть, она обычно состоит именно в том, что вам требуется. Так что не стоит об этом волноваться.)

Так, предыдущий пример можно было бы записать в следующем виде:

$а *= 3;

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

$line .= "\п"; # Дописать символ перевода строки к $line.

$fill х= 80;# Сделать строку $fill 80-кратным повторением самой себя.

$val I|= "2";# Установить значение $val равным 2, если оно не "true".

В строке 6 нашего Стандартного примера есть две конкатенации строк, одна из которых представляет собой оператор присваивания. А строка 14 содержит сокращенный оператор +=.

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

$а = $Ь = $с = 0;

Также часто можно видеть, что присваивание используется в условии цикла while, как в строке 4 нашего Стандартного примера.

Что должно удивить С-программистов, так это то, что присваивание в Perl возвращает фактическую переменную, выступающую как 1-значение, поэтому можно модифицировать одну и ту же переменную несколько раз в одной команде. Например, можно написать:

($temp -= 32) *= 5/9;

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

chop($number = <STDIN>);

чтобы «обрубить» конечное значение $number. Вообще говоря, эту особенность можно использовать всякий раз, когда требуется что-то скопировать и одновременно произвести над ним какие-то действия.

Унарные арифметические операторы

Как если бы запись $variable += 1 была недостаточно короткой, Perl заимствует из С еще более краткий способ приращения переменной. Операторы инкремента (и декремента) просто прибавляют (или вычитают) единицу к значению переменной. Они могут помещаться с любой стороны переменной, в зависимости от того, в какой момент требуется их выполнить:

Пример

Название

Результат

++$а, $а++

- -$а, $а- -

Инкремент

Декремент

Прибавить 1 к $а

Вычесть 1 из $а

Когда один из этих «автоматических» операторов предшествует переменной, то это называется префиксным инкрементированием (декрементированием) переменной, ее значение будет изменено перед тем, как произойдет обращение к ней. Когда оператор помещается после переменной, то это называется постфиксным инкрементированием (декрементированием) переменной, и ее значение изменяется после использования. Например:

$а =5;#$априсваиваетсязначение 5

$Ь =++$а;#$Ьприсваиваетсяинкрементированное значение $а, 6

$с =$а--;#$сприсваивается6, затем $а декрементируется и становится5

В строке 15 нашего Стандартного примера число результатов увеличивается на единицу, и мы получаем количество результатов, которые нужно усреднить. При этом используется оператор постфиксного инкрементирования ($sco「es++), но в данном случае это несущественно, поскольку выражение применяется в пустом контексте, что представляет собой лишь причудливый способ сказать, что выражение вычисляется только ради побочного эффекта инкрементирования переменной. Возвращаемое значение при этом отбрасывается.

Логические операторы

Логические операторы, которые называют также операторами «короткого действия» («short-circuit»), позволяют программе принимать решения, исходя из нескольких критериев, без применения вложенных операторов if. Их называют операторами короткого действия, поскольку они пропускают

(закорачивают) вычисление правого аргумента, если считают, что в левом аргументе содержится достаточно информации для получения итогового результата. Это делается не только для повышения производительности. Программист может явным образом использовать этот режим закорачивания, чтобы избежать вычислений в правом аргументе, о которых ему известно, что они сорвались бы, если бы их не «охранял» левый аргумент. В Perl можно сказать: «California or bust!» (в Калифорнию или провалиться), и при этом не провалиться (предполагая, что вы действительно доберетесь до Калифорнии). На самом деле в Perl есть два набора логических операторов: традиционный набор, заимствованный из С, и более новый (но еще более традиционный) набор операторов со сверхнизким приоритетом, заимствованный из BASIC. Оба набора при надлежащем применении повышают удобочитаемость программ. Операторы С, использующие знаки пунктуации, уместны, когда желательно, чтобы логические операторы имели больший приоритет, чем запятые, тогда как записываемые словами операторы BASIC хорошо использовать, когда желательно, чтобы запятые имели больший приоритет, чем логические операторы. Часто они действуют одинаково, а использование того или иного набора является делом вкуса. (Примеры, выявляющие контраст, можно найти в разделе «Логические and, or, not и хог» главы 3 «Унарные и бинарные операторы».) Хотя из-за различных приоритетов эти два набора операторов не являются взаимозаменяемыми, после синтаксического анализа сами операторы ведут себя одинаково; приоритетность просто определяет область расположения их аргументов. В табл. 1.1 перечислены логические операторы.

Таблица 1Л. Логические операторы

Пример

Название

Результат

$а && $Ь

И

$а, если $а ложно, в противном случае $Ь

$а II $Ь

Или

$а, если $а истинно, в противном случае $Ь

! $а

Не

Истинно, если $а не истинно

$а and $b

И

$а, если $а ложно, $Ь в противном случае

$а ог $Ь

Или

$а, если $а истинно, $Ь в противном случае

not $а

Не

Истинно, если $а не истинно

$а хог $Ь

Исключающее или

Истинно, если $а или $Ь истинны, но не оба сразу

Благодаря тому что логические операторы «закорачивают» вычисление, их часто используют в Perl для условного выполнения кода. В следующей строке (строка 3 нашего Стандартного примера) делается попытка открыть файл grades:

open(GRADES, "grades") or die "Невозможно открыть grades: $!\n";

Если файл удается открыть, происходит переход к следующей строке программы. Если файл открыть не удается, выводится сообщение об ошибке, и выполнение прекращается.

Буквально эта строка означает: «Открыть grades или умереть!» Операторы короткого действия служат еще одним примером естественности языка, но, кроме того, оберегают зрительное представление. Важные действия перечисляются в левой части экрана, а второстепенные скрыты справа. (Переменная $! содержит сообщение об ошибке, возвращенное операционной системой -см. главу 28 «Специальные идентификаторы».) Конечно, эти логические операторы можно использовать и в более традиционных условных выражениях, таких как операторы if и while.

Некоторые операторы сравнения чисел и строк

Операторы сравнения, или отношения, сообщают нам о том, как две скалярные величины (числа или строки) относятся одна к другой. Есть два набора операторов: один сравнивает числа, а другой - строки. (В любом случае аргументам будет сначала «принудительно» навязан соответствующий тип.) Предполагая, что левый и правый аргументы суть $а и $Ь, получаем:

Сравнение

Числа

Строки

Возвращаемое значение

Равно

==

eq

Истина, если $а равно $Ь

Не равно

!=

ne

Истина, если $а не равно $Ь

Меньше

<

It

Истина, если $а меньше $Ь

Больше

>

gt

Истина, если $а больше $Ь

Больше или равно

<=

le

Истина, если $а не больше $Ь

Меньше или равно

>=

ge

Истина, если $а не меньше $Ь

Сравнение

<=>

cmp

0, если равно, 1, если $а больше, -1, если $Ь больше

Последние два оператора (<=> и стр) совершенно избыточны. Однако они крайне полезны в подпрограммах сортировки sort (см. главу 29 «Функции»).

Некоторые операторы проверки файлов

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

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

Пример

Название

Результат

-е $з

Существует (exists)

Истина, если файл с именем $а существует

-г $а

Доступен по чтению (readable)

Истина, если файл с именем $а доступен по чтению

-w $а

Доступен по записи (writable)

Истина, если файл с именем $а доступен по записи

-d $а

Каталог (directory)

Истина, если файл с именем $а является каталогом

-f $а

Файл (file)

Истина, если файл с именем $а является обычным файлом

-Т $а

Текстовый файл (text file)

Истина, если файл с именем $а является текстовым файлом

Можно так использовать эти операторы:

-е "/usr/bin/perl" or warn "Perl неправильно установлен\п";

-f "/vmlinuz" and print "Вижу, что вы друг Лайнуса\п";

Обратите внимание, что обычный (regular) файл - не то же самое, что текстовый файл (text file). Двоичные файлы типа /vmlinuz являются обычными, но не текстовыми. Текстовые файлы представляют собой противоположность двоичным файлам, тогда как обычные файлы - противоположность «иррегулярным» файлам типа каталогов или устройств.

Существует много операторов проверки файлов сверх перечисленных нами. Большинство таких операторов представляют собой унарные булевы операторы, т. е. принимают только один операнд (скаляр, значением которого является имя файла или его дескриптор) и возвращают значение true или false. Некоторые из них возвращают более замысловатые значения, например, размер или время, относящееся к файлу; их, когда они вам понадобятся, вы сможете найти в разделе «Именованные унарные операторы и операторы проверки файлов» в главе 3 «Унарные и бинарные операторы».

Управляющие структуры

До настоящего момента все рассмотренные нами примеры, за исключением одного большого примера, были совершенно прямолинейными: мы выполняли все команды по порядку. Было приведено несколько примеров использования операторов короткого действия для выполнения (или невыполнения) отдельной команды. Хотя можно писать очень полезные линейные программы (к которым относятся многие сценарии CGI), но при наличии условных выражений и циклов можно создавать значительно более мощные приложения. В совокупности эти механизмы называются управляющими

структурами (control structures). Поэтому можно рассматривать Perl и как управляющий язык.

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

Что есть истина?

Мы обсуждали термин «истинность» (truth) и упоминали, что некоторые операторы возвращают значения true или false. Прежде чем двигаться дальше, необходимо точно договориться о том, что под ними подразумевается. В Perl значение истинности рассматривается несколько иначе, чем в других языках программирования, но, поработав с ним некоторое время, читатель найдет это очень разумным. (На самом деле, мы надеемся, что разумным это покажется вам после чтения нижеизложенного.)

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

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

Любая строка, кроме "" и "О", является истиной

Любое число, кроме 0, является истиной.

Любая ссылка является истиной.

Любая неопределенная величина является ложью.

Фактически последние два правила следуют из двух первых. Любая ссылка (правило 3) указывает на нечто, имеющее адрес, и имеет значением число или строку, содержащую этот адрес, которые не могут быть равны 0, поскольку всегда определены. А всякая неопределенная величина (правило 4) всегда имеет значением 0 или нулевую строку.

А в некотором смысле и правило 2 можно вывести из правила 1, если представить, что все является строками. Опять же, для вычисления истинности никакого приведения строк не производится, но если бы приведение строк производилось у то число 0 превратилось бы в строку "О" и оказалось бы ложью. Любое другое число превратилось бы в строку, отличную от "О", а потому оказалось бы истиной. Рассмотрим несколько примеров, которые позволят лучше это понять:

О# становится строкой "О", поэтому false.

1# становится строкой "1", поэтому true.

10 - 10

# 10 минус 10 равно 0, преобразуется в строку "0", поэтому false.

0.00

# равно 0, преобразуется в строку "0", поэтому false.

"0"

# является строкой "0", поэтому false.

# является нулевой строкой, поэтому false.

"0.00"

# является строкой "0.00", ни "", ни "0", поэтому true!

"0.00" +

0 # становится числом 0 (приведение из-за +), поэтому false.

\$а

# является ссылкой на $а, поэтому true, даже если $а есть false.

undef()

# функция, возвращающая неопределенное значение, поэтому false.

Поскольку ранее было что-то невнятно сказано о вычислении истинности в скалярном контексте, у читателя может возникнуть вопрос о том, как оценивается истинность списка. Дело в том, что ни одна операция Perl не возвращает список в скалярном контексте. Все они обнаруживают, что находятся в скалярном контексте, и потому возвращают скалярное значение, к которому и применяются правила истинности. Поэтому здесь не возникает проблемы, т. к. можно определить значение, возвращаемое любым данным оператором в скалярном контексте. Оказывается как массивы, так и хеши возвращают скалярные значения, являющиеся истиной, если в массиве или хеше есть хоть один элемент. Подробнее об этом далее.

Операторы if и unless

Мы видели выше, что логический оператор может действовать в качестве условного. Несколько более сложной формой логического оператора является оператор if. Оператор if вычисляет истинность условия (т. е. булево выражение) и выполняет блок кода, если условие истинно:

if ($debug_level > 0) {

# Что-то не так. Сообщить пользователю.

print "Отладка: Тревога, Уилл Робинсон, тревога!\п";

print "Отладка: Ответ был '54', а ожидалось '42'.\п";

}

Блоком называется одна или несколько команд, заключенных в пару фигурных скобок. Поскольку оператор if выполняет блок, фигурные скобки требуются в нем по определению. Те, кто знаком с языком типа С, заметят различие. Скобки необязательно использовать в С, если команда всего одна, но в Perl скобки не являются факультативными.

Иногда недостаточно выполнить блок команд при удовлетворении условию. Может потребоваться выполнить другой блок, если условие не выполняется. Конечно, можно использовать два оператора if с условием одного, являющимся отрицанием условия другого, но Perl предоставляет более элегантное решение. После блока if может принять необязательное второе условие, называемое else, которое выполняется, только если условие ложно. (Ветеранов программирования это не должно удивить.)

Иногда возможных вариантов выбора оказывается больше двух. В таких случаях требуется добавить условие истинности elsif для каждого возможного варианта. (Ветеранов программирования может весьма удивить написание elsif, за что никто не собирается просить прощения. Извините.)

if ($city eq "New York") {

print "Нью-Йорк находится на северо-востоке от Вашингтона, округ Колумбия.\п";

}

elsif ($city eq "Chicago") {

print "Чикаго находится на северо-западе от Вашингтона, округ Колумбия.\п";

}

elsif ($city eq "Miami") {

print "Майами находится на юге от Вашингтона. И там гораздо теплее!\п";

} else { print "Извините, но я не знаю, где находится $city.\п";

}

Предложения if и elsif вычисляются по очереди, пока одно из них не окажется истинным или не будет достигнуто условие else. Когда одно из условий оказывается истинным, выполняется его блок, а все остальные ветви пропускаются. Иногда требуется, чтобы никакие действия не выполнялись, если условие истинно - только если оно ложно. Применение пустого if с else выглядит неряшливо, a if с отрицанием может быть трудным для чтения; в обычном языке фраза «если не это является истиной, сделать то-то и то-то» звучит несколько странно. В таких случаях следует предпочесть оператор unless:

unless ($destination eq $home) { print "Я еду не домой.\n";

}

Оператор elsunless отсутствует. Вообще говоря, его можно охарактеризовать как излишество (feature).

Итеративные (циклические) конструкции

В Perl есть четыре основных типа итеративных операторов: while, until, for и foreach. Эти операторы позволяют программе Perl повторять выполнение одного и того же кода.

Операторы while и until

Операторы while и until ведут себя аналогично операторам if и unless, но позволяют выполнять блок многократно. Иными словами, они выполняют цикл. Сначала проверяется значение части оператора, являющейся условием. Если условие соблюдено (т. е. оно принимает значение true для while или false для until), выполняется блок команд.

while ($tickets_sold < 10000) {

$available 二 10000 - $tickets_sold;

print "$available билетов в наличии. Сколько нужно вам:";

$purchase 二 <STDIN>;

chomp($purchase);

$tickets_sold += $purchase;

}

Обратите внимание, что если исходное условие не выполнено, вход в цикл вообще не производится. Например, если уже продано 10 000 билетов, можно потребовать, чтобы следующая строка программы сообщала что-то вроде:

print "Билеты на это представление распроданы, пожалуйста, зайдите в следующий раз.\п";

В строке 4 нашего Стандартного примера осуществляется чтение:

while ($line = <GRADES>) {

В результате очередная строка присваивается переменной $line и, как объяснялось выше, возвращается значение $line, поэтому в условии оператора while может быть определена истинность $line. Читателю может показаться, что Perl получит ошибочное ложное значение при вводе пустой строки и досрочно выйдет из цикла. На самом деле этого не произойдет. Причина будет понятна, если поразмыслить обо всем сказанном выше. Оператор ввода строки оставляет в конце строки символ перевода строки, поэтому пустая строка имеет значение "\п". А как известно, \п ' не является каким-либо из канонических ложных значений. Поэтому условие истинно, и цикл продолжается даже при вводе пустых строк.

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

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

while (@ARGV) {

process(shift @ARGV);

}

Оператор shift при каждой итерации цикла удаляет один элемент из списка аргументов (и возвращает его). Цикл автоматически завершается, когда исчерпывается массив @ARGV, т. е. его длина становится равной 0. А 0 в Perl является ложью. В некотором смысле сам массив становится ложью.

Оператор for

Другой итеративный оператор 一 цикл for, выполняемый точно так же, как цикл while, но выглядящий совсем иначе. (Однако С-программистам он покажется очень знакомым.)

for ($sold = 0; $sold < 10000; $sold += $purchase) { $available = 10000 - $sold;

print "$available билетов в наличии. Сколько нужно вам: ”；

$purchase = <STDIN>; chomp($purchase);

}

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

Оператор foreach

Последним из итеративных операторов Perl является оператор foreach, применяемый для выполнения одного и того же кода для каждого скаляра из некоторого набора, которым может, например, быть массив:

foreach $user (@users) { if (-f "$home{$user}/.nexrc") { print "$user крут... он использует vi, поддерживающий perl!\n";

}

}

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

В типичной программе Perl можно обнаружить значительно больше циклов foreach, чем циклов for, поскольку в Perl очень легко создавать такие спис-

ки, которые требуются foreach для итерации. Одной из идиом, которые встречаются часто, является цикл для перебора отсортированных ключей хеша:

foreach $key (sort keys %hash) {

На практике именно это делает строка 9 нашего Стандартного примера.

Выход из цикла: next и last

Операторы next и last позволяют изменять порядок выполнения команд в цикле. Не так уж редки особые ситуации, которые нужно пропускать или при возникновении которых нужно завершить цикл. Например, при работе с учетными записями в Unix может потребоваться пропустить такие учетные записи системы, как root или 2P. Оператор next позволяет переместиться в конец текущей итерации цикла и начать новую итерацию. Оператор last позволяет перескочить конечную границу блока, как если бы условие выполнения цикла оказалось ложным. Это может быть полезным, если, к примеру, надо отыскать определенную учетную запись и, найдя ее, выйти из цикла.

foreach $user (@users) {

if ($user eq "root" or $user eq "Ip") { next;

}

if ($user eq "special") {

print "Нашел учетную запись special.\n"; # какая-то обработка

last;

}

}

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

LINE: while ($line = <ARTICLE>) {

last LINE if $line eq "\n"; # остановиться на первой пустой строке next LINE if $line =~ /Л#/; # пропустить строки комментариев # your ad here

}

Читатель может сказать: «Погодите, что это еще за нелепые значки Л# между наклонными зубочистками? Это не очень-то похоже на английский язык.» И будет прав. Это шаблон для поиска, содержащий регулярное выражение (хотя и довольно простое). О регулярных выражениях будет рассказано в следующем разделе. Perl является лучшим в мире языком обработки текста, а регулярные выражения образуют сердцевину обработки текста в Perl.

Регулярные выражения

Регулярные выражения (regular expressions} (известные также как regexes, regexps или RE) используются многими программами поиска, такими как grep и findstr, изменяющими текст («text-munging») программами, такими как sed и awk, а также редакторами, например ui и emacs. Регулярное выражение -это способ описать множество строк, не перечисляя все строки, входящие в это множество.

Регулярные выражения входят во многие другие языки программирования (некоторые из них даже рекламируют «регулярные выражения Рег15»!), но ни в один из этих языков регулярные выражения не интегрированы так, как в Perl. Регулярные выражения используются в Perl несколькими способами. Во-первых, и это главное, они применяются в условных операторах, чтобы определить, соответствует ли строка некоторому шаблону, поскольку в булевом контексте они возвращают «истину» или «ложь». Поэтому, увидев в условном операторе нечто вроде /foo/, знайте, что перед вами обычный оператор поиска по шаблону (pattern-matching):

if (/Windows 95/) { print " Пора делать апгрейд?\п" }

Во-вторых, найдя шаблон в строке, можно заменить его чем-либо другим. Поэтому, увидев нечто типа s/foo/bar/, знайте, что это просьба Perl заменить, при возможности, «Ьаг» на «foo». Мы называем это оператором подстановки (substitution). Он также возвращает true или false в зависимости от успешности операции, но обычно выполняется ради своего побочного результата:

s/Windows/Linux/;

Наконец, с помощью шаблонов можно задавать не только то, что где-то существует, но и то, чего нет. Поэтому оператор split использует регулярное выражение для задания того, где данных нет. Это значит, что регулярное выражение задает разделители (separators), разграничивающие поля данных. В нашем Стандартном примере есть пара простейших образцов. В строках 5 и 12 производится расщепление строк по пробелам и возвращается список слов. Но расщепление возможно и по любому другому разделителю, задаваемому регулярным выражением:

($good, $bad, $ugly) = split(/,/, "vi,emacs,teco");

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

В простейшем случае регулярные выражения используются для поиска литерального выражения. В приведенном выше примере расщепления осуществлялся поиск одиночных запятых. Но если надо отыскать несколько символов подряд, то все они должны быть найдены один за другим. То есть шаблон, как и ожидалось, ищет подстроку. Допустим, что требуется показать все строки файла HTML, содержащие ссылки HTTP (но не ссылки FTP). Представим себе, что мы впервые работаем с файлом HTML и слегка наивны. Мы знаем, что в этих ссылках всегда где-то присутствует http:. Можно организовать такой цикл по нашему файлу:

while ($line 二 <FILE>) { if ($line =~ /http:/) { print $line;

}

}

Здесь =~ (оператор привязки шаблона) указывает Perl на необходимость поиска регулярного выражения http: в переменной $line. Если выражение будет найдено, то оператор возвратит значение «истина», и будет выполнен блок (оператор print).

Между прочим, если не использовать оператор привязки =~, то Perl будет осуществлять поиск в строке, установленной по умолчанию, а не в $line. Это все равно, что сказать: «Ой! Помогите найти мою контактную линзу!» И люди станут автоматически искать ее около вас, хотя вы не говорили им, где нужно искать. Аналогично, Perl знает, что есть место, по умолчанию установленное для поиска, если не указано, где надо искать. Эта строка по умолчанию является на самом деле особой скалярной переменной с необычным именем $_. На практике это место по умолчанию не только для поиска по шаблону; многие операторы Perl используют по умолчанию переменную $_, поэтому программист Perl со стажем, вероятно, написал бы последний пример так:

while (<FILE>) { print if /http:/;

}

(Хм-м, похоже, что сюда проник еще один из этих модификаторов команд. Хитрые маленькие бестии.)

Все это достаточно хорошо, но что если нужно найти все типы ссылок, а не только ссылки HTTP? Можно дать список ссылок, например http:, ftp:, mailto: и т. д. Но этот список может оказаться длинным, и как быть, если появится новый тип ссылки?

while (<FILE>) { print if /http:/; print if /ftp:/; print if /mailto:/; # Что еще?

Поскольку регулярные выражения описывают множество строк, можно просто описать то, что мы ищем: несколько символов алфавита, за которыми следует двоеточие. На языке регулярных выражений это будет выглядеть как /[a-zA-Z]+:/, где скобки определяют класс символов (character class). Группы a-z и A-Z представляют все символы английского алфавита (черточка обозначает диапазон всех символов с начального по конечный включительно). Азнак + является специальным символом, означающим «не менее одного из того, что мне предшествовало». Это то, что мы называем квантификатором (quantifier), представляющим собой штуковину, позволяющую сообщить, сколько раз нечто может повториться. (Символы косой черты, в сущности, являются не частью регулярного выражения, а частью оператора поиска по шаблону. Они действуют подобно кавычкам, в которые заключается регулярное выражение.)

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

Название

Определение в ASCII Код

Пробельный символ

Символ слова

Цифра

[\t\n\r\f]\s

[a-zA-Z_0-9]\w

[0-9]\d

Заметьте, что эти коды соответствуют одиночным символам. Метасимвол \w ищет соответствие любому одиночному символу слова, а не целому слову. (Квантификатор + еще не забыт? Можно задать \w+ для поиска слова.) В Perl можно задать отрицание этих классов, используя символы на верхнем регистре, например, \D для символа, не являющегося цифрой.

Следует заметить, что \w не всегда эквивалентно [a-zA-Z_0-9] (a \d не всегда эквивалентно [0-9]). В некоторых наборах параметров локализации (locales) определяются дополнительные символы, не входящие в ASCII, которые соблюдаются метасимволом \w・ Новым версиям Perl «знакомы» также свойства букв и цифр Unicode, и символы Unicode с этими свойствами обрабатываются надлежащим образом. (Perl и идеограммы рассматривает как символы \w・)

Есть еще один совершенно особенный класс символов, записываемый как точка (.), которому соответствует вообще любой символ. Например, /а./ соответствует любой строке, содержащей а, если только это не последний

символ в строке. Таким образом, это выражение соответствует at или ат, или даже а!, но не а, поскольку после а нет ничего, чему могла бы соответствовать точка. Поскольку поиск шаблона выполняется в любом месте строки, ему соответствуют также oasis и camel, но не sheba. Он соответствует caravan по первой а. Он мог бы соответствовать и второй а, но поиск останавливается после нахождения первого соответствия, слева направо.

Квантификаторы

Символы и классы символов, о которых мы говорили, ищут соответствие одиночным символам. Мы уже говорили, что можно искать соответствие нескольким символам «слова» посредством \w+・ Одним из квантификаторов является +, но есть и другие. Все они помещаются после того элемента, количество вхождений которого определяют.

В самом общем виде квантификатор задает минимальное и максимальное допустимое число соответствий элемента. Эти два числа заключаются в скобки и разделяются запятой. Например, если пытаться найти номера телефонов в Северной Америке, то последовательность \d{7,11} соответствует не менее чем семи цифрам, но не более чем одиннадцати. Если в скобки помещено одно число, то оно задает одновременно минимум и максимум, т. е. точное число соответствий элемента. (Все элементы без указания количества имеют неявный квантификатор {1}.)

Если указать минимум и запятую, но опустить максимум, то максимум принимается равным бесконечности. Иными словами, соответствие должно быть найдено хотя бы минимальное число раз, плюс еще сколько угодно. Например, \d{7} будет соответствовать только первым семи цифрам (к примеру, местному номеру в Северной Америке или первым семи цифрам более длинного номера), в то время как \d{7,} будет соответствовать любому номеру телефона, даже международному (если только он не окажется короче семи цифр). Нет специального способа задания «не более чем» определенного числа раз. Нужно просто сказать, например, {0,5}, чтобы найти не более пяти произвольных символов.

Некоторые сочетания минимума и максимума встречаются так часто, что в Perl для них имеются особые квантификаторы. Мы уже видели +, означающий то же, что {1,}, или «хотя бы один из предшествующих элементов». Имеется также *, что равносильно {0,}, или «ноль или более предшествующих элементов», а также?, что равносильно {0,1}, или «ноль или один предшествующий элемент» (т. е. предшествующий элемент является необязательным). Применяя квантификаторы, следует кое в чем проявлять осторожность. Во- первых, квантификаторы Perl по умолчанию являются жадными. Это означает, что они ищут самое длинное соответствие шаблону из всех возможных. Например, если искать /\d+/ в строке 1234567890, то будет найдена вся строка. За этим нужно следить, особенно если используется символ «.», соответствующий любому символу. Часто встречаются строки типа:

larry:JYHtPhO./NJTU:100:10:Larry Wall:/home/larry:/bin/tcsh

в которых выполняется поиск larry: с помощью /. + :/. Однако, поскольку квантификатор + является жадным, этот шаблон включит все, вплоть до и в том числе /home/larry:, поскольку отыскивается самое длинное соответствие перед последним двоеточием, включая другие двоеточия. Иногда этого можно избежать, используя отрицание класса, т. е. с помощью выражения /［】］+:/, которое требует найти один или несколько символов, не являющихся двоеточием (как можно больше), вплоть до первого двоеточия. Эта маленькая крышечка служит для отрицания класса символов. Другой момент, который надо иметь в виду, - это стремление регулярных выражений находить возможно более раннее соответствие. Оно даже берет верх над жадностью. Поскольку просмотр строки происходит слева направо, это означает, что шаблон будет найден как можно левее, даже если в другом месте есть более длинное соответствие. (Регулярные выражения могут быть жадными, но не тянут с вознаграждением.) Предположим, например, что используется команда подстановки (s///) в строке по умолчанию, т. е. с переменной $_, и требуется удалить строку символов х из середины строки. Если сказать:

$_ = "fred ххххххх barney'1;

s/x*〃；

то эффекта не будет никакого! Это связано с тем, что х* (означающее ноль или более символов х) соответствует «ничему» в начале строки, поскольку нулевая строка имеет длину ноль символов, а ясно, как божий день, что перед символом f в слове f red сидит нулевая строка.

И еще об одной вещи нужно знать. По умолчанию квантификаторы применяются к единственному предшествующему символу, поэтому /Ьат{2}/ найдет bamm, но не bambam. Для того чтобы применить квантификатор к нескольким символам, поставьте скобки. Поэтому для поиска bambam используйте шаблон /(bam){2}/・

Минимальное соответствие

Если при работе со старыми версиями Perl требуется, чтобы поиск не был жадным, то необходимо использовать отрицание класса. (На самом деле все равно получится жадный поиск, но несколько более сдержанный.)

В новых версиях Perl можно принудительно задать нежадный, минимальный поиск, поместив после любого квантификатора вопросительный знак. Теперь тот же наш поиск имени пользователя должен выглядеть как /. *?:/. Этот . *? будет теперь стараться найти не как можно больше символов, а как можно меньше, поэтому остановка произойдет после первого двоеточия, а не последнего.

Как поймать на слове

При попытке найти совпадение с шаблоном проверка осуществляется с каждого места, пока не будет найдено соответствие. Привязка (anchor) позволяет ограничить места, где ищется шаблон. В сущности, привязка есть нечто, соответствующее «ничему», но особому виду «ничего», зависящему от окружения. Можно назвать ее также правилом, ограничением, утверждением. Как бы она ни была названа, она пытается найти нечто нулевой длины, с успехом или без. (Неуспех просто означает, что шаблон нельзя найти этим конкретным способом. Если можно попробовать еще какие-то способы, то будут продолжены попытки найти шаблон этими способами.)

Специальный символ \Ь соответствует границе слова, которая определяется как «ничто» между символом слова (\w) и символом, не принадлежащим слову (\W), в любом порядке. (Символы, которые не существуют перед началом и после конца строки, не считаются символами слова.) Например,

/\bFred\b/

будет соответствовать Fred как в The Great Fred, так и в Fred the Great, но не в Frederick the Great, потому что за d в Frederick не следует символ слова.

В аналогичное русло укладываются символы привязки к началу или концу строки. Символ вставки (八),будучи первым символом строки, соответствует «ничему» в начале строки. Поэтому шаблон /^Fred/ будет соответствовать Fred в Frederick the Great, но не в The Great Fred, тогда как /Fred,'/ не будет найден ни в одной из этих строк. (На самом деле в нем вообще мало смысла.) Знак доллара ($) работает так же, как символ вставки, но соответствует «ничему» не в начале, а в конце строки.1

Теперь, вероятно, читатель уже сможет определить, что говоря:

next LINE if $line =~ /%/;

мы имеем ввиду: «перейти к следующей итерации цикла LINE, если данная строка начинается с символа #».

Ранее мы сказали, что последовательность \d{7,11} будет соответствовать числу длиной от семи до одиннадцати цифр. Будучи абсолютно верным, это утверждение вводит в заблуждение: задание этой последовательности в реальном операторе поиска по шаблону, /\d{7,11}/, не исключает того, что после одиннадцати соответствующих шаблону цифр не окажется других, ему не соответствующих! Для получения желаемого результата часто требуется осуществлять привязку шаблонов с квантификаторами с одного или обоих концов.

Ссылки на найденный текст

Ранее говорилось, что объединять элементы, на которые действует квантификатор, можно с помощью скобок, но можно использовать скобки и для запоминания частей найденного. Пара скобок вокруг части регулярного выражения приводит к тому, что символы, соответствующие этой части в найденном, будут запомнены и смогут использоваться в дальнейшем. При этом критерии поиска не изменяются, поэтому /\d+/ и /(\d+)/ будут искать самую длинную последовательность цифр, но в последнем случае они будут запомнены в специальной переменной, к которой позже можно обратиться.

Способ ссылки на найденную часть строки зависит от того, откуда это нужно сделать. Внутри того же самого регулярного выражения это делается с помощью обратной косой черты, за которой следует целое число. Целое число, соответствующее данной паре скобок, определяется путем подсчета числа левых скобок с начала шаблона, начиная с единицы. Например, для поиска чего-то похожего на тег HTML, типа <B>Bold</B>, можно использовать шаблон /<(. *?)>. *?<\/\1>/. Он требует, чтобы обе его части соответствовали в точности одинаковой строке, как В в данном примере.

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

s/(\S+)\s+(\S+)/$2 $1/

В правой части подстановки (между вторым и третьим символами косой черты) находится просто необычная разновидность строки в двойных кавычках, поэтому и можно производить в ней интерполяцию переменных, включая переменные с найденным текстом. Это важное понятие: интерполяция (в контролируемых условиях) - это одна из причин, по которым Perl является хорошим языком обработки текста. Другой причиной, конечно, является поиск по шаблону. Регулярные выражения предназначены для того, чтобы разобрать на кусочки, а интерполяция - чтобы собрать все вместе снова. Возможно, не все потеряно для Шалтая-Болтая.

Обработка списков

Где-то в начале этой главы мы говорили о том, что в Perl есть два основных контекста: скалярный контекст (для работы с отдельными объектами) и списочный контекст (для работы с множественными объектами). Многие из описывавшихся до сего времени традиционных операторов были по своему действию чисто скалярными. Они всегда принимают одиночные аргументы (или пары одиночных аргументов в бинарных операторах) и всегда производят одиночный результат, даже в списочном контексте. Поэтому если есть запись:

@аггау = (1 + 2, 3 - 4, 5 * 6, 7 / 8);

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

Однако другие операторы Perl могут порождать как скалярные, так и списочные значения, в зависимости от контекста. Они просто «знают», что от них ожидается 一 скаляр или список. Но как можно узнать об этом? Оказывается, это нетрудно сделать, если усвоить некоторые ключевые понятия.

Во-первых, списочный контекст должен быть предоставлен чем-то, находящимся «вокруг». В предшествующем примере его предоставляет присваивание списка. Ранее мы видели, что его предоставляет оператор цикла foreach. Оператор print также предоставляет его. Но не надо заучивать это все.

Посмотрев на синтаксические сводки, разбросанные по оставшейся части книги, можно увидеть операторы, в определении которых в качестве принимаемого аргумента указан LIST. Это и есть операторы, предоставляющие списочный контекст. Всюду в этой книге LIST используется как специфический технический термин, означающий «синтаксическая конструкция, предоставляющая списочный контекст». Например, найдя sort, вы обнаружите такую синтаксическую сводку:

sort LIST

Это значит, что sort предоставляет списочный контекст для своих аргументов.

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

sort @dudes, @chicks, other();

то каждый из @dudes, @chicks и other() знает на этапе компиляции, что от него ждут список, а не скалярную величину. Для отражения этого компилятор генерирует внутренние коды операций.

Позже, на этапе выполнения (когда внутренние коды операций интерпретируются фактически), каждый из этих элементов в LIST порождает свой список, а затем (это важно) все отдельные списки объединяются вместе, друг за другом, в один общий список. Этот расплющенный одномерный список и передается в конечном итоге функции, которая требовала LIST. Поэтому, если @dudes содержит (Fred, Barney), @chicks содержит (Wilma, Betty), а функция other() возвращает список из одного элемента (Dino), то LIST, который получит sort, будет таким:

(Fred,Barney,Wilma,Betty,Dino)

a LIST, который возвратит sort, будет следующим:

(Barney,Betty,Dino,Fred,Wilma)

Одни операторы порождают списки (например, keys), другие потребляют их (например, print), а третьи преобразуют один список в другой (например, sort). Операторы последней категории можно рассматривать как фильтры, но в них, в отличие от оболочки, поток данных идет справа налево, поскольку списочные операторы воздействуют на аргументы, передаваемые им справа. Можно расположить подряд несколько списочных операторов:

print reverse sort map {lc} keys %hash;

В этом выражении функция keys получает ключи из хеша %hash и возвращает их функции тар, которая переводит их все в нижний регистр, применяя к каждому оператор 1с, и передает функции sort, которая сортирует их и передает функции reverse, которая обращает порядок элементов списка и передает их функции print, которая их выводит.

Как видите, описать это на Perl куда проще, чем на естественном языке.

Есть много других случаев, когда обработка списка порождает более естественный код. Невозможно все их здесь перечислить, но чтобы показать пример, вернемся на минуту к регулярным выражениям. Мы уже обсуждали применение шаблонов для поиска в скалярном контексте, но если использовать шаблон в списочном контексте, происходит нечто иное: все ссылки на найденный текст вытаскиваются в виде списка. Допустим, вы производите поиск в журнальном файле или почтовом ящике и хотите разобрать строку, содержащую время в формате «12:59:59 ат». Можно сделать это так:

($hour, $min, $sec, $ampm) = /(\d+):(\d+):(\d+) *(\w+)/;

Это удобный способ присвоить значения одновременно нескольким переменным. Но ничуть не сложнее сказать:

@hmsa = /(\d+):(\d+):(\d+) *(\w+)/;

и поместить все четыре значения в один массив. Как ни странно, но, отделяя мощь регулярных выражений от мощи выражений Perl, списочный контекст увеличивает мощь языка. Мы редко признаемся в этом, но Perl, помимо того, что является диагональным языком, фактически является и ортогональным языком. Можно один пирог съесть дважды.

Чего вы не знаете, то вам не навредит (сильно)

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

язык по ходу дела и обычно с пользой применять язык, не дожидаясь того времени, когда изучат его целиком. Вы не знаете пока Perl целиком, как не знаете целиком и тот язык, на котором разговариваете. Но в культуре Perl это официально считается нормальным. Вы можете с пользой работать на Perl, даже если мы еще не рассказали вам, как создавать собственные подпрограммы. Мы едва коснулись того, как применять Perl для системного администрирования, быстрого создания прототипов, сетевого взаимодействия или в качестве объектно-ориентированного языка. Об этих вопросах можно написать целые главы. (Если вдуматься, то мы это уже сделали.)

Но в конечном итоге читатель должен выработать собственное отношение к Perl. Как художник, вы имеете право на собственные муки творчества. Мы можем показать, как мы пишем картины, но не можем показать, как вы пишете картины. Есть Много Способов Сделать Это.

Получите причитающееся вам удовольствие.

II

Анатомия Perl

2

Всякая всячина

Мы начнем с малого и посвятим эту главу элементам Perl.

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

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

Разумеется, мы будем только приветствовать, если вы заглянете в справочные материалы, имеющиеся в конце книги. (Это не считается перескакиванием через страницы.) В частности, отдельные слова, выделенные моноширинным шрифтом, скорее всего можно найти в главе 29 «Функции». Мы старались сделать изложение не зависящим от операционной системы, но если вы незнакомы с терминологией Unix и столкнетесь со словом, имеющим иной смысл, чем вы себе представляете, следует поискать его в глоссарии. Если не поможет глоссарий, то, вероятно, поможет предметный указатель.

Атомы

Хотя есть много незаметных вещей, которые происходят за кулисами и о которых мы вскоре расскажем, самыми маленькими объектами, с которыми обычно приходится работать в Perl, являются отдельные символы. Мы говорим именно о символах: в прежние времена Perl легко путал байты с символами, а символы с байтами, но в наступившую эпоху глобальных сетей нужно тщательно различать эти две вещи.

Можно, конечно, писать на Perl, ориентируясь исключительно на 7-разряд- ный набор символов ASCII. Но на Perl можно писать и с использованием любого 8- или 16-разрядного набора символов, будь это национальный или какой-либо традиционный алфавит. Однако, если вы станете применять какой-либо из старых (не-ASCII) наборов символов, помните, что символы не- ASCII можно использовать только в строковых литералах. Необходимо обеспечить соответствие семантики программы выбранному национальному алфавиту. Так, работая с 16-разрядным набором азиатских национальных символов не забывайте, что Perl обычно воспринимает каждый из этих символов как два байта, а не один символ.

В главе 15 «Unicode» сказано о том, что недавно в Perl была добавлена кодировка Unicode. Эта поддержка относится к языку в целом: можно использовать символы Unicode как в идентификаторах (например, именах переменных), так и в строках литералов. В случае применения Unicode не нужно беспокоиться о том, сколько бит или байт занимает символ. Perl представляет дело так, как если бы все символы Unicode имели одинаковый размер (а именно 1), даже если какой-то символ имеет внутреннее представление из нескольких байт. Обычно Perl использует для внутреннего представления кодировку с переменной длиной UTF-8. (Например, «смайлик» в кодировке Unicode, U-263A, внутренне представляется последовательностью из трех символов.)

Если вы позволите несколько развить нашу аналогию с физическими элементами, то символы атомарны в том же самом смысле, что и атомы различных элементов. Да, они состоят из более мелких частиц, которые называются битами и байтами, но если расколоть символ на части (очевидно, в символьном ускорителе), то отдельные биты и байты утратят отличительные «химические» свойства целого символа. Как нейтроны являются деталями реализации атома урана-238, так и байты являются деталями реализации символа U-263A.

Поэтому мы будем стремиться говорить: «символы», имея в виду символы, и говорить: «байты», имея в виду байты. Но мы не хотели никого напугать: вы по-прежнему можете легко по старинке обрабатывать байты. Надо только сообщить Perl, что вы по-прежнему хотите рассматривать байты

как символы. Это можно сделать с помощью прагмы (директивы) use bytes (см. главу 31 «Модули прагм»). Даже если вы этого не сделаете, Perl все равно позаботится о том, чтобы хранить маленькие символы в 8 разрядах, как вам того и хотелось бы.

А теперь хватит о мелочах. Переходим к более крупным и приятным вещам.

Молекулы

Perl является языком свободной формы (free-form language), но это не значит, что Perl вообще бесформенный. Компьютерщики обычно используют этот термин для обозначения языка, в котором пробелы, символы табуляции и перевода строки можно помещать где угодно - за исключением тех мест, где этого делать нельзя.

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

Пробельный символ допускается помещать между любыми двумя лексемами, но обязательным его присутствие является только между такими лексемами, которые без него могут быть приняты за одну. Для этой цели могут использоваться любые символы из числа пробельных. Символы перевода строки отличаются от пробелов и символов табуляции только внутри строк, заключенных в кавычки, форматов и некоторых строчно-ориентированных типов заключения в кавычки. Конкретно символ новой строки не служит концом команды (утверждения), как это имеет место в некоторых других языках (например, FORTRAN или Python). В Perl команды завершаются точкой с запятой, как в С и производных от него языках.

Пробельные символы Unicode допускается использовать в Unicode-программах Perl, но при этом следует проявлять осторожность. Применяя особые разделители абзацев и строк из Unicode, учтите, что Perl может пронумеровать строки не так, как это сделает ваш текстовый редактор, из-за чего

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

Лексемы распознаются путем жадного поиска: если в некотором месте анализатор Perl имеет выбор между короткой и длинной лексемами, он предпочтет длинную. Если вам нужно, чтобы это были две лексемы, вставьте между ними пробельный символ. (Мы в любом случае стараемся ставить лишние пробелы по краям большей части операторов, чтобы повысить удобочитаемость.)

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

Еще одна особенность связана с тем, что если строка начинается с = и в этом месте допустимо поместить команду, то Perl игнорирует все, от этой строки вплоть до строки, начинающейся с =cut. Игнорируемый текст считается документацией, или pod («plain old documentation»). В дистрибутив Perl входят программы, извлекающие комментарии типа pod из модулей Perl и преобразующие их в простой текст, страницы руководства, документы LaTeX, HTML, а в скором будущем, возможно, XML. Анализатор Perl, напротив, извлекает код Perl из модулей Perl и игнорирует pod. Можно рассматривать это как второй способ создания многострочных комментариев. Можете не верить, но для модулей Perl, документированных таким способом, документация никогда не теряется. О деталях документирования программ рассказывается в главе 26 «Документирование программ»; там же описывается обработка многострочных комментариев средствами Perl.

Но не пренебрегайте и обычным символом комментария. Есть что-то успокаивающее в аккуратной колонке символов # с левой стороны многострочного комментария. Она немедленно говорит вашим глазам: «Это не код». Заметьте, что даже в языках, имеющих средства создания многострочных комментариев, таких как С, программисты часто все равно помещают колонку символов * по левому краю комментариев. Внешний вид часто важнее, чем может показаться.

В Perl, как в химии и в языке, можно строить все более и более крупные структуры из мелких. Мы уже употребляли слово команда (statement): это просто последовательность лексем, составляющих вместе предложение в повелительном наклонении. Последовательность команд можно объединить в блок, который заключается в фигурные скобки (braces), любовно называемые также «завитушками» теми, кто считает, что braces - это подтяжки.

Блоки, в свою очередь, могут объединяться в еще более крупные блоки. Некоторые блоки действуют как подпрограммы (subroutines), которые могут объединяться в модули (modules), которые могут объединяться в программы (programs). Но мы слишком забегаем вперед - это темы последующих глав. Лучше построим из символов еще несколько лексем.

Встроенные типы данных

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

Языки программирования различаются по числу и видам имеющихся в них типов данных. В отличие от некоторых широко распространенных языков, в которых есть много запутанных типов для сходных между собой видов значений, в Perl довольно мало встроенных типов данных. Возьмите С, в котором можно встретить char, short, int, long, long long, bool, wchar_t, size_t, off_t, regex_t, uid_t, u_longlong_t, pthread_key_t, fp_exception_field_type и т. д. И это только некоторые целочисленные типы! А кроме того есть числа с плавающей запятой, а также указатели, а также строки.

Всем этим сложным типам данных соответствует в Perl единственный тип: скаляр. (Обычно ничего не нужно, кроме простых типов данных Perl, но если что-то потребуется, можно определять необычные динамические типы с использованием объектно-ориентированных возможностей Perl - см. главу 12 «Объекты».) Основными тремя типами данных Perl являются скаляры, массивы скаляров и хеши скаляров (называемые также ассоциативными массивами). Некоторые предпочитают называть их не типами, а структурами данных. Это их право.

Скаляры являются базовым типом, на основе которого строятся более сложные структуры. Скаляр содержит одно простое значение, обычно строку или число. Элементы этого простого типа могут объединяться в один из двух составных типов. Массив - это упорядоченный список скаляров, обращение к которым происходит с помощью целочисленного индекса (subscript). В Perl индексация начинается с 0. Однако, в отличие от многих языков программирования, Perl считает допустимыми отрицательные индексы: вместо отсчета с начала отрицательные индексы ведут обратный отсчет с конца чего бы то ни было индексируемого. (Это относится как к обычному индексированию, так и к различным операциям с подстроками и подсписками.) Напротив, хеш является неупорядоченным списком пар ключ/значение, обращение к которым производится путем использования строки (ключа} в качестве индекса для поиска скаляра (значения), соответствующего данному ключу. Переменные всегда имеют один из этих трех типов. (Кроме переменных в Perl есть другие абстракции, которые можно рассматривать как типы данных, например, дескрипторы файлов, дескрипторы каталогов, форматы, подпрограммы, таблицы имен и записи таблиц имен.)

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

Подобно членам математического уравнения, назначением термов в Perl является создание величин, с которыми действуют операторы типа сложения и умножения. Однако, в отличие от математического уравнения, Perl должен что-то делать с величинами, которые он вычисляет, а не просто размышлять с карандашом в руке, равны ли между собой две части уравнения. Действие чаще всего состоит в том, чтобы где-то запомнить значение:

$Х 二 $у;

Это пример оператора присвоения (а не оператора равенства чисел, который в Perl записывается как ==). Присвоение получает значение из $у и помещает его в $х. Обратите внимание, что терм $х используется не ради его значения, а ради его адреса. (Прежнее значение $х будет уничтожено присвоением.) Мы говорим, что $х является 1-значением (от left value - левое значение), подразумевая под этим, что данный тип памяти может присутствовать в левой части присвоения. Мы говорим, что $у является r-значением (от right value - правое значение), поскольку оно расположено в правой части.

Есть и третий тип значений, называемый временными значениями, который нужно понимать, если вы действительно хотите узнать, что в действительности делает Perl с вашими 1-значением и r-значением. Если мы действительно выполняем какие-то математические действия и говорим:

$х = $у + 1;

то Perl берет левое значение $у и прибавляет к нему правое значение 1, в результате чего создается временное значение, которое в конечном итоге присваивается левому значению $х. Возможно, вам будет легче представить себе зрительно, что происходит, если мы сообщим, что Perl запоминает эти временные значения во внутренней структуре, называемой стеком.1 Термы выражения (о которых мы говорим в данной главе) стремятся протолкнуть значения в стек, тогда как операторы выражения (о которых мы будем говорить в следующей главе) стремятся вытолкнуть их обратно, возможно, оставляя при этом в стеке временный результат, с которым будет работать сле-

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

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

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

Переменные

Неудивительно, что есть три типа переменных, соответствующие трем указанным выше абстрактным типам данных. Каждой из таких переменных предшествует так называемый разыменовывающий префикс (funny character).1 Имя скалярной переменной всегда начинается символом $, даже если ссылка производится на скаляр, являющийся частью массива или хеша. Его действие несколько напоминает использование определенного артикля «the» в английском языке. Таким образом, мы имеем:

Конструкция

Значение

$days

Простое скалярное значение $days

$days[28]

29-й элемент массива @days

$days{'Feb'}

Значение «Feb» из хеша %days

Обратите внимание, что одно и то же имя можно использовать для $days, @days и %days, и при этом Perl не запутается.

Есть и другие, необычные скалярные термы, применяемые в особых ситуациях, в которые мы пока вникать не будем. Они выглядят так:

Конструкция

Значение

${days}

To же, что $days, но устраняется неоднозначность перед буквенно-цифровыми символами

$Dog::days $#days $days->[28]

Еще одна переменная $days, в пакете Dog

Последний индекс массива @days

29-й элемент массива, на который указывает ссылка $days

Это еще один технический термин в вычислительных науках (если раньше он им не был, то сейчас является).

(продолжение)

Конструкция

Значение

$days[0][2]

$days{2000}{'Feb'} $days{2000,'Feb'}

Многомерный массив

Многомерный хеш

Эмуляция многомерного хеша

Массивы в целом (или срезы массивов и хешей) именуются с помощью разыменовывающего символа @, действующего во многом аналогично словам «эти» или «те»:

Конструкция

Значение

@days

@days[3, 4, 5]

@days[3..5]

@days{'Jan','Feb'}

Массив, содержащий ($days[O]t $days[1], ... $days[n]) Срез массива, содержащий ($days[3]t $days[4], $days[5]) Срез массива, содержащий ($days[3], $days[4], $days[5]) Срез хеша, содержащий ($days{' Jan'}, $days{' Feb'})

Хеш в целом именуется с помощью %:

Конструкция%daysКонструкция%daysЗначение

Конструкция

%days

Конструкция

%days

(Jan => 31, Feb => $leap ? 29 : 28,...)

Все эти конструкции могут также служить в качестве 1-значений, задавая адрес, по которому можно присвоить значение. Для массивов, хешей и срезов массивов и хешей 1-значение предоставляет местоположение для присвоения, поэтому можно одновременно присваивать им несколько значений:

@days =1 .. 7;

Имена

Мы говорили о хранении значений в переменных, но и сами переменные (их имена и связанные с ними определения) тоже должны где-то храниться. Теоретически такие места называются пространствами имен (namespaces). В Perl есть два вида пространств имен, которые часто называются таблицами имен (symbol tables) и областями лексической видимости (lexical scopes), Можно иметь произвольное количество таблиц имен и областей лексической видимости, и каждое определяемое вами имя хранится в той или иной из них. Далее мы рассмотрим оба типа пространств имен, но пока только

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

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

Имена подпрограмм могут начинаться с символа &, хотя при вызове подпрограмм задание разыменовывающего префикса не обязательно. Обычно подпрограммы не считаются 1-значениями, но в последних версиях Perl разрешается возвращать из подпрограммы 1-значение и выполнять присвоение по отношению к нему, что выглядит как присвоение подпрограмме.

Иногда требуется имя, которым можно назвать «все, что названо foo», независимо от разыменовывающего символа. Поэтому имена записей таблицы имен могут начинаться символом *, при этом звездочка заменяет все остальные разыменовывающие префиксы. Эти записи называются записями глобальной таблицы имен (typeglobs), и есть несколько способов их использования. Они могут также выступать в качестве 1-значений. Посредством присвоения типу данных typeglob в Perl реализуется импорт имен из одной таблицы имен в другую. Подробнее об этом тоже дальше.

Как и в большинстве языков программирования, в Perl имеется список зарезервированных слов, которые распознаются им как особые ключевые слова. Однако поскольку имена переменных всегда начинаются с разыменовывающего префикса, то зарезервированные слова фактически не конфликтуют с именами переменных. Но некоторые другие типы имен не имеют разыменовывающих префиксов, например дескрипторы файлов и метки. Для таких имен нужно беспокоиться (но не сильно) об отсутствии конфликта с зарезервированными словами. Поскольку в большинстве зарезервированных слов применяется только нижний регистр, рекомендуем выбирать имена меток и дескрипторов файлов так, чтобы они содержали заглавные буквы. Например, говоря open (LOG, logfile), а не предосудительное open(log, "logfile"), нельзя ввести Perl в заблуждение, будто имеется в виду встроенный оператор log (который, конечно же, осуществляет логарифмирование). Использование дескрипторов файлов в верхнем регистре также повышает удобочитае-

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

Как можно было заключить из предыдущего абзаца, в идентификаторах имеет значение регистр - FOO, Foo и foo являются в Perl разными именами. Идентификаторы начинаются с символа подчеркивания или буквы, могут иметь любую длину (где любая длина находится в диапазоне от 1 до 251 включительно) и могут содержать буквы, цифры и символы подчеркивания, в том числе буквы и цифры Unicode. Идеограммы Unicode тоже сойдут за буквы, но не советуем их использовать, если вы не умеете произносить их. См. главу 15 «Unicode».

Имена с разыменовывающими префиксами не обязаны, строго говоря, быть идентификаторами. Они могут начинаться с цифр, и тогда должны содержать только цифры, например $123. Имена, начинающиеся с символа, отличного от буквы, цифры или подчеркивания, ограничены (обычно) одним символом (например, $? или $$) и обычно имеют в Perl предопределенное значение. Например, как и в оболочке Борна, $$ является идентификатором текущего процесса, а $? - статусом завершения последнего дочернего процесса.

Начиная с версии 5.6 в Perl появился открытый синтаксис для внутренних имен переменных. Всякая переменная вида ${^NAME} является специальной переменной, зарезервированной для применения в Perl. Все эти имена, не являющиеся идентификаторами, помещаются в главную таблицу имен. Некоторые примеры можно найти в главе 28 «Специальные имена».

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

$Santa::Helper::Reindeer::Rudolph::nose

Это похоже на каталоги и имена файлов в именах маршрутов:

/Santa/Helper/Reindeer/Rudolph/nose

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

менной в самой глубоко вложенной таблице имен. Например, в приведенной ранее переменной именем таблицы является Santa::Helper::Reindeer: Rudolph: :,а фактическая переменная в этой таблице имен 一 $nose (нос). (А значением этой переменной является, конечно, «красный».)

Таблицу имен в Perl называют также пакетом (package), поэтому соответствующие переменные часто называются пакетными. Пакетные переменные номинально принадлежат пакету, в котором существуют, но являются глобальными в том смысле, что сами пакеты глобальны. Это значит, что каждый может указать имя пакета, чтобы добраться до переменной, но просто по ошибке это сделать трудно. Например, всякая программа, в которой упоминается $Dog: :bert, запрашивает переменную $be「t из пакета Dog::. А эта переменная совсем не такая, как $Cat: :bert. См. главу 10 «Пакеты».

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

Поиск имен

Итак, вопрос: что в имени тебе моем? Как Perl определяет, что вы имеете в виду, говоря просто $bert? Хороший вопрос. Вот правила, которыми руководствуется анализатор Perl, пытаясь понять неквалифицированное имя в контексте:

Сначала Perl просматривает ближайший охватывающий блок и проверяет, нет ли в этом блоке данной переменной в объявлениях ту или our (почитайте о них в главе 29 «Функции» и разделе «Объявления с областью видимости» главы 4 «Команды и объявления»). Если объявление ту есть, то переменная имеет лексическую область видимости и не существует ни в каком пакете - она существует только в этой лексической области видимости (т. е. во временной памяти этого блока). Поскольку лексические области видимости безымянны, никто вне этого фрагмента не может даже назвать вашу переменную.

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

области видимости от точки объявления до конца блока, в котором она объявлена, включая вложенные блоки, например тот, из которого мы пришли на шаге 1. Если Perl не находит объявления, он повторяет шаг 2, пока не кончатся охватывающие блоки.

Когда Perl не может больше найти блоки, охватывающие данные, он рассматривает всю компилируемую единицу и ищет в ней объявления, как если бы это был блок (компилируемой единицей является весь текущий файл или строка, компилируемая в данный момент оператором eval STRING). Если компилируемой единицей является файл, то это самая большая возможная лексическая область видимости, и Perl прекращает дальнейший поиск лексических областей видимости, поэтому мы переходим к шагу 4. Если компилируемой единицей является строка, то все не так просто. Строка, компилируемая как код Perl на этапе выполнения, представляется блоком в лексической области видимости, из которой вызван eval STRING, хотя действительными границами лексической области видимости являются не фигурные скобки, а границы строки, содержащей код. Поэтому, если Perl не находит переменной в лексической области видимости строки, действие происходит так, как если бы eval STRING был блоком, и выполняется возврат к шагу 2, только на этот раз поиск начинается с лексической области видимости оператора eval STRING, а не с области внутри его строки.

Если мы попали сюда, это значит, что Perl не нашел для переменной никаких объявлений (ни ту, ни our). Теперь Perl отказывается от поиска переменной с лексической областью видимости и считает, что переменная является пакетной. Если действует директива strict, то в данном случае будет получена ошибка, если только эта переменная не является одной из предопределенных переменных Perl или не импортирована в текущий пакет. Дело в том, что данная директива запрещает использование неквалифицированных глобальных имен. Однако мы еще не покончили с лексическими областями видимости. Perl осуществляет такой же поиск лексических областей видимости, как на шагах с 1 по 3, но на этот раз ищет не объявления переменных, а объявления пакетов. Если он находит такое объявление пакета, то полагает, что текущий код компилируется для указанного пакета, и делает имя объявленного пакета префиксом переменной.

Не обнаружив объявления пакета в окружающей лексической области видимости, Perl ищет имя переменной в непоименованном пакете верхнего уровня, именем которого оказывается main, если только у него не отсутствует тег имени. Поэтому, в отсутствие противоречащих тому объявлений, $bert означает то же, что $:: bert, что означает то же, что $main:: bert. (Но поскольку main является пакетом в непоименованном пакете верхнего уровня, то это также $: :main: :bert, и $main: :main: :bert, $: :main: :main: :bert и т. д. Это можно рассматривать как бесполезный факт. Однако загляните в раздел «Таблицы имен» главы 10 «Пакеты».)

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

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

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

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

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

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

Местонахождение обычного имени переменной можно полностью определить на этапе компиляции.

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

$bert

можно сказать:

${ some_expression() }

и если функция some_expression() возвращает ссылку на переменную $bert (или даже строку bert), то это равносильно тому, что вы сказали бы $be「t. С другой стороны, если функция возвращает ссылку на $ernie, то вы получите

его переменную. Продемонстрированный синтаксис является наиболее общим (и наименее доходчивым) вариантом косвенности, но мы расскажем о некоторых его удобных разновидностях в главе 8 «Ссылки».

Скалярные значения

Скаляр, будь он поименован прямо или косвенно, находись он в переменной, элементе массива или временной величине, всегда содержит единственное значение. Этим значением может быть число, строка или ссылка на другой фрагмент данных. Значение может также вовсе отсутствовать, и тогда скаляр называют неопределенным (undefined). Хотя можно говорить, что скаляр «содержит» число или строку, скаляры не имеют типа: не требуется объявлять, что скаляр имеет тип целого числа или числа с плавающей точкой, строки или какой-либо еще.

Perl хранит строки как последовательности символов без каких-либо ограничений на размер или содержимое. Простыми словами, не нужно решать заранее, насколько длинными будут строки, а включать в них можно любые символы, в том числе нулевые байты. Perl старается сохранять числа как целые со знаком, а если это невозможно, то как величины с плавающей точкой и двойной точностью в родном формате машины. Точность значений с плавающей точкой не бесконечна. Об этом нужно помнить, иначе равенства типа (10/3 二二 1/3*10) по таинственным причинам не будут выполняться.

При необходимости Perl осуществляет преобразование между различными подтипами, поэтому можно обращаться с числом как со строкой и со строкой как с числом, и Perl будет поступать как должно. Чтобы преобразовать строку в число, Perl внутренне использует нечто вроде функции atof(3) из библиотеки С. Чтобы преобразовать число в строку, он на большинстве машин осуществляет действие, эквивалентное вызову sprintf(3) с форматом "%. 14g". Попытки преобразования нечисловой строки типа foo в число дают в результате числовой 0 и вызывают вывод предупредительных сообщений, если он включен. Примеры определения типа данных, содержащихся в строке, можно найти в главе 5 «Поиск по шаблону».

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

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

Под неприводимостью мы понимаем то, что нельзя, например, преобразовать ссылку на массив в ссылку на хеш. Ссылки не преобразуются в другие типы указателей. Однако если использовать ссылку как число или строку, то получается числовое или строковое значение, которому обеспечено сохранение уникальности ссылки, даже несмотря на то, что «ссылочность» значения утрачивается при его копировании из действительной ссылки. Такие величины можно сравнивать или определять их тип. Но сделать что-либо еще с этими величинами трудно, поскольку нельзя преобразовать числа или строки обратно в ссылки. Обычно это не вызывает проблем, поскольку Perl не принуждает вас заниматься арифметикой указателей 一 и даже не разрешает ее. Дополнительные сведения о ссылках см. в главе 8 «Ссылки».

Числовые литералы

Числовые литералы задаются в одном из нескольких обычных форматов чисел с плавающей запятой или целых чисел:

$х

=12345;

# целое

$х

=12345.67;

# с плавающей точкой

$х

=6.02е23;

# научная нотация

$х

=4_294_967一296;

# подчеркивания для лучшей читаемости

$х

=0377;

# восьмеричное

$х

=Oxffff;

# шестнадцатеричное

$х

二 0Ы100_0000;

# двоичное

Поскольку Perl использует запятую в качестве разделителя в списках, она не может выступать в качестве разделителя тысяч в больших числах. Для этой цели Perl разрешает применять символ подчеркивания. Символ подчеркивания действует только в числовых литералах, определяемых в вашей программе, но не в строках, выступающих как числа, или данных, считываемых из какого-либо другого места. Аналогичным образом префиксы Ох для шестнадцатеричных чисел, ОЬ для двоичных и 0 для восьмеричных действуют только в литералах. Автоматическое преобразование строки в число не распознает эти префиксы: необходимо выполнять явное преобразование с помощью функции oct, которая обрабатывает также и шестнадцатеричные и двоичные числа с префиксами Ох или ОЬ.

Строковые литералы

Строковые литералы обычно заключаются в одинарные или двойные кавычки. Они действуют во многом так же, как в оболочке Unix: строковые литералы в двойных кавычках подвергаются интерполяции обратного слэша и переменных, а строки в одинарных кавычках - нет (за исключением \' и \\, чтобы можно было включать одинарные кавычки и обратную косую черту в строки, заключенные в одинарные кавычки). Если требуется встроить другую последовательность с обратного слэша, например \п (перевод строки), то следует выбрать формат в двойных кавычках. (Последовательности с обратного слэша называются также езсаре-последователъностями, поскольку позволяют временно «избежать» обычной интерпретации символов.)

Строка, заключаемая в одинарные кавычки, должна отделяться пробелом от предшествующего слова, поскольку одинарная кавычка является допустимым, хотя и архаичным, символом идентификатора. Вместо него теперь используется более отчетливо видимая последовательность : :. Это означает, что $main' var и $main: : van суть одно и то же, но считается, что вторую запись легче читать и человеку, и программе.

Строки, заключенные в двойные кавычки, подвергаются различным видам интерполяции символов, многие из которых окажутся знакомы программирующим на других языках. Они перечислены в табл. 2.1.

Таблица 2.1. Escape-последовательности с обратным слэшем

Код

Значение

\п \г \t \f \b

\а \е \ОЗЗ \x7f \сС \х{263а} \N{NAME}

Перевод строки (обычно LF)

Возврат каретки (обычно CR)

Горизонтальная табуляция

Подача листа

Забой

Тревога (звонок)

ESC-символ

ESC в восьмеричном виде

DEL в шестнадцатеричном виде

<Ctrl>+<C>

Unicode (смайлик)

Именованный символ

Обозначение \N{NAME} используется только совместно с прагмой charnames, описанной в главе 31 «Модули прагм». Она позволяет задавать символические имена символов, например, \N{GREEK SMALL LETTER SIGMA}, \N{greek:Sigma} или \N{sigma} - в зависимости от способа вызова директивы. См. также главу 15 «Unicode».

Существуют также escape-последовательности для изменения регистра или «метасвойств» последующих символов, приведенных в табл. 2.2.

Таблица 2.2. Escape-последовательности трансляции

Код

Значение

\и

Перевести следующий символ в верхний регистр («регистр заголовка» (titlecase) в Unicode)

\1 \и \L

Перевести следующий символ в нижний регистр

Перевести все следующие символы в верхний регистр

Перевести все следующие символы в нижний регистр

\о

Поставить обратную косую черту во всех последующих символах, не являющихся буквой или цифрой

\Е

Прекратить действие \U \L или \Q

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

Кроме перечисленных выше escape-последовательностей, начинающихся с обратным слэшем, строки, заключенные в двойные кавычки, подвергаются интерполяции переменных скалярными и списочными значениями. Это означает, что значения некоторых переменных можно вставлять непосредственно в строковый литерал. По сути это просто удобная форма конкатенации строк. Интерполяция переменных может выполняться для скалярных переменных, целых массивов (но не хешей), отдельных элементов массива или хеша либо срезов (множественных индексов) массива или хеша. Интерполяция чего-либо другого не производится. Иными словами, интерполировать можно только выражения, начинающиеся с $ или @, поскольку это те два символа (наряду с обратным слэшем), которые ищет анализатор строк. Внутри строк литерал @, не являющийся частью идентификатора массива или среза, но за которым следует буквенно-цифровой символ, должен быть предварен обратным слэшем (\@), иначе возникает ошибка компиляции. Хотя хеш в целом, обозначаемый с помощью %, не может интерполироваться в строку, отдельные значения хеша или его срезы допускаются, поскольку начинаются с $ и @, соответственно.

Следующий фрагмент кода выводит "Цена $100.":

$Price = '$100';# не интерполируется

print "Цена $Price.\п";# интерполируется

Как и в некоторых оболочках, можно заключить идентификатор в фигурные скобки, чтобы отличить его от последующих буквенно-цифровых символов: "How ${verb}able!". Идентификатор в таких скобках преобразуется в строку, как всякий отдельный идентификатор в индексе хеша. Например:

$days{'Feb'}

можно записать как:

$days{Feb}

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

$days{'February 29th'}# Ok.

$days{"February 29th"}# Тоже ok. "" не надо интерполировать.

$days{ February 29th }# НЕВЕРНО, влечет ошибку анализатора.

В частности, всегда нужно использовать кавычки в таких срезах, как:

@days{'Jan','Feb'}# Ok.

@days{"Jan","Feb"}# Тоже ok.

@days{ Jan, Feb }# He совсем (ошибка при use strict)

Помимо индексов интерполируемых переменных массивов и хешей, нет нескольких уровней интерполяции. В противоположность ожиданиям программирующих для оболочек, обратные кавычки не приводят к интерполяции внутри двойных кавычек, и одинарные кавычки не влекут вычисление переменных, когда используются внутри двойных кавычек. Интерполяция является очень мощным средством, но в Perl находится под жестким контролем. Она происходит только в двойных кавычках и некоторых других операциях типа двойных кавычек, о которых мы расскажем в следующем разделе:

print "\n";# 0k, вывод перевода строки.

print \п ;# НЕВЕРНО, нет интерполируемого контекста.

Выберите свои кавычки

Хотя обычно мы рассматриваем кавычки как литеральные значения, в Perl они действуют скорее как операторы, предоставляя различные возможности интерполяции и поиска по шаблону. Для этих режимов Perl предоставляет возможность выбора собственных символов вместо кавычек, а также более общий способ выбора символа кавычек для каждого из этих режимов. В таблице 2.3 показано, что вместо / можно указать любой буквенно-цифровой символ, отличный от пробельного. (Символы перевода строки и пробела

больше нельзя использовать в качестве разделителей, хотя в старых версиях Perl это разрешалось.)

Таблица 2.3. Структуры «закавычивания»

Пользовательские

Общие

Значение

Интерполируется

q〃

Строка-литерал

Нет

qq〃

Строка-литерал

Да

qx〃

Выполнение команды

Да

О

qw〃

Список слов

Нет

〃

m//

Поиск по шаблону

Да

s///

s///

Замена по шаблону

Да

У///

tr///

Транслирование симво

Нет

лов

qr//

Регулярное выражение

Да

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

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

Ssingle = q!Я сказал: "Ты сказал: 'Она сказала это. "'!;

$double = qq(Можем мы получить какую-нибудь "хорошую" $variable?); $chunk_of_code = q {

if (Scondition) { print "Гоча!";

}

}；

Последний пример показывает, что можно использовать пробельный символ между спецификатором кавычек и их открывающим символом. В двухэлементных конструкциях, таких как s/// и tr///, когда первая пара кавычек служит парой скобок, вторая часть получает свой собственный символ начальной кавычки. В действительности вторая пара не обязательно должна совпадать с первой, поэтому можно писать такие вещи, как s<foo>(bar) или tr(a-f )[A-F]. Поскольку между двумя внутренними символами кавычек допускается наличие пробельного символа, последний пример можно записать даже так:

tr (a-f)

[A-F];

Однако пробельные символы недопустимы, когда в качестве кавычек выступает #• q#foo# разбирается анализатором как строка ' f оо', a q #foo# - как оператор кавычек q, за которым следует комментарий. Символ-ограничитель этого оператора будет взят со следующей строки. Комментарии можно помещать в середину двухэлементных конструкций, что позволяет писать:

s {foo} # Заменить foo {bar}; # на bar.

tr [a-f] # Перевести шестнадцатеричные цифры из нижнего регистра [A-F]; #в верхний

Или опустите кавычки полностью

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

@days 二(Mon,Tue,Wed,Thu,Fri);

print STDOUT hello, ' ', world, "\n";

записывает в массив ©days сокращенные названия дней недели и выводит hello world и символ перевода строки на STDOUT. Если опустить дескриптор файла, то Perl попытается интерпретировать в качестве дескриптора файла hello, что приведет к синтаксической ошибке. Поскольку применение голых слов чревато возникновением ошибок, некоторые программисты склонны их избегать вовсе. Перечисленные выше операторы кавычек предоставляют много удобных форм, в том числе конструкцию qw〃 «заключения слов в кавычки», которая точно заключает в кавычки список слов, разделенных пробелами:

@days 二 qw(Mon Tue Wed Thu Fri);

print STDOUT "hello world\n";

Можно пойти и на то, чтобы вообще запретить использование голых слов. Если сказать:

use strict 'subs';

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

no strict 'subs';

Обратите внимание, что голые идентификаторы в конструкциях типа:

"${verb}able"

$days{Feb}

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

Имя без кавычек, за которым следуют два двоеточия, например main: : или Dog::, всегда считается именем пакета. На этапе компиляции Perl преобразует могущее оказаться голым словом Camel:: в строку Camel, поэтому при наличии директивы use st rict его применение не вызовет осуждения.

Интерполяция величин, являющихся массивами

Переменные, являющиеся массивами, интерполируются в строки, заключенные в двойные кавычки, путем объединения всех элементов массива через разделитель, заданный в переменной $ т (по умолчанию содержащей пробел). Эквивалентны следующие формы:

$temp = join( $", @ARGV );

print $temp;

print "@ARGV";

В шаблонах поиска, тоже подвергающихся интерполяции двойных кавычек, возникает досадная двусмысленность: следует ли /$foo[ba「]/ интерпретировать как /${foo}[ba「]/ (где [bar] является классом символов в регулярном выражении) или как /${foo[bar]}/ (где [bar] является индексом массива @foo)? Если @foo не существует, то это, очевидно, класс символов. Если @foo существует, Perl пытается угадать, чем является [bar], и почти всегда с успехом. Если он угадывает неверно или вы страдаете паранойей, то можно принудительно задать правильную интерпретацию с помощью фигурных скобок, как показано выше. Даже если вы всего лишь проявляете благоразумие, это может быть неплохой мыслью.

Встроенные документы («here» documents)

Строчно-ориентированная форма расстановки кавычек основана на синтаксисе встроенных документов (here-documents) оболочки Unix. Под строчной ориентированностью имеется в виду, что ограничителями являются не символы, а строки. Начальным ограничителем является текущая строка, а конечным - строка, которую вы задаете. Вслед за « задается строка, которая должна завершить заключаемый в кавычки текст, и все строки, следующие за текущей, но исключая завершающую, становятся частью строки. Завершающая строка может быть идентификатором (словом) или некоторым текстом, заключенным в кавычки. В случае применения кавычек их тип определяет обработку текста, как и при обычном использовании кавычек. Идентификатор без кавычек действует так, как если бы был заключен в двойные кавычки. Идентификатор, которому предшествует обратная косая черта, действует так, как если бы он был заключен в одинарные кавычки (для совместимости с синтаксисом оболочки). Между « и идентификатором без кавычек не должно быть пробела, хотя пробельный символ разрешен, если указывается не голый идентификатор, а строка в кавычках. (Если вставить пробел, то он будет рассматриваться как нулевой идентификатор, что допустимо, но осуждается, и соответствует первой пустой строке - см. первое Ура! в нижеследующем примере.) Завершающая строка должна задаваться в чистом виде, без кавычек и лишних пробельных символов по концам в последней строчке.

print «EOF; # то же, что в прежнем примере Цена $Price.

EOF

print «"EOF"; # то же, что выше, но с явными кавычками Цена $Price.

EOF

print «'EOF';# Одинарные кавычки

All things (e.g. a camel's journey through A needle's eye) are possible, it's true. But picture how the camel feels, squeezed out In one long bloody thread, from tail to snout.

--C.S. Lewis

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

EOF

print « х 10;# вывести следующую строку 10 раз

Верблюды идут! Ура! Ура!

print У" х 10; # более предпочтительная запись того же Верблюды идут! Ура! Ура!

print «'ЕОС';# выполнить команды

echo эй, там!

echo смотри туда! ЕОС

print «"верблюд одногорбый", «"camelid"; # можно собрать в кучу Я сказал верблюд двугорбый.

верблюд одногорбый Она сказала лама, camelid

funkshun(«"3T0", 23, «'ТО);# то, что они в скобках, не имеет значения

Вот строка

или две строки.

ЭТО

Вот еще одна.

ТО

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

print «'odd'

2345 odd

+ 10000;# выводит 12345

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

($quote = «'QUOTE') =~ s/\s+〃gm;

The Road goes ever on and on,

down from the door where it began.

QUOTE

Можно даже заполнить массив строчками встроенного документа, например:

@sauces = «End_Lines =~ m/(\S. *\S)/g;

обычный томатный

томатный со специями зеленый чили сырный "зеленый" с белым вином

End_Lines

Литералы v-строк

Литерал, начинающийся с v, за которым следуют одно или более целых чисел, разделяемых точками, рассматривается как строковый литерал, состоящий из символов с указанными порядковыми номерами:

$crlf 二 v13.10;$crlf 二 v13.10;# ASCII-символы возврата каретки, перевода строки

$crlf 二 v13.10;

$crlf 二 v13.10;

Такие литералы называются v-строками, сокращенно от «векторных строк» или «строк версии» или чего-нибудь еще, что можно вообразить себе начинающимся с «V» и содержащим список целых чисел. Они предоставляют альтернативный и более доходчивый способ создания строк, когда требуется задать численные значения для каждого символа. Так, например, v1.20. 300.4000 служит более приятным средством создания строкового значения, чем любое из следующих:

"\x{1}\x{14}\x{12c}\x{fa0}" packC'U*", 1, 20, 300, 4000) chr(1) . chr(20) . chr(300) . chr(4000)

Если в таком литерале две или более точки (три или более целых числа), то ведущее v можно опустить.

print v9786;print v102.111.111;print 102.111.111;print v9786;print v102.111.111;print 102.111.111;use 5.6.0;use 5.6.0;# выводит SMILEY в кодировке UTF-8, "\х{263а}

print v9786;

print v102.111.111;

print 102.111.111;

print v9786;

print v102.111.111;

print 102.111.111;

use 5.6.0;

use 5.6.0;

# выводит "foo"

# то же самое

# требует указанной версии Perl (или более новой)

Sipaddr 二 204.148.40.9;Sipaddr 二 204.148.40.9;# IPv4-aflpec oreilly.com# IPv4-aflpec oreilly.com

Sipaddr 二 204.148.40.9;

Sipaddr 二 204.148.40.9;

# IPv4-aflpec oreilly.com

# IPv4-aflpec oreilly.com

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

Номера версий и IP-адреса, хранящиеся в v-строках, не предназначены для чтения человеком, поскольку отдельные целые числа хранятся в виде произвольных символов. Чтобы создать нечто читаемое, используйте флаг v в маске printf, например "%vd", согласно описанию sprintf в главе 29 «Функции». Дополнительные сведения о строках Unicode можно найти в главе 15 «Unicode», а о директиве use bytes - в главе 31 «Модули прагм»; о сравнении строк версий с применением операторов сравнения строк и представлении адресов IPv4 см. описание gethostbyaddr в главе 29 «Функции».

Другие литеральные лексемы

Все идентификаторы, начинающиеся и оканчивающиеся удвоенным символом подчеркивания, зарезервированы в Perl для особых синтаксических целей. Двумя такими особыми литералами являются —LINE— и ―FILE—, кото-

рые представляют текущие номер строки и имя файла в данной точке вашей программы. Их можно использовать только как отдельные лексемы, они не интерполируются в строки. Аналогично, __PACKAGE__ представляет собой имя пакета, в который компилируется текущий код. Если текущего пакета нет (согласно пустой директиве package;), —PACKAGE— имеет неопределенное значение. Лексему —END(или же символы Control-D или Control-Z) можно использовать для обозначения логического окончания сценария до реального конца файла. Любой следующий за ними текст игнорируется, но может быть прочитан с помощью дескриптора файла DATA.

Лексема „DATA__ действует аналогично лексеме __END__, но открывает дескриптор файла DATA в пространстве имен текущего пакета, поэтому в файлах, загружаемых посредством require, могут одновременно быть открыты собственные дескрипторы файлов DATA. За дополнительными сведениями обратитесь к описанию DATA в главе 28 «Специальные имена».

Контекст

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

Скалярный и списочный контексты

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

$х = funkshun(); # скалярный контекст $х[1] = funkshun(); # скалярный контекст $x{"ray"} = funkshun(); # скалярный контекст

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

# списочный контекст# списочный контекст# списочный контекст # списочный контекст # списочный контекст# списочный контекст # списочный контекст # списочный контекст@х=funkshun();

# списочный контекст

# списочный контекст

# списочный контекст # списочный контекст # списочный контекст

# списочный контекст # списочный контекст # списочный контекст

@х[1]=funkshun();

@x{"ray"} =funkshun();

%х=funkshun();

Присвоение списку скаляров тоже обеспечивает списочный контекст в правой части, даже если в списке только один элемент:

($x,$y,$z) = funkshun(); # списочный контекст ($х) = funkshun(); # списочный контекст

Правила остаются неизменными при объявлении переменной путем модификации терма с помощью ту или our, поэтому:

my $х = funkshun(); # скалярный контекст my @х = funkshun(); # списочный контекст my %х = funkshun(); # списочный контекст my ($х) = funkshun(); # списочный контекст

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

Если некоторые операторы реагируют на контекст, то, очевидно, должно быть что-то, окружающее их, предоставляющее этот контекст. Мы показали, что присвоение может предоставлять контекст своему правому операнду, но это не должно удивлять, поскольку все операторы предоставляют тот или иной контекст для каждого из своих операндов. Что действительно необходимо знать, так это то, какие операторы какой контекст предоставляют своим операндам. Оказывается, отличить операторы, предоставляющие списочный контекст, не трудно, поскольку в их синтаксических описаниях указан LIST. Все остальное предоставляет скалярный контекст. Обычно это вполне интуитивно. При необходимости можно установить скалярный контекст для аргумента в середине LIST с помощью псевдофункции scalar. В Perl нет средства установки списочного контекста в скалярном контексте, поскольку там, где требуется списочный контекст, он уже обеспечен с помощью LIST какой-либо управляющей функции.

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

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

Логический (булев) контекст

Другим особым произвольным скалярным контекстом является булев контекст. Булев контекст представляет собой просто любое место, где вычисляется значение выражения и проверяется его истинность. Когда в этой книге мы говорим «true» и《false», то имеем в виду используемое в Perl техническое определение: скалярное значение является истинным, если оно не равно нулевой строке "" или числу 0 (или его строковому эквиваленту, "О'). Ссылка всегда истинна, поскольку представляет адрес, не могущий быть 0. Неопределенное значение (часто обозначаемое undef) всегда ложно, поскольку является "" или 0, в зависимости от того, рассматривается ли это значение как строка или как число. (Списочные величины не имеют логического значения, поскольку никогда не создаются в скалярном контексте!)

Поскольку булев (логический) контекст является безразличным контекстом, он не вызывает преобразования скаляров, хотя, конечно, сам скалярный контекст налагается на любой операнд, различающий контекст. А для многих различающих операндов скаляр, создаваемый ими в скалярном контексте, представляет собой некоторое булево значение. Это значит, что операторы, создающие список в списочном контексте, могут быть использованы для проверки на true/false в булевом контексте. Например, в списочном контексте, производимом оператором unlink, имя массива порождает список его значений:

unlink @files; # Удалить все файлы, игнорируя ошибки.

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

while (©files) {

my $file = shift ©files;

unlink $file or warn "Невозможно удалить $file: $!\n";

}

Здесь @files вычисляется в логическом контексте, предоставляемом командой while, поэтому Perl вычисляет сам массив и проверяет, является ли он истинным массивом или ложным массивом. Истинным массивом он остается, пока в нем содержатся имена файлов, но становится ложным, как только из него выталкивается последнее имя файла. Обратите внимание, что

остается справедливым сказанное нами выше. Несмотря на то что массив содержит (и может порождать) списочное значение, мы не вычисляем списочное значение в скалярном контексте. Мы сообщаем массиву, что он скаляр, и спрашиваем, что он сам о себе думает.

Не соблазнитесь использованием для этого defined ©files. Ничего не получится, потому что функция defined определяет, является ли скаляр равным undef, но массив - это не скаляр. Достаточно простой логической проверки.

Пустой контекст

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

"Camel Lot";

можно получить предупреждение такого вида:

Useless use of a constant in void context in myprog line 123;

[бесполезное использование константы в пустом контексте в myprog, строка 123]

Интерполирующий контекст

Выше мы говорили, что в литеральных строках в двойных кавычках производится интерполяция обратного слэша и переменных, но интерполирующий контекст (часто называемый контекстом двойных кавычек, поскольку не все могут выговорить « интерполирующий ») применяется не только к строкам в двойных кавычках. Среди других конструкций двойных кавычек находятся обобщенный оператор обратных кавычек qx//, оператор поиска по шаблону т//, оператор подстановки s/// и оператор заключения в кавычки регулярного выражения qr//. Оператор подстановки производит интерполяцию в левой части перед поиском по шаблону, а затем интерполяцию в правой части при каждом нахождении соответствия левой части.

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

Списочные значения и массивы

Теперь, когда мы обсудили контексты, можно поговорить о списочных литералах и их поведении в контексте. Вы уже видели несколько списочных ли-

тералов. Списочные литералы обозначаются путем разделения отдельных значений запятыми (и заключения списка в круглые скобки, если этого требует приоритетность). Поскольку (почти) никогда не вредно добавить пару лишних скобок, синтаксическая диаграмма списочного значения обычно обозначается так:

(LIST)

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

Однако в скалярном контексте списочный литерал ведет себя не так, как LIST, поскольку не предоставляет списочный контекст своим значениям. Вместо этого он просто вычисляет каждый из своих аргументов в скалярном контексте и возвращает значение последнего элемента. Это происходит потому, что он представляет собой в действительности просто замаскированный оператор запятой из С, который является бинарным оператором, всегда отбрасывающим значение слева и возвращающим значение справа. Говоря на языке обсуждавшегося нами выше, левая сторона оператора запятой, в сущности, предоставляет пустой контекст. Поскольку оператор запятой обладает левой ассоциативностью, то ряд значений, разделяемых запятыми, приводит в итоге к последнему значению, т. к. последняя запятая отбрасывает все, что произвели предыдущие запятые. Разница между контекстами видна из того, что списочное присвоение

©stuff = ("один", "два", "три");

присваивает все списочное значение массиву @stuf f, но скалярное присвоение

$stuff = ("один", "два", "три");

присваивает только значение «три» переменной $stuff・ Подобно упоминавшемуся выше массиву @files, оператор запятой знает, находится он в скалярном или списочном контексте, и действует соответствующим образом.

Можно повторить, что списочное значение отлично от массива. Действительная переменная массива знает также свой контекст и в списочном контексте возвращает свой внутренний список значений как списочный литерал. Но в скалярном контексте она возвращает только размер массива. В следующем примере переменной $stuf f присваивается значение 3:

©stuff 二("один", "два", "три");

$stuff 二 ©stuff;

Если вы ожидали значение "три", то, вероятно, сделали неверное обобщение, предположив, что Perl использует правило оператора запятой, чтобы отбросить все, кроме одного, временные значения, которые помещены @stuff на стек. Но дело обстоит не так. Массив @stuf f не помещал все свои значения на стек. В действительности он не помещал на стек ни одного своего значения. Он поместил лишь одну величину, размер массива, поскольку знал, что находится в скалярном контексте. Ни один терм или оператор в скалярном контексте не помещает на стек список. Вместо этого он помещает в стек один скаляр (каким бы непривычным это ни показалось), который едва ли окажется последним значением списка, которое он возвратил бы в списочном контексте, потому что последнее значение вряд ли окажется самым полезным значением в скалярном контексте. Уловили? (Если нет, лучше перечитайте этот абзац еще раз, поскольку это важно.)

Теперь вернемся к настоящим LIST - тем, которые образуют списочный контекст. До сих пор мы представляли дело так, будто списочные литералы являются просто списками литералов. Но так же как строковый литерал может интерполировать другие подстроки, списочный литерал может интерполировать другие подсписки. В списке может находиться любое выражение, возвращающее значения. Используемые при этом значения могут быть скалярными или списочными, но все они становятся частью нового списочного значения, потому что LIST производит автоматическую интерполяцию подсписков. Это означает, что при вычислении LIST каждый элемент списка вычисляется в списочном контексте, и результирующее списочное значение интерполируется в LIST, как если бы каждый отдельный элемент был членом LIST. Поэтому массивы утрачивают свою индивидуальность в LIST. Список

(@stuff,©nonsense, funkshun())

содержит элементы @stuf f, за которыми следуют элементы @nonsense, а за ними следуют те значения, которые подпрограмма &funkshun сочтет нужными возвратить в списочном контексте. Обратите внимание, что все они могут интерполироваться нулевым (пустым) списком, и в этом случае все происходит так, как если бы в этом месте не интерполировался никакой массив или вызов функции. Собственно нулевой список представляется литералом (). Как и для нулевого массива, который интерполируется как нулевой список и потому фактически игнорируется, интерполяция нулевого списка в другой список не оказывает никакого эффекта. Поэтому ((),(),()) эквивалентно ().

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

©releases =(

"альфа",

бета", гамма",

Можно вообще отказаться от запятых: другим способом задания списка литералов является упомянутый выше синтаксис qw (заключение в кавычки слов). Эта конструкция эквивалентна расщеплению строки в одинарных кавычках по пробельным символам. Например:

@froots = qw(

яблокобананкарамболь

кокосгуавакумкват

мандарин грушамандарин грушанектарин хурманектарин хурмаперсик сливаперсик слива

мандарин груша

мандарин груша

нектарин хурма

нектарин хурма

персик слива

персик слива

(Обратите внимание, что эти круглые скобки ведут себя не как обычно, а как кавычки. С таким же успехом это могли быть угловые или фигурные скобки или косая черта. Но круглые скобки красивее.)

Со списочным значением можно использовать индексы, как в обычном массиве. Для избежания неоднозначности нужно заключать список в круглые скобки (настоящие). Хотя таким способом часто из списка извлекаются отдельные значения, на самом деле это срез списка, поэтому синтаксис такой:

(LIST)[LIST]

Примеры:

stat возвращает списочное значение.

$modification_time = (stat($file))[9];

ЗДЕСЬ СИНТАКСИЧЕСКАЯ ОШИБКА.

$modification_time = stat($file)[9]; # ОЙ, СКОБКИ ЗАБЫЛИ

Найти шестнадцатеричную цифру.

$hexdigit = ('а','b','с','d','е','f)[$digit-1O];

"Оператор обратной запятой", return (pop(@foo),pop(@foo))[0];

Получить несколько значений как срез.

($day, $month, $уеаг) = (localtime)[3,4,5];

Присвоение спискам

Присвоение списку можно осуществлять, только если допустимо присвоение для каждого элемента списка:

($а, $b, $с) = (1, 2, 3);

($map{red}, $map{green}, $map{blue}) = (OxffOOOO, OxOOffOO, OxOOOOff);

Можно осуществлять присвоение элементам undef в списке. Это удобно, если нужно отбросить некоторые значения, возвращаемые функцией:

($dev, $ino, undef, undef, $uid, $gid) = stat($file);

Последним элементом списка может быть массив или хеш:

($а, $b, @rest)二 split;

my ($a, $b, %rest)二 @arg_list;

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

Можно даже осуществлять присвоение пустому списку:

()=funkshun();

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

Присвоение списку в скалярном контексте возвращает число элементов, образованных выражением в правой части присвоения:

$х = ( ($а, $Ь) = (7,7,7) );# присваивает $х 3, а не 2

$х = ( ($а, $Ь)二 funk() );# присваивает $х количество значений, возвращаемых

funk()

$х =(()二 funk() );# тоже присваивает $х число значений, возвращаемых

funk()

Это удобно в случае присвоения списку в булевом контексте, поскольку большинство списочных функций возвращают по завершении нулевой список, который при присвоении порождает 0, интерпретируемый как false. Вот как можно использовать это в цикле while:

while (($login, Spassword)二 getpwent) {

if (crypt($login, $password) eq Spassword) { print "$login имеет ненадежный пароль!\n";

Размер массива

Число элементов в массиве @days можно определить, вычисляя @days в скалярном контексте, например:

@days + 0;# неявная установка для @days скалярного контекста

scalar(@days) # явная установка для @days скалярного контекста

Обратите внимание, что это действует только для массивов. В целом для списочных значений это не действует. Как уже говорилось, список с разделителем-запятой, вычисляемый в скалярном контексте, возвращает последнее значение, как оператор запятой в С. Но поскольку в Perl практически никогда не требуется знать размер списка, из-за этого не возникает проблем.

Со скалярным вычислением @days тесно связана переменная $#days. Она возвращает индекс последнего элемента массива, на единицу меньший размера массива, поскольку (обычно) имеется 0-й элемент. Присвоение переменной $#days изменяет размер массива. Укорачивание массива с помощью этого метода уничтожает лишние значения. Можно добиться некоторого увеличения эффективности программы, заранее увеличивая размер массива, который должен разрастись. (Расширить массив можно и присвоением значения элементу, находящемуся за его пределами.) Можно произвести полное усечение массива, присвоив ему нулевой список (). Следующие две команды эквивалентны:

©whatever =();

$#whatever = -1;

Всегда выполняется и следующее равенство:

scalar(@whatever) == $#whatever + 1;

Усечение массива не высвобождает занимаемую им память. Чтобы вернуть память в пул памяти процесса, нужно использовать undef(©whatever). Вернуть память в системный пул, вероятно, не удастся, поскольку немногие операционные системы поддерживают это.

Хеши

Как было сказано ранее, хеш является просто необычным видом массива, поиск значений в котором осуществляется с помощью ключевых строк, а не чисел. Хеш ассоциирует ключи со значениями, поэтому хеши часто называют ассоциативными массивами (те, кому не лень вводить столько букв с клавиатуры).

На практике в Perl нет такой вещи, как хеш-литерал, но если присвоить хешу обычный список, то каждая пара значений в списке образует одну связь ключ/значение:

%тар = ('red'.OxffOOOO,'green'.OxOOffOO,'blue'.OxOOOOff);

Такой же результат получается после команд:

%тар = ();#сначалаочиститьхеш

$map{red} 二 OxffOOOO;

$map{green} = OxOOffOO;

$map{blue} = OxOOOOff;

Часто код легче читать, если использовать оператор => в парах ключ/значе- ние. Оператор => служит просто синонимом запятой, но зрительно более отчетлив и заключает в кавычки голые идентификаторы в своей левой части (как идентификаторы в фигурных скобках выше), что делает его удобным для нескольких видов операций, включая инициализацию переменных типа хеш:

%тар =(

red => OxffOOOO,

green => OxOOffOO, blue => OxOOOOff, )；

или инициализацию ссылок на анонимные хеши, используемые как записи:

$гес = {

NAME => 'John Smith', RANK => 'Captain', SERNO => '951413',

или применение именованных параметров для вызова сложных функций:

$field = radio_group( NAME VALUES DEFAULT LINEBREAK LABELS$field = radio_group( NAME VALUES DEFAULT LINEBREAK LABELS=> 'животные',=> ['верблюд', 'лама=> * верблюд',=> 'true',=> \%animal_names,=> 'животные',=> ['верблюд', 'лама=> * верблюд',=> 'true',=> \%animal_names,баран', 'волк'],баран', 'волк'],

$field = radio_group( NAME VALUES DEFAULT LINEBREAK LABELS

$field = radio_group( NAME VALUES DEFAULT LINEBREAK LABELS

=> 'животные',

=> ['верблюд', 'лама

=> * верблюд',

=> 'true',

=> \%animal_names,

=> 'животные',

=> ['верблюд', 'лама

=> * верблюд',

=> 'true',

=> \%animal_names,

баран', 'волк'],

баран', 'волк'],

Но мы снова забегаем вперед. Вернемся к хешам.

Переменную типа хеш (%hash) можно использовать в списочном контексте, и в этом случае она интерполирует все свои пары ключ/значение в список. То, что хеш инициализировался в определенном порядке, не означает, что его значения будут в том же порядке возвращаться. Внутренне хеши реализуются с применением хеш-таблиц для быстрого поиска, в результате чего порядок, в котором запоминаются элементы, зависит от внутренней хеш-функ- ции, используемой для расчета позиции в хеш-таблице, а не чего-либо другого. Поэтому записи возвращаются в порядке, кажущемся случайным. (Оба элемента каждой пары ключ/значение возвращаются, конечно, в правильном порядке.) Примеры способов упорядочения вывода можно найти в описании функции keys в главе 29 «функции».

При вычислении переменной, представляющей собой хеш, в скалярном контексте, значение true возвращается, если в хеше есть хотя бы одна пара ключ/значение. Если пары ключ/значение есть, возвращаемое значение является строкой, состоящей из числа использованных блоков и числа выделенных блоков, разделенных косой чертой. В основном это полезно только для того, чтобы обнаружить, что алгоритм хеширования Perl (встроенный

в него) плохо работает на ваших данных. Например, если вы поместите в хеш 10 000 значений, но при вычислении %HASH в скалярном контексте получите 1/8, это будет означать, что только один из восьми блоков задействован. Вероятно, в этом одном блоке содержатся все 10 000 ваших элементов. Скорее всего, этого не произойдет.

Чтобы определить количество ключей в хеше, вызывайте функцию keys в скалярном контексте: scalar(keys(%HASH)).

Многомерный хеш можно эмулировать путем задания в фигурных скобках нескольких ключей, разделенных запятыми. Перечисленные ключи конкатенируются вместе, при этом в качестве разделителя выступает содержимое $; ($SUBSCRIPT一SEPARATOR), по умолчанию равное chr(28). Получившаяся строка используется в качестве фактического ключа хеша. Две следующие строки выполняют одно и то же:

$people{ $state, $county } = $census_results;

$people{ join $; => $state, $county } = $census_results;

Эта функция первоначально была реализована для поддержки а2р9 транслятора из awk в Perl. В нынешние времена вы можете просто использовать реальный (скажем, более реальный) многомерный массив, как это описывается в главе 9 «Структуры данных». Но в одном случае старый стиль все еще удобен: для хешей, связанных с файлами DBM (см. описание DB_File в главе 32 «Стандартные модули»), которые не поддерживают многомерные ключи.

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

$hash{ $х, $у, $z }# одиночное значение

@hash{ $х, $у, $z }# срез из трех значений

Таблицы имен и дескрипторы файлов

В Perl есть особый тип под названием type glob, предназначенный для хранения целых записей таблицы имен. (Запись таблицы имен *foo содержит значения $foo, @foo, %foo, &foo и нескольких интерпретаций старого доброго foo.) Префиксом типа typeglob является *, поскольку он представляет все типы.

Одним из применений typeglob (или ссылок на него) является передача и запоминание дескрипторов файлов. Для того чтобы запомнить дескриптор файла, поступите так:

$fh = *STDOUT;

или используйте реальную ссылку:

$fh 二 \*STDOUT;

Это дает также способ создания локального дескриптора файла, например:

sub newopen {

my $path 二 shift;

local *FH;# ни my(), ни our()

open(FH, $path) or return undef;

return *FH;# не \*FH!

}

$fh = newopen('/etc/passwd');

Другие способы создания новых дескрипторов файлов приведены в описании функции open.

В настоящее время основным применением typeglob является создание псевдонима для одной записи таблицы имен с помощью другой записи таблицы имен. Псевдоним можно рассматривать как прозвище. Если сказать:

*foo 二 *bar;

то все с именем foo становится синонимом для соответствующего объекта, называемого bar. Можно создать псевдоним лишь для одной переменной из записи таблицы имен, присваивая ссылку:

*foo 二 \$bar;

При этом $foo становится псевдонимом для $Ьа「, но @foo не становится псевдонимом для @Ьа「, как и %foo для %bar. Все это оказывает воздействие только на глобальные (пакетные) переменные; доступ к лексическим переменным не может быть осуществлен через записи таблицы имен. Такое создание псевдонимов для глобальных переменных может показаться делом вовсе ненужным, однако на этой функции построен весь механизм экспорта/импор- та модулей, поскольку ничто не указывает на то, что символ, для которого создан псевдоним, должен находиться в вашем пространстве имен. Команда

local *Here::blue 二 \$There::дгееп;

временно делает $Here: :blue псевдонимом для $There: :green, но не делает@Не- re: :blue псевдонимом для @There: :green или %Here: :blue псевдонимом для %There: :green. К счастью, все эти сложные манипуляции с typeglob там, где нужно, скрыты от ваших глаз. Дополнительное обсуждение typeglob и проблем импорта можно найти в разделах «Ссылки на обработчики» и «Ссылки на таблицы имен» главы 8 «Ссылки», в разделе «Таблицы имен» главы 10 «Пакеты» и в главе 11 «Модули».

Операторы ввода

Есть несколько операторов ввода, которые мы опишем здесь, поскольку они анализируются как термы. Иногда их называют псевдо литералами, поскольку во многих отношениях они ведут себя, как строки в кавычках. (Операторы вывода типа print анализируются как списочные операторы и обсуждаются в главе 29 «Функции».)

Оператор ввода команд (обратные кавычки)

Прежде всего, имеется оператор ввода команд, известный также как оператор «обратные кавычки» (backticks), поскольку он выглядит так:

$info 二 'finger $user';

Строка, заключенная в обратные кавычки (или, говоря «техническим» языком, в грависы), сначала претерпевает интерполяцию переменных, как строка в двойных кавычках. Затем результат интерпретируется системой как командная строка, а выдача команды становится значением псевдолитерала. (Это делается по подобию с аналогичным оператором оболочек Unix.) В скалярном контексте возвращается одна строка, содержащая выдачу. В списочном контексте возвращается список значений, по одному для каждой строки выдачи. (С помощью $/ можно назначить иной символ окончания строки.)

Команда выполняется при всяком вычислении псевдолитерала. Числовой статус выполнения команды сохраняется в $? (см. в главе 28 «Особые имена» интерпретацию $?, известную также, как $CHILD_ERROR). В отличие от версии этой команды в csh, в возвращаемых данных не производится трансляция: перевод строки остается переводом строки. В отличие от всех оболочек, одинарные кавычки в Perl не скрывают от интерпретации имена переменных в команде. Чтобы передать $ оболочке, нужно защитить этот символ обратным слэшем. Переменная $user в вышеприведенном примере finger интерполируется Perl, а не оболочкой. (Поскольку команда подвергается обработке оболочкой, возникают проблемы с защитой данных, рассматриваемые в главе 23 «Защита данных ».)

Обобщенной формой «обратных кавычек» является qx// (от «quoted execution» -«выполнение в кавычках»), но оператор действует в точности так же, как обычные обратные кавычки. Просто вы можете выбрать свои символы в качестве кавычек. Как и в случае аналогичных псевдофункций заключения в кавычки, если в качестве разделителя выбирается одинарная кавычка, то команда не подвергается интерполяции, как в случае двойных кавычек:

$perl_info 二 qx(ps $$);# это $$ в Perl

$shell_info = qx'ps $$';# это $$ в оболочке

Оператор ввода строки (угловых скобок)

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

менной, но в одном случае происходит автоматическое присвоение. Тогда и только тогда, когда в условии цикла while нет ничего, кроме оператора ввода строки, значение автоматически присваивается специальной переменной $_. При этом проверяется, определено ли присвоенное значение. (Эта конструкция может показаться странной, но вы будете часто ее использовать, поэтому стоит ее изучить.) Во всяком случае, следующие строки эквивалентны:

while (defined($_ = <STDIN>)) { print $_; }# самый длинный путь

явно относительно $_короткий способзамаскированный цикл whileдлинный модификатор командыявно относительно $_короткий модификатор командыявно относительно $_короткий способзамаскированный цикл whileдлинный модификатор командыявно относительно $_короткий модификатор командыwhile ($_ = <STDIN>) { print; }

явно относительно $_

короткий способ

замаскированный цикл while

длинный модификатор команды

явно относительно $_

короткий модификатор команды

явно относительно $_

короткий способ

замаскированный цикл while

длинный модификатор команды

явно относительно $_

короткий модификатор команды

while (<STDIN>) { print; } for (;<STDIN>;) { print; } print $_ while defined($_ = <STDIN>); print while $_ = <STDIN>;

print while <STDIN>;

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

while (<FH1> && <FH2>) { ... }# НЕВЕРНО: отбрасывает оба ввода

if (<STDIN>){ print; }# НЕВЕРНО: выводит прежнее значение $_

if ($_ = <STDIN>) { print; }# не самое оптимальное: нет проверки

определенности

if (defined($_ = <STDIN>)) { print; }# самое лучшее

При неявном присвоении $_ в цикле, использующем $_, это имя указывает на глобальную переменную, а не локальную для цикла while. Существующее значение $_ можно защитить так:

while (local $_ = <STDIN>) { print; }# использовать локальную $_

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

while (my $line = <STDIN>) { print $line; } # теперь закрытая

(Оба эти цикла while все же неявно проверяют, является ли определенным результат присвоения, поскольку ту и local не влияют на то, как анализатор видит присвоение.) Дескрипторы файлов STDIN, STDOUT и STDERR являются заранее определенными и заранее открытыми. Дополнительные дескрипторы файлов могут создаваться с помощью функций open или sysopen. Подробности о них см. в документации по этим функциям в главе 29 «Функции».

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

$one_line = <MYFILE>; # Получить первую строку.

@all_lines = <MYFILE>; # Получить оставшиеся строки.

Со списочной формой оператора ввода не связано никаких чудес while, поскольку условие цикла while всегда предоставляет скалярный контекст (как и всякий условный оператор).

Использование нулевого дескриптора файла в операторе угловых скобок представляет собой особенность: оно эмулирует режим командной строки таких типичных программ-фильтров Unix, как sed и awk. При чтении строк из <> вы чудесным образом получаете все строки файлов, перечисленных в командной строке. Если никакие файлы не указаны, вы получаете стандартное устройство ввода, поэтому вашу программу легко вставить в середину конвейера процессов.

Вот как это работает: при первом вычислении о проверяется массив @ARGV, и если он является нулевым, то $ARGV[O] устанавливается равным «-», что при открытии дает стандартное устройство ввода. После этого массив @ARGV обрабатывается как список имен файлов. Более явно, цикл:

while (о) { ...# код для каждой строки

}

эквивалентен следующему Perl-образному псевдокоду:

@ARGV = ('-') unless @ARGV; # принять STDIN, если пуст, и только тогда while (@ARGV) {

$ARGV = shift @ARGV; # каждый раз укорачивать @ARGV if (!open(ARGV, $ARGV)) {

warn "Невозможно открыть $ARGV: $!\n"; next;

}

while (<ARGV>) { ...# код для каждой строки

}

}

за исключением того, что его не так утомительно писать, и он реально работает. Он действительно сдвигает массив @ARGV и помещает текущее имя файла в глобальную переменную $ARGV. При этом также внутренне используется особый дескриптор файла ARGV 一 о служит просто синонимом более явной записи <ARGV>, являющейся магическим дескриптором файла. (Псевдокод, приведенный выше, не работает, поскольку рассматривает <ARGV> не как магический.)

Можно модифицировать @ARGV до первого о, если в итоге этот массив будет содержать список тех имен файлов, которые действительно вам нужны. Поскольку Perl использует здесь свою обычную функцию open, то имя файла «-», если таковое встретится, считается стандартным вводом, и вам автоматически становятся доступны более скрытые возможности open (такие как откры-

тие «файла» с именем gzip -de < file. gz|). Нумерация строк ($.) продолжается так, как если бы ввод удачно представлял собой один большой файл. (Однако посмотрите в примере для eof в главе 29 «Функции», как сбрасывать номера строк для каждого файла.)

Если требуется поместить в @ARGV собственный список файлов, то это можно сделать так:

# по умолчанию берется файл README, если не заданы аргументы

@ARGV 二("README") unless @ARGV;

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

while (@ARGV and $ARGV[O] =~ /</) {

$_ 二 shift;

last if Г- -$/;

if (/〈Da*)/) { $debug 二 $1 } if (/—и/){ $verbose++ }

...# другие ключи

}

while (<>) { ...# код для каждой строки

}

Обозначение <> возвратит false только один раз. Если после этого его вызвать снова, то оператор будет считать, что обрабатывается еще один список @ARGV, и если значения @ARGV не присвоены, то входные данные будут браться из STDIN.

Если строка в угловых скобках является скалярной переменной (например, <$foo>), то эта переменная содержит косвенный дескриптор файла, являющийся либо именем дескриптора файла, из которого нужно брать входные данные, либо ссылкой на такой дескриптор. Например:

$fh = \*STDIN;

$line 二 <$fh>;

или:

open($fh, "<data.txt");

$line = <$fh>;

Поиск файлов по шаблону

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

(«globbing»).1 Совпадения с шаблоном отыскиваются в файлах текущего каталога (или каталога, заданного как часть шаблона), и оператор возвращает найденные имена файлов. Как и в случае оператора ввода строки, имена возвращаются по одному в скалярном контексте, или все сразу в списочном контексте. Обычно встречается последний вариант, и нередко можно видеть такие команды:

@files = <*.xml>;

Как и для других типов псевдолитералов, сначала выполняется один уровень интерполяции переменных, но для этого нельзя написать <$foo>, поскольку, как сказано выше, это будет воспринято как косвенный дескриптор файла. В прежних версиях Perl программисты вызывали принудительную интерпретацию строки как шаблона при помощи фигурных скобок: <${foo}>. В настоящее время предпочитают прямой вызов внутренней функции, как в glob($foo), что, вероятно, правильно. Поэтому вместо угловых скобок вы пишете:

@files 二 glob("*.xml");

если с презрением относитесь к перегрузке оператора угловых скобок для этих целей. Имеете на это право.

Применяете ли вы функцию glob или придерживаетесь старой формы с угловыми скобками, в любом случае оператор поиска файла по шаблону осуществляет магию цикла while, как и оператор ввода строки, присваивая результат переменной $_. (Это было главной причиной перегрузки оператора угловых скобок.) Например, для того чтобы изменить права доступа ко всем файлам исходных текстов на С, можно сказать:

while (glob "*.с") { chmod 0644, $_;

}

что эквивалентно:

while (<*.О) { chmod 0644, $_;

}

Функция glob в прежних версиях Perl (и даже более старых версиях Unix) была реализована как команда оболочки, что приводило к относительной дороговизне ее выполнения, а что еще хуже, она по-разному работала в раз-

Fileglob (шаблон имени файла) не имеет никакого отношения к ранее упомянутым typeglob (шаблон имени символа), за исключением того, что в обоих символ * выступает в качестве группового. У символа *, используемого с этой целью, есть прозвище «glob». С помощью typeglob осуществляется поиск одноименных символов в таблице имен. С помощью fileglob осуществляется поиск имен файлов в каталоге по шаблону, как это происходит во многих оболочках.

личных системах. Сейчас она является встроенной, а потому более надежной и значительно более быстрой. Читайте в описании модуля File: :Glob в главе 32 «Стандартные модули», как можно изменить установленный по умолчанию режим работы этого оператора: будут ли пробелы в операнде (аргументе) рассматриваться как разделители в маршруте, нужно ли расширять тильду и фигурные скобки, учитывать ли регистр, сортировать ли возвращаемые значения и т. д.

Конечно, самый короткий способ выполнения приведенной выше команды chmod и, можно утверждать, самый удобочитаемый, - это использование поиска по шаблону как списочного оператора:

chmod 0644, <*.О;

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

($file) = <blurch*>; # списочный контекст

чем:

$file 二 <blurch*>; # скалярный контекст

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

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

@files = <$dir/*.[ch]>;# Действует, но лучше избегать.

@files = glob("$dir/*.[ch]"); # Вызов glob как функции.

@files = glob $some_pattern;# Вызов glob как оператора.

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

3

Унарные и бинарные операторы

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

Должна же социология приносить какую-то пользу.

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

На обычном языке это значит, что работать с операторами удобно.

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

По арности различают три вида операторов Perl: унарные, бинарные и тернарные. Унарные операторы всегда являются префиксными (за исключением постфиксных операторов инкрементирования и декрементирования).1 Все остальные операторы - инфиксные, если не считать списковые операторы, которые могут быть префиксом для любого числа аргументов. Однако большинство воспринимает списковые операторы как обычные функции, вокруг аргументов которых допускается позабыть поставить скобки. Вот несколько примеров:

! $х$х * $у$х ? $у : $z print $х, $у, $z! $х$х * $у$х ? $у : $z print $х, $у, $zунарный оператор

! $х

$х * $у

$х ? $у : $z print $х, $у, $z

! $х

$х * $у

$х ? $у : $z print $х, $у, $z

бинарный оператор

тернарный оператор

списковый оператор

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

2 + 3*42 + 3*4# дает в результате 14, а не 20

2 + 3*4

2 + 3*4

Порядок выполнения двух операторов с одинаковым приоритетом зависит от их ассоциативности. Эти правила тоже в некоторой степени следуют соглашениям, принятым в математике:

2*3*42 * * 3 * * 42 ! = 3 ! = 42*3*42 * * 3 * * 42 ! = 3 ! = 4# означает (2 * 3) * 4, левая ассоциативность

2*3*4

2 * * 3 * * 4

2 ! = 3 ! = 4

2*3*4

2 * * 3 * * 4

2 ! = 3 ! = 4

# означает 2 ** (3 ** 4), правая ассоциативность

недопустимо, не ассоциативный оператор

В табл. 3.1 перечислены ассоциативность и арность операторов Perl, начиная с высшего приоритета и кончая низшим.

Таблица 3.1. Приоритеты операторов

Ассоциативность

Арность

Класс приоритета

Нет

0

Термы и списковые операторы (слева)

Слева

2

Нет

1

++ --

Справа

2

* *

Справа

1

! ~ \ и унарные + и -

Слева

2

! ~

Слева

2

* / % X

Слева

2

+ -.

1 Хотя различные кавычки и скобки можно рассматривать как «циркумфиксные» операторы, определяющие границы термов.

Ассоциативность

Арность

Класс приоритета

Слева

2

« >>

Справа

0,1

Именованные унарные операторы

Нет

2

<><=>= it gt le ge

Нет

2

二二 I二 <=> eq ne cmp

Слева

2

&

Слева

2

Слева

2

&&

Слева

2

II

Нет

2

Справа

3

?:

Справа

2

二 += -二 *= и т. д.

Слева

2

,

Справа

0+

Списковые операторы (справа)

Справа

1

not

Слева

2

and

Слева

2

or хог

Может показаться, что уровней старшинства слишком много, чтобы их можно было запомнить. И это правда. К счастью, есть два облегчающих обстоятельства. Во-первых, уровни приоритетов определены так, что обычно соответствуют интуитивным представлениям, если только у вас все в порядке с психикой. А во-вторых, те, у кого нервы пошаливают, всегда могут поставить пару лишних скобок, чтобы избавиться от мучительного беспокойства.

Еще один полезный совет: операторы, заимствованные из С, сохраняют по отношению друг к другу принятые там приоритеты, даже когда в С для них установлено довольно странное старшинство. (Это облегчает изучение Perl тем, кто знает С и C++. И, может быть, даже Java.)

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

Хотя ссылки и являются скалярными величинами, но применение большинства этих операторов к ссылкам не очень разумно, поскольку числовое значение ссылки имеет смысл только для самого Perl. Однако если ссылка указывает на объект класса, допускающего перегрузку, то к такому объекту эти операторы можно применять, а если в классе определена перегрузка некоторого оператора, то она определяет действие над объектом при применении к нему данного оператора. Таким способом, например, в Perl реализованы комплексные числа. Более подробно перегрузка рассмотрена в главе 13 «Перегрузка».

Термы и списковые операторы (слева)

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

Теперь слушайте внимательно. Есть пара очень важных правил, существенно упрощающих дело, но приводящих иногда к неожиданным результатам, если не проявлять осмотрительность. Если за списковым оператором (например, print) или любым именованным унарным оператором (например, chdir) в качестве следующей лексемы следует левая круглая скобка (не считая пробельных символов), то оператор и аргументы в скобках получают высший приоритет, как если бы это был обычный вызов функции. Правило следующее: если это похоже на вызов функции, то это и есть вызов функции. Можно сделать так, чтобы он не выглядел как функция, поместив перед скобками унарный плюс, который, семантически говоря, не делает абсолютно ничего - даже не принуждает аргумент к переводу в число.

Например, поскольку 11 имеет более низкий приоритет, чем chdir, мы получим:

chdir $foo

II

die;

#

(chdir $foo)

II

die

chdir($foo)

丨丨

die;

#

(chdir $foo)

II

die

chdir ($foo)

II

die;

#

(chdir $foo)

II

die

chdir +($foo)

II

die;

#

(chdir $foo)

II

die

но т. к. * имеет более высокий приоритет, чем chdir, получится:

chdir $foo * 20;chdir($foo) * 20;chdir ($foo) * 20;chdir +($foo) * 20;chdir $foo * 20;chdir($foo) * 20;chdir ($foo) * 20;chdir +($foo) * 20;chdir ($foo * 20)(chdir $foo) * 20(chdir $foo) * 20chdir ($foo * 20)chdir ($foo * 20)(chdir $foo) * 20(chdir $foo) * 20chdir ($foo * 20)

chdir $foo * 20;

chdir($foo) * 20;

chdir ($foo) * 20;

chdir +($foo) * 20;

chdir $foo * 20;

chdir($foo) * 20;

chdir ($foo) * 20;

chdir +($foo) * 20;

chdir ($foo * 20)

(chdir $foo) * 20

(chdir $foo) * 20

chdir ($foo * 20)

chdir ($foo * 20)

(chdir $foo) * 20

(chdir $foo) * 20

chdir ($foo * 20)

Аналогично для любого числового оператора, который является именованным унарным оператором, например оператора rand:

rand 10 * 20;rand(10) * 20;rand (10) * 20;rand +(10) * 20;rand 10 * 20;rand(10) * 20;rand (10) * 20;rand +(10) * 20;# rand (10 * 20)# (rand 10) * 20# (rand 10) * 20# rand (10 * 20)# rand (10 * 20)# (rand 10) * 20# (rand 10) * 20# rand (10 * 20)

rand 10 * 20;

rand(10) * 20;

rand (10) * 20;

rand +(10) * 20;

rand 10 * 20;

rand(10) * 20;

rand (10) * 20;

rand +(10) * 20;

# rand (10 * 20)

# (rand 10) * 20

# (rand 10) * 20

# rand (10 * 20)

# rand (10 * 20)

# (rand 10) * 20

# (rand 10) * 20

# rand (10 * 20)

В отсутствие круглых скобок приоритет списковых операторов, таких как print, sort или chmod, оказывается либо очень высоким, либо очень низким, в зависимости от того, на какую сторону оператора смотреть - левую или правую. (Это и есть «слева», выведенное в заголовок этого раздела.) Например, в:

@а「у 二(1, 3, sort 4, 2);

print @ary;# выводит 1324

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

Эти операторы выполняют exit раньше, чем print: print($foo, exit); # Очевидно, это не то, что нужно, print $foo, exit; # Как и это.

Эти операторы выполняют print раньше, чем exit: (print $foo), exit; # Это то, что нужно.

print($foo), exit; # И это.

print ($foo), exit; # И даже это.

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

print ($foo & 255) + 1, "\n";# выводит ($foo & 255)

Это выполняется не так, как может показаться с первого взгляда. К счастью, ошибки такого вида обычно вызывают вывод предупредительных сообщений типа «Useless use of addition in a void context» (бесполезное сложение в пустом контексте), если вывод предупредительных сообщений включен.

Конструкции do {} и eval {} тоже выделяются анализатором как термы, как и вызовы подпрограмм и методов, конструкторы анонимных массивов и хешей []и {}, а также анонимных подпрограмм sub {}.

Оператор «стрелка»

Точно так же, как в С и C++, двоичный оператор -> является инфиксным оператором разыменования. Если правая часть представляет собой индекс массива [...], индекс хеша {...} или список аргументов подпрограммы (...), то левая часть должна быть ссылкой (жесткой или символической) на массив, хеш и подпрограмму, соответственно. В контексте 1-значения (допускающем присваивание), когда левая часть не является ссылкой, она должна быть неким адресом, по которому может храниться жесткая ссылка, и в этом случае происходит самооживление (autovivification) такой ссылки. Более подробно об этом (с некоторыми предупреждениями относительно случайного самоооживления) рассказано в главе 8 «Ссылки».

$a「ef->[42]#разыменованиемассива

$href->{"corned beef"}#разыменованиехеша

$sref->(1,2,3)#разыменованиеподпрограммы

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

метода), а левая часть должна вычисляться как объект (связанная с объектом ссылка) или имя класса (т. е. имя пакета):

$yogi 二 Bear->new("Yogi"); # вызов метода класса

$yogi->swipe($picnic);$yogi->swipe($picnic);# вызов метода объекта# вызов метода объекта

$yogi->swipe($picnic);

$yogi->swipe($picnic);

# вызов метода объекта

# вызов метода объекта

Имя метода может быть квалифицировано именем пакета для указания класса, с которого нужно начать поиск метода, либо специальным именем пакета SUPER::, указывающим, что поиск должен быть начат с родительского класса. См. главу 12 «Объекты».

Автоинкрементирование и автодекрементирование

выводит

'100

#

выводит

'Ь0'

#

выводит

'Ва'

выводит

'ааа

Операторы ++ и - - работают так же, как в С. Это значит, что, будучи помещены перед переменной, они инкрементируют или декрементируют переменную перед тем, как возвратить ее значение, а будучи помещены после нее, они инкрементируют или декрементируют переменную после того, как возвращено ее значение. Например, $а++ инкрементирует значение скалярной переменной $а, возвращая ее значение перед выполнением инкрементирования. Аналогично --$b{(/(\w+)/)[0]} декрементирует элемент хеша %Ь с индексом, равным первому «слову» в установленной по умолчанию для поиска переменной ($_) и возвращает значение, полученное после декрементирования. В оператор автоинкрементирования встроено еще одно «магическое» свойство. При инкрементировании переменной, являющейся числом или когда- либо появлявшейся в числовом контексте, мы получаем обычное инкрементирование. Если, однако, переменная после присваивания ей значения использовалась только в строковых контекстах и имеет значение, отличное от нулевой строки и соответствующее шаблону /c[a-zA-Z]*[0-9]*$/, то выполняется инкрементирование строки с сохранением символов в этом диапазоне и переносом:

print ++($foo = '99'); print ++($foo = 'a9'); print ++($foo 二'Az'); print ++($foo 二'zz');

На момент написания книги магическое автоинкрементирование не было распространено на буквы и цифры Unicode, но в будущем это может быть сделано.

Однако оператор автодекрементирования магическим не является, и мы не планируем сделать его таковым.

Возведение в степень

Бинарный оператор ** осуществляет возведение в степень. Обратите внимание, что он связывает аргументы даже сильнее, чем унарный минус, поэтому -2**4 равно -(2**4), а не (-2)**4. Этот оператор реализован с помощью С-функции роз(З), использующей (внутренне) числа с плавающей запятой. Расчет выполняется с использованием логарифмов, поэтому можно возводить и в дробные степени, но иногда получаемые результаты не столь точны, какими могли бы быть при обычном умножении.

Идеографические унарные операторы

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

Унарный ! осуществляет логическое отрицание, то есть «не». Вариант логического отрицания с более низким приоритетом - not. Значением отрицаемого операнда становится «истина», или true, (1), если операнд есть «ложь», или false, (число 0, строка "О", нулевая строка или неопределенное значение), и «ложь», или false, ('" ), если операнд есть «истина».

Унарный - осуществляет арифметическое отрицание, если операнд является числом. Если операнд представляет собой идентификатор, то возвращается строка, состоящая из знака «минус», конкатенированного с идентификатором. В иных случаях, если строка начинается со знака («плюс» или «минус»), возвращается строка, начинающаяся с противоположного знака. Одним из результатов этих правил является то, что -bareword эквивалентно "-bareword". Это очень удобно для программирующих на Тк.

Унарный ~ осуществляет поразрядное отрицание, т. е. дополнение до 1. Из определения следует, что этот оператор не вполне переносим, поскольку связан с размером машинного слова. Например, на 32-разрядной машине ~123 равно 4294967172, а на 64-разрядной равно 18446744073709551492. Но об этом читатель уже знает.

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

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

Унарный + не оказывает никакого семантического действия - даже на строки. Его синтаксическая польза состоит в отделении имени функции от выражения в скобках, которое иначе интерпретировалось бы как полный список аргументов функции. (См. примеры раздела «Термы и списковые операторы» данной главы.) Можно представить себе это и так, что + отрицает действие скобок по превращению префиксных операторов в функции.

Унарный оператор \ создает ссылку на то, что следует за ним. Применение его к списку создает список ссылок. Подробности можно найти в разделе «Оператор обратной косой черты» главы 8 «Ссылки». Не смешивайте действие этого оператора с действием обратной косой черты внутри строки, хотя в обоих случаях передается некоторая идея отрицания, для того чтобы защитить последующий объект от интерпретации. Это сходство не является полностью случайным.

Операторы связывания

Бинарный оператор =~ связывает строковое выражение с поиском по шаблону, подстановкой или транслитерацией (вольно называемой трансляцией). Если не использовать этот оператор, то поиск или замена осуществляются в строке, содержащейся в переменной $_ (переменной по умолчанию). Строка, подлежащая связыванию, помещается в левую часть, а сам оператор - справа от нее. Возвращаемое значение указывает на успех или неудачу оператора справа, поскольку оператор связывания, в сущности, никаких самостоятельных действий не выполняет.

Если правый аргумент представляет собой выражение, а не операторо поиска по шаблону, замены или транслитерации, то на этапе выполнения это выражение будет интерпретироваться как шаблон, по которому должен быть проведен поиск. Например, $_ =~ $pat эквивалентно $_ =~ /$pat/. Это менее эффективно, чем явный поиск, поскольку шаблон должен проверяться и, возможно, перекомпилироваться при каждом вычислении выражения. Избежать повторной компиляции можно путем предварительной компиляции исходного шаблона с использованием оператора q г// (заключения в кавычки регулярного выражения).

Бинарный оператор ! ~ аналогичен =~, с тем отличием, что возвращается логическое отрицание результата. Следующие два выражения действуют одинаково:

$string !~ /pattern/ not $string =~ /pattern/

Мы сказали, что возвращаемое значение сигнализирует об успешности операции, но есть разные типы успеха. Подстановка возвращает число найден-

ных совпадений, как и транслитерация. (На практике оператор транслитерации часто применяют для подсчета символов.) Поскольку любой ненулевой результат является истиной, то все работает. Наиболее впечатляющий пример истинного значения дает присваивание шаблона списку: в списковом контексте поиск по шаблону может возвращать подстроки, соответствующие круглым скобкам, имеющимся в шаблоне. И снова, согласно правилам присваивания списку сама операция присваивания возвращает истину, если что-либо было найдено и присвоено, и ложь в противном случае. Поэтому иногда можно встретить код такого вида:

if ( ($k,$v)二 $string =~ m/(\w+)=(\w*)/ ) { print "КЛЮЧ $k ЗНАЧЕНИЕ $v\n";

}

Рассмотрим этот пример по частям. Оператор =~ имеет приоритет над =, поэтому сначала происходит =~・ Оператор =~ связывает $string с поиском по шаблону в правой части, который ищет в строке подстроку, похожую на КЛЮЧ=ЗНАЧЕНИЕ. Он находится в списковом контексте, поскольку расположен в правой части присваивания списку. Если поиск успешен, то он возвращает список, который нужно присвоить $к и $v・ Само присваивание списку находится в скалярном контексте, поэтому оно возвращает 2 - число значений в правой части присваивания. А 2 оказывается истиной, поскольку наш скалярный контекст является также и булевым. Если поиск неудачен, то значения не присваиваются и возвращается 0, который является ложью.

Дополнительно о работе с шаблонами см. главу 5 «Поиск по шаблону».

Мультипликативные операторы

В Perl имеются С-подобные операторы * (умножение), / (деление) и % (взятие по модулю). Операторы * и / действуют точно так, как можно предположить, умножая или деля два свои операнда. Деление осуществляется с плавающей точкой, если не используется модуль прагмы integer.

Оператор % преобразует свои операнды в целые числа, а затем находит остаток от деления целых чисел. (Однако при необходимости он осуществляет это деление с плавающей точкой, поэтому на большинстве 32-разрядных машин операнды могут иметь размер до 15 цифр.) Допустим, что имена этих двух операндов суть $а и $Ь. Если $Ь положительно, то результатом $а % $Ь будет $а минус наибольшее кратное $Ь, не превышающее $а (вследствие чего результат всегда будет находиться в диапазоне 0 .. $Ь -1). Если $Ь отрицательно, то результатом $а % $Ь будет $а минус наименьшее кратное $Ь, которое не меньше $а (вследствие чего результат всегда будет находиться в диапазоне $Ь +1 . . 0).

Если в области видимости имеется директива use integer, то % предоставляет прямой доступ к оператору взятия по модулю в том виде, в каком он реализован в вашем компиляторе С. Этот оператор не вполне корректно определен для отрицательных операндов, но выполняется быстрее.

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

print '-' х 80;# выводит строку дефисов

print "\t" х ($tab/8), ' ' х ($tab%8);# замена пробелов табуляцией

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

@ones = (1) х 80;# список из 80 единиц

@ones = (5) х @ones;# установить все элементы равными 5

Аналогично оператор х можно использовать для инициализации срезов массивов и хешей:

@keys = qw(perls before swine);

@hash{@keys}二("")x @keys;

Если вам это непонятно, то обратите внимание, что @keys выступает как список в левой части присваивания и как скалярная величина (возвращающая размер массива) в правой части сравнения. Предыдущий пример оказывает на %hash такое же воздействие, как:

$hash{perls}=

$hash{before}二"";

$hash{swine} 二

Аддитивные операторы

Как ни странно, в Perl есть и обычные операторы + (сложение) и - (вычитание). Оба оператора при необходимости преобразуют свои аргументы из строк в числа и возвращают числовой результат.

Кроме того, в Perl имеется оператор . для конкатенации строк. Например:

Salmost 二"Fred" . "Flintstone"; # возвращает FredFlintstone

Заметьте, что Perl не помещает пробел между конкатенируемыми строками. Если пробел необходим или нужно конкатенировать более двух строк, можно использовать оператор join, описываемый в главе 29 «Функции». Чаще всего, однако, конкатенацию выполняют неявным образом, заключая строку в двойные кавычки:

$fullname 二"$firstname $lastname";

Операторы сдвига

Операторы поразрядного сдвига (« и ») возвращают значение левого аргумента, сдвинутое влево («) или вправо (») на число разрядов, заданное правым аргументом. Аргументы должны быть целыми числами. Например:

1 « 4;# возвращает 16

32 » 4;# возвращает 2

Пользуйтесь, однако, этими операторами с осторожностью. Результат применения их к большим (или отрицательным) числам может различаться в зависимости от количества разрядов, используемых в вашей машине для представления целых чисел.

Именованные унарные операторы и операторы проверки файлов

Некоторые из «функций», описываемых в главе29 «Функции», являются в действительности унарными операторами. В табл. 3.2 перечислены все именованные унарные операторы.

Таблица 3.2 Именованные унарные операторы

-X (проверка файлов)

gethostbyname

localtime

return

alarm

getnetbyname

lock

rmdir

caller

getpgrp

log

scalar

chdir

getprotobyname

Istat

sin

ch root

glob

my

sleep

cos

gmtime

oct

sqrt

defined

goto

ord

srand

delete

hex

quotemeta

stat

do

int

rand

uc

eval

1c

readlink

ucfirst

exists

lefirst

ref

umask

exit

length

require

undef

Унарные операторы имеют более высокий приоритет, чем некоторые бинарные. Например:

sleep 4 | 3;

«засыпает» не на 7 секунд, а на 4, а затем берет результат, возвращаемый sleep (обычно 0), и выполняет его поразрядное ИЛИ с 3, как если бы скобки были расставлены так:

(sleep 4) I 3;

Сравните с:

print 4 I 3;

Этот оператор выполняет логическое ИЛИ 4 и 3 (7 в данном случае), перед выводом, как если бы стояли скобки:

print (4 I 3);

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

Еще одно любопытное обстоятельство, связанное с унарными операторами, заключается в том, что многие из них по умолчанию работают с $_, если не передать им никакого аргумента. Однако если аргумент опущен, но лексема, следующая за унарным оператором, похожа на начало аргумента, Perl придет в замешательство, поскольку он ждет появления терма. Когда анализатор лексем Perl получает один из символов, перечисленных в табл. 3.3, он возвращает различные типы лексем в зависимости от того, что он рассчитывает получить 一 терм или оператор.

Таблица 3.3. Двусмысленные символы

Символ

Оператор

Терм

+

Сложение

Унарный плюс

-

Вычитание

Унарный минус

*

Умножение

*typeglob

Деление

/шаблон/

<

Меньше, сдвиг влево

<HANDLE>, «END

Конкатенация

.3333

?

?:

?шаблон?

%

Взятие по модулю

%assoc

&

&, &&

&subroutine

Типичная глупая ошибка выглядит так:

next if length < 80;

В этом случае < кажется анализатору началом символа ввода о (термом), а не оператором «меньше», который вам нужен. Исправить эту ситуацию в Perl и одновременно сохранить его патологическую эклектичность решительно невозможно. Если вы невероятно ленивы и не можете заставить себя напечатать два символа $_, воспользуйтесь одним из следующих способов:

next if length() < 80;

next if (length) < 80;

next if 80 > length;

next unless length >= 80;

Если ожидается терм, то знак «минус», за которым следует одна буква, всегда рассматривается как оператор проверки файла. Оператор проверки файла представляет собой унарный оператор, который принимает один аргумент, являющийся именем файла или его дескриптором, и проверяет, обладает ли этот файл некоторым свойством. Если аргумент опущен, оператор проверяет $_, за исключением оператора -t, который проверяет STDIN. Если не указано иное, возвращаемым значением является 1 при истинности и "" при ложности либо неопределенное значение, если файл не существует или недоступен по каким-то другим причинам. Реализованные в настоящее время операторы проверки файлов перечислены в табл. 3.4.

Таблица 34 Операторы проверки файлов

Оператор

Значение

-г

Файл доступен для чтения текущему пользователю или группе (effective UID/GID)

-W

Файл доступен для записи текущему пользователю или группе (effective UID/GID)

-х

Файл доступен для выполнения текущему пользователю или группе (effective UID/GID)

-0

-R

Файл принадлежит текущему пользователю (effective UID)

Файл доступен для чтения реальному пользователю или группе (real UID/GID)

-W

Файл доступен для записи реальному пользователю или группе (real

UID/GID)

-X

Файл доступен для выполнения реальному пользователю или группе (real UID/GID)

-0

Файл принадлежит реальному пользователю (real UID)

-е

Файл существует

-Z

Файл имеет нулевую длину

-S

-f

-d

-1

Файл имеет ненулевую длину (возвращает размер)

Обычный файл

Каталог

Файл является символической ссылкой

Таблица 34 ( продолжение)

Оператор

Значение

-р

Файл является именованным каналом (FIFO)

-S

Файл является сокетом

-Ь

Блочный файл

-с

Символьный файл

-t

Дескриптор файла открыт на текущем терминале

-и

Для файла установлен бит setuid

-g

Для файла установлен бит setgid

-k

Для файла установлен «липкий бит» (sticky bit)

-т

Файл является текстовым

-в

Файл является двоичным (в противоположность -Т)

-м

Время, прошедшее от последней модификации файла до запуска сценария, в днях

-А

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

-С

Время, прошедшее от последнего изменения индексного дескриптора до запуска сценария, в днях

Обратите внимание, что -s/a/b/ не производит подстановки с отрицанием. Однако -exp($foo) работает, как должно: только одиночные буквы после минуса трактуются как проверка файла.

Интерпретация операторов прав доступа к файлам -г, -R, -w, -W, -х и -X основывается исключительно на свойствах файла и пользовательском и групповом идентификаторах пользователя. Могут быть и другие причины, по которым не удается читать, записывать или выполнять файл, например, списки управления доступом файловой системы Andrew File System (AFS). Заметьте также, что для суперпользователя -г, -R, -w и -W всегда возвращают 1, а -х и -X возвращают 1, если установлен хоть один бит исполнения. Поэтому в сценариях, выполняемых суперпользователем, может потребоваться выполнить stat, чтобы определить действительный режим файла, либо временно установить другой идентификатор пользователя.

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

while (о) {

chomp;

next unless -f $_;# пропустить "особые" файлы

Ключи -Т и -В работают следующим образом. Участок файла примерно в объеме первого блока исследуется на наличие необычных символов, таких как коды управления или байты с установленным старшим битом (не похожие на UTF-8). Если необычными оказываются более одной трети байтов, то файл считается двоичным, в противном случае - текстовым. Кроме того, двоичным считается любой файл, в первом блоке которого встретился символ ASCII NUL (\0). Если -Т или -В применяется к дескриптору файла, то исследуется не первый блок файла, а текущий буфер ввода (стандартный I/O или «stdio»). Оба оператора, -Т и -В, возвращают истину для пустого файла или файла, указатель которого находится в EOF 一 конце файла, если проверяется дескриптор. Поскольку Perl должен прочесть файл, чтобы выполнить проверку -Т, применение последней со специальными файлами, которые могут вызвать зависание или доставить другие неприятности, нежелательно. Поэтому чаще всего нужно сначала выполнить проверку с ключом -f, например:

next unless -f $file && -T $file;

Если какой-либо из проверок файлов (или операторам stat или Istat) передается специальный дескриптор файла, состоящий из одного символа подчеркивания, то используется структура stat от предыдущей проверки файла (или оператора stat), что позволяет избежать нового системного вызова. (Это не действует для оператора -t, и нужно помнить, что Istat и -1 оставляют в структуре stat значения, относящиеся к символической ссылке, а не к реальному файлу. Аналогично, -1 _ всегда возвращает «ложь» после обычного stat.)

Вот несколько примеров:

print "Доступен для обработки .\n" if -г $а || -w _ || -х _; stat($filename);

print "Доступен для чтения\п" if -г _; print "Доступен для записи\п" if -w _; print "Исполняемый \n" if -x _;

print "Установлен бит setuid\n"if -u

print "Установлен бит setgid\n"if -g _;

print "Текстовый\п" if -T _;

print "Двоичный\п" if -B _;

# файлы старше 12 часов# файл новее, чем процесс# файлы старше 12 часов# файл новее, чем процессВремя существования файла операторами -М, -А и -С возвращается в днях (считая дробную часть суток) на момент начала выполнения сценария. Это время хранится в особой переменной $^Т ($BASETIME). Поэтому, если файл был изменен после начала выполнения сценария, возвращается отрицательное время. Обратите внимание, что значения времени в большинстве случаев (в среднем, 86399 из 86400) являются дробными, поэтому проверка равенства целому числу без использования функции int обычно оказывается бесполезной. Примеры:

# файлы старше 12 часов

# файл новее, чем процесс

# файлы старше 12 часов

# файл новее, чем процесс

next unless -М $file > .5; &newfile if -M $file < 0;

&mailwarning if int(-A) == 90; # обращение к файлу ($_) ????? ????? ровно 90 дней назад

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

$^Т 二 time;

Операторы сравнения

В Perl имеется два класса операторов сравнения. Один класс выполняет операции сравнения со строковыми величинами, другой с числовыми, как показано в табл. 3.5.

Таблица 35 Операторы сравнения

Числа

Строки

Значение

>

gt

Больше

>=

де

Больше или равно

<

It

Меньше

<=

1е

Меньше или равно

Эти операторы возвращают 1 в качестве истины и ' " - как ложь. Заметьте себе, что операторы сравнения неассоциативны, что означает синтаксическую ошибку в выражении $а < $Ь < $с.

В отсутствие объявлений национальных настроек сравнение строк основывается на схеме упорядочения ASCII/Unicode, при этом, в отличие от некоторых языков программирования, концевые пробелы участвуют в сравнении. При наличии объявления национальных установок используется определенная в нем схема упорядочения. (Механизмы сравнения, основывающиеся на национальных установках, не всегда могут хорошо взаимодействовать с механизмами сравнения Unicode, находящимися в настоящее время в стадии разработки.)

Операторы равенства

Операторы равенства, перечисленные в табл. 3.6, во многом похожи на операторы сравнения.

Таблица 3.6. Операторы равенства

Числа

Строки

Значение

==

Eq

Равно

1 二

Ne

Не равно

<=>

Cmp

Сравнение, результат со знаком

Операторы проверки равенства и неравенства возвращают 1 в качестве значения «истина» и в качестве значения «ложь» (так же, как операторы сравнения). Операторы <=> и стр возвращают -1, если левый операнд меньше правого, 0 при их равенстве и +1, если левый операнд больше правого. Хотя операторы равенства кажутся аналогичными операторам сравнения, они имеют более низкий приоритет, поэтому запись $а < $Ь <=> $с < $d синтаксически допустима.

По причинам, очевидным для каждого видевшего фильм «Звездные войны», оператор <=> называют также оператором «космический корабль» (spaceship).

Операторы поразрядного действия

Как и в С, в Perl есть поразрядные операторы И, ИЛИ и исключающее ИЛИ (XOR): &, |, и К Взяв на себя труд изучить таблицу в начале этой главы, читатель мог обнаружить, что поразрядное И имеет более высокий приоритет, чем остальные поразрядные операторы, но мы смошенничали и объединили их в нашем изложении.

Эти операторы по-разному действуют на числа и строки. (Один из немногих случаев, когда Perl учитывает разницу между ними.) Если оба операнда - числа (или использовались как числа), они преобразуются в целые числа и поразрядная операция производится над двумя числами. Эти числа имеют гарантированную длину 32 разряда, но на некоторых машинах это может быть 64 разряда. Дело в том, что существует произвольное ограничение, налагаемое архитектурой машины.

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

Например, если выполнить И над двумя строками:

"123.45" & "234.56"

то получится новая строка:

"020.44"

Но если выполнить И над строкой и числом:

"123.45" & 234.56

то строка сначала преобразуется в число, что дает:

123.45 & 234.56

Затем числа преобразуются в целые:

123 & 234

и в результате получается 106. Обратите внимание, что все битовые строки истинны (если только не равны строке "О"). Это значит, что если требуется определить, оказался ли какой-то байт ненулевым, то вместо:

if ( "fred" & "\1\2\3\4" ){...}

нужно записать:

if ( ("fred" & "\1\2\3\4") - /[ЛО]/ ){...}

Логические операторы в стиле С (короткого действия)

Как и в С, в Perl имеются операторы && (логическое И) и 11 (логическое ИЛИ). Они выполняют вычисления слева направо (при этом && имеет несколько больший приоритет, чем | |), проверяя утверждения на истинность. Эти операторы известны как операторы короткого действия, поскольку определяют истинность утверждения, вычисляя возможно меньшее число операндов. Например, если левый операнд оператора && имеет значение «ложь», то правый операнд не вычисляется вообще, поскольку вне зависимости от его значения результат имеет значение «ложь».

Пример

Название

Результат

$a && $b

И

$а, если $а ложно, в противном случае $Ь

$a II $b

ИЛИ

$а, если $а истинно, в противном случае $Ь

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

open(FILE, "некий_файл") || die "Невозможно открыть некий_файл: $!\п";

В данном случае Perl сначала вычисляет функцию open. Если ее значение истинно (т. е. некий_файл был успешно открыт), то выполнение функции die не является обязательным и пропускается. Можно прочесть это буквально: «Открыть некий файл или умереть!»

Операторы && и | | отличаются от имеющихся в С тем, что возвращают не 0 или 1, а последнее вычисленное значение. В случае | | это приводит к тому приятному результату, что можно выбрать первое из ряда скалярных значений, которое окажется истинным. Поэтому весьма переносимым способом найти исходный каталог пользователя может быть такой:

$home 二 $ENV{HOME} I I $ENV{LOGDIR}

|| (getpwuid($<))[7]

11 die "Да ты бездомный!\n";

С другой стороны, поскольку левый аргумент всегда вычисляется в скалярном контексте, нельзя использовать | | при выборе для присваивания одного из двух составных объектов:

@а = @Ь || @с;# Получится не то, что нужно, поскольку

@а = scalar(@b) || @с;# в действительности будет вот что.

@а = @Ь ? @Ь : @с;# А это работает прекрасно.

В Perl есть также операторы с более низким приоритетом, and и or, которые некоторым кажутся более удобочитаемыми и не принуждают использовать скобки в списковых операторах. Они тоже имеют короткое действие. Полный список можно найти в табл. 1.1.

Оператор диапазона

Оператор диапазона .. представляет собой, в сущности, два разных оператора в зависимости от контекста.

В скалярном контексте .. возвращает булево значение. Оператор диапазона, подобно электронному триггеру, имеет два устойчивых состояния и эмулирует оператор диапазона строки (запятая) из sed, awk и различных редакторов. Каждый скалярный оператор .. сохраняет собственное булево состояние. Оно имеет значение «ложь», если левый операнд имеет значение «ложь». Если левый операнд имеет значение «истина», оператор диапазона остается истинным, пока правый операнд не получит значение «истина», после чего оператор диапазона снова получает значение «ложь». Оператор не получит значения «ложь», пока не будет вычислен в очередной раз. Он может проверить правый операнд и стать ложным в том же вычислении, когда стал истинным (так ведет себя оператор диапазона awk), но все равно один раз возвратит значение «истина». Если вы не хотите, чтобы правый операнд проверялся до следующего вычисления (а так действует оператор диапазона sed), нужно вместо двух точек использовать три (. . .). Как для .., так и для ... правый операнд не проверяется, пока оператор находится в состоянии «ложь», а левый операнд не проверяется, пока оператор находится в состоянии «истина».

Возвращаемое значение является либо пустой строкой для значения «ложь», либо порядковым номером (начинающимся с 1) для значения «истина». Последовательный номер сбрасывается для каждого встретившегося диапазона. К последнему номеру в диапазоне добавляется строка ЕО, которая не влияет на числовое значение, но дает значение, в котором можно осуществлять поиск при желании исключить конечную точку. Исключить начальную точку можно, ожидая, когда последовательный номер станет больше 1. Если оба операнда скалярного .. представляют собой числовые литералы, то операнды неявно сравниваются с переменной $., которая содержит номер строки входного файла. Примеры:

if (101 .. 200) { print; } # вывести вторую сотню строк

next line if (1 .. /"$/);# пропустить заголовочные строки сообщения

s/c/> / if (/八$/ .. eof()); # заключить в кавычки тело сообщения

В списковом контексте .. возвращает список значений, считая от левого до правого операндов. Это удобно при записи циклов for (1.. 10) и операций среза над массивами:

for (101 .. 200) { print; }# выводит 101102...199200

@foo = @foo[0 .. $#foo];# дорогостоящий пустой код операции

@foo = @foo[ -5-1];# срез из последних 5 элементов

Если левое значение больше правого, возвращается пустой список. (Для создания списка, следующего в обратном порядке, используется оператор reverse.)

Если операнды являются строками, оператор диапазона применяет алгоритм магического автоинкрементирования, обсуждавшийся ранее.1 Поэтому можно сказать:

©alphabet = ('А' .. 'Z');

и получить все буквы (английского) алфавита, либо:

$hexdigit = (0 .. 9, 'а' .. 'f')[$num & 15];

и получить шестнадцатеричную цифру, либо:

@z2 = ('01' .. '31'); print $z2[$mday];

и получить дату с ведущими нулями. Можно также сказать:

@combos = ('аа' .. 'zz');

и получить все комбинации из двух букв нижнего регистра. Однако остерегайтесь таких выражений:

@bigcombos = ('аааааа' .. 'zzzzzz');

поскольку для них требуется большой объем памяти. Если точно, то потребуется память для записи 308 915 776 скаляров. Будем надеяться, что для свопинга выделен большой раздел. Возможно, итеративный подход лучше.

Условный оператор

Как и в С, ?: является единственным тернарным оператором. Он часто называется условным оператором, поскольку во многом работает сходно с if-then-

Если конечное значение не входит в последовательность, которую создает магическое инкрементирование, последовательность продолжается, пока ее очередное значение не станет длиннее указанного конечного значения.

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

COND ? THEN : ELSE

Если условие COND является истинным, то вычисляется только выражение THEN, значение которого становится значением выражения в целом. В противном случае вычисляется только выражение ELSE, значение которого становится значением выражения в целом.

Скалярный или списковый контекст распространяется далее на второй или третий аргумент в зависимости от того, который из них выбран. (Первый аргумент всегда находится в скалярном контексте, поскольку этот оператор является условным.)

$а = $ок ?$Ь:$с;# получитьскаляр

@а = $ок ?@Ь:@с;# получитьмассив

$а = $ок ?@Ь:@с;# получитьсчетчикчисла элементов массива

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

printf "I have %d camel%s.\n", $n, $n == 1 ? "" : "s";

Удобно, что приоритет ?: выше, чем у запятой, но ниже, чем у большинства операторов, используемых внутри (== в данном примере), поэтому обычно не приходится расставлять скобки. Но для ясности можно, при желании, добавить и скобки. Для условных операторов, вложенных в части THEN других условных операторов, мы предлагаем использование перевода строки и отступа, как если бы это были обычные операторы if:

$1еаруеаг =

$уеаг % 4 == О

? $уеаг % 100 == 0

? $уеаг % 400 == 0

? 1 :0 :1 :0;

Для условных операторов, вложенных в части ELSE предшествующих условных операторов, можно сделать аналогичную вещь:

$1еаруеаг =

$уеаг % 4

? 0

:$уеаг % 100

? 1

:$уеаг % 400 ? 0 ：1；

но, как правило, лучше построить все части C0ND и THEN вертикально:

$1еаруеаг 二

$уеаг %4 ? 0 :

$уеаг % 100 ? 1 : $уеаг % 400 ? 0 : 1;

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

printf "Да, мне нравятся мои %s книги!\п", $i18n eq "french" ? "chameau":

$i18n eq "german" ? "Kamel":

$i18n eq "Japanese" ? "\x{99F1}\x{99DD}": “camel”

Можно осуществлять присваивание условному оператору, если второй и третий аргументы являются допустимыми 1-значениями (т. е. допускают присваивание им), и оба являются либо скалярами, либо списками (в противном случае Perl не будет знать, какой контекст предоставить правой части присваивания):

($а_ог_Ь ? $а : $Ь)二 $с; # либо $а, либо $Ь получают значение $с

Имейте в виду, что условный оператор связывает аргументы сильнее, чем различные операторы присваивания. Обычно это и требуется (взгляните, например, на вышеприведенные присваивания $1еаруеаг), но изменить это без помощи скобок нельзя. Присваивание без скобок может привести к неприятностям, при этом можно не получить ошибки синтаксического анализа, поскольку условный оператор может быть проанализирован как левое значение. Например, можно написать так:

$а % 2 ? $а +二 10 : $а += 2# НЕВЕРНО

Но это будет проанализировано так:

(($а % 2) ? ($а +二 10) : $а) +二 2

Операторы присваивания

Perl признает операторы присваивания С, добавляя к ним некоторые собственные. Их много:

=**=+=*=&=<<=&&=

~=/=I=>>=I1=

.=%=

х 二

Каждый оператор требует 1-значения (обычно переменной или элемента массива), являющегося целью, в левой части и выражения в правой части. Для простого оператора присваивания:

TARGET = EXPR

значение EXPR запоминается в переменной или по адресу, указанному в TARGET. Для других операторов Perl вычисляет выражение:

TARGET 0Р= EXPR

как если бы оно было записано:

TARGET = TARGET OP EXPR

Это удобное мысленное правило, но в двух отношениях оно вводит в заблуждение. Во-первых, операторы присваивания всегда анализируются на уровне старшинства обычного присваивания, независимо от приоритета, который ОР имел бы самостоятельно. Во-вторых, TARGET вычисляется только один раз. Обычно это не имеет значения, если нет побочных эффектов, таких как автоинкрементирование:

$va「[$a++] += $value;# $а инкрементируется один раз

$va「[$a++] = $va「[$a++] + $value; # $а инкрементируется два раза

В отличие от С, оператор присваивания создает допустимое 1-значение. Модификация присваивания аналогична выполнению присваивания с последующей модификацией переменной, которой было присвоено значение. Это удобно при модификации копии чего-либо, например:

($tmp = $global) += $constant;

что эквивалентно:

$tmp = $global + $constant;

Аналогично:

($a += 2) *= 3;

эквивалентно:

$a += 2;

$a *二 3;

Это не Бог весть как удобно, но вот идиома, которую можно встретить часто:

($new = $old) =~ s/foo/bar/g;

Во всех случаях значением оператора присваивания является новое значение переменной. Поскольку операторы присваивания ассоциативны справа налево, это можно использовать для присваивания нескольким переменным одного и того же значения:

$а = $Ь = $с = 0;

При этом 0 присваивается $с, результат этого действия (по-прежнему 0) присваивается $Ь, а результат этого действия (по-прежнему 0) присваивается $а.

Присваивание списку может выполняться только простым оператором присваивания =.В списковом контексте присваивание списку возвращает список новых значений - так же, как это делает скалярное присваивание. В скалярном контексте присваивание списку возвращает число значений, имевшихся в правой части присваивания, как отмечалось в главе 2 «Всякая всячина». Благодаря этому такое присваивание удобно использовать для проверки значений функций, возвращающих пустой список, когда их вызов оказывается безуспешным (или перестает быть успешным), например:

while (($key, $value) = each %gloss) { ... } next unless ($dev, $ino, $mode) = stat $file;

Оператор запятой

Бинарный оператор , является оператором запятой. Находясь в скалярном контексте, он вычисляет свой левый аргумент в пустом контексте, отбрасывает полученное значение, затем вычисляет свой правый аргумент в скалярном контексте и возвращает полученное значение. Это действие вполне идентично действию оператора запятой в С. Например:

$а 二(1, 3);

присваивает $а значение 3. Не следует путать использование этого оператора в скалярном и списковом контекстах. В списковом контексте запятая служит просто разделителем аргументов и вставляет оба свои аргумента в LIST. Никакие значения она не отбрасывает.

Например, если изменить предыдущий пример следующим образом:

@а 二(1, 3);

то будет создан список из двух элементов, а

atan2(1, 3);

является вызовом функции atan2 с двумя аргументами.

Диграф => служит в основном синонимом оператора запятой. Он удобен при записи аргументов, которые задаются парами. Кроме того, он заставляет интерпретировать любой идентификатор, находящийся непосредственно слева от него, как строку.

Списковые операторы (справа)

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

Логические and, orf not и xor

В качестве альтернативы для &&, | | и ! Perl предоставляет операторы and, or и not, имеющие низкий приоритет. Способ действия этих операторов идентичен; в частности, and и or обладают свойством сокращенного действия, как и их аналоги, что делает их полезными не только в логических выражениях, но и для управления логикой программы.

Поскольку приоритет этих операторов значительно ниже, чем у заимствованных из С, их можно безопасно использовать после списковых операторов без всяких скобок:

unlink "alpha", "beta", "gamma" or gripe(), next LINE;

Применяя операторы в стиле С, следовало бы написать нечто типа:

unlink("alpha", "beta", "gamma") Н (gripe(), next LINE);

Но нельзя просто взять и заменить все вхождения 11 на or. Допустим, что команду

$xyz = $х II $у I I $z;

мы заменим такой:

$xyz = $х or $у or $z;# НЕВЕРНО

Она сделает совсем другое! Приоритет присваивания выше, чем приоритет or, но ниже, чем приоритет | |, поэтому $х будет присвоена $xyz, а затем выполнены or. Чтобы получить такой же результат, как с использованием 11, нужно написать:

$xyz = ( $х or $у or $z );

Мораль истории такова: выучить приоритеты (или использовать скобки) придется вне зависимости от того, с какими логическими операторами вы работаете.

Существует также логический оператор хог, не имеющий точного аналога в С или Perl, поскольку единственный предоставляемый ими оператор исключающего ИЛИ (人)действует поразрядно. Оператор хог не может иметь сокращенного действия, поскольку необходимо вычисление операндов с обеих сторон. Лучшим эквивалентом для $а хог $Ь является, вероятно, ! $а ! = ! $Ь. Конечно, можно написать ! $а 八! $b или даже $а ? ! $Ь : !! $Ь. Суть в том, что $а и $Ь должны быть вычислены как true или false в булевом контексте, а имеющийся поразрядный оператор не предоставляет булев контекст без до・ полнительных усилий.

Операторы С, отсутствующие в Perl

Вот что есть в С и чего нет в Perl: унарный &

Оператор взятия адреса. Однако оператор \ в Perl (для получения ссылки) занимает ту же экологическую нишу:

$ref_to_var = \$var;

Но ссылки Perl значительно безопаснее, чем указатели С.

унарный *

Оператор разыменования адреса. Поскольку в Perl нет адресов, нет нужды и в их разыменовании. Однако ссылки в нем есть, поэтому символы префиксов переменных Perl служат как операторы разыменования, а также указывают на тип: $, @, % и &. Несколько странно, что фактически имеется оператор разыменования *, но поскольку 女 является специальным символом, обозначающим typeglob, он используется иным образом.

(ТУРЕ)

Оператор приведения типа. Во всяком случае, никому не хочется, чтобы его тип приводили.

4

Операторы и объявления

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

В отличие от большинства языков программирования, Perl не требует, чтобы переменные объявлялись явным образом. Они начинают существовать при первом обращении к ним, независимо от того, были они объявлены или нет. При попытке использовать значение переменной, которой ни разу не было присвоено значение, она по умолчанию считается нулем (если выступает как число) или "" - нулевой строкой (если используется как строка), или получает значение «ложь» при обращении к ней как к логической переменной. Если программист хочет получать предупреждения об использовании неопределенных значений как если бы они действительно были строками или числами или даже рассматривать такие действия как ошибку, то об этом позаботится объявление use warnings (см. раздел «Директивы» в конце данной главы).

Однако разрешается объявить переменную, если есть такое желание, поместив перед ее именем слово ту или our. Программист даже может установить, что использование необъявленной переменной является ошибкой. Это очень хорошо, что соблюдается такой порядок, но необходимо объявить, что этот порядок вам нужен. Обычно Perl не вмешивается в ваши привычки про-

граммирования, но при наличии объявления use strict использование необъявленных переменных перехватывается на этапе компиляции. Опять же, см. раздел «Директивы».

Простые операторы

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

Несмотря на то что такие операторы, как eval {}, do {} и sub {}, выглядят как составные операторы, в действительности они таковыми не являются. Верно, внутри них допускается наличие нескольких команд, но это не в счет. При взгляде извне эти операторы являются просто термами в выражении и потому требуют явного использования точки с запятой, если используются как последний элемент оператора.

За любым простым оператором может следовать один необязательный модификатор, как раз перед завершающей точкой с запятой (или окончанием блока). Допускаются следующие модификаторы:

if EXPR unless EXPR while EXPR until EXPR foreach LIST

Модификаторы if (если) и unless (если только не) действуют весьма схожим с обычным языком образом:

$trash->take('out') if $you_love_me; shutup() unless $you_want_me_to_leave;

Модификаторы while и until вычисляются многократно. Модификатор while обеспечивает повторное выполнение, пока его выражение остается истинным, а модификатор until обеспечивает повторное выполнение, пока его выражение остается ложным:

$expression++ while -е "$file$expression";

kiss('me') until $I_die;

Модификатор foreach (вариант написания for) выполняет одно вычисление для каждого элемента в его списке LIST, при этом $_ служит псевдонимом текущего элемента:

s/java/perl/ for ©resumes;

print "поле: $_\n" foreach split /:/, $dataline;

Модификаторы while и until имеют обычную семантику цикла while (сначала вычисляется условие), за исключением применения к do BLOCK (или команде do SUBROUTINE, использование которой осуждается), когда блок один раз выполняется перед тем, как вычисляется условие. Благодаря этому можно писать такие циклы:

do {

$line = <STDIN>;

} until $line eq ".\n";

Посмотрите три разных описания do в главе 29 «Функции». Обратите также внимание на то, что операторы управления циклом, описываемые ниже, в этой конструкции не будут работать, поскольку модификаторы не принимают метки циклов. Всегда можно поместить вокруг нее лишний блок для досрочного завершения или внутри нее для досрочной итерации, как описывается далее в разделе «Голые блоки». Либо можно написать действительный цикл с несколькими операторами управления циклом внутри. Если речь зашла о настоящих циклах, то нужно сначала поговорить о составных командах.

Составные операторы

Последовательность операторов в области видимости1 называется блоком. Иногда областью видимости является весь файл, например файл, загружаемый директивой require, или файл, содержащий главную программу. Иногда областью видимости является строка, вычисляемая через eval. Но обычно блок ~ это то, что заключено в фигурные скобки ({}). Когда говорят об области видимости, то имеют в виду любой из этих трех вариантов. Когда имеют в виду блок в фигурных скобках, то используют термин «блок» (BLOCK).

Составные операторы образуются из выражений и блоков (BLOCK). Выражения состоят из термов и операторов. В наших синтаксических описаниях мы будем словом EXPR обозначать место, в котором можно использовать любое скалярное выражение. Для обозначения выражения, вычисляемого в списковом контексте, будем говорить LIST.

Следующие команды можно применять для управления условным и многократным выполнением блоков BLOCK. (Часть LABEL является необязательной.)

if (EXPR) BLOCK

if (EXPR) BLOCK else BLOCK

if (EXPR) BLOCK elsif (EXPR) BLOCK ...

if (EXPR) BLOCK elsif (EXPR) BLOCK . .. else BLOCK

Области видимости и «Всякая всячина».Области видимости и «Всякая всячина».пространства имен описываются в разделе «Имена» главы 2

Области видимости и «Всякая всячина».

Области видимости и «Всякая всячина».

LABEL while

LABEL while

(EXPR) BLOCK

(EXPR) BLOCK continue BLOCK

LABEL until

LABEL until

(EXPR) BLOCK

(EXPR) BLOCK continue BLOCK

unless unless unless unless

(EXPR) BLOCK

(EXPR) BLOCK else BLOCK

(EXPR) BLOCK elsif (EX叩)BLOCK ...

(EXPR) BLOCK elsif (EXPR) BLOCK . .. else BLOCK

LABEL for (EXPR; EXPR; EXPR) BLOCK

LABEL foreach (LIST) BLOCK

LABEL foreach VAR (LIST) BLOCK

LABEL foreach VAR (LIST) BLOCK continue BLOCK

LABEL BLOCK

LABEL BLOCK continue BLOCK

Обратите внимание на то, что, в отличие от С и Java, они определены в терминах блоков, а не операторов. Это означает, что фигурные скобки необходимы -наличие висящих операторов не допускается. Условный оператор без фигурных скобок можно записать несколькими способами. Все следующие команды делают одно и то же:

unless (open(FOO, $foo)) if (!open(FOO, $foo))die "Невозможно открыть $foo: $!die "Невозможно открыть $foo: $!open(FOO, $foo) open FOO, $foounless (open(FOO, $foo)) if (!open(FOO, $foo))die "Невозможно открыть $foo: $!die "Невозможно открыть $foo: $!open(FOO, $foo) open FOO, $foo{ die "Невозможно открыть $foo: $!" }{ die "Невозможно открыть $foo: $!" }{ die "Невозможно открыть $foo: $!" }{ die "Невозможно открыть $foo: $!" }11 die or die11 die or dieunless open(FOO, $foo);if !open(FOO, $foo);Невозможно открыть $foo: $!Невозможно открыть $foo: $!unless open(FOO, $foo);if !open(FOO, $foo);Невозможно открыть $foo: $!Невозможно открыть $foo: $!

unless (open(FOO, $foo)) if (!open(FOO, $foo))

die "Невозможно открыть $foo: $!

die "Невозможно открыть $foo: $!

open(FOO, $foo) open FOO, $foo

unless (open(FOO, $foo)) if (!open(FOO, $foo))

die "Невозможно открыть $foo: $!

die "Невозможно открыть $foo: $!

open(FOO, $foo) open FOO, $foo

{ die "Невозможно открыть $foo: $!" }

{ die "Невозможно открыть $foo: $!" }

{ die "Невозможно открыть $foo: $!" }

{ die "Невозможно открыть $foo: $!" }

11 die or die

11 die or die

unless open(FOO, $foo);

if !open(FOO, $foo);

Невозможно открыть $foo: $!

Невозможно открыть $foo: $!

unless open(FOO, $foo);

if !open(FOO, $foo);

Невозможно открыть $foo: $!

Невозможно открыть $foo: $!

В большинстве случаев мы предпочитаем последнюю пару форматов. Они выглядят менее перегруженными, чем остальные, особенно вариант or die. В формате | | нужно привыкнуть к скрупулезному указанию кавычек, но в версии or о них можно и позабыть.

Но главная причина, по которой нам больше нравятся последние варианты, состоит в том, что они выдвигают в начало строки самую важную часть оператора, где ее сразу видно. Обработка ошибки смещается в сторону, так что можно не обращать на нее внимания, пока в этом не возникнет необходимость. Если каждый раз табулировать все проверки or die, чтобы они оказывались в одной и той же колонке справа, то чтение окажется еще более легким:

chdir $dir open FOO, $filechdir $dir open FOO, $fileor die "Смена каталога $dir: $! or die "Открытие $file: $!";

chdir $dir open FOO, $file

chdir $dir open FOO, $file

@lines = <F00>or die "$file пуст?";

close FOOor die "Закрытие $file: $!";

Операторы if и unless

Оператор if прост. Поскольку блоки всегда заключены в фигурные скобки, неоднозначности в отношении того, к которому if относится тот или иной else или elsif, не возникает. Из каждой данной последовательности блоков if/elsif/else выполняется только тот первый, значение условия которого истинно. Если ни одно условие не является истинным, то выполняется блок else, если он имеется. Обычно полезно поместить else в конце цепочки elsif на тот случай, если один из вариантов будет случайно пропущен.

Если unless используется вместо if, то смысл проверки условия становится противоположным. Это значит, что:

unless ($х == 1)...

равносильно:

if ($х != 1)...

или даже неприглядному:

if (!($х == 1))…

Область видимости переменной, объявленной в управляющем условии, простирается от места ее объявления и по всему условному оператору, включая все elsif и завершающее предложение else, если они имеются, но не далее того:

if ((my $color 二 <STDIN>) =~ /red/i) { $value = OxffOOOO;

}

elsif ($color =~ /green/i) { $value = OxOOffOO;

}

elsif (Scolor =~ /blue/i) { $value = OxOOOOff;

}

else {

warn "неизвестная составляющая RGB 'Scolorr, вместо нее использован черный \n"; $value = 0x000000;

}

По завершении блока else переменная $color больше не видима. Если нужно продлить область видимости, объявите переменную заранее.

Операторы Loop

Формальный синтаксис всех операторов цикла допускает использование необязательной метки LABEL. (Метку можно поставить против любого оператора, но в цикле она имеет особое значение.) Метка состоит из идентификатора и двоеточия, следующего за ним. Обычно метки пишутся в верхнем регистре, чтобы избежать конфликта с зарезервированными словами и для лучшего выделения. Perl не будет сбит с толку, если использовать метку, уже имеющую значение, например метку if или open, чего нельзя сказать о тех, кто будет читать вашу программу.

Операторы while и until

Оператор while повторно выполняет блок, пока EXPR остается истинным. Если слово while заменить словом until, то смысл проверки становится противоположным, т. е. блок выполняется, только пока EXPRимеет значение «ложь». Однако условие все равно проверяется перед первой итерацией цикла.

Операторы while или until могут иметь необязательный дополнительный блок: блок continue, выполняемый тогда, когда блок продолжается - при выходе за конец первого блока или явном вызове next (оператор управления циклом, который вызывает переход к новой итерации). На практике блок continue применяется не слишком часто, но, сказав о нем, мы теперь сможем строго определить цикл for в следующем разделе.

В отличие от цикла foreach, который мы рассмотрим несколько ниже, цикл while не локализует переменные в проверяемом условии неявным образом. В результате могут возникнуть «интересные» последствия, если в качестве переменных цикла используются глобальные переменные. В частности, посмотрите в разделе «Оператор ввода строки (угловые скобки)» главы 2 «Всякая всячина», как в некоторых циклах while может происходить неявное присвоение глобальной переменной $_, а также пример того, как решить эту проблему, явно делая $_ локальной. Другие переменные цикла лучше всего объявлять с помощью ключевого слова ту, как показано в следующем примере.

Переменная, объявленная в условии оператора while или until, имеет видимость только в одном или нескольких блоках, на которые распространяется действие этого условия. Она не входит в окружающую область видимости. Например:

while (my $line = <STDIN>) {

$line = 1c $line;

}

continue {

print $line; # пока видима

}

теперь $line ушла из области видимости

В данном случае область видимости $line простирается от ее объявления в управляющем выражении через всю конструкцию цикла, включая блок

continue, но не далее того. Если необходимо продлить область видимости, объявите переменную перед циклом.

Циклы for

Состоящий из трех частей цикл for содержит в скобках выражения, разделенные точкой с запятой. Эти выражения выступают, соответственно, как выражения инициализации, условия и реинициализации цикла. Все три выражения (но не точки с запятыми) не обязательны; условие, если оно опущено, всегда считается истинным. Таким образом, состоящий из трех частей цикл for можно определить на языке соответствующего цикла while. Оператор:

LABEL:

for (my $i = 1; $i <= 10; $i++) {

}

аналогичен следующему:

{

my $i = 1;

LABEL:

while ($i <= 10) {

} continue { $i++;

}

}

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

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

for ($i = 0, $bit = 0; $i < 32; $i++, $bit «= 1) { print "Бит $i установлен \n" if $mask & $bit;

}

значения $i и $bit сохраняются после конца цикла

Можно также объявить эти переменные так, чтобы они оказались видимыми только внутри цикла for:

for (my ($i, $bit) = (0, 1); $i < 32; $i++, $bit «= 1) { print "Бит $i установлен \n" if $mask & $bit;

}

теперь версии $i и $bit для цикла вышли из области видимости

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

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

$on_a_tty 二-t STDIN && -t STDOUT;

sub prompt { print "да? " if $on_a_tty }

for ( prompt(); <STDIN>; prompt() ) { # какие-то действия

}

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

for (；；) {

Это то же самое, что

while (1) {

}

Если вас смущает идея бесконечного цикла, то следует заметить, что всегда можно выйти из цикла, находясь в любом его месте, с помощью явного оператора управления циклом, такого как last. Конечно, если разрабатывается управляющая программа для крылатой ракеты, то явный выход из цикла может не потребоваться. В должное время цикл будет завершен автоматически.1

Циклы foreach

Цикл foreach осуществляет перебор списка значений, последовательно устанавливая управляющую переменную (VAH) равной каждому элементу списка:

foreach VAR (LIST) {

Ключевое слово foreach служит просто синонимом ключевого слова for, поэтому for и foreach можно использовать взаимозаменяемо и в зависимости от того, которое из них выглядит более удобочитаемым в конкретной ситуации. Если VAR опущена, используется глобальная переменная $_. (Не беспокойтесь, Perl легко отличит for (@ARGV) от for ($i=0; $i<$#ARGV; $i++), поскольку в последнем содержатся точки с запятой.) Вот несколько примеров:

То есть имеется тенденция к автоматическому выходу из цикла.

$sum = 0; foreach $value (@array) { $sum += $value }

for $count (10,9,8,7,6,5,4,3,2,1,'БУМ!') { # обратный счет print "$count\n"; sleep(1);

}

for (reverse 'БУМ!', 1 .. 10) {# то же самое

print "$_\n"； sleep(1);

}

for $field (split /:/, $data) {# любое выражение LIST

print "Поле содержит: '$field'\n";

}

foreach $key (sort keys %hash) { print "$key => $hash{$key}\n";

}

Последний пример представляет собой канонический способ вывода значений хеша в отсортированном порядке. Более подробные примеры можно найти в описаниях keys и sort в главе 29 «Функции».

Применяя foreach, невозможно узнать, в каком месте списка вы находитесь. Можно сравнивать соседние элементы списка, запоминая предыдущий элемент в какой-нибудь переменной, но иногда нужно просто взять и написать трехчастный цикл for, перебирающий индексы. В конце концов, для того и создан цикл for второго типа.

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

# всем прибавка 8%# всем прибавка 8%# изменить меню# изменить меню# то же# удалить ведущие пробелы# удалить замыкающие пробелы# то же# удалить ведущие пробелы# удалить замыкающие пробелыforeach $рау (@salaries) { $рау *= 1.08;

# всем прибавка 8%

# всем прибавка 8%

# изменить меню

# изменить меню

# то же

# удалить ведущие пробелы

# удалить замыкающие пробелы

# то же

# удалить ведущие пробелы

# удалить замыкающие пробелы

}

for (@christmas, @easter) { s/ham/turkey/;

s/ham/turkey/ for @christmas, @easter; for ($scala「， @array, values %hash) {

s/[s+〃；

s/\s+$〃；

}

Переменная цикла действует только в динамической или лексической области видимости цикла и неявно становится лексической, если предвари-

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

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

for my $i (1 .. 10) { ... }# $i всегда лексическая

for our $Tick (1 .. 10) { ... }# $Tick всегда глобальная

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

Вот как программист С или Java мог бы поначалу решить запрограммировать некоторый алгоритм на Perl:

for ($i = 0; $i < @ary1; $i++) {

for ($j = 0; $j < @ary2; $j++) {

if ($ary1[$i] > $a「y2[$j]) {

last;# Нельзя выйти во внешний цикл.:-(

}

$ary1[$i] += $a「y2[$j];

}

сюда приведет этот last

}

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

WID: foreach $this (@агу1) {

JET: foreach $that (@агу2) { next WID if $this > $that; $this += $that;

}

}

Видите, насколько легче это делается с помощью идиом Perl? Аккуратнее, надежнее и быстрее. Аккуратнее, поскольку меньше шума. Надежнее, поскольку если позже добавить код между внутренним и внешним циклами, новый код не будет выполнен по ошибке, так как next (о котором говорится ниже) явно проходит внешний цикл, а не просто выходит из внутреннего. И быстрее, поскольку Perl выполняет оператор foreach быстрее, чем эквивалентный ему цикл for, т. к. обращение к элементам выполняется непосредственно, а не через индексы.

Однако пишите так, как вам больше нравится. TMTOWTDL

Как и оператор while, оператор foreach может иметь блок continue. Это позволяет выполнять фрагмент кода в конце каждой итерации цикла вне зависимости от того, попадаете вы в него при обычном ходе событий или посредством next.

И теперь мы можем, наконец, сказать: next будет следующим.

Управление циклом

Мы уже говорили о том, что можно поместить метку на цикле и тем самым дать ему имя. Метка цикла идентифицирует его для операторов управления циклом, таких как next, last и redo. Метка дает имя циклу в целом, не только его вершине. Поэтому оператор управления циклом, ссылаясь на цикл, на самом деле не осуществляет переход «go to» на метку цикла. С точки зрения компьютера, с таким же успехом метку можно было поместить и в конце цикла, но по каким-то причинам люди предпочитают, чтобы метка стояла вверху.

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

next LINE if /」/; # выкинуть комментарии

Синтаксис операторов управления циклом следующий:

last LABEL next LABEL redo LABEL

Метка LABEL является необязательной; если она опущена, то оператор ссылается на самый внутренний из охватывающих циклов. Но если нужно перескочить более чем через один уровень, вы должны использовать метку, чтобы указать цикл, на который хотите оказать воздействие. Эта метка не обязана попадать в вашу лексическую область видимости, хотя, вероятно, ей следовало бы там находиться. На самом деле метка может находиться в любом месте вашей динамической области видимости. Если при этом происходит выход из eval или подпрограммы, Perl выдаст предупредительное сообщение (если его об этом попросить).

Так же как можно иметь в функции сколько угодно операторов return, в цикле можно иметь сколько угодно операторов управления циклом. Не следует считать это плохим тоном. На заре структурного программирования некоторые настаивали на том, чтобы в циклах и программах имелось только по одному входу и одному выходу. Концепция одного входа по-прежнему

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

Оператор last осуществляет немедленный выход из соответствующего цикла. Блок continue, если он есть, не выполняется. В следующем примере осуществляется « катапультирование » из цикла после обнаружения первой пустой строки:

LINE: while (<STDIN>) {

last LINE if /八$/; # выйти после обработки почтового заголовка

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

LINE: while (<STDIN>) {

next LINE if /Л#/;# пропустить комментарии

next LINE if /^$/;# пропустить пустые строки

} continue { $count++;

}

Оператор redo перезапускает блок цикла, не проверяя снова условия. Блок continue, если он есть, не выполняется. Этот оператор часто используется в программах, которым требуется «обмануть» себя, читая данные. Предположим, что обрабатывается файл, в котором строка может завершаться обратной косой чертой, означающей продолжение записи на следующей строчке. Вот как в этом случае можно использовать redo:

while (о) { chomp; if (s/\\$〃){ $_ •= <>； redo unless eof;# не читать после eof каждого файла

}

теперь обработать $_

Это обычное сокращение Perl для более явного (и скучного) варианта:

LINE: while (defined($line = <ARGV>)) { chomp($line);

if ($line s/\\$//) {

$line .= <ARGV>;

redo LINE unless eof(ARGV);

}

теперь обработать $line

}

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

ARG: while (@ARGV && $ARGV[O] =~ s/”(？=. )//) {

ОРТ: for (shift @ARGV) {

m/飞/

&& do {

next ARG;

m/Y/

&& do {

last ARG;

s/P//

&& do { $Debug_Level++;

redo OPT;

s/F〃

&& do { $Gene「ate_Listing++;

redo OPT;

s/F(・*)〃

&& do { $In_Place = $1 || ".bak";

next ARG;

say_usage('

'Неизвестная опция: $_");

}

Еще одно замечание относительно операторов управления циклом. Как можно было заметить, мы не называем их утверждениями (statements). Это связано с тем, что они не являются утверждениями, хотя, как всякое выражение, могут быть использованы как утверждение. Можно даже представить их себе как унарные операторы, которым дозволено изменять порядок выполнения программы. Поэтому их допускается применять везде, где имеет смысл их использование в выражении. На самом деле операторы управления циклом можно использовать даже там, где это не имеет смысла. Иногда можно видеть в программе такую ошибку:

open FILE, $file

or warn "Невозможно открыть $file: $!\n", next FILE; # НЕВЕРНО

Намерения благие, но next FILE будет проанализирован как аргумент warn, являющегося списковым оператором. Поэтому next выполняется раньше, чем warn получает возможность выдать предупреждение. В данном случае ситуацию легко исправить, обратив списковый оператор warn в вызов функции warn с помощью надлежащим образом расставленных скобок:

open FILE, $file

or warn("Невозможно открыть $file: $!\n"), next FILE; # okay

Однако может показаться, что следующий код прочесть легче:

unless (open FILE, $file) {

warn "Невозможно открыть $file: $!\n";

next FILE;

Голые блоки

Отдельный блок, независимо от наличия у него метки, семантически эквивалентен однократно выполняемому циклу. Поэтому можно использовать last для выхода из блока или redo для его повторного выполнения. Заметьте, что это не так для блоков в eval {}, sub {} и, ко всеобщему удивлению, do {}. Эти три конструкции - не блоки циклов, поскольку сами не являются блоками (BLOCKS); стоящее впереди ключевое слово делает их просто термами в выражении, в которых оказался блок кода. Поскольку они не являются блоками циклов, им нельзя присвоить метку или применить операторы управления циклом. Операторы управления циклом можно использовать только в настоящих циклах, так же как return - только в подпрограмме (ну, еще в eval).

Операторы управления циклом не работают также в if и unless, поскольку это не циклы. Но всегда можно вставить дополнительную пару фигурных скобок, чтобы создать голый блок, который считается циклом:

if (/pattern/) {{ last if /alpha/; last if /beta/; last if /gamma/; # какие-то действия, если все еще в if() }}

Вот каким образом блок обеспечивает операторам управления циклом возможность работать с конструкцией do {}. Для того чтобы использовать next или redo в do, поместите внутрь голый блок:

do {{

next if $х == $у;

здесь какие-то действия

}} until $х++ > $z;

Для применения last нужно потрудиться больше:

{ do { last if $х = $у ** 2;

# здесь какие-то действия

} while $х++ <= $z;

}

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

DO.LAST: {

do {

DO_NEXT:{

next DO_NEXT if $x == $y;

last DO_LAST if $x = $y ** 2;

# здесь какие-то действия

}

} while $x++ <= $z;

}

Но, дойдя до такой конструкции (если не раньше), лучше всего организовать обычный бесконечный цикл с last в конце:

for (；；) {

next if $х == $у;

last if $х = $у ** 2;

# здесь какие-то действия last unless $х++ <= $z;

}

Структуры типа case

В отличие от некоторых других языков программирования, в Perl нет официальных операторов switch или case. Это связано с тем, что в Perl они и не требуются, т. к. он предоставляет много способов делать то же самое, что и эти операторы. Особенно удобны для создания структур типа case (многовариантных переключателей) голые блоки. Вот один пример:

last SWITCH; } last SWITCH; } last SWITCH; }last SWITCH; } last SWITCH; } last SWITCH; }SWITCH: {

last SWITCH; } last SWITCH; } last SWITCH; }

last SWITCH; } last SWITCH; } last SWITCH; }

if (/%Ьс/) { $abc = 1 if (/^def/) { $def = 1 if (Cyz/) { $xyz = 1 $nothing = 1;

}

а вот другой:

SWITCH: {

}}

}

}

/^abc/

&&

do {

$abc =

1; last

SWITCH; }

/Fef/

&&

do {

$def =

1; last

SWITCH; }

/^xyz/

&&

do {

$xyz =

1; last

SWITCH; }

$nothing =

:1；

или с таким форматированием, которое лучше выделяет каждый вариант:

SWITCH: {

/%Ьс/&& do {

$abc 二 1;

last SWITCH;

}；

/Fef/ && do {

$def 二 1;

last SWITCH;

}；

/^xyz/ && do {

$xyz = 1;

last SWITCH;

}；

$nothing = 1;

}

или даже (о, ужас!):

if

(/%bc/)

{ $abc = 1 }

elsif

(/Fef/)

{ $def = 1 }

elsif

(/%yz/)

{ $xyz 二 1 }

else

{ $nothing 二 1 }

В следующем примере обратите внимание на то, как операторы last игнорируют блоки do {}, которые не являются циклами, и осуществляют выход из цикла for:

for ($very_nasty_long_name[$i++][$j++]->method()) {

/this pattern/ and do { push @flags, '-e'; last; };

/that one/ and do { push @flags, '-h'; last; };

/something else/ and do {last; };

die "неизвестное значение: '$_'";

}

Вам может показаться странным, что организуется цикл по единственному значению, поскольку проход через цикл будет совершен только один раз. Однако удобно использовать способность for/foreach создавать псевдонимы для того, чтобы осуществить временное, локальное присвоение для $_. При повторяющихся сравнениях с одним и тем же длинным значением это весьма облегчает ввод с клавиатуры и, соответственно, затрудняет возникновение опечаток. Устраняется возможность получения побочного эффекта от повторного вычисления выражения. А что касается данного раздела, то это одна из наиболее часто встречающихся стандартных идиом, реализующих структуру switch или case.

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

$value 二 /red/OxFFOOOO/green/?OxOOFFOO/blue/OxOOOOFF0x000000$value 二 /red/OxFFOOOO/green/?OxOOFFOO/blue/OxOOOOFF0x000000for ($user_color_preference) {for ($user_color_preference) {# черный, если нет совпадений# черный, если нет совпадений

$value 二 /red/

OxFFOOOO

/green/

?

OxOOFFOO

/blue/

OxOOOOFF

0x000000

$value 二 /red/

OxFFOOOO

/green/

?

OxOOFFOO

/blue/

OxOOOOFF

0x000000

for ($user_color_preference) {

for ($user_color_preference) {

# черный, если нет совпадений

# черный, если нет совпадений

}

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

%color_map =(

azure chartreuse lavender magenta turquoiseazure chartreuse lavender magenta turquoise二〉OxFOFFFF, -> 0x7FFF00, => 0xE6E6FA, => OxFFOOFF, => 0x40E0D0,二〉OxFOFFFF, -> 0x7FFF00, => 0xE6E6FA, => OxFFOOFF, => 0x40E0D0,

azure chartreuse lavender magenta turquoise

azure chartreuse lavender magenta turquoise

二〉OxFOFFFF, -> 0x7FFF00, => 0xE6E6FA, => OxFFOOFF, => 0x40E0D0,

二〉OxFOFFFF, -> 0x7FFF00, => 0xE6E6FA, => OxFFOOFF, => 0x40E0D0,

）；

то точный поиск строки выполняется быстро:

$value 二 $color_map{ 1c $user_color_preference } || 0x000000;

Даже сложные многократно ветвящиеся операторы (где в каждом случае требуется выполнить несколько различных операторов) можно превратить в быстрый поиск. Нужно только использовать хеш ссылок на функции. О том, как это делается, рассказано в разделе «Хеши функций» главы 9 «Структуры данных».

goto

Не по малодушию (но и не с легким сердцем) Perl все же поддерживает оператор goto. Есть три его вида: goto LABEL, goto EXPR и goto &NAME.

В формате goto LABEL отыскивается оператор с меткой LABEL и выполнение продолжается с него. Его нельзя применять для перехода в какую-либо конструкцию, требующую инициализации, например, подпрограмму или цикл foreach. Нельзя также использовать его для перехода в конструкцию, удаленную в результате оптимизации (см. главу 18 «Компиляция»). С его помощью можно перейти почти в любое другое место в текущем блоке или любом блоке динамической области видимости (т. е. блоке, из которого был произведен вызов). Посредством goto можно даже выходить из подпрограмм, но обычно лучше делать это другими средствами. Автор Perl никогда не испытывал нужды использовать эту форму goto (имеется в виду, в Perl, в С это другое дело).

Форма goto ЕХРН является просто обобщением goto LABEL. Предполагается, что результат вычисления выражения EXPR представляет собой имя метки, местонахождение которой, очевидно, должно динамически определяться интерпретатором. В результате можно применять вычисляемые переходы goto, как в FORTRAN, что не особенно рекомендуется делать, если требуется облегчить сопровождение кода:

goto(("FOO", "BAR", "GLARCH")[$i]); # в надежде, что 0 <= i < 3

@loop_label = qw/FOO BAR GLARCH/;

goto $loop_label[rand @loop_label]; # случайная телепортация

В большинстве подобных случаев обычно гораздо более правильным решением является применение структурных механизмов управления последовательностью выполнения, предоставляемых next, last и redo, а не использование goto. В некоторых приложениях разумный подход состоит в использовании хеша ссылок на функции или обработки исключительных ситуаций с помощью пары eval и die.

Форма goto &NAMEявляется прямо волшебной и достаточно далека от обычного goto, что должно избавить ее пользователей от тех оскорблений, которым обычно подвергаются те, кто не пренебрегает goto. Она заменяет вызов указанной подпрограммы на подпрограмму, выполняющуюся в данный момент. Такое свойство этого оператора используется подпрограммами AUTOLOAD, чтобы загрузить другую подпрограмму, а затем представить дело так, будто в первую очередь была вызвана та, другая подпрограмма. После goto даже функция caller не сможет определить, что первой была вызвана данная подпрограмма. Все модули autouse, AutoLoader и SelfLoader используют эту стратегию, чтобы определять функции при первом к ним обращении, а затем передавать в них управление, так что никто никогда и не заметит, что этих функций в начале не было.

Глобальные объявления

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

Это значит, что нельзя создавать условные объявления подпрограмм или форматов, скрывая их от компилятора в условных операторах этапа исполнения типа if, т. к. только интерпретатор обращает внимание на условное выполнение этих операторов. Объявления подпрограмм и форматов (а также объявления use и по) видны компилятору независимо от того, где они находятся. Глобальные объявления обычно помещаются в начале или конце программы либо отдельно в другом файле. Однако при объявлении переменных с лекси-

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

Заметьте, что мы незаметно перешли в разговоре с объявлений на определения. Иногда полезно разделить определение (definition) подпрограммы и ее объявление (declaration). Единственная синтаксическая разница между ними в том, что определение включает блок, содержащий код, который должен быть выполнен, а в объявлении его нет. (Определение подпрограммы действует как ее объявление, если объявления нет в области видимости.) Отделение определения от объявления позволяет поместить объявление подпрограммы в начало файла, а определение - в конец (при этом ваши объявления переменных с лексической областью видимости удачно располагаются посередине):

sub count (@);# Теперь компилятор знает, как вызывать count().

my $х;# Теперь компилятор знает о лексической переменной.

$х = count(3,2,1);# Компилятор может проверить вызов функции.

sub count (@) { @_ } # Теперь компилятор знает, что означает count().

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

Объявление подпрограммы позволяет использовать ее при компиляции, начиная с данного места, без скобок, как если бы это был встроенный оператор. (В последнем примере мы использовали скобки для вызова count, но фактически этого не требовалось.) Объявить подпрограмму, не определяя ее, можно, просто сказав:

sub myname;

$me = myname $0or die "He могу найти myname";

Такое голое объявление делает функцию списковым, а не унарным оператором, поэтому будьте внимательны и применяйте or, а не 11. Оператор 11 слишком сильно связывает аргументы, чтобы быть использованным после списковых операторов, хотя всегда можно заключить аргументы спискового оператора в круглые скобки, превратив его снова в нечто, более похожее на вызов функции. Альтернативным вариантом является использование прототипа ($), позволяющее превратить подпрограмму в унарный оператор:

sub myname ($);

$me = myname $0|| die " Не могу найти myname";

Теперь это будет проанализировано так, как вы рассчитываете, но все же следует выработать привычку использовать в такой ситуации or. Подробнее о прототипах см. главу 6 «Подпрограммы».

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

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

Более удобный способ загрузки объявлений и определений предоставляет директива use, которая, по сути, вызывает require для модуля на этапе компиляции (поскольку use рассматривается как блок BEGIN) и позволяет импортировать некоторые из объявлений модуля в вашу программу. Поэтому можно рассматривать use как своего рода глобальное объявление, поскольку она на этапе компиляции импортирует имена в ваш собственный (глобальный) пакет так, как если бы вы объявили их сами. В разделе «Таблицы символов» главы 10 «Пакеты» приведено описание механизма низкого уровня, действующего при импорте из одного пакета в другой; в главе 11 «Модули» - описание настройки импорта и экспорта в модуле; в главе 18 «Компиляция» - описание BEGIN и родственных ему CHECK, INIT и END, которые тоже в некотором роде служат глобальными объявлениями, поскольку работа с ними происходит на этапе компиляции и может иметь глобальные результаты.

Объявления с областью видимости

Как и глобальные объявления, объявления с лексической областью видимости оказывают воздействие на этапе компиляции. В отличие от глобальных объявлений, объявления с лексической областью видимости действуют только от точки, где находится объявление, и до конца самой внутренней из охватывающих областей видимости (блока, файла или eval - что раньше встретится). Поэтому мы говорим: «с лексической областью видимости», хотя «с текстуальной областью видимости» было бы, вероятно, точнее, поскольку «лексическая область видимости» имеет мало общего со словарями (лексиконами). Однако компьютерные специалисты во всем мире знают, что означает «лексическая область видимости» («lexically scoped»), поэтому мы сохраняем здесь это название.

Perl поддерживает также объявления с динамической областью видимости. Динамическая область видимости (dynamic scope) тоже распространяется до конца самого внутреннего из охватывающих блоков, но в этом случае «охватывание» динамически определяется на этапе исполнения, а не текстуально на этапе компиляции. Иными словами, динамическая вложенность блоков определяется вызовом одного блока другим, а не включением одного в состав другого. Эта вложенность динамических областей может отчасти кор-

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

Мы уже говорили о том, что в некоторых отношениях use можно рассматривать в качестве глобального объявления, но в других отношениях use имеет лексическую область видимости. В частности, use не только импортирует имена пакета, но также осуществляет различные магические подсказки компилятору, называемые директивами. Прагмы в большинстве своем имеют лексическую область видимости, включая директиву use strict 'vacs', которая требует, чтобы переменные были объявлены перед использованием. См. далее раздел «Прагмы».

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

Объявления переменных с областью видимости

Оставшаяся часть главы посвящена в основном использованию глобальных переменных. Или скорее тому, как не использовать глобальные переменные. Есть несколько объявлений, помогающих обойтись без глобальных переменных -или, по крайней мере, без неразумного их применения.

Мы уже упоминали объявление пакета, давно введенное в Perl для того, чтобы позволить разбить глобальные переменные на несколько пакетов. Для некоторых типов переменных это действует довольно хорошо. Пакеты используются библиотеками, модулями и классами для хранения данных своих интерфейсов (и некоторых своих полузакрытых данных), чтобы избежать конфликтов с одноименными переменными и функциями в основной программе или других модулях. Так, запись $Some:: stuff означает, что используется скалярная переменная $stuff из пакета Some. См. главу 10 «Пакеты».

Если бы в этом заключалось все, относящееся к данному вопросу, то программы Perl по мере увеличения в размере быстро становились бы громоздкими. К счастью, имеющиеся в Perl три объявления области видимости позволяют легко создавать совершенно закрытые переменные (с помощью ту), предоставлять избирательный доступ к глобальным переменным (посредством our) и обеспечивать временные значения для глобальных переменных (с использованием local):

my $nose;

our $House;

local $TV_channel;

Если перечисляется более одной переменной, то список должен быть заключен в круглые скобки. Для ту и our элементы могут быть только простыми скалярными переменными, переменными массивов и хешей. Для local ограничения несколько более слабые: можно сделать локальными также целые записи таблицы имен typeglob и отдельные элементы или срезы массивов и хешей:

my ($nose, @eyes, %teeth);

our ($House, @Autos, %Kids);

local (*Spouse, $phone{HOME});

Каждый из этих модификаторов предоставляет свой тип «заключения» для модифицируемых переменных. Несколько упрощая, можно сказать, что our ограничивает область видимости имен, local ограничивает область видимости значений, а ту ограничивает область видимости как имен, так и значений.

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

Синтаксически my, our и local являются просто модификаторами (как прилагательные) выражения 1-значения. Когда выполняется присваивание модифицированному 1-значению, модификатор не влияет на то, рассматривается ли 1-значение как скаляр или как список. Чтобы узнать, как будет работать присваивание, можно просто представить себе, что модификатор отсутствует. Поэтому каждое из:

my ($foo) = <STDIN>;

ту @array = <STDIN>;

предоставляет списковый контекст для правой части, в то время как:

my $foo = <STDIN>;

предоставляет скалярный контекст.

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

my $foo, $bar = 1;my $foo, $bar = 1;# НЕВЕРНО# НЕВЕРНО

my $foo, $bar = 1;

my $foo, $bar = 1;

# НЕВЕРНО

# НЕВЕРНО

Это равносильно следующему:

my $foo;

$bar = 1;

Если включен вывод предупредительных сообщений с помощью ключей командной строки -w или -W или, что предпочтительней, через объявление use warnings, описываемое далее в разделе «Прагмы», то будет получено сообщение об ошибке.

В целом, лучше всего объявить для переменной минимальную допустимую область видимости, которая годится для нее. Поскольку переменные, объявляемые в операторе управления логикой программы, видимы только в блоке, которым управляет этот оператор, их видимость является ограниченной. Читаемость на естественном языке благодаря этому тоже улучшается.

sub check_warehouse {

for my $widget (our @Current_Inventory) {

print "Сегодня у меня на складе есть $widget.\л";

}

}

Чаще всего встречается тип объявления ту, объявляющий переменные с лексической областью видимости, имена и значения которых хранятся во временной памяти текущей области видимости и не доступны глобально. Очень близко к нему объявление оиг, которое вводит в текущую область видимости имя с лексической областью видимости, как и ту, но при этом фактически ссылается на глобальную переменную, к которой при желании может обратиться каждый. Иными словами, это глобальная переменная, маскирующаяся под лексическую.

Другая форма области видимости, динамическая область видимости, применяется к переменным с модификатором local, которые, несмотря на слово «local», являются на самом деле глобальными переменными и не имеют никакого отношения к локальной временной памяти.

Переменные с лексической областью видимости: ту

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

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

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

my $name = "feed";

ту @stuff 二("саг", "house", "club");

ту (Svehicle, $home, Stool) = @stuff;

Эти лексические переменные совершенно скрыты от всего мира за пределами непосредственно охватывающей их области видимости. В отличие от действия динамической области видимости, создаваемой local (см. следующий раздел), лексические переменные скрыты от любых подпрограмм, вызываемых из своей области видимости. Это верно даже в отношении той же самой подпрограммы, вызываемой из себя самой или из любого другого места: каждый экземпляр подпрограммы получает собственную «временную память» для лексических переменных.

В отличие от области видимости блока, области видимости файла не могут быть вложенными; «охват», по крайней мере, текстуально, не имеет места. Если вы загружаете код из отдельного файла с помощью do, require или use, то код в этом файле не имеет доступа к вашим лексическим переменным, равно как и вы не имеете доступа к лексическим переменным из этого файла.

Однако любая область видимости внутри файла (и даже сам файл) действует по правилам. Часто удобно иметь области видимости более широкие, чем определения функций, так как это позволяет организовать совместный доступ к закрытым переменным для ограниченного набора подпрограмм. Так создаются переменные, которые С-программист назвал бы статическими:

{

my $state 二 0;

sub on{ Sstate = 1 }

sub off{ $state 二 0 }

sub toggle { $state = !Sstate } }

Оператор eval STRING тоже действует как вложенная область видимости, поскольку код в eval может видеть лексические переменные вызвавшей его области (если их имена не замаскированы идентичными объявлениями в собственной области видимости eval). Аналогично анонимные подпрограммы могут обращаться ко всем лексическим переменным охватывающей их области видимости; когда это происходит, их называют замыканиями (closures). Объединим эти два замечания: если блок выполняет eval над строкой

и создает при этом анонимную подпрограмму, эта подпрограмма становится замыканием с полным доступом к лексическим переменным как eval, так и блока, даже после выхода из eval и блока. См. раздел «Замыкания» главы 8 «Ссылки».

Вновь объявленная переменная (или значение в случае local) не видна до оператора, следующего после оператора, содержащего объявление. Поэтому можно копировать переменную так:

ту $х 二 $х;

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

Объявление лексической переменной с некоторым именем маскирует все ранее объявленные лексические переменные с таким же именем. При этом маскируются также неквалифицированные глобальные переменные с тем же именем, но к глобальной переменной, однако, всегда можно получить доступ, явно квалифицировав ее именем пакета, в котором она находится, например $PackageName: :varname.

Глобальные объявления с лексической областью видимости: our

Более правильным способом доступа к глобальным переменным, особенно из программ и модулей с объявлением use strict, является объявление our. Это объявление имеет лексическую область видимости, поскольку действует только до конца текущей области видимости. Но, в отличие от лексической области видимости ту или динамической области видимости local, our не изолирует ничего в текущей лексической или динамической области видимости. Напротив, оно обеспечивает доступ к глобальной переменной в текущем пакете, маскируя одноименные лексические переменные, которые, в противном случае, закрыли бы от вас эту глобальную переменную. В этом отношении переменные our действуют точно так же, как переменные ту.

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

sub check_wa「ehouse {

our @Current_Inventory;

my $widget;

foreach $widget (@Current_Inventory) {

print "Сегодня у меня на складе есть $widget.\n";

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

Повторные объявления оиг не имеют смысла вложенности. Каждое вложенное ту создает новую переменную, а каждое вложенное local создает новое значение. Но всякий раз, когда используется our, речь идет о той же самой глобальной переменной без учета вложенности. Если осуществляется присвоение переменной our, его результат сохраняет свое действие и после конца области видимости объявления. Дело в том, что оиг не создает значений; оно просто предоставляет ограниченную форму доступа к глобальной переменной, срок жизни которой не ограничен:

our $PROGRAM_NAME = "waiter";

{

our $PROGRAM一NAME = "server";

Вызываемый здесь код видит "server".

}

Выполняемый здесь код по-прежнему видит "server".

Сравните все это с тем, что происходит с ту или local, когда за пределами блока наружная переменная или значение снова становятся видимыми:

my $i = 10;

{

ту $i = 99;

}

Компилируемый здесь код видит наружную переменную, local $PROGRAM_NAME = "waiter";

{

local $PROGRAM_NAME 二"server";

Код, выполняемый здесь, видит "server".

}

Код, выполняемый здесь, снова видит "waiter".

Обычно имеет смысл делать только одно присваивание в объявлении оиг, вероятно, в самом верху программы или модуля, либо, реже, когда вы предваряете оиг собственным local:

{

local our @Current_Inventory 二 qw(bananas);

check_warehouse(); # нет, бананов у нас нет :-)

}

Переменные с динамической областью видимости: local

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

Если вы встречаете объявление local, которое выглядит так:

{

local $var = $newvalue;

some_func();

то можете представлять его себе исключительно в терминах присваиваний этапа выполнения:

{

$oldvalue = $var;

$var = $newvalue; some_func();

} continue { $var = $oldvalue;

}

Разница в том, что при использовании local значение восстанавливается независимо от того, каким образом происходит выход из блока, даже если это досрочный возврат из данной области видимости. Переменная остается все той же глобальной переменной, но обнаруживаемое в ней значение зависит от того, из какой области видимости вызвана функция. Вот почему эта область видимости называется динамической: она изменяется на этапе исполнения.

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

ПРЕДУПРЕЖДЕНИЕ: Изменения в этой динамической области видимости являются временными.

local $Some_Global = $Some_Global;

После этого глобальная переменная по-прежнему видна всюду в программе независимо от того, была ли она явно определена с помощью ои г или возникла из ничего, или содержит значение local, подлежащее отбрасыванию при выходе из области видимости. В маленьких программках это не столь плохо, но в больших программах вы быстро потеряете возможность отслеживать, где в коде применяются все эти глобальные переменные. При желании можно запретить случайное использование глобальных переменных с помощью директивы use strict ' vars', описываемой в следующем разделе.

Хотя и ту и local предоставляют некоторую степень защиты, в целом предпочтительнее использовать ту, а не local. Однако иногда применение local необходимо, чтобы временно изменить значение существующих глобальных переменных, например, перечисленных в главе 28 «Специальные имена». Лексическую область видимости могут иметь только буквенно-цифровые идентификаторы, а многие из этих специальных переменных не являются строго буквенно-цифровыми. Без local также не обойтись при осуществлении временных изменений в таблице имен пакета, как показано в разделе «Таблицы имен» главы 10 «Пакеты». Наконец, можно распространить действие local на один элемент или целый срез массива или хеша. Это допустимо, даже если массив или хеш являются лексической переменной, при этом режим динамической области видимости local накладывается поверх этих лексических переменных. Мы не станем здесь больше распространяться о семантике local. Дополнительные сведения можно получить из описания local в главе 29 «Функции».

Прагмы

Многие языки программирования позволяют давать компилятору советы. В Perl эти советы сообщаются компилятору посредством прагмы (директивы) use. Вот некоторые из них:

use warnings;

use strict;

use integer;

use bytes;

use constant pi => ( 4 * atan2(1,1));

Все прагмы Perl описаны в главе 31 «Модули прагм», но сейчас мы отдельно поговорим о некоторых из них, особенно полезных в связи с материалом, излагаемым в данной главе.

Хотя некоторые директивы представляют из себя глобальные объявления, воздействующие на глобальные переменные в текущем пакете, в большинстве своем это объявления с лексической областью видимости, действие которых продолжается только до конца охватывающего блока, файла или eval (в зависимости от того, что встретится раньше). Директива с лексической областью видимости может быть отменена во внутренней области видимости с помощью объявления по, которая действует как use, но противоположным образом.

Управление выводом предупредительных сообщений

Чтобы показать, как это работает, мы поработаем с директивой warnings, указывая Perl, нужно ли выводить предупредительные сообщения по поводу сомнительных приемов программирования:

use warnings; # Включить вывод предупреждений отсюда и до конца файла.

{

no warnings; # Отключить вывод предупреждений до конца блока.

}

Здесь вывод предупреждений автоматически снова активизируется.

Когда вывод предупредительных сообщений включен, Perl сообщает о переменных, используемых только один раз, объявлениях переменных, маскирующих другие объявления в той же области видимости, недопустимых преобразованиях строк в числа, использовании неопределенных значений в качестве законных строк или чисел, попытках записи в файлы, открытые только для чтения (или вообще не открытые), и многих других ситуациях, описанных в главе 33 «Диагностические сообщения».

Прагма use warnings является предпочтительным способом управления выводом предупредительных сообщений. В старых программах можно было только использовать ключ командной строки -w или изменять глобальную переменную $』：

{ local $』二 0;

}

Гораздо лучше применять директивы use warnings и no warnings. Лучше, потому что это происходит на этапе компиляции, представляет собой лексическое объявление и, следовательно, не может влиять на код, на который не должно влиять, и потому (хотя мы не показали этого в наших простых примерах), что позволяет тонко управлять отдельными классами сообщений. Дополнительные сведения о директиве warnings, включая и то, как преобра-

зовать просто надоедливые сообщения в фатальные ошибки, и как переопределить директиву, чтобы включить глобальный вывод предупредительных сообщений, даже если модуль требует обратного, можно найти в описании use warnings в главе 31 «Модули прагм».

Управление использованием глобальных переменных

Еще одно часто встречающееся объявление - это прагма use strict, выполняющая несколько функций, одной из которых является управление использованием глобальных переменных. Обычно Perl позволяет создавать новые переменные (а нередко и «затаптывать» старые) путем простого их упоминания. Никаких объявлений переменных не требуется 一 имеется в виду по умолчанию. Поскольку бесконтрольное применение глобальных переменных может сделать мучительным сопровождение больших программ и модулей, иногда желательно воспрепятствовать случайному их использованию. Чтобы содействовать предотвращению таких несчастных случаев, можно сказать:

use strict 'vars';

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

Это одна из специальных переменных Perl, действующих всюду в программе (см. главу 28 «Специальные имена»).

Она полностью квалифицирована именем своего пакета (см. главу 10 «Пакеты»).

Она импортирована в текущий пакет (см. главу 11 «Модули»).

Она маскирует переменную с лексической областью видимости посредством объявления our. (Это основная причина, по которой мы ввели в Perl объявления our.)

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

no strict 'vars'

С помощью этой директивы можно также включить строгую проверку символического разыменования и случайного использования простых слов. Обычно просто говорят:

use strict;

чтобы включить все три ограничения. Дополнительные сведения можно найти в описании use strict в главе 31 «Модули прагм».

5

Поиск по шаблону

Встроенная в Perl поддержка поиска по шаблону обеспечивает удобный и эффективный поиск в больших объемах данных. Perl превосходно подойдет тем, кто управляет большим коммерческим порталом в Сети и просматривает все поступающие новости в поисках интересных данных, правительственным организациям, занимающимся анализом демографических данных (или генома человека), или тем, кто работает в образовательных учреждениях и пытается организовать представление каких-то динамических данных на своем веб-сайте, отчасти благодаря его возможностям работы с базами данных, но в большей степени благодаря возможностям поиска по шаблону. Если рассматривать «текст» в самом широком смысле этого слова, то, вероятно, 90% всего, что мы делаем, на 90% состоит из обработки текста. Это действительно та область, на которую нацелен Perl, и всегда был нацелен; эта цель даже присутствует в самом названии Perl: Practical Extraction and Report Language - практический язык извлечения данных и генерации отчетов. Шаблоны Perl предоставляют мощный способ просмотра гор простых данных и извлечения из них полезной информации.

Шаблон задается путем создания регулярного выражения (regular expression или regex). Машина регулярных выражений Perl («Engine») берет это выражение и определяет, соответствует ли этот шаблон (и каким образом) вашим данным. Хотя большая часть данных представляет собой, вероятно, текстовые строки, ничто не мешает применять регулярные выражения для поиска и замены в любых последовательностях байт, даже если обычно мы рассматриваем их как «двоичные» данные. Для Perl байты - это просто символы,

порядковые значения которых оказались меньшими 256. (Подробнее об этом см. главу 15 «Unicode».)

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

match( $строка, $шаблон );

subst( $строка, $шаблон, $замена );

Но поиск и подстановка являются в Perl такими фундаментальными задачами, что заслужили для себя однобуквенные операторы: с/PATTERN/ (/шаблон/) и s/PATTERN/REPLACEMENT/ (/шаблон/замена/), для краткости - m// и s///. Они не только имеют краткий синтаксис, но и анализируются не как обычные операторы, а как строки в двойных кавычках; тем не менее, они действуют как операторы, и так мы и будем их называть. На протяжении всей этой главы рассматривается применение этих операторов для поиска шаблонов в строке. Если какая-то часть строки согласуется с шаблоном, то мы будем говорить, что поиск успешен. Если поиск успешен, то можно выполнить массу мощных операций. В частности, в случае применения s/// успешный поиск приводит к замене обнаруженной части строки тем, что было задано в качестве REPLACEMENT.

Вся эта глава посвящена построению и использованию шаблонов. Регулярные выражения Perl представляют собой мощной средство, позволяющее уместить много смысла в малом объеме. Поэтому они могут выглядеть устрашающе для того, кто попытается догадаться, что же в целом делает некий длинный шаблон. Но если суметь разбить его на части и знать, как машина эти части интерпретирует, то можно понять действие любого регулярного выражения. Нередко можно видеть, как сотня строк программы на С или Java выражается на Perl регулярным выражением, состоящим из одной строки. Понять это регулярное выражение может оказаться несколько труднее, чем каждую отдельную строку длинной программы, но, с другой стороны, регулярное выражение, возможно, будет значительно легче понять, чем длинную программу в целом. Просто имейте такие вещи в виду.

Бестиарий регулярных выражений

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

несколько символов выстроены подряд, они должны быть найдены, как и можно ожидать, в указанном порядке. Поэтому, если записать шаблон для поиска:

/Frodo/

то можно быть уверенным, что поиск будет успешным, только если строка содержит в каком-то месте подстроку "Frodo". (Подстрока является просто частью строки.) Соответствие может находиться в любом месте строки, если только в нем рядом расположены эти пять символов в указанном порядке.

Другие символы не соответствуют самим себе, а некоторым образом «неправильно» ведут себя. Мы называем их метасимволами. (Все метасимволы ведут себя неправильно сами, но некоторые из них настолько дурны, что «заражают» плохим поведением и соседние символы.)

Вот эти негодяи:

\ I ()［「$* + ? •

Метасимволы на практике очень полезны и имеют в шаблонах особое значение; по ходу дела мы об этих значениях расскажем. Но хотим уверить читателя, что всегда можно осуществить поиск этих символов литерально, помещая перед ними обратную косую черту (обратный слэш). Например, обратная косая черта сама является метасимволом, поэтому для буквального поиска обратной косой черты нужно поместить обратную косую черту перед ней самой: \\.

Как видите, обратный слэш 一 это один из тех символов, которые провоцируют неправильное поведение других символов. Результатом того, что мы заставляем плохо себя вести плохо ведущий себя метасимвол, является его хорошее поведение - как если бы это было двойное отрицание. Поэтому помещение обратной косой черты перед символом для того, чтобы он воспринимался литерально, действует, но только на символы пунктуации; обратная косая черта перед (обычно хорошо воспитанным) буквенно-цифровым символом производит противоположный эффект: она превращает буквальный символ в нечто особое. Встретив такие двухсимвольные последовательности:

\b \D \t \3 \s

необходимо знать, что эта последовательность является метасимволом, соответствующим чему-то необычному. Например, \Ь соответствует границе слова, a \t - обычному символу табуляции. Обратите внимание, что табуляция имеет размер в один символ, тогда как граница слова имеет ширину ноль символов, поскольку это место между двумя символами. Поэтому мы называем \Ь утверждением нулевой ширины (zero-width assertion). Тем не менее, \t и \Ь схожи в том, что оба утверждают нечто о конкретном месте в строке. Утверждая что-либо в регулярном выражении, мы просто требуем, чтобы это нечто было истинным при соответствии шаблону.

Большинство участков регулярного выражения представляют собой утверждения того или иного вида, при этом обычные символы просто утверждают, что они соответствуют самим себе. Если быть точным, то они утверждают также, что нечто следующее будет иметь соответствие на один символ дальше в строке, поэтому мы и говорим, что символ табуляции «имеет ширину в один символ». Некоторые утверждения (такие, как \t) «съедают» в случае своего соответствия часть строки, в то время как другие (такие, как \Ь) не делают этого. Но обычно мы используем термин «утверждение» только для утверждений нулевой ширины. Чтобы избежать путаницы, мы будем называть нечто, обладающее шириной, атомом. (Если вы физик, можете представлять себе атомы с ненулевой шириной как имеющие массу, в противоположность утверждениям нулевой ширины, которые не имеют массы, как фотоны.)

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

Один из таких структурирующих символов - вертикальная черта, обозначающая чередование (alternation):

/Frodo|Pippin|Merry|Sam/

Это означает, что нахождение любой из этих строк делает поиск успешным; об этом рассказывается в разделе «Чередование» далее в этой главе. А в следующем за ним разделе «Захват и кластеризация» мы покажем, как осуществлять группирование путем заключения частей шаблона в круглые скобки:

/(Frodo|Drogo|Bilbo) Baggins/

или даже:

/(Frod|Drog|Bilb)o Baggins/

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

* + ? *? {3} {2,5}

Однако в такой изоляции вы их не увидите. Квантификаторы имеют смысл только тогда, когда прикреплены к атомам, т. е. утверждениям, имеющим ширину.1 Квантификаторы прикрепляются только к предшествующему атому; на человеческом языке это означает, что обычно они указывают количество повторений только одного символа. Для того чтобы найти три экземпляра "bar" подряд, нужно сгруппировать отдельные символы "bar" в одной «молекуле» с помощью скобок, вот так:

/(Ьаг){3}/

Это будет соответствовать строке "barbarbar". Если бы вы сказали /Ьаг{3}/, это соответствовало бы "barer". Подробнее о квантификаторах см. далее раздел « Квантификаторы ».

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

Операторы поиска по шаблону

Рассуждая в терминах зоосада, можно сказать, что операторы Perl поиска по шаблону действуют как своего рода клетки для регулярных выражений, из которых последние не должны выбраться. Дело в том, что если выпустить зверюшек из семейства регулярных выражений на просторы языка, Perl может превратиться в настоящие джунгли. Конечно, миру нужны джунгли - в конце концов, они поддерживают биологическое многообразие - но джунгли должны находиться там, где им положено. Аналогично, несмотря на то что они являются двигателем комбинаторного многообразия, регулярные выражения должны оставаться внутри операторов поиска по шаблону, где их место. Там находятся джунгли.

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

волы, обозначаемые с помощью обратной косой черты. (См. раздел «Специальные символы» далее в этой главе.) Они применяются раньше, чем строка интерпретируется как регулярное выражение. (Это один из немногочисленных случаев в Perl, когда строка обрабатывается более чем за один проход.) Первый проход представляет собой не совсем обычную интерполяцию строки в двойных кавычках, поскольку известно, что на нем должно интерполироваться и что должно быть передано анализатору регулярных выражений. Поэтому, например, символ $, сразу за которым следует вертикальная черта, закрывающая круглая скобка или конец строки, будет обрабатываться не как интерполяция переменной, а как обычное утверждение регулярного выражения, означающее конец строки. Поэтому, если сказать:

$foo = "bar";

/$foo$/;

то на проходе интерполяции в двойных кавычках известно, что эти два символа $ действуют по-разному. Поэтому производится интерполяция $foo, а затем анализатору регулярных выражений передается следующее:

/Ьаг$/;

Другим следствием этого двухпроходного анализа является то, что обычный анализатор лексем Perl сначала находит конец регулярного выражения, совсем как если бы он искал завершающий ограничитель для обычной строки. Только после того, как найден конец строки (и завершена интерполяция всех переменных), шаблон рассматривается как регулярное выражение. Помимо всего прочего это означает, что нельзя «скрыть» завершающий ограничитель внутри конструкции регулярного выражения (такой как класс символов или комментарий в регулярном выражении, о которых мы еще расскажем). Perl увидит ограничитель, где бы он ни был, и закончит шаблон в этом месте.

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

Оператор транслитерации tr/// не осуществляет интерполяцию переменных, он даже не использует регулярные выражения! (На самом деле ему, возможно, вообще не место в этой главе, но лучшего для него мы не нашли.) Однако у него есть одна общая черта с т// и s///: он выполняет привязку к переменным с помощью операторов =~ и !".

Операторы 二~ и !", описанные в главе 3 «Унарные и бинарные операторы», привязывают скалярное выражение из своей левой части к одному из трех

операторов типа кавычек, находящихся в их правой части: т// для поиска по шаблону, s/// для подстановки некоторой строки вместо подстроки, отыскиваемой по шаблону, и tr/// (или его синоним - у///) для транслитерации (замены) одного набора символа другим. (Можно также записывать т// как //, без т, если в качестве ограничителя выступает косая черта.) Если в правой части =~ или ! ~ находится нечто отличное от этих трех операторов, оно все равно рассматривается как операция поиска т//, но при этом не остается места для каких-либо замыкающих модификаторов (см. далее раздел «Модификаторы шаблонов»), и вам придется обрабатывать свои собственные кавычки:

print "соответствует" if $somestring =~ $somepattern;

На самом деле нет оснований, чтобы не написать это явно:

print "соответствует" if $somestring =~ m/$somepattern/;

При использовании в операции поиска =~ и ! ~ иногда читаются, как «подходит» (matches) и «не подходит», соответственно (хотя «содержит» и «не содержит» способствовали бы меньшей путанице).

Кроме операторов - т// и s/// - регулярные выражения появляются в Perl еще в двух местах. Первый аргумент функции split представляет собой особый оператор поиска, определяющий, что не должно возвращаться при разбиении строки на несколько подстрок. См. описание и примеры применения split в главе 29 «Функции». Оператор qr// («quote regex» - заключить в кавычки регулярное выражение) тоже задает шаблон посредством регулярного выражения, но он не пытается ничего найти (в отличие от т//, который пытается). Вместо этого он возвращает скомпилированную форму регулярного выражения, которую можно будет использовать в дальнейшем. Дополнительные сведения можно найти в разделе «Интерполяция переменных» данной главы.

Один из операторов m//, s/// или tr/// может быть применен к конкретной строке с помощью оператора привязки (который, в сущности, является не оператором, а некоторым «тематизатором», рассуждая в терминах лингвистики). Вот несколько примеров:

поиск по простому шаблонуто жеполезная для здоровья заменапростое (для раскрытия)шифрованиепоиск по простому шаблонуто жеполезная для здоровья заменапростое (для раскрытия)шифрованиеShaystack =~ m/needle/

поиск по простому шаблону

то же

полезная для здоровья замена

простое (для раскрытия)

шифрование

поиск по простому шаблону

то же

полезная для здоровья замена

простое (для раскрытия)

шифрование

$haystack /needle/

$italiano =~ s/butter/olive oil/

$rotate13 =~ tr/a-zA-Z/n-za-mN-ZA-M/

В отсутствие оператора привязки в качестве «темы» неявным образом используется $_:

/new life/ and# искать в $_ и (если найдена)

/new civilizations/ # смело снова искать в $_

s/sugar/aspartame/# заменить на заменитель в $_

tr/ATCG/TAGC/# дополнить нить ДНК в $_

Поскольку s/// и tr/// модифицируют скаляры, к которым применяются, их можно использовать только с допустимыми левыми значениями:

"onshore" =~ s/on/off/; # НЕВЕРНО: ошибка этапа компиляции

Однако т// работает с результатом любого скалярного выражения:

if ((1с $magic_hat->fetch_contents->as_string) =~ /rabbit/) { print "Эй, что тут происходит?\п";

}

else { print "Фокус не удался!\п";

}

Но следует проявлять некоторую осторожность, поскольку =~ и ! ~ имеют достаточно высокий приоритет: в нашем предшествующем примере необходимо заключить левый терм в круглые скобки. Оператор привязки ! ~ действует подобно =~, но отрицает логический результат операции:

if ($song !~ /words/) { print qq/Похоже, 4To"$song" является песней без слов.\n/;

}

Поскольку m//, s/// и tr/// являются операторами кавычек, мы можем выбрать собственные ограничители. Они действуют так же, как операторы кавычек q//, qq//, qr// и qw// (см. раздел «Выберите собственные кавычки» в главе 2 «Всякая всячина»).

$path =~ s#/tmp#/var/tmp/scratch#;

if ($dir =~ m[/bin]) { print "Пожалуйста, без каталогов с двоичными модулями.\п";

}

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

s(egg)<larva>;

s{larva}{pupa};

s[pupa]/imago/;

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

s (egg) <larva>;

s {larva} {pupa};

s [pupa] /imago/;

Всякий раз, когда поиск по шаблону оказывается успешным (в том числе при замене по шаблону), переменные $', $& и $' устанавливаются равными тексту слева от найденного соответствия, всему соответствию и тексту справа от соответствия. Это удобно для разделения строк на части:

"hot cross buns" =~ /cross/;print "Найдено: <$'> $& <$'>\n";print "Слева:<$'>\n";print "Соответствие: <$&>\n";print "Справа:<$'>\n";"hot cross buns" =~ /cross/;print "Найдено: <$'> $& <$'>\n";print "Слева:<$'>\n";print "Соответствие: <$&>\n";print "Справа:<$'>\n";# Найдено: <hot > cross < buns>Слева:<hot >Соответствие: <cross>Справа:< buns># Найдено: <hot > cross < buns>Слева:<hot >Соответствие: <cross>Справа:< buns>

"hot cross buns" =~ /cross/;

print "Найдено: <$'> $& <$'>\n";

print "Слева:<$'>\n";

print "Соответствие: <$&>\n";

print "Справа:<$'>\n";

"hot cross buns" =~ /cross/;

print "Найдено: <$'> $& <$'>\n";

print "Слева:<$'>\n";

print "Соответствие: <$&>\n";

print "Справа:<$'>\n";

# Найдено: <hot > cross < buns>

Слева:<hot >

Соответствие: <cross>

Справа:< buns>

# Найдено: <hot > cross < buns>

Слева:<hot >

Соответствие: <cross>

Справа:< buns>

Детализацию и эффективность можно увеличить при помощи скобок, позволяющих захватывать отдельные участки того, что требуется сохранить. Каждая пара круглых скобок захватывает подстроку, соответствующую подшаблону, заключенному в эти скобки. Пары скобок нумеруются слева направо в соответствии с позицией левых скобок; подстроки, соответствующие этим субшаблонам, после нахождения соответствия доступны как пронумерованные переменные $1, $2, $3 и т. д.:

$_ = "Бильбо Бэггинс родился 22 сентября";

/(.*) родился (.*)/;

print "Имя: $1\п";

print "Дата: $2\п";

$',$&,$' и нумерованные переменные являются глобальными переменными, неявно локализованными в охватывающей динамической области видимости. Их значение сохраняется до очередного успешного поиска по шаблону или конца текущей области видимости, смотря по тому, что произойдет раньше. Подробнее об этом потом, в другой области видимости.

Когда Perl видит, что где-то в программе нужна одна из переменных, $', $& или $ ', он создает их при каждом поиске по шаблону. Это несколько замедляет выполнение программы. Аналогичный механизм используется в Perl для создания переменных $1, $2 и т. д., поэтому приходится платить и за каждый шаблон, содержащий захватывающие скобки. (См. в разделе «Кластеризация», как избежать издержек захвата при сохранении режима группирования.) Но если ни разу не использовать $', $& или $', то шаблоны без захватывающих скобок штрафом не облагаются. Поэтому обычно лучше избегать применения $', $& и $', если есть такая возможность, особенно в библиотечных модулях. Но если вы хоть раз их использовали (а в некоторых алгоритмах это действительно удобно), то можете дальше уже не особенно

стесняться, поскольку за все заплачено. В последних версиях Perl переменная $& требует меньших расходов, чем две остальные.

Модификаторы шаблонов

Мы обсудим отдельные операторы поиска по шаблону буквально через мгновение, но сначала хотелось бы сказать еще об одном, общем для них: модификаторах.

Сразу за последним ограничителем оператора m//, s///, qr// или tr/// можно поместить один или несколько необязательных модификаторов, в любом порядке. Для большей ясности модификаторы обычно пишутся как «модификатор /о» и читаются «модификатор слэш о», даже если конечный ограничитель отличен от слэша (косой черты). (Иногда говорят «флаг» или «опция», имея в виду «модификатор»; это тоже нормально.)

Некоторые модификаторы изменяют режим действия отдельного оператора, подробно мы опишем их позже. Другие изменяют то, как интерпретируется регулярное выражение, и мы поговорим о них сейчас. Операторы m//, s/// и qr//1 - все принимают следующие модификаторы после своего конечного ограничителя:

Модификатор

Значение

/i

Игнорировать различия в регистре

/s

Разрешить . устанавливать соответствие переводу строки и игнорировать устаревшую переменную $*

加

Разрешить и $ устанавливать соответствие рядом со встроенным \п

/х

Игнорировать (почти все) пробельные символы и разрешить в шаблоне комментарии

/о

Компилировать шаблон только один раз

Модификатор /i указывает на необходимость поиска в верхнем и нижнем регистрах (и в заглавном регистре 《title» в Unicode). Например, /perl/i найдет соответствие в строках "PROPERLY" и "Perlaceous" (среди прочих). Прагма use locale также может повлиять на критерий эквивалентнсти. (Ее влияние может оказаться пагубным, если строки содержат Unicode.)

Модификаторы /s и /т не делают ничего оригинального. Они влияют на способ, которым Perl осуществляет поиск в строке, содержащей символы перевода строки. Но они относятся не к определению наличия символа \п в анализируемой строке, а к тому, должен ли Perl допускать, что последовательность символов содержит одну строку (/s) или несколько (/т), т. к. некоторые метасимволы по-разному действуют в зависимости от того, предполагается ли их использование в режиме, ориентированном на строки, или нет.

Обычно метасимвол "." соответствует любому символу, кроме символа перевода строки, потому что традиционно он предназначается для поиска символов в строчке (line). Однако при наличии модификатора /s метасимвол "." может соответствовать и символу перевода строки, поскольку этот модификатор сообщает Perl о необходимости игнорировать то обстоятельство, что строка (string) может содержать символы перевода строки. (Модификатор /s также заставляет Perl игнорировать устаревшую переменную $*, которую, надеемся, вы тоже игнорируете.) Напротив, модификатор /т изменяет интерпретацию метасимволов 八 и $, позволяя им устанавливать соответствие рядом с символами перевода строки внутри нее, а не только по концам строки. Примеры см. в разделе «Позиции» далее в этой главе.

Модификатор /о управляет перекомпиляцией шаблона. Если только в качестве разделителей не выбраны одинарные кавычки (т' PATTERN', s' PATTERN' REPLACEMENT' или qr' PATTERN) то все переменные в шаблоне будут интерполироваться (что может повлечь повторную компиляцию шаблона) при каждом вычислении оператора шаблона. Для того чтобы этот шаблон компилировался один и только один раз, используйте модификатор /о. Это позволяет избежать дорогостоящей рекомпиляции на этапе исполнения. Однако указание /о содержит в себе обещание, что мы не будем изменять переменные, входящие в шаблон. Если же их все-таки изменить, Perl не обратит на это никакого внимания. Лучшее управление рекомпиляцией достигается при использовании оператора кавычек qr//. Подробности см. далее в этой главе в разделе «Интерполяция переменных».

Модификатор /х является ззспрессивным: он позволяет э^cплyaтиpoвaть пробельные символы и пояснительные комментарии в целях улучшения понятности вашего шаблона и даже экспансии шаблона через границы символов перевода строки.

Это означает, что /х изменяет значение пробельных символов (и символа #): вместо того чтобы при поиске «притвориться» обычными символами, они превращаются в метасимволы, которые, как ни странно, ведут себя в результате так, как и должны пробельные символы (и символ комментария). Следовательно, благодаря /х пробелы, символы табуляции и перевода строки используются для форматирования, как в обычном коде Perl. Также благодаря этому модификатору за символом #, обычно не являющимся в шаблоне каким-либо особенным, можно размещать комментарии, продолжающиеся до конца текущей строчки (line) в строке (string) шаблона.1 Если действительно требуется найти пробельный символ (или символ #), придется поместить его в класс символов либо поставить перед ним обратную косую черту, либо записать его в восьмеричном или шестнадцатеричном коде. (Но обычно поиск пробельных символов осуществляется с помощью последовательностей \s* или \s+, поэтому на практике такая ситуация возникает редко.)

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

m/\w+:(\s+\w+)\s*\d+/;# Слово, двоеточие, пробел, слово, пробел, цифры.

m/\w+: (\s+ \w+) \s* \d+/x; # Слово, двоеточие, пробел, слово, пробел, цифры.

т{

\w+:

# Найти слово и двоеточие.

\s+# Найти один или несколько пробелов.

\w+# Найти еще одно слово.

\s* \d+

# (конец группы)

# Найти ноль или несколько пробелов.

# Найти несколько цифр

}х;

Эти новые метасимволы мы объясним далее в этой главе. (Данный раздел должен был рассказывать о модификаторах шаблонов, но, впав в экстаз по поводу /х, мы не смогли удержаться в заданных рамках.) Вот регулярное выражение, отыскивающее повторяющиеся слова в абзацах и украденное прямо из «Perl. Библиотека программиста». В нем используются модификаторы /х и /1, а также модификатор /д, который будет описан ниже.

Найти в абзацах повторяющиеся слова, возможно, пересекая границы строчек.

Применяется /х для пробелов и комментариев, /i для поиска обоих 'is'

в "Is is this ok?", и /g для поиска всех дубликатов.

$/ = "";# режим "paragrep"

while (о) {

while

(m{

\b# начать с границы слова

(\w\S+)# найти похожий на слово фрагмент,

(

\s+#отделенный каким-нибудь пробелом,

\1#и еще раз этот же фрагмент.

)+#Повторять, сколько возможно,

\Ь#до следующей границы слова

}xig

)

print "повтор слова '$1' в абзаце $.\п”； }

}

Если применить этот код к данной главе, можно получить что-то вроде:

повтор слова 'THE' в абзаце 100

В данном случае мы знаем, что это повторение является преднамеренным.

Оператор т// (поиск)

EXPR =~ т/PATTERN/GQimQSX

EXPR =~ /PATTERN/cgimosx

EXPR =~ ?PATTERN?cgieusx

m/PATTERN/c^imQSx

/PATTERN/cgimusx

?PATTERN?cgimosx

Оператор m// ищет строку в скаляре EXPR, соответствующую шаблону PATTERN. Если ограничителем служит символ / или ?, то присутствие начальной m не обязательно. Символы ? и ' имеют специальное значение в случае применения в качестве ограничителя: первый служит для однократного поиска, второй подавляет интерполяцию переменных и шесть езсаре-последовательнос- тей трансляции (\U и тому подобных, описываемых ниже).

Если значением PATTERN окажется нулевая строка (потому ли, что вы так задали его с помощью //, потому ли, что интерполируемая переменная дала значение в виде пустой строки), то для поиска используется последнее успешно выполненное регулярное выражение, не скрытое во внутреннем блоке (или в split, g rep или map).

В скалярном контексте оператор возвращает в случае успешного выполнения значение «истина» (1), а в противном случае значение «ложь» ( ). В булевом контексте обычно можно видеть такую форму:

if ($shire =~ m/Baggins/){ ... } #искатьBagginsв $shire

if ($shire =~ /Baggins/){ ... } #искатьBagginsв $shire

if ( m#Baggins# ){...}#искатьпрямо в$_

if ( /Baggins/ ){...}#искатьпрямо в$_

В списковом контексте т// возвращает список подстрок, соответствующих захватывающим скобкам в шаблоне (т. е. $1, $2, $3 и т. д.), как описывается далее, в разделе «Захват и кластеризация» данной главы. Нумерованным переменным по-прежнему присваиваются значения, даже если возвращается список. Если поиск в списковом контексте оказывается безуспешным, возвращается нулевой список. А если успешен, но скобок захвата в шаблоне нет (как и модификатора /д), возвращается список со значением (1). Поскольку при неудаче поиска возвращается нулевой список, этот формат т// можно применять в булевом контексте, но только в косвенном виде через присвоение списку:

if (($key,$value) = /(\w+): (.*)/){... }

Допустимые для m// (в любом его обличье) модификаторы показаны в табл. 5.1.

Таблица 5.1. Модификаторы т//

Модификатор

Значение

/i

Игнорировать различия в регистре

/т

Разрешить ° и $ устанавливать соответствие рядом со встроенным \п

/s

Разрешить . устанавливать соответствие переводу строки и игнорировать устаревшую переменную $*

/х

Игнорировать (почти все) пробельные символы и разрешить в шаблоне комментарии

/о

Компилировать шаблон только один раз

/д

Глобальный поиск всех соответствий

/сд

Разрешить продолжение поиска после неудачи поиска /д

Первые пять модификаторов относятся к регулярному выражению и были описаны выше. Последние два меняют режим работы самого оператора поиска. Модификатор /д задает глобальный поиск, т. е. поиск всех соответствий шаблона в строке. Однако его действие зависит от контекста. В списковом контексте m//g возвращает список всех найденных соответствий. Найдем, например, все места, где упоминается "perl", "Perl", "PERL" и т. д.:

if (@perls 二 Sparagraph =~ /perl/gi) { printf "Perl упомянут %d раз.\n", scalar @perls; }

Если в шаблоне с /д нет захватывающих скобок, возвращаются полные соответствия. Если скобки есть, возвращаются только захваченные строки. Пусть имеется такая строка:

$string 二"password=xyzzy ve「bose=9 score=0";

Пусть также требуется использовать ее для такой инициализации хеша:

%hash = (password => "xyzzy", verbose 二〉9, score => 0);

Кроме того, конечно, у вас есть не список, а строка. Чтобы получить соответствующий список, можно применить оператор m//g в списковом контексте и захватить все пары ключ/значение, имеющиеся в строке:

%hash 二 $string =~ /(\w+)=(\w+)/g;

Последовательность (\w+) захватывает слово из алфавитно-цифровых символов. См. раздел «Захват и кластеризация» далее в этой главе.

В скалярном контексте модификатор /д задает поступательный поиск, что заставляет Perl искать следующее соответствие для той же переменной, начиная с позиции, следующей сразу за последним найденным соответствием. Утверждение \G представляет эту позицию в строке (см. описание \G ниже в этой главе в разделе «Позиции»). Если в дополнение к /д указан модифи-

катор /с («continue»), то когда /д заканчивает работу, последний неудачный поиск не сбрасывает указатель позиции.

Если в качестве ограничителя выступает ?, как в ?PATTERN?, то поиск выполняется, как обычный /PATTERN/, но при этом мы ищем только одно соответствие между вызовами оператора reset. Такой прием может дать удобный способ оптимизации, если во время прогона программы требуется найти не все соответствия шаблону, а только первое. Оператор осуществляет поиск при каждом вызове, пока, наконец, что-нибудь не найдет, после чего выключается и будет возвращать «ложь», пока не будет явно включен снова с помощью reset. Работу по отслеживанию состояния поиска Perl берет на себя.

Оператор ?? полезнее всего тогда, когда обычный поиск по шаблону ищет последнее, а не первое вхождение:

open DICT, "/usr/dict/words" or die "Невозможно открыть words: $!\n";

while (<DICT>) {

$first 二 $1 if ?(/'neur. *)?;

$last = $1 if /(^neur.*)/;

}

print $first,"\n";# выводит "neurad"

print Blast,"\n";# выводит "neurypnology"

Оператор reset сбрасывает только экземпляры ??, скомпилированные в том же пакете, что и вызов reset. Высказывание т?? эквивалентно высказыванию ??.

Оператор s/// (подстановка)

LVALUE =~ s/PATTERN/REPLACEMENT/e^imosx

s/PATTERN/REPLACEMENT/eQlmos\

Этот оператор ищет в строке шаблон PATTERN и, если он найден, заменяет найденную подстроку текстом REPLACEMENT. (Модификаторы описываются ниже.)

$lotr = $hobbit;# Просто копируем Хоббита

$lotr =~ s/Bilbo/Frodo/g; # и легко пишем продолжение.

Значение, возвращаемое оператором s/// (одинаковое в скалярном и списковом контекстах), равно количеству успешных выполнений (оно может быть больше одного при использовании модификатора /д, описанного выше). При неуспехе, поскольку количество замен равно нулю, он возвращает значение «ложь» ( ), численный эквивалент 0.

if ($lotr =~ s/Bilbo/Frodo/) { print "Продолжение успешно написано." } $change_count 二 $lotr =~ s/Bilbo/Frodo/g;

Часть оператора, определяющая заменяющий текст, рассматривается как строка в двойных кавычках. В строке замены можно использовать любые из описанных выше переменных шаблонов с динамической областью видимости ($',$&,$', $1, $2 ит. д.)и любые другие связанные с двойными кавычками

приемы, которые вам заблагорассудится применить. Вот, например, как найти все строки "revision", "version", "release" и заменить каждую из них эквивалентом из заглавных букв с помощью управляющего символа \и в заменяющей части:

s/revision|version|release/\u$&/g； # Используйте | для обозначения "или" в шаблоне

В контексте двойных кавычек разыменовываются все скалярные переменные, а не только эти необычные. Допустим, у нас есть хеш %Names, содержащий соответствие номеров версий внутренним названиям проектов; например, $Names{"3.0"} содержит кодовое имя "Isengard". Можно с помощью s/// найти номера версий и заменить их соответствующими названиями проектов:

s/version ([0-9.]+)/the $Names{$1} release/g;

В строке замены $1 возвращает то, что захватила первая (и единственная) пара скобок. (Можно также указать \1, как в шаблоне, но такое использование в замене считается предосудительным. В обычной строке, заключенной в двойные кавычки, \1 означает <Ctrl>+<A>.)

Если шаблон PATTERN представляет собой нулевую строку, то вместо него используется последнее успешно выполненное регулярное выражение. Интерполяция переменных происходит в обеих строках, PATTERN и REPLACEMENT, но PATTERN интерполируется всякий раз, когда оператор s/// выполняется в целом, a REPLACEMENT интерполируется каждый раз, когда шаблон найден. (PATTERN может находить несколько соответствий при одном выполнении, если указан модификатор /д.)

Как и выше, первые пять модификаторов в табл. 5.2 изменяют действие регулярного выражения; они те же, что в т// и qr//. Последние два изменяют сам оператор подстановки.

Таблица 52 Модификаторы s///

Модификатор

Значение

/i

Игнорировать различия в регистре (при поиске)

/т

Разрешить " и $ устанавливать соответствие рядом со встроенным \п

/s

Разрешить . устанавливать соответствие переводу строки и игнорировать устаревшую переменную $*

/х

Игнорировать (почти все) пробельные символы и разрешить в шаблоне комментарии

/0

Компилировать шаблон только один раз

/д

Глобальная замена, т. е. всех вхождений

/е

Вычислять правую часть как выражение

Модификатор /д используется с оператором /// для замены всех, а не только первого найденного, значений PATTERN значением REPLACEMENT. Оператор s///g действует как глобальный поиск и замена, производя сразу все изменения,

подобно списковому m//g, за исключением того, что m//g ничего не изменяет. (A s///g не является последовательным поиском, в отличие от скалярного m//g.)

Модификатор /е рассматривает REPLACEMENT как фрагмент кода Perl, а не как интерполируемую строку. Результат выполнения этого кода выступает в качестве заменяющей строки. Например, s/([0-9]+)/sprintf ("%#х", $1)/де преобразует все числа в шестнадцатеричные, заменяя, например, 2581 на 0хЬ23. Или, предположим, в нашем прежнем примере мы не уверены в наличии названий для всех версий, поэтому все остальные хотим оставить без изменений. Творчески применив форматирование /х, можно сказать:

s{

version

\s+ ( [0-9.]+

}{

$Names{$1}

? "the $Names{$1} release" :$&

}xge;

Правая часть s///e (или, в данной части, нижняя часть) проходит синтаксическую проверку и компилируется на этапе компиляции, как и остальная часть нашей программы. Синтаксические ошибки обнаруживаются во время компиляции, а исключительные ситуации времени исполнения не перехватываются. Каждый дополнительный /е после первого (например, /ее, /еее и т. д.) эквивалентен вызову eval STRING и его применению к результату выполнения кода, по одному для каждого лишнего /е. При этом вычисляется результат кодового выражения, а исключительные ситуации перехватываются в специальной переменной $@・ Дополнительные сведения есть в разделе «Программные шаблоны» далее в этой главе.

Модификация строк en passant

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

$lotr 二 $hobbit;

$lotr =~ s/Bilbo/Frodo/g;

можно объединить эти команды в одну. Порядок старшинства операторов требует, чтобы присвоение было заключено в круглые скобки, поскольку в большинстве случаев они применяют =~ к выражению.

($lotr 二 $hobbit) =~ s/Bilbo/Frodo/g;

В отсутствие скобок была бы изменена строка $hobbit, а в $lotr было бы записано количество сделанных замен, каковой результат не представил бы особого интереса.

Применять оператор s/// непосредственно к массиву нельзя. Для этого нужен цикл. По счастливому совпадению создание псевдонимов в for/foreach в сочетании с использованием $_ в качестве переменной цикла по умолчанию лежит в основе стандартной идиомы Perl для поиска и замены в каждом элементе массива:

for (©chapters) { s/Bilbo/Frodo/g } # Сделать замену в каждой главе s/Bilbo/Frodo/g for @chapters; # То же самое.

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

@oldhues 二('bluebird', 'bluegrass','bluefish', 'the blues');

for (@newhues 二 @oldhues) { s/blue/red/ } print "@newhues\n";# выводит: redbird redgrass redfish the reds

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

for ($string) {

s/c\s+//;# отбросить ведущие пробельные символы

s/\s+$//;# отбросить замыкающие пробельные символы

s/\s+/ /д;# сжать внутренние пробельные символы

}

что дает такой же результат, как и:

$string = join(" ", split " ", $string);

Можно также оранизовать такой же цикл с присваиванием, какой рассматривался в случае массива:

for ($newshow 二 $oldshow) {

s/Fred/Homer/g; s/Wilma/Marge/g; s/Pebbles/Lisa/g; s/Dino/Bart/g; }

Когда глобальная подстановка оказывается недостаточно глобальной

Иногда модификатора /д оказывается недостаточно для того, чтобы выполнить все необходимые изменения, т. к. или подстановка должна происходить справа налево, или нужно, чтобы длина $' изменялась между поисками. Обычно можно достичь желаемого, повторно вызывая s///. Однако нам нужно, чтобы цикл остановился, когда s/// окончательно окажется неуспешным, поэтому он должен быть помещен в условный оператор, и в основной части цикла не остается ничего для выполнения. Поэтому мы просто пишем 1, что довольно скучно, но иногда скука - это лучшее, на что можно рас-

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

расставить в нужных местах целого числа запятые

1 while s/(\d)(\d\d\d)(?!\d)/$1,$2/;

заменить табуляцию на пробелы по 8 в колонке

1 while s/\t+/' ' х (length($&)*8 - length($')%8)/e;

удалить (вложенные (даже глубоко вложенные (как это))) замечания

1 while s/\(厂()]*\)〃g;

удалить слова, повторяющиеся дважды (и трижды (и четырежды...))

1 while s/\b(\w+) \1\b/$1/gi;

В последнем случае требуется цикл, иначе:

Paris in THE THE THE THE spring.

будет превращено в:

Paris in THE THE spring.

что может вызвать перед глазами того, кто немного знает французский, образ Париса, сидящего в артезианском колодце с ледяным чаем, т. к. «the» по-французски - «чай». Парижанина, конечно, не обманешь.

Оператор tr/// (транслитерации)

LVALUE 二~ tг/SEARCHLIST/REPLACEMENTLIST/c^s t т/SEARCHL 工 ST/REPLACEMENTL 工 ST/cds

Для приверженцев sed предоставляется оператор у/// в качестве синонима tr///. По этой причине нельзя вызывать функции с именем у, как и функции с именами q или т. Во всех остальных отношениях у/// совпадает с tr///, и больше мы об этом говорить не будем.

Этот оператор может показаться не вписывающимся в главу о поиске по шаблону, поскольку он не использует шаблоны. Он просматривает строку символ за символом и заменяет каждый символ, оказывающийся в SEARCHLIST (это не регулярное выражение), на соответствующий символ из REPLACEMENTLIST (это не строка замены). Однако он несколько похож на т// и s///, и в нем даже можно применять операторы привязки =~ и ! ~, поэтому мы описываем его здесь. (Операторы qr// и split выполняют поиск по шаблону, но с ними не используются операторы привязки, поэтому они находятся в другом месте книги. Куда мы вас и отсылаем.)

Транслитерация возвращает число замененных или удаленных символов. Если строка не задана с помощью операторов =~ или ! ~, то изменения прово-

дятся в строке $_. В SEARCHLIST и REPLACEMENTLIST могут определяться диапазоны последовательных символов с помощью дефиса:

$message =~ tr/A-Za-z/N-ZA-Mn-za-m/; # rot13 шифрование.

Заметьте, что диапазон вроде A-Z предполагает линейный набор символов типа ASCII. Но в каждом наборе символов есть свои представления о том, как они упорядочены и, следовательно, о том, какие символы попадают в конкретный диапазон. Разумный принцип состоит в использовании только таких диапазонов, начало и конец которых находятся в алфавите одного регистра (а-е, А-Е) или являются цифрами (0-4). Ко всем остальным нужно относиться с подозрительностью. Если есть сомнения, приведите набор символов полностью: ABCDE.

В SEARCHLIST и REPLACEMENTLIST интерполяция переменных, как в строках в двойных кавычках, не производится; можно, однако, использовать последовательности с обратной косой чертой, соответствующие конкретным символам, например \п или \015.

В табл. 5.3 перечислены модификаторы, применимые к оператору tr///. Они совершенно отличны от тех, которые применяются к m//, s/// или q「//, даже если выглядят одинаково.

Таблица 5.3. Модификаторы tr///

Модификатор

Значение

/С

Дополнение к SEARCHLIST

/d

Удалить найденные, но не замененные символы

/s

Подавить повторяющиеся замененные символы

Если задан модификатор /с, осуществляется дополнение набора символов в SEARCHLIST; т. е. реальный список для поиска состоит из всех символов, отсутствующих в SEARCHLIST. В случае применения Unicode таких символов может оказаться много, но поскольку они хранятся логически, а не физически, можно не беспокоиться о том, что не хватит памяти.

Модификатор /d превращает tr/// в оператор «замены-удаления»: любые символы, указанные в SEARCHLIST, для которых не задана замена в REPLACEMENTLIST, удаляются. (Это дает несколько большую гибкость, чем в некоторых программах 力г(1), удаляющих все, что они находят в SEARCHLIST.)

Если задан модификатор /s, то последовательности символов, превращаемых в один и тот же символ, сжимаются до одного этого символа.

При использовании модификатора /d список HEPLACEMENTLIST всегда интерпретируется точно так, как он задан. Без него, когда REPLACEMENTLIST короче SEARCHLIST, последний символ копируется до достижения нужной длины. Если REPLACEMENTLIST представляет собой нулевую строку, в него копируется SEARCHLIST, что оказывается полезным, если требуется просто подсчитать символы, не заменяя их. Это полезно также для сжатия символов с ключом /s.

tr/aeiou/!/;

tr{/\\\r\nW. }{_};

tr/A-Z/a-z/ for @ARGV;

$count = ($para =~ tr/\n//);

$count = tr/0-9//;

$word =~ tr/a-zA-Z//s;

tr/@$%*//d;

tr#A-Za-zO-9+/##cd;

заменить все гласные на!

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

перевести в нижний регистр ASCII

подсчитать количество переводов строки в $рага

подсчитать цифры в $_

bookkeeper -> bokeper

удалить указанные

удалить символы не из base64

# изменить en passant

($HOST = $host) =~ tr/a-z/A-Z/;

Spathname =~ tr/a-zA-Z/_/cs; # заменить небуквы (ASCII) на подчеркивание

tr [\200-\377]

[\000-\177];# сбросить 8-й разряд

Если в SEARCHLIST один и тот же символ повторяется несколько раз, то используется только первый, поэтому команда

tr/AAA/XYZ/

поменяет все символы А на X (в $_).

Хотя переменные не интерполируются в tr///, того же эффекта можно добиться с помощью eval EXPR:

$count = eval "tr/$oldlist/$newlist/";

die if $@; # распространяет исключительную ситуацию при недопустимом содержании eval

Еще одно замечание: не используйте tr/// для перевода текста в верхний или нижний регистр. В этом случае следует предпочесть последовательности \U или \L в строках, заключенных в двойные кавычки (или эквивалентные функции ис и 1с), поскольку они учитывают национальные установки и Unicode, a tr/a-z/A-Z/ не учитывает. Кроме того, в строках Unicode последовательность \и и соответствующая ей функция ucfirst учитывают понятие «заглавного регистра» (titlecase), что в некоторых языках отличается от простого преобразования в верхний регистр.

Метасимволы и метазнаки

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

При всей своей мощи и выразительности шаблоны в Perl распознают те же 12 обычных метасимволов, которые имеются во многих других пакетах, поддерживающих регулярные выражения:

\ 丨()[「$* + ? •

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

Некоторые простые метасимволы (「$) действуют самостоятельно. Они не оказывают непосредственного влияния на соседние символы. Другие метасимволы действуют как префиксные операторы, управляя тем, что следует за ними, например \. Третьи действуют как постфиксные операторы, управляя тем, что непосредственно предшествует им, например, *, + и ?. Один метасимвол, I, действует как инфиксный оператор, располагаясь между управляемыми им операндами. Есть даже структурирующие метасимволы, действующие как охватывающие операторы, управляющие тем, что в них содержится, такие как (.. .) и [...], Особенно важны круглые скобки, поскольку они задают границы для | с внутренней стороны и для *, +, и ? с внешней.

Если запоминать только один из этих двенадцати метасимволов, нужно выбрать обратную косую черту. (Ну... еще круглые скобки.) Это связано с тем, что обратная косая черта отключает все остальные. Когда обратная косая черта предшествует в шаблоне символу, не являющемуся буквой или цифрой, она превращает этот символ в литерал. Если необходимо буквально найти по шаблону один из этих двенадцати метасимволов, то его нужно написать с обратной косой чертой впереди. Поэтому \. соответствует действительной точке, \$ 一 действительному знаку доллара, \\ - действительной обратной косой черте и т. д. Это называют «обходом» метасимвола («escaping», 《quoting» или «backslashing»). (Конечно, вы уже знаете, что обратная косая черта используется для подавления интерполяции переменных в строках, заключенных в двойные кавычки.)

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

Таблицы метазнаков

В последующих таблицах в колонке «Атомарный» указывается «да», если этот метазнак поддается количественному определению (может соответство-

вать чему-то, обладающему в какой-то мере шириной). Мы также применяли многоточие (...) для представления «чего-то еще». Пожалуйста, посмотрите следующее далее описание, чтобы выяснить, что означает ..., если это непонятно из однострочного объяснения в таблице.

В табл. 5.4 приведены основные обычные метазнаки. Первые четыре из них являются структурирующими, и о них говорилось выше, тогда как последние три - это просто метасимволы. Примером атома служит метасимвол ., поскольку он соответствует чему-то, имеющему ширину (в данном случае ширину символа); и $ представляют собой примеры утверждений, поскольку соответствуют чему-то, имеющему нулевую ширину, и вычисляются, только чтобы посмотреть, истинны они или нет.

Таблица 54 Общие метасимволы регулярных выражений

Символ Атомарный

Значение

\...По-разному

Сделать обычным следующий не буквенно-цифровой метасимвол и сделать метасимволом (может быть) следующий буквенно-цифровой символ

...|. . . Нет

(...)Да

[.••]Да

Чередование (соответствие одному или другому)

Группировка (рассматривать воедино)

Класс символов (соответствие одному символу из набора)

сНет

Истинно в начале строки (или, возможно, после любого символа перевода строки)

Да

Соответствие одному символу (обычно, кроме символа перевода строки)

$Нет

Истинно в конце строки (или, возможно, перед любым символом перевода строки)

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

Таблица 5.5. Квантификаторы регулярных выражений

Квантификатор Атомарный

Значение

*Нет

+Нет

?Нет

{COUNT}Нет

{MIN,}Нет

{MIN, МАХ}Нет

0 или более совпадений (максимальный)

1 или более совпадений (максимальный)

1 или 0 или более совпадений (максимальный)

Ровно COUNT совпадений

Не меньше MIN совпадений (максимальный)

Не меньше MIN совпадений, но не больше МАХ (максимальный)

*?Нет

0 или более совпадений (минимально)

Таблица 5,5 ( продолжение )

Квантификатор Атомарный

Значение

+?Нет

??Нет

{MIN、}?Нет

{MIN,МАХ}?Нет

1 или более совпадений (минимальный)

0 или 1 совпадений (минимальный)

Не меньше MIN совпадений (минимальный)

Не меньше MIN, но не больше МАХ совпадений (минимальный)

Минимальный квантификатор пытается найти как можно меньше символов в отпущенных ему пределах, максимальный - как можно больше. Например, .+ обеспечивает соответствие по крайней мере одному символу в строке, но будет соответствовать всем им, если дать возможность. Эти возможности описываются далее в разделе «Маленькая машинка, которая /(не) может?/» данной главы.

Заметьте, что квантификаторы нельзя квантифицировать.

Мы хотим обеспечить открытый синтаксис для новых типов метазнаков. Учитывая, что мы могли работать всего лишь с дюжиной метасимволов, мы выбрали для использования в произвольных синтаксических расширениях ранее недопустимую для регулярных выражений последовательность. Все эти метазнаки имеют вид (2KEY. ..); т. е. скобка (парная), за которой следует вопросительный знак, за которым следует KEY и оставшаяся часть подшаблона. Символ KEY указывает на конкретное расширение синтаксиса регулярных выражений. Полный их список приведен в табл. 5.6. Большинство из них является структурирующими, поскольку основываются на скобках, но у них есть и дополнительное значение. Квантифицироваться могут только атомы, поскольку они представляют нечто действительно существующее (потенциально).

Таблица 5.6. Расширенные последовательности регулярных выражений

Расширение

Атомарный

Значение

(?#...)

Нет

Отбросить комментарий

(?：...)

Да

Скобки только для кластера, без захвата

(?imsx-imsx)

Нет

Включить/отключить модификаторы шаблона

(?imsx-

Да

Скобки только для кластера плюс модификаторы

imsx:...)

(?=•••)

Нет

True, если выполняется утверждение после данной точки

(?!...)

Нет

True, если не выполняется утверждение после данной точки

(?<=...)

Нет

True, если выполняется утверждение перед данной точкой

(?<!...)

Нет

True, если не выполняется утверждение перед данной точкой

(?>...)

Да

Совпадение с подшаблоном без ссылки на найденный текст

Расширение

Атомарный

Значение

(?{...})

Нет

Выполнить встроенный код Perl

(??{...})

Да

Поиск регулярного выражения из встроенного кода Perl

(?(...)■•-I...)

Да

Поиск по шаблону if-then-else

(?(-..)...)

Да

Поиск по шаблону if-then

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

Таблица 5.7. Буквенно-цифровые метазнаки регулярных выражений

Символ

Атомарный

Значение

\о

Да

Совпадение с символом null (ASCII NUL)

\NNN

Да

Совпадение с символом, заданным в восьмеричной системе, до \377

\п

Да

Совпадение с n-й ранее захваченной строкой (десятичный)

\а

Да

Совпадение с символом звонка (BEL)

\А

Нет

True в начале строки

\ь

Да

Совпадение с символом возврата (BS)

\ь

Нет

True на границе слова

\в

Нет

True не на границе слова

\СХ

Да

Совпадение с управляющим символом Control-X (\cZ, \с[ и т. д.)

\с

Да

Совпадение с одним байтом (С char) даже в utf8 (опасно)

\d

Да

Совпадение с любой цифрой

\D

Да

Совпадение с любым символом - не цифрой

\е

Да

Совпадение с символом escape (ASCII ESC, не обратная косая черта)

\Е

—

Конец трансляции регистра (\L, \U) или метакавычки (\Q)

\f

Да

Совпадение с символом подачи страницы (FF)

\G

Нет

True в позиции конца совпадения или перед m//g

\1

—

Нижний регистр только для следующего символа

\L

—

Нижний регистр до \Е

\n

Да

Совпадение с символом перевода строки (обычно NL, но CR на Мас'ах)

\N{NAME}

Да

Совпадение с именованным символом (\N{greek:Sigma})

\~PROP}

Да

Совпадение с любым символом с поименованным свойством

\P {以?OP}

Да

Совпадение с любым символом без поименованного свойства

Таблица 5.7 ( продолжение 丿

Символ

Атомарный

Значение

\Q

—

Цитировать (де-мета) метасимволы до \Е

\г

Да

Совпадение с символом возврата каретки (обычно CR, но NL на Мас* ах)

\s

Да

Совпадение с любым пробельным символом

\s

Да

Совпадение с любым непробельным символом

\t

Да

Совпадение с символом табуляции (НТ)

\u

—

Заглавный регистр только для следующего символа

\u

—

Верхний регистр (не заглавный регистр) до \Е

\w

Да

Совпадение с любым «символом слова» (буквенно-цифровым или «_»)

\w

Да

Совпадение с любым «несимволом слова»

\x{abcd}

Да

Совпадение с символом, заданным в шестнадцатеричной системе

\x

Да

Совпадение со строкой Unicode «комбинированная символьная последовательность»

\z

Нет

True только в конце строки

\z

Нет

True в конце строки или перед символом перевода строки

Если в \р или \Р имя свойства состоит из одного символа, фигурные скобки не обязательны. Если в \х шестнадцатеричное число состоит из двух и менее цифр, фигурные скобки не обязательны. Фигурные скобки всегда обязательны в \N.

В классах символов (квадратных скобках) могут использоваться только метасимволы, в описании которых присутствует «Совпадение с ... символом» или «Совпадение с любым». Это значит, что классы символов могут содержать только метазнаки, описывающие другие конкретные наборы символов или описывающие отдельные конкретные символы. Конечно, эти метасимволы можно использовать вне классов символов наряду с остальными неклассифицирующими метазнаками. Обратите внимание, что \Ь - это два совершенно разных «зверя»: внутри класса символов это символ забоя (backspace), но утверждение границы слова вне его.

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

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

водится анализ регулярного выражения. Можно задавать регулярные выражения как обычные строки в двойных кавычках, но тогда нужно следовать правилам, применяемым к обычным строкам в двойных кавычках. Все предыдущие метазнаки, соответствующие фактическим символам, будут работать, даже если они не откладываются до анализатора регулярных выражений. Но нельзя использовать другие метасимволы в обычных двойных кавычках (или аналогичных конструкциях типа qq(...), qx(...) или эквивалентных встроенных документах (here documents). Для того чтобы строка анализировалась как регулярное выражение без выполнения поиска, следует использовать оператор q「〃 (заключить в кавычки регулярное выражение).

Заметьте, что escape-последовательности трансляции регистра и метакавычек (\U и компания) должны обрабатываться на этапе интерполяции переменных, поскольку назначение этих метазнаков состоит в воздействии на способ интерполяции переменных. Если подавить интерполяцию переменных с помощью одинарных кавычек, то не удастся и получить escape-последовательности трансляции. Ни переменные, ни escape-последовательности трансляции (\U и т. д.) не разыменовываются ни в строках в одинарных кавычках, ни в операторах одинарных кавычек m'. . . ‘ или qL ...'・ Даже при выполнении интерполяции эти escape-последовательности трансляции игнорируются, если они появляются как результат интерполяции переменных, поскольку в этом случае уже слишком поздно влиять на интерполяцию переменных.

Хотя оператор транслитерации не принимает регулярные выражения, любой метасимвол из обсуждавшихся нами, который соответствует конкретному отдельному символу, работает и в операции t г///. Остальные - нет (за исключением обратной косой черты, которая как всегда продолжает работать обратным способом).

Специальные символы

Как уже говорилось, в шаблоне все, что не является специальным, соответствует самому себе. Это значит, что /а/ ищет «а», /二/ ищет «=» и т. д. Однако некоторые символы не так просто ввести с клавиатуры, а если вам это и удастся, то они не будут видны в выводе; этим славятся управляющие символы. В регулярном выражении Perl распознает следующие псевдонимы символов в двойных кавычках:

Escape-последовательностьEscape-последовательность\0 \а \е \f \п \г \t\0 \а \е \f \п \г \tЗначение

Escape-последовательность

Escape-последовательность

\0 \а \е \f \п \г \t

\0 \а \е \f \п \г \t

Символ Null (ASCII NUL)

Звонок (BEL)

Escape (ESC)

Подача страницы (FF)

Перевод строки (NL, CR на Mac)

Возврат каретки (CR, NL на Mac)

Табуляция (НТ)

Как и в строках, заключенных в двойные кавычки, Perl отличает в шаблонах следующие четыре метазнака:

\сХ

Именованный управляющий символ, например, \сС для <Ctrl>+vC>, \cZ для <Ctrl>4-<Z>, \с[ для <Esc> и \с? для <Del>.

\NNN

Символ, заданный с помощью двух- или трехзначного восьмеричного кода. Ведущий 0 не обязателен, за исключением чисел, меньших 010 (8 десятичное), поскольку (в отличие от строк в двойных кавычках) код из одной цифры всегда считается ссылкой на подстроку текста, найденного по шаблону. Несколько цифр интерпретируются как n-ая ссылка, если ранее вы захватили по шаблону не менее п подстрок (где п считается десятичным числом); в противном случае они интерпретируются как символ в восьмеричной системе.

\x{LONGHEX}

\х〃ЕХ

Номер символа, заданный в виде одной или двух шестнадцатеричных цифр ([0-9a-fA-F]), например \х1В. Формат из одной цифры можно использовать, только если следующий символ не является шестнадцатеричной цифрой. Если применяются фигурные скобки, цифр может быть сколько угодно, в результате чего можно получить символ Unicode. Например, \x{262f} соответствует символу Unicode «Инь - Ян».

\N{/W£}

Именованный символ, например \N{GREEK SMALL LETTER EPSILON}, \N{g「e- ek:epsilon} или \N{epsilon}. Для этого требуется прагма use charnames, описанная в главе 31 «Модули прагм», которая также определяет те разновидности имен, которые можно использовать (" :long", " :full", " :short" соответственно, связанные с тремя показанными только что стилями).

Список всех имен символов Unicode можно найти в ближайшем документе со стандартами Unicode или в ПУТЬ_К_РЕВШВ/unicode/Names.txt.

Групповые метазнаки

Три особых метазнака выступают в качестве групповых, каждому из которых соответствует «любой» символ (для некоторых значений слова «любой»). Ими являются точка ( . ), \С и \Х. Ни один из них нельзя использовать в классах символов. В них не допускается налие точки, потому что она будет соответствовать (почти) любому существующему символу, являясь своего рода всеобщим классом символов. Если необходимо все исключить или все включить, нет особого смысла в использовании класса символов. Особые групповые символы \С и \Х имеют особый структурирующий смысл, который не очень хорошо согласуется с идеей выбора одного символа Unicode, что является тем уровнем, на котором работают классы символов.

Метасимвол «точка» соответствует любому отдельному символу, кроме символа перевода строки. (А с модификатором /s соответствует и ему тоже.) Как и для любого из двенадцати метасимволов в шаблоне, для буквального поиска точки ее нужно преобразовать с помощью обратной косой черты. Например, следующая команда проверяет, заканчивается ли имя файла точкой и расширением из одного символа:

if ($pathname =~ /\.(.)\z/s) { print "Оканчивается на $1\п";

}

Первая точка, преобразованная обратной косой чертой, представляет собой литеральный символ, а вторая говорит «найти любой символ». Последовательность \z указывает, что соответствие следует искать только в конце строки, а модификатор /s разрешает, чтобы точка соответствовала и символу перевода строки. (Да, использование символа перевода строки в качестве расширения файла выглядит не очень красиво, но это не значит, что так не бывает.)

Символ точки чаще всего используется с квантификатором. Выражение . * соответствует максимальному числу символов, тогда как . *? соответствует минимальному числу символов. Но иногда она применяется без квантификатора для ширины: /(..):(..):(..)/ ищет три поля, каждое из которых имеет размер в два символа и отделяется двоеточием.

Если точка присутствует в шаблоне, компилированном с прагмой use utf8, находящейся в лексической области видимости, то она будет соответствовать любому символу Unicode. (Для этого не предполагается необходимость use utf8, но в противном случае возникнут неприятности. К тому моменту, когда вы будете это читать, использование этой прагмы, возможно, не потребуется.)

use utf8;

use charnames qw/:full/;

$BWV[887] = "G\N{MUSIC SHARP SIGN} minor";

($note, $black, $mode) = $BWV[887] — Л([A-G])(.)\s+(\S+)/;

print "That's lookin' sharp!\n" if $black eq chr(9839);

Метасимвол \X ищет символ в более широком смысле. Он, в действительности, ищет строку из одного или нескольких символов Unicode, называемую «combining character sequence» - комбинированной символьной последовательностью. Такая последовательность состоит из базового символа, за которым следуют символы «пометок» (диакритические знаки, такие как седиль «,» и умляут «"» (dieresis)), объединяющиеся с этим базовым символом в одну логическую единицу. \Х в точности эквивалентен (?:\РМ\рМ*). Это позволяет находить один логический символ, даже если в действительности он состоит из нескольких отдельных символов. Длина соответствия /\Х/ больше одного символа, если найдена комбинация из нескольких символов. (Это длина в символах, а не в байтах.)

Если вы работаете с Unicode и действительно хотите получить один байт, а не один символ, можете воспользоваться метазнаком \С. Он всегда соответствует одному байту (именно одному типу char языка С), даже если при этом возникает расхождение с потоком символов Unicode. См. соответствующие предупреждения в главе 15.

Классы символов

При поиске по шаблону можно искать любой символ, который обладает (или не обладает) некоторым свойством. Есть четыре способа задания классов символов. Можно задавать классы символов традиционным способом - при помощи квадратных скобок и перечисляя возможные символы или прибегнув к любому из трех мнемонических сокращений: традиционные классы Perl, новые для Perl свойства Unicode или стандартные классы POSIX. Каждое из этих сокращений ищет только один символ из своего набора. Снабдите их квантификаторами для поиска более крупных промежутков, например, \d+ ищет одну или несколько цифр. (Естественная ошибка - считать, что \w соответствует слову. Для поиска слова используйте \w+・)

Пользовательские классы символов

Перечисление символов, заключенное в квадратные скобки, называется классом символов и соответствует любому одному из символов этого списка. Например, [aeiouy] ищет букву, являющуюся гласной в английском языке. (Для уэльсского добавьте "w", для шотландского - "г".) Для поиска правой квадратной скобки поставьте перед ней обратную косую черту или поместите первой в списке.

Диапазоны символов могут задаваться с помощью дефиса и обозначения типа a-z. Можно объединять несколько диапазонов, например, [0-9a-fA-F] соответствует одной шестнадцатеричной «цифре». Можно использовать обратную косую черту, чтобы защитить дефис, который иначе будет интерпретироваться как ограничитель диапазона, либо поместить дефис в начале или конце класса (прием, который наверняка менее читаем, но более традиционен).

Символ вставки 人(или циркумфлекс, или «крышка», или «стрелка вверх») перед классом символов инвертирует класс, в результате чего он соответствует любому символу, не входящему в список. (Чтобы найти символ вставки, либо не ставьте его первым, либо, еще лучше, поставьте перед ним обратную косую черту.) Например,厂aeiouy] соответствует любому символу, который не является гласной. Однако будьте осторожны с отрицанием классов символов, поскольку вселенная символов расширяется. Например, этот класс символов соответствует согласным, а также пробелам, символам перевода строки и чему угодно (включая гласные) в кириллице, греческом и почти любом другом алфавите, не говоря уже обо всех китайских, японских и корейских иероглифах. А в один прекрасный день, может быть, даже в ал-

фавитах Cirth, Tengwar и Klingon. (И уж наверняка в критском письме В и этрусском.) Поэтому лучше, может быть, задать согласные явно, например, как [cbdfghjklmnpqrstvwxyz] или, для краткости, [b-df-hj-np-tv-z]. (Это также решает проблему с латинской буквой «у», которая должна быть одновременно в обоих местах, что не получится при использовании дополнения класса.)

Внутри класса символов можно применять обычные символьные метазнаки, (см. раздел «Специальные символы» этой главы), такие как \n, \t, \сХ, \NNN и \^{NAME}. Кроме того, в классе символов можно использовать \Ь, означающий возврат, так же как в строках, заключенных в двойные кавычки. Обычно при поиске по шаблону он обозначает границу слова. Но утверждения нулевой ширины не имеют смысла в классах символов, поэтому в них \Ь возвращается к своему обычному значению в строках. Можно также использовать любые предопределенные классы символов из описываемых далее в этой главе (классические, Unicode или POSIX), но не пытайтесь применять их в качестве границ диапазона: это бессмысленно, поэтому символ - будет интерпретирован буквально.

Все остальные метазнаки утрачивают свое особое значение, находясь в квадратных скобках. В частности, не допускается применение трех общих групповых символов: ., \Х и \С. Первое часто вызывает удивление, но не имеет смысла использовать универсальный класс символов внутри ограниченного, зато часто нужно найти точку в составе класса символов, например при поиске имен файлов. Бессмысленно также задавать квантификаторы, утверждения или чередование внутри класса символов, поскольку символы интерпретируются индивидуально. Например, [fee | fie | foe | foo] означает то же самое, что и[feio|].

Классические сокращенные обозначения классов в Perl

С самого начала в Perl имелся ряд сокращенных обозначений классов символов. Они перечислены в табл. 5.8. Все они являются буквенными метазнаками с косой чертой впереди, и в каждом случае версия на верхнем регистре представляет собой отрицание версии на нижнем регистре. Значение их не является вполне фиксированным, как можно было бы ожидать: на него могут оказывать влияние национальные установки. Даже если вы не работаете с национальными установками, значение может изменяться при выходе нового стандарта Unicode, вводящего дополнительные буквы и цифры. (Чтобы сохранить старые значения байтов, можно использовать прагму use bytes.

Значения utf8 поясняются в разделе «Свойства Unicode» далее в этой главе. В любом случае значения utf8 являются надмножеством значений байтов.)

Таблица 5.8. Классические классы символов

Символ

Значение

Как байт

Как utf8

\d

Цифра

[0-9]

\p{IsDigit}

\D

He цифра

「0-9]

\P{IsDigit}

\s

Пробельный символ

[\t\n\r\f]

\p{IsSpace}

\s

Непробельный символ

厂 \t\n\r\f]

\P{IsSpace}

\w

Символ слова

[a-zA-Z0-9_]

\p{IsWord}

\W

Не (символ слова)

厂a-zA-Z0-9_]

\P{IsWord}

(Мы знаем, что большинство слов не содержит цифры и символы подчеркивания; \w ищет «слова» в смысле типичного языка программирования. Или в смысле Perl, если на то пошло.)

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

if ($var =" /\D/){ warn "содержит нецифру" }

if ($var =~ /[c\w\s.]/) { warn "содержит не-(слово, пробел, точка)" }

Свойства Unicode

К свойствам Unicode обращаются с помощью \[){РНОР} и его дополнительного множества \Р{РНОР}. Для тех редких свойств, имена которых состоят из одного символа, фигурные скобки не обязательны, как в \pN для обозначения числового символа (не обязательно десятичного, римские числа тоже являются числовыми символами). Эти классы свойств можно использовать самостоятельно или объединять в создаваемом классе символов:

if ($var =~ /c\p{IsAlpha}+$/) { print "одни буквы" }

if ($var =~ s/[\p{Zl}\p{Zp}]/\n/g) { print "желающие исправлены на перевод строки" }

Некоторые свойства непосредственно определены в стандарте Unicode, другие являются составными, определяемыми Perl на основе стандартных свойств. Z1 и Zp представляют собой стандартные свойства Unicode, это разделители строк и параграфов, a IsAlpha определяется в Perl как класс свойств, объединяющий стандартные свойства LI, Lu, Lt и Lo (т. е. буквы в нижнем и верхнем регистрах, в заголовочном регистре или другом). В версии Perl 5.6.0 требуется задать use utf8, чтобы эти свойства работали. Это ограничение в будущем будет ослаблено.

Свойств очень много. Мы перечислим те, о которых нам известно, но список неизбежно будет неполным. Вероятно, в новых версиях Unicode появятся новые свойства, и можно даже определять собственные. Подробнее об этом далее.

Консорциум Unicode (Unicode Consortium) производит электронные ресурсы, которые обращаются в различные файлы, используемые Perl в его реализации Unicode. Подробнее об этих файлах сказано в главе 15. Хороший обзор Unicode содержится в документе FiyTb_K_PERLLIB/unicode/Unicode3.html, где FiyTb_K_PERLLIB может быть выведен с помощью команды:

perl -MConfig -le 'print $Config{privlib}'

Большинство свойств Unicode имеют вид \p{IsP80P}・ Буквы Is сделаны необязательными, поскольку они очень часто употребляются, но для улучшения читаемости их можно оставить.

Свойства Unicode в Perl

Во-первых, в табл. 5.9 перечислены составные свойства Perl. Они определены так, чтобы быть достаточно близкими к стандартным определениям POSIX классов символов.

Таблица 5.9. Составные свойства Unicode

Свойство

Эквивалент

IsASCII IsAlnum IsAlpha IsCntrl IsDigit IsGraph IsLower IsPrint IsPunct IsSpace IsUpper IsWord

IsXDigit

[\x00-\x7f]

[\p{IsLl}\p{IsLu}\p{IsLt}\p{IsLo}\p{IsNd}] [\p{IsLl}\p{IsLu}\p{IsLt}\p{IsLo}]

\p{IsC}

\p{Nd}

[x'\pC\p{IsSpace}]

\p{IsLl}

\P{IsC}

\p{IsP}

[\t\n\f\r\p{IsZ}]

[\p{IsLu}\p{IsLt}J

[_\p{IsLl}\p{IsLu}\p{IsLt}\p{IsLo}\p{IsNd}] [0-9a-fA-F]

Perl предоставляет также следующие составные свойства для каждой из основных категорий стандартных свойств Unicode (см. следующий раздел):

Свойство

Значение

Нормативность

IsC

Необычные управляющие коды и т. п.

Да

IsL

Буквы

Частично

IsM

Пометки

Да

IsN

Числа

Да

IsP

Пунктуация

Нет

IsS

Символы

Нет

IsZ

Разделители (сепараторы? зепараторы?)

Да

Стандартные свойства Unicode

В табл. 5.10 перечислены основные стандартные свойства Unicode, производные от всех категорий символов. Всякий символ принадлежит только одной категории. Некоторые свойства являются нормативными, другие - чисто информативными. В Стандарте Unicode можно найти стандартные разглагольствования о том, насколько нормативна нормативная информация и насколько информативна информативная информация.

Таблица 5.10. Стандартные свойства Unicode

Свойство

Значение

Normative

IsCc

Прочие, управляющие

Да

IsCf

Прочие, форматирование

Да

IsCn

Прочие, не назначены

Да

IsCo

Прочие, частное использование

Да

IsCs

Прочие, суррогат

Да

IsLl

Буква, нижний регистр

Да

IsLm

Буква, модификатор

Нет

IsLo

Буква, прочие

Нет

IsLt

Буква, заглавный регистр

Да

IsLu

Буква, верхний регистр

Да

IsMc

Специальный знак, объединение

Да

IsMe

Специальный знак, заключение

Да

IsMn

Знак, диакритический

Да

IsNd

Число, десятичная цифра

Да

IsNl

Число, буквенное

Да

IsNo

Число, прочие

Да

IsPc

Пунктуация, соединительный символ

Нет

IsPd

Пунктуация, черточка

Нет

IsPe

Пунктуация, закрытие

Нет

IsPf

Пунктуация, закрывающая кавычка

Нет

IsPi

Пунктуация, открывающая кавычка

Нет

IsPo

Пунктуация, прочие

Нет

IsPs

Пунктуация, открытие

Нет

IsSc

Символ, валюты

Нет

IsSk

Символ, модификатор

Нет

IsSm

Символ, математический

Нет

IsSo

Символ, прочие

Нет

IsZl

Разделитель, строк

Да

IsZp

Разделитель, абзацев

Да

IsZs

Разделитель, пробел

Да

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

Свойство

Утраченная информация

IsDecoCanon

Нет

IsDecoCompat

Кое-какая (что-то из нижеследующего)

IsDCcircle

Кружок вокруг символа

IsDCfinal

Предпочтение последней позиции (арабский)

IsDCfont

Предпочтение варьирующегося шрифта

IsDCfraction

Характеристика простой дроби

IsDCinitial

Предпочтение начальной позиции (арабский)

IsDCisolated

Предпочтение изолированной позиции (арабский)

IsDCmedial

Предпочтение средней позиции (арабский)

IsDCnarrow

Характеристика «узкий» (narrow)

IsDCnoBreak

Предпочтение «неразрывный» (пробел или тире)

IsDCsmall

Характеристика « малый »

IsDCsquare

Символы ККЯ (Корея, Китай, Япония), обведенные

рамкой

IsDCsub

Нижний индекс

IsDCsuper

Верхний индекс

IsDCvertical

Поворот (с горизонтального в вертикальное)

IsDCwide

Характериситка «широкий» (wide)

IsDCcompat

Особенность (identity), разное

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

ный вывод:

Свойство

Значение

IsBidiL

Слева направо (арабский, еврейский)

IsBidiLRE

Слева направо, встраивание

IsBidiLRO

Слева направо, переопределение

IsBidiR

Справа налево

IsBidiAL

Справа налево, арабский

IsBidiRLE

Справа налево, встраивание

IsBidiRLO

Справа налево, переопределение

(продолжение 丿

Свойство

Значение

IsBidiPDF

Прочитать формат направленности (pop directional format)

IsBidiEN

Число в европейском формате

IsBidiES

Разделитель числа в европейском формате

IsBidiET

Терминатор числа в европейском формате

IsBidiAN

Арабское число

IsBidiCS

Разделитель числа

IsBidiNSM

Метка непробельного символа (nonspacing mark)

IsBidiBN

Граничный символ (boundary neutral)

IsBidiB

Разделитель абзацев

IsBidiS

Разделитель сегментов

IsBidiWS

Пробельный символ

IsBidiON

Other Neutrals

IsMirrored

Обратить при использовании справа налево

Следующие свойства классифицируют различные слоговые азбуки в соответствии с гласными звуками:

IsSylA

IsSylE

IsSylO

IsSylWAA

IsSylWH

IsSylAA

IsSylEE

IsSylOO

IsSylWC

IsSylWO

IsSylAAI

IsSyll

IsSylU

IsSylWE

IsSylWOO

IsSylAI

IsSylll

IsSylV

IsSylWEE

IsSylWU

IsSylC

IsSylN

IsSylWA

IsSylWI

工sSylWV

Например, \p{IsSylA} соответствует \N{KATAKANA LETTER КА}, но не \N{KATAKANA LETTER KU}.

Теперь, когда мы в основном рассмотрели свойства Unicode 3.0, следует указать, что несколько наиболее таинственных из них не реализованы в версии Perl 5.6.0, поскольку отчасти его реализация основывалась на Unicode 2.0 и такие вещи, как двунаправленный алгоритм, все еще разрабатывались. Однако к моменту чтения данной книги отсутствующие свойства вполне могут быть реализованы, поэтому мы на всякий случай их перечислили.

Свойства блоков Unicode

Некоторые свойства Unicode имеют вид \^{IqSCRIPT}. (Обратите внимание на разницу между Is и In.) Свойства In предназначены для проверки блоковых диапазонов конкретного шрифта SCRIPT. Если у вас есть символ и вас интересует, принадлежит ли он греческому алфавиту, можно проверить это с помощью

print "It's Greek to me!\n" if chr(931) =~ /\p{InGreek}/;

При этом проверяется, находится ли символ «в» допустимом для данного шрифта диапазоне. Отрицание можно задать с помощью \P{InSCRIPT}, чтобы установить, что нечто не находится в конкретном блоке шрифта; например, \P{InDingbats} проверяет, содержит ли строка не-«как его там». В число свойств блоков входят следующие:

InArabic

InCyrillic

InHangulJamo

InMalayalam

InSyriac

InArmenian

InDevanagari

InHebrew

InMongolian

InTamil

InArrows

InDingbats

InHiragana

InMyanmar

InTelugu

InBasicLatin

InEthiopic

InKanbun

InOgham

InThaana

InBengali

InGeorgian

InKannada

InOriya

InThai

InBopomofo

InGreek

InKatakana

InRunic

InTibetan

InBoxDrawing

InGujarati

InKhmer

InSinhala

InYiRadicals

InCherokee

InGurmukhi

InLao

InSpecials

InYiSyllables

Не говоря уже о таких зубодробительных:

InAlphabeticPresentationForms InArabicPresentationForms-A InArabicPresentationForms-B InBlockElements InBopomofoExtended InBraillePatterns InCJKCompatibility InCJKCompatibilityForms InCJKCompatibilityldeographs InCJKRadicalsSupplement InCJKSymbolsandPunctuation InCJKUnifiedldeographs InCJKUnifiedldeographsExtensionA InCombiningDiacriticalMarks InCombiningHalfMarks InCombiningMarksforSymbols InControlPictures InCurrencySymbols InEnclosedAlphanumerics InEnclosedCJKLettersandMonths InGeneralPunctuation InGeometricShapes InGreekExtendedА вот победитель:InAlphabeticPresentationForms InArabicPresentationForms-A InArabicPresentationForms-B InBlockElements InBopomofoExtended InBraillePatterns InCJKCompatibility InCJKCompatibilityForms InCJKCompatibilityldeographs InCJKRadicalsSupplement InCJKSymbolsandPunctuation InCJKUnifiedldeographs InCJKUnifiedldeographsExtensionA InCombiningDiacriticalMarks InCombiningHalfMarks InCombiningMarksforSymbols InControlPictures InCurrencySymbols InEnclosedAlphanumerics InEnclosedCJKLettersandMonths InGeneralPunctuation InGeometricShapes InGreekExtendedА вот победитель:InHalfwidthandFullwidthForms InHangulCompatibilityJamo InHangulSyllables InHighPrivatellseSurrogates InHighSurrogates InldeographicDescriptionCharacters InIPAExtensions InKangxiRadicals InLatin-ISupplement InLatinExtended-A InLatinExtended-B InLatinExtendedAdditional InLetterlikeSymbols InLowSurrogates InMathematicalOperators InMiscellaneousSymbols InMiscellaneousTechnical InNumberForms InOpticalCharacterRecognition InPrivatellse InSuperscriptsandSubscripts InSmallFormVariants InSpacingModifierLettersInHalfwidthandFullwidthForms InHangulCompatibilityJamo InHangulSyllables InHighPrivatellseSurrogates InHighSurrogates InldeographicDescriptionCharacters InIPAExtensions InKangxiRadicals InLatin-ISupplement InLatinExtended-A InLatinExtended-B InLatinExtendedAdditional InLetterlikeSymbols InLowSurrogates InMathematicalOperators InMiscellaneousSymbols InMiscellaneousTechnical InNumberForms InOpticalCharacterRecognition InPrivatellse InSuperscriptsandSubscripts InSmallFormVariants InSpacingModifierLetters

InAlphabeticPresentationForms InArabicPresentationForms-A InArabicPresentationForms-B InBlockElements InBopomofoExtended InBraillePatterns InCJKCompatibility InCJKCompatibilityForms InCJKCompatibilityldeographs InCJKRadicalsSupplement InCJKSymbolsandPunctuation InCJKUnifiedldeographs InCJKUnifiedldeographsExtensionA InCombiningDiacriticalMarks InCombiningHalfMarks InCombiningMarksforSymbols InControlPictures InCurrencySymbols InEnclosedAlphanumerics InEnclosedCJKLettersandMonths InGeneralPunctuation InGeometricShapes InGreekExtended

А вот победитель:

InAlphabeticPresentationForms InArabicPresentationForms-A InArabicPresentationForms-B InBlockElements InBopomofoExtended InBraillePatterns InCJKCompatibility InCJKCompatibilityForms InCJKCompatibilityldeographs InCJKRadicalsSupplement InCJKSymbolsandPunctuation InCJKUnifiedldeographs InCJKUnifiedldeographsExtensionA InCombiningDiacriticalMarks InCombiningHalfMarks InCombiningMarksforSymbols InControlPictures InCurrencySymbols InEnclosedAlphanumerics InEnclosedCJKLettersandMonths InGeneralPunctuation InGeometricShapes InGreekExtended

А вот победитель:

InHalfwidthandFullwidthForms InHangulCompatibilityJamo InHangulSyllables InHighPrivatellseSurrogates InHighSurrogates InldeographicDescriptionCharacters InIPAExtensions InKangxiRadicals InLatin-ISupplement InLatinExtended-A InLatinExtended-B InLatinExtendedAdditional InLetterlikeSymbols InLowSurrogates InMathematicalOperators InMiscellaneousSymbols InMiscellaneousTechnical InNumberForms InOpticalCharacterRecognition InPrivatellse InSuperscriptsandSubscripts InSmallFormVariants InSpacingModifierLetters

InHalfwidthandFullwidthForms InHangulCompatibilityJamo InHangulSyllables InHighPrivatellseSurrogates InHighSurrogates InldeographicDescriptionCharacters InIPAExtensions InKangxiRadicals InLatin-ISupplement InLatinExtended-A InLatinExtended-B InLatinExtendedAdditional InLetterlikeSymbols InLowSurrogates InMathematicalOperators InMiscellaneousSymbols InMiscellaneousTechnical InNumberForms InOpticalCharacterRecognition InPrivatellse InSuperscriptsandSubscripts InSmallFormVariants InSpacingModifierLetters

InllnifiedCanadianAboriginalSyllabics

Чтобы получить более новый список этих свойств блоков символов, обратитесь к файлу ПУТЬ_К_РЕВИ1В/Unicode/In/*.р1. Заметьте, что эти свойства In только проверяют, входит ли символ в блок символов, выделенный данному шрифту. Нет гарантии, что в этом диапазоне определены все символы, поэтому нужно также проверить одно из свойств Is, обсуждавшихся выше, чтобы узнать, определен ли данный символ. Нет также гарантии, что неко-

торый язык не использует символы вне выделенного ему блока. В частности, во многих европейских языках смешаны символы расширенной латиницы и Latin-1.

Но долой уныние; если вам нужно какое-то свойство, которое отсутствует, то невелика проблема. Читайте дальше.

Задание собственных свойств символов

Для того чтобы определить собственное свойство, следует написать подпрограмму, именем которой будет название свойства (см. главу 6 «Подпрограммы»). Процедура должна быть определена в пакете, которому требуется это свойство (см. главу 10 «Пакеты»), а это значит, что если требуется использовать его в нескольких пакетах, то понадобится либо импортировать его из модуля (см. главу 11 «Модули»), либо наследовать его как метод класса из пакета, в котором он определен (см. главу 12 «Объекты»).

Если все это улажено, то подпрограмма должна возвратить данные в таком же формате, как файлы в каталоге ПУТЬ_К_РЕВШВ/unicode/Is. Это значит, что должен возвращаться список символов или диапазонов символов в шестнадцатеричном виде, по одному в строчке (line). Если это диапазон, то два числа разделяются символом табуляции. Предположим, что нам нужно свойство, принмающее значение «истина», если символ находится в какой-либо из японских азбук, известных как хирагана и катакана (вместе их называют кана). Можно просто задать два диапазона, например:

sub InKana {

return «'END';

3040309F

30A0 30FF

END

}

Либо можно определить свойство, используя названия существующих свойств:

sub InKana { return «'END';

+utf8::InHiragana

+utf8::InKatakana

END

}

Можно также вычитать массивы символов с помощью префикса «-». Предположим, что нам нужны только фактические символы, а не диапазоны блоков символов. Отмести все неопределенные символы можно так:

sub IsKana {

return «'END';

+utf8::InHiragana

+utf8::InKatakana

-utf8::工sCn

END

}

Можно также начать с дополнительного набора символов, используя префикс «! »:

sub IsNotKana { return «'END';

!utf8::InHiragana

~utf8::InKatakana

+utf8::IsCn

END

}

Сам Perl использует точно такие же приемы для определения своих «классических» классов символов (типа \w), когда мы включаем их в собственные классы символов (типа [-.\w\s]). Может показаться, что чем сложнее становятся правила, тем медленнее они выполняются, но на практике, после того как Perl рассчитает битовую матрицу для некоторого 64-разрядного образчика нашего свойства, он его кэширует, и больше пересчитывать матрицу не приходится. (Он делает это в 64-разрядных образчиках (swatches), поэтому для поиска ему даже не приходится декодировать наш utf8.) В результате все классы символов, встроенные или пользовательские, работают примерно с одинаковой скоростью, после того как они созданы.

Классы символов в стиле POSIX

В отличие от других сокращенных обозначений классов символов в Perl, обозначения классов символов в стиле POSIX, [:CLASS: ], могут использоваться только при создании других классов символов, то есть внутри другой пары квадратных скобок. Например /[., [:alpha: ][ :digit: ]]/ осуществляет поиск одного символа, который является литеральной точкой (поскольку она находится в классе символов) или запятой, или буквой алфавита, или цифрой.

Классы POSIX, имеющиеся в Perl версии 5.6, показаны в табл. 5.11.

Таблица 5.〃. Классы символов POSIX

Класс alnum alphaascii cntrlКласс alnum alphaascii cntrlЗначение

Класс alnum alpha

ascii cntrl

Класс alnum alpha

ascii cntrl

Любой буквенно-цифровой символ, т. е. alpha или digit

Любая буква. (Это значительно больше букв, чем вы думаете, если только вы не думаете на Unicode, но и тогда это достаточно много.)

Любой символ с порядковым значением от 0 до 127

Любой управляющий символ. Обычно это символы, которые сами не выводятся, но некоторым образом управляют терминалом, например, перевод строки, подача страницы, возврат - все они являются управляющими символами. Символы с порядковым номером до 32 чаще всего классифицируются как управляющие

218

Глава 5. Поиск по шаблону

Таблица 5・/1 f продолжение 丿

Класс

Значение

digit

Символ, представляющий десятичную цифру, например, от 0 до 9. (В Unicode включает и другие символы.) Эквивалентен \d

graph

Любой буквенно-цифровой символ или знак пунктуации

lower

Буква на нижнем регистре

print

Любой буквенно-цифровой символ или знак пунктуации, или пробел

punct

Любой знак пунктуации

space

Любой пробельный символ. Включает символы табуляции, перевода строки, подачи страницы и возврата каретки (и много чего еще в Unicode). Эквивалентен \s

upper

Любая буква в верхнем (или заглавном) регистре

word

Любой символ идентификатора, буквенно-цифровой или подчеркивания

xdigit

Любая шестнадцатеричная цифра. Хотя это может показаться глупым (достаточно [0-9a-fA-F]), включен для полноты

Можно создавать отрицание классов символов POSIX, помещая перед именем класса 八 вслед за [:. (Это расширение Perl.) Например:

POSIX

Классический

[「digit:]

\D

[「space:]

\s

[:"word:]

\W

Если прагма use utf8 не запрашивается, но запрашивается прагма use locale, то классы прямо коррелируют с эквивалентными функциями в интерфейсе библиотеки С isa/p九а⑶(кроме word, являющегося расширением Perl, копирующим \w)・

Если используется прагма utf8, то классы символов POSIX в точности эквивалентны соответствующим свойствам Is, которые перечислены в табл. 5.9. Например, эквивалентны [:lower: ] и \р{Lower}, за исключением того, что классы POSIX могут применяться только при создании классов символов, тогда как для свойств Unicode такого ограничения нет, и они могут использоваться в тех же местах шаблонов, где и сокращенные обозначения классов Perl \s и \w.

Квадратные скобки являются частью конструкции в стиле POSIX [:: ], а не частью класса символов в целом. Поэтому можно писать такие шаблоны, как /^[[: lower: ][ :digit: ]]+$/ для поиска строки, состоящей только из букв на нижнем регистре или цифр (и, возможно, замыкающего символа перевода строки). В частности, следующая команда не работает:

42 — /^:digit:]$/42 — /^:digit:]$/# НЕВЕРНО# НЕВЕРНО

42 — /^:digit:]$/

42 — /^:digit:]$/

# НЕВЕРНО

# НЕВЕРНО

Это неверно, потому что класс POSIX не находится внутри класса символов. Но это класс символов, представляющий символы 《：》, «i», «t», «д» и 《d»・ Perl безразлично, что символ « : » задан дважды.

Вот что нужно было написать в действительности:

42 =~ /工「digit:]]+$/

Классы символов POSIX [.сс. ] и [=сс=] распознаются, но порождают ошибку, в которой сообщается, что они не поддерживаются. Попытка применения любого класса символов POSIX в более старых версиях Perl провалится, причем, возможно, без слов. Если вы собираетесь использовать классы символов POSIX, лучше всего затребовать новую версию Perl, сказав:

use 5.6.0;

Квантификаторы

Если не указано иное, то для каждого элемента в регулярном выражении отыскивается только одно совпадение. Для такого шаблона, как /пор/, должны быть найдены все эти символы, один за другим. Такие слова, как «panoply» и «xenophobia», подходят, потому что не имеет значения, где находится совпадение.

Если нам надо, чтобы подходили как «xenophobia», так и «Snoopy», то шаблон /пор/ использовать нельзя, поскольку он требует наличия только одного «о» между «п» и «р», а в «Snoopy» их два. В таких случаях на помощь приходят квантификаторы: они сообщают, сколько раз что-то должно совпадать, вместо однократного совпадения по умолчанию. Квантификаторы в регулярном выражении - как циклы в программе. В действительности, если представить себе регулярное выражение как программу, то они и есть циклы. Некоторые циклы точные, типа «повторить это совпадение только пять раз» ({5}). Другие задают нижнюю и верхнюю границы счетчика совпадений, типа «повторить это совпадение не меньше двух, но не больше четырех раз» ({2,4}). Кроме того, вообще нет установленной верхней границы, вроде «совпадение по крайней мере дважды, но столько раз, сколько угодно» ({2,}). В табл. 5.12 показаны квантификаторы, которые Perl распознает в шаблоне.

Таблица 5.12. Квантификаторы в регулярных выражениях

Максимальный

Минимальный

Допустимый диапазон

{MIN, МАХ}

{MIN, М4Х}?

Совпадение не меньше М2"раз, но не больше МАХ раз

{MIN, }

{MIN,}?

Совпадение не меньше MIN раз

{COUNT}

{COUNT}?

Совпадение ровно COUNT раз

*

*?

0 или более раз (то же, что {0,})

+

+?

1 или более раз (то же, что {1,})

??

0 или 1 раз (то же, что {0,1})

Нечто, обозначаемое * или ?, фактически не должно совпадать. Дело в том, что совпадение может произойти 0 раз и считаться успехом. Квантификатор + может быть более подходящим, поскольку предполагает хотя бы одно соответствие.

Пусть вас не смущает использование в предыдущей таблице слова «ровно». Оно относится только к счетчику повторений, а не к строке в целом. Например, $n =~ /\d{3}/ не означает: «Равна ли длина строки ровно трем цифрам?» Здесь спрашивается, есть ли в $п место, в котором подряд находятся три цифры. Строка «101 Morris Street» удовлетворяет этому, как и строки 《95472» и «1-800-555-1212». Все они содержат три цифры в одной или нескольких точках, и это все, о чем мы спрашивали. Для закрепления см. раздел «Позиции», где описывается использование утверждений позиций (как в /c\d{3}$/)・

Имея возможность найти совпадение разное количество раз, максимальные квантификаторы выбирают максимальное число повторений. Поэтому, когда мы говорим: «Столько раз, сколько угодно», жадный квантификатор интерпретирует это как «столько раз, сколько сможешь унести», ограничиваясь лишь требованием, чтобы это не помешало поиску совпадений согласно последующим спецификациям. Если в шаблоне есть два квантификатора с открытыми концами, то, очевидно, оба они не могут «съесть» строку целиком: символы, которые использует одна часть совпадения, становятся недоступными части, следующей за ней. Все квантификаторы проявляют жадность, обделяя следующие за ними, при этом шаблон читается слева направо. Это обычное поведение квантификаторов в регулярных выражениях. Однако Perl позволяет нам изменить поведение своих квантификаторов: поместив ? после квантификатора, мы превратим его из максимального в минимальный. Это не значит, что минимальный квантификатор всегда будет давать совпадение из минимального числа повторений, разрешенных в его диапазоне, как не означает и того, что максимальный квантификатор всегда будет находить максимальное число совпадений, допустимое в его диапазоне. Успешным должно быть совпадение в целом, и минимальное совпадение возьмет столько, сколько нужно, чтобы быть успешным, и не более. (Минимальные квантификаторы удовлетворение ценят выше жадности.)

Например, при поиске:

"exasperate" /е(.*)е/ # $1 содержит теперь "xasperat"

.* соответствует "xasperat", самой длинной из возможных строк. (Это значение также записывается в $1, как описывается в разделе «Захват и кластеризация» далее в этой главе.) Хотя имелось более короткое соответствие, при жадном поиске это не важно. Если в одной и той же точке есть возможность выбора, всегда возвращается более длинный вариант.

Сравните это со следующим:

"exasperate" =~ /е(.*?)е/ # $1 содержит теперь "xasp"

Здесь применяется минимальная версия поиска, . *?. Добавление ? к * заставляет *? вести себя противоположным образом: теперь, если в одной точке есть выбор из двух возможностей, всегда возвращается более короткая из них.

Хотя можно прочесть *? как «искать ноль или более чего-то, но предпочтительно ноль», это не значит, что всегда будет отыскиваться ноль символов. Если бы это было так, и в нашем примере $1 была установлена в то не была бы найдена вторая "е", т. к. она не следует за первой непосредственно.

Вы можете поинтересоваться, почему при минимальном поиске /е(. *?)е/ Perl не вставил в $1 строку " rat" . Ведь "rat" тоже находится между двумя "е" и короче "xasp". В Perl выбор между максимальным и минимальным происходит только при наличии альтернатив соответствия, причем все они имеют одну и ту же начальную точку. Если есть два возможных соответствия, но начинаются они на разном смещении от начала строки, то их длина не играет роли, как и то, какой квантификатор используется - минимальный или максимальный. Из нескольких возможных соответствий побеждает всегда то, которое встретилось раньше. Лишь если несколько возможных совпадений начинаются в одной и той же точке, для принятия решения используется минимальное или максимальное соответствие. А если начальные точки различаются, то и решать нечего. Обычно Perl ищет самое левое наибольшее совпадение; при минимальном поиске оно становится самым левым наименьшим, Часть «самое левое» всегда постоянна и является доминирующим критерием.

Есть два способа преодолеть «левый уклон» поиска по шаблону. Во-первых, можно использовать сначала жадный квантификатор (обычно . *), чтобы постараться «проглотить» начальные части строки. При поиске соответствия для жадного квантификатора сначала отыскивается самое длинное соответствие, в результате чего оставшаяся часть строки просматривается справа налево:

"exasperate" =~ /.*е(.*?)е/# $1 теперь содержит "rat"

Но будьте осторожны, поскольку общий результат поиска теперь содержит всю строку вплоть до этой точки.

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

Позиции

Некоторые конструкции в регулярных выражениях символизируют позиции в строке, которые должны быть найдены, представляющие собой место слева или справа от реального символа. Эти метазнаки являются примерами утверждений нулевой ширины, поскольку они не соответствуют фактическим символам строки. Часто мы называем их просто утверждениями (assertions). (Они называются также точками привязки (anchors), поскольку привязывают какую-то часть шаблона к определенной позиции.)

Есть возможность манипулирования позициями в строке без использования шаблонов. Встроенная функция substr позволяет извлекать подстроки и осуществлять присвоение подстрокам, измеряемым с начала строки, с конца строки или с конкретного числового смещения. Этого может оказаться достаточно при работе, например, с записями фиксированной длины. Шаблоны необходимы, только если числового смещения недостаточно. Но чаще всего смещений недостаточно или, по крайней мере, они недостаточно удобны в сравнении с шаблонами.

Начало: утверждения \ А и А

Утверждение \А соответствует только началу строки, какой бы она ни была. Однако традиционным утверждением начала строки (string) и начала строчки (line) является 1 Поэтому, если в шаблоне используется модификатор /т1 и внутри строки есть символы перевода строки,八 соответствует также любому месту в строке сразу за символом перевода строки:

/\Abar/# Соответствует"bar"и"barstool"

/"bar/# Соответствует"bar"и"barstool"

/ЛЬаг/т# Соответствует"bar"и"barstool"and"sand\nbar"

В сочетании с модификатором /дмодификатор /тпозволяет находить соот

ветствие с многократно в одной и той же строке:

s/c\s+//gm;# Обрезать ведущие пробельные символы во всех строчках

$total++ while /^./mg; # Подсчитать непустые строчки

Конец: утверждения \zf \Z и $

Метасимвол \z соответствует концу строки независимо от ее содержания. \Z соответствует позиции перед символом перевода строки в конце строки, если этот символ там есть, и в конце строки, если его нет. Метасимвол $ обычно имеет тот же смысл, что и \Z. Однако если задан модификатор /т и внутри строки есть символы перевода строки, то $ может соответствовать любому месту в строке перед символом перевода строки:

/bot\z/

#

Соответствует

"robot"

/bot\Z/

#

Соответствует

"robot" и "abbot\n"

/bot$/

#

Соответствует

"robot" и "abboAn"

/bot$/m

#

Соответствует

"robot" и "abbot\n" и

"robot\nrules"

/c「obot$/

#

Соответствует

"robot" и "robot\n"

/"robot$/m

#

Соответствует

"robot" и "robot\n" и

"this\nrobot\n"

/\Arobot\Z/

Соответствует

"robot" и "robot\n"

/\Arobot\z/

Соответствует

только "robot" - - но

почему вы не использовали eq?

Как и для с, модификатор /т позволяет находить соответствие $ многократно в одной и той же строке, если задан модификатор /д. (В следующих примерах предполагается, что в $_ считана запись из нескольких строк; возможно, нужно установить перед чтением $/ равной '.)

s/\s*$//gm;# Обрезать замыкающие пробелы во всех строках абзаца

while (/с([с：]+)：\s*(.*)/gm ) { # получить заголовок почтового сообщения $headers{$1} = $2;

}

В разделе «Интерполяция переменных» далее в этой главе мы расскажем о том, как можно интерполировать переменные в шаблонах: если $foo имеет значение «Ьс», то /a$foo/ эквивалентно /аЬс/. Здесь $ не соответствует концу строки. Чтобы $ соответствовал концу строки, он должен быть в конце шаблона, либо сразу за ним должна следовать вертикальная черта или закрывающая скобка.

Границы: утверждения \Ь и \В

Утверждение \Ь соответствует любой границе слова, определяемой как позиция между символом \w и символом \W, в любом порядке. Порядок \W\w соответствует границе начала слова, а порядок \w\W - границе конца слова. (Концы строки рассматриваются здесь как символы \W.) Утверждение \В соответствует любой позиции, которая не является границей слова, т. е. находится в середине \w\w или \W\W.

/\bis\b/ # /\Bis\B/ # /\bis\B/ # /\Bis\b/ #/\bis\b/ # /\Bis\B/ # /\bis\B/ # /\Bis\b/ #Соответствует Соответствует Соответствует СоответствуетСоответствует Соответствует Соответствует Соответствует"what it is” и "that is it" "thistle" и "artist" "istanbul" и "so- -isn't that butter? "confutatis" и "metropolis near you"

/\bis\b/ # /\Bis\B/ # /\bis\B/ # /\Bis\b/ #

/\bis\b/ # /\Bis\B/ # /\bis\B/ # /\Bis\b/ #

Соответствует Соответствует Соответствует Соответствует

Соответствует Соответствует Соответствует Соответствует

Поскольку \W включает все знаки пунктуации (кроме подчеркивания), границы \Ь присутствуют в середине таких строк, как «isn't», «booktech@oreil- ly.com», «М.1.Т.» и «key/value».

Внутри класса символов ([\Ь]) знак \Ь представляет символ возврата, а не границу слова.

Последовательный поиск

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

Sburglar = "Bilbo Baggins"; while ($bu「gla「二~ /Ь/gi) { printf "Найдена В в позиции %d\n", pos($burglar)-1;

}

(Мы вычитаем из позиции единицу, поскольку мы ищем длину строки, a pos всегда указывает на позицию после найденного соответствия.)

Вышеприведенный код выводит:

Найдена В в позиции О

Найдена В в позиции 3

Найдена В в позиции 6

После неудачного поиска позиция для поиска обычно сбрасывается в начало. Если дополнительно указать модификатор /с (от «continue»), то когда очередной поиск с модификатором /д окажется неудачным, указатель позиции не будет сброшен в начало. Это позволяет продолжить поиск, не возобновляя его с самого начала.

$bu「gla「二"Bilbo Baggins";

while (Sburglar =~ /b/gci) {# ADD /с

printf " Найдена В в позиции %d\n", pos($burglar)-1;

}

while (Sburglar =~ /i/gi) {

printf " Найдена I в позиции %d\n", pos($burglar)-1;

}

Кроме трех В, найденных ранее, Perl сообщает теперь об i, найденной в позиции 10. Без /с второй поиск в цикле начался бы с начала и нашел бы еще одну i в позиции 1.

Где вы остановились: утверждение \G

При мысли об использовании функции pos возникает соблазн разделать строку с помощью функции substr, но такой подход редко бывает правильным. Чаще, если уж мы начали с поиска по шаблону, то лучше так и продолжить. Однако если надо найти утверждение позиции, то, вероятно, мы ищем \G.

Утверждение \G представляет в шаблоне ту же точку, которую pos представляет вне его. Если мы осуществляем последовательный поиск в строке с модификатором /д (или воспользовались функцией pos для непосредственного вызова начальной точки), то можем использовать \G для задания позиции сразу за предыдущим найденным соответствием. То есть он соответствует месту непосредственно перед тем символом, текущая позиция кото-

рого будет определена посредством pos. Это позволяет запомнить, где мы остановились:

($recipe = <<'DISH') =~ s/c\s+〃gm; Preheat oven to 451 deg. fahrenheit. Mix 1 ml. dilithium with 3 oz. NaCl and stir in 4 anchovies. Glaze with 1 g. mercury. Heat for 4 hours and let cool for 3 seconds. Serves 10 aliens.

DISH

$recipe/\d+ /g;$recipe =~ /\G(\w+)/;$recipe/\d+ /g;$ recipe =~ /\G(\w+)/;$recipe =~ /\d+ /g;$「ecipe =~ /\G(\w+)/;$recipe/\d+ /g;$recipe =~ /\G(\w+)/;$recipe/\d+ /g;$ recipe =~ /\G(\w+)/;$recipe =~ /\d+ /g;$「ecipe =~ /\G(\w+)/;# $1 теперь "deg# $1 теперь "deg# $1 теперь "ml# $1 теперь "ml# $1 теперь "oz# $1 теперь "oz

$recipe/\d+ /g;

$recipe =~ /\G(\w+)/;

$recipe/\d+ /g;

$ recipe =~ /\G(\w+)/;

$recipe =~ /\d+ /g;

$「ecipe =~ /\G(\w+)/;

$recipe/\d+ /g;

$recipe =~ /\G(\w+)/;

$recipe/\d+ /g;

$ recipe =~ /\G(\w+)/;

$recipe =~ /\d+ /g;

$「ecipe =~ /\G(\w+)/;

# $1 теперь "deg

# $1 теперь "deg

# $1 теперь "ml

# $1 теперь "ml

# $1 теперь "oz

# $1 теперь "oz

Метазнак \G часто применяется в цикле, как показано в следующем примере. Мы «останавливаемся» после каждой цифровой последовательности и проверяем в этом месте, нет ли за ней аббревиатуры. Если есть, то захватываем два следующих слова, в противном случае только одно следующее слово:

pos($recipe) = 0;# На всякий случай сбросим \G в 0

$「ecipe /(\d+) /д ) {

my $amount 二 $1;

if ($recipe =~ / \G (\w{0,3}) \. \s+ (\w+) /х) { # сокращ. + слово print "$amount $1 of $2\n";

} else {

$recipe =~ / \G (\w+) /х;# просто слово

print "$amount $1\n";

}

}

В результате получается:

451 deg of fahrenheit

ml of dilithium

oz of NaCl

anchovies

g of mercury

hours

seconds

aliens

Захват и кластеризация

Шаблоны позволяют группировать их части в подшаблоны и запоминать строки, соответствующие этим подшаблонам. Первое мы называем кластеризацией (clustering), а второе - захватом (capturing).

Захват

Чтобы захватить строку и в дальнейшем ее использовать, заключите в круглые скобки соответствующий ей под шаблон. Первая пара скобок хранит свою подстроку в переменной $1, вторая пара -в$2ит. д. Скобок может быть сколько угодно; Perl просто продолжает определять новые нумерованные переменные, представляющие эти захваченные строки.

Некоторые примеры:

/(\d)(\d)/ # Найти две цифры, захватив их в $1 и $2

/(\d+)/# Найти одну или более цифр, захватив их все в $1

/(\d)+/# Найти цифру один или более раз, захватив последнюю в $1

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

Захваченные строки часто называют ссылками на найденный текст (back- references), поскольку они ссылаются на части захваченного текста. Есть два способа получить эти ссылки. Нумерованные переменные, которые мы видели, показывают, как получить ссылки на найденный текст, находясь вне шаблона, но в самом шаблоне они не работают. Для этого приходится использовать \1, \2 и т. д. Поэтому для поиска повторяющихся слов, например, "the the" или "had had", можно применить такой шаблон:

/\b(\w+) \1\b/i

Но чаще всего вы будете прибегать к формату $1, потому что обычно шаблон применяется и с подстроками выполняются какие-то действия. Допустим, есть некоторый текст (почтовый заголовок), который выглядит так:

From: gnat@perl.com

То: camelot@oreilly.com

Date: Mon, 17 Jul 2000 09:00:00 -1000

Subject: Eye of the needle

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

while (<>) {

/с(.*?)： (.*)$/；# Текст до двоеточия - в $1, после него - в $2

$fields{$1}二 $2;

}

Подобно $', $& и $' эти нумерованные переменные имеют динамическую область видимости до конца охватывающего блока или строки eval либо до следующего успешного поиска по шаблону, в зависимости от того, что произойдет раньше. Их можно также использовать в правой (заменяющей) части подстановки:

s/X\S+) (\S+)/$2 $1/; # Поменять местами первые два слова

Группирование может быть вложенным и в этом случае нумерация групп производится согласно положению левой скобки. Поэтому для строки «Primula Brandybuck» шаблон

/X(\w+) (\w+))$/

захватит "Primula Brandybuck" в $1, "Primula" в $2 и "Brandybuck" в $3. Это отражено на рис. 5.1.

ZR(\W+) 8丽))$?

А $2:А$3

*$1

Рис. 5.1. Создание ссылок на найденный текст с помощью круглых скобок

Шаблоны с захватами часто применяются в списковом контексте для заполнения списка значениями, т. к. шаблон достаточно «сообразителен», чтобы возвращать перехваченные строки в виде списка:

($first, $last) = /<\w+) (\w+)$/;

($full, $first, $last)二 /X(\w+) (\w+))$/;

При наличии модификатора /g шаблон может возвращать несколько подстрок от нескольких найденных соответствий в одном списке. Предположим, что почтовый заголовок, который мы видели выше, целиком находится в одной строке (скажем, в $_). То же самое, что в нашем построчном цикле, можно сделать с помощью одной команды:

%fields 二 /У.*?): (.*)$/gm;

Шаблон находит соответствие четыре раза, и в каждом соответствии он находит две подстроки. Поиск с модификатором /gm возвращает их все в плос-

ком списке из восьми строк, которые присвоение списку %fields удачно проинтерпретирует как четыре пары ключ/значение, восстановив таким образом гармонию во вселенной.

Есть еще несколько специальных переменных, относящихся к тексту, захватываемому при поиске по шаблону. $& содержит всю найденную строку, $' содержит все, что находится слева от соответствия, $' - справа, а $+ содержит текст последней ссылки на найденный текст.

$_ 二"Speak, <EM>friend</EM>,

and enter.";

m[ (<•

*?>) (•*?) (</■*?>) ]x;

#

Тег, затем символы, затем закрывающий тег

print

"prematch: $'\n";

#

Speak,

print

"match: $&\n";

#

<EM>friend</EM>

print

"postmatch: $'\n";

#

,and enter.

print

"lastmatch: $+\n";

</EM>

Разъяснение этих магических переменных (и способ их написания по-английски) имеются в главе 28 «Специальные имена».

Массив @- (@LAST_MATCH_START) содержит смещения начал всех подчиненных соответствий, а массив @+ (@LAST_MATCH_END) содержит смещения концов:

#!/usr/bin/perl

$alphabet 二"abcdefghijklmnopqrstuvwxyz";

$alphabet =~ /(hi).*(stu)/;

print"Всесоответствияначалисьв$-[0]изакончилисьв$+[0]\п";

print"Первоесоответствиеначалосьв$-[1]изакончилосьв$+[1]\п";

print"Второесоответствиеначалосьв$-[2]изакончилосьв$+[2]\п";

Если в действительности требуется найти совпадениеслитеральным симво

лом скобок, а не интерпретировать его как метасимвол, поставьте перед ним обратную косую черту:

/\(е.д., ,*?\)/

Это соответствует примеру в скобках (т. е. данному утверждению). Но поскольку точка является групповым символом, это соответствует и любому утверждению в скобках с первой буквой е и третьей буквой g (т. е. и этому утверждению).

Кластеризация

Голые скобки и группируют, и захватывают. Но иногда нам требуется не это. Иногда надо просто сгруппировать части шаблона, не создавая ссылки на найденный текст. Можно использовать расширенную форму скобок для подавления захвата: обозначение (?: PATTERN) кластеризует без захвата.

Есть по крайней мере три причины, по которым может потребоваться кластеризация без захвата:

Для квантифицирования чего-либо.

Чтобы ограничить область видимости внутреннего чередования; например, шаблон /^cat |cow|dog$/ должен стать /Л(? :cat |cow|dog)$/ , чтобы кошка (cat) не убежала с 八•

Чтобы ограничить область видимости модификатора шаблона конкретным подшаблоном, как, например, в /foo(?-i :Case_Matters)bar/i. (См. раздел «Замкнутые модификаторы шаблонов».)

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

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

В оставшейся части этой главы мы увидим много других расширений регулярных выражений, которые кластеризуют без захвата, а также делают что- то еще. Особенность расширения (? ".PATTERN) как раз в том, что оно ничего больше не делает. Поэтому высказывание:

@fields = split(/\b(?:a|b|c)\b/)

похоже на:

@fields 二 split(/\b(a|b|c)\b/)

но не возвращает ненужных полей. (Оператор split немного похож на m//g в том, что выдает лишние поля для всех строк, захваченных в шаблоне. Обычно split возвращает только то, с чем совпадений не найдено. Дополнительные сведения о split см. в главе 29.)

Замкнутые модификаторы шаблонов

Можно замкнуть (cloister) модификаторы /i, /т, /s и /х, ограничив их действие только частью шаблона, поместив их (без косой черты) между символами ? и :, образующими обозначение кластера. Если сказать:

/Harry (?i:s) Truman/

то это будет соответствовать обеим строкам, Harry S Truman" и "Harry s Truman", в то время как:

/Harry (?х: [A-Z] \.? \s )?T「uman/

соответствует Harry S Truman" и "Harry S. Truman", а также "Harry Truman", а шаблон:

/Harry (?ix: [A-Z] \.? \s )?Truman/

соответствует пяти строкам, соединяя в замыкании модификаторы /i и /х.

Можно вычитать модификаторы из замыканий с помощью знака «минус»:

/Harry (?x-i: [A-Z] \.? \s )?Truman/i

Это соответствует любому выделению заглавными буквами в имени, но если есть средний инициал, он должен быть заглавной буквой, поскольку действие /i, примененного ко всему шаблону, отменяется внутри замыкания.

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

/(?i)foo/# Эквивалентно /foo/i

/foo((?-i)bar)/i # "bar" должно быть в нижнем регистре

/foo((?x-i) bar)/ # Включает /х и отключает /i для "bar"

Обратите внимание, что во втором и третьем примерах создаются ссылки на возвращаемый текст. Если они не нужны, следует применить (?-i:bar) и(?x-i: bar), соответственно.

Установка модификаторов для части шаблона особенно полезна, когда необходимо, чтобы . соответствовала символам перевода строки в некоторой части шаблона, но не во всем шаблоне. Установка /s для всего шаблона для этих целей бесполезна.

Чередование

Внутри шаблона или подшаблона метасимвол | служит для задания набора возможностей, любая из которых считается соответствием. Например:

/Gandalf I Saruman|Radagast/

соответствует Gandalf или Saruman, или Radagast. Чередование простирается до ближайшей закрывающей скобки (осуществляющей захват или нет):

/prob|n|r|l|ate/ # Соответствует prob, n, г, 1 или ate

/pro(b|n|r|l)ate/ # Соответствует probate, pronate, prorate или prolate /рго(?:Ь|п|r|l)ate/ # Соответствует probate, pronate, prorate или prolate

Вторая и третья форма ищут одинаковые строки, но во второй форме переменный символ захватывается в $1, ав третьей - нет.

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

/(Sam|Samwise)/

переменная $1 никогда не получит значения Samwise, в какой бы строке ни производился поиск, поскольку всегда сначала будет найдено соответствие Sam. Осуществляя такой перекрывающийся поиск, ставьте более длинные альтернативы в начало шаблона.

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

'"Sam I am,' said Samwise" =~ /(Samwise|Sam)/; # $1 eq "Sam"

Однако можно принудительно вызвать просмотр справа налево, используя жадные квантификаторы, как обсуждалось ранее в разделе «Квантификаторы»:

'Sam I am, ' said Samwise" =~ /. *(Samwise|Sam)/; # $1 eq "Samwise"

Можно изменить порядок поиска слева направо (или справа налево) с помощью различных утверждений позиции, рассмотренных нами выше, таких как \G, с и $• Здесь мы привязываем шаблон к концу строки:

'"Sam I am,' said Samwise"二~ /(Samwise|Sam)$/; # $1 eq "Samwise"

В этом примере $ выносится за скобки чередования (поскольку у нас уже есть парочка скобок, после которых можно его поместить), но и в отсутствие скобок можно расставить утверждения перед некоторыми или всеми имеющимися альтернативами соответственно тому, какое соответствие для них нам требуется. В следующей маленькой программе выводятся все строки, начинающиеся с маркеров 一一DATA一一 или ―END―:

#!/usr/bin/perl

while (о) {

print if /с DATA Г END /;

}

Но будьте при этом осторожны. Помните, что первая и последняя альтернативы (перед первой | и вслед за последней) стремятся схватить все элементы регулярного выражения с той или с другой стороны вплоть до конца выражения, если только нет охватывающих скобок. Часто встречается такая ошибка:

/^catjdogjcowS/

когда в действительности имеется в виду:

/^(cat|dog|cow)$/

Первый шаблон хватает "cat" в начале строки или "dog" в любом месте, или "cow" в конце строки. Второй соответствует любой строке, состоящей только из "cat" или "dog", или "cow". Он также захватывает результат в $1, что может быть нам не нужно, тогда можно сказать:

/Лса1$Гс1од$Гсом$/

Ниже мы покажем другое решение.

Альтернатива может быть пустой и в этом случае она всегда соответствует.

/com(poundI)/;# Соответствует "compound" или "сот"

/com(pound(s|)I)/; # Соответствует "compounds", "compound" или "com"

Это похоже на использование квантификатора ?, который соответствует О или 1 раз:

/com(pound)?/; # Соответствует "compound" или "сот" /com(pound(s?))?/; # Соответствует "compounds", "compound" или "com" /com(pounds?)?/; # То же, но не использует $2

Однако есть одно отличие. Когда ? применяется к шаблону, осуществляющему захват в нумерованную переменную, эта переменная остается неопределенной, если в нее не попадает никакая строка. При использовании нумерованной переменной она тоже ложная, но определена, и в ней находится нулевая строка.

Управление процессом

Всякому хорошему менеджеру известно, что не следует чрезмерно опекать своих подчиненных. Нужно просто указать им, что требуется, и позволить самим определять, как лучше всего этого добиться. Аналогично, часто лучше всего представлять себе регулярное выражение как своего рода указание: «Вот что мне нужно; пойди и найди мне подходящую строку».

С другой стороны, лучшие менеджеры также разбираются в той работе, которую пытаются сделать их подчиненные. То же самое верно в отношении поиска по шаблону в Perl. Чем глубже мы понимаем, как Perl решает задачу поиска по некоторому шаблону, тем разумнее мы сможем использовать возможности Perl для поиска по шаблону.

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

Пусть Perl сделает дело

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

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

Аналогично, нужно управлять последовательностью команд, выполняемых Perl для принятия решения о том, какие шаблоны выполнять, а какие 一 пропустить. Регулярные выражения довольно сообразительны, но это сообразительность лошади. Если она видит сразу слишком много, ее внимание может рассеяться. Поэтому иногда нужно надевать на нее шоры. Вспомните приведенный ранее пример чередования:

/Gandalf I Saruman|Radagast/

Он работает так, как обещано, но не так хорошо, как могло бы быть, поскольку в каждой позиции строки ищет все имена, прежде чем переместиться к следующей позиции. Внимательные читатели «Властелина колец» вспомнят, что из трех названных магов Гэндальф упоминается значительно чаще, чем Саруман, а Саруман упоминается значительно чаще, чем Рада- гаст. Поэтому обычно для осуществления чередования логические операторы Perl более эффективны:

/Гэндальф/ 11 /Саруман/ 11 /Радагаст/

Это еще один способ преодолеть «левый уклон» машины регулярных выражений. При этом Сарумана мы ищем только тогда, когда не видно Гэндальфа. А Радагаста - только тогда, когда Сарумана тоже нет.

Это позволяет не только изменить порядок поиска объектов, но и (иногда) улучшить работу оптимизатора регулярных выражений. Обычно проще оптимизировать поиск отдельной строки, чем нескольких строк одновременно. Аналогично, поиск с привязкой тоже часто можно оптимизировать, если он не слишком сложен.

Не обязательно ограничивать управление последовательностью выполняемых команд только оператором | |. Часто можно осуществлять управление на уровне команд. Всегда следует подумать о том, чтобы сначала исключить общие случаи. Допустим, что вы пишете цикл для обработки файла конфигурации. Многие файлы конфигурации состоят, в основном, из комментариев. Часто лучше всего сразу выбросить комментарии и пустые строки, прежде чем приступать к интенсивной обработке, даже если эта интенсивная обработка выбрасывает комментарии и пустые строки по ходу дела:

while (<CONF>) { next if /%/; next if /1s*(#|$)/; chomp;

munchabunch($_);

}

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

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

warn warn warn warn warn warn warnwarn warn warn warn warn warn warnсодержит нецифры" if /\D/;содержит нецифры" if /\D/;не натуральное число" unlessне натуральное число" unlessне целое число" unless не целое число" unless не десятичное число" unless не десятичное число" unlessне целое число" unless не целое число" unless не десятичное число" unless не десятичное число" unless/\d+$/;/<?\d+$/;/7+-]?\d+$/;/<?\d+\.?\d*$/;/\d+$/;/<?\d+$/;/7+-]?\d+$/;/<?\d+\.?\d*$/;# отвергает -3# отвергает +3# rejects . 2# отвергает -3# отвергает +3# rejects . 2/、？(？：\d+(?:\.\d*)?|\.\d+)$/;/、？(？：\d+(?:\.\d*)?|\.\d+)$/;не число с плавающей точкой Сне число с плавающей точкой С

warn warn warn warn warn warn warn

warn warn warn warn warn warn warn

содержит нецифры" if /\D/;

содержит нецифры" if /\D/;

не натуральное число" unless

не натуральное число" unless

не целое число" unless не целое число" unless не десятичное число" unless не десятичное число" unless

не целое число" unless не целое число" unless не десятичное число" unless не десятичное число" unless

/\d+$/;

/<?\d+$/;

/7+-]?\d+$/;

/<?\d+\.?\d*$/;

/\d+$/;

/<?\d+$/;

/7+-]?\d+$/;

/<?\d+\.?\d*$/;

# отвергает -3

# отвергает +3

# rejects . 2

# отвергает -3

# отвергает +3

# rejects . 2

/、？(？：\d+(?:\.\d*)?|\.\d+)$/;

/、？(？：\d+(?:\.\d*)?|\.\d+)$/;

не число с плавающей точкой С

не число с плавающей точкой С

unless /7[+-]?)(?=\d|\.\d)\d*(\Ad*)?([Ee]([+-]?\d+))?$/;

Можно было бы надолго растянуть этот раздел, но, в действительности, такого рода вещам посвящена вся книга. По ходу изложения мы увидим многочисленные примеры взаимодействия кода Perl и поиска по шаблону. В частности, имеется в виду раздел «Программные шаблоны» далее в этой главе. (Конечно, можно сначала прочесть материал, прерывающий изложение.)

Интерполяция переменных

Применение механизмов Perl, управляющих последовательностью выполняемых команд, для управления поиском с использованием регулярных выражений имеет свои ограничения. Основная сложность в том, что это подход типа «все или ничего»; либо мы выполняем шаблон, либо нет. Иногда общие черты требуемого шаблона ясны, но желательно иметь возможность его параметризации. Такую возможность предоставляет интерполяция переменных, подобно тому, как параметризация подпрограммы позволяет в большей мере оказывать влияние на ее выполнение, чем просто решать, вызывать ее или нет. (Подробнее о подпрограммах рассказано в следующей главе.)

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

if ($num =~ /7-+]?\d+\.?\d*$/) { ... }

Но наши намерения становятся более очевидными, если записать так:

$sign 二'[-+]?';

$digits = '\d+';

$decimal = '\.?';

$more_digits = '\d*';

$number = "$sign$digits$decimal$more_digits";

if ($num =~ /c$numbe「$/o) { ... }

Мы еще поговорим о таком использовании интерполяции в разделе «Генерируемые шаблоны» далее в этой главе. Просто отметим, что при помощи

модификатора /о мы подавили повторную компиляцию шаблона, поскольку предполагаем, что $numbe「не будет изменять свое значение во время выполнения программы.

Другой изящный прием состоит в том, чтобы вывернуть проверки «наизнанку» и задать переменную строку для поиска по шаблону в наборе известных заранее строк:

chomp($answer = <STDIN>);

print "Action print "Action print "Action print "Action print "Actionprint "Action print "Action print "Action print "Action print "Actionis send\n" } is stop\n" } is abort\n" } is list\n" } is edit\n" }is send\n" } is stop\n" } is abort\n" } is list\n" } is edit\n" }if (“SEND” /AQ$answer/i) { elsif ("STOP" =~ /AQ$answer/i) { elsif ("ABORT" =~ /AQ$answer/i) { elsif ("LIST" /AQ$answer/i) { elsif ("EDIT" — /AQ$answer/i) {

print "Action print "Action print "Action print "Action print "Action

print "Action print "Action print "Action print "Action print "Action

is send\n" } is stop\n" } is abort\n" } is list\n" } is edit\n" }

is send\n" } is stop\n" } is abort\n" } is list\n" } is edit\n" }

Этот код позволяет нам выполнять действие «send», вводя любую строку из S, SE, SEN или SEND (произвольно чередуя верхний и нижний регистры). Для действия «stop» нужно ввести, по крайней мере, ST (или St, или sT, или st).

Когда встречается обратная косая черта

Рассматривая интерполяцию строк в двойных кавычках, мы обычно имеем в виду интерполяцию переменных и обратной косой черты. Но, как уже говорилось, регулярные выражения обрабатываются за два прохода, и на проходе интерполяции интерпретация обратной косой черты, по большей части, откладывается для обработки анализатором регулярных выражений (который мы обсудим ниже). Обычно мы не замечаем разницы, поскольку Perl берет на себя труд ее скрыть. (Одной из последовательностей, которая очевидным образом ведет себя по-разному, является метазнак \Ь, который становится утверждением границы слова - во всяком случае, вне классов символов. Внутри класса символов, где утверждения не имеют смысла, он получает свое обычное значение символа возврата.)

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

($СО11, $С012)二 /(.*?) \t+ (.*?)/х;

Если бы Perl не откладывал интерпретацию \t до анализатора регулярных выражений, то \t обратился бы в пробельный символ, который анализатор регулярных выражений и проигнорировал бы из-за модификатора /х. Но Perl не настолько подл или коварен.

Однако можно перехитрить самого себя. Предположим, что мы выделили разделитель колонок таким способом:

$colsep = "\t+";# (двойные кавычки)

($со11, $со12) = /(.*?) $colsep (.*?)/х;

Ну вот мы все и испортили, потому что \t превратится в действительный символ табуляции, прежде чем попадет на анализатор регулярных выраже-

ний, который будет думать, что мы сказали /(. *?)+(. *?)/, после того как выбросит пробельные символы. Чтобы исправить положение, не указывайте /х или используйте одинарные кавычки. Еще лучше, обратитесь к qr//. (См. следующий раздел.)

Единственными escape-последовательностями в двойных кавычках, обрабатываемыми в этом качестве, являются шесть последовательностей трансляции: \U, \u, \L, \1, \Q и \Е. Если бы мы посмотрели, как устроен компилятор регулярных выражений Perl, то нашли бы в нем код для обработки таких escape-последовательностей, как \t для символа табуляции, \п для символа перевода строки и т. д. Но кода для обработки этих шести escape-последовательностей трансляции мы бы не нашли. (Мы перечислили их в табл. 5.7 только потому, что многие рассчитывают найти их там.) Если каким-то образом нам удастся протащить их в шаблон, не проведя сначала через вычисление в двойных кавычках, они не будут распознаны.

Как могут они прокрасться? Можно подавить интерполяцию путем использования одиночных кавычек в качестве ограничителя шаблона. В т'...', qr'... ' и s'' одинарные кавычки подавляют интерполяцию переменных и обработку escape-последовательностей, как если бы они находились в строках, заключенных в одинарные кавычки. Если сказать m'\ufrodo', то бедняга frodo (заглавными буквами) найден не будет. Однако, поскольку «обычные» символы обратной косой черты во всяком случае не обрабатываются на этом уровне, m' \t\d' все же соответствует действительному символу табуляции, за которым следует цифра.

Другим способом преодоления интерполяции служит сама интерполяция. Если сказать:

$var 二'\U*;

/${var}frodo/;

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

$hobbit = 'Frodo';

$var 二'$hobbit';# (одинарные кавычки)

/$var/;# означает m'$hobbit', а не m'Frodo'.

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

#!/usr/bin/perl

$pattern = shift;

while (<>) { print if /$pattern/o;

}

Если назвать эту программу pgrep и вызвать ее так:

% pgrep ‘\t\cT *.с

то мы обнаружим, что она выводит все строчки исходного кода на С, в которых за символом табуляции следует цифра. Нам не пришлось делать что-либо особенное, чтобы заставить Perl понять, что \t означает табуляцию. Если бы шаблоны Perl были просто интерполируемыми строками в двойных кавычках, нам бы пришлось; к счастью, они такими не являются. Они распознаются непосредственно анализатором регулярных выражений.

В действительности программа grep имеет ключ -i, который отключает поиск с учетом регистра. Этот ключ не нужно добавлять к вашей программе pgrep; она и так может обрабатывать его без модификации. Нужно лишь передать ей несколько более замысловатый шаблон со встроенным модификатором /i:

% pgrep f(?i)ring' LotR*.pod

Эта команда находит «Ring», «ring», «RING» и т. д. Эта функция не очень заметна в литеральных шаблонах, поскольку всегда можно просто написать /ring/i. Но для шаблонов, передаваемых в командной строке, в формах поиска в Интернете или встроенных в файлы конфигурации это может быть спасением. (Если говорить о кольцах.)

Оператор кавычек регулярных выражений qr//

Переменные, интерполирующиеся в шаблоны, делают это на этапе выполнения, а не компиляции. Это замедляет выполнение, поскольку Perl должен проверять, не изменил ли пользователь содержимое переменной; если да, то перекомпилирует регулярное выражение. Как указывалось в разделе «Операторы поиска по шаблону», если мы обещаем не изменять шаблон, то можем использовать опцию /о, чтобы интерполировать и компилировать только один раз:

print if /$pattern/o;

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

foreach $item (@data) {

fo「each $pat (@patterns) { if ($item /$pat/) { ... }

}

Нельзя написать /$pat/o, поскольку значение $pat изменяется при каждом прохождении внутреннего цикла.

Решением является оператор q「/PATTERN/ieusx, который заключает в кавычки и компилирует как регулярное выражение передаваемый ему шаблон PATTERN. PATTERN интерполируется таким же образом, как в е/PATTERN/. Если в качестве ограничителя используется одинарная кавычка ', то интерполяция переменных (и шести escape-последовательностей трансляции) не производится. Оператор возвращает значение Perl, которое можно использовать вместо эквивалентного литерала в соответствующем поиске по шаблону или подстановке. Например,

$regex = qr/my.STRING/is; s/$regex/something else/;

эквивалентно:

s/my.STRING/something else/is;

Поэтому в приведенной выше задаче с вложением цикла обработайте предварительно свой шаблон в отдельном цикле:

©regexes =();

foreach $pat (©patterns) { push @regexes, qr/$pat/;

}

Или разом с помощью оператора Perl map:

©regexes = map { qr/$_/ } ©patterns;

А затем измените цикл, чтобы он использовал прекомпилированные регулярные выражения:

foreach $item (@data) { foreach $re (©regexes) { if ($item =~ /$ге/) { ... } }

}

Теперь при запуске поиска Perl не должен будет создавать компилированное регулярное выражение при каждой проверке if, потому что он видит, что оно у него уже есть.

Результат q г// можно даже интерполировать в более крупный поиск, как если бы он был простой строкой:

$regex = qr/$pattern/;

$string =~ /foo${regex}bar/; # интерполировать в более крупный шаблон

На этот раз Perl перекомпилирует шаблон, но всегда можно связать вместе несколько операторов qr//.

Это работает, потому что оператор q г// возвращает объект особого типа, в котором перегружена операция превращения в строку, как это описано в главе 13 «Перегрузка». Если вывести возвращаемое значение, то можно увидеть эквивалентную строку:

$re = qr/my.STRING/is;

print $re; # выводит (?si-xm:my.STRING)

Модификаторы /s и /1 включены в шаблоне, потому что они были переданы q「//・ Модификаторы /х и /т, однако, отключены, потому что не были переданы.

Всякий раз, интерполируя в шаблон строки неизвестного происхождения, следует быть готовым к обработке исключительных ситуаций, возбуждаемых компилятором регулярных выражений, если кто-то подбросил вам строку с дикими зверюшками:

$re = qr/$pat/is; # может убежать и съесть вас $re = eval { qr/$pat/is } || warn ... # попалась в наружную клетку

Подробнее об операторе eval см. главу 29.

Компилятор регулярных выражений

После того как интерполирующий проход сделает со строкой свое дело, наконец-то возможность разобраться с ней предоставляется анализатору регулярных выражений. Фактически в этом месте может возникнуть не очень много неприятностей, если только нет путаницы в скобках и не используются ничего не значащие последовательности метасимволов. Анализатор осуществляет рекурсивно-нисходящий анализ регулярного выражения, и если разбор произведен, оно превращается в формат, пригодный для интерпретации машиной регулярных выражений (см. следующий раздел). Самое интересное из происходящего в анализаторе 一 это оптимизация регулярного выражения для максимально быстрого его выполнения. Эту часть мы излагать не будем. Это профессиональный секрет. (Слухи о том, что, глядя на код, обрабатывающий регулярные выражения, можно сойти с ума, сильно преувеличены. Как мы надеемся.)

Но можно поинтересоваться, что анализатор думает о нашем регулярном выражении, и если вежливо его об этом спросить, он ответит. Сказав use re "debug", можно увидеть, как анализатор регулярных выражений обрабатывает шаблон. (Те же данные можно получить, задав ключ командной строки -Dr, которым можно пользоваться, если при установке Perl вы компилировали его с флагом -DDEBUGGING.)

#!/usr/bin/perl use re "debug";

"Smeagol" =~ /"Sm(.*)g[aeiou]l$/;

Ниже приведен вывод. Как можно видеть, перед выполнением Perl компилирует регулярное выражение и назначает смысл компонентам шаблона: BOL для начала строки () REG_ANY для точки и т. д.:

Compiling REx '^Sm(.*)g[aeiou]l$' size 24 first at 2 rarest char 1 at 0 rarest char S at 0

B0L(2)

EXACT <Sm>(4)

0PEN1(6)

STAR(8)

REG_ANY(O)

CLOSEI(IO)

EXACT <g>(12)

ANY0F[aeiou](21)

EXACT <1>(23)

EQL(24)

END(O)

anchored 'Sm' at 0 floating 'l'$ at 4..2147483647 (checking anchored) anchored(BOL) minlen 5

Omitting $' $& $' support.

Некоторые строки содержат выводы, сделанные оптимизатором регулярных выражений. Ему известно, что строка должна начинаться с "Sm", и потому нет оснований для обычного просмотра слева направо. Ему известно, что строка должна оканчиваться на "1", поэтому иные строки он без промедления отвергает. Ему известно, что строка должна быть не короче пяти символов, поэтому более короткую строку он игнорирует с лету. Ему также известно, какой символ самый редкий в каждой константной строке, что иногда помогает при поиске в «изученных» строках. (См. study в главе 29.)

Затем производится трассировка выполнения поиска по шаблону:

EXECUTING...

Guessing start of match, REx '^Sm(.*)g[aeiou]l$' against 'Smeagol'...

Guessed: match at offset 0

Matching REx '^SmC.*)g[aeiou]l$' against 'Smeagol Setting an EVAL scope, savestack=3

0

<> <Smeagol>

丨1

BOL

0

<> <Smeagol>

1 2

EXACT <Sm>

2

<Sm> <eagol>

1 4

0PEN1

2

<Sm> <eagol>

1 6

STAR

REG.

.ANY can match 5 times out of 32767.

Setting an EVAL scope,

savestack=3

7

<Smeagol> <>

1 8

:CL0SE1

7

<Smeagol> <>

1 10

:EXACT <g>

failed...

6

<Smeago> <1>

1 8:

:CL0SE1

6

<Smeago> <1>

1 10

:EXACT <g>

failed...

5 <Smeag> <ol>

1 8;

:CLOS臼

5 <Smeag> <ol>

1 10

:EXACT <g>

failed...

4 <Smea> <gol>

I 8

:CL0SE1

4 <Smea> <gol>

I io

:EXACT <g>

5 <Smeag> <ol>

1 12

:ANYOF[aeiou]

6 <Smeago> <1>

I 21

:EXACT <1>

7 <Smeagol> <>

I 23

:EOL

7 <Smeagol> <>

I 24

END

Match successful!

Freeing REx: '^Sm(.*)g[aeiou]l$

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

Маленькая машинка, которая /(не) может?/

А теперь мы хотим рассказать сказку о маленьком Регексе - машине регулярных выражений, которая говорит: «Думаю, что смогу. Думаю, что смогу. Думаю, что смогу».

В этом разделе мы излагаем правила, которыми руководствуется машина регулярных выражений в Perl для поиска шаблона в строке. Машина регулярных выражений очень настойчива и трудолюбива. Вполне может оказаться, что она все еще работает, когда мы думаем, что она уже закончила работу. Машина регулярных выражений не сдастся, пока не будет полностью уверена, что найти соответствие между шаблоном и строкой невозможно. Приведенные ниже Правила объясняют, как машина регулярных выражений «думает, что сможет» как можно дольше, пока не будет знать, может она или нет. Проблема для нашей машины регулярных выражений в том, что ее задача не решается просто грубой силой. Она должна произвести поиск в потенциально очень сложном пространстве возможностей, следя при этом за тем, где она уже была, а где еще нет.

Машина регулярных выражений использует для поиска совпадения недетерминированный конечный автомат (НДКА). Это означает, что она следит за тем, что она опробовала, а что - нет, и если что-то не клеится, она возвращается и пробует что-то еще. Это известно как перебор с возвратом (backtracking). Машина регулярных выражений может перепробовать миллион подшаблонов в каком-либо месте, затем бросить их все, вернуться назад к некоторому варианту в начале и снова перебрать миллион подшаблонов в другой точке. Машина регулярных выражений не слишком умна, просто настойчива и дотошна. Если вы достаточно хитры, то дадите машине регулярных выражений эффективный шаблон, который не заставит ее делать много дурацких отступлений.

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

Правило 1

Машина пытается найти совпадение в строке возможно левее, так чтобы регулярное выражение в целом находило соответствие согласно Правилу 2.

Машина начинает работу прямо перед первым символом и пытается найти соответствие всему шаблону с этой точки. Весь шаблон соответствует тогда и только тогда, когда машина достигает конца шаблона раньше, чем она соскочит с конца строки. Если совпадение найдено, она сразу прекращает работу; продолжать поиск «более удачного» совпадения она не станет, даже если шаблон может быть приложен многими различными способами.

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

В строке из п символов фактически имеется п + 1 позиция для поиска соответствия. Дело в том, что начало и конец соответствия находятся между символами строки. Это правило иногда удивляет тех, кто пишет шаблон типа /х*/, который может соответствовать нулю или более символов "х". Если применить этот шаблон к строке "fox", он не найдет "х". Вместо этого он немедленно найдет совпадение с нулевой строкой перед "f" и больше ничего искать не станет. Для того чтобы найти один или более символов х, нужно использовать шаблон /х+/. О квантификаторах читайте в Правиле 5.

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

Правило 2

Когда машина обнаруживает набор альтернатив (разделяемых символами I) - либо на верхнем уровне, либо на текущем уровне кластера, - она опробует их слева направо, останавливаясь на первом успешном совпадении, позволяющем успешно завершить поиск шаблона в целом.

Набор альтернатив соответствует строке, если соответствует какая-либо из альтернатив согласно Правилу 3. Если ни одна из альтернатив не соответствует, происходит возвращение к Правилу, вызвавшему данное Правило, которым обычно является Правило 1, но может также быть Правило 4 или 6, если мы находимся внутри кластера. Это правило ищет новую позицию, в которой нужно применить Правило 2.

Если альтернатива только одна, то либо она соответствует, либо нет, и Правило 2 по-прежнему применимо. (Такой вещи, как нулевая альтернатива, не существует, поскольку с нулевой строкой всегда устанавливается соответствие.)

Правило 3

Данная конкретная альтернатива соответствует строке, если все элементы, перечисленные в альтернативе, последовательно находятся в строке согласно Правилам 4 и 5 (так, чтобы при этом удовлетворялось регулярное выражение в целом).

Элемент состоит из утверждения (о них говорится в Правиле 4) или квантифицированного атома (о них говорится в Правиле 5). Элементам, для которых есть несколько вариантов соответствия, дается «порядок клева» слева направо. Если нельзя найти соответствие элементам в заданном порядке, то машина отступает и выбирает следующую альтернативу согласно Правилу 2.

Элементы, которые должны быть последовательно найдены, не разделяются в регулярном выражении с помощью какого-либо синтаксиса: они просто располагаются рядом в том порядке, в котором должны совпасть в строке. Когда мы просим найти /^foo/, то фактически просим найти четыре элемента, располагающиеся один за другим. Первый является утверждением нулевой ширины, отыскиваемым согласно Правилу 4, а остальные три представляют собой обычные символы, которые должны совпасть сами с собой, один за другим, согласно Правилу 5.

Порядок слева направо означает, что в шаблоне:

/х*у*/

сначала х* выбирает один способ соответствия, а затем у* перепробует все свои способы. Если последнее завершается неудачей, то х* получает возможность выбрать свой второй вариант и заставить у* снова перепробовать все свои способы, и т. д. Находящиеся правее элементы «изменяются быстрее», если позаимствовать выражение из многомерных массивов.

Правило 4

Если утверждению нет соответствия в текущей позиции, машина возвращается к Правилу 3 и осуществляет опробование других вариантов выбора для элементов более высокого порядка.

Некоторые утверждения более замысловаты, чем другие. Perl поддерживает много расширений регулярных выражений, из которых какие-то являются утверждениями нулевой ширины. Например, положительное заглядывание вперед (?=. ..) и отрицательное заглядывание вперед (?!...) не соответствуют в действительности никаким символам, а просто утверждают, что регулярное выражение, представленное .. ., должно (или не должно) соответствовать в этой точке, если бы мы гипотетически попробовали его применить.1

Правило 5

Атом с квантификатором соответствует строке, только если сам атом соответствует некоторое число раз, допускаемое квантификатором. (Соответствие самого атома устанавливается согласно Правилу 6.)

Для разных квантификаторов требуется разное число совпадений, и для большинства из них допускается диапазон числа совпадений. Многократные совпадения должны происходить подряд, т. е. примыкать в строке друг к другу. У неквантифицированного атома предполагается наличие квантификатора, требующего ровно одного совпадения (т. е. /х/ означает то же самое, что /х{1}/). Если в текущей позиции нельзя найти совпадение с каким-либо допустимым количеством рассматриваемого атома, то машина возвращается к Правилу 3 и осуществляет опробование других вариантов выбора для элементов более высокого порядка.

Квантификаторами являются *,+,?,*?, +?,??и различные виды фигурных скобок. Если используется формат {COUNT}, то выбора нет, и атом должен совпадать ровно указанное число раз. В противном случае для числа совпадений атома имеется некоторый диапазон, и машина отслеживает все выбираемые варианты, чтобы при необходимости вернуться назад. Но тогда возникает вопрос о том, с которого из вариантов следует начать. Можно начать с максимального числа и затем снижать его, а можно - с минимального и увеличивать его.

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

На самом деле машина действительно пытается найти соответствие. Машина возвращается к Правилу 2, чтобы проверить подшаблон, а затем стирает все упоминания о том, какая часть строки была «проглочена», и возвращает только значение утверждения в виде успеха или неудачи. (Захваченные подстроки, однако, запоминаются.)

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

Если, например, мы говорим /. *foo/, то машина пытается найти максимальное число «любых» символов (представляемое точкой) вплоть до конца строки, прежде чем пытаться найти "foo"; и когда для "foo" там не находится соответствия (и не может найтись, потому что в конце строки для него недостаточно места), машина начинает отдавать по одному символу, пока не найдет "foo". Если "foo" встречается в строке более одного раза, машина остановится на последнем, поскольку в действительности это будет первое найденное при поиске с возвратом совпадение. Когда найден весь шаблон при некоторой определенной длине . *, машина знает, что может теперь отбросить все более короткие варианты для . * (те, которые она стала бы использовать, если бы текущее "foo" не подошло).

Помещая вопросительный знак вслед за жадным квантификатором, мы превращаем его в умеренный квантификатор, который для первой попытки выбирает самое маленькое количество. Поэтому, если сказать /. *?foo/, то . *? сначала пытается найти соответствие 0 символов, затем 1 символу, затем 2 и т. д., пока не сможет найти соответствие "foo". Вместо того чтобы отступать назад, машина, так сказать, отступает вперед и заканчивает, найдя в строке первое "foo", а не последнее.

Правило 6

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

Соответствие атомов определяется согласно следующим типам:

Регулярное выражение в круглых скобках, (...), соответствует тому же, чему соответствует регулярное выражение, представленное (...) согласно Правилу 2. Скобки действуют, как оператор кластеризации для квантифицирования. Скобки имеют также побочный эффект, захватывая найденную подстроку, которую можно потом использовать в ссылке на найденный текст (Ъackreference). Побочный эффект можно подавить, используя конструкцию (?:...), имеющую только кластеризующую семантику: она ничего не запоминает в $1, $2 и т. д.

Возможны и другие формы атомов в скобках (и утверждений) - см. оставшийся материал этой главы.

Точка соответствует любому символу, за исключением, возможно, символа перевода строки.

Список символов в квадратных скобках (класс символов) соответствует любому из символов, указанных в списке.

Буква с обратной косой чертой перед ней сответствует конкретному символу или символу из числа приведенных в табл. 5.7.

Любой другой символ с обратной косой чертой перед ним соответствует этому символу.

Любой символ, не упомянутый выше, соответствует самому себе.

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

Слова «машина регулярных выражений предпочитает самое левое соответствие» просто означают, что ручку начальной позиции она крутит медленнее всего. А поиск с возвратом означает, что нужно открутить назад ручку, которую мы только что крутили, и попытаться покрутить ручку, находящуюся выше в порядке старшинства, положение которой изменяется медленней.

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

$а = 'nobody';

$b = 'bodysnatcher';

if С'$а $b" =" /<\w+)(\w+) \2(\w+)$/) { print "$2 перекрывается в $1-$2-$3\п";

}

Программа выводит:

body перекрывается в no-body-snatcher

Можно предположить, что $1 из-за своей жадности схватит все слово "nobody". Так и происходит - поначалу. Но когда это сделано, не остается символов для переменной $2, которые необходимо поместить в нее из-за квантификатора +. Поэтому машина регулярных выражений отступает, и $1 неохотно отдает один символ для $2.

На этот раз успешно отыскивается пробел, но затем машина видит \2, которая представляет жалкую букву у. Следующий символ в строке не у, а Ь. Машине регулярных выражений приходится постоянно отступать и делать еще

несколько попыток, в конце концов, заставив $1 отдать «body» переменной $2. Habeas corpus,1 так сказать.

На самом деле, это не вполне срабатывает, когда само перекрытие является удвоением, как, например, в паре слов "rococo" и "cocoon". Приведенный выше алгоритм решит, что перекрывающейся строкой, $2, будет "со", а не "coco". Но нам не нужно "rocococoon"; нам нужно "гососооп". Это тот случай, когда вы можете оказаться умнее машины регулярных выражений. Добавив квантификатор минимального соответствия к части $1, получим значительно лучший шаблон /^(\w+?)(\w+) \2(\w+)$/, который делает как раз то, что нужно.

Значительно более подробное обсуждение достоинств и недостатков различных типов машин регулярных выражений можно найти в книге Джеффри Фридла (Jeffrey Friedl) «Mastering regular expressions». Машина регулярных выражений Perl работает очень хорошо при решении многих повседневных задач, которые требуется решать с помощью Perl, и даже не столь повседневных, если проявить к ней чуточку уважения и понимания.

Сложные шаблоны

Заглядывающие утверждения

Иногда требуется только глянуть украдкой. Есть четыре расширения регулярных выражений, которые позволяют сделать это и которые мы называем заглядывающими утверждениями (lookaround assertions), поскольку они позволяют выполнить своего рода разведку, не осуществляя настоящий поиск символов. Эти утверждения утверждают, что соответствие некоторому шаблону было бы (или не было) найдено, если бы мы попытались это сделать. Машина регулярных выражений организует это, осуществляя реальный поиск соответствия гипотетическому шаблону и делая потом вид, что оно не найдено (если найдено).

Когда машина регулярных выражений смотрит вперед из текущей позиции строки, мы называем это утверждением с заглядыванием вперед (lookahead assertion). Если она смотрит назад - утверждением с заглядыванием назад (lookbehind assertion). Шаблоны для заглядывания вперед могут быть любыми регулярными выражениями, но шаблоны для заглядывания назад могут иметь только фиксированную ширину, поскольку должны знать, откуда начинать свое гипотетическое соответствие.

Хотя все эти четыре расширения являются утверждениями нулевой ширины и потому не поглощают символов (по крайней мере, официально), на са-

Акт «Habeas Corpus», гарантирующий свободу личности, принятый в Англии в 1679 г., согласно которому судебная власть обязана по требованию заинтересованных лиц обеспечить доставку в суд всякого, кто подвергся заключению, для проверки законности ареста. - Примеч. ред.

мом деле можно захватывать в них строки, если добавить дополнительные уровни захватывающих скобок.

(?=PATTERN) (утвердительное заглядывание вперед)

Когда машина встречает (?=PATTERN), она заглядывает дальше в строку и убеждается, что в ней встречается шаблон PATTERN. Если вы вспомните, то в нашей программе для удаления дубликатов слов пришлось написать цикл, поскольку шаблон каждый раз съедал слишком много:

$_ = "Paris in THE THE THE THE spring.";

удалить слова, повторяющиеся дважды (и трижды (и четырежды...)) 1 while s/\b(\w+) \1\b/$1/gi;

Услышав слова «съел слишком много», всегда нужно подумать «утверждение с заглядыванием вперед». (Ну, почти всегда.) Заглядывая вперед, вместо того, чтобы проглотить второе слово, можно написать программу, удаляющую дубликаты за один проход, например:

s/ \b(\w+) \s (?= \1\b ) //gxi;

Конечно, это не совсем правильно, поскольку может исказить и допустимые фразы типа «The clothes you DON DON4 fit».

(?! PATTERN) (отрицательное заглядывание вперед)

Когда машина встречает (?二PATTERN), она заглядывает дальше в строку и убеждается, что шаблон PATTERN в ней не встречается. Чтобы исправить наш предшествующий пример, можно добавить отрицательное утверждение с заглядыванием вперед после положительного утверждения и исключить случай сокращенной формы:

s/ \b(\w+) \s (?= \1\b (?! '\w))//xgi;

Это \w в конце необходимо, чтобы избежать смешивания со словами в конце строк в одинарных кавычках. Можно пойти еще дальше, чтобы законные обороты типа «that that particular» наша программа не «исправляла». Мы добавим альтернативу для отрицательного заглядывания вперед, чтобы предотвратить исправление «that» (при этом демонстрируя, что для кластеризации альтернатив может использоваться любая пара круглых скобок):

s/ \b(\w+) \s (?= \1\b (?! '\w I \s particular))//gix;

Теперь мы знаем, что фраза «that that particular» является безопасной. К несчастью, Геттисбергская речь по-прежнему будет разрушена. Поэтому добавим еще одно исключение:

s/ \b(\w+) \s (?= \1\b (?! '\w I \s particular | \s nation))//igx;

Это уже начинает выходить из-под контроля. Поэтому составим Официальный список исключений и прибегнем к хитрому трюку с интерполяцией, чтобы переменная $" разделяла альтернативы символом |:

@thatthat = qw(particular nation);

local $"二'Г;

s/ \b(\w+) \s (?= \1\b (?! '\w I \s (?: @thatthat )))//xig;

(?<二PATTERN) (утвердительное заглядывание назад)

Когда машина обнаруживает (?<=PATTERN), она смотрит назад в строку и проверяет, что шаблон PATTERN уже встретился.

В нашем примере все еще остается проблема. Хотя он уже позволяет Честному Эйбу произносить такие слова, как «that that nation», он также допускает фразы типа «Paris, in the the nation of France». Мы можем добавить положительное утверждение с заглядыванием назад перед нашим списком исключений, чтобы гарантировать применение исключений @thatthat действительно только к «that that».

s/ \b(\w+) \s (?= \1\b (?! '\w I (?<= that) \s (?: @thatthat )))//ixg;

Да, это становится ужасно сложным, но потому наша глава и названа «Сложные шаблоны», в конце концов. Если кому-то необходимо сделать шаблон еще более сложным, чем это нам пока удалось, то разумное использование комментариев и q「// поможет ему сохранить разум. Или, по крайней мере, в большей степени сохранить.

(?<! PATTERN) (отрицательное заглядывание назад)

Обнаружив (?<! =PATTEHN), машина смотрит назад в строку и проверяет, что шаблон PATTERN не встретился.

На этот раз возьмем совсем простой пример. Простой вариант старого орфографического правила: «I перед Е, если только не после С». На Perl ошибки исправляются так:

s//(?<! c)ei/ie/g

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

Подшаблоны без возврата

Как описывалось в «Маленькая машинка, которая /(не) могла?/», машина регулярных выражений часто осуществляет перебор с возвратом при прохождении шаблона. Можно помешать машине регулярных выражений осуществлять возврат к некоторому набору вариантов путем создания подшаблона без возврата (nonbacktracking subpattern). Подшаблон без возврата выглядит как ("PATTERN) и работает так же, как простой «.PATTERN), но если PATTERN находит соответствие, то возврат к другим квантификаторам или альтернативам внутри подшаблона подавляется. (Следовательно, бес-

смысленно использовать его с шаблоном, не содержащим квантификаторов или альтернатив.) Единственный способ заставить его изменить свое решение -это возвратиться к чему-либо до подшаблона и снова войти в подшаблон слева.

Это все равно, что покупать автомобили. После некоторой торговли вы ставите ультиматум: «Вот мое последнее предложение; либо оно принимается, либо мы расходимся». Если оно не принимается, вы не начинаете снова торговаться. Вместо этого вы осуществляете возврат через входную дверь. Можно пойти к другому дилеру и опять начать торговаться. Вам позволено снова торговаться, но только потому, что вы снова вошли в шаблон без возврата в другом контексте.

Приверженцы Prolog или SNOBOL могут представить это себе как оператор отсечения или ловушки с видимостью (scoped cut or fence operator).

Посмотрите, как в "aaab" =~ /(? :a*)ab/ подшаблон а* сначала находит три а, а потом отдает одну из них, поскольку последняя а понадобится позже. Подгруппа жертвует частью того, что ей требуется, чтобы успешным оказался поиск в целом. (Что выглядит как позволение продавцу автомобиля уговорить вас отдать ему часть ваших денег, поскольку вы боитесь, что сделка не состоится.) Напротив, подшаблон в "aaab" =~ /(?>а*)аЬ/ никогда не отдаст того, что схватил, даже если такое его поведение приведет к неудаче поиска в целом.

Хотя (DPATTERN) полезен для изменения режима работы шаблона, он применяется в основном для того, чтобы ускорить получение неуспеха при некоторых видах поиска, когда известно, что он все равно окажется неудачным (если только не будет успешным сразу). Машине регулярных выражений может потребоваться весьма много времени, чтобы выйти на неуспех, особенно при вложенности квантификаторов. Следующий шаблон почти мгновенно приводит к успеху:

$_ = "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaab";

/а*а*а*а*а*а*а*а*а*а*а*а*а*а*а*а*а*а*а*а*а*а*а*а*а*а*а*а*а*а*а*а*[Ь]/;

Но проблема не в успехе. Проблема в неуспехе. Если удалить из строки последнюю букву Ь, то шаблон, возможно, будет выполняться долгие и долгие годы, прежде чем будет получен неуспех. Многие и многие тысячелетия. Фактически миллиарды и миллиарды лет. Внимательно посмотрев, мы обнаружим, что этот шаблон не может быть успешно найден, если в конце строки нет Ь, но оптимизатор регулярных выражений не настолько сообразителен (на момент написания книги), чтобы определить, что /[Ь]/ эквива-

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

/(?>а*а*а*а*а*а*а*а*а*а*а*а*а*а*а*а*а*а*а*а*а*а*а*а*а*а*а*а*а*а*а*а*)[Ь]/;

Возьмем более реалистический (надеемся) пример. Представим себе программу, которая должна считывать сразу абзац и показывать строки, имеющие продолжение, которые отмечаются обратной косой чертой в конце строки. Вот образец из Makefile для Perl, в котором действует данное соглашение по продолжению строк:

# Files to be built with variable substitution before miniperl # is available.

sh = Makefile.SH cflags.SH config_h.SH makeaperl.SH makedepend.SH \ makedir.SH myconfig.SH writemain.SH

Можно написать такую простую программу:

#!/usr/bin/perl -00р

while (/((•+)( (?<А\) \п •* )+ ) /дх) { print "GOT $.: $1\n\n";

}

Она работает правильно, но очень медленно. Дело в том, что машина регулярных выражений отступает от конца строки с шагом в один символ, сокращая то, что находится в $1. Это неумно. Если избавиться от ненужного захвата, то это не сильно поможет. Использование в качестве шаблона:

(•+(?：(?<=\\)\п.*)+)

несколько ускоряет работу, но незначительно. В такой ситуации существенно помогает шаблон без возврата. Шаблон:

((?>.+)(?:(?<=\\)\п.*)+)

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

С помощью (?>.. .) нельзя добиться такого успеха, которого нельзя добиться с помощью (?:...) и даже простого (...). Но если провал неизбежен, лучше пусть он произойдет скорее, чтобы можно было жить дальше.

Программные шаблоны

Большинство программ на Perl следует императивному (называемому также процедурным) стилю программирования, в котором ряд разрозненных команд подается в легко обозримом порядке: «Разогреть плиту, перемешать, глазировать, нагреть, остудить, подать пришельцам.» Иногда в эту смесь добавляют чуть-чуть функционального программирования («Возьмите немного больше глазури, чем, как вам кажется, нужно, приняв это во внимание, разровняйте рекурсивно») или сдабривают ее объектно-ориентированной

технологией («но, пожалуйста, придержите объекты анчоусов»). Часто встречается комбинация всех этих стилей.

Но машина регулярных выражений применяет для решения задач совершенно иной подход, являющийся скорее декларативным. Мы описываем цели на языке регулярных выражений, а машина регулярных выражений реализует ту логику, которая требуется для решения наших задач. Логические языки программирования (например, Prolog) не всегда получают такое же освещение, как остальные три стиля, но используются чаще, чем это может показаться. Perl нельзя было бы даже скомпилировать без make(l) или уасс(1), которые можно рассматривать если не как чисто декларативные языки, то, по крайней мере, как гибриды, в которых соединились императивное и логическое программирование.

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

Можно также передавать обычные выражения Perl в качестве заменяющей части оператора s〃/ с помощью модификатора /е. Это позволяет динамически генерировать строку замены путем выполнения фрагмента кода при обнаружении всякого совпадения шаблона.

Еще более изощренным приемом является вставка с помощью расширения (?{CODE }) в любое место в середине шаблона фрагментов кода, который будет выполняться каждый раз, когда машина регулярных выражений обнаруживает этот код, двигаясь вперед и назад в этом сложном танце поиска с возвратом.

Наконец, можно применить s///ee или (??{СООЕ }) для введения еще одного уровня косвенности: сами результаты выполнения этих фрагментов кода будут повторно вычисляться и использоваться, создавая фрагменты программы и шаблона на лету в нужный момент.

Генерируемые шаблоны

Уже было сказано, что программы, которые пишут программы, - самые счастливые программы на свете. В книге Джеффри Фридла «Mastering regular expressions» финальная демонстрация изобретательности показывает, как написать программу, создающую регулярное выражение для определения того, удовлетворяет ли строка стандарту RFC 822, т. е. содержится ли в ней совместимый со стандартами допустимый почтовый заголовок. Создаваемый ею шаблон имеет длину в несколько тысяч символов, и читать его примерно так же легко, как двоичный дамп памяти при аварии машины. Однако машина поиска по шаблону Perl этим не озабочена; компиляция

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

Это очень сложный пример. А выше мы привели очень простой пример такой же технологии, когда построили шаблон $numbe「из деталей (см. раздел «Интерполяция переменных»). Но чтобы продемонстрировать мощь этого программного подхода при создании шаблона, возьмем задачу средней сложности.

Допустим, необходимо выбрать все слова с определенной последовательностью гласных и согласных; например, «audio» и «eerie» удовлетворяют шаблону VVCVV (ГГСГГ). Хотя нетрудно описать, что считать гласной, а что - согласной, не хочется, чтобы каждый раз нужно было снова это вводить с клавиатуры. Даже в нашем простом случае VVCVV нужно ввести шаблон, который выглядит примерно так:

,'[aeiouy][aeiouy][cbdfghjklmnpqrstvwxzy][aeiouy][aeiouy]$

Программа для более широкого применения должна получить строку VVCVV и программным образом создать такой шаблон. Еще большая гибкость будет достигнута, если она сможет принять слово, например, audio, на входе, использовать его как шаблон для получения VVCVV, а из последнего уже получить вышеприведенный шаблон. Кажется сложным, но на практике это не так, поскольку вместо нас генерировать шаблон будет программа. Вот простая программа ситар, которая все это делает:

#!/usr/bin/perl

$vowels 二’aeiouy';

# исходное отображение для С (С) и V (Г)теперь для каждого типа буквполучить все буквы этого типаи отобразить букву обратно в тип# исходное отображение для С (С) и V (Г)теперь для каждого типа буквполучить все буквы этого типаи отобразить букву обратно в типдля каждой буквы в слове шаблонадобавить соответствующий класс символакомпилировать шаблонотладочная выдачавыбрать словарь по умолчаниюпройти через входные данные,выводя все совпадающие строкидля каждой буквы в слове шаблонадобавить соответствующий класс символакомпилировать шаблонотладочная выдачавыбрать словарь по умолчаниюпройти через входные данные,выводя все совпадающие строки$cons 二'cbdfghjklmnpqrstvwxzy';

# исходное отображение для С (С) и V (Г)

теперь для каждого типа букв

получить все буквы этого типа

и отобразить букву обратно в тип

# исходное отображение для С (С) и V (Г)

теперь для каждого типа букв

получить все буквы этого типа

и отобразить букву обратно в тип

для каждой буквы в слове шаблона

добавить соответствующий класс символа

компилировать шаблон

отладочная выдача

выбрать словарь по умолчанию

пройти через входные данные,

выводя все совпадающие строки

для каждой буквы в слове шаблона

добавить соответствующий класс символа

компилировать шаблон

отладочная выдача

выбрать словарь по умолчанию

пройти через входные данные,

выводя все совпадающие строки

%map = (C => $cons, V => $vowels);

for $class ($vowels, $cons) {

for (split //, $class) { $map{$_} .= $class;

} }

for $char (split //, shift) { Spat .= "[$map{$char}]";

}

$re 二 qr/^${pat}$/i;

print "REGEX is $re\n";

@ARGV 二('/usr/dict/words')

if -t && !@ARGV;

while (<>) {

print if /$ге/;

Все интересное содержится в переменной %тар. Ключами в ней служат все буквы алфавита, а соответствующими значениями - все буквы их типа. С и V тоже есть в ней, поэтому можно задать либо VVCVV, либо audio, и в любом случае получить eerie. Каждый символ аргумента, переданного программе, используется для извлечения нужного класса символов и добавления его в шаблон. Когда шаблон создан и скомпилирован с помощью qr//, поиск (даже длинного шаблона) происходит быстро. Вот что можно получить, если запустить эту программу с аргументом «fortuitously» (случайно, неожиданно):

% cvmap fortuitously /usr/dict/words

REGEX is (?i-xsm:"[cbdfghjklmnpqrstvwxzylEaeiouylEcbdfghjklmnpqrstvwxzylfcbd fghjklmnpqrstvwxzy][aeiouy][aeiouy][cbdfghjklmnpqrstvwxzy][aeiouy][aeiouy][c bdfghjklmnpqrstvwxzy][cbdfghjklmnpqrstvwxzy][aeiouycbdfghjklmnpqrstvwxzy]$) carriageable circuitously fortuitously languorously marriageable milquetoasts sesquiquarta sesquiquinta villainously

Глядя на это REGEX, можно убедиться в том, какого объема гнусного ввода с клавиатуры удалось избежать благодаря «ленивому» программированию, хотя и окольным путем.

Вычисления при подстановке

Когда модификатор /е («е» от «expression evaluation» - вычисление выражения) используется в выражении s/PATTERN/CODE/e, заменяющая часть интерпретируется не как строка в двойных кавычках, а как выражение Perl. Это похоже на встроенную команду do { CODE }. Несмотря на внешний вид строки это, в действительности, блок кода, компилируемый одновременно с остальной программой задолго до того, как подстановка будет производиться фактически.

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

s/(\d+)/$1 * 2/;# Заменяет"42" на "42 * 2"

s/(\d+)/$1 * 2/е;# Заменяет "42" на "84"

А вот как температура по Цельсию переводится в температуру по шкале Фаренгейта:

$_ = "Разогреть духовку до 233С.\п";

s/\b(\d+\.?\d*)C\b/int($1 * 1.8+32) . ”F“/e;# преобразование в 451F

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

% perl -pi -е 'sr(\d+)(?=: )/100 + $1/е' filename

Иногда нужно сделать несколько большее, чем просто использовать найденную строку в другом вычислении. Иногда нужно, чтобы строка и была вычислением, результат которого будет выступать в качестве заменяющего значения. Каждый дополнительный модификатор /е вслед за первым заключает код, который нужно выполнить, в eval. Следующие две строки выполняют одно и то же, но первую из них легче прочесть:

s/PATTERN/CODE/ee

s/PATTERN/eYaMCODE)/e

Этот прием подходит для замены упоминаний простых скалярных переменных на их значения:

s/(\$\w+)/$1/eeg;s/(\$\w+)/$1/eeg;# Интерполяция большинства значений скаляров

s/(\$\w+)/$1/eeg;

s/(\$\w+)/$1/eeg;

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

$_ 二"I have 4+19 dollars and 8/2 cents.\n"; s{(

\d+ \s*

#

найти целое число

[+*/-]

#

и арифметический оператор

\s* \d+

#

и второе целое число

)

}{ $1 }eegx;

#

затем разыменовать $1 и выполнить этот код

print;

"I have 23 dollars and 4 cents."

Как и для любых других eval STRING, перехватываются ошибки этапа компиляции (например, синтаксические) и исключительные ситуации этапа исполнения (например, деление на ноль). Если они возникают, то узнать, что произошло, можно из переменной $@ ($EVAL_ERROR).

Выполнение кода на этапе поиска

В большинстве программ, использующих регулярные выражения, логической последовательностью выполняемых команд руководит управляющая структура этапа исполнения окружающей программы. Мы пишем циклы if или while либо вызываем функции или методы, которые могут привести к вызову операции поиска по шаблону. Даже в s///e управление принадлежит оператору подстановки, а код, находящийся в замене, выполняется только при успехе поиска.

В случае применения подшаблонов, содержащих код, обычная связь между регулярным выражением и программным кодом инвертируется. Когда машина регулярных выражений применяет к нашему шаблону свои Правила на этапе поиска, она может наткнуться на расширение регулярного выражения вида (? {CODE}). Будучи запущен, этот подшаблон не выполняет поиск или «заглядывание». Это утверждение нулевой ширины, которое всегда «успешно» и выполняется только для получения побочных эффектов. Когда машине регулярных выражений по ходу выполнения шаблона нужно пройти подшаблон, содержащий код, она выполняет этот код.

"glyph" =~ /.+ (?{ print "hi" }) ./х; # Выводит"И1" два раза.

Когда машина регулярных выражений пытается сопоставить glyph с этим шаблоном, она сначала позволяет . + «съесть» все пять букв. Затем выводит hi. Когда она находит последнюю точку, все пять букв уже «съедены», поэтому она отступает к , + и заставляет его отдать одну из пяти букв. Затем она снова двигается вперед по шаблону, останавливаясь, чтобы еще раз вывести hi, перед тем как присвоить h конечной точке и успешно завершить поиск.

Фигурные скибки вокруг фрагмента CODE имеют целью напомнить, что это блок кода Perl, ведущий себя как блок в лексическом смысле. Это означает, что если в нем для объявления переменной с лексической областью видимости используется ту, то переменная является закрытой в этом блоке. Но если локализовать переменную с динамической областью видимости при помощи local, то результат может оказаться не таким, как мы ожидаем. Подшаблон (?{CODE }) создает неявную динамическую область видимости, которая действует в оставшейся части шаблона, пока либо поиск не окажется успешным, либо не произойдет возврат через подшаблон с кодом. Можно представлять себе это так, будто возврат из блока по достижении его конца не происходит. Вместо этого осуществляется невидимый рекурсивный вызов машины регулярных выражений для поиска соответствия оставшейся части шаблона. Лишь по завершении этого рекурсивного вызова происходит возврат из блока и снятие локализации с переменных.

В следующем примере мы инициализируем переменную $i значением О, включив в начало шаблона подшаблон, содержащий код. Затем мы находим

соответствие любому числу символов с помощью . * - но между . и * мы поместим еще один подшаблон с кодом, чтобы подсчитать, сколько раз . находит совпадение.

$_ 二'lothlorien';

# Установить $i в О# Обновить $i, даже после возврата# Вызывает возврат# Установить $i в О# Обновить $i, даже после возврата# Вызывает возвратт/ (?{ $i = 0 })

# Установить $i в О

# Обновить $i, даже после возврата

# Вызывает возврат

# Установить $i в О

# Обновить $i, даже после возврата

# Вызывает возврат

(•(?{ $i++ }))*

Iori

/х；

Машина регулярных выражений весело движется вперед, устанавливая $i в 0 и позволяя . * проглотить все 10 символов строки. Встретив в шаблоне литерал Iori, она отступает и отдает эти четыре символа из . *. После того как найдено соответствие, $i по-прежнему будет равна 10.

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

$_ = 'lothlorien';т/ (?{ $i=0})(.(?{ local $i = $i + 1; }) ” #Iori(?{ $result = $i })#/х;$_ = 'lothlorien';т/ (?{ $i=0})(.(?{ local $i = $i + 1; }) ” #Iori(?{ $result = $i })#/х;Обновление $i,не зависящее от возвратов.Копировать по нелокализованному адресу.Обновление $i,не зависящее от возвратов.Копировать по нелокализованному адресу.

$_ = 'lothlorien';

т/ (?{ $i=0})

(.(?{ local $i = $i + 1; }) ” #

Iori

(?{ $result = $i })#

/х;

$_ = 'lothlorien';

т/ (?{ $i=0})

(.(?{ local $i = $i + 1; }) ” #

Iori

(?{ $result = $i })#

/х;

Обновление $i,не зависящее от возвратов.

Копировать по нелокализованному адресу.

Обновление $i,не зависящее от возвратов.

Копировать по нелокализованному адресу.

Здесь посредством local мы гарантируем нахождение в $i числа символов, найденных . *, независимо от возвратов при поиске. $i будет забыта, когда закончится регулярное выражение, поэтому подшаблон с кодом (?{ $ result 二 =$i }) сохраняет этот счетчик в $result.

Специальная переменная $吓(описанная в главе 28) содержит результат последнего (?{CODE }), выполненного в составе успешного поиска.

Расширение (? {CODE }) можно использовать в качестве условия COND в (?(С0М?) IFTHUE\IFFALSE). При этом $吓 не устанавливается, а круглые скобки вокруг условного оператора можно опустить:

"glyph" /.+(?(?{ $foo{bar} gt "symbol" }).|signet)./；

Здесь мы проверяем, больше ли $foo{ba「}, чем symbol. Если да, то в шаблон включается . , а если нет, то signet. Несколько растянув эту команду, можно сделать ее более удобочитаемой:

"glyph" =~ т{

.+#несколько чегоугодно

(?(?{#если

$foo{ba「} gt "symbol"#это правда

})

# найти еще что угодно

|# иначе

signet# найти signet

)

.# и еще что угодно

}х；

Когда действует use re 'eval', регулярное выражение может содержать подшаблоны (? {CODE }), даже если в нем интерполируются переменные:

/(.*?) (?{length($1) < 3 && warn}) $suffix/; # Ошибка без use re 'eval'

Обычно это запрещено, поскольку представляет собой угрозу безопасности. Даже если приведенный шаблон невинен, поскольку невинен $suffix, анализатор регулярных выражений не может различить, какие части строки интерполировались, а какие нет, поэтому он просто запрещает все подшаблоны с кодом, если производилась интерполяция.

Если шаблон получен из меченых данных, то даже use re ' eval' не разрешит поиск по шаблону.

Когда действует use re ' taint' и к меченой строке применяется регулярное выражение, захваченные подшаблоны (в нумерованных переменных или списке значений, возвращаемом т// в списковом контексте) помечаются. Это удобно, если операции регулярного выражения над мечеными данными имеют целью не извлечение безопасных подстрок, а просто осуществление других преобразований. Дополнительные сведения о меченых данных см. в главе 23 «Защита данных». Для этой прагмы прекомпилированные регулярные выражения (обычно получаемые через q г//) не считаются интерполированными:

/foo${pat}bar/

Это допустимо, если $pat представляет собой прекомпилированное регулярное выражение, даже если $pat содержит подшаблоны с кодом (?{CODE }).

Выше мы привели небольшой фрагмент вывода use re 'debug'. Более упрощенное решение для отладки состоит в использовании подшаблонов с кодом (?{СООЕ }) для вывода соответствия, уже найденного в процессе поиска:

"abcdef" =~ / .+ (?{print "Пока найдено: $&\n"}) bcdef $/х;

В результате выводится:

Пока найдено: abcdef

Пока найдено: abcde

Пока найдено: abed

Пока найдено: abc

Пока найдено: ab

Пока найдено: а

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

Интерполяция шаблона на этапе поиска

Можно строить части шаблона, находясь в нем самом. Расширение (??{CODE }) делает возможным добавление кода, результатом выполнения которого является допустимый шаблон. Похоже на то, чтобы сказать /$patte「n/, за исключением того, что $pattern можно генерировать на этапе исполнения или, точнее, на этапе поиска. Например:

八w (??{ if ($threshold > 1) { "red" } else { "blue" } }) \d/x;

Это эквивалентно /\wred\d/, если $threshold больше 1, и /\wblue\d/ в противном случае.

В исполняемый код можно включать ссылки на найденный текст из только что найденных подстрок (даже если позже они окажутся ненайденными из- за возврата). Например, следующая команда находит все строки, которые одинаково читаются в прямом и обратном направлении (известные как палиндромы, фразы «с горбом посередине»):

/с (.+) .? (??{quotemeta reverse $1}) $/xi;

Нейтрализовать круглые скобки можно так:

$text =~ /( \(+ )(.*?)(??{'、)• х length $1 })/х;

Это соответствует строкам вида (shazam!) и (((shazam!))), помещая shazam! в $2. К несчастью, этот шаблон не обнаруживает, есть ли парные скобки в середине. Для этого требуется рекурсия.

Но очень хорошо, что можно создавать и рекурсивные шаблоны. Можно заставить скомпилированный шаблон, использующий ⑺{CODE }), ссылаться на себя самого. Рекурсивный поиск оказывается довольно нерегулярным. В любой книге по регулярным выражениям указывается, что стандартные регулярные выражения не могут правильно находить вложенные скобки. И это правильно. Правильно и то, что регулярные выражения в Perl не являются стандартными. Следующий шаблон находит набор вложенных скобок, сколь бы глубоко они ни были вложены:

$np = qr{

\(

(?：

(?>「()]+)# Нескобки без возврата

(??{ $пр })# Группировать с найденными скобками

)*

\)

}х；

Вот как можно с его помощью организовать поиск вызова функции:

$funpat - qr/\w+$np/;

'myfunfun(1,(2*(3+4)),5)' =~ /^$funpat$/; # Соответствует!

Условная интерполяция

Расширение регулярных выражений (?(CO/W?) IFTRUE\IFFALSE) аналогично оператору ?: в Perl. Если COND истинно, применяется шаблон IFTRUE; в противном случае - шаблон IFFALSE. Условие COND может быть ссылкой на найденный текст (выражаемой как «голое» целое число без \ или $), утверждением с заглядыванием или подшаблоном с кодом. (См. разделы «Утверждения с заглядыванием» и «Выполнение кода на этапе поиска» выше в этой главе.)

Если COND представляет собой целое число, оно рассматривается как ссылка на найденный текст. Рассмотрим пример:

#!/usr/bin/perl

$х 二'Perl является бесплатным.';

$у 二'ManagerWare стоит $99.95.';

foreach ($х, $у) {

/X\w+) (?:является| (стоит)) (?(2)(\$\d+) |\w+)/; # Либо (\$\d+), либо \w+ if ($3) {

print "$1 стоит денег.\n";# ManagerWare стоит денег.

} else {

print "$1 распространяется бесплатно.\n"; # Perl распространяется бесплатно.

} }

Здесь COND есть (2), что истинно, когда существует вторая ссылка на найденный текст. Если это так, то (\$\d+) включается в шаблон в этой точке (создавая ссылку на найденный текст $3); в противном случае используется \w+.

Если COND представляет собой утверждение с заглядыванием или подшаблоном, содержащим код, то определить, надо ли включать IFTHUE или IFFALSE, можно на основании истинности утверждения:

/[ATGC]+(?(?<=AA)G|C)$/;

Здесь в качестве COND применяется утверждение с заглядыванием назад, чтобы найти в ДНК последовательность, которая оканчивается на AAG или другую основную комбинацию и С.

Альтернатива | IFFALSEможет быть опущена. В этом случае шаблон 工FTRUE будет включен в шаблон, как обычно, если истинно COND, но если условие не истинно, машина регулярных выражений переместится к следующей части шаблона.

Определение собственных утверждений

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

В приведенном ниже примере мы задаем два преобразования, которые должны происходить, когда Perl обнаруживает шаблон. Во-первых, мы определим \tag таким образом, что когда он встречается в шаблоне, то автоматически транслируется в (?:<. *?>), что соответствует большинству тегов HTML и XML. Во-вторых, мы «переопределим» метазнак \w так, чтобы он работал только с буквами английского алфавита.

Мы определим пакет с именем Tagger, который укроет перегрузку от нашей основной программы. Сделав это, мы сможем сказать:

use Tagger;

$_ 二'<1>верблюд</1>';

print "Найден верблюд в тегах" if /\tag\w+\tag/;

Вот Tagger.pm, оформленный в виде модуля Perl (см. главу 11):

package Tagger； use overload;

sub import { overload::constant 'qr' => \&convert }

sub convert { my $re 二 shift; $re =~ s/ \\tag /<.*?>/xg; $re =~ s/ \\w/[A-Za-z]/xg;

return $re;

}

1；

Модуль Tagger получает шаблон непосредственно перед интерполяцией, поэтому обойти перегрузку можно, обойдя интерполяцию, например:

$re = '\tag\w+\tag';# Эта строка начинается с \t, символа табуляции

print if /$ге/;# Ищет символ табуляции, за которым следует "а"...

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

$ге 二’\tag\w+\tag';# Эта строка начинается с \t, символа табуляции

$re = Tagger::convert $re; # разыменовать \tag и \w

print if /$ге/;# $re становится <.*?>[A-Za-z]+<.*?>

Если вы все еще не поняли, что это за штуки sub в модуле Tagger, то скоро поймете, потому что этому посвящена вся следующая глава.

6

Подпрограммы

Как и многие другие языки, Perl предоставляет возможность создания подпрограмм, определяемых пользователем. Эти подпрограммы могут быть определены в любом месте основной программы, загружены из других файлов с помощью ключевых слов do, require или use либо сгенерированы на этапе исполнения с помощью eval. Можно даже загружать их на этапе исполнения с помощью механизма, описываемого в разделе «Автозагрузка» в главе 10 «Пакеты». Вызов подпрограмм может осуществляться косвенным образом посредством переменной, содержащей имя программы или ссылку на нее, либо через объект, позволяя последнему определить, какая подпрограмма в действительности должна быть вызвана. Можно создавать анонимные подпрограммы, доступ к которым осуществляется только через ссылки, и при желании использовать их для клонирования новых почти идентичных функций через замыкания (closures), описываемые в одноименном разделе главы 8 «Ссылки».

Синтаксис

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

sub NAME

sub NAME PROTO

sub NAME ATTRS

sub NAME PROTO ATTRS

Именованную подпрограмму можно объявить и определить, добавив блок BLOCK:

sub NAMEBLOCK

sub NAME PROTO BLOCK

sub NAME ATTRS BLOCK sub NAME PROTO ATTRS BLOCK

Для создания анонимной подпрограммы или замыкания надо опустить NAME:

subBLOCK

subPROTO BLOCK

subATTRS BLOCK

subPROTO ATTRS BLOCK

PROTO и ATTRS обозначают прототип и атрибуты; о том и другом будет рассказано в соответствующих разделах далее в этой главе. PROTO и ATTRS не столь важны: существенными частями являются NAME и BLOCK, даже если они отсутствуют.

Для форматов с отсутствующим NAME должен все же иметься какой-то способ вызова подпрограммы. Для этого нужно сохранить возвращаемое значение, потому что эта форма объявления sub не только компилируется на этапе компиляции, как можно было предполагать, но и создает возвращаемое значение этапа исполнения:

$sub「ef = sub BLOCK;

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

use MODULE qw(NAME1 NAME2 NAME3...);

Прямой вызов подпрограмм осуществляется так:

NAME(LIST)# & не обязателен, если есть скобки.

NAME LIST# Скобки не обязательны, если sub имеет объявление/

импортирована.

ШМЕШМЕПередает подпрограмме текущее значение @_

ШМЕ

ШМЕ

(и обходит прототип).

Для косвенного вызова подпрограмм (по имени или по ссылке) используется синтаксис:

&$subref (/.IS7) $subref->(LIST) &$subref&$subref (/.IS7) $subref->(LIST) &$subref& нельзя опускать при косвенном вызове

&$subref (/.IS7) $subref->(LIST) &$subref

&$subref (/.IS7) $subref->(LIST) &$subref

(если только не используется инфиксная запись).

Передает подпрограмме текущее значение @_.

Официальное имя подпрограммы содержит префикс &• Можно вызывать подпрограмму с указанием префикса, но обычно он не является обязательным, как и круглые скобки, если подпрограмма предварительно объявлена. Однако & не является необязательным, когда подпрограмме нужно просто указать имя, как при использовании в качестве аргумента функций defined или undef, либо при создании ссылки на именованную подпрограмму, как в $sub「ef = \&name. Нельзя опускать & и в тех случаях, когда осуществляется косвенный вызов подпрограммы в конструкциях &$sub「ef () или &{$sub「ef} ()• Однако в более удобном обозначении $sub「ef->() амперсанд не требуется. Дополнительные сведения о ссылках на подпрограммы см. в главе 8 «Ссылки».

Perl не требует какого-либо особого стиля заглавных букв в именах подпрограмм. Однако одно нестрого соблюдаемое соглашение состоит в том, что имена функций, неявно вызываемых системой этапа исполнения Perl (BEGIN, CHECK, INIT, END, AUTOLOAD, DESTROY и всех функций, указанных в главе 14 «Связанные переменные»), пишутся заглавными буквами, поэтому такого стиля, возможно, следует избегать. (Но подпрограммы, используемые для константных величин, обычно тоже пишутся заглавными буквами. Это нормально. Надеемся...)

Семантика

Пока вы не слишком устали от всего этого синтаксиса, просто запомните, что обычный способ определения простой подпрограммы выглядит примерно так:

sub razzle {

print "Ok, you've been razzled.\n";

}

а обычный способ ее вызова просто:

razzle();

В данном случае мы игнорировали входные данные (аргументы) и выходные (возвращаемые значения). Но действующая в Perl модель передачи данных в подпрограмму и из нее на самом деле очень проста: все параметры функции передаются как один плоский список скаляров; аналогично, множественные возвращаемые значения возвращаются в место вызова как один плоский список скаляров. Как и для любого списка, все массивы и хеши, передаваемые в этих списках, интерполируют свои значения в плоский список, утрачивая свою индивидуальность, но есть несколько способов обойти это, и часто весьма полезной оказывается автоматическая интерполяция списка. Как список параметров, так и список возвращаемых значений могут содержать сколь угодно много или сколь угодно мало скалярных элементов (хотя можно наложить ограничения на список параметров путем использования прототипов). В действительности архитектура Perl основывается на понятии вариадических (variadic) функций (таких, которые принимают любое

число аргументов), в отличие от С, куда они довольно неуклюже втиснуты, чтобы можно было вызывать print f(3).

Итак, собираясь создавать язык на основе идеи передачи переменного числа произвольных аргументов, следует подумать о том, как облегчить обработку этих произвольных списков аргументов. Любые аргументы, передаваемые в программу Perl, поступают в нее в виде массива @_. Если функция вызывается с двумя аргументами, то внутри функции они доступны как первые два элемента этого массива: $_[0] и $_[1]・ Поскольку @_ представляет собой обычный массив с необычным именем, с ним можно делать все то же, что обычно делают с массивом. Массив @_ является локальным, но его значения служат псевдонимами для реальных скалярных параметров. (Это называется семантикой передачи по ссылке.) Поэтому можно изменять фактические параметры, изменяя соответствующие элементы @_・(Однако это делается редко, потому что в Perl очень легко возвращать значения, которые представляют интерес.)

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

Приемы работы со списками параметров

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

sub maysetenv {

my ($key, $value)二 @_;

$ENV{$key}二 $value unless $ENV{$key};

}

Но от вас не требуется давать имена параметрам, в чем состоит весь смысл массива @_. Например, для определения максимума можно непосредственно пройти по массиву @_:

sub max {

my $max 二 shift(@_); for my $item (@_) {

$max = $item if $max < $item;

} return $max;

}

$bestday = max($mon,$tue,$wed, $thu, $f ri);

Либо можно заполнить сразу весь хеш:

sub configuration { my %options = @_; print "Максимально подробно.\n" if $options{VERBOSE} == 9;

}

configuration(PASSWORD => "xyzzy", VERBOSE => 9, SCORE => 0);

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

upcase_in($v1, $v2); # эта подпрограмма изменяет $v1 и $v2 sub upcase_in {

for (@_) { tr/a-z/A-Z/ }

}

Конечно, таким способом нельзя модифицировать константы. Если бы аргумент оказался скалярным литералом, например «хоббит», или скалярной переменной, доступной только для чтения, например $1, и вы попытались бы его изменить, Perl возбудил бы исключительную ситуацию (предположительно, фатальную; возможно, угрожающую вашей карьере). Например, следующий вызов не будет работать:

upcase_in("фредерик");

Было бы значительно безопаснее написать функцию upcase_in так, чтобы она возвращала копию своих параметров, а не изменяла их по месту:

($v3, $v4) = upcase($v1, $v2);

sub upcase {

my @parms = @_;

for (@parms) { tr/a-z/A-Z/ }

Проверить, осуществлен ли вызов в списковом контексте, return wantarray ? @parms : $parms[0];

}

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

@newlist = upcase(@list1, @list2);

@newlist 二 upcase( split /:/, $var );

Не соблазнитесь, однако, написать такое:

(@а, @Ь)二 upcase(@list1, @list2); # НЕВЕРНО

Почему так нельзя? Потому что, как и список входных параметров @_, список возвращаемых значений является плоским. В результате он запишет все свои значения в @а и очистит @Ь, записав туда нулевой список. Как этого избежать, см. далее в разделе «Передача ссылок».

Индикация ошибок

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

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

if ($something_went_awry) {

return if defined wantarray; # хорошо, не пустой контекст.

die "Да ты ??смотри на мою ошибку, сокет висячий!!!\п";

Вопросы областей видимости

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

&foo(1,2,3);# передача трех аргументов

foo(1,2,3);# то же самое

foo();# передача пустого списка

&foo();# то же самое

&foo; foo;&foo; foo;# foo() получает текущие аргументы, как foo(@_), но быстрее!

&foo; foo;

&foo; foo;

# то же, что foo(), если было объявление sub foo, иначе голое слово "foo"

Формат & не только делает необязательным список аргументов, но и отключает проверку прототипа для передаваемых аргументов. Отчасти это обусловлено историческими причинами, а отчасти сделано для того, чтобы было удобнее мошенничать, если вы хорошо понимаете, что делаете. См. раздел «Прототипы» далее в этой главе.

Переменные, к которым вы обращаетесь в функции, не определенные в ней как закрытые, не обязательно будут глобальными переменными: они подчиняются обычным правилам Perl для областей видимости блоков. Как объяснялось в разделе «Имена» главы 2 «Всякая всячина», это значит, что попытка разрешения их сначала предпринимается в окружающей лексической области (или областях) видимости, а затем в области видимости пакета. Поэтому с точки зрения подпрограммы все переменные ту из охватывающей области видимости вполне доступны.

Например, приведенная ниже функция bumpx имеет доступ к лексической переменной $х с областью видимости в файле, поскольку область видимости, в которой было объявление ту - сам файл - не была закрыта раньше, чем определена подпрограмма:

начало файла

ту $х 二 10; # объявление и инициализация переменной

sub bumpx { $х++ } # функция может видеть внешнюю лексическую переменную

Программисты на С и C++ представят себе, вероятно, $х как «файловую статическую» переменную. Она закрыта для функций в других файлах, но глобальна с точки зрения функций, определенных после объявления ту. Программисты на С, которые ищут в Perl то, что они назвали бы «статическими переменными» для файлов или функций, не находят в нем ключевого слова «static». Программисты на Perl обычно избегают этого слова, потому что статические системы мертвы и скучны, а история употребления этого слова слишком запутана.

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

Лексические переменные не исчезают при автоматической сборке мусора, когда происходит выход из их области видимости; они попадают в переработку только тогда, когда больше не используются, что значительно важнее. Чтобы создать закрытые переменные, которые не сбрасываются автоматически между обращениями к функции, заключите всю функцию в дополнительный блок, в который поместите также объявление ту и определение функции. Можно помещать в блок более одной функции, и тогда они получают совместный доступ к переменной, которая иначе была бы закрытой:

my $counter 二 0;

sub next_counter { return ++$counte「 } sub prev_counter { return --$counter } }

Как всегда, доступ к лексической переменной ограничен кодом в той же области лексической видимости. С другой стороны, имена двух функций доступны глобально (внутри пакета) и, поскольку они определены внутри области видимости $counte「, то могут обращаться к этой переменной, хотя никто больше делать этого не может.

Если функция загружена через require или use, то все может быть прекрасно. Если все происходит в основной программе, то нужно обеспечить, чтобы на этапе исполнения какое-либо присвоение переменной ту выполнялось достаточно рано. Для этого можно поместить весь блок перед основной программой, либо поместить все в блок BEGIN или INIT, чтобы гарантировать выполнение до запуска программы:

BEGIN {

my @scale = ('А' .. 'G');

my $note 二-1;

sub next_pitch { return $scale[ ($note += 1) %= @scale ] };

}

Блок BEGIN не оказывает воздействия на определение подпрограммы и на сохранение значений лексическими переменными, используемыми подпрограммой. Он нужен только для того, чтобы гарантировать инициализацию переменных до первого вызова подпрограммы. Дополнительные сведения об объявлении закрытых и глобальных переменных можно найти в описаниях ту и our, соответственно, в главе 29 «Функции». Конструкции BEGIN и INIT описываются в главе 8 «Компиляция».

Передача ссылок

Если требуется передать более одного массива в функцию или из нее, и вы хотите поддержать их целостность, нужно использовать механизм явной передачи по ссылке. Но раньше необходимо разобраться в деталях действия ссылок, описанных в главе 8 «Ссылки». В противном случае эта глава может оказаться не понятой вами. Однако вы всегда можете посмотреть картинки...

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

$total 二 sum ( \@а );

sub sum {

my ($aref) = @_;

my ($total)二 0;

foreach (@$a「ef) { $total +二 $_ }

return $total;

}

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

@tailings = popmany ( \@а, \@b, \@с, \@d );

sub popmany {

my @retlist =();

for my $aref (@_) {

push @retlist, pop @$aref;

} return ©retlist;

}

Вот как можно написать функцию, которая находит пересечение множеств, возвращая список ключей, имеющихся в каждом из переданных ей хешей:

@common = inter( \%foo, \%bar, \%joe );

sub inter {

my %seen;

for my $href (@_) {

while (my $k = each %$href ) { $seen{$k}++;

}

}

return grep { $seen{$_} == @_ } keys %seen;

}

Пока мы задействовали обычный механизм возврата списка. Что происходит, если требуется передать или возвратить хеш? Если хеш только один или вы не возражаете против того, чтобы они объединились в один, то сойдет и обычное соглашение по вызовам, хотя обходится оно дороговато.

Как мы уже отмечали, беда случается при такой записи:

(@а, @b) = func(@c, @d);

или такой:

(%а, %b) = func(%c, %d);

Этот синтаксис не работает. Он просто устанавливает @а или %а и очищает @Ь или %Ь. Кроме того, эта функция не получает в качестве аргументов два отдельных массива или хеша: она получает, как обычно, один длинный список в @_.

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

($aref, $bref) = func(\@c, \@d); print "@$aref больше, чем @$bref\n"; sub func {

my ($cref, $dref) = @_;

if (@$cref > @$dref) { return ($cref, $dref);

} else { return ($dref, $cref);

}

}

О том, как передавать в функции и из них дескрипторы файлов или каталогов, см・ разделы «Ссылки на дескрипторы файлов» и «Ссылки на таблицы символов» главы 8.

Прототипы

Perl позволяет пользователю определять свои функции так, чтобы они вызывались как встроенные функции Perl. Рассмотрим push(@array, $item), в которой подразумевается, что она получит ссылку на @аггау, а не список значений, содержащихся в @аггау, чтобы можно было модифицировать массив. Прототипы дают возможность определять подпрограммы так, чтобы они принимали аргументы как многие встроенные функции, т. е. с определенными ограничениями на число и типы аргументов. Мы называем их «прототипы», но они действуют, скорее, как автоматические шаблоны для контекста вызова, чем как то, что называют прототипами программисты на С или Java. С помощью этих шаблонов Perl автоматически добавляет неявные символы обратной косой черты или вызовы scalar и все прочее, благодаря чему полученный результат должен выглядеть согласно шаблону. Например, если объявить:

sub mypush (\@@);

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

Поскольку прототипы принимаются во внимание только на этапе компиляции, естественно, следует, что они не оказывают влияния на ссылки на подпрограммы типа \&foo или косвенный вызов подпрограмм типа &{$sub「ef} или $sub「ef->()• На вызовы методов прототипы также не оказывают влияния. Дело в том, что фактически вызываемая функция не определена на этапе компиляции и зависит от наследования, которое определяется в Perl динамически.

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

Объявление

Вызов

sub mylink ($$) sub myreverse (@) sub myjoin ($@) sub mypop (\@) sub mysplice (\@$$@) sub mykeys (\%) sub mypipe (**) sub myindex ($$;$)

mylink $old, $new myreverse $a,$b,$c myjoin ”： \$a,$b,$c mypop @array

mysplice @аггау,@аггау,0,@pushme

mykeys %{$hashref}

mypipe READHANDLE, WRITEHANDLE myindex &getstring, "substr" myindex &getstring, "substr", $start

sub mysyswrite (*$;$$)

mysyswrite OUTF, $buf

mysyswrite OUTF, $buf, length($buf)-$off, $off

sub myopen (*;$@)

myopen HANDLE

myopen HANDLE, $name

myopen HANDLE, "-|", @cmd

sub mygrep (&@) sub myrand ($) sub mytime ()

mygrep { /foo/ } $a,$b,$c

myrand 42

mytime

Каждый символ прототипа с обратной косой чертой перед ним (в скобках в левой колонке) представляет фактический аргумент (пример которого приведен в правой колонке), который обязательно должен начинаться с этого символа. Как первый аргумент keys должен начинаться с %, так и первый аргумент mykeys должен начинаться с %.

Точка с запятой отделяет обязательные аргументы от необязательных. (Перед @ или % ее употребление излишне, т. к. списки могут быть нулевыми.) Символы прототипа без обратной косой черты имеют особый смысл. Каждый символ @ или % без обратной косой черты съедает все остальные фактические аргументы и устанавливает списковый контекст. (Это эквивалентно LIST в описании синтаксиса.) Для аргумента, представленного $, устанавливается списковый контекст. Символ & требует ссылки на именованную или анонимную подпрограмму.

Символ * позволяет подпрограмме принимать в этом месте все, что было бы принято встроенной функцией как дескриптор файла: голое имя, константа, скалярное выражение, typeglob или ссылка на typeglob. Это значение будет доступно в подпрограмме как простой скаляр или (в двух последних слу-

чаях) как ссылка на typeglob. Для того чтобы такие аргументы всегда преобразовывались в ссылки на typeglob, используйте Symbol: :qualify_to_ref следующим образом:

use Symbol 'qualify_to_ref';

sub foo (*) { my $fh 二 qualify_to_ref(shift, caller);

}

Обратите внимание, что последние три примера в вышеприведенной таблице анализатор обрабатывает особым образом, mygrep анализируется как настоящий списковый оператор, myrand - как настоящий унарный оператор с тем же унарным приоритетом, что и у rand, a mytime - как настоящая функция без аргументов, типа time.

Это значит, что, сказав:

mytime +2;

вы получите mytime() + 2, а не mytime(2), как было бы, если бы она анализировалась без прототипа или с унарным прототипом.

Пример myg rep показывает также, что & обрабатывается особым образом, когда является первым аргументом. Обычно прототип с & требует аргумента типа \&foo или sub{}. Однако, если это первый аргумент, можно пропустить sub в анонимной подпрограмме и просто передать голый блок на место «косвенного объекта» (без последующей запятой). Поэтому изящество прототипа & состоит в том, что с его помощью можно создавать новый синтаксис при условии, что & находится в первой позиции:

sub try (&$) {

my ($try, $catch)二 @_;

eval { &$try };

if ($@) {

local $_ = $@; &$catch;

}

}

sub catch (&) { $_[0] }

try {

die "phooey";

}# не конец вызова функции!

catch { /phooey/ and print "unphooey\n";

}；

В результате выводится unphooey. В этом примере try вызывается с двумя аргументами: анонимной функцией {die "phooey";} и значением, возвращаемым функцией catch, которое в данном случае является ее первым аргументом 一 всем блоком другой анонимной функции. В try вызывается первая

функция-аргумент, являющаяся защищенной в блоке eval, который перехватит ошибку, если она возникнет. Если это произойдет, вызывается вторая функция с локализованным вариантом глобальной переменной $_, которая установлена в соответствии с возбужденной исключительной ситуацией. Если все это выглядит для вас полной неразберихой, почитайте о функциях die и eval в главе 29, а затем об анонимных функциях и замыканиях в главе 8. С другой стороны, те, кого это заинтересовало, могли бы изучить модуль Error из СР AN, в котором такая технология применяется для реализации тщательно структурированной обработки исключительных ситуаций с использованием предложений try, catch, except, otherwise и finally.

Вот новая реализация оператора grep (встроенная функция, конечно, более эффективна):

sub mygrep (&@) {

my $coderef = shift;

my @result;

foreach $_ (@_) {

push(@result, $_) if &$coderef;

}

return @result;

}

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

Подставляемые функции-константы

Функции, прототип которых содержит пустые скобки (), и, следовательно, не принимающие никаких аргументов, анализируются аналогично встроенной time. Что интересно, компилятор рассматривает такие функции как кандидаты на подстановку (inlining). Если результатом такой функции, после оптимизации и свертывания констант, становится константа или скаляр с лексической областью видимости без других ссылок, то это значение будет использоваться вместо вызова данной функции. Однако вызовы вида &NAME никогда не преобразуются в подстановку, так же, как не подвергаются другим воздействиям прототипов. (См. в главе 31 «Модули прагм» описание директивы use constant, где рассказывается, как объявлять такие константы.)

Обе следующие версии функций для вычисления числа 冗 компилятор сделает подставляемыми:

sub pi (){ 3.14159 }# Не точно, но близко

sub PI (){ 4 * atan2(1, 1) }# Точно, насколько можно

На практике все следующие функции будут подставляемыми, поскольку Perl сможет все определить на этапе компиляции:

sub FLAG_FOO (){ 1 « 8 }

sub FLAG_BAR (){ 1 « 9 }

sub FLAG_MASK (){ FLAG_FOO | FLAG_BAR }

sub OPT_GLARCH (){ (0x1B58 & FLAG_MASK) == 0 }

sub GLARCH_VAL (){

if (OPT_GLARCH) { return 23 } else{ return 42 }

}

sub N () { int(GLARCH_VAL) / 3 }

BEGIN {# компилятор выполняет этот блок на этапе компиляции

my $prod = 1;# сохраняющая значение закрытая переменная

for (1 .. N) { $prod *= $_ } sub NFACT () { $prod }

}

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

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

sub not_inlined () { return 23 if $$;

}

Более подробно о том, что происходит в фазах компиляции и выполнения программы, см. в главе 18.

Предосторожности при использовании прототипов

Вероятно, лучше всего применять прототипы с новыми функциями, а не модифицировать старые. Это ведь шаблоны контекста, а не прототипы ANSI С, поэтому особенную осторожность нужно проявлять, чтобы незаметно не изменить контекст. Предположим, например, решено, что функция должна принимать только один параметр, как в следующем примере:

sub func ($) { my $n = shift; print "вы передали мне $n\n";

}

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

func @foo;func split /:/;func "a", "b", "c";func("a"t "b", "c");func @foo;func split /:/;func "a", "b", "c";func("a"t "b", "c");считает элементы @foo

func @foo;

func split /:/;

func "a", "b", "c";

func("a"t "b", "c");

func @foo;

func split /:/;

func "a", "b", "c";

func("a"t "b", "c");

считает число возвращаемых полей

передает только "а", отбрасывая "Ь" и "с

неожиданная ошибка компилятора!

Скаляр был неявно передан в начале списка аргументов, что может оказаться несколько неожиданным. Прежний массив @foo, содержавший один элемент, не передается. Вместо него в func передается 1 (число элементов в @foo). A split, будучи вызвана в скалярном контексте, запортит весь ваш список параметров @_. В третьем примере, т. к. func имеет прототип унарного оператора, передано будет только а; затем значение, возвращаемое func, отбрасывается, т. к. оператор «запятая» продолжает вычисление следующих двух элементов и возвращает с. В последнем примере пользователь столкнется во время компиляции с синтаксической ошибкой в коде, который ранее отлично компилировался и выполнялся.

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

sub func (\$) {

my $nref = shift;

print "вы передали мне $$nref\n";

}

Теперь компилятор не пропустит ничего, что не начинается с символа $:

func @foo;func split/:/;func $s;func @foo;func split/:/;func $s;# ошибка компиляции, есть @, нужен $

func @foo;

func split/:/;

func $s;

func @foo;

func split/:/;

func $s;

# ошибка компиляции, есть функция, нужен $

# здесь ок -- получен символ $

func $а[3];func $h{stuff}[-1];func 2+5;func ${ \(2+5) };func $а[3];func $h{stuff}[-1];func 2+5;func ${ \(2+5) };и здесь

func $а[3];

func $h{stuff}[-1];

func 2+5;

func ${ \(2+5) };

func $а[3];

func $h{stuff}[-1];

func 2+5;

func ${ \(2+5) };

и даже здесь

скалярное выражение, ошибка компиляции

ок, но лекарство оказывается хуже болезни

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

Атрибуты подпрограмм

С объявлением или определением подпрограммы может быть связан список атрибутов. Если такой список атрибутов есть, то разделителями в нем служат пробельные символы или двоеточия, и обрабатывается он так, как если бы была встречена директива use attributes. Подробности о применении директивы use attributes можно найти в главе 31. Есть три стандартных атрибута подпрограмм: locked, method и lvalue.

Атрибуты locked и method

В эту функцию допускается только один поток, sub afunc : locked { ... }

В эту функцию для данного объекта допускается только один поток.

sub afunc : locked method { ... }

Установка атрибута locked имеет смысл только тогда, когда подпрограмма или метод предназначены для вызова одновременно из нескольких потоков. При установке для подпрограммы, не являющейся методом, Perl обеспечивает блокировку самой подпрограммы перед входом в нее. При установке для подпрограммы, которая является методом (т. е. имеющей также атрибут method), Perl обеспечивает при каждом ее вызове неявную блокировку первого аргумента (объекта), прежде чем начать ее выполнение.

Семантика этой блокировки такая же, как в случае, если первой командой программы будет применение оператора lock к этой подпрограмме. Дополнительно о блокировках читайте в главе 17 «Потоки».

Атрибут method может использоваться самостоятельно:

sub afunc : method { ... }

В настоящее время его действие заключается только в том, что данная подпрограмма не будет вызывать предупреждающее сообщение Ambiguous call resolved as CORE: :%s (неоднозначный вызов разрешен как CORE: :%s). (Возможно, когда-нибудь мы дадим ему дополнительный смысл.)

Система атрибутов допускает расширение со стороны пользователя, позволяя ему создавать собственные имена атрибутов. Эти новые атрибуты долж-

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

Вот примеры допустимого синтаксиса (даже если атрибуты неизвестны):

sub fnord (&\%) : switch(10,foo(7,3)) : expensive; sub plugh () : Ugly('\(") :Bad;

sub xyzzy : _5x5 { ... }

Вот примеры неправильного синтаксиса:

sub fnord :

:switch(10,foo();

# нет баланса скобок

sub snoid :

:Ugly('(');

# нет баланса скобок

sub xyzzy :

:5x5;

# "5x5" не является идентификатором

sub plugh :

:Y2::north;

# "Y2::north" не является простым идентификатором

sub snurt

:foo + bar;

# "+" не является двоеточием или пробелом

Список атрибутов передается как список строк-констант в код, который связывает их с подпрограммой. Точное представление о том, как он работает (или не работает), можно получить экспериментальным путем. Текущее состояние дел со списками атрибутов и их обработкой можно посмотреть в attri- butes(3).

Атрибут lvalue

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

my $val;

sub canmod : lvalue {

$val;

}

sub nomod {

$val;

}

canmod() = 5;# присвоение $val.

nomod() = 5;# ERROR

При передаче параметров подпрограмме, возвращающей 1-значение, обычно нужны скобки для устранения неопределенности типа присваиваемого значения:

canmod $х = 5 canmod 42 = 5 canmod($x) = 5 canmod(42) = 5canmod $х = 5 canmod 42 = 5 canmod($x) = 5 canmod(42) = 5сначала присваивает $х значение 5!

canmod $х = 5 canmod 42 = 5 canmod($x) = 5 canmod(42) = 5

canmod $х = 5 canmod 42 = 5 canmod($x) = 5 canmod(42) = 5

нельзя изменить константу - ошибка при компиляции

это ок

и это тоже

С этим можно справиться в том случае, если подпрограмма принимает один аргумент. Если функция объявлена с прототипом ($), то при синтаксичес-

ком анализе она получает приоритет именованного унарного оператора. Поскольку именованные унарные операторы имеют более высокий приоритет, чем присвоение, скобки больше не нужны. (Целесообразность этого зависит от используемого стиля.)

В том случае, если подпрограмма принимает ноль аргументов (т. е. с прототипом ()),можно, не вызывая неоднозначности, сказать:

canmod = 5;

Это допустимо, потому что терм не может начинаться с символа 二.Аналогично можно опускать скобки в вызовах методов, возвращающих 1-значение, если им не передаются аргументы:

$obj->canmod 二 5;

Обещаем, что эти две конструкции сохранятся в будущих версиях Perl. Они удобны, когда нужно обернуть (wrap) атрибуты объекта в вызовы методов (чтобы их можно было наследовать, как методы, но обращаться, как к переменным).

Скалярный или списковый контекст подпрограммы, возвращающей 1-значение, и правой части присвоения этой подпрограмме определяется так, как если бы вызов подпрограммы был заменен скаляром. Например:

data(2,3) = get_data(3,4)；

Обе подпрограммы здесь вызываются в скалярном контексте, в то время как в:

(data(2,3)) = get_data(3,4)；

и в:

(data(2),data(3))二 get_data(3,4)；

все подпрограммы вызываются в списковом контексте.

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

7

Форматы

В Perl имеется механизм, позволяющий создавать простые отчеты и диаграммы. Для упрощения этой задачи Perl помогает запрограммировать вывод страницы близко к тому, как она будет выглядеть при печати. Он позволяет следить за такими вещами, как количество строчек на странице, номер текущей страницы, управление выводом заголовков страницы и т. д. Ключевые слова заимствованы из FORTRAN: format для объявления и write для выполнения; см. соответствующие разделы главы 29 «Функции». К счастью, структура читается значительно легче - скорее как в команде PRINT USING языка BASIC. Можете считать, что это nroff(l) для бедных. (Это может не быть достаточной рекомендацией для тех, кто знаком с nroff.)

Форматы, как пакеты и подпрограммы, не выполняются, а объявляются, поэтому они могут находиться в любом месте программы. (Обычно все же лучше держать их все в одном месте.) У них есть собственное пространство имен, отличное от других типов в Perl. Это значит, что если у нас есть функция с именем Foo, то это не то же самое, что формат Foo. Однако именем по умолчанию для формата, ассоциированного с некоторым дескриптором файла, служит имя этого дескриптора файла. Поэтому формат по умолчанию для STDOUT называется "STDOUT", а формат по умолчанию для дескриптора файла TEMP называется "TEMP". Они только выглядят одинаково, но не являются одним и тем же.

Форматы выходных записей объявляются так:

format NAME 二

FORMLIST

Если имя NAME опущено, то определяется формат STDOUT. FOHMLIST состоит из последовательности строк, каждая из которых может иметь один из трех типов:

Комментарий, обозначаемый # в первой колонке.

Строка шаблона (picture line), определяющая формат одной выводимой строки.

Строка с аргументами, дающими значения, встраиваемые в предшествующую строку картинки.

Строки шаблонов выводятся точно так, как они выглядят, за исключением того, что вместо некоторых полей подставляются их значения. Каждое поле подстановки в строке шаблона начинается с @ (at) или (крышка). Эти строки не подвергаются никакой интерполяции переменных. Поле @ (не путать с маркером массива @) представляет собой поле обычного типа; поле другого типа, типа ", предназначено для элементарного заполнения многострочных блоков текста. Размер поля задается заполнением его символами <, > или | для установки, соответственно, выравнивания по левому краю, выравнивания по правому краю и выравнивания по центру. Если переменная превосходит заданную для нее ширину, она усекается.

В качестве альтернативной формы выравнивания по правому краю можно использовать символы # (после начального @ или °) для задания числового поля. Вместо одного из символов # можно вставить . (точку) и выровнять десятичные точки. Если значение, передаваемое какому-либо из этих полей, содержит символ перевода строки, то выводится только текст перед этим символом. И, наконец, специальное поле @* может служить для вывода многострочных и неусеченных значений; в большинстве случаев оно должно быть единственным полем в строке шаблона.

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

Если выражение имеет значением число со знаками после десятичной точки и в соответствующем шаблоне указано, что дробная часть выдачи должна выводиться (т. е. в любом шаблоне, кроме множественных символов #, не со-

держащих точки .), то символ, выбранный в качестве десятичной точки, определяется текущей установкой LC_NUMERIC. Это означает, например, что если в среде окружения этапа исполнения заданы немецкие национальные установки, то вместо точки будет использоваться запятая. Дополнительные сведения имеются на странице руководства perllocale.

Внутри выражения пробельные символы \n, \t и \f считаются эквивалентными одному пробелу. Поэтому можно считать, что к каждому значению формата применяется фильтр:

$value =~ tr/\n\t\f/ /;

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

Поля шаблона, начинающиеся с символа ； а не @, обрабатываются особым образом. Поле # заполняется пробелами, если значение не определено. Для остальных типов полей крышечка ° включает режим заполнения. Передаваемое значение должно быть не выражением, а именем скалярной переменной, содержащей строку текста. Perl помещает в поле столько текста, сколько можно, а затем отсекает переднюю часть строки, так что при новом обращении к переменной может быть выведена следующая часть текста. (Да, это означает, что при выполнении вызова write переменная не сохраняется и сама изменяется. Сохранить исходное значение можно во временной переменной.) Обычно для вывода текстового блока используют ряд полей, выровненных по вертикали. Можно вывести в последнем поле символы «...», которые будут появляться в выводимой информации, если текст слишком длинный, чтобы быть выведенным полностью. Изменить символы, по которым (или после которых) производится разрыв текста, можно, указав в переменной $: (если используется модуль English, то $FORMAT_LINE_BREAK_CHARACTERS) список желаемых символов.

В случае применения полей 八 могут создаваться записи переменной длины. Если форматируемый текст короткий, просто повторите строку формата с полем 人 несколько раз. Для коротких данных это приведет к выводу нескольких пустых строк. Для подавления вывода пустых строк поместите в любом месте строки символ ~ (тильда). (Сама тильда при выводе будет переведена в пробел.) Если рядом с первой тильдой поместить вторую, то строка будет повторяться, пока не исчерпается весь текст в полях этой строки. (Это возможно потому, что поля ° «съедают» выводимые ими строки. Но если используется поле типа @ вместе с двумя тильдами, то желательно, чтобы передаваемое в него выражение не выводило одно и то же значение до бесконечности! В этом случае вам нужен оператор shift или какой-либо другой оператор с побочным эффектом, позволяющим исчерпать список значений.)

Обработка начала страницы по умолчанию осуществляется форматом, имя которого состоит из имени данного дескриптора файла с присоединенными в конце символами _ТОР. Она выполняется в начале вывода каждой страницы. См. описание write в главе 29.

Вот несколько примеров:

отчет по файлу /etc/passwd format STDOUT_TOP =

Файл Passwd

ИмяИмяЛогин Офис Uid Gid Каталог

Имя

Имя

format STDOUT = @«««««<«<«« @||||||| @«««@>>» @>>» @<«««««««<< $name,$login, $office,$uid,$gid, $home

отчет по бланку сообщения об ошибке format STDOUT_TOP 二

Сообщение об ошибке @«««««««««««<@|||@»»»»»»»»»»»>

$system,$%,$date

format STDOUT =

Сообщение: @«««««««««««««««««««««««<«<«« $subject

Индекс: @««««««««««<«<«« ,'«««««««««««««< $index,$description

Приоритет: @««««« Date: @«««< ,'«««««««««««««<

$priority, $date, $description

От: @««««««««««««««< ,'««««««««««««««« $from,$description

Предназначено: @«««««««<«<«« ,'«««««««««<«<«« $pгод rammer,$description

~,'««««««««««<«<««

$description

~,'««««««««««««««

$description

~,'««««««««««««««

$description

~,'««««««««««<«<««

$description

~,'««<«««««««««...

$description

Лексические переменные не видны в формате, если только объявление формата не находится в области видимости лексической переменной.

Можно чередовать применение print и write в одном и том же канале вывода, но придется самостоятельно обрабатывать специальную переменную $- ($FORMAT_LINES_LEFT, если используется модуль English).

Переменные форматов

Имя текущего формата хранится в переменной $~ ($FORMAT_NAME), а имя текущего формата начала страницы - в переменной $八($FORMAT_TOP_NAME). Номер текущей выводимой страницы хранится в $% ($FORMAT_PAGE_NUMBER), а число строк на странице - в $= ($FORMAT_LINES_PER_PAGE). Необходимость автоматической очистки буфера этого дескриптора определяется переменной $ | ($OUT- PUT_AUTOFLUSH). Строка, которую нужно выводить перед началом каждой страницы (кроме первой), хранится в $1 ($FORMAT_FORMFEED). Эти переменные устанавливаются отдельно для каждого дескриптора файла, поэтому нужно выбрать дескриптор файла с помощью select, чтобы изменить переменные его формата:

select((select(OUTF),

$~ = "My_Other_Format",

$八="My_Top_Format" )[0]);

Довольно безобразно, не так ли? Однако это общепринятая идиома, поэтому не удивляйтесь, увидев ее. Можно использовать временную переменную для хранения предыдущего дескриптора файла:

$ofh = select(OUTF);

$~ = "My_Other_Format";

$八="My_Top_Format"; select($ofh);

В целом такой подход гораздо лучше, поскольку он не только улучшает читаемость, но и создает промежуточную команду в коде, на которой происходит остановка при отладке в пошаговом режиме. При использовании модуля English имена переменных даже становятся читаемыми:

use English;

$ofh = select(OUTF);

$FORMAT_NAME 二"My_Other_Format";

$FORMAT_TOP_NAME = "My_Top_Format"; select($ofh);

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

use FileHandle;

OUTF->format_name("My_Other_Format"); OUTF->format_top_name("My_Top_Format");

Так уже гораздо лучше!

Поскольку в строке значений, следующей за строкой шаблона, могут содержаться произвольные выражения (для полей типа @, не полей ^), можно передать более сложную обработку другим функциям, скажем, sprintf или своим собственным. Например, чтобы вставить в число запятые:

format Ident 二

@«««««««< commify($n)

А для того чтобы вставить в поле реальные @, ~ или °, сделайте так:

format Ident 二 Я поместил @ сюда.

Для выравнивания по центру всей строки текста надо сделать примерно нижеследующее:

format Ident 二

@IHIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII "Какой-то текст"

Индикатор длины поля > обеспечивает выравнивание текста по правому краю поля, но само поле располагается в точности там, где это указано. Нет прямого способа: «переместить это поле к правому краю страницы, какой бы широкой она ни была». Необходимо указать, где оно должно находиться относительно левого края. Те, кому это крайне необходимо, могут создать формат динамически, задав действительное число колонок, а затем выполнить его через eval:

Sformat = "format STDOUT 二 \n" .'<'x $cols . "\n" .'Sentry' . "\n" .. У x ($cols-8) . "~~\n" .'Sentry' . "\n" • "An";

print $fo「mat if $Debugging;

eval $format; die $@ if $@;

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

format STDOUT =

,'«««««««««««««««««««««««««<«<««

Sentry

,'«««««««««««««««««««««<«<««~~

Sentry

Вот маленькая программа, которая работает подобно утилите Unix /тп力⑴：

format =

С<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<< ~~

$/ =

while (о) {

s/\s*\n\s*/ /д; write;

}

Нижние колонтитулы

В то время как имя текущего формата заголовка хранится в переменной $八($FORMAT_TOP_NAME), соответствующего механизма для нижнего колонтитула нет. Одна из главных проблем заключается в том, что размер формата не известен до тех пор, пока он не обработан. Эта задача помещена в список TODO. Можно предложить такую стратегию: если нижний колонтитул имеет фиксированный размер, то выводить его, проверяя число оставшихся в формате строк $- ($FORMAT_LINES_LEFT) перед каждой операцией write, и при необходимости самостоятельно выводить нижний колонтитул.

Вот другая стратегия: откройте канал с помощью open(MESELF, " | -") (см. описание open в главе 29) и всегда выполняйте write в MESELF вместо STDOUT. Затем пусть ваш дочерний процесс обработает свой STDIN и переставит верхние и нижние колонтитулы так, как вам хочется. Не очень удобно, но реализуемо.

Низкоуровневый доступ к форматированию

Для низкоуровневого доступа к форматированию можно использовать встроенный оператор formline и обратиться к $^А (переменная SACCUMULATOR) непосредственно. (Форматы, в сущности, компилируются в последовательность вызовов formline.) Например:

$str = formline «'END', 1,2,3;

@«< @||| @»>

END

print "Вау, я запомнил '$^A' в аккумулятор!\п";

Чтобы создать подпрограмму swrite (которая относится к write, как sprintf к printf), сделайте следующее:

use Carp; sub swrite { croak "использование: swrite PICTURE ARGS" unless @_; my $format = shift;

$“ 二 formline($format, @_); return $F;

}

$string = swrite(«'END', 1, 2, 3); Check me out @«< @| 11 @»> END

print $string;

Если используется модуль FileHandle, то с помощью formline можно переносить блок текста по колонке 72 так:

use FileHandle;

STDOUT->foгmline(",'" . ("<" х 72) . "~Лп", $long_text);

8

Ссылки

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

Допустим, требуется построить простую таблицу (двумерный массив) с демографической статистикой - возраст, цвет глаз и вес 一 для группы людей. Можно сделать это, сначала создав массив для каждого отдельного лица:

@john = (47, "темно-карие", 186);

@тагу = (23, "карие", 128);

@bill = (35, "голубые", 157);

Затем можно создать один дополнительный массив, содержащий имена остальных массивов:

@vitals = ( John', 'тагу', 'bill');

Чтобы изменить цвет глаз Джона на «красные» после ночи, проведенной в увеселительных местах, нам надо иметь возможность изменить содержание массива @john, используя только простую строку "john". Это основная проблема косвенной адресации (indirection), которая в различных языках решается по-разному. В С самой распространенной формой косвенной адресации является указатель, который позволяет одной переменной хранить в памяти адрес другой переменной. В Perl самая распространенная форма косвенной адресации - ссылка (reference).

Что такое ссылка?

В нашем примере $vitals[0] имеет значение "John". Это значит, что данный элемент содержит строку, которая представляет собой имя другой (глобальной) переменной. Мы говорим, что первая переменная ссылается на вторую, и эта ссылка называется символической (symbolic), поскольку Perl нужно найти @john в таблице символов. (Символические ссылки на переменные аналогичны символическим ссылкам файловой системы.) О символических ссылках мы будем говорить далее в этой главе.

Другим типом ссылки является жесткая (hard) ссылка, и именно к ним прибегает большинство программистов Perl для осуществления косвенной адресации. Жесткими мы называем эти ссылки потому, что они надежные и прочные. Если хотите, можете считать жесткие ссылки настоящими ссылками, а символические ссылки - поддельными. Разница такая же, как между настоящей дружбой и похвальбой знакомством с известным человеком. Если мы не указываем, какого типа ссылку имеем в виду, значит, это жесткая ссылка. На рис. 8.1 изображена переменная с именем $bar, которая ссылается на содержимое скаляра с именем $foo, имеющего значение bot.

Рис. 8.1. Жесткая ссылка и символическая ссылка

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

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

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

Символическая ссылка - это просто строка, служащая именем для некоторого элемента таблицы имен в пакете. Это не столько какой-то особый тип, сколько способ обращения со строкой. Однако жесткая ссылка - это зверь совсем иной породы. Это третий из трех видов фундаментальных скалярных типов данных. Чтобы сослаться на нечто, жесткой ссылке не нужно знать его имя, и, самое главное, совершенно нормально, если такого имени, которое можно использовать, и нет. Такие совершенно безымянные объекты ссылки называются анонимными; мы расскажем о них далее в разделе «Анонимные данные».

В терминологии данной главы, чтобы ссылаться (to reference) на значение, нужно создать на него жесткую ссылку. (Для этого акта созидания есть специальный оператор.) Создаваемая при этом ссылка является просто скаляром, который во всех известных контекстах ведет себя как всякий другой скаляр. Разыменовать (dereference) этот скаляр означает использовать ссылку для доступа к объекту ссылки. Как создание ссылки, так и разыменование происходят только при вызове определенного явного механизма; неявные создание ссылки и разыменование в Perl никогда не происходят. Ну, или почти никогда.

В вызове функции может использоваться семантика неявной передачи по ссылке, если это объявлено соответствующим образом в ее прототипе. В этом случае при вызове функции ссылка не передается ей явным образом, но, тем не менее, ее приходится явно разыменовывать в теле функции. См. раздел «Прототипы» в главе 6. И, если уж быть совсем честным, то некоторое закулисное разыменование происходит, когда используются некоторые виды дескрипторов файлов, но это делается для поддержки обратной совместимости и происходит прозрачным для обычного пользователя способом. И, наконец, две встроенные функции, bless и lock, принимают в качестве своих аргументов ссылку и неявным образом разыменовывают ее, чтобы применить свои механизмы к тому, что за ней скрывается. Но если оставить в стороне эти признания, то базовый принцип все же состоит в том, что Perl не заинтересован во внесении беспорядка в ваши уровни косвенной адресации.

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

Имейте, однако, в виду, что внутреннее представление массивов и хешей в Perl является одномерным. Это означает, что их элементы могут хранить только скалярные значения (строки, числа и ссылки). Говоря «массив мас-

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

Создание ссылок

Есть несколько способов создания ссылок, большинство из которых мы опишем, а затем объясним, как использовать (разыменовывать) получаемые ссылки.

Оператор обратной косой черты

Ссылку на любую именованную переменную или подпрограмму можно создать с помощью обратной косой черты. (Можно также использовать ее с анонимными скалярными значениями, например, 7 или "camel", но вам не часто это понадобится.) Этот оператор работает аналогично оператору & (адрес) в С, по крайней мере, на первый взгляд.

Вот несколько примеров:

$scalarref 二 \$foo;

$constref 二 \186_282.42;

$arrayref 二 \@ARGV;

$hash「ef 二 \%ENV;

$coderef 二 \&handler;

$globref = \*STDOUT;

Оператор обратной косой черты может сделать больше, чем просто создать одну ссылку. Если применить его к списку, то он создаст целый список ссылок. Подробности см. в разделе «Другие приемы использования жестких ссылок».

Анонимные данные

В только что приведенных примерах оператор обратной косой черты просто создает дубликат ссылки, уже содержащейся в имени переменной, за одним исключением. На 186_282.42 именованная переменная не ссылается, это просто значение. Это пример одного из анонимных объектов ссылки, уже упоминавшихся выше. Доступ к анонимным объектам ссылки осуществляется только с помощью ссылок. Данный объект представляет собой число, но можно также создавать анонимные массивы, хеши и подпрограммы.

Формирователь анонимных массивов

Ссылку на анонимный массив можно создать с помощью квадратных скобок:

$arrayref = [1, 2, ['a', 'b', 'с', 'd']];

Здесь мы сформировали анонимный массив из трех элементов, последним элементом которого является ссылка на анонимный массив из четырех элементов (изображенный на рис. 8.2). (Для доступа к этим элементам может использоваться многомерный синтаксис, описываемый ниже. Например, $arrayref->[2][1] имеет значение ' Ь'.)

Рис. 8.2. Ссылка на массив, третий элемент которого сам является ссылкой на массив

Теперь у нас есть способ представить таблицу, приведенную в начале главы:

$table 二[["john", 47, "темно-карие", 186], ["тагу", 23, "карие", 128], ["bill", 35, "голубые", 157]];

Квадратные скобки действуют подобным образом только там, где анализатор Perl предполагает наличие терма в выражении. Не следует путать их с квадратными скобками в выражении типа $аггау[6], хотя мнемоническая ассоциация с массивами является намеренной. Внутри строки, заключенной в двойные кавычки, квадратные скобки не образуют анонимных массивов, а становятся литеральными символами строки. (Квадратные скобки все же действуют при создании индексов в строках, иначе нельзя было бы выводить строковые значения вида "VAL=$array[6]\n". И если уж совсем откровенно, то, на самом деле, можно протащить формирователи анонимных массивов в строки, но только если они встроены в более крупное выражение, которое подвергается интерполяции. Об этой возможности речь пойдет ниже, поскольку она включает в себя не только создание ссылки, но и разыменование.)

Формирователь анонимных хешей

Ссылку на анонимный хеш можно создать с помощью фигурных скобок:

$hash「ef 二｛

'Адам'=> ，Ева',

'Клайд' => $bonnie,

'Антоний' => 'Клео' . 'патра', }；

В значениях (но не ключах) хеша можно смело смешивать другие формирователи анонимных массивов, хешей и подпрограмм, создавая сколь угодно сложные структуры.

Теперь у нас есть еще один способ представить таблицу, приведенную в начале главы:

Stable 二{

"john" => [ 47, "темно-карие", 186 ],

"тагу" => [ 23, "карие", 128 ],

"bill" => [ 35, "голубые", 157 ],

}；

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

Stable 二{

"john"=>

{ age

二〉

47,

eyes

=>

"темно-карие"

weight },

二〉

186,

"тагу"=>

{ age

=>

23,

eyes

=>

"карие",

weight },

=>

128,

"bill"=>

{ age

=>

35,

eyes

=>

"голубые",

weight },

=>

157,

}；

Как и квадратные, фигурные скобки действуют подобным образом только там, где анализатор Perl предполагает наличие терма в выражении. Не следует путать их с фигурными скобками в выражении типа $hash{key} - хотя мнемоническая ассоциация с массивами и в этом случае является намеренной. Те же предостережения относятся к использованию фигурных скобок в строках.

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

sub hashem{{@_ } }#НЕВЕРНО,но без сообщений - - возвращает @_.

sub hashem{+{@一}}#Ok.

sub hashem{return {@_ } }#Ok.

Формирователь анонимных подпрограмм

Создать ссылку на анонимную подпрограмму можно с помощью объявления sub без имени подпрограммы:

$coderef 二 sub { print "Boink!\n" }; # Теперь &$code「ef выводит "Boink!"

Обратите внимание на точку с запятой, которая требуется для завершения выражения. (Точка с запятой не требуется при более традиционном использовании sub NAME {} для объявления и определения именованной подпрограммы.) Безымянная sub {} представляет собой не столько объявление, сколько оператор - как {} или eval {} - за исключением того, что находящийся внутри код не выполняется немедленно. Вместо этого генерируется ссылка на код, в нашем примере помещаемая в $coderef. Однако сколько бы раз ни выполнялась приведенная выше строка, $code「ef будет ссылаться на одну и ту же безымянную процедуру.

Конструкторы объектов

Подпрограммы также могут возвращать ссылки. Может звучать банально, но иногда мы обязаны использовать для создания ссылки подпрограмму, а не создавать ссылку самостоятельно. В частности, особые подпрограммы, называемые конструкторами, создают или возвращают ссылки на объекты. Объект - это просто ссылка особого типа, которой известно, с каким классом она связана, и конструкторы умеют создавать эту связь. Они делают это, беря обычный предмет ссылки и превращая его в объект с помощью оператора bless, поэтому можно считать, что объект - это «blessed reference» («освященная», или обработанная, ссылка). Ничего религиозного здесь не происходит. Поскольку класс выступает как тип, определенный пользователем, обработка объекта ссылки с помощью bless просто делает его типом, определенным пользователем, в дополнение к встроенному. Конструкторам часто дают имя new - особенно в программах на C++, - но в Perl их можно называть как угодно.

Конструкторы можно вызывать любым из следующих способов:

$objref 二 Doggie::->new(Tail => 'короткий', Ears => 'длинные'); #1 $objref = new Doggie:: Tail => 'короткий', Ears => 'длинные';#2

$objref = Doggie->new(Tail => 'короткий', Ears => 'длинные');#3

$objref = new Doggie Tail => 'короткий', Ears => 'длинные';#4

Первый и второй вызовы одинаковы. В обоих вызывается функция с именем new, которую предоставляет модуль Doggie. Третий и четвертый вызовы такие же, как первые два, но несколько более двусмысленны: анализатор запутается, если вы определите собственную программу с именем Doggie. (Почему обычно и придерживаются нижнего регистра в именах подпрограмм и верхнего регистра в именах модулей.) Четвертый вызов может также сбиться, если определить собственную подпрограмму new и не выполнить команды require или use для модуля Doggie, каждая из которых имеет эффект объявления модуля. Всегда объявляйте свои модули, если хотите пользоваться вариантом 4. (И остерегайтесь «бродячих» подпрограмм Doggie.)

Обсуждение объектов Perl см. в главе 12 «Объекты».

Ссылки на дескрипторы

Ссылки на дескрипторы файлов или дескрипторы каталогов можно создавать посредством ссылки на typeglob с тем же именем:

splutter(\*STDOUT);

sub splutter {

my $fh = shift;

print $fh "her um well a hmmm\n";

}

$rec 二 get_「ec(\*STDIN);

sub get_rec {

my $fh 二 shift; return scalar <$fh>;

}

Если передаются дескрипторы файлов, то можно применять для этого голые (простые) typeglob: в вышеприведенном примере вместо \*STDOUT и \*STDIN можно было использовать *STDOUT или *STDIN.

Хотя typeglob и ссылки на typeglob обычно можно использовать взаимозаменяемым образом, в некоторых случаях это недопустимо. Простые typeglob нельзя превратить в объекты с помощью bless, а ссылки на typeglob нельзя возвращать из области видимости локализованного typeglob.

При создании новых дескрипторов файлов раньше использовали примерно такой код для открытия списка файлов:

for $file (@names) { local *FH; open(*FH, $file) || next; $handle{$file}二 *FH;

}

Такой код по-прежнему допустим, но сейчас можно легко позволить неопределенной переменной автоматически оживить анонимный typeglob:

for $file (@names) { my $fh;

open($fh, $file) || next;

$handle{$file} = $fh;

}

Для косвенных дескрипторов файлов не важно, применяется ли typeglob, ссылки на typeglob или какой-нибудь более экзотический объект ввода/вы- вода. Вы просто используете скаляр, который так или иначе будет интерпретирован как дескриптор файла. В большинстве случаев почти никакого значения не имеет, что выбрать - typeglob или ссылку на typeglob. Как уже сообщалось раньше, при этом неявно работают некоторые механизмы разыменования.

Ссылки на таблицы символов

В некоторых редких случаях во время написания программы может быть неизвестно, какого типа ссылка требуется. Ссылку можно создать с помощью особого синтаксиса, который любовно называют синтаксисом ★ foo{THING}. Синтаксис ★too{THING} возвращает ссылку на позицию для THING в *fooj которая является записью в таблице имен, содержащей значения $foo, @foo, %foo и компании.

$scalarref

二 oo{SCALAR};

To же,

что и \$foo

$arrayref

二 *ARGV{ARRAY};

To же,

что и \@ARGV

$hash「ef

二 *ENV{HASH};

#

To же,

что и \%ENV

$coderef

二 *handler{CODE};

#

To же,

что и \&handler

$glob「ef

二 *foo{GLOB};

#

To же,

что и \*foo

$ioref

二 *STDIN{IO};

Э-э...

Все они говорят сами за себя, за исключением *STDIN{IO}. Последний возвращает фактический внутренний объект 10: :Handle, содержащийся в typeglob, то есть ту часть typeglob, в которой реально заинтересованы различные функции ввода/вывода. Для совместимости с более ранними версиями Perl обозначение *foo{FILEHANDLE} служит синонимом для более знакомого *foo{10}.

Теоретически, использовать *HANDLE{10\ можно там же, где и ★HANDLE или '★HANDLE, например, при передаче дескрипторов в подпрограмму или из нее или для запоминания их в более крупных структурах данных. (На практике все же есть некоторые шероховатости, которые нужно сгладить.) Преимущество заключается в возможности применения с реально требуемыми объектами ввода/вывода, а не со всем typeglob, что позволяет избежать риска затереть полезные данные, присваивая значение переменной typeglob (хотя если всегда выполнять присваивание скалярной переменной, а не typeglob,

Развернутое толкование и историю термина «foo» можно найти в Файле Жаргона (http://www.jargon,org/). - Примеч.ред.

то все будет в порядке). Недостаток состоит в отсутствии в настоящее время возможности самооживления.

splutter(*STDOUT);

splutter(*STDOUT{IO});

sub splutter {

my $fh 二 shift;

print $fh "her um well a hmmm\n";

}

Оба вызова splutter() выводят "her um well a hmmm".

Конструкция ★fooiTHING} возвращает undef, если указанный аргумент THING компилятор еще не видел, за исключением тех случаев, когда THING представляет собой SCALAR. Дело в том, что *foo{SCALAR} возвращает ссылку на анонимный скаляр, даже если компилятор еще не видел $foo. (Perl всегда добавляет скаляр к любому typeglob для оптимизации кода по размеру. Но не следует полагать, что так будет и в последующих версиях.)

Неявное создание ссылок

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

Использование жестких ссылок

Так же как есть много способов создания ссылок, есть много способов их использования, или разыменования {dereference). Есть только один главный принцип: Perl не выполняет неявно создание ссылок или их разыменование. Если в скаляре содержится ссылка, то он ведет себя как простой скаляр. Он не начинает при этом чудесным образом вести себя как массив, или хеш, или подпрограмма: об этом ему нужно сказать явным образом путем разыменования.

Использование переменной в качестве имени переменной

Встретив скаляр, скажем, $foo, следует представить себе «скалярное значение foo»・ Это значит, что в таблице имен есть запись foo, а разыменовываю-

щий символ $ дает возможность посмотреть на скалярное значение, которое в ней находится. Если то, что в ней находится, представляет собой ссылку, то можно посмотреть, что находится в этой ссылке, поставив впереди еще один разыменовывающий символ и разыменовав таким образом $foo. Или, если посмотреть на это с другой стороны, можно заменить скалярной переменной, указывающей на фактический объект ссылки, литерал foo в скаляре $foo. Это справедливо для переменной любого типа, поэтому не только $$foo - это скалярное значение того, на что ссылается $foo, но и @$bar - это значение типа массив - того, на что ссылается $Ьа「，и %$gla「ch - это значение типа хеш - того, на что ссылается $gla「ch, и т. д. Вывод таков: можно поместить дополнительный разыменовывающий символ впереди любой простой скалярной переменной и в результате разыменовать ее:

$foo二"трехгорбый";

$scalarref 二 \$foo;# $scalarref теперь ссылка на $foo

$camel_model = $$scalarref;# $camel_model теперь"трехгорбый"

Вот еще несколько примеров разыменования:

$bar = $$scalarref;

push(@$arrayref, $filename);

$$arrayref[O] = "January";# Установить первый элемент @$arrayref

@$ar「ay「ef[4..6] = qw/May June July/; # Установить несколько элементов @$arrayref

%$hashref = (KEY => "ЗВЕНИТ", BIRD => "ПОЕТ"); # Инициализировать весь хеш $$hashref{KEY}二"ЗНАЧЕНИЕ";# Установить одну пару ключ/значение

@$hashref{"W41',1"OT42"}二("ЗНАЧ1", "ЗНАЧ2");# Установить еще две пары

&$coderef(1,2,3);

print $handle「ef "вывод\п";

В этом виде разыменования могут применяться только к простым скалярным переменным (без индексов). Это значит, что разыменование происходит до (или связывает сильнее) поиска в массиве или хеше. Попробуем использовать фигурные скобки, чтобы пояснить, что мы имеем в виду: выражение вида $$arrayref[O] эквивалентно ${$arrayref}[0] и означает первый элемент массива, на который ссылается $arrayref. Это совсем не то же самое, что ${$arrayref[0]}, разыменовывающее первый элемент массива с именем @аг- rayref, возможно, несуществующего. Аналогично, $$hashref{KEY} представляет то же самое, что и ${$hash「ef}{KEY}, и не имеет отношения к ${$hash- ref{KEY}}, разыменовывающему элементу хеша с именем %hashref, возможно, несуществующего. Пока вы этого не поймете, вам будет плохо.

Конкатенируя соответствующие разыменовывающие символы, можно достигать разных уровней ссылок и разыменований. Следующий пример выводит "howdy":

$refref ref 二 \\\"howdy"; print $$$$refref ref;

Можно считать, что знаки доллара действуют слева направо. Однако в начале цепочки все же должна быть простая скалярная переменная без индекса. Есть, правда, более замысловатый способ, которым мы уже тайком пользовались раньше и о котором расскажем в следующем разделе.

Использование блока в качестве имени переменной

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

$bar = ${$scalarref};

push(@{$arrayref}, $filename);

${$arrayref}[0] = "January";

@{$arrayref}[4..6]二 qw/May June July/;

${$hashref}{"KEY"} = "ЗНАЧЕНИЕ";

@{$hashref}{"KЛЮЧ1"I"КЛЮЧ2"} = ("ЗНАЧ1","ЗНАЧ2");

&{$code「ef}(1,2,3);

не говоря уже о:

$refref ref = \\\"howdy";

print ${${${$refrefref}}};

Положим, в таких простых примерах глупо использовать фигурные скобки, но блок может содержать произвольное выражение - в частности, выражения с индексами. В следующем примере предполагается, что $dispatch{$in- dex} содержит ссылку на подпрограмму (такие ссылки иногда называют «coderef» - ссылкой на код). Подпрограмма вызывается здесь с тремя аргументами.

&{ $dispatch{$index} }(1, 2, 3);

Здесь использование блока необходимо. Без внешней пары фигурных скобок Perl рассматривал бы это как ссылку на код $dispatch, а не $dispatch{$index}.

Использование оператора «стрелка»

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

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

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

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

$$arrayref [2]二"Dorian";#1

${$arrayref }[2]二"Dorian";#2

$arrayref->[2]二"Dorian";#3

$$hash「ef {KEY}二"F#major";#1

${$hashref }{KEY}二"F#major";#2

$hashref->{KEY}二"F#major";#3

$coderef (Presto => 192);#1

&{$coderef }(Presto => 192);#2

$coderef->(Presto => 192);#3

Можно заметить, что начальный разыменовывающий символ отсутствует в третьем обозначении каждой тройки. Perl угадывает начальный символ, который нельзя поэтому использовать для разыменования целых массивов, целых хешей или их срезов. Однако, работая со скалярными выражениями, можно расположить слева от -> любое выражение, в том числе другое разыменование, поскольку операторы стрелки связываются слева направо:

print $агray[3]->{"English"}->[0];

Из этого выражения можно заключить, что четвертый элемент @а「「ау должен быть ссылкой на хеш, а значением элемента "English" в этом хеше должна быть ссылка на массив.

Обратите внимание на то, что $а「「ау[3] и $аггау->[3] - это не одно и то же. В первом случае речь идет о четвертом элементе массива @аггау, а во втором - о четвертом элементе массива (возможно, анонимного), ссылка на который содержится в $аггау.

Предположим теперь, что элемент $а「「ау[3] не определен. Следующая команда все же допустима:

$агray[3]->{"English"}->[0]二"January";

Это один из тех упоминавшихся ранее случаев, когда ссылка создается (са- мооживляется) при использовании в качестве 1-значения (т. е. когда ей присваивается значение). Если элемент $аггау[3] был неопределенным, он автоматически определяется как ссылка на хеш, и поэтому в него можно поместить значение $агray[3]->{"English"}. После этого $array[3]->{"English"} автоматически определяется как ссылка на массив, и можно что-нибудь присвоить первому элементу этого массива. Обратите внимание, что с г-зна- чениями дело обстоит несколько иначе: print $аггау[3]->{"English"}->[0]

определяет только $аг「ау[3] и $аггау[3]->{"English"}, но не $аггау[3]->{"Еп- glish"}->[0], поскольку последний элемент не является 1-значением. (То, что он вообще определяет первые два элемента в контексте r-значения, может считаться программной ошибкой. Возможно, мы это исправим.)

Использование стрелки между квадратными или круглыми скобками либо между закрывающей квадратной или фигурной скобкой и круглой скобкой при косвенном вызове подпрограммы не является обязательным. Предшествующий код можно укоротить до следующего:

$dispatch{$index}(1, 2, 3);

$array[3]{"English"}[0]二"January";

Для обычных массивов это дает многомерные массивы, такие же, как массивы в С:

$answer[$x][$y][$z] +二 42;

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

$listref->[2][2]二"hello";# Вполне понятно

$$listref[2][2]二"hello";# Несколько смущает

Вторая команда может привести в замешательство программиста на С, привыкшего использовать *a[i] для задания того, на что указывает Е-й элемент а. Но в Perl пять символов ($ @ * % &) осуществляют более сильное связывание, чем фигурные или квадратные скобки. Поэтому $$listref, а не $listref [2] принимается за ссылку на массив. Для того чтобы было как в С, нужно либо написать ${$listref [2]} и заставить $listref [2] выполняться перед разыменованием $ либо использовать обозначение ->:

$listref[2]->[$greeting] = "hello";

Использование методов объектов

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

Perl не обеспечивает инкапсуляцию. Мы не сторонники тоталитаризма. Однако мы рассчитываем на некоторую элементарную вежливость.

В обмен на эту вежливость вы получаете полную ортогональность между объектами и структурами данных. Любая структура данных может вести себя как объект, когда это требуется. Или не вести, когда не требуется.

Псевдохеши

Псевдохеш - это любая ссылка на массив, первым элементом которого является ссылка на хеш. С псевдохешем можно обращаться либо как со ссылкой на массив (что естественно), либо как со ссылкой на хеш (что может быть неожиданным). Вот пример псевдохеша:

$john 二[{age => 1, eyes => 2, weight => 3}, 47, "темно-карие", 186 ];

Хеш, на который ссылается $john->[0], определяет имена ("age", "eyes", "weight") последующих элементов массива (47, "темно-карие", 186). Теперь обратиться к элементу можно с помощью любой из нотаций - хеша и массива:

$john->{weight}# Обращается к $john как к ссылке на хеш

$john->[3]# Обращается к $john как к ссылке на массив

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

$john->[0]{height} =4;# height будет элементом 4

$john->{height} = "tall"; # Или $john->[4]二"tall"

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

delete $john->[0]{height}; # Удаляет только из хеша

$john->{height};# Теперь вызовет исключительную ситуацию

$john->[4];# По-прежнему выводит "tall"

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

Чтобы избежать несоответствий, можно использовать для создания псевдохешей функцию fields:: phash, предоставляемую директивой use fields:

use fields;

$ph = fields::phash(age => 47, eyes => "коричневые", weight => 186); print $ph->{age};

Есть два способа проверки существования ключа в псевдохеше. В первом способе используется функция exists, с помощью которой проверяется, устанавливалось ли данное поле. Такое действие соответствует поведению реального хеша. Например:

use fields;

$ph= fields::phash([qw(age eyes brown)], [47]);

$ph->{eyes} = undef;

print exists $ph->{age};print exists $ph->{weight};print exists $ph->{eyes};print exists $ph->{age};print exists $ph->{weight};print exists $ph->{eyes};True, 'age' установлен по объявлению.

print exists $ph->{age};

print exists $ph->{weight};

print exists $ph->{eyes};

print exists $ph->{age};

print exists $ph->{weight};

print exists $ph->{eyes};

False, 'weight' не использовался.

True, было присвоение 'eyes'.

Второй способ - использовать exists с хешем соответствия, находящимся в первом элементе массива. При этом проверяется, является ли данный ключ допустимым полем для этого псевдохеша:

print exists $ph->[O]{age};# Тrue, 'age' является допустимым полем

print exists $ph->[O]{name}; # False, 'name' нельзя использовать

В отличие от того, что происходит в настоящем хеше, вызов delete для элемента псевдохеша удаляет только значение массива, соответствующее ключу, а не действительный ключ в хеше соответствия. Чтобы удалить ключ, нужно явно удалить его из хеша соответствия. После этого использовать имя данного ключа в индексе псевдохеша уже нельзя:

print delete $ph->{age}; # print exists $ph->{age}; # print exists $ph->[O]{age}; # print delete $ph->[O]{age}; # print $ph->{age}; #print delete $ph->{age}; # print exists $ph->{age}; # print exists $ph->[O]{age}; # print delete $ph->[O]{age}; # print $ph->{age}; #Удаляет и возвращает $ph->[1], 47Теперь falseTrue, ключ 'age' еще естьТеперь ключа 'age' нетОшибка на этапе исполненияУдаляет и возвращает $ph->[1], 47Теперь falseTrue, ключ 'age' еще естьТеперь ключа 'age' нетОшибка на этапе исполнения

print delete $ph->{age}; # print exists $ph->{age}; # print exists $ph->[O]{age}; # print delete $ph->[O]{age}; # print $ph->{age}; #

print delete $ph->{age}; # print exists $ph->{age}; # print exists $ph->[O]{age}; # print delete $ph->[O]{age}; # print $ph->{age}; #

Удаляет и возвращает $ph->[1], 47

Теперь false

True, ключ 'age' еще есть

Теперь ключа 'age' нет

Ошибка на этапе исполнения

Удаляет и возвращает $ph->[1], 47

Теперь false

True, ключ 'age' еще есть

Теперь ключа 'age' нет

Ошибка на этапе исполнения

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

Такие свойства псевдохешей, как скорость, эффективность и проверка доступности на этапе компиляции (можно рассматривать ее как контроль типов), особенно удобны при создании эффективных и надежных модулей классов. См. обсуждение директивы use fields в главе 12 «Объекты» и в главе 31 «Модули прагм».

Псевдохеши являются новой и относительно экспериментальной функцией, поэтому их реализация вполне может подвергнуться изменениям в будущем. Чтобы не пострадать от таких изменений, всегда используйте документированный интерфейс модуля fields с его функциями phash и new.

Другие приемы работы с жесткими ссылками

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

@reflist = (\$s, \@а, \%h, \&f);# Список из четырех ссылок

@「eflist 二 \($s, @а %h, &f);# To же самое

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

@「eflist 二 \(@х);# Интерполировать массив, затем получить ссылки

@「eflist 二 map { \$_ } @х;# То же самое

То же происходит при наличии внутренних скобок:

@「eflist = \(@х, (@у));# Разыменовываются только одиночные составные

объекты

@「eflist 二(\@х, map { \$_ } @у);# То же самое

Если попробовать проделать это с хешем, то результат будет содержать ссылки на значения (ожидаемый результат) и ссылки на копии ключей (довольно неожиданный результат).

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

@env「efs 二 \@ENV{'HOME', 'TERM'};# Обратная косая черта перед срезом

@env「efs 二 \( $ENV{HOME}, $ENV{TERM} ); # Обратная косая черта перед списком @env「efs 二(\$ENV{HOME}, \$ENV{TERM} ); # Список из двух ссылок

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

@「eflist 二 \fx();

@reflist 二 map { \$_ } fx();# To же самое

@「eflist 二 \( fx(), fy(), fz());

@「eflist = ( \fx(), \fy(), \fz() );# To же самое

@reflist 二 map { \$_ } fx(), fy(), fz();# To же самое

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

@reflist = \localtime(); # Ссылки на все 9 элементов времени $lastref = \localtime(); # Ссылка на признак летнего времени

В этом отношении обратная косая черта ведет себя как именованные списковые операторы Perl, такие как print, reverse и sort, всегда предоставляющие списковый контекст в правой части независимо от того, что происходит в левой. Как и с именованными списковыми операторами, явно используйте scalar, чтобы установить для следующих операндов скалярный контекст:

$date「ef = \scalar localtime(); # \"Sat Jul 16 11:42:18 2000"

Чтобы определить, на что указывает ссылка, можно использовать оператор ref. Рассматривайте ref как оператор《typeof», который возвращает истину, если его аргумент представляет собой ссылку, и ложь в противном случае. Возвращаемое значение зависит от типа объекта ссылки. Встроенными типами являются SCALAR, ARRAY, HASH, CODE, GLOB, REF, LVALUE, 10, 10: '.Handle и Regexp. Вот как можно проверить аргументы подпрограммы:

sub sum {

my $arrayref = shift;

warn "He ссылка на массив" if ref($arrayref) ne "ARRAY"; return eval join("+", @$arrayref);

}

Жесткая ссылка, применяемая в строковом контексте, превращается в строку, содержащую тип и адрес: SCALAR(OxlfcOe). (Обратное преобразование невозможно, поскольку при преобразовании в строку теряются данные о счетчике использования ссылки, а также потому, что было бы опасно позволить программе обращаться к адресу памяти, указываемому в произвольной строке.)

Посредством оператора bless можно устанавливать связь между объектом ссылки и пакетом, действующим как класс объектов. После его выполнения ref возвращает не внутренний тип, а имя класса. При использовании ссылки на объект в строковом контексте возвращается строка, содержащая внешний и внутренний тип, а также адрес памяти: MyType=HASH(0x20d10) или 10: : Handle=IO(0x186904). Дополнительные сведения об объектах см. в главе 12 «Объекты».

Поскольку способ, выбранный для разыменовывания, всегда указывает, какого вида объект ссылки нам нужен, typeglob может использоваться так же, как ссылка, несмотря на то, что typeglob содержит несколько объектов ссылки разных типов. Поэтому ${*main: :foo} и ${\$main: :foo} обращаются к одной и той же скалярной переменной, хотя последнее обращение более эффективно.

Вот прием, с помощью которого можно вставить в строку значение, возвращаемое подпрограммой:

print "На этот раз моя подпрограмма возвратила @{[ mysub(1,2,3) ]}.\п";

Работает это так. На этапе компиляции, когда обнаруживается @{...} в двойных кавычках, это выражение анализируется как блок, возвращающий ссылку. В блоке имеются квадратные скобки, создающие ссылку на анонимный массив, состоящий из того, что находится в скобках. Поэтому на этапе исполнения mysub(1,2,3) вызывается в списковом контексте, а результаты помещаются в анонимный массив, ссылка на который возвращается в блоке. Эта ссылка на массив немедленно разыменовывается охватывающим @{...}, а значение массива вставляется в строку в двойных кавычках, как это было бы сделано с обычным массивом. Такое крючкотворство удобно использовать и с произвольными выражениями, например:

print "Нам нужно @{ [$п + 5] } штуковин!\п";

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

print "mysub возвращает теперь @{ [scalar mysub(1,2,3)] }.\n";

Замыкания

Ранее мы говорили о создании анонимных подпрограмм с помощью безымянного sub {}. Можно рассматривать такие подпрограммы как определяемые на этапе исполнения, а это означает, что для них существует момент генерации и должно быть известно местонахождение определения. Во время создания подпрограммы в области видимости могут находиться одни переменные, а при ее вызове - другие переменные.

Забудем на мгновение о подпрограммах и рассмотрим ссылку на лексическую переменную:

{

my $critter = "camel"; $critterref = \$critter;

}

Значением $$critterref останется "camel", несмотря на то, что $critter исчезает после закрывающей фигурной скобки. Но $critterref с таким же успехом могла ссылаться на подпрограмму, ссылающуюся на $critter:

{

my $critter 二"camel";

$critterref = sub { return $critter };

Это и есть замыкание (closure), понятие которого пришло из области функционального программирования в LISP и Scheme. Оно означает, что если анонимная функция определена в некоторой лексической области видимости в определенный момент, то при вызове этой подпрограммы позднее извне этой области она должна вести себя так, будто находится в этой области видимости. (Пурист сказал бы, что она ничего не должна - она действительно выполняется в этой области видимости.)

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

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

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

sub make_saying {

my $salute = shift; my $newfunc = sub { my $target 二 shift; print "$salute, $target!\n";

}；

return $newfunc;# Возвращает замыкание

}

$f = make_saying("Howdy");# Создает замыкание

$g = make_saying("Greetings"); # Создает еще одно замыкание

# Прошло некоторое время...

$f->("world");

$g->("earthlings");

В результате выводится:

Howdy, world!

Greetings, earthlings!

Особенно обратите внимание на то, что $salute продолжает ссылаться на фактическое значение, переданное в make_saying, хотя my $salute вышла из области видимости ко времени выполнения подпрограммы. Для этого и предназначены замыкания. Поскольку $f и $д содержат ссылки на функции, которым при вызове требуется доступ к разным версиям $salute, эти версии автоматически сохраняются. Если теперь перезаписать $f, то ее версия $salute автоматически исчезнет. (Perl производит уборку только тогда, когда вы этого не видите.)

Perl не предоставляет ссылки на методы объектов (описываемые в главе 12 «Объекты»), но аналогичных результатов можно добиться с помощью замыкания. Допустим, что нам нужна ссылка не просто на подпрограмму, представляющую метод, но такая, которая может вызывать этот метод с определенным объектом. Легко сохранить объект и метод в качестве лексических переменных, увязанных в замыкании:

sub get_method_ref {

my ($self, $methodname)二 @_;

my $meth「ef 二 sub {

# @_ внизу не та же, что вверху! return $self->$methodname(@_);

}；

return $methref;

my $dog = new Doggie::my $dog = new Doggie::Name 二〉"Lucky", Legs => 3,Tail => "clippedName 二〉"Lucky", Legs => 3,Tail => "clipped# # # ## # # #у меня новая собачонка по кличке Везунчик, у нее три ногиу меня новая собачонка по кличке Везунчик, у нее три ногикуцый хвост.куцый хвост.

my $dog = new Doggie::

my $dog = new Doggie::

Name 二〉"Lucky", Legs => 3,

Tail => "clipped

Name 二〉"Lucky", Legs => 3,

Tail => "clipped

# # # #

# # # #

у меня новая собачонка по кличке Везунчик, у нее три ноги

у меня новая собачонка по кличке Везунчик, у нее три ноги

куцый хвост.

куцый хвост.

'wag');'wag');# Вызывает $dog->wag('tail').# Вызывает $dog->wag('tail').$wagger->("tail");$wagger->("tail");our $wagge「 = get_method_ref($dog,

'wag');

'wag');

# Вызывает $dog->wag('tail').

# Вызывает $dog->wag('tail').

$wagger->("tail");

$wagger->("tail");

Теперь можно заставить Везунчика (Lucky) вилять (wag) тем, что осталось от его хвоста, даже когда лексическая переменная $dog уйдет из области видимости и Lucky не будет видно: глобальная переменная $wagge「заставит его выполнить команду wag, где бы он ни находился.

Замыкания как шаблоны функций

Использование замыкания в качестве шаблона функции позволяет генерировать несколько функций, действующих аналогичным образом. Допустим, нам нужен набор функций, генерирующих изменение цвета шрифта в HTML:

print "Будь ", red("осторожен "), "с этим ", дгееп("огнем"), "!!!";

Функции red и green должны быть очень похожи. Хотелось бы дать им имена, но у замыканий имен нет, т. к. они представляют собой просто анонимные подпрограммы. Чтобы обойти это обстоятельство, прибегнем к хитрому трюку. Можно связать ссылку на код и существующее имя, присвоив его переменной typeglob с именем функции, которая нам нужна. См. раздел «Таблицы имен» главы 10 «Пакеты» • В данном случае это будет привязка к двум разным именам, одному на верхнем регистре и другому 一 на нижнем:

@colors = qw(red blue green yellow orange purple violet); for my $name (@colors) {

no strict 'refs';# Разрешить символические ссылки

*$name = *{uc $name} = sub { "<FONT COLOR='$name'>;@_</FONT>" };

}

Теперь можно вызывать функции с именами red, RED, blue, BLUE и т. д.; при этом будет вызываться соответствующее замыкание. Этот прием уменьшает продолжительность компиляции и экономит память, а также уменьшает вероятность ошибок, поскольку проверка синтаксиса происходит во время компиляции. Важно, чтобы при создании замыкания все переменные в анонимной подпрограмме были лексическими. Этим обосновывается появление ту в приведенном коде.

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

*$name 二 sub ($) { "<FONT COLOR='$name'>$_[O]</FONT>" };

Это почти хорошо. Однако, поскольку проверка прототипа происходит на этапе компиляции, вышеприведенное присвоение на этапе исполнения не слишком полезно, т. к. происходит слишком поздно. Положение можно поправить, поместив весь цикл присваиваний в блок BEGIN, чтобы они происходили на этапе компиляции. (Скорее всего, его нужно поместить в модуль, загружаемый use на этапе компиляции.) В этом случае прототипы будут иметь видимость на всем протяжении компиляции.

Вложенные подпрограммы

Если вы привыкли (при работе с другими языками) использовать подпрограммы, которые вкладываются в другие подпрограммы, причем в каждой из них есть собственные закрытые переменные, то в Perl это потребует некоторых дополнительных усилий. Именованные подпрограммы вкладываются одна в другую неправильно, в отличие от анонимных. Тем не менее, мож-

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

sub outer {

my $х = $_[0] + 35;

local *inner = sub { return $x * 19 }; return $x + inner();

}

Теперь inner может вызываться только из outer, поскольку в замыкании выполняются временные присвоения. Но если она вызывается, то получает обычный доступ к лексической переменной $х из области видимости outer.

При этом возникает интересный эффект создания функции, локальной для другой функции, что в Perl, вообще говоря, не поддерживается. Поскольку local имеет динамическую область видимости и поскольку имена функций являются глобальными в своих пакетах, любая другая функция, которую вызывает outer, может также вызвать временную версию inner. Чтобы помешать этому, нужно ввести еще один уровень косвенной адресации:

sub outer {

my $х = $_[0] + 35;

my $inner 二 sub { return $x * 19 }; return $x + $inner->();

}

Символические ссылки

Что произойдет, если попытаться разыменовать значение, не являющееся жесткой ссылкой? Это значение будет рассматриваться как символическая ссылка (symbolic reference). Это означает, что ссылка интерпретируется как строка, содержащая имя глобальной переменной.

$name = "bam";$$name 二 1;$name->[0]二 4;$name->{X} = "Y";@$name =();keys %$name;&$name;$name = "bam";$$name 二 1;$name->[0]二 4;$name->{X} = "Y";@$name =();keys %$name;&$name;Вот как это действует:

$name = "bam";

$$name 二 1;

$name->[0]二 4;

$name->{X} = "Y";

@$name =();

keys %$name;

&$name;

$name = "bam";

$$name 二 1;

$name->[0]二 4;

$name->{X} = "Y";

@$name =();

keys %$name;

&$name;

Устанавливает $bam

Устанавливает первый элемент @bam

Устанавливает элемент X массива %bam равным Y

Очищает @bam

Возвращает ключи %bam

Вызывает &bam

Это очень мощное средство и несколько опасное, потому что можно намереваться (совершенно искренне) использовать жесткую ссылку, но случайно указать вместо нее символическую. Чтобы защититься от этого, можно сделать так:

use strict 'refs';

и тогда до конца охватывающего блока будут разрешены только жесткие

ссылки. Вложенный блок может отменить это постановление с помощью

no strict 'refs';

Важно также понимать различие между следующими двумя строками кода:

${identifier}# То же, что $identifier.

${"identifier"}； # Тоже Sidentifier, но символическая ссылка.

Поскольку во второй форме использованы двойные кавычки, она воспринимается как символическая ссылка, и если действует use strict ' refs', то будет сгенерировано сообщение об ошибке. Даже если strict ' refs' не действует, ссылка может осуществляться только на переменную пакета. Первая же форма идентична формату без скобок и будет ссылаться даже на переменную с лексической областью видимости, если таковая объявлена. В следующем примере это демонстрируется (а в следующем разделе обсуждается).

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

our $value = "global"; {

my $value = "private";

print "Inside, mine is ${value}, print "but ours is ${'value'}.\n";

}

print "Outside, ${value} is again ${'value'}.\n";

что выводит:

Inside, mine is private, Outside, global is again [Внутри - мое приватное, Снаружи глобальное так иInside, mine is private, Outside, global is again [Внутри - мое приватное, Снаружи глобальное так иbut ours is global, global.а наше - глобальное, остается глобальным.]but ours is global, global.а наше - глобальное, остается глобальным.]

Inside, mine is private, Outside, global is again [Внутри - мое приватное, Снаружи глобальное так и

Inside, mine is private, Outside, global is again [Внутри - мое приватное, Снаружи глобальное так и

but ours is global, global.

а наше - глобальное, остается глобальным.]

but ours is global, global.

а наше - глобальное, остается глобальным.]

Фигурные скобки, квадратные скобки и кавычки

В предыдущем разделе мы отметили, что ${identifier} не считается символической ссылкой. Вас может заинтересовать, как в этом участвуют зарезервированные слова, и кратким ответом будет: «Никак». Несмотря на то что push является зарезервированным словом, следующие две команды выводят "pop on over":

$push 二"pop on

print "${push}over";

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

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

print ${push} . 'over';

или даже (поскольку пробелы не имеют значения):

print ${ push } . 'over';

одинаково выводят "pop on over", несмотря на то, что фигурные скобки находятся вне двойных кавычек. То же правило применимо к любому идентификатору, используемому в качестве индекса хеша. Поэтому вместо:

$hash{ "ааа" }{ "bbb" }{ "ссс" }

можно просто написать:

$hash{ ааа }{ bbb }{ ссс }

или:

$hash{aaa}{bbb}{ccc}

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

$hash{ shift }

интерпретируется как $hash{"shift"}. Добиться интерпретации как зарезервированного слова можно с помощью добавления чего-либо, лишающего положения просто идентификатора:

$hash{ shift() }

$hash{ +shift }

$hash{ shift @_ }

Ссылки не действуют в качестве ключей хеша

Ключи хешей внутренне хранятся как строки. Если попытаться сохранить ссылку в качестве ключа хеша, значение ключа будет преобразовано в строку:

$х{ \$а } = $а;

($key, $value)二 each %х;

print $$key;# НЕВЕРНО

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

произойдет разыменование не жесткой ссылки, а символической - а т. к., вероятно, переменной с именем SCALAR(OxlfcOe) нет, то попытку завершить не удастся. Скорее надо сделать что-то вроде:

$г = \@а;

$х{ $г } = $г;

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

Хотя нельзя сохранить ссылку как ключ, если (как в вышеприведенном примере) жесткая ссылка используется в строковом контексте, гарантировано, что она создаст уникальную строку, т. к. в результирующую строку включается адрес ссылки. Поэтому на практике можно использовать ссылку в качестве уникального ключа хеша. Просто нельзя будет потом разыменовать ее.

Существует один особый вид хеша, в котором можно использовать ссылки в качестве ключей. Благодаря волшебству (magic) модуля Tie: : Ref Hash, поставляемого с Perl, то, что, как мы только что сказали, сделать нельзя, на самом деле сделать можно:

use Tie::RefHash;

tie my %h, 'Tie::RefHash';

%h 二(

["this", "here"] => "at home",

["that", "there"] => "elsewhere",

)；

while ( my($keyref, $value)二 each %h ) { print "@$keyref is $value\n";

}

На самом деле, связывая (tie) различные реализации со встроенными типами, можно добиться от скаляров, хешей и массивов многого из того, чего, как мы говорили, они не могут. Ну, каковы! Бестолковые авторы...

Подробнее о связывании см. главу 14 «Связанные переменные».

Сборка мусора, циклические ссылки и слабые ссылки

Языки высокого уровня обычно позволяют программистам не заботиться об освобождении памяти, которая больше не используется. Этот автоматический процесс переработки отходов известен как сборка мусора (garbage collection). В большинстве случаев Perl использует быстрый и простой способ сборки мусора, основанный на ссылках.

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

{# заставим $а и $Ь указывать друг на друга

ту ($а, $Ь);

$а 二 \$b;

$Ь = \$а;

}

или еще проще:

{# заставим $а указывать на саму себя

ту $а;

$а 二 \$а;

}

Несмотря на то что $а следует освободить в конце блока, это сделано не будет. При создании рекурсивных структур данных необходимо самостоятельно разорвать (или ослабить, см. ниже) автоссылки, если требуется, чтобы память была утилизирована прежде, чем программа (или поток) завершит работу. (При выходе память будет освобождена автоматически путем дорогостоящей, но полной процедуры сборки мусора типа «пометка и очистка» (mark-and-sweep).) Если структура данных является объектом, то для автоматического разрыва ссылки можно применить метод DESTROY; см. раздел «Сборка мусора с помощью методов DESTROY» в главе 12 «Объекты».

Аналогичная ситуация может иметь место с кэшами - хранилищами данных для ускоренного извлечения. Вне кэша есть ссылки на данные, находящиеся в нем. Проблема возникает, когда все эти ссылки уничтожены, но данные в кэше со своими внутренними ссылками остались. Существование хотя бы одной ссылки не позволяет Perl утилизировать объект ссылки, даже если мы хотим, чтобы данные исчезали из кэша, как только в них отпала нужда. Как и в случае циклических ссылок, нам нужна ссылка, которая не влияет на счетчик ссылок и потому не задерживает сборку мусора.

Слабые ссылки (weak references) решают проблемы, вызываемые циклическими ссылками и кэшированными данными, разрешая «ослабить» любую ссылку, т. е. сделать так, чтобы она не влияла на счетчик ссылок. Когда удаляется последняя не слабая ссылка на объект, он уничтожается, и все слабые ссылки на объект автоматически освобождаются.

Для использования этой возможности необходим пакет WeakRef из С PAN, в котором содержится дополнительная документация. Слабые ссылки являются экспериментальной функцией. Но кто-то же должен быть подопытным кроликом.

9

Структуры данных

Perl предоставляет многие готовые структуры данных, которые в других языках приходится создавать самостоятельно. Стеки и хеши, изучаемые будущими специалистами по информатике, в Perl являются просто массивами. Когда к массиву применяются push и pop (или shift и unshift), это стек; когда к массиву применяются push и shift (или unshift и pop), это очередь. А многие из встречающихся древовидных структур создаются только для обеспечения быстрого динамического доступа к таблицам поиска, концептуально являющимся плоскими. Хеши, конечно, встроены в Perl и обеспечивают быстрый динамический доступ к таблицам поиска, концептуально являющимся плоскими, без использования структур данных, от рекурсивнос- ти которых цепенеют мозги, и которые кажутся красивыми тем, чьи мозги уже достаточно оцепенели.

Но иногда вложенные структуры данных нужны, потому что они естественным образом моделируют решаемую задачу. Поэтому Perl позволяет комбинировать и вкладывать массивы и хеши для создания структур данных произвольной сложности. При надлежащем применении они могут применяться для создания связанных списков, двоичных деревьев, куч, бинарных деревьев, множеств, графов и всего, что вы еще придумаете. См. книги «Mastering Algorithms with Perl», O'Reilly 1999 (Язык Perl и реализация алгоритмов); «Perl Cookbook», О*Reilly 1998 («Perl: библиотека программиста», СПб, изд. «Питер», 2000) или CPAN - главное хранилище таких модулей. Однако возможно, что вам никогда не понадобится ничего сверх простых сочетаний массивов и хешей, поэтому о них-то мы и поговорим в этой главе.

Массивы массивов

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

Создание двумерного массива и доступ к нему

Вот как собирается двумерный массив:

^Присвоить массиву список ссылок на массивы.

@АоА =(

["feed", "barney"],

["george", "jane", "elroy"],

["homer", "marge", "bart"],

)；

print $AoA[2][1];# выводит "marge"

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

# Создать ссылку на массив ссылок на массивы.

$「ef_to_AoA =[

["fred", "barney", "pebbles", "bamm bamm", "dino",],

["homer", "bart", "marge", "maggie",],

["george", "jane", "elroy", "judy",],

]；

print $ref_to_AoA->[2][3];# выводит "judy"

Помните, что между каждой парой примыкающих фигурных или квадратных скобок подразумевается присутствие ->. Поэтому следующие две строки:

$АоА[2][3]

$「ef_to_AoA->[2][3]

эквивалентны таким двум строкам:

$АоА[2]->[3]

$「ef_to_AoA->[2]->[3]

Здесь, однако, перед первой парой квадратных скобок не подразумевается присутствия ->, но для разыменования $ref_to_AoA начальный -> требуется. Помните также, что можно вести обратный отсчет от конца массива с помощью отрицательного индекса, поэтому:

$АоА[0][-2]

является предпоследним элементом первой строки.

Наращивание массива

Такие присвоения большим спискам годятся для создания фиксированных структур данных, но как быть, если нужно вычислять каждый элемент на лету или иным образом строить структуру по частям?

Прочтем структуру данных из файла. Будем предполагать, что это плоский текстовый файл, в котором каждая строчка является строкой данных и состоит из элементов, разделяемых пробельными символами. Вот как нужно действовать:

while (о) {

@tmp 二 split;# Расщепить элементы в массив.

push @АоА, [ @tmp ];# Добавить к @АоА ссылку на анонимный массив.

}

Конечно, нет необходимости давать имя временному массиву, поэтому можно сказать и так:

while (<>) {

push @АоА, [ split ]; }

Если нужна ссылка на массив массивов, можно сделать так:

while (о) {

push @$ref_to_AoA, [ split ];

}

В обоих этих примерах к массиву массивов добавляются новые строки. А как добавить новые колонки? При работе с двумерными массивами часто проще всего использовать обычное присваивание:

forfor# Для каждой строки...# Для каждой колонки...# ...присвоить этой ячейке# Для каждой строки...# Для каждой колонки...# ...присвоить этой ячейке$х (09) {

for

for

# Для каждой строки...

# Для каждой колонки...

# ...присвоить этой ячейке

# Для каждой строки...

# Для каждой колонки...

# ...присвоить этой ячейке

for $у (0 .. 9) {

$АоА[$х][$у]二 func($x, $у); }

for $х ( 0..9 ) {

$ref_to_AoA->[$x][3]二 func2($x); }

# Для каждой строки...

# ...установить четвертую колонку

Порядок присваивания элементам значений не важен, как и то, существуют ли уже элементы @АоА с указываемыми индексами: Perl охотно создаст их для вас, установив, как водится, промежуточные элементы равными неопределенному значению. (Perl даже создаст, при необходимости, первую ссылку в $「ef_to_AoA.) Для добавления строки нужно сделать нечто более замысловатое:

# Добавить новые колонки к существующей строке.

push @{ $АоА[0] }, "wilma", "betty";

Обратите внимание, что следующая команда не будет работать:

push $АоА[0], "wilma", "betty"; # НЕВЕРНО!

Это даже не будет скомпилировано, потому что аргумент команды push должен быть настоящим массивом, а не ссылкой на массив. Поэтому первый аргумент обязательно должен начинаться с символа @. То, что следует за @, может быть предметом обсуждения.

Доступ к массивам и вывод

А теперь выведем структуру данных. Если нужен только один элемент, достаточно следующего:

print $АоА[3][2];

Но чтобы напечатать весь массив, нельзя просто сказать:

print @АоА;# НЕВЕРНО

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

for $「ow ( @АоА ) { print "@$row\n";

}

Если вы хотите следить за индексами, то можно сделать так:

for $i ( 0 .. $#АоА ) { print "строка $i: @{$AoA[$i]}\n";

}

или даже так (обратите внимание на внутренний цикл):

for $i ( 0 .. $#АоА ) {

for $j ( 0 .. $#{$AoA[$i]} ) {

print "элемент $i $j : $AoA[$i][$j]\n";

}

}

Как видите, дело немного усложняется. Поэтому иногда проще решить задачу с помощью временной переменной:

for $i ( 0 .. $#АоА ) {

$row = $AoA[$i];

for $j ( 0 .. $#{$「ow} ) {

print "элемент $i $j : $row->[$j]\n";

}

}

Срезы

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

©part =();

for ($у = 7; $у < 13; $у++) {

push ©part, $АоА[4][$у];

}

Данный цикл можно заменить срезом массива:

©part = @{ $АоА[4] } [ 7..12 ];

Если требуется двумерный срез, например, для $х в диапазоне 4.. 8 и $у в диапазоне 7. . 12, то его можно получить так:

@newAoA =();

for ($startx = $х = 4; $х <= 8; $х++) {

for ($starty = $у = 7; $у <= 12; $у++) {

$newAoA[$x - $startx][$y - $starty] = $АоА[$х][$у];

}

}

В этом примере отдельные значения нашего целевого двумерного массива @newAoA присваиваются одно за другим, взятые из двумерного подмассива @АоА. Другой возможностью является создание анонимных массивов, каждый из которых состоит из нужного среза подмассива @АоА, и помещение ссылок на эти анонимные массивы в @newAoA. В этом случае мы будем записывать ссылки в @newAoA (так сказать, один раз проиндексированный), а не значения подмассива в дважды проиндексированный @newAoA. При таком методе устраняется самый внутренний цикл:

for ($х = 4; $х <= 8; $х++) {

push @newAoA, [ @{ $АоА[$х] } [ 7..12 ]];

}

Конечно, если вы делаете это часто, то, вероятно, следует написать подпрограмму, назвав ее, например, extract_rectangle. А если вы делаете это очень часто и с большими наборами многомерных данных, то следует, вероятно, воспользоваться модулем PDL (Perl Data Language), который можно получить из СР AN.

Распространенные ошибки

Как говорилось ранее, массивы и хеши в Perl являются одномерными. Даже «многомерные» массивы фактически имеют в Perl одно измерение, но значения в них являются ссылками на другие массивы, сжимающими несколько элементов в один. При выводе этих значений без разыменования будут получены не требуемые данные, а ссылки, преобразованные в строки. Например, следующие две строки:

@АоА 二([2, 3], [4, 5, 7], [0]);

print "@АоА";

выводят нечто типа:

ARRAY(0x83c38) ARRAY(0x8b194) ARRAY(Ox8b1dO)

С другой стороны, следующая строка выводит 7:

print $АоА[1][2];

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

for $i (1. .10) {

@аггау 二 somefunc($i);

$AoA[$i]二 @array; # НЕВЕРНО!

}

Здесь доступ к @а「「ау осуществляется в скалярном контексте и поэтому дает число его элементов, которое послушно присваивается элементу $AoA[$i]. Как правильно присваивать ссылку, будет показано через мгновение.

Сделав такую ошибку, человек понимает, что нужно присвоить ссылку, поэтому следующая естественная ошибка - это многократное получение ссылки на один и тот же адрес:

for $i (1..10) {

@аггау = somefunc($i);

$AoA[$i]二 \@array; # СНОВА НЕВЕРНО!

}

Все ссылки, создаваемые во второй строке цикла, будут одинаковыми, а именно ссылками на единственный массив @агтау. Да, этот массив изменяется при каждом проходе цикла, но когда все закончено, $АоА содержит

10 ссылок на один и тот же массив, в котором содержится последний набор присвоенных ему значений. Вывод @{$АоА[1]} показывает те же значения, что и вывод @{$АоА[2]}・

Вот более удачный подход:

for $i (1..10) {

@array 二 somefunc($i);

$AoA[$i] = [ @a「「ay ];# ПРАВИЛЬНО!

}

Квадратные скобки вокруг массива @агтау создают новый анонимный массив, в который копируются значения элементов @а「гау・ Затем мы запоминаем ссылку на этот новый массив.

Аналогичный результат производится кодом (более трудно читаемым):

for $i (1. .10) {

@array 二 somefunc($i);

@{$AoA[$i]} = @array;

}

Поскольку элемент $AoA[$i] должен быть новой ссылкой, эта ссылка создается. Затем предшествующий @ разыменовывает эту новую ссылку, в результате чего значения @аггау присваиваются (в списковом контексте) массиву, на который ссылается $AoA[$i]・ Возможно, чтобы код был более понятным, такой конструкции следует избегать.

Однако есть ситуация, в которой можно было бы ее использовать. Допустим, что @АоА уже является массивом ссылок на массивы, т. е. выполнены присваивания типа:

$АоА[3]二 \@original_array;

А теперь предположим, что нужно изменить @original_array (т. е. четвертую строку $АоА) так, чтобы он ссылался на элементы @а「「ау. Для этого подойдет такой код:

@{$АоА[3]}二 @array;

В данном случае сама ссылка не меняется, изменяются элементы массива, на который производится ссылка. В результате перезаписываются значения массива @original_array.

Наконец, следующий страшно выглядящий код прекрасно работает:

for $i (1..10) {

my @array 二 somefunc($i);

$AoA[$i]二 \@array;

}

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

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

for $i (1..10) {

$AoA[$i]二[somefunc($i)];

}

Подведем итоги:

$AoA[$i] = [ @array ];# Самое безопасное, иногда самое быстрое

$AoA[$i]二 \@array; # Быстро, но рискованно, зависит от ту массива

@{ $AoA[$i] } = @array; # Несколько мудрено

Овладев применением массивов, состоящих из массивов, вы захотите заняться более сложными структурами данных. Тот, кто ищет структуры С или записи Pascal, не найдет в Perl зарезервированных слов, которые их создают. Вместо них предоставляется более гибкая система. Если вы считаете, что структура записи должна быть менее гибкой, или хотите дать своим пользователям нечто менее прозрачное и более жесткое, то можете воспользоваться объектно-ориентированными функциями, подробно описываемыми в главе 12 «Объекты».

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

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

Хеши массивов

Используйте хеш массивов, когда нужно находить каждый массив по некоторой строке, а не просто по номеру индекса. В нашем примере с персонажами телесериалов вместо того, чтобы просматривать списки имен 0-й передачи, 1-й передачи и т. д., мы сделаем так, что можно будет найти состав действующих лиц по названию передачи.

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

Формирование хеша массивов

Хеш анонимных массивов можно создать так:

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

%НоА 二( flintstones => [ "fred", "barney"], jetsons=> [ "george", "jane", "elroy"],

simpsons=> [ "homer", "marge", "bart"],

)；

Чтобы добавить к хешу еще один массив, можно просто сказать:

$HoA{teletubbies}二["tinky winky", "dipsy", "laa-laa", "po"];

Генерирование хеша массивов

Вот несколько приемов, с помощью которых можно заполнить хеш массивов. Чтобы произвести чтение из массива следующего формата:

flintstones: fred barney wilma dino

jetsons:george jane elroy

simpsons:homer marge bart

можно использовать один из следующих циклов:

while ( <> ) {

next unless s/^(.*?)：\s*//;

$HoA{$1} = [ split ];

}

while ( $line = <> ) {

($who, $rest) = split /:\s*/, $line, 2;

@fields = split ' ', $rest;

$HoA{$who} = [ @fields ];

}

Если имеется подпрограмма get_family, которая возвращает массив, можно использовать ее для заполнения %НоА с помощью одного из двух следующих циклов:

for $group ( "simpsons", "jetsons", "flintstones" ) { $HoA{$group}二[get_family($group)];

}

for $group ( "simpsons", "jetsons", "flintstones" ) { @members 二 get_family($group); $HoA{$group}二[@members ];

}

Новые члены можно дописать к существующему массиву следующим образом:

push @{ $HoA{flintstones} }, "wilma", "pebbles";

Доступ к хешу массивов и вывод его элементов

Присвоить значение первому элементу некоторого массива можно так:

$НоА{flintstones}[0]二"Fred";

Для записи с заглавной буквы второго из Симпсонов примените подстановку к соответствующему элементу массива:

$HoA{simpsons}[1] =~ s/(\w)/\u$1/;

Все семейства можно вывести, пройдя в цикле все ключи хеша:

for $family ( keys %НоА ) { print "$family: @{ $HoA{$family} }\n"; }

Приложив некоторые дополнительные усилия, можно добавить и индексы массивов:

for $family ( keys %НоА ) { print "$family:";

for $i ( 0 .. $#{ $HoA{$family} } ) { print " $i = $HoA{$family}[$i]";

} print "\n";

}

Или отсортировать массивы по числу входящих в них элементов:

for $family ( sort { @{$HoA{$b}} <=> @{$HoA{$a}} } keys %HoA ) { print "$family: @{ $HoA{$family} }\n"

}

Или даже отсортировать массивы по числу элементов, а затем упорядочить массивы в соответствии с таблицей ASCII (или, более точно, utf8):

Вывести все, упорядочив по числу элементов и фамилиям.

for $family ( sort { @{$HoA{$b}} <=> @{$HoA{$a}} } keys %HoA ) {

print "$family: ", join(", ", sort @{ $HoA{$family} }), "\n

Массивы хешей

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

Формирование массива хешей

Массив анонимных хешей можно создать так:

@АоН 二(

husband wife sonhusband wife son=> "barney", 二〉"betty",=> "barney", 二〉"betty",bamm bamm",bamm bamm",

husband wife son

husband wife son

=> "barney", 二〉"betty",

=> "barney", 二〉"betty",

bamm bamm",

bamm bamm",

wife sonwife son=> "elroy'=> "elroy'wife sonwife sonmarge",marge",二〉"bart二〉"bart

wife son

wife son

=> "elroy'

=> "elroy'

wife son

wife son

marge",

marge",

二〉"bart

二〉"bart

husband => "george",

jane",

husband 二〉"homer",

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

push @АоН, { husband => "fred", wife 二〉"wilma", daughter 二〉"pebbles" };

Генерирование массива хешей

Вот несколько приемов, с помощью которых можно заполнить массив хешей. Чтобы произвести чтение из массива такого формата:

husband^fred friend=barney

можно использовать один из следующих циклов:

while ( о ) {

$гес = {};

for $field ( split ) {

($key, $value)二 split /二/, $field;

$rec->{$key} = $value;

}

push @АоН, $гес;

}

while ( <> ) { push @АоН, { split /[\s=]+/ };

}

Если имеется подпрограмма get_next_pair, которая возвращает пары ключ/ значение, можно применить ее для заполнения @АоН с помощью одного из двух следующих циклов:

while ( @fields = get_next_pair() ) { push @AoH, { @fields };

}

while (<>) { push @AoH, { get_next_pair($_) };

}

Новые члены можно дописать к существующему хешу так:

$AoH[0]{pet} = "dino";

$AoH[2]{pet} = "santa's little helper";

Доступ к массиву хешей и вывод его элементов

Задать пару ключ/значение в некотором хеше можно так:

$AoH[0]{husband}二"fred";

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

$AoH[1]{husband} =~ s/(\w)/\u$1/;

Вывести все данные можно так:

for $href ( @АоН ) { print "{ for $role ( keys %$href ) { print "$role=$href->{$role}";

} print "}\n";

}

и с индексами:

for $i ( 0 .. $#AoH ) { print "$i is {"; for $role ( keys %{ $AoH[$i] } ) { print "$role=$AoH[$i]{$role}";

}

print ”}\n”；

Хеши хешей

Многомерный хеш является самой гибкой из вложенных структур Perl. Он напоминает запись, которая, в свою очередь, содержит другие записи. На каждом уровне индекс хеша задается с помощью строки (при необходимости заключаемой в кавычки). Не забывайте, однако, что пары ключ/значение извлекаются из хеша в произвольном порядке. Для извлечения пар в нужном порядке можно использовать функцию sort.

Формирование хеша хешей

Хеш анонимных хешей можно создать так:

%НоН

flintstones => {"fred", "barney"husband pal=>=>jetsons => { husband=>"george"wife=>"jane","his boy"=>"elroy",simpsons => { husband=>"homer",wife=>"marge",kid=>"barf,flintstones => {"fred", "barney"husband pal=>=>jetsons => { husband=>"george"wife=>"jane","his boy"=>"elroy",simpsons => { husband=>"homer",wife=>"marge",kid=>"barf,},},# Ключи должны быть в кавычках.# Ключи должны быть в кавычках.

flintstones => {

"fred", "barney"

husband pal

=>

=>

jetsons => { husband

=>

"george"

wife

=>

"jane",

"his boy"

=>

"elroy",

simpsons => { husband

=>

"homer",

wife

=>

"marge",

kid

=>

"barf,

flintstones => {

"fred", "barney"

husband pal

=>

=>

jetsons => { husband

=>

"george"

wife

=>

"jane",

"his boy"

=>

"elroy",

simpsons => { husband

=>

"homer",

wife

=>

"marge",

kid

=>

"barf,

},

},

# Ключи должны быть в кавычках.

# Ключи должны быть в кавычках.

）；

Чтобы добавить к %НоН еще один анонимный хеш, можно просто сказать:

$НоН{ mash } = { captain => "pierce" major => "burns", corporal => "radar",

Генерирование хеша хешей

Вот несколько приемов, с помощью которых можно заполнить хеш хешей.

Чтобы произвести чтение из массива такого формата:

flintstones: husband=fred pal=barney wife=wilma pet=dino

можно использовать один из следующих циклов:

while ( о ) { next unless s/X. *?) ：\s*〃； $who 二 $1;

for $field ( split ) {

($key, $value) = split /=/, $field; $HoH{$who}{$key}二 $value;

}

}

while ( <> ) {

next unless s/^(.*?)：\s*//;

$who 二 $1;

$rec 二{};

$HoH{$who} = $rec;

for $field ( split ) {

($key, $value)二 split /=/, $field;

$rec->{$key}二 $value;

Если имеется подпрограмма get_family, которая возвращает список пар ключ/значение, можно использовать ее для заполнения %НоН с помощью одного из трех следующих фрагментов кода:

for $group ( "simpsons", "jetsons", "flintstones" ) { $HoH{$group} = { get_family($group) };

}

for $group ( "simpsons", "jetsons", "flintstones" ) { @members 二 get_family($group);

$HoH{$group}二{ @members };

}

sub hash-families { my @ret;

for $group ( @_ ) {

push @ret, Sgroup, { get_family($group) };

} return @ret;

}

%HoH 二 hash_families( "simpsons", "jetsons", "flintstones");

Новые члены можно дописать к существующему хешу так:

%new_folks =( wife => "wilma", pet => "dino";

)；

for $what (keys %new_folks) {

$HoH{flintstones}{$what}二 $new_folks{$what};

Доступ к хешу хешей и вывод его элементов

Установить значение пары ключ/значение в некотором хеше можно так:

$НоН{flintstones}{wife} = "wilma";

Для записи с заглавной буквы некоторой пары ключ/значение примените к элементу подстановку:

$HoH{jetsons}{'his boy'} =~ s/(\w)/\u$1/;

Состав всех семейств можно вывести путем перебора в цикле ключей внешнего хеша, а затем - перебора в цикле ключей внутреннего хеша:

for $family ( keys %НоН ) {

print "$family:

for $role ( keys %{ $HoH{$family} } ) { print "$role=$HoH{$family}{$role}";

}

print "\n"；

}

Для очень больших хешей несколько более быстрым способом может оказаться одновременное извлечение ключей и значений с помощью each (что помешает сортировке):

while ( ($family, $roles) = each %HoH ) { print "$family:";

while ( ($role, $person) = each %$roles ) { print "$role=$person ";

}

print "\n";

}

(К несчастью, как раз большие хеши и приходится сортировать, в противном случае в выведенном невозможно найти то, что требуется.) Можно отсортировать семейства, а затем роли следующим образом:

for $family ( sort keys %HoH ) { print "$family:";

for $role ( sort keys %{ $HoH{$family} } ) { print "$role=$HoH{$family}{$role}";

}

print "\n"；

}

Чтобы отсортировать семейства по числу членов (а не по ASCII (или utf8)), можно использовать keys в скалярном контексте:

for $family ( sort { keys %{$HoH{$a}} <=> keys %{$HoH{$b}} } keys %HoH ) { print "$family:";

for $role ( sort keys %{ $HoH{$family} } ) { print "$role=$HoH{$family}{$role}";

}

print "\n";

}

Для сортировки членов семейств в некотором фиксированном порядке можно присвоить им ранги:

$i = 0;

for ( qw(husband wife son daughter pal pet) ) { $rank{$_} = ++$i }

for $family ( sort { keys %{$HoH{$a}} <=> keys %{$HoH{$b}} } keys %HoH ) { print "$family: ”；

for $role ( sort { $rank{$a} <=> $rank{$b} } keys %{ $HoH{$family} } ) { print "$role=$HoH{$family}{$role}";

}

print "\n"；

Хеши функций

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

if ($cmd =~ /Fxit$/i) elsif ($cmd =~ /^helpS/i) elsif ($cmd =~ /^watchS/i) elsif ($cmd =~ /^mailS/i) elsif ($cmd =~ /"editS/i) elsif ($cmd =~ /^delete$/i) else {if ($cmd =~ /Fxit$/i) elsif ($cmd =~ /^helpS/i) elsif ($cmd =~ /^watchS/i) elsif ($cmd =~ /^mailS/i) elsif ($cmd =~ /"editS/i) elsif ($cmd =~ /^delete$/i) else {{ exit }{ show_help() }{ Swatch = 1 }{ mail_msg($msg) }{ $edited++; editmsg($msg); }{ confirm_kill() }{ exit }{ show_help() }{ Swatch = 1 }{ mail_msg($msg) }{ $edited++; editmsg($msg); }{ confirm_kill() }

if ($cmd =~ /Fxit$/i) elsif ($cmd =~ /^helpS/i) elsif ($cmd =~ /^watchS/i) elsif ($cmd =~ /^mailS/i) elsif ($cmd =~ /"editS/i) elsif ($cmd =~ /^delete$/i) else {

if ($cmd =~ /Fxit$/i) elsif ($cmd =~ /^helpS/i) elsif ($cmd =~ /^watchS/i) elsif ($cmd =~ /^mailS/i) elsif ($cmd =~ /"editS/i) elsif ($cmd =~ /^delete$/i) else {

{ exit }

{ show_help() }

{ Swatch = 1 }

{ mail_msg($msg) }

{ $edited++; editmsg($msg); }

{ confirm_kill() }

{ exit }

{ show_help() }

{ Swatch = 1 }

{ mail_msg($msg) }

{ $edited++; editmsg($msg); }

{ confirm_kill() }

warn "Неизвестная команда: '$cmd'; попробуйте вызвать'help'\n }

В структурах данных можно запоминать ссылки на функции точно так же, как ссылки на массивы и хеши:

%HoF =( exit help watch mail edit delete

# Формирование хеша функций

=> sub { exit },

=> \&show_help,

=> sub { Swatch = 1 },

=> sub { mail_msg($msg) },

=> sub { $edited++; editmsg($msg); },

=> \&confirm_kill,

);

if ($HoF{lc $cmd}) { $HoF{lc $cmd}->() }# Вызов функции

else { warn " Неизвестная команда: '$cmd'; попробуйте вызвать'help'\n" }

В предпоследней строке проверяется, существует ли заданное имя команды (на нижнем регистре) в «таблице рассылки», %HoF. Если да, то мы вызываем соответствующую команду, разыменовывая значение хеша как функцию и передавая этой функции пустой список аргументов. Мы могли бы разыменовать ее также как &{ $HoF{lc $cmd} }() или, в версии Perl 5.6, просто $HoF{lc $cmd}().

Более сложные записи

То, что мы до сих пор видели в этой главе, представляет собой простые двухуровневые однородные структуры данных: каждый элемент содержит объекты ссылки того же типа, что и остальные элементы на том же уровне. Так, конечно, должно быть не обязательно. Любой элемент может содержать скаляр любого типа, т. е. может быть строкой, числом или ссылкой на что угодно. Ссылка может быть ссылкой на массив или хеш, псевдохешем, ссылкой на именованную или анонимную функцию или объект. Единственное, чего нельзя делать, это помещать в один скаляр несколько объектов ссылки. Если вы обнаружите, что делаете такую попытку, значит, вам нужна ссылка на массив или хеш, чтобы сжать несколько значений в одно.

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

Формирование, доступ и вывод более сложных записей

Вот запись, содержащая шесть в корне отличающихся по типу полей:

$гес = {

TEXT

=> $string,

SEQUENCE

=> [@old_values ],

LOOKUP

=> { %some_table },

THATCODE

=> \&some_function,

THISCODE

=> sub { $_[0] ** $_[1] },

HANDLE

=> \*STDOUT,

}；

Поле TEXT является обыкновенной строкой, поэтому его можно вывести: print $гес->{ТЕХТ};

SEQUENCE и LOOKUP представляют собой обычные ссылки на массив и хеш:

print $rec->{SEQUENCE}[O];

$last = pop @{ $rec->{SEQUENCE} };

print $rec->{LOOKUP}{"key"};

($first_k, $first_v) = each %{ $rec->{LOOKUP} };

THATCODE - это именованная подпрограмма, a THISCODE - анонимная подпрограмма, но вызываются они идентичным образом:

$that_answer = $rec->{THATCODE}->($arg1, $arg2);

$this_answer = $rec->{THISCODE}->($arg1, $arg2);

С помощью дополнительной пары фигурных скобок можно обращаться с $rec->{HANDLE} как с косвенным объектом:

print { $rec->{HANDLE} } "строка\п";

А применение модуля FileHandle позволяет даже обращаться с дескриптором как с обычным объектом:

use FileHandle;

$rec->{HANDLE}->autoflush(1);

$rec->{HANDLE}->print("CTpOKa\n");

Формирование, доступ и вывод еще более сложных записей

Естественно, что поля ваших структур данных «имеют право» сами быть структурами данных произвольной сложности:

%TV =(

flintstones => 《 series => nights => members =>

{ name -

"flintstones",

["monday", "thursday", "friday"],

[

=> "fred", role => "husband", age => 36, },

{name=>"wilma",role=>"wife",age=> 31,},

{name=>"pebbles",role=>"kid",age=> 4,},

series => "jetsons”，

nights => [ "Wednesday", "Saturday"], members => [

{name=>"george",role=>"husband",age=>41,},

{ name :

-> "jane", role => "wife", age => 39, },

{ name => "elroy", role => "kid", age => 9, },

simpsons => {

series 二〉"simpsons",

nights => [ "monday"], members => [

{name=>"homer",role二〉"husband",age=> 34,},

{name=>"marge",role二〉"wife",age=> 37,},

{name=>"barf,role=>"kid",age=>11,},

Генерирование хеша сложных записей

Поскольку Perl хорошо анализирует сложные структуры данных, можно поместить объявления данных в отдельный файл в виде обычного кода Perl,

а затем загружать их с помощью встроенных функций do или require. Другим распространенным подходом является применение модуля CPAN (такого, как XML: :Parser) для загрузки произвольных структур данных, описанных на каком-то другом языке (например, XML).

Можно строить структуры данных по частям:

$гес = {};

$rec->{series} = "flintstones";

$rec->{nights} = [ find_days()];

Или считывать их из файла (в данном случае предполагается использование синтаксиса поле=значение):

©members =(); while (о) {

%fields = split /[\s二]+/; push @members, { %fields };

}

$rec->{members} = [ ©members ];

И вкладывать их в более крупные структуры данных, используя в качестве ключа одно из подполей:

$TV{ $rec->{series} }二 $rec;

Применение дополнительных полей с указателями позволяет избежать дублирования данных. Например, в запись о человеке можно включить поле "kids", которое может быть ссылкой на массив, содержащий ссылки на собственные записи, относящиеся к детям. Заставив одни части структуры данных ссылаться на другие, можно избежать противоречивости данных, возникающей при их обновлении лишь в одном месте из нескольких необходимых:

for $family (keys %TV) {

my $rec = $TV{$family};# временный указатель

@kids =();

for $person ( @{$rec->{members}} ) { if ($person->{role} =~ /kid|son|daughter/) { push @kids, Sperson;

} } # $rec и $TV{$family} указывают на одни и те же данные! $rec->{kids} = [ @kids ];

}

Присваивание $rec->{kids} = [ @kids ] копирует содержимое массива, которое представляет собой просто ссылки на некопируемые данные. Это значит, что если увеличить возраст Барта:

# увеличивает до 12# увеличивает до 12$TV{simpsons}{kids}[0]{аде}++;

# увеличивает до 12

# увеличивает до 12

то, поскольку $TV{simpsons}{kids}[0] и $TV{simpsons}{members}[2] указывают на одну и ту же анонимную хеш-таблицу, мы увидим следующий результат:

print $TV{simpsons}{members}[2]{age}; # тоже выводит 12

Теперь выведем всю структуру %TV:

for $family ( keys %TV ) {

print "the $family";

print " is on ", join (" and ", @{ $TV{$family}{nights} }), "\n";

print "its members are:\n";

for $who ( @{ $TV{$family}{members} } ) {

print " $who->{name} ($who->{role}), age $who->{age}\n";

}

print "children: ”；

print join (", ", map { $_->{name} } @{ $TV{$family}{kids} });

print "\n\n";

Сохранение структур данных

Если вы хотите сохранить свои структуры данных для использования в дальнейшем другой программой, то сделать это можно несколькими способами. Проще всего применить модуль Perl Data::Dumper, который преобразует структуру данных (возможно, содержащую ссылки на саму себя) в строку, которую можно сохранить во внешней памяти, а затем воспроизвести с помощью eval или do.

use Data::Dumper;

$Data::Dumper::Purity = 1;# поскольку %TV содержит ссылки на себя

open (FILE, "> tvinfo.perldata") or die "невозможно открыть tvinfo: $!"; print FILE Data::Dumper->Dump([\%TV], ['*TV]);

close FILEor die "невозможно закрыть tvinfo: $!";

Отдельная программа (или та же самая) может позже считать этот файл:

open (FILE, "< tvinfo.perldata") or die "невозможно открыть tvinfo: $!";

undef $/;# считать сразу весь файл

eval <FILE>;# воссоздать %TV

die "невозможно воссоздать данные tv из tvinfo.perldata: $@" if $@;

close FILEor die "невозможно закрыть tvinfo: $!";

print $TV{simpsons}{members}[2]{age};

или просто:

do "tvinfo.perldata"or die " невозможно воссоздать tvinfo: $! $@";

print $TV{simpsons}{members}[2]{age};

Есть много других решений, в которых формат записи изменяется от упакованного двоичного (очень быстрого) до XML (очень совместимого). Сегодня же посмотрите на ближайшем зеркале CPAN!

10

Пакеты

В этой главе мы добрались до приятных вещей, поскольку речь пойдет о разработке программного обеспечения. Если мы собираемся обсуждать правильное проектирование программного обеспечения, то должны поговорить о Лени, Нетерпении и Самодовольстве - основах правильной разработки программного обеспечения.

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

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

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

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

Первый шаг на пути к экологически чистому программированию очень прост: не надо мусорить в парке. Когда вы пишете некоторый код, подумайте о создании для него собственного пространства имен, чтобы ваши переменные и программы никого не обидели, и наоборот. Пространство имен немного похоже на ваш собственный дом, в котором можно быть сколь угодно неряшливым, соблюдая, конечно, во взаимодействии с прочими гражданами достаточные приличия. В Perl пространство имен называется пакетом (package). Пакеты образуют те базовые строительные блоки, из которых сооружаются понятия модулей и классов, находящиеся на более высоком уровне.

Как и понятие «дом», понятие «пакет» несколько туманно. Пакеты не зависят от файлов. Можно иметь много пакетов в одном файле и один пакет, охватывающий несколько файлов, точно так же, как ваш дом может быть маленькой мансардой в большом здании (если вы - голодающий художник), а может состоять из нескольких зданий (если вас зовут королева Елизавета). Но обычный размер дома - одно здание, а обычный размер пакета - один файл. Perl оказывает особую помощь тем, кто хочет поместить пакет в один файл, если только они согласны дать файлу то же имя, что и пакету и использовать расширение ・рт, что представляет собой сокращение от «perl module». Модуль является в Perl фундаментальной единицей повторного использования кода. На практике обращение к модулю осуществляется с помощью директивы компилятора use, управляющей импортом из модуля подпрограмм и переменных. Все виденные вами до сих пор случаи применения use были примерами повторного использования модулей.

Архив Perl (Comprehensive Perl Archive Network, или CPAN) - то место, куда вы должны поместить свои модули, если считаете, что они могут оказаться полезными другим. Процветание Perl вызвано готовностью программистов поделиться плодами своего труда с обществом. Естественно, на СР AN можно найти модули, заботливо помещенные туда другими для всеобщего пользования. Подробности см. в разделе «СРAN» главы 22 и на www.cpan.org.

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

Эта книга не посвящена объектно-ориентированным технологиям, и мы не собираемся обращать вас в неистового фанатика объектной ориентированности, даже если вы этого хотите. Для этого уже существует масса книг. Философия Perl в отношении объектно-ориентированной разработки соот-

ветствует его философии в отношении всего прочего: прибегать к объектноориентированной разработке там, где это имеет смысл, и избегать там, где этого смысла нет. Выбор за вами.

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

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

Как упоминалось в главе 8 «Ссылки», объектно-ориентированное программирование в Perl реализуется через ссылки, объекты которых «знают», к какому классу они принадлежат. Фактически, теперь, когда вы знаете о ссылках, вы знаете почти обо всем сложном, что есть в объектах. Все остальное «находится в пальцах», как сказал бы пианист. Конечно, нужно немного попрактиковаться.

Одно из основных упражнений для пальцев состоит в том, чтобы научиться защищать различные фрагменты кода от непреднамеренного взаимного воздействия на переменные. Каждый участок кода принадлежит определенному пакету, который определяет, какие переменные и подпрограммы ему доступны. Когда Perl встречает фрагмент кода, то компилирует его в то, что называется текущим пакетом. Первоначальный текущий пакет называется «main», но в любой момент вы можете переключить текущий пакет на другой с помощью объявления package. Текущий пакет определяет, какая таблица имен используется для поиска переменных, подпрограмм, дескрипторов ввода/вывода и форматов.

Любые переменные, не объявленные с ключевым словом ту, ассоциируются с пакетом - даже кажущиеся вездесущими переменные типа $_ и %SIG. На самом деле такой вещи, как глобальная переменная, в Perl фактически нет. (Специальные идентификаторы, такие как _ и SIG, просто кажутся глобальными, поскольку их пакетом по умолчанию является main, а не текущий.)

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

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

внутри своей охватывающей области видимости и только в ней, независимо от объявлений пакетов.)

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

На идентификаторы в других пакетах можно ссылаться, ставя префикс идентификатора в виде имени пакета и удвоенного двоеточия: $Пакет: беременная («квалифицируя» его). Если имя пакета пусто, предполагается использование пакета main. Это значит, что $:: sail эквивалентно $main:: sail.

Прежним ограничителем пакетов была одинарная кавычка, поэтому в старых программах Perl можно увидеть переменные типа $main'sail и $some- pack' horse. Но сейчас предпочтительным ограничителем является удвоенное двоеточие - отчасти потому, что его легче читать человеку, отчасти потому, что его легче читать макросам emacs. Он также позволяет программистам C++ чувствовать себя как дома - в противоположность использованию одинарной кавычки в качестве разделителя, которая должна была помочь в том же программистам Ada. Поскольку старомодный синтаксис все еще поддерживается для обратной совместимости, то в такой строке, как "This is $ow- пег's house", будет выполнено обращение к $owner: :s; т. е. переменной $s в пакете owner, чего вы, возможно, не желали. Двусмысленности можно избежать при помощи фигурных скобок, например, "This is ${owner} 's house".

Удвоенное двоеточие может применяться для связывания в цепочку идентификаторов в имени пакета: $Red:: Blue: :var. Это обозначает переменную $var, принадлежащую пакету Red::Blue. Пакет Red: :В1ие не имеет никакого отношения к возможно существующим пакетам Red или Blue. То есть, связь между Red:: Blue и Red или Blue может что-то означать для того, кто пишет или использует программу, но ничего не значит для Perl. (Кроме того обстоятельства, что в текущей реализации таблица имен Red:: Blue хранится в таблице имен Red. Но язык Perl прямо этого не использует.)

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

Только идентификаторы (имена, начинающиеся с буквы или символа подчеркивания) хранятся в таблице имен пакета. Все остальные имена хранятся в пакете main, в том числе все небуквенные переменные, такие как $!, $? и $_. Кроме того, идентификаторы STDIN, STDOUT, STDERR, ARGV, ARGVOUT, ENV, INC и SIG, если они не квалифицированы, принудительно помещаются в пакет main, даже если используются для других целей, нежели их встроенные тезки. Не называйте свои пакеты m, s, у, tr, q, qq, qr, qw или qx, если только не хотите нажить себе множество неприятностей. Например, вы не сможете использовать квалифицированную форму идентификатора в качестве дескриптора файла, поскольку она будет интерпретирована как поиск по шаблону, подстановка или транслитерация.

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

Хеш %SIG (предназначенный для перехвата сигналов; см. главу 16 «Межпроцессное взаимодействие») тоже является особым. Если определить обработчик сигнала как строку, то она будет указывать на подпрограмму в пакете main, если только явно не задано имя другого пакета. Задавайте полностью квалифицированное имя обработчика сигнала, если вы хотите указать конкретный пакет, или вообще избегайте использования строк, осуществляя вместо этого присвоение typeglob или ссылки на функцию:

$SIG{QUIT} ="Pkg::quit_catcher"; #полностью квалифицированное имя обработчика

$SIG{QUIT} ="quit_catcher";#подразумевается "main::quit_catcher"

$SIG{QUIT} =*quit_catcher;#устанавливает sub из текущего пакета

$SIG{QUIT} =\&quit_catcher;#устанавливает sub из текущего пакета

$SIG{QUIT} = sub { print "Перехвачен SIGQUIT\n" };# анонимная sub

Понятие «текущего пакета» относится как к этапу компиляции, так и к этапу исполнения. Большинство операций поиска имен переменных происходит на этапе компиляции, а поиск на этапе исполнения случается при разыменовании символических переменных, а также когда новые фрагменты кода анализируются при выполнении eval. В частности, когда eval применяется к строке, Perl знает, в каком пакете была вызвана eval, и распространяет действие этого пакета внутри обрабатываемой строки. (Конечно, внутри строки eval всегда можно переключиться в другой пакет, поскольку строка eval считается блоком, как и файл, загруженный с помощью do, require или use.)

С другой стороны, eval может узнать, в каком пакете она находится, с помощью специального символа __PACKAGE__, в котором содержится имя текущего пакета. Поскольку допускается обращение с ним как со строкой, можно использовать его в символической ссылке для доступа к переменной пакета. Но в таком случае, вероятно, следовало бы объявить переменную с ключевым словом our, чтобы к ней можно было обращаться как к лексической переменной.

Таблицы имен

Содержимое пакета в совокупности называется таблицей имен (symbol table). Таблица имен хранится в хеше, имя которого совпадает с именем пакета, но дополнено двумя двоеточиями. Таким образом, именем таблицы для main служит %main::. Поскольку main оказывается и пакетом по умолчанию, Perl допускает сокращенное имя %:: для %main::.

Аналогично, таблица имен для пакета Red:: Blue носит имя %Red:: Blue::. Таблица имен main содержит все остальные таблицы имен верхнего уровня, включая саму себя, поэтому %Red: :Blue:: в то же время является и %та- in::Red::Blue:

Когда мы говорим, что таблица имен содержит другую таблицу имен, мы имеем в виду, что она содержит ссылку на другую таблицу имен. Поскольку main является пакетом верхнего уровня, он содержит ссылку на самого себя, поэтому %main:: это то же самое, что и %main: : main: :, и %main: : main: : main: :, и т. д. до бесконечности. Этот особый случай важно учитывать при написании кода, который обходит все таблицы имен.

Внутри хеша таблицы имен каждая пара ключ/значение устанавливает соответствие между именем переменной и ее значением. Ключи представляют собой символические идентификаторы, а значения являются соответствующими typeglob. Поэтому посредством обозначения *NAME typeglob мы, в действительности, просто обращаемся к значению в хеше, который содержит таблицу имен текущего пакета. На самом деле следующие строки имеют (почти) одинаковый эффект:

*sym = *main::variable;

*sym = $main::{"variable"};

Первая строка более эффективна, потому что доступ к таблице имен main может осуществляться на этапе компиляции. Она также создает новый typeglob с указанным именем, если его еще не существует, а вторая форма - нет.

Поскольку пакет представляет собой хеш, можно найти ключи пакета и получить все его переменные. А так как значения хеша являются typeglob, разыменовывать их можно несколькими способами. Например, так:

foreach $symname (sort keys %main::) {

local *sym = $main::{$symname};

print "\$$symname определен\п" if defined $sym;

print "\@$symname не нуль\п" if@sym;

print "\%$symname не нуль\п" if%sym;

}

Все пакеты доступны (прямо или косвенно) через пакет main, поэтому можно написать код Perl, который обойдет все переменные программы. Именно это делает отладчик Perl, когда вы запрашиваете у него дамп переменных с помощью команды V. Заметьте, что при этом не будут видны переменные, объявленные с помощью ту, поскольку они не зависят от пакетов, но будут видны переменные, объявленные через our. См. главу 20 «Отладчик».

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

$!@#$%=0;#НЕВЕРНО, синтаксическаяошибка.

${'!@#$%'}= 1;#0k, хотя не квалифицирована.

${'main::!@#$%'}= 2;#Можно квалифицировать встроке.

print ${ $main::{'!@#$%'} }#Ok, выводит 2!

Присвоение для typeglob осуществляет операцию создания псевдонима, т. е. в результате

*dick 二 richard;

переменные, подпрограммы, форматы, дескрипторы файлов и каталогов, доступные через идентификатор richard, оказываются доступными и через имя dick. Для того чтобы создать псевдоним только для конкретной переменной или подпрограммы, используйте ссылку:

*dick = \$richard;

В результате $richard и $dick становятся одной и той же переменной, но @「ic- hard и @dick остаются разными массивами. Ловко, не правда ли?

Вот как работает Exporter при импорте имен из одного пакета в другой. Например,

*SomePack::dick 二 \&OtherPack::richard;

импортирует функцию &richard из пакета OtherPack в пакет SomePack, делая ее доступной как функцию &dick・ (Модуль Exporter описывается в следующей главе.) Если перед присвоением поставить local, то псевдоним будет действовать только до конца текущей динамической области видимости.

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

my %newhash = (km => 10, kg => 70); return \%newhash;

Аналогично можно передать ссылку в подпрограмму и использовать ее без разыменования:

%units 二(miles => 6, stones => 11);

# Передача ссылки# Выводит 4# Передача ссылки# Выводит 4fillerup( \%units );

# Передача ссылки

# Выводит 4

# Передача ссылки

# Выводит 4

print $units{quarts};

sub fillerup {

local *hashsym 二 shift; # Присвоить \%units для typeglob

$hashsym{quarts} = 4;# Действует на %units; не требуется разыменования!

}

Это ловкие приемы для передачи ссылок без лишних затрат, когда вы не хотите явно их разыменовывать. Обратите внимание на то, что оба приема работают только с переменными пакета; их нельзя использовать, если объявить %units как ту.

С помощью таблиц имен можно также создавать скалярные «константы»:

*Р1 = \3.14159265358979;

Теперь изменить $Р1 нельзя, что, вообще-то, правильно. Это не то же самое, что подпрограмма-константа, оптимизируемая на этапе компиляции. Подпрограмма-константа -это такая подпрограмма, в прототипе которой указано, что она не принимает аргументов и возвращает постоянное выражение; подробности можно найти в разделе «Подставляемые функции-константы» главы 6 «Подпрограммы». Удобным сокращением является использование директивы use constant (см. главу 31 «Модули прагм»):

use constant PI => 3.14159;

При реализации используется место для подпрограммы *Р1, а не место для скаляра, как ранее. Это эквивалентно более компактной (но хуже читаемой) записи:

*PI = sub () { 3.14159 };

Однако это удобная идиома, которую нужно знать: присвоение sub {} для typeglob является способом дать имя анонимной подпрограмме на этапе выполнения.

Присвоить ссылку на typeglob другой переменной typeglob (*sym = \*oldvar) означает то же самое, что присвоить всю typeglob, потому что Perl автоматически разыменовывает ссылку на typeglob. А когда typeglob присваивается обычная строка, она становится именем typeglob в целом, потому что Perl ищет строку в текущей таблице имен. Все нижеследующие строки эквивалентны между собой, но первые две вычисляют элемент таблицы имен на этапе компиляции, а вторые две - на этапе исполнения:

*sym = *oldvar;*sym = \*oldvar;*sym = *{"oldvar"};*sym 二 "oldvar";*sym = *oldvar;*sym = \*oldvar;*sym = *{"oldvar"};*sym 二 "oldvar";автоматическое разыменование

*sym = *oldvar;

*sym = \*oldvar;

*sym = *{"oldvar"};

*sym 二 "oldvar";

*sym = *oldvar;

*sym = \*oldvar;

*sym = *{"oldvar"};

*sym 二 "oldvar";

явный поиск в таблице имен

неявный поиск в таблице имен

Осуществляя любое из следующих присваиваний, мы заменяем только одну ссылку внутри typeglob:

*sym 二 \$frodo;

*sym = \@sam;

*sym = \%merry;

*sym = \&pippin;

*pkg::sym{SCALAR}# то же, что\$pkg::sym*pkg::sym{ARRAY}# то же, что\@pkg::sym*pkg::sym{HASH}# то же, что\%pkg::sym*pkg::sym{CODE}# то же, что\&pkg::sym*pkg::sym{GLOB}# то же, что\*pkg::sym*pkg::sym{SCALAR}# то же, что\$pkg::sym*pkg::sym{ARRAY}# то же, что\@pkg::sym*pkg::sym{HASH}# то же, что\%pkg::sym*pkg::sym{CODE}# то же, что\&pkg::sym*pkg::sym{GLOB}# то же, что\*pkg::sym*pkg::sym{I0}*pkg::sym{I0}*ркд::sym{NAME}*ркд::sym{PACKAGE}*ркд::sym{NAME}*ркд::sym{PACKAGE}внутренний дескриптор файла/каталога, нет прямого эквивалента"sym" (не ссылка)"ркд" (не ссылка)внутренний дескриптор файла/каталога, нет прямого эквивалента"sym" (не ссылка)"ркд" (не ссылка)Если взглянуть на это со стороны, то typeglob можно рассматривать как хеш, содержащий записи для различных типов переменных. В данном случае ключи фиксированы, поскольку typeglob может содержать ровно один скаляр, один массив, один хеш и т. д. Но можно извлекать отдельные ссылки:

*pkg::sym{SCALAR}

# то же, что

\$pkg::sym

*pkg::sym{ARRAY}

# то же, что

\@pkg::sym

*pkg::sym{HASH}

# то же, что

\%pkg::sym

*pkg::sym{CODE}

# то же, что

\&pkg::sym

*pkg::sym{GLOB}

# то же, что

\*pkg::sym

*pkg::sym{SCALAR}

# то же, что

\$pkg::sym

*pkg::sym{ARRAY}

# то же, что

\@pkg::sym

*pkg::sym{HASH}

# то же, что

\%pkg::sym

*pkg::sym{CODE}

# то же, что

\&pkg::sym

*pkg::sym{GLOB}

# то же, что

\*pkg::sym

*pkg::sym{I0}

*pkg::sym{I0}

*ркд::sym{NAME}

*ркд::sym{PACKAGE}

*ркд::sym{NAME}

*ркд::sym{PACKAGE}

внутренний дескриптор файла/каталога, нет прямого эквивалента

"sym" (не ссылка)

"ркд" (не ссылка)

внутренний дескриптор файла/каталога, нет прямого эквивалента

"sym" (не ссылка)

"ркд" (не ссылка)

Выражения *foo{PACKAGE} и *foo{NAME} позволяют узнать, каковы имя и пакет для элемента таблицы имен *foo. Это может оказаться полезным в подпрограмме, которой typeglob передаются в качестве аргументов:

sub identify_typeglob { my $glob 二 shift; print 'Вы передали мне ', *{$glob}{PACKAGE}, '::', *{$glob}{NAME}, "\n"； }

identify_typeglob(*foo);

identify_typeglob(*bar::glarch);

В результате выводится:

Вы передали мне main::foo

Вы передали мне bar::glarch

Обозначение *foo{77HWG} можно использовать для получения ссылок на отдельные элементы *foo. Подробности см. в разделе «Ссылки на таблицы имен» главы 8 «Ссылки».

Этот синтаксис служит, в основном, для получения внутренней ссылки на дескриптор файла или каталога, поскольку другие внутренние ссылки можно получить иным способом. (Прежнее *foo{FILEHANDLE} все же поддерживается в значении *foo{10}, только не думайте, что это имя позволит отличить дескрипторы файлов от дескрипторов каталогов.) Но мы решили, что еле-

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

Автозагрузка

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

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

sub AUTOLOAD {

our $AUTOLOAD;

warn "Попытка вызвать $AUTOLOAD не удалась.\n";

}

blarg(10);# наша $AUTOLOAD получит значение main::blarg

print "Все еще живы!\n";

Либо можно возвратить значение от имени не определенной подпрограммы:

sub AUTOLOAD {

our $AUTOLOAD;

return "Я вижу $AUTOLOAD(@_)\n";

}

print blarg(20);# выводит: Я вижу main::blarg(20)

Ваша подпрограмма AUTOLOAD может загрузить определение для неопределенной подпрограммы с помощью eval или require, либо прибегнуть к обсуждавшемуся выше приему с присвоением glob, а затем выполнить эту неопределенную подпрограмму с применением специальной формы goto, которая может без следа стереть запись активации подпрограммы AUTOLOAD. Сейчас мы определим подпрограмму, присвоив замыкание переменной glob:

sub AUTOLOAD {

my $name = our $AUTOLOAD;

*$AUTOLOAD 二 sub { print "Я вижу $name(@_)\n" }; goto &$AUTOLOAD; # Запустить новую подпрограмму. }

blarg(30);# выводит: Я вижу main::blarg(30)

glarb(40); # выводит: Я вижу main::glarb(40)

blarg(50); # выводит: Я вижу main::blarg(50)

Стандартный модуль AutoSplit применяется разработчиками модулей для автоматического разделения своих модулей на отдельные файлы (имена которых заканчиваются .al ), в каждом из которых содержится одна подпрограмма. Эти файлы помещаются в каталог auto/ в системной библиотеке Perl, после чего их можно автоматически загружать по требованию с помощью стандартного модуля Autoloader.

Аналогичный подход осуществлен в модуле SelfLoader, за исключением того, что он автоматически загружает функции из собственной области DATA файла, что менее эффективно в одних отношениях и более эффективно в других. Автозагрузка функций Perl с помощью AutoLoader и Self Loader аналогична динамической загрузке скомпилированных функций С с помощью Dyna- Loader, за исключением того, что минимальная единица автозагрузки - функция, а минимальная единица динамической загрузки - целый модуль, и при этом обычно компонуется сразу много функций С или C++. (Многие программисты Perl прекрасно обходятся без модулей AutoSplit, AutoLoader, Self Loader или DynaLoader. Просто знайте, что они есть, на случай, если не сможете прекрасно обходиться без них.)

Можно неплохо развлечься, работая с программами AUTOLOAD, служащими оболочками для других интерфейсов. Давайте, например, потребуем, чтобы для каждой не определенной функции вызывалась команда system с теми же аргументами. Нужно сделать лишь следующее:

sub AUTOLOAD {

my $program 二 our $AUTOLOAD;

$program =~ s/.*:://; # обрезать имя пакета system($p「og「am, @_);

}

(Поздравляем, вы реализовали элементарную форму модуля Shell, стандартно поставляемого с Perl.) Вызвать свой автозагрузчик (в Unix) можно так:

date();

who('am', 'i');

Is('-l');

echo("Abadugabudabuda...");

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

sub date (;$$);sub who (;$$$$);sub Is;sub echo ($@);sub date (;$$);sub who (;$$$$);sub Is;sub echo ($@);Допускает от нуля до двух аргументов.

sub date (;$$);

sub who (;$$$$);

sub Is;

sub echo ($@);

sub date (;$$);

sub who (;$$$$);

sub Is;

sub echo ($@);

Допускает от нуля до четырех аргументов.

Допускает любое число аргументов.

Допускает не меньше одного аргумента.

date;

who "am", "i";

Is "-1";

echo "That's all, folks!";

11

Модули

Модуль является в Perl фундаментальной единицей повторно используемого кода. Он реализуется просто как пакет, определенный в файле с тем же именем (и .рт в конце). В этой главе мы обсудим, как можно использовать созданные другими модули и создавать собственные.

Perl поставляется с большим числом модулей, которые можно найти в каталоге lib дистрибутива Perl. Многие из этих модулей описаны в главе 32 «Стандартные модули» и главе 31 «Модули прагм». Для всех стандартных модулей имеется также обширная электронная документация, которая (о, ужас!) может быть более актуальной, чем данная книга. Попробуйте выполнить команду perldoc, если команда man не работает.

Архив Perl «Comprehensive Perl Archive Network» (CPAN) содержит общемировое хранилище модулей, созданных сообществом Perl, и обсуждается в главе 22 «CPAN». См. также http://www.cpan.org.

Использование модулей

Есть два вида модулей: традиционные и объектно-ориентированные. Традиционные модули определяют подпрограммы и переменные, которые вызывающая их сторона может импортировать и затем использовать. Объектноориентированные модули действуют как определения классов, и доступ к ним осуществляется через вызов методов, как описывается в главе 12 «Объекты». Некоторые модули делают и то и другое.

Модули Perl обычно включаются в программу с помощью команды:

use MODULE LIST;

или просто:

use MODULE',

MODULE должен быть идентификатором, соответствующим имени пакета модуля и файла. (Описания синтаксиса здесь предполагаются наводящими; полный синтаксис команды use дан в главе 29 «Функции».)

Команда use осуществляет предварительную загрузку модуля MODULE на этапе компиляции и импорт запрошенных имен, которые становятся доступными на протяжении последующей компиляции. Если не задать список LIST нужных имен, используются имена, которые содержатся во внутреннем массиве модуля @EXPORT 一 в предположении, что применяется модуль Exporter, описываемый в разделе «Закрытость модуля и Exporter» далее в этой главе. (Если LIST указан, то все его имена должны содержаться в массивах ©EXPORT или @EXPORT_OK, иначе возникнет ошибка.)

Если модули служат для импорта имен в текущий пакет Exporter, можно использовать имена модуля без квалификатора пакета:

use Fred; # Если в Fred.pm есть @EXPORT = qw(flintstone), flintstone();# ...это вызывает Fred::flintstone().

Все модули Perl имеют расширение .рт. Это (как и кавычки) предполагается обеими командами use и require, поэтому вам не нужно писать ''MODULE, pm". Применение голых идентификаторов помогает отличить новые модули от библиотек ・р2 и .р九，применявшихся в старых версиях Perl. При этом MODULE вводится также в качестве официального имени модуля, что помогает анализатору в некоторых двусмысленных ситуациях. Удвоенное двоеточие в имени модуля транслируется в разделитель каталогов, используемый системой, поэтому если ваш модуль называется Red::Blue: :Green, то Perl будет искать его как Red/Blue/Green^pm.

Perl ищет модули в каждом из каталогов, перечисленных в массиве @INC. Поскольку use загружает модули на этапе компиляции, любые изменения @INC должны происходить тоже на этапе компиляции. Сделать это можно с помощью директивы lib, описываемой в главе 32 «Модули прагм» или с помощью блока BEGIN. После включения модуля в хеш %INC добавляется пара ключ/значение. Ключом будет имя файла модуля (в нашем примере Red/ Blue/Green. pm), а значением - полный путь, которым может быть что-то вроде C:/perl/site/lib/Red/Blue/Green. pm для модуля, надлежащим образом установленного под Windows.

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

директив (директивных модулей) на нижнем регистре для использования в дальнейшем.

При загрузке модуля посредством use любой код в нем выполняется так же, как при загрузке с помощью обычного require. Если вам безразлично, когда загружается модуль - при компиляции или на этапе исполнения, можете просто сказать:

require MODULE',

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

Следующие две команды выполняют почти одно и то же:

require MODULE1, require "MODULE, pm";

Однако есть два отличия. В первой команде require транслирует удвоенные двоеточия в системный разделитель каталогов - так же, как это делает use. Во втором случае трансляция не выполняется, что вынуждает указывать имя пути к модулю литерально и делает код менее переносимым. Второе отличие в том, что первая команда require сообщает компилятору, что выражения с косвенными обозначениями объектов, включающие в себя MODULE (например, $ob 二 purge MODULE), являются вызовами методов, а не функций. (Это действительно может быть существенно, если в вашем собственном модуле имеется конфликтующее определение purge.)

Поскольку объявление use и родственное объявление по подразумевают наличие блока BEGIN, компилятор загружает модуль (и выполняет имеющийся в нем код инициализации), как только обнаруживает это объявление и прежде чем компилировать оставшуюся часть файла. Благодаря этому директивы могут влиять на работу компилятора, а модули объявлять подпрограммы, которые затем видны как списковые операторы на протяжении дальнейшей компиляции. Этого не будет, если вместо use использовать require. Едва ли не единственной причиной для применения require является наличие двух модулей, в каждом из которых требуется функция из другого модуля. (И мы не уверены, что это достаточное основание.)

Модули Perl всегда загружают файл .рт, но этот файл, в свою очередь, может загружать связанные файлы, например, динамически компонуемые библиотеки С или C++ или автоматически загружаемые определения подпрограмм Perl. При этом дополнительные файлы будут полностью прозрачны для пользователя модуля. Обязанность загрузки (или подготовки к автоматической загрузке) дополнительных функций лежит на файле .рт. Модуль POSIX осуществляет как динамическую, так и автоматическую загрузку, но можно просто сказать:

use POSIX;

и получить все экспортируемые функции и переменные.

Создание модулей

Ранее мы сказали, что у модуля есть два способа сделать свой интерфейс доступным вашей программе: экспортируя имена или разрешая вызовы методов. Здесь мы приведем пример первого стиля; второй стиль предназначен для объектно-ориентированных модулей и описывается в следующей главе. (Объектно-ориентированные модули не должны ничего экспортировать, т. к. вся идея методов заключается в том, что Perl находит их автоматически, исходя из типа объекта.)

Для конструирования модуля с именем Bestiary, создайте файл Bestiary.pm, выглядящий так:

packageBestiary;

requireExporter;

our @ISA

二 qw(Exporter);

our @EXPORT

二 qw(camel); # Имена, экспортируемые по умолчанию

our @EXPORT_OK

二 qw($weight); # Имена, экспортируемые по запросу

our $VERSION

=1.00;# Номер версии

### Здесь включаются ваши функции и переменные sub camel { print "Одногорбый верблюд" } $weight 二 1024;

1；

Теперь программа может сказать use Bestiary, чтобы получить доступ к функции camel (но не к переменной $weight), и сказать use Bestiary qw(camel $weight), чтобы получить доступ как к функции, так и к переменной.

Можно также создавать модули, динамически загружающие код, написанный на С. Подробности см. в главе 21 «Внутри и снаружи».

Закрытость модуля и Exporter

Perl не осуществляет автоматического патрулирования границ между закрытыми и открытыми элементами в своих модулях - в отличие от таких языков, как C++, Java и Ada, Perl не озабочен поддержкой закрытости. Модуль Perl предпочтет, чтобы вы не входили в его комнату, потому что вас не приглашали, а не потому, что у него есть дробовик.

Между модулем и его пользователем заключен контракт, часть которого составляет общее право, а часть записывается. Общее право устанавливает, что модуль будет воздерживаться от изменения любого пространства имен, если его об этом не просили. Письменная часть контракта для модуля (а именно документация) может ставить дополнительные условия. И тогда после прочтения контракта предполагается, что, говоря RedefineTheWorld, вы знаете, что изменяете мир и готовы к риску, связанному с последствиями этого. Самый распространенный способ переопределения миров - это ис*

пользование модуля Exporter. Как вы увидите далее в этой главе, с помощью данного модуля можно даже переопределять встроенные функции.

Если модуль загружается с помощью use, то обычно он делает некоторые переменные и функции доступными вашей программе, или, точнее, ее текущему пакету. Это действие по экспортированию имен модуля (и, таким образом, импортированию их в вашу программу) иногда называют загрязнением (polluting) вашего пространства имен. Большинство модулей использует для этого Exporter; поэтому в начале большинства модулей есть что-нибудь вроде:

require Exporter;

our @ISA = ("Exporter");

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

our @EXPORT =qw($camel %wolf ram);# Экспортпо умолчанию

our @EXPORT_OK =qw(leopard @llama $emu);# Экспортпо запросу

our %EXPORT_TAGS二(# Экспорткак группы

camelids => [qw($camel @llama)], critters => [qw(「am $camel %wolf)], )；

С точки зрения экспортирующего модуля массив ©EXPORT содержит имена переменных и функций, экспортируемых по умолчанию: то, что ваша программа получает, сказав use Bestiary. Переменные и функции в @EXPORT_OK экспортируются только тогда, когда программа специально запрашивает их в команде use. Наконец, пары ключ/значение в %EXPORT_TAGS позволяют программе включать отдельные группы имен, перечисленных в ©EXPORT и @ЕХ- PORT_OK・

С точки зрения импортирующего пакета, команда use задает список имен, которые нужно импортировать, группу, указанную в %EXPORT_TAGS, шаблон имен или вообще ничего, и тогда в программу импортируются имена, указанные в ©EXPORT.

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

use use use use use use use use useuse use use use use use use use useBestiary;Bestiary ();Bestiary qw(「am @llama);Bestiary qw(:camelids);Bestiary qw(:DEFAULT);Bestiary qw(/am/);Bestiary qw(/^\$/);Bestiary qw(:critters !ram);Bestiary;Bestiary ();Bestiary qw(「am @llama);Bestiary qw(:camelids);Bestiary qw(:DEFAULT);Bestiary qw(/am/);Bestiary qw(/^\$/);Bestiary qw(:critters !ram);##Импортировать имена из @ЕХРОВТ Ничего не импортироватьИмпортировать имена из @ЕХРОВТ Ничего не импортироватьимпортировать Импортировать Импортировать Импортировать Импортировать Импортироватьимпортировать Импортировать Импортировать Импортировать Импортировать Импортироватьфункцию ram и массив @11ата $сате1 и @11ата имена ©EXPORT$camel, @11ата и гат все скалярыcritters, за исключением гатфункцию ram и массив @11ата $сате1 и @11ата имена ©EXPORT$camel, @11ата и гат все скалярыcritters, за исключением гатBestiary qw(:critters !:camelids);Bestiary qw(:critters !:camelids);

use use use use use use use use use

use use use use use use use use use

Bestiary;

Bestiary ();

Bestiary qw(「am @llama);

Bestiary qw(:camelids);

Bestiary qw(:DEFAULT);

Bestiary qw(/am/);

Bestiary qw(/^\$/);

Bestiary qw(:critters !ram);

Bestiary;

Bestiary ();

Bestiary qw(「am @llama);

Bestiary qw(:camelids);

Bestiary qw(:DEFAULT);

Bestiary qw(/am/);

Bestiary qw(/^\$/);

Bestiary qw(:critters !ram);

#

#

Импортировать имена из @ЕХРОВТ Ничего не импортировать

Импортировать имена из @ЕХРОВТ Ничего не импортировать

импортировать Импортировать Импортировать Импортировать Импортировать Импортировать

импортировать Импортировать Импортировать Импортировать Импортировать Импортировать

функцию ram и массив @11ата $сате1 и @11ата имена ©EXPORT

$camel, @11ата и гат все скаляры

critters, за исключением гат

функцию ram и массив @11ата $сате1 и @11ата имена ©EXPORT

$camel, @11ата и гат все скаляры

critters, за исключением гат

Bestiary qw(:critters !:camelids);

Bestiary qw(:critters !:camelids);

# Импортировать critters, за исключением camelids

Отсутствие элемента в списке экспорта (или явное удаление из списка импорта с помощью восклицательного знака) не делает его недоступным программе, использующей модуль. Программа всегда может обратиться к содержимому пакета модуля, полностью квалифицировав его именем пакета, например, %Bestiary: :gecko. (Поскольку лексические переменные не принадлежат пакетам, возможность закрытия сохраняется: см. раздел «Закрытые методы» главы 12.)

Чтобы увидеть, как обрабатываются спецификации и что действительно импортируется в ваш пакет, можно сказать BEGIN { $ Exporter:: Ve「bose=1 }.

Exporter сам представляет собой модуль Perl, и, если у вас есть интерес, вы можете посмотреть, какие фокусы он выделывает с typeglob для экспорта имен из одного пакета в другой. Внутри модуля Exporter ключевой является функция import, которая осуществляет назначение псевдонимов, необходимое для того, чтобы имя одного пакета появилось в другом. На практике команда use Bestiary LIST совершенно эквивалентна

BEGIN {

require Bestiary; import Bestiary LIST; }

Это значит, что вашим модулям не обязательно обращаться к Exporter. Модуль может делать все то же, что при его использовании, т. к. use просто вызывает обычный метод import для модуля, а вы можете определить этот метод так, чтобы он выполнял все что вам угодно.

Экспортирование без вызова метода import модуля Exporter

Exporter определяет метод с именем export_to_level, применяемый в ситуациях, когда (по какой-то причине) вы не можете непосредственно вызвать метод import модуля Exporter. Метод export_to_level вызывается так:

^L//.E->export_to_level($where_to_export, @what_to_export);

где $where_to_export представляет собой целое число, указывающее, насколько далеко в стек вызовов должны экспортироваться ваши имена, а @what_to_expo「t - это массив, в котором перечислены экспортируемые имена (обычно @_).

Предположим, например, что в нашем Bestiary есть своя функция import:

package Bestiary;

@ISA = qw(Exporter);

@EXPORT_OK = qw ($zoo);

sub import {

$Bestiary::zoo = "зверинец";

Наличие этой функции import не позволяет наследовать функцию import из Exporter. Для того чтобы функция import из Bestiary, после того как она установит $Bestiary: :zoo, вела себя точно так же, как функция import из Exporter, ее следует определить так:

sub import {

$Bestiary::zoo 二"зверинец"; Bestiary->export_to_level(1, @_); }

При этом имена экспортируются на один уровень «выше» текущего пакета, т. е. в любую программу или модуль, которые используют Bestiary.

Проверка версий

Если в модуле определена переменная SVERSION, то программа, использующая этот модуль, может проверить, достаточно ли свежей является его версия. Например:

use Bestiary 3.14; # Bestiary должен иметь версию 3.14 или выше

use Bestiary v1.0.4; # Bestiary должен иметь версию 1.0.4 или выше

Эти команды преобразуются в вызовы Bestia「y->「equi「e_ve「sion, которые модуль затем наследует.

Действия при обнаружении неизвестных имен

В некоторых ситуациях может потребоваться воспрепятствовать экспорту некоторых имен. Обычно это относится к модулям, содержащим функции или константы, не имеющие смысла в некоторых системах. Можно помешать Exporter экспортировать эти имена, поместив их в массив @EXPORT_FAIL.

Когда программа пытается импортировать одно из этих имен, Exporter дает модулю возможность обработать ситуацию, прежде чем сгенерировать ошибку. Он делает это, передавая список ошибочных имен вызываемому методу export_fail, который можно определить так (в предположении, что ваш модуль использует модуль Carp):

sub export_fail { my $class = shift; carp "К сожалению, эти имена недоступны: @_"; return @_;

}

Exporter предоставляет метод export_fail, вызываемый по умолчанию, который просто возвращает в неизменном виде список и делает вызов use неуспешным, возбуждая исключительную ситуацию для каждого имени. Если export_fail возвращает пустой список, значит, ошибок не отмечено, и все запрошенные имена экспортированы.

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

Поскольку имена, перечисленные в %EXPORT_TAGS, должны также появиться в ©EXPORT или @EXPORT_OK, в Exporter есть две функции, позволяющие добавить эти помеченные группы имен:

%EXPORT_TAGS = (foo => [qw(aa bb cc)], bar => [qw(aa cc dd)]);

Exporter::export_tags('foo');# добавить aa, bb и cc в @EXP0RT

Exporter::export_ok_tags('bar'); # добавить aa, cc и dd в @EXPORT_OK

Задание имен, не являющихся тегами, вызывает ошибку.

Замещение встроенных функций

Многие встроенные функции могут быть замещены (overridden), хотя (так же, как пробивать дыры в стенах своего дома) это следует делать только изредка и с достаточными на то основаниями. Обычно это может осуществляться в пакете, пытающемся эмулировать отсутствующие встроенные функции в системе, отличной от Unix. (Не путайте замещение с перегрузкой (overloading), которая придает встроенным операторам дополнительные объектно-ориентированные значения, но ничего не замещает. Дополнительно читайте об этом в описании модуля overload в главе 13 «Перегрузка».)

Замещение может осуществляться только путем импортирования имени из модуля - обычного предварительного объявления для этого недостаточно. Если быть совсем откровенным, то это присвоение typeglob, который запускает замещение, ссылки на код, как в *ореп 二 \&myopen. Кроме того, присвоение должно быть осуществлено в каком-нибудь другом пакете; это сделано с целью затруднить случайное замещение при создании псевдонима typeglob. Однако если вам действительно нужно сделать собственное замещение, не отчаивайтесь, потому что директива subs позволяет предварительно объявлять подпрограммы посредством синтаксиса импорта, и этими именами потом замещаются встроенные:

use subs qw(chdir chroot chmod chown);

chdir $somewhere; sub chdir { ... }

Вообще говоря, модули не должны экспортировать такие встроенные имена, как open или chdir, в составе своего списка по умолчанию ©EXPORT, т. к. эти имена могут попасть в еще чье-то пространство имен и неожиданным образом изменить семантику. Если вместо этого включить такое имя в список @EXPORT_OK, то импортеры будут вынуждены явно запрашивать замещение встроенного имени, принуждая таким образом всех к честности.

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

Ну, почти всегда. Описанный механизм замещения совершенно умышленно ограничен тем пакетом, который запрашивает импорт. Но есть механизм с более широким спектром действия, который можно использовать при намерении заместить встроенную функцию везде, не взирая на границы пространств имен. Это достигается путем определения функции в псевдопакете CORE: :GLOBAL. Ниже приведен пример, в котором оператор glob заменяется на нечто, понимающее регулярные выражения. (Учтите, что этот пример реализует не все, что нужно для чистого замещения встроенного в Perl glob, который ведет себя по-разному в зависимости от того, находится ли он в скалярном или списковом контексте. На практике многие встроенные функции Perl имеют такие зависящие от контекста режимы, и каждое правильно написанное замещение должно их адекватным образом поддерживать. Полностью функциональный пример замещения glob можно получить, изучая модуль File: :Glob, поставляемый с Perl.) Тем не менее, вот асоциальная версия:

*CORE: -.GLOBAL: :glob = sub {

my $pat = shift;

my @got;

local *D;

if (opendir D, '.') {

@got = grep /$pat/, readdir D; closedir D;

}

return @got;

}

package Whatever;

print <c[a-z_]+\.pm\$>;print <c[a-z_]+\.pm\$>;# показать все директивы в текущем каталоге

print <c[a-z_]+\.pm\$>;

print <c[a-z_]+\.pm\$>;

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

Наша философия замещения такова: приятно быть важным, но важнее быть приятным.

12

Объекты

Прежде всего, необходимо разбираться в пакетах и модулях; см. главу 10 «Пакеты» и главу 11 «Модули». Требуется также понимание ссылок и структур данных; см. главу8 «Ссылки» и главу9 «Структуры данных». Кроме того, полезно немного знать об объектно-ориентированном программировании (ООП), поэтому в следующем разделе мы прочтем вам небольшой курс ООЖ (объектно-ориентированного жаргона).

Краткая памятка по объектно-ориентированному жаргону

Объект - это структура данных с некоторым набором режимов поведения (behaviors). Обычно мы говорим о поведении объекта, как если бы оно осуществлялось им непосредственно, иногда доходя при этом до антропоморфизма. Например, можно услышать, что прямоугольник «умеет» выводить себя на экран, или что он «знает», как рассчитать свою площадь.

Каждый объект получает свои режимы поведения благодаря тому, что является экземпляром (instance) класса. Класс определяет методы: режимы поведения, применимые к классу и его экземплярам. Тогда, когда это различие существенно, мы называем методы, применяемые только к конкретному объекту, методами объекта, а те, которые применяются к классу в целом, методами класса. Но это только соглашение: для Perl метод всегда только метод, отличаемый лишь по типу своего первого аргумента.

Можно рассматривать метод экземпляра как некоторое действие, осуществляемое конкретным объектом, например, вывод самого себя, копирование себя или изменение одного или нескольких своих свойств («установить название этого меча равным Андрил»). Методы класса могут осуществлять операции над совокупностью многих объектов («вывести названия всех мечей») или выполнять другие действия, не зависящие от конкретных объектов («с данного момента, когда выковывается новый меч, регистрировать его владельца в этой базе данных»). Методы, которые генерируют экземпляры (объекты) класса, называются конструкторами («создать меч с рукояткой, украшенной драгоценными камнями и таинственной надписью»). Обычно это методы класса («сделать мне новый меч»), но могут быть и методы объекта («сделать точную копию этого меча»).

Класс может наследовать (inherit) методы родительских классов (parent classes), называемых также базовыми классами (base classes) или надклассами (superclasses). В этом случае класс называется производным классом (derived class) или подклассом (subclass). (Еще более запутывает вопрос то, что под «базовым классом» иногда в литературе имеется в виду «самый верхний» надкласс. Мы в таком значении его не используем.) Наследование создает новый класс, который ведет себя так же, как существующий, но допускает наличие измененного или дополнительного поведения, которого нет у его родителей. При вызове метода, определения которого нет в классе, Perl автоматически ищет определение в родительских классах. Например, класс меча может наследовать свой метод attack у общего класса клинка. У родителей могут быть свои родители, и Perl, при необходимости, будет вести поиск и в тех классах. Класс клинка, в свою очередь, может наследовать метод attack от еще более общего класса оружия.

Когда для объекта вызывается метод attack, итоговое поведение может зависеть от того, является ли объект мечом или стрелой. Возможно, никакого различия вообще не будет, например, если и меч, и стрела унаследовали свой режим нападения от более общего класса «оружие». Но если различие в поведении есть, то механизм диспетчеризации методов выбирает метод attack, подходящий для рассматриваемого объекта. Полезное свойство, позволяющее всегда выбрать наиболее подходящее поведение для конкретного типа объекта, называется полиморфизмом. Это важный вид безразличия.

Необходимо позаботиться о внутреннем содержании своих объектов при реализации своего класса, но при использовании класса следует представлять себе его объекты как черные ящики. Невозможно увидеть, что находится внутри, не надо знать, как он работает, и вы взаимодействуете с ящиком лишь на его условиях: через методы, предоставляемые классом. Даже если известно, что эти методы делают с объектом, надо устоять перед побуждением покопаться в нем самому. Это как пульт управления телевизором: даже если вы знаете, что происходит внутри него, следует избегать праздного вмешательства в его внутреннее устройство без особых причин.

Perl позволяет вам при необходимости заглянуть внутрь объекта, находясь вне класса. Но при этом нарушается его инкапсуляция 一 принцип, согласно

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

Perl не требует, чтобы вы придерживались какого-либо определенного стиля программирования, и не одержим идеей закрытости, как некоторые другие объектно-ориентированные языки программирования. Однако Perl одержим идеей свободы, и одна из свобод, которые Perl предоставляет программисту, это право избрать такую меру закрытости, какую он пожелает. На самом деле, Perl может обеспечить более сильную закрытость в своих классах и объектах, чем C++. Это означает, что Perl ни в чем не ограничивает программиста и, в частности, не ограничивает его право ограничивать самого себя (если вас занимают такого рода вещи). Разделы «Закрытые методы» и «Использование замыканий в закрытых объектах» далее в этой главе показывают, как можно ужесточить самодисциплину.

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

Система объектов Perl

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

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

Объект является просто ссылкой... э-э, объектом ссылки.

Поскольку ссылки позволяют отдельным скалярам представлять большие совокупности данных, не должно вызывать удивления, что для всех объектов используются ссылки. Технически объект не является собственно ссылкой - это, на самом деле, то, на что указывает ссылка. Однако программисты на Perl часто не замечают этого отличия, и, поскольку мы считаем это прекрасной метонимией, то продолжим здесь использовать ее, когда это для нас удобно.

Класс является просто пакетом.

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

Метод является просто подпрограммой.

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

Вызов методов

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

Perl поддерживает две разные синтаксические формы для вызова методов. В одной используется знакомый вам стиль, всюду встречающийся в Perl, а вторая может показаться вам знакомой по другим языкам программирования. Какая бы форма вызова метода ни использовалась, подпрограмме, образующей метод, всегда передается дополнительный начальный аргумент. Если для вызова метода используется класс, этот аргумент будет именем класса. А если объект, то этот аргумент будет ссылкой на объект. Чем бы он ни был, мы будем называть его инвокантом (invocant) метода. Для метода класса инвокантом является имя пакета. Для метода экземпляра инвокантом является ссылка, задающая объект.

Иными словами, инвокант - это то, что вызывает метод. Иногда в литературе по ООП его называют агентом (agent) или актором (actor). Грамматически инвокант не является ни субъектом действия, ни получателем этого действия. Он более похож на косвенное дополнение, бенефициара, в чью пользу

осуществляется действие, - как слово «мне» в команде «выкуй мне меч!». Семантически можно представлять себе инвоканта либо как то, что создает вызов, либо как то, что служит предметом вызова, - в зависимости от того, что больше подходит вашему складу ума. Мы не собираемся заставлять вас думать каким-то определенным способом. (Во всяком случае не об этом.)

По большей части методы вызываются явно, но могут вызываться и неявно, когда их запускают деструкторы объектов, перегруженные операторы или связанные переменные. Если говорить точно, то это не обычные вызовы подпрограмм, а вызовы методов, автоматически запускаемые Perl от имени объекта. Деструкторы описываются далее в этой главе, перегрузка - в главе 13 «Перегрузка», а связи - в главе 14 «Связанные переменные».

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

Причина, по которой пакет метода не может быть разрешен раньше, относительно проста: пакет определяется классом инвоканта, а инвокант неизвестен, пока метод не будет фактически вызван. В центре ООП лежит простая логическая цепочка: когда известен инвокант, известен класс инвоканта, а когда известен класс, известно, кому он наследует, а когда известно, кому наследует класс, известна фактическая подпрограмма, которую нужно вызвать. За использование алгоритмов абстракции приходится платить. Из-за позднего разрешения методов объектно-ориентированное решение в Perl, скорее всего, будет выполняться медленнее, чем соответствующее решение без применения ООП. Для некоторых изощренных приемов, описываемых ниже, это может быть значительно медленнее. Однако многие распространенные задачи решаются путем не быстрой, а умной работы. Вот тут и начинает блистать ООП.

Вызов методов с помощью оператора стрелки

Как уже упоминалось, есть два стиля вызова методов. Первый выглядит так:

INVOCANT->METHOD (LIST) INVOCANT->METHOD

По очевидной причине этот метод обычно называют стрелочной формой вызова. (Не путайте -> и =>, «двуствольную» стрелку, используемую вместо запятой.) Если есть аргументы, необходимы круглые скобки. При выполнении вызов сначала находит подпрограмму, которую совместно определяют класс INVOCANT и имя METHOD, а затем вызывает эту подпрограмму, передавая ей INVOCANT в качестве первого аргумента.

Если INVOCANT является ссылкой, то мы говорим, что METHOD вызывается как метод экземпляра (объекта), а если INVOCANT является именем пакета, то говорим, что METHOD вызывается как метод класса. На практике различия между тем и другим нет, за исключением того, что имя пакета более очевидным образом связано с самим классом, чем с объектами этого класса. Поверьте нам на слово, что объекты тоже знают, к какому классу они принадлежат. Очень скоро мы расскажем, как связать объект с именем класса, но использовать объекты можно и не зная этого.

Например, чтобы создать объект с помощью метода класса summon и вызвать затем с полученным объектом метод экземпляра speak, можно сказать:

$mage = Wizard->summon("Gandalf"); # метод класса $mage->speak("friend");# метод экземпляра

Методы summon и speak определены классом Wizard - или одним из классов, которым он наследует. Но вас это не должно беспокоить. Не вмешивайтесь в дела Волшебников.

Поскольку оператор стрелки ассоциативен слева (см. главу 3 «Унарные и бинарные операторы»), можно даже объединить две команды в одну:

Wizard->summon("Gandalf")->speak("friend");

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

$method 二"summon";

$mage = Wizard->$method("Gandalf"); # Вызвать Wizard->summon

$travel 二 $companion eq "Shadowfax" ? "ide" : "walk";

$mage->$travel("seven leagues"); # Вызвать $mage->ride или $mage->walk

Хотя имя метода служит для его косвенного вызова, такое использование не запрещается use strict ' refs', поскольку в действительности для всех обращений к методам их поиск осуществляется по таблицам имен в момент разрешения.

В нашем примере мы записали в $t ravel имя метода, но это могла быть и ссылка на подпрограмму. При этом происходит обход алгоритма поиска метода, но иногда это как раз то что требуется. Посмотрите раздел «Закрытые методы» и обсуждение метода сап в разделе «UNIVERSAL: первичный класс предков». О том, как создать ссылку на конкретный метод конкретного экземпляра, см. раздел «Замыкания» главы 8 «Ссылки».

Вызов методов с использованием косвенных объектов

Второй стиль вызова метода выглядит так:

METHOD INVOCANT (LIST)

METHOD INVOCANT LIST

METHOD INVOCANT

Круглые скобки вокруг LIST не обязательны; если они опущены, метод действует как списковый оператор. Поэтому можно писать такие команды с использованием данного стиля вызова методов:

$mage = summon Wizard "Gandalf";

$nemesis 二 summon Balrog home => "Moria", weapon => "whip";

move $nemesis "bridge";

speak $mage "You cannot pass";

break $staff-;# надежнее использовать: break $staff ();

Синтаксис спискового оператора должен быть вам знаком; это тот же стиль, который используется для передачи дескрипторов файлов в print и printf:

print STDERR "help!!!\n";

Это аналогично таким английским предложениям, как «Give Gollum the Preciousss», поэтому мы называем это формой косвенного объекта (indirect object). Ожидается, что инвокант находится в позиции косвенного объекта (indirect object slot). Когда вы читаете, что встроенной функции, например, system или ехес, что-то передается в ее «позицию косвенцого объекта», это означает, что передается этот дополнительный аргумент без запятых в том же месте, в котором он был бы при вызове метода с использованием синтаксиса косвенного объекта.

Форма косвенного объекта даже допускает, что INVOCANT задается как BLOCK, значением которого является объект (ссылка) или класс (пакет). Это позволяет так объединить два приведенные вызова в одной команде:

speak { summon Wizard "Gandalf" } "friend";

Синтаксическая путаница с косвенными объектами

Один синтаксис часто оказывается более удобочитаемым, чем другой. Синтаксис косвенного объекта часто оказывается менее загроможденным, но страдает некоторыми формами синтаксической неоднозначности. Первая состоит в том, что часть LIST вызова косвенного объекта обрабатывается син-

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

enchant $sword ($pips + 2) * $cost;

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

($sword->enchant($pips + 2)) * $cost;

Скорее всего, здесь выполняется не то, что нам нужно: enchant вызывается только с $pips + 2, а значение, возвращаемое методом, умножается затем на $cost. Как и с другими списковыми операторами, нужно также проявлять осторожность в отношении старшинства && и | | относительно and и ог.

Например,

name $sword Soldname || "Glamdring"; # здесь нельзя использовать "or"!

становится желаемым:

$sword->name($oldname || "Glamdring")；

но:

speak $mage "friend" && enter();# здесь должно быть "and"!

становится двусмысленным:

$mage->speak("friend" && enter());

что можно исправить, переписав в одной из следующих эквивалентных форм:

enter() if $mage->speak("friend"); $mage->speak("friend") && enter(); speak $mage "friend" and enter();

Вторая синтаксическая неудачность формы косвенного объекта состоит в том, что в ней INVOCANT может быть только именем, скалярной переменной без индекса или блоком. Анализатор получает INVOCANT в свое распоряжение, как только встречает что-либо из перечисленного, поэтому он начинает искать список LIST. Значит, вызовы:

move $party->{LEADER};# вероятно, ошибочно!

move $riders[$i];# вероятно, ошибочно!

на практике анализируются как:

$раrty->move->{LEADER};

$riders->move([$i]);

хотя, на самом деле, вероятно, требовалось:

$раrty->{LEADER}->move;

$riders[$i]->move;

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

Даже в английском языке есть аналогичная проблема. Возьмите команду: «Throw your cat out the window a toy mouse to play with». Если слишком поспешно анализировать это предложение, то в результате в окно полетит кошка, а не мышка (если только вы не заметите, что кошка уже за окном). Как и в Perl, в английском есть два варианта синтаксиса для обозначения агента: «Throw your cat the mouse» и «Throw the mouse to your cat». Иногда более длинная форма оказывается понятнее и проще, а иногда - более короткая. В Perl, по крайней мере, требуется заключить сложный косвенный объект в скобки.

Классы, цитирующие имя пакета

Последняя синтаксическая двусмысленность вызова методов в стиле косвенных объектов состоит в том, что они могут вообще не быть опознаны как обращение к методу, если в текущем пакете есть подпрограмма с таким же именем, как у метода. В случае вызова метода класса, имя пакета которого совпадает с именем инвоканта, существует способ разрешения этой неопределенности при сохранении синтаксиса косвенного объекта: добавить удвоенное двоеточие к имени класса, цитируя (package-quote), тем самым, имя пакета:

$obj = method CLASS::;# навязывает "CMSS"->method

Это важно, потому что обычная запись:

$obj = new CLASS', # может не быть воспринято как метод

не всегда ведет себя так, как нужно, если в текущем пакете есть подпрограмма с именем new или CLASS. Даже если старательно использовать для вызова метода стрелку, а не косвенный объект, в редких случаях все же могут возникать проблемы. Ценой помех, вызываемых лишними знаками пунктуации, обозначение CLASS:: гарантирует правильный анализ в Perl вызова метода. Первые два примера из приведенных ниже не всегда анализируются одинаково, в отличие от следующих двух:

$obj 二 new ElvenRing;$obj 二 ElvenRing->new;$obj 二 new ElvenRing::;$obj 二 ElvenRing::->new;$obj 二 new ElvenRing;$obj 二 ElvenRing->new;$obj 二 new ElvenRing::;$obj 二 ElvenRing::->new;может быть new("ElvenRing")

$obj 二 new ElvenRing;

$obj 二 ElvenRing->new;

$obj 二 new ElvenRing::;

$obj 二 ElvenRing::->new;

$obj 二 new ElvenRing;

$obj 二 ElvenRing->new;

$obj 二 new ElvenRing::;

$obj 二 ElvenRing::->new;

или даже new(ElvenRing())

could be ElvenRing()->new()

всегда "ElvenRing"->new()

всегда "ElvenRing"->new()

$obj 二 new ElvenRing:: name =>$obj 二 new ElvenRing:: name =>owner => domain => stone =>owner => domain => stone =>"Narya", "Gandalf", "fire", "ruby";"Narya", "Gandalf", "fire", "ruby";Эту нотацию можно сделать симпатичнее путем некоторого выравнивания:

$obj 二 new ElvenRing:: name =>

$obj 二 new ElvenRing:: name =>

owner => domain => stone =>

owner => domain => stone =>

"Narya", "Gandalf", "fire", "ruby";

"Narya", "Gandalf", "fire", "ruby";

Все еще можно сказать: «①у!», глядя на это удвоенное двоеточие, поэтому сообщим, что всегда можно обойтись простым именем класса, если соблюдаются два условия. Во-первых, в классе нет подпрограммы, имя которой совпадает с именем класса. (Если следовать соглашению, что имена подпрограмм, как в new, начинаются на нижнем регистре, а имена классов, как в ElvenRing, начинаются на верхнем регистре, то это не составляет проблемы.) Во-вторых, класс загружен с помощью одной из двух команд:

use ElvenRing;

require ElvenRing;

Благодаря наличию любого из этих объявлений Perl знает, что ElvenRing представляет собой имя модуля, и любое голое имя вроде new перед именем класса ElvenRing будет интерпретироваться как вызов метода, даже если вы определили собственную подпрограмму new в текущем пакете. Обычно проблем с косвенными классами не возникает, если только не пытаться втиснуть много классов в один файл, из-за чего Perl может не знать, что некоторое имя пакета должно быть именем класса. Те, кто дает своим подпрограммам имена типа ModuleNames, тоже в итоге бывают огорчены.

Создание объектов

Все объекты являются ссылками, но не все ссылки являются объектами. Ссылка не сможет действовать как объект, пока ее предмет не будет помечен особым образом, который сообщит Perl о том, к какому пакету он принадлежит. Действие, состоящее в пометке предмета ссылки именем пакета - и, следовательно, класса, т. к. класс - это просто пакет, - состоит в применении к ней функции bless и называется blessing («благословение»). Можете считать, что при этом ссылка превращается в объект, хотя точнее было бы сказать, что ссылка превращается в ссылку на объект.

Функция bless принимает один или два аргумента. Первый аргумент является ссылкой, а второй - пакетом, в котором находится объект ссылки. Если второй аргумент опущен, используется текущий пакет.

$obj = { };# Получить ссылку на анонимный хеш.

bless($obj);# Сделать хеш объектом в текущем пакете.

bless($obj, "Critter");# Сделать хеш объектом в классе Critter.

Здесь мы использовали ссылку на анонимный хеш, который обычно выступает в объектах как структура данных. Хеши являются очень гибкой конструкцией. Но хотелось бы подчеркнуть, что можно применить bless к ссылке, указывающей на любой элемент, на который можно ссылаться в Perl, в том числе скаляры, массивы, подпрограммы и typeglob. Можно применить bless даже к хешу таблицы имен пакета, если для этого найдется причина. (И даже если не найдется.) Объектная ориентированность в Perl совершенно ортогональна структуре данных.

После того как предмет ссылки «благословлен», применение встроенной функции ref к ссылке на него возвращает не встроенный тип, а имя его класса, например HASH. Если вам нужен встроенный тип, используйте функцию reftype из модуля attributes. См. описание use attributes в главе 31 «Модули прагм».

А вот как создается объект. Берется какая-то ссылка, ей придается класс путем его «благословления» в пакете - и все. Это все, что нужно сделать, если создается минимальный класс. Если класс лишь используется, то нужно еще меньше, потому что разработчик класса спрятал bless в методе, называемом конструктором, который создает и возвращает экземпляры класса. Поскольку bless возвращает свой первый аргумент, обычный конструктор может быть очень прост:

package Critter;

sub spawn { bless {}; }

Или, если расписать все несколько подробнее:

package Critter; sub spawn {

my$self = {};# Ссылка на пустой анонимный хеш

bless $self, "Critter"; # Сделать этот хеш объектом Critter return $self;# Возвратить только что созданный Critter

}

Имея такое определение, можно создавать объект Critter:

$pet = Critter->spawn;

Наследуемые конструкторы

Как и все методы, конструктор - это просто подпрограмма, но мы не вызываем его как подпрограмму. Мы всегда вызываем его как метод - метод класса, в данном случае, потому что инвокантом является имя пакета. Вызовы методов отличаются от вызовов обычных подпрограмм в двух отношениях. Во- первых, они получают дополнительный аргумент, о чем говорилось выше.

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

Механику наследования мы обсудим более строго в следующем разделе, а пока несколько простых примеров его действия должны помочь вам в разработке собственных конструкторов. Допустим, что у нас есть класс Spider, наследующий методы класса Critter (живое существо). В частности, пусть в классе Spider нет собственного метода spawn. Применяется следующее соответствие:

Вызов метода

Результирующий вызов подпрограммы

Critter->spawn()

Critter::spawn("Critter")

Spider->spawn()

Critter::spawn("Spider")

В обоих случаях вызывается одна и та же подпрограмма, но с разными аргументами. Обратите внимание на то, что наш конструктор spawn, приведенный выше, совершенно игнорировал свой аргумент, и это значит, что наш объект Spider был некорректно «благословлен» в класс Critter. Более правильный конструктор должен передать bless имя пакета (полученное в качестве первого аргумента):

sub spawn {

my $class = shift; # Сохранить имя пакета my $self = { };

bless($self, $class); # «Благословить» ссылку в этот пакет return $self;

}

Теперь в обоих случаях можно использовать одну и ту же подпрограмму:

$ve「min 二 Critter->spawn;

$shelob = Spider->spawn;

И каждый объект будет принадлежать правильному классу. Теперь это работает даже косвенным образом:

$type = "Spider";

$shelob = $type->spawn;# To же, что и "Spider"->spawn

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

Если бы $type была объектом, а не именем класса, то приведенное определение конструктора было бы неработоспособно, потому что для bless требуется имя класса. Но для многих классов есть смысл в использовании существующего объекта в качестве шаблона для создания нового объекта. В таких случаях можно разрабатывать такие конструкторы, которые работают и с объектами, и с именами классов:

sub spawn {

my $invocant 二 shift;

my $class = ref($invocant) || $invocant; # Объект или имя класса my $self = { }; bless($self, $class);

return $self;

}

Инициализаторы

Большинство объектов хранят внутреннюю информацию, которая косвенно обрабатывается методами объекта. До сих пор все наши конструкторы создавали пустые хеши, но нет причин оставлять их пустыми. Например, можно сделать так, что конструктор будет принимать дополнительные аргументы и хранить их в хеше в виде пар ключ/значение. В литературе по ООП такие данные часто называются свойствами, атрибутами, методами доступа, данными-членами, данными экземпляра и переменными экземпляра (properties, attributes, accessors, member data, instance data, instance variables). В разделе «Переменные экземпляра» далее в этой главе атрибуты обсуждаются более подробно.

Представим себе класс Horse (лошадь) с атрибутами «пате» (кличка) и «color» (масть):

$steed = Horse->new(name => "Shadowfax", color => "white");

Если объект реализован как ссылка на хеш, пары ключ/значение можно непосредственно интерполировать в хеш, как только инвокант удален из списка аргументов:

sub new {

my $invocant = shift;

my $class = ref(Sinvocant) || Sinvocant;

my $self = { @_ };# Оставшиеся аргументы становятся атрибутами

bless($self, Sclass);# «Благословление» в объекты

return $self;

}

На этот раз в качестве конструктора класса мы использовали метод с именем new, что может создать у программистов C++ ощущение понимания происходящего. Но Perl не рассматривает слово «new», как имеющее особый смысл; вы можете называть свои конструкторы как угодно. Любой метод, создающий и возвращающий объект, является конструктором de facto. В целом, мы советуем давать конструкторам осмысленные в контексте решаемой задачи имена. Например, конструкторы в модуле Тк имеют имена, соответствующие создаваемым ими графическим объектам. В модуле DBI конструктор с именем connect возвращает объект - дескриптор базы данных, а другой конструктор, с именем prepare, вызывается как метод экземпляра и возвращает объект - дескриптор команды. Но если нет подходящего в данном контексте имени конструктора, то new является не самым ужасным выбором. С другой стороны, не так уж плохо выбрать какое-то случайное имя, которое

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

В ходе дальнейшей разработки можете оснастить свой конструктор парами ключ/значение по умолчанию, которые пользователь может в дальнейшем переопределить с помощью переданных аргументов:

sub new {

my $invocant = shift;

my $class = ref($invocant) || $invocant;

my $self 二{ color => "гнедой", legs => 4, owner => undef, @_,# Заместить прежние атрибуты

}； return bless $self, $class;

}

$ed 二 Horse->new;# 4-ногая гнедая лошадь

$stallion 二 Horse->new(color => "черный"); # 4-ногая вороная лошадь

Конструктор Horse игнорирует имеющиеся у его инвоканта атрибуты при использовании в качестве метода экземпляра. Можно было бы создать второй конструктор, предназначенный для вызова в качестве метода экземпляра, и сделать так, чтобы значения вызывающего объекта принимались как значения по умолчанию для нового объекта:

$steed 二 Horse->new(color => "серовато-коричневый");

$foal 二 $steed->clone(owner => "EquuGen Guild, Ltd. sub clone {

my $model 二 shift;

my $self = $model->new(%$model, @_);

return $self; # Ранее «благословленный» с помощью ->new }

(Можно было бы поместить эти возможности прямо в new, но тогда имя не вполне соответствовало бы функции.)

Обратите внимание, что даже ъ конструкторе clone мы не кодируем жестко Horse - имя класса. Мы делаем так, что исходный объект, чем бы он ни был, вызывает свой собственный метод new. Если бы вместо $model->new мы написали Ho「se->new, то этот класс не позволил бы наследовать классам Зебра или Единорог. Не хотелось бы, клонируя Пегаса, получить лишь лошадь другой масти.

Иногда, однако, возникает противоположная проблема: вместо того, чтобы делить один конструктор между несколькими классами, желательно иметь несколько конструкторов для объекта одного класса. Это случается, когда конструктор хочет вызвать конструктор базового класса, чтобы тот выполнил часть работы. Perl не производит иерархического создания объектов. Это значит, что Perl не станет автоматически вызывать конструкторы (или

деструкторы) для каких-либо базовых классов создаваемого объекта, поэтому вашему конструктору придется сделать это самостоятельно, а затем добавить дополнительные атрибуты, необходимые производному классу. Ситуация отчасти сходна с программой clone, за исключением того, что вместо копирования существующего объекта в новый объект необходимо вызвать конструктор своего базового класса, а затем превратить новый базовый объект в новый производный объект.

Наследование классов

Как и вообще в системе объектов Perl, наследование одного класса другим не требует ввода в язык особого синтаксиса. При вызове метода, для которого Perl не находит подпрограммы в пакете инвоканта, исследуется массив ©ISA】 этого пакета. Вот как Perl реализует наследование: каждый элемент массива @ISA данного пакета содержит имя другого пакета, в котором производится поиск отсутствующих методов. Например, в следующем примере класс Horse становится подклассом класса Critter. (Мы объявляем @ISA как our, потому что он должен быть переменной пакета, а не лексической переменной, объявляемой через ту.)

package Horse;

our @ISA 二"Critter";

Теперь вы должны быть в состоянии использовать класс или объект Horse везде, где встречался класс Critter. Если ваш новый класс пройдет эту проверку на пустой подкласс, то вы будете знать, что Critter является правильным базовым классом, пригодным для наследования.

Допустим, что в Ssteed находится объект Horse, и вы вызываете с ним метод move:

$steed->move(10);

Поскольку $steed является объектом Horse, Perl сначала ищет для этого метода подпрограмму Horse: :move. Если такой не найден, то Perl не возбуждает исключительную ситуацию на этапе исполнения, а обращается к первому элементу массива@Horse: :ISA, который отправляет его в пакет Critter в поисках Critter: :move. Если и эта подпрограмма не найдена, а в Critter есть собственный массив @Critter: :ISA, то и в нем начнется поиск имени пакета-предка, который мог бы предоставить метод move, и так движение по иерархии наследования будет продолжаться до достижения пакета, в котором нет @ISA.

Описанная только что ситуация называется одиночным наследованием (single inheritance), при этом у каждого класса есть только один родитель. Такое наследование подобно связанному списку родственных пакетов. Perl поддерживает также множественное наследование (multiple inheritance)} нужно

Произносится «изэ», как в «is а».

просто добавить еще пакеты в @ISA класса. Такого рода наследование действует скорее как структура данных в виде дерева, потому что у каждого пакета может иметься более одного непосредственного родителя. Некоторые находят, что это более сексуально.

При вызове метода meth пате с инвокантом типа class name Perl опробует шесть разных способов, чтобы найти подпрограмму, которую нужно использовать:

Сначала Perl ищет в собственном пакете инвоканта подпрограмму с именем classname: \methname. Если это не удается, вступает в действие наследование, и мы переходим к шагу 2.

Затем Perl проверяет методы, унаследованные от базовых классов, просматривая все пакеты parent, которые перечислены в @classname: :ISA, в поисках подпрограммы parent'.:methname. Поиск ведется слева направо, рекурсивно и сначала вглубь. Рекурсия обеспечивает проведение поиска во всех классах - прародителей, прапрародителей, прапрапрародителей ит. д.

Если это не помогло, Perl ищет подпрограмму с именем UNIVERSAL:: methname.

В этом месте Perl отчаивается найти meth пате и начинает искать AUTOLOAD. Сначала он ищет подпрограмму с именем classname \: AUTOLOAD.

Если этот поиск неудачен, Perl ищет во всех пакетах parent, перечисленных в @classname: :ISA, какую-нибудь подпрограмму parent: AUTOLOAD. Поиск опять ведется слева направо, рекурсивно и сначала вглубь.

Наконец, Perl ищет подпрограмму с именем UNIVERSAL:: AUTOLOAD.

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

Can't locate object method ''methname'' via package "classname''

(He могу найти объектный метод “methname” через пакет ''classname'')

Если ваша версия Perl собрана с поддержкой отладки при помощи опции компилятора -DDEBUGGING, то при задании Perl ключа -Do можно увидеть прохождение всех этих шагов во время разрешения вызова метода.

По мере изложения мы будем обсуждать механизм наследования более подробно.

Наследование через @ISA

Если массив @ISA содержит больше одного имени пакета, то поиск в пакетах осуществляется в порядке слева направо. Поиск ведется сначала вглубь, поэтому, если у вас есть класс Mule (мул), так подготовленный для наследования:

package Mule;

our @ISA 二("Horse", "Donkey");

то Perl ищет методы, отсутствующие в Mule, сначала в Horse (и всех его предках, например, Critter) и только потом переходит к поиску в Donkey (осел) и его предках.

Если отсутствующий метод найден в базовом классе, то Perl внутренне кэширует этот метод в текущем пакете для повышения эффективности, поэтому когда ему потребуется найти данный метод в следующий раз, не надо будет ходить далеко. Изменение @ISA или определение новых методов делает кэш недействительным и заставляет Perl снова выполнять поиск.

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

Когда вы устанавливаете значения @ISA, присвоение происходит обычно на этапе исполнения, поэтому, если не принять мер предосторожности, код в блоках BEGIN, CHECK и INIT не будет иметь возможность использовать иерархию наследования. Одним из средств предосторожности (или удобства) является прагма use base, которая позволяет выполнять require для классов и добавлять их в @ISA на этапе компиляции. Вот как можно ее использовать:

package Mule;

use base ("Horse", "Donkey"); # объявление надклассов

Это сокращенная запись для следующего:

package Mule;

BEGIN {

our @ISA 二("Horse", "Donkey");

require Horse; require Donkey;

}

за исключением того, что use base учитывает также объявления use fields.

Некоторых удивляет, что включение класса в @ISA не влечет require соответствующего модуля. Это связано с тем, что система классов Perl в значительной мере ортогональна его системе модулей. В одном файле может содержаться много классов (поскольку они являются просто пакетами), а один пакет может указываться в нескольких файлах. Но в наиболее обычной ситуации, когда один пакет, один класс, один модуль и один файл в конечном итоге оказываются весьма взаимозаменяемыми - если сильно прищуриться, прагма use base предлагает синтаксис объявления, который устанавливает наследование, загружает файлы модулей и размещает любые объявленные поля базового класса. Это одна из удобных диагоналей, о которых мы говорим.

Дополнительные сведения можно найти в описаниях use base и use fields в главе 31 «Модули прагм».

Доступ к замещенным методам

Когда класс определяет метод, то эта подпрограмма замещает одноименные методы во всех базовых классах. Представьте себе, что у вас есть объект Mule (производный от класса Horse и класса Donkey) и вы решаете вызвать метод breed (скрещивание) вашего объекта. Хотя у родительских классов есть собственные методы breed, разработчик класса Mule заместил их, снабдив класс Mule собственным методом breed. Это значит, что следующее скрещивание вряд ли будет продуктивным:

$stallion 二 Horse->new(gender => "male");

$molly = Mule->new(gender => "female")；

$colt 二 $molly->breed($stallion);

Теперь допустим, что чудеса генной инженерии позволили вам решить известную проблему стерильности мула, и вы хотите перескочить через нежизнеспособный метод Mule:: breed. Можно вызвать свой метод как обычную подпрограмму, обеспечив явную передачу инвоканта:

$colt = Horse::breed($molly, Sstallion);

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

$colt = $molly->Horse::breed($stallion);

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

В таких случаях удобно использовать псевдокласс SUPER. Он позволяет вызывать замещенный метод базового класса, не указывая, в каком классе этот метод определен. Следующая подпрограмма ведет поиск в @ISA текущего пакета, не заставляя вас указывать конкретные классы:

package Mule;

our @ISA 二 qw(Ho「se Donkey);

sub kick {

my $self = shift;

print "Мул лягается!\n";

$self->SUPER::kick(@_);

}

Псевдопакет SUPER имеет значение только в случае применения внутри метода. Тот, кто реализует класс, может включить SUPER в свой код, но тот, кто просто использует объекты класса - нет.

SUPER не всегда работает так, как вам хотелось бы, если происходит множественное наследование. Как можно ожидать, он использует @ISA как обычный механизм наследования: слева направо, рекурсивно, сначала вглубь. Если бы метод speak был у обоих классов, Horse и Donkey, и вы предпочли бы метод Donkey, то пришлось бы явно указать этот родительский класс:

sub speak {

my $self 二 shift;

print "Мул разговаривает!\n";

$self->Donkey::speak(@_);

}一

Более сложные подходы к ситуациям с множественным наследованием могут разрабатываться с помощью метода UNIVERSAL: :сап, который описывается в следующем разделе. Можете также воспользоваться модулем Class: : Multimethods из СР AN, в котором есть много усовершенствованных решений, в том числе поиск ближайшего соответствия вместо самого левого.

В любом месте кода Perl известно, какой пакет является текущим, т. е. определен последней командой package. Метод SUPER обращается к @ISA только того пакета, в который был скомпилирован вызов SUPER. Его не интересуют ни класс инвоканта, ни пакет вызываемой подпрограммы. Это может послужить источником проблем, если попытаться определить методы в другом классе путем лишь манипуляций с именем метода:

package Bird;

use Dragonfly;

sub Dragonfly::divebomb { shift->SUPER::divebomb(@_) }

К несчастью, при этом вызывается надкласс Bird, а не Dragonfly. Чтобы осуществить то, что вы хотите, нужно явно перейти в соответствующий пакет, и тогда SUPER правильно скомпилируется:

package Bird;

use Dragonfly;

package Dragonfly;

sub divebomb { shift->SUPER::divebomb(@_) }

Как показывает этот пример, не требуется редактировать файл модуля, чтобы добавить новые методы к существующему классу. Поскольку класс является просто пакетом, а метод 一 просто подпрограммой, нужно лишь определить функцию в нужном пакете, как мы здесь и сделали, и в классе внезапно появится новый метод. Никакого наследования не требуется. Значение имеет только пакет, а т. к. пакеты являются глобальными, то доступ к любому пакету может быть осуществлен из любого места программы. (Кстати, мы уже говорили, что собираемся на следующей неделе поставить у вас в комнате джакузи?)

UNIVERSAL: первичный класс предков

Если после поиска в классе инвоканта и рекурсивного поиска во всех классах, являющихся его предками, не найдено определения метода с нужным именем, производится еще одна проверка метода с этим именем в особом предопределенном классе с именем UNIVERSAL. Этот пакет никогда не указывается в @ISA, но проверка в нем всегда производится, если поиск по @ISA оказывается неудачным. Можно считать UNIVERSAL изначальным прародителем, от которого неявным образом производятся все классы.

Ниже описаны предопределенные методы, имеющиеся в классе UNIVERSAL, а следовательно и во всех классах. Все они работают независимо от того, вызываются ли они как методы класса или как методы объекта.

INVOCANT->is^CLASS)

Метод isa возвращает true, если классом ивоканта INVOCANTявляется CLASS или любой класс, наследующий CLASS. При этом CLASS может быть не именем пакета, а одним из встроенных типов, например, "HASH'^ или "ARRAY". (Однако выяснение точного типа не сулит ничего хорошего инкапсуляции и полиморфизму. Чтобы получить правильный метод, следует полагаться на диспетчеризацию методов.)

use FileHandle;

if (FileHandle->isa("Exporter")) { print "FileHandle есть Exporter.\n";

}

$fh = FileHandle->new();

if ($fh->isa("IO::Handle")) {

print "\$fh есть какой-то объект 10.\n";

} if ($fh->isa("GLOB")) { print ”\$fh есть ссылка на GLOB.\n";

}

INVOCANT-〉can(METHOD)

Метод can возвращает ссылку на подпрограмму, которая была бы вызвана при применении METHOD к INVOCANT. Если такая подпрограмма не найдена, возвращается undef.

if ($invocant->can("copy")) { print "Наш инвокант умеет копировать.\n";

}

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

$obj->snarl if $obj->can("snarl");

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

sub snarl {

my $self = shift;

print "Ворчащие (snarling): @_\rT;

my %seen;

for my $parent (@ISA) {

if (my $code = $parent->can("snarl")) { $self->$code(@_) unless $seen{$code}++;

}

}

}

Мы используем хеш %seen, чтобы следить за тем, какие подпрограммы мы уже вызывали, и избежать таким образом повторного вызова одной и той же подпрограммы. Это могло бы произойти, если бы у нескольких родительских классов был общий предок.

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

INVOCANT-〉YERSION(NEED)

Метод VERSION возвращает значение номера версии класса инвоканта INVO- CANT, хранящееся в переменной пакета $VERSION. Если передается аргумент NEED, то метод проверяет, не меньше ли номер текущей версии, чем NEED, и если это так, возбуждается исключительная ситуация. Этот метод использует use для определения того, достаточно ли свеж модуль.

use Thread 1.0;# вызывает Thread->VERSI0N(1.0)

print "Выполняется Thread-версия ", Thread->VERSION, ".\n";

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

Находящиеся в UNIVERSAL методы представляют собой встроенные подпрограммы Perl, которые можно вызывать, полностью квалифицируя и передавая два аргумента, например, UNIVERSAL::isa($formobj, "HASH"). (Делать так,

однако, не рекомендуется, поскольку обычно ответ на ваш вопрос может дать сап.)

Можно добавлять в класс UNIVERSAL собственные методы. (Конечно, следует проявлять осторожность: можно запутать кого-либо, кто рассчитывает на отсутствие метода с определенным вами именем и осуществление его автозагрузки из какого-либо другого места.) Сейчас мы создадим метод сору, который могут использовать объекты всех классов, не определившие собственный такой метод. (При этом мы демонстрируем неудачу метода, если он вызван с классом, а не объектом.)

use Data::Dumper;

use Carp;

sub UNIVERSAL::copy { my $self = shift; if (ref $self) { return eval Dumper($self); # ссылки на CODE не допускаются } else {

confess "UNIVERSAL::copy не может копировать класс $self";

}

}

Эта стратегия Data: : Dumper не работает, если объект содержит ссылки на подпрограммы, потому что они не могут быть правильно воспроизведены. Даже если доступен исходный код, лексические привязки будут утеряны.

Автозагрузка методов

Обычно при обращении к неопределенной подпрограмме в пакете, который определяет подпрограмму AUTOLOAD, вместо возбуждения исключительной ситуации вызывается подпрограмма AUTOLOAD (см. раздел «Автозагрузка» главы 10 «Пакеты»). Для методов это действует несколько иначе. Если обычный поиск метода (через класс, его предков и, наконец, UNIVERSAL) не может найти соответствия, та же последовательность поиска выполняется снова, но на этот раз выполняется поиск подпрограммы AUTOLOAD. Если она найдена, то вызывается в качестве метода, при этом переменная пакета $AUTOLOAD устанавливается равной полностью квалифицированному имени подпрограммы, по поручению которой была вызвана AUTOLOAD.

При автозагрузке методов следует проявлять некоторую осторожность. Во- первых, подпрограмма AUTOLOAD должна немедленно осуществить возврат, если вызвана по поручению метода с именем DESTROY, если только вашей целью не была эмуляция DESTROY, имеющего в Perl особое значение, как описано в разделе «Деструкторы экземпляров» далее в этой главе.

sub AUTOLOAD {

return if our $AUTOLOAD /::DESTROYS/;

}

Во-вторых, если класс предоставляет страховку в виде AUTOLOAD, то невозможно использовать UNIVERSAL: :сап с именем метода, чтобы проверить, безопасно ли его вызывать. Проверять AUTOLOAD нужно отдельно:

if ($obj->can("methname") || $obj->can("AUTOLOAD")) { $obj->methname();

}

Наконец, когда при множественном наследовании класс наследует двум или более классам, в каждом из которых есть AUTOLOAD, запускается только самый левый из них, т. к. Perl останавливается, найдя первый AUTOLOAD.

Последние две странности легко обойти, объявив подпрограммы в пакете, чей AUTOLOAD должен справиться с этими методами. Можно сделать это с помощью отдельных объявлений:

package Goblin;

sub kick;

sub bite:

sub scratch;

или с помощью прагмы use subs, что более удобно, если надо объявить много методов:

package Goblin;

use subs qw(kick bite scratch);

Несмотря на то что эти подпрограммы лишь объявлены, но не определены, системе этого достаточно, чтобы считать их существующими. Они видны при проверке UNIVERSAL::сап и, что более важно, на шаге 2 поиска метода, который никогда не перейдет к шагу 3, не говоря уже о шаге 4.

«Но послушайте»,- воскликнете вы,- «они же вызывают AUTOLOAD, не так ли» В конечном счете, да, но механизм этого иной. Найдя на шаге 2 заглушку метода, Perl пытается вызвать его. При обнаружении, что метод - не то, чем ему полагается быть, снова начинается поиск метода AUTOLOAD, но на этот раз поиск начинается в классе, содержащем заглушку, что ограничивает поиск этим классом и его предками (и UNIVERSAL). Благодаря этому Perl находит для запуска правильный AUTOLOAD и умеет игнорировать методы AUTOLOAD, находящиеся в неверной части исходного дерева наследования.

Закрытые методы

Есть такой способ вызова метода, при котором Perl вообще игнорирует наследование. Если вместо литерального имени метода задать простую скалярную переменную, содержащую ссылку на подпрограмму, то подпрограмма вызывается непосредственно. В описании UNIVERSAL->can в предыдущем разделе последний пример вызывает все замещенные методы с помощью ссылки на подпрограмму, а не ее имени.

Интересная сторона такого режима состоит в том, что его можно применять для реализации вызовов закрытых методов. Если поместить класс в модуль,

то можно использовать лексическую область видимости файла для создания закрытых методов. Сначала сохраним анонимную подпрограмму в лексической переменной с файловой областью видимости:

# объявление закрытого метода

my $secret_door = sub { ту $self 二 shift;

}；

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

sub knock {

my $self 二 shift;

if ($self->{knocked}++ > 5) { $self->$secret_door();

}

}

Это позволяет собственным подпрограммам файла (методам класса) вызывать метод, к которому код вне лексической области видимости не имеет доступа.

Деструкторы экземпляров

Как и для любого другого объекта ссылки в Perl, как только исчезает последняя ссылка на объект, его память неявно освобождается для повторного использования. Объекты позволяют перехватить управление непосредственно перед тем, как это произойдет, путем определения подпрограммы DESTROY в пакете класса. Этот метод автоматически запускается в нужный момент, и в качестве единственного объекта ему передается объект, который вот-вот должен быть уничтожен.

Деструкторы редко требуются в Perl, потому что управление памятью осуществляется автоматически. Однако структура некоторых объектов может выходить за пределы памяти, и о ней желательно было бы позаботиться; например, это касается дескрипторов файлов и соединений с базами данных.

package MailNotify;

sub DESTROY {

my $self 二 shift;

my $fh 二 $self->{mailhandle};

my $id 二 $self->{name};

print $fh "\n$id отключается в " . localtime() . "\n";

close $fh; # закрыть канал обработчика почты

Так же как для создания объекта Perl достаточно единственного метода, даже если класс конструктора наследует одному или нескольким другим классам, Perl использует только один метод DESTROY для каждого объекта, невзирая на наследование. Иными словами, Perl не станет выполнять для вас иерархическое уничтожение. Если ваш класс замещает деструктор надкласса, то вашему методу DESTROY может понадобиться вызвать метод DESTROY для всех соответствующих базовых классов:

sub DESTROY {

my $self = shift;

Проверка замещения деструктора...

$self~>SUPER: DESTROY if $self->can("SUPER::DESTROY");

теперь делайте свои собственные дела

}

Это относится только к производным классам; объект, который просто содержится в текущем объекте - как, например, одно значение в более крупном хеше - будет освобожден и уничтожен автоматически. Это одна из причин, по которым вложенность путем простого агрегирования (иногда называемая отношением «has-а» - «имеет») часто является более беспримесной и понятной, чем наследование (отношение «is-а» - «является»). Иными словами, часто нужно лишь поместить один объект непосредственно внутрь другого, избегая наследования, которое вносит ненужную сложность. Иногда пользователи хватаются за множественное наследование, в то время как вполне достаточно одиночного.

Явное обращение к DESTROY допускается, но редко требуется. Оно может даже оказаться вредным, поскольку повторный запуск деструктора одного и того же объекта может привести к неприятным последствиям.

Сборка мусора методами DESTROY

Как описывалось в разделе «Сборка мусора, циклические и слабые ссылки» главы 8 «Ссылки», переменные, которые ссылаются на самих себя (или несколько ссылок, ссылающихся друг на друга косвенно), не освобождаются до выхода из программы (или встроенного интерпретатора). Для того чтобы раньше возвратить занимаемую ими память, обычно приходится явным образом разорвать ссылку или ослабить ее с помощью модуля WeakRef из СР AN. Для объектов другим решением может быть создание класса-контейнера, содержащего указатель на структуру данных со ссылками на саму себя. Определите метод DESTROY для класса, содержащего объект, который явно разрушает цикличность в структуре данных, содержащей ссылки на саму себя. Пример такого рода можно найти в главе 13 книги «Perl: библиотека программиста» Т. Кристиансена и Н. Торкингтона («Perl Cookbook») в рецепте 13.13 «Как справиться с циклическими структурами данных».

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

ется для того, чтобы предотвратить использование методами DESTROY уже уничтоженных ссылок. (А также потому, что обыкновенные ссылки попадают в сборку мусора только во встроенных интерпретаторах, поскольку выход (exit) из процесса является очень быстрым способом утилизации ссылок. Но при выходе не запускаются деструкторы объектов, поэтому сначала Perl делает это.)

Управление данными экземпляров

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

Классы Perl наследуют методы, а не данные, но если любой доступ к объекту осуществляется через вызовы методов, то это отлично действует. Если вам требуется наследование данных, его нужно осуществлять через наследование методов. В целом, это не является необходимостью в Perl, поскольку большинство классов хранит данные своих объектов в анонимных хешах. Данные экземпляра объекта хранятся в этом хеше, служащем собственным маленьким пространством имен, которое будут разбирать классы, когда им нужно что-то сделать с объектом. Например, если нужно, чтобы в объекте $city было поле данных с именем elevation, можно просто обратиться к $ci- ty>{elevation}. Никаких объявлений не требуется. Но и у методов-оболочек есть свое применение.

Допустим, надо реализовать объект Person. Принято решение, что необходимо поле данных «пате», которое, по странному совпадению, будет храниться с ключом name в анонимном хеше, служащем в качестве объекта. Но вы не хотите, чтобы пользователи входили в прямой контакт с данными. Чтобы пожинать плоды инкапсуляции, у пользователей должны быть методы для доступа к этой переменной экземпляра без поднятия завесы абстрактности.

Например, можно создать пару методов доступа:

sub get_name {

my $self = shift; return $self->{name};

}

sub set_name {

my $self = shift; $self->{name}二 shift;

}

что ведет к использованию такого кода:

$him = Pe「son->new();

$him->set_name("Frodo");

$him->set_name( ucfirst($him->get_name));

Можно даже объединить два метода в один:

sub name {

my $self = shift;

if (@_) { $self->{name}二 shift } return $self->{name};

}

Это ведет к использованию такого кода:

$him 二 Person->new();

$him->name(,'Frodo");

$him->name( ucfirst($him->name));

Преимуществом написания отдельных функций для каждой переменной экземпляра (для нашего класса Person это могут быть паше 一 имя, age - имя, height - имя и т. д.) являются непосредственность, очевидность и гибкость. Недостатком является то, что при возникновении необходимости в новом классе приходится определять один или два почти идентичных метода для каждой переменной экземпляра. На первый взгляд, в этом нет ничего страшного, и никому не возбраняется выбрать тот способ, который больше понравится. Но если отдается предпочтение удобству перед гибкостью, то более предпочтительным может оказаться один из приемов, описанных в следующих разделах.

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

Договориться с членами семьи сложнее. Если подкласс замещает метод доступа к атрибуту из надкласса, должен он обращаться к тому处е полю хеша или нет? Можно привести аргументы в пользу того и другого, в зависимости от природы атрибута. В общем случае в интересах безопасности каждый метод доступа может сделать префиксом имени поля хеша имя своего класса, чтобы подкласс и надкласс имели собственные варианты поля. Некоторые из приведенных ниже примеров, а также стандартный модуль Struct: :Class используют такую стратегию защиты от подкласса. Можно видеть методы доступа такого типа:

sub name {

my $self 二 shift;

my $field 二—PACKAGE. . "::name";

if (@_) { $self->{$field} = shift } return $self->{$field};

}

В каждом из последующих примеров мы создаем простые классы Person с полями name, race и aliases, интерфейсы которых идентичны, но реализация совершенно разная. Мы не скажем, который из них нам больше нравится, потому что они все нам нравятся, в зависимости от ситуации. О вкусах не спорят. Кто любит генерала, а кто - свиной хрящик.

Объявление полей с помощью use fields

Объекты не обязательно нужно реализовывать как анонимные хеши. Можно использовать любую ссылку. Например, в случае применения анонимного массива можно организовать такой конструктор:

sub new {

my $invocant = shift;

my $class = ref($invocant) || $invocant;

return bless [], $class;

}

и такие методы доступа:

sub name {

my $self = shift;

if (@_) { $self->[0] = shift }

return $self->[0];

}

sub race {

my $self = shift;

if (@_) { $self->[1] = shift }

return $self->[1];

}

sub aliases {

my $self = shift;

if (@_) { $self->[2] = shift }

return $self->[2];

}

Доступ к массивам происходит несколько быстрее, чем к хешам, и они занимают меньше памяти, но пользоваться ими не совсем удобно. Приходится следить за номерами индексов (не только в вашем классе, но и в надклассе тоже), которые должны как-то указывать, какие части массива использует ваш класс. В противном случае можно обратиться к уже занятой позиции.

Со всеми этими моментами помогает справиться прагма use fields:

package Person;

use fields qw(name race aliases);

Эта прагма не создает методы доступа вместо вас, но использует некоторые встроенные механизмы (называемые псевдохешами), выполняющие нечто подобное. (Во всяком случае можно создать методы доступа - оболочки для полей, как делается в следующем примере.) Псевдохеши - это ссылки на массивы, которые можно использовать как хеши, поскольку с ними связывается таблица отображения ключей. Это отображение ключей устанавливается с помощью прагмы use fields, которая объявляет, какие поля допустимы в объекте Person; благодаря этому о них знает компилятор Perl. Если объявить тип вашей переменной объекта (как в my Person $self в следующем примере), то компилятор оказывается достаточно сообразительным, чтобы оптимизировать доступ к полям, превратив его в прямой доступ к массиву. Более важно, вероятно, что он проверяет имена полей на правильность типа (в действительности на отсутствие опечаток при вводе) на этапе компиляции. (См. раздел «Псевдохеши» главы 8 «Ссылки»).

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

package Person;

use fields qw(name race aliases); sub new { my $type = shift;

my Person $self = fields::new(ref $type || $type); $self->{name} = "unnamed";

$self->{race} = "unknown";

$self->{aliases} = 口； return $self;

}

sub name {

my Person $self = shift; $self->{name} = shift if @_; return $self->{name};

} sub race { my Person $self = shift; $self->{race} = shift if @_; return $self->{race};

}

sub aliases {

my Person $self = shift;

$self->{aliases} = shift if @_; return $self->{aliases};

}

1；

Если неправильно введен литеральный ключ для доступа к псевдохешу, то не придется ждать этапа исполнения, чтобы узнать об этом. Компилятор знает тип объекта, на который должна ссылаться $self (вы сами это сообщили), поэтому может проверить, что код обращается только к тем полям, которые действительно есть у объектов Person. Если у вас ветер в голове и вы пытаетесь обратиться к несуществующему полю (например, $self->{mane}),

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

Методы получения доступа к переменным экземпляра несколько повторяются, поэтому целесообразно автоматизировать создание простых методов доступа с помощью предлагаемых ниже приемов. Однако, поскольку во всех этих методах используется того или иного рода косвенная адресация, в случае их применения теряются преимущества проверки опечаток в ключах доступа к хешу на этапе компиляции.

Если вы для реализации своего класса выбрали псевдохеш, то любой класс, наследующий ему, должен знать о том, что в основе реализации лежит псевдохеш. Если объект реализован как псевдохеш, то все участники иерархии наследования должны использовать объявления use base и use fields. Например,

package Wizard;

use base "Person";

use fields qw(staff color sphere);

Этот код делает модуль Wizard подклассом класса Person и загружает файл Person.pm. Кроме того, регистрируются также три новых поля в этом классе в дополнение к унаследованным от Person. Поэтому, когда вы пишете:

my Wizard $mage 二 fields::new("Wizard");

то получаете объект псевдохеша с доступом к полям обоих классов:

$mage->name("Gandalf");

$mage->color("Grey");

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

$mage->{name} = "Gandalf";

$mage->{color}二"Grey";

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

Хотя use base поддерживает только одиночное наследование, это редко является серьезным ограничением. См. описания use base и use fields в главе 31 «Модули прагм».

Порождение классов с помощью Class::Struct

Стандартный модуль Class: :Struct экспортирует функцию с именем struct. Она создает все необходимое для начала работы с классом в целом. Ею генерируется конструктор с именем new, а также методы доступа ко всем полям данных (переменным экземпляра), указанным в этой структуре.

package Person;use Class::Struct; struct Person => { name => '$' race => '$' aliases => @}；1；package Person;use Class::Struct; struct Person => { name => '$' race => '$' aliases => @}；1；Например, поместим класс в файл Person.pm:

package Person;

use Class::Struct; struct Person => { name => '$' race => '$' aliases => @

}；

1；

package Person;

use Class::Struct; struct Person => { name => '$' race => '$' aliases => @

}；

1；

создать определение для "Person"

поле name является скаляром

поле race тоже является скаляром

но поле aliases является ссылкой на массив

Теперь можно так использовать этот модуль:

use Person;

my $mage = Person->new();

$mage->name("Gandalf");

$mage->race("Istar");

$mage->aliases( ["Mithrandir", "Olorin", "Incanus"]);

Все эти четыре метода создал модуль Class::Struct. Поскольку он придерживается политики защиты подклассов путем дополнения имени поля префиксом из имени класса, он позволяет классу-наследнику, не вызывая конфликта, иметь свое собственное поле с таким же именем, как у базового класса. В данном случае это значит, что в качестве ключа хеша для переменной этого экземпляра используется Person:: name, а не просто name.

Поля в объявлении struct не обязательно должны иметь базовый тип Perl. Они могут также указывать на другие классы, но лучше всего работают классы, созданные с помощью struct, потому что эта функция делает допущения о поведении классов, которые, вообще говоря, верны не для всех них. Например, для инициализации поля вызывается метод new соответствующего класса, хотя для многих классов конструкторы имеют другие имена.

Дополнительные сведения можно получить в описании Class:: St ruct в главе 32 «Стандартные модули» и электронной документации. Многие стандартные модули с помощью Class: :Struct реализуют свои классы, в том числе User: :pwent и Net: : hostent. Изучение их кода может оказаться поучительным.

Генерация методов доступа с помощью автозагрузки

Как говорилось выше, при вызове несуществующего метода у Perl есть два способа поиска метода AUTOLOAD в зависимости от того, объявлен ли метод-заглушка. Это свойство можно использовать для предоставления доступа к данным экземпляра без написания отдельной функции для каждого экземпляра. В программе AUTOLOAD имя фактически вызываемого метода можно извлечь из переменной $AUTOLOAD. Рассмотрим следующий код:

use Person;

$him = Person->new;

$him->name("Aragorn");

$him->race("Man");

$him->aliases( ["Strider", "Estel", "Elessar"]);

printf "%s is of the race of %s.\n", $him->name, $him->race;

print "His aliases: ", join(", ", @{$him->aliases}), ".\n";

Как и прежде, эта версия класса Person реализует структуру данных с тремя полями: name, race и aliases:

package Person;

use Carp;

my %Fields =(

"Person::name" => "unnamed",

"Person::race" => "unknown",

"Person::aliases" => [],

)；

# Следующее объявление гарантирует получение собственного автозагрузчика, use subs qw(name race aliases);

sub new {

my $invocant = shift;

my $class = ref($invocant) || $invocant;

my $self = { %Fields, @_ };# клонировать, как Class::Struct

bless $self, $class;

return $self;

}

sub AUTOLOAD {

my $self = shift;

# обрабатывать только методы экземпляра, но не класса croak "$self не является объектом" unless ref($invocant); my $name = our $AUTOLOAD;

return if $name =~ /::DESTROYS/;

unless (exists $self->{$name}) {

croak "Нет доступа к полю '$name' в $self";

}

if (@_) { return $self->{$name} = shift } else { return $self->{$name} }

}

Как видите, методов с именами name, race или aliases нигде нет. Обо всем этом заботится программа AUTOLOAD. Если кто-то использует $him->name("Ara- gorn"), подпрограмма AUTOLOAD вызывается с $AUTOLOAD, установленной в Person: :name. То, что имя полностью квалифицировано, приводит его как раз в тот формат, который нужен для доступа к полям хеша объекта. Благодаря этому в случае применения данного класса в составе более крупной иерархии не возникает конфликта с такими же именами в других классах.

Создание методов доступа с помощью замыканий

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

package Person;

sub new {

my $invocant = shift;

my $self = bless({}, ref $invocant || $invocant); $self->init();

return $self;

}

sub init {

my $self = shift;

$self->name("unnamed");

$self->race(,,unknown"); $self->aliases([]);

}

for my $field (qw(name race aliases)) { my $slot = __PACKAGE__ . "::$field"; no strict "refs";# Так работает символическая ссылка на typeglob,

my $self = shift;

$self->{$field} = shift if @_; return $self->{$field};

}； }

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

Использование замыканий в закрытых объектах

Приведенные до сих пор приемы управления данными экземпляров не предоставляли механизма «защиты» от внешнего доступа. Находясь вне класса, каждый может открыть черный ящик объекта и залезть внутрь - если он не опасается потери гарантии. Осуществление политики закрытия может

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

В СЛУЧАЕ ПОЖАРА РАЗБИТЬ СТЕКЛО

К такого рода инкапсуляции следует, по возможности, относиться с уважением, но, тем не менее, нужно иметь простой доступ к содержимому в аварийной ситуации 一 например, для отладки.

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

В разделе «Закрытые методы» мы разобрали, как класс может использовать замыкания для реализации методов, которые не видны вне файла модуля. Ниже мы рассмотрим методы доступа, которые делают данные класса настолько закрытыми, что даже остальную часть класса лишают неограниченного доступа. Но все же это достаточно традиционное применение замыканий. Действительно интересный подход состоит в том, чтобы использовать замыкание в качестве самого объекта. Переменные экземпляра объекта оказываются заточенными в области видимости, к которой имеет свободный доступ только сам объект 一 т. е. замыкание. Это очень сильная форма инкапсуляции: она не только защищает от вмешательства извне, но и требует, чтобы другие методы того же класса получали данные объекта посредством надлежащих методов доступа.

Вот пример использования этой технологии. Мы применяем замыкания как для самих объектов, так и для создаваемых методов доступа:

package Person; sub new {

my $invocant 二 shift;

my Sclass 二 ref(Sinvocant) || $invocant; my $data = {

NAME => "unnamed",

RACE => "unknown",

ALIASES => [],

}；

my $self 二 sub {

my $field 二 shift;

############################## Ш ЗДЕСЬ ПРОВЕРКА ДОСТУПА Ш ############################## if (@_) { $data->{$field} = shift } return $data->{$field};

};

bless($self, $class); return $self;

}

# создание имен методов

for my $field (qw(name race aliases)) {

no strict "refs"; # для доступа к таблице имен *$field = sub { my $self 二 shift;

return $self->(uc $field, @_);

}；

}

Объект, создаваемый и возвращаемый методом new, уже не является хешем, как это было в рассмотренных нами ранее конструкторах. Это замыкание с исключительным доступом к данным атрибутов, хранящимся в хеше, на который ссылается $data. После завершения вызова конструктора доступ к $data (и, следовательно, атрибутам) возможен только через замыкание.

При обращении вида $him->name("Bombadil") вызывающий объект, хранящийся в $self, является замыканием, обработанным bless и возвращенным конструктором. С замыканием мало что можно сделать, кроме как вызвать его; это мы и делаем с помощью $self->(uc $field, @_). Пусть вас не вводит в заблуждение стрелка: это обычное косвенное обращение к функции, а не вызов метода. Первым аргументом является строка name, а оставшиеся аргументы представляют все, что еще было передано. Когда выполнение переходит внутрь замыкания, ссылка на хеш внутри $data снова становится доступной. После этого замыкание имеет возможность разрешать доступ или отказывать в нем по своему усмотрению.

Никто за пределами объекта замыкания не имеет непосредственного доступа к этим сильно закрытым данным экземпляра, даже другие методы класса. Они могли бы попытаться обратиться к замыканию таким же способом, как это делают методы, генерируемые в цикле for, например, присваивая значение переменной экземпляра, о которой классу ничего не известно. Но такой подход легко блокируется в участках кода конструктора, где можно найти комментарии по поводу проверки доступа. Прежде всего, нужна общая преамбула:

use Carp;

local $Carp::CarpLevel = 1; # Делает сообщения croak короткими my ($cpack, $cfile) = caller();

Теперь рассмотрим каждую из этих проверок. Первая проверяет существование указанного имени атрибута:

croak "Недопустимое поле '$field' в объекте" unless exists $data->{$field};

Следующая проверка разрешает вызов только из того же файла:

carp "Непосредственный доступ из сторонних файлов запрещен" unless $cfile eq __FILE—;

Следующая проверка разрешает вызов только из того же пакета:

carp "Непосредственный доступ запрещен стороннему пакету ${сраск}::" unless $сраск eq __PACKAGE__;

А эта проверка разрешает вызов только из классов, наследующих нашему:

carp "Непосредственный доступ запрещен недружественному классу ${сраск}::" unless $cpack->isa(__PACKAGE―);

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

Но некоторым приходится быть разборчивыми. Разборчивость нужна тому, кто пишет программное обеспечение для управления полетами. Если вы хотите или обязаны быть одним из таких людей и предпочитаете использовать готовый код, а не изобретать все самому, возьмите из CPAN модуль Tie: :Se- cureHash Дамиана Конвея (Damian Conway). В нем реализованы хеши с ограниченным доступом, поддерживающие разборчивость на открытом, защищенном и закрытом уровнях. В нем решаются также проблемы наследования, которые мы проигнорировали в предыдущем примере. Дамиан написал также еще более амбициозный модуль Class::Contract, который налагает на гибкую систему объектов Perl формальный режим разработки программного обеспечения. Список функций этого модуля выглядит, как перечень из учебника по разработке программного обеспечения, написанного профессором информатики,1 включая принудительную инкапсуляцию, статическое наследование и проверку условия проектирования по контракту (design-by- contract condition) для объектно-ориентированного Perl наряду с декларативным синтаксисом для определений атрибутов, методов, конструкторов и деструкторов на уровне объекта и класса, а также предусловиями, постусловиями и инвариантами классов. Уф!

Новые приемы

Начиная с версии Perl 5.6, можно объявлять методы, возвращающие 1-значение. Это делается с помощью атрибута подпрограммы lvalue (не путайте с атрибутами объекта). Эта экспериментальная функция позволяет обращаться с методом как с чем-то, что может появиться слева от знака равенства:

package Critter;

sub new {

my Sclass = shift;

my $self = { pups => 0, @_ };# Замещение значения по умолчанию,

bless $self, Sclass;

}

sub pups : lvalue {# Присвоение pups() будет выполнено позже,

my $self = shift;

$self->{pups};

}

package main;

$varmint = Critter->new(pups => 4);

$varmint->pups *= 2;# Присвоение $varmint->pups!

$varmint->pups =~ s/(.)/$1$1/;# Изменение $varmint->pups по месту!

print $varmint->pups;# Теперь у нас 88 pups.

Это позволяет обращаться с $varmint->pups как с переменной, в то же время придерживаясь инкапсуляции. См. раздел «Атрибут lvalue» главы 6 «Подпрограммы».

Если вы работаете с версией Perl, поддерживающей потоки, и хотите, чтобы только один поток мог вызывать некоторый метод с объектом, можете использовать для этого атрибуты locked и method:

sub pups : locked method {

}

Когда поток вызывает с объектом метод pups, Perl перед его выполнением блокирует объект, запрещая делать это другим объектам. См. раздел «Атрибуты locked и method» главы 6 «Подпрограммы».

Управление данными класса

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

Ведение учета всех когда-либо созданных или действующих в данный момент объектов.

Ведение списка всех объектов, которые можно итерировать.

Хранение имени дескриптора файла для журнального файла, используемого методом отладки всего класса.

Ведение учета общих данных, например общей суммы денег, выданных всеми банкоматами в сети за данные сутки.

Отслеживание последнего созданного классом объекта или объекта, к которому чаще всего осуществляется доступ.

Поддержка кэша хранимых в памяти объектов, воссозданных из постоянной памяти.

Поддержка таблицы обратного поиска для обнаружения объекта по значению его атрибута.

Вопрос сводится к принятию решения о том, где хранить состояние этих общих атрибутов. В Perl нет специального синтаксического механизма для объявления как атрибутов класса, так и атрибутов экземпляра. Perl предоставляет разработчику набор мощных, но гибких функций, которые можно уникальным образом использовать в зависимости от конкретных требований ситуации. В результате можно выбрать механизм, наиболее оправданный в данной ситуации, а не полагаться на чужие проектные решения. С другой стороны, можно обратиться к проектным решениям, которые кто- то другой упаковал и положил в СР AN. Как всегда, TMTOWTDL

Как и во всем, что относится к классам, при доступе к данным класса следует избегать непосредственного обращения к ним, особенно из-за пределов самой реализации класса. Нельзя обеспечить инкапсуляцию, если, тщательно разработав ограничивающие методы доступа к переменным экземпляра, затем позволить кому угодно укокошить свои переменные класса непосредственно, например, установив $SomeClass:: Debug = 1. Чтобы установить четкую преграду между интерфейсом и реализацией, можно создать методы доступа к данным класса, аналогичные тем, которые применяются для доступа к данным экземпляра.

Представим себе, что нужно вести глобальный учет поголовья объектов Critter. Мы будем хранить это число в переменной пакета, но предоставим метод с именем population, благодаря которому пользователям класса не потребуется знать ничего о механизме реализации.

Critter->population()# Доступ через имя класса

$gollum->population()# Доступ через экземпляр

Поскольку класс в Perl является просто пакетом, естественнее всего хранить данные класса в переменной пакета. Ниже приведена простая реализация такого класса. Метод population игнорирует передаваемый ему инвокант и возвращает текущее значение переменной пакета, $Population. (Некоторые программисты предпочитают писать свои глобальные переменные с заглавной буквы.)

package Critter;

our $Population 二 0;

sub population { return $Population; }

sub DESTROY { $Population- - } sub spawn {

my $invocant = shift;

ту $class = ref($invocant) || $invocant;

$Population++;

return bless { name => shift || "anon" }, $class;

} sub name { my $self = shift; $self->{name}二 shift if @_; return $self->{name};

}

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

our $Debugging = 0;# начальные данные класса

sub debug { shift;# намеренное игнорирование инвоканта

$Debugging = shift if @_;

return $Debugging;

}

Теперь можно установить общий уровень отладки в классе или любом из его экземпляров.

Являясь переменной пакета, $Debugging доступна глобально. Но если изменить ои г на ту, то ее сможет видеть только последующий код в том же файле. Можно пойти еще дальше: отобрать неограниченный доступ к атрибутам класса даже у остальной части самого класса. Поместите объявление переменной в область видимости блока:

{

my $Debugging = 0;# начальные данные класса с лексической областью

видимости

sub debug { shift;# намеренное игнорирование инвоканта

$Debugging = shift if @_;

} }

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

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

Для одних типов классов такой подход работает, а для других - нет. Допустим, мы создаем подкласс Wa「g класса Critter. Если мы хотим вести отдельный учет поголовья, то Wa「g не может наследовать метод population у Critter,

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

Необходимо решать в каждом конкретном случае отдельно, имеет ли смысл атрибутам класса зависеть от пакета. Если вам нужны атрибуты, зависящие от пакета, используйте класс инвоканта для нахождения пакета с данными класса:

sub debug {

my Sinvocant = shift;

my $class = ref(Sinvocant) || Sinvocant;

my $varname = $class . ”：：Debugging”；

no strict "refs"; # для доступа к данным пакета через таблицу имен $$varname = shift if @_;

return $$varname;

}

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

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

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

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

Резюме

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

13

Перегрузка

Объекты, конечно, хороши, но иногда они слишком хороши. Иногда хочется, чтобы они меньше вели себя как объекты и больше как обычные типы данных. Но на этом пути есть проблема: объекты представляются ссылками, а возможности работы со ссылками не велики: ссылки нельзя складывать, выводить или (с какой-нибудь пользой) применять многие встроенные операторы Perl. По сути дела, их можно только разыменовывать. Вот и приходится то и дело явно писать вызовы методов, например:

print $object->as_string;

$new_object = $subject->add($object);

Такое явное разыменование, вообще говоря, дело полезное, т. к. при этом не спутаешь ссылки с их объектами, кроме как в тех случаях, когда это делается намеренно. Один из таких моментов сейчас и настал. Если при разработке класса использована перегрузка (overloading), то можно сделать вид, что никаких ссылок нет, и просто сказать:

print $object;

$new_object = Ssubject + Sobject;

При перегрузке встроенного оператора Perl вы определяете, как он должен себя вести, будучи применен к объектам определенного класса. Перегрузка применяется в ряде стандартных модулей Perl, например Math: :BigInt, который позволяет создавать объекты Math:: Biglnt, ведущие себя как обычные целые числа, но размер которых не ограничен. Их можно складывать

с помощью +, делить посредством /, для сравнения использовать <=>, а для вывода - print.

Обратите внимание, что перегрузка (overloading) - это совсем не то же самое, что автозагрузка (autoloading), которая означает загрузку отсутствующих функций или методов по требованию. Точно так же, это совсем не то же самое, что замещение (overriding), при котором одна функция или метод маскируют другую функцию. Перегрузка ничего не скрывает; благодаря ей бессмысленная до того операция над ссылкой приобретает смысл.

Прагма overload

Прагма use overload осуществляет перегрузку операторов. Ей передается список пар ключ/значение, состоящий из операторов и связанных с ними действий:

package MyClass;

use overload '+' => \&myadd,# ссылка на код

'<'=> "less_than",# именованный метод

'abs' => sub { return @_ }; # анонимная подпрограмма

Теперь, если попытаться сложить два объекта MyClass, то для формирования результата будет вызвана подпрограмма myadd.

Если вы попытаетесь сравнить два объекта MyClass с помощью оператора <, то Perl обнаружит, что нужное действие задано в виде строки и будет интерпретировать эту строку как имя метода, а не просто подпрограммы. В приведенном примере метод less_than может быть предоставлен самим пакетом MyClass или унаследован от базового для MyClass класса, а вот подпрограмма myadd должна быть предоставлена текущим пакетом. Анонимная подпрограмма для abs предоставляется еще более непосредственным способом. Каким бы образом ни предоставлялись эти программы, будем называть их обработчиками (handlers).

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

Для бинарных операторов, таких как + или <, обработчик вызывается, если первый операнд является объектом класса или второй операнд является объектом класса, а для первого операнда перегрузка не задана. Поэтому можно сказать:

$object + 6

или:

+ Sobject

не беспокоясь о порядке операндов. (Во втором случае операнды при передаче обработчику поменяются местами^ Если бы у нас было выражение:

$animal + $vegetable

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

В Perl есть только один тернарный («тринарный») оператор, ?:, и перегрузить его нельзя. К счастью.

Обработчики перегрузки

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

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

$object - 6

и:

- $object

Если первые два аргумента обработчика могут меняться местами, то третий имеет значение true. В противном случае третий аргумент будет равен false, и в этом случае есть также более тонкое различие: если обработчик запущен другим обработчиком оператора с присваиванием (как для +=, где положение знака + определяет тип инкремента), то третий аргумент не просто false, но undef. Это различие позволяет выполнить некоторую оптимизацию.

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

package ClipByte;

use overload '+' => \&clip_add,

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

'-'=> \&clip_sub;

sub new {

my $class = shift;

my $value = shift; return bless \$value => $class;

}

sub clip_add { my ($x, $y) = @_;

my ($value) = ref($x) ? $$x : $x; $value += ref($y) ? $$y : $y; $value = 255 if $value > 255;

Rvalue =0 if $value < 0;

return bless \$value => ref($x); }

sub clip_sub { my ($x, $y, $swap) = @_;

my ($value) = (ref $x)?$$x:$x;

$value-= (ref $y)?$$y:$y;

if ($swap) { Svalue = -$value } $value=255 if $value>255;

Svalue=0 if Svalue<0;

return bless \$value => ref($x); }

package main;

$byte1=ClipByte->new(200);

$byte2=ClipByte->new(100);

$byte3=$byte1 + $byte2;#255

$byte4=$byte1 - $byte2;#100

$byte5=150 - $byte2;#50

Обратите внимание на то, что все функции здесь по необходимости являются конструкторами, поэтому каждая из них использует bless для связи ссылки на свой новый объект с текущим классом, чем бы он ни был; мы предполагаем, что наш новый класс может наследоваться. Мы также предполагаем, что если $у является ссылкой, то это ссылка на объект созданного нами типа. Если быть дотошнее, то вместо проверки ref($y) можно вызывать $y->isa("Clip- Byte") (выполнялось бы это медленнее).

Перегружаемые операторы

Перегружать можно только определенные операторы, которые приведены в табл. 13.1. Эти операторы перечислены также в хеше %overload: :ops, который становится доступным в результате use overload, хотя разбивка по категориям производится там несколько иначе.

Таблица 13.1. Перегружаемые операторы

Категория

Операторы

Преобразование

0+ bool

Арифметичес-

+ - * / % ** х . neg

кие

Логические

!

Поразрядные

& 1 ~ л ! « »

Присваивания

+— — * — /— %— * * — Х— ,— <<— >>— ++ ——

Сравнения

==<<=> >=I= <=> it le gt ge eq ne cmp

Математические

atan2 cos sin exp abs log sqrt

Итеративные

<>

Разыменования

${} @{} %{} &{}*{}

Псевдо

nomethod fallback =>

Обратите внимание, что neg, bool, nomethod и fallback фактически не являются операторами Perl. Пять разыменовывающих операторов, "" и 0+ тоже не похожи на операторы. Тем не менее, все они допустимы в качестве ключей в списке параметров, передаваемом use overload. На самом деле, это не представляет проблемы. Откроем маленький секрет: мы слегка мошенничаем, говоря, что прагма overload перегружает операторы. Она перегружает производимые операции, когда вызывается явно через «официальные» операторы или неявно через какой-либо связанный оператор. (Отмеченные псевдооператоры могут вызываться только неявно.) Иными словами, перегрузка производится не на синтаксическом уровне, а на семантическом. Цель не в том, чтобы хорошо выглядеть, а в том, чтобы делать то, что нужно. Обобщить можете сами.

Заметьте также, что = не перегружает оператор присваивания Perl, как можно было бы предположить. Это не было бы Правильным Делом. Подробнее об этом ниже.

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

Операторы преобразования: "", 0+, bool.

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

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

ключа хеша. Преобразование также служит причиной того, что вы видите что-то типа SCALAR(0xba5fe0) при попытке вывести объект.

Мы говорим, что происходит преобразование в число (numification), когда нечисловая переменная преобразуется в число в каком-либо числовом контексте, например, в математическом выражении, индексе массива или даже операторе .. диапазона.

Наконец, хотя никто не посмеет назвать это boolification, но можно определить способ интерпретации объекта в булевом контексте (таком, как if, unless, while, for, and, or, &&, 11, ?: или блок выражения grep) путем создания булева обработчика.

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

Вот пример "", который запускает обработчик as_st「ifig объекта при преобразовании в строку. Не забывайте заключать в кавычки сами кавычки:

package Person;

use overload q("")二〉\&as_string;

sub new {

my $class 二 shift;

return bless { @_ } => $class;

}

sub as_string { my $self 二 shift; my ($key, $value, $result); while (($key, $value)二 each %$self) { $result .二"$key => $value\n";

} return Sresult;

}

$obj = Person->new(height => 72, weight => 165, eyes => "темно-карие");

print $obj;

Вместо чего-то вроде Person=HASH(0xba1350) этот код выводит (в порядке, определяемом хешем):