Глава 2. Конструкции языка Perl

Любая команда в Perl — это выражение. Выполнение команды заключается в вычислении выражения. Присваивание не является исключением. Вычисляемым значением для присваивания является то, что присваивается.

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

Perl
$x=$y=$z=0;

Если встречается цепочка присваиваний, они выполняются справа налево, как будто расставлены скобки:

Perl
$x=($y=($z=0));

Значение выражения во внутренних скобках равно нулю (так как ноль присваивается переменной $z), и оно присваивается переменной $y. Поэтому нулю будет равно и выражение во внешних скобках. Оно будет присвоено переменной $x.

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

Perl
($x, $y, $z)=(3, 4, 5);

Такое списочное присваивание равносильно трём обычным:

Perl
$x=3;
$y=4;
$z=5;

Иногда требуется обменять значения двух переменных. Пусть, к примеру, значения переменных $x и $y равны 2 и 3 соответственно. Наивное решение не сработает:

Perl
$x=$y;	теперь значение $x равно 3
$y=$x;	а теперь и $y равно 3

Тут не обойтись без вспомогательной переменной $tmp, в которую предварительно запишем старое значение $x, а потом отправим в переменную $y:

Perl
$tmp=$x;
$x=$y;
$y=$tmp;

(имя $tmp происходит от английского temporary — временный; так часто называют переменные, которые нужны для однократного использования, как в нашем случае).

Списочное присваивание избавляет нас от необходимости прибегать к вспомогательной переменной:

Perl
($x, $y)=($y, $x);

В Perl имеется несколько способов записи числовых констант:

Текст будет позже.

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

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

К примеру, при выбранной кодовой таблице UCS строка Hello, world! состоит из символов с номерами $72,101,108,108,111,44,32,119,111,114,108,100,33$, а строка Школа №54 — из символов с номерами $1064,1082,1086,1083,1072,32,8470,53,52$. Обратите внимание, что английская буква o и русская буква о имеют различные номера в кодовой таблице ($111$ и $1086$), несмотря на совершенно одинаковое изображение.

Чтобы поместить в программу текстовую строку, имеются несколько способов. Во-первых, можно заключить текст в одиночные кавычки ' (правильное название для этой кавычки — апостроф). Вот так: 'текст'. Если требуется включить в текст сам знак апострофа, нужно сделать так, чтобы он не воспринимался как правый ограничитель строки. Для этого помещаем перед апострофом знак обратной косой черты (бэкслэш): 'Rock\'n\'Roll'. Это способ поместить в программу строку Rock'n'Roll. Если вдруг зачем-то понадобится создать строку со знаком бэкслэш, за которым следует знак апострофа, поступаем так: '…\\\'…' — перед апострофом ставим бэкслэш, а перед предшествующим ему знаком бэкслэш помещаем ещё один. Такое применение бэкслэша имеется во многих компьютерных языках: этот символ лишает следующий за ним символ какого-то особенного смысла, или, наоборот, придаёт ему особый смысл. В результате бэкслэш сам приобретает особый смысл, а вот предшествующий ему бэкслэш уже лишает его особого смысла.

Заключение строки в апострофы позволяет вводить в текст программы строковые константы (то есть неизменяемые, постоянные строки).

Другой способ даёт возможность создавать строки, в которых есть изменяемая часть. Это строки в двойных кавычках ". Их использование почти такое же, что и использование апострофов, но есть отличия. Главное отличие состоит в том, что внутри таких строк происходит интерполяция переменных, то есть подстановка вместо имён переменных их значения.

Поясним это явление на примере. Фрагмент программы

Perl
$user='cerebellum';
print "Hello, $user!";

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

Perl
$user='cerebellum';
print 'Hello, '.$user;

Здесь мы соединяем (сцепляем) вместе две строки, константу 'Hello, ' и строку в переменной $user, и печатаем командой print то, что получилось. Правда, так получается длинней, особенно если требуется поместить в строку несколько переменных, да и от кавычек и операторов конкатенации (.) рябит в глазах.

Следующий пример иллюстрирует одну возможную неприятность во время интерполяции переменных:

Perl
$hours=3;
$minutes=14;
print "Total time: $hoursh $minutesm";

Вместо ожидаемой строки Total time: 3h 14m программа выведет

Name "main::hours" used only once: possible typo at ./a.pl line 2.
Name "main::minutes" used only once: possible typo at ./a.pl line 3.
Name "main::hoursh" used only once: possible typo at ./a.pl line 4.
Name "main::minutesm" used only once: possible typo at ./a.pl line 4.
Use of uninitialized value $hoursh in concatenation (.) or string at ./a.pl line 4.
Use of uninitialized value $minutesm in concatenation (.) or string at ./a.pl line 4.
Total time:  

Первые четыре предупреждения намекают нам, что переменные $hours, $minutes, $hoursh, $minutesm использованы только по одному разу, то есть без всякой пользы. Это, конечно, не криминал, но, как правило, свидетельствует об ошибке программирования (возможно, опечатке). Позвольте, а что это за переменные $hoursh, $minutesm? Это результат близкого соседства имени переменной и единицы измерения времени внутри двойных кавычек. Perl видит "…$hoursh…" и пытается подставить вместо законного имени переменной $hoursh её значение. Но эта переменная упоминается здесь первый и последний раз, она ни разу не получала значение. Последние две жалобы как раз об этом. Откуда грамматическому анализатору знать, что имя подставляемой переменной, по нашему замыслу, $hours, а следующая буква h — это просто буква? Для борьбы с двусмысленностью поступаем так:

Perl
print "Total time: ${hours}h ${minutes}m";

Если после имён подставляемых переменных идёт символ, который запрещено использовать в именах, эта проблема не возникает.

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

Perl
print "Invest only $1 and become millionaire!";

Получаем следующее:

Use of uninitialized value $1 in concatenation (.) or string at ./a.pl line 5.
Invest only  and become millionaire!

Дело в том, что здесь выполняется нежелательная подстановка переменной $1 (да, это специальная переменная, и её имя не соответствует нашим канонам; она имеет отношение к регулярным выражениям, см. главу 30. «Регулярные выражения»). В данном случае были бы уместней апострофы:

Perl
print 'Invest only $1 and become millionaire!';

А можно «защитить» знак доллара, поставив перед ним наш любимый бэкслэш:

Perl
print "Invest only \$1 and become millionaire!";

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

Комбинации \x{…} и \N{…} бывают полезны, если символ неудобно или невозможно ввести в текст программы непосредственно, например, из-за отсутствия его на клавиатуре. Шестнадцатеричные номера и названия символов берутся из таблицы UCS.

Помимо комбинаций, предназначенных для вставки символов, имеются комбинации особого назначения:

Спрашивается, а зачем могут понадобится эти команды? Почему бы не писать просто "Moscow" вместо "\umoscow"? Конечно же полезными эти возможности становятся при использовании интерполяции переменных в ""-строках. Рассмотрим пример, в котором переменные $surname и $firstname содержат фамилию и имя, записанные целиком прописными буквами, а требуется вывести их в обычном формате (первая буква прописная, остальные — строчные):

Perl
$surname='MARX';
$firstname='KARL';
print "\u\L$firstname\E \u\L$surname\E\n";

Karl Marx

В Perl имеется конструкция, позаимствованная из командного языка операционной системы Linux. Это так называемые here-строки. Если в текст программы нужно поместить многострочный текст, удобно воспользоваться такой конструкцией:

Perl
$text=<<__TEXT__;
Придешь усталый,
                вешаться хочется.
Ни щи не радуют,
                ни чая клокотанье.
А чайкой поплещешься —
                      и мёртвый расхохочется
от этого
        плещущего щекотания.
__TEXT__

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

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

Perl
$text="Придешь усталый,\n                вешаться хочется.\nНи щи не радуют,\n                ни чая клокотанье.\nА чайкой поплещешься —\n                      и мёртвый расхохочется\nот этого\n        плещущего щекотания.\n";

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

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

Внутри <<__MARKER__-строк действуют те же правила, что и внутри ""-строк. Там точно так же производится интерполяция переменных и действуют комбинации, начинающиеся со знака бэкслэш:

Perl
print <<__EMAIL__
Здравствуйте, $name!

Вы были зарегистрированы на сайте swindler-shop.com под логином:
Логин: $login
Пароль: $password

Вы можете зайти на сайт с этим логином и отслеживать состояние своих заказов.

С уважением, компания «Swindler Shop».
__EMAIL__

Этот пример показывает, что here-строки возможно использовать не только в правой части присваивания.

Если требуется, чтобы внутри here-строк не производилась интерполяция переменных и обработка бэкслэш-комбинаций, заключим маркер в одиночные кавычки сразу после <<:

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

Perl
@a=(1, 2, 3, 4, 5, "математика", "механика");

Как показывает этот листинг, элементами массива могут быть как числа, так и строки.

Ещё один способ создать массив — присвоить ему другое значение-массив:

Perl
@b=@a;

В результате такого присваивания получится массив @b — точная копия массива @a. Последующие изменения в массиве @b никак не отразятся на содержимом массива @a, и наоборот.

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

Perl
$c[2]=54;
$c[5]="школа";

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

Обратите внимание на знак $ в выражениях $c[2] и $c[5]. Хотя перед именем массива @c используется знак @, здесь используется доллар в знак того, что мы имеем дело с отдельной ячейкой массива, содержащей скалярное значение.

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

Perl
@numbers=0..99;

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

Perl
@alphabet='A'..'Z';

Размер массива можно получить, использовав саму переменную-массив. Например, так:

Perl
@array=('пн', 'вт', 'ср', 'чт', 'пт', 'сб', 'вс');
$arraySize=@array;	теперь в скалярной переменной $arraySize будет число 7

Имеется специальное обозначение для индекса последнего элемента массива. Для массива @a специальная переменная $#a содержит такой индекс. Для пустого массива значение этой переменной равно -1. Переменную можно использовать и в левой части присваивания, если нужно явно укоротить или удлинить массив до нужной длины. Присваивание такой переменной значения -1 опустошает массив. Впрочем, того же результата можно добиться, присвоив массиву пустой список:

Perl
@a=();

В Perl допускается обращение к элементам массива с отрицательными индексами. Индекс -1 указывает на последний элемент массива, -2 на предпоследний, и так далее. Таким образом, выражение $a[-1] равносильно выражению $a[$#a].

Для людей ленивых, а также тех, которые не любят, когда от кавычек и запятых рябит в глазах, в Perl имеется оператор qw/…/, позволяющий записывать короче массив строк. Пример с сокращёнными названиями дней недели можно было бы записать короче:

Perl
@array=qw/пн вт ср чт пт сб вс/;

Естественно, использование оператора qw/…/ ограничивается созданием массивов строк, чьи элементы не содержат пробелов, поскольку пробелы внутри оператора служат для разделения элементов. Если это необходимо для наглядности, можно в качестве разделителей использовать по нескольку пробелов подряд, или использовать вместо пробелов пробельные символы (например, символ табуляции или конца строки):

Perl
my @daysOfWeek=qw/
		понедельник
		вторник
		среда
		четверг
		пятница
		суббота
		воскресенье
	/;

В отличие от многих других языков программирования, в Perl допустимо обращаться не только к отдельной ячейке массива, но и к целому набору ячеек. Например, скопировать из массива @a в массив @b ячейки с индексами 7, 3, 5 (именно в таком порядке) можно следующим образом:

Perl
@b=@a[7, 3, 5];

Мы не ошиблись. На этот раз перед именем массива @a, несмотря на последующие квадратные скобки, ставится именно @, а не $, поскольку выражение @a[7, 3, 5] даёт список скалярных значений.

Выражения вида @a[…], где в квадратных скобках указан список индексов, можно использовать и в левой части операции присваивания. Эта интересная возможность позволяет переставлять местами некоторые элементы массива без использования вспомогательных переменных. К примеру, поменять местами первый и последний элементы в массиве можно классическим способом

Perl
$tmp=$a[0];
$a[0]=$a[-1];
$a[-1]=$tmp;

Но можно сделать то же самое короче и яснее так:

Perl
@a[0, -1]=@a[-1, 0];

Команда shift (shift [ʃıft] — сдвинуть) извлекает из массива самый первый элемент. При этом элемент из массива удаляется, а на его место сдвигаются его соседи справа. Команда unshift делает противоположное — добавляет в массив скалярное значение слева; при этом все элементы массива сдвигаются вправо. Аналогичные манипуляции с массивом осуществляют команды pop (pop [pɔp] — вытолкнуть) и push (push [puʃ] — втолкнуть), но только с правого конца массива:

Perl
@days=('пн', 'вт', 'ср', 'чт', 'пт', 'сб', 'вс');
$monday=shift @days;		теперь @days содержит
				('вт', 'ср', 'чт', 'пт', 'сб', 'вс'),
				а $monday содержит 'пн'

push @days, $monday;		теперь в @days содержится
				('вт', 'ср', 'чт', 'пт', 'сб', 'вс', 'пн')

unshift @days, (pop @days);	вернём всё в первоначальное состояние

Команды unshift и push могут добавлять в массив (соответственно слева и справа) и по нескольку ячеек сразу.

Реже используемая команда splice обобщает те возможности, которые предоставляются командами shift, pop, unshift, push. Она, во-первых, вырезает из массива кусок, начинающийся с заданного индекса и имеющий заданную длину, возвращая его. Во-вторых, при желании, на место вырезанной части вставляется новый список элементов.

Чтобы прояснить поведение всех этих пяти команд, приведём таблицу эквивалентов:

Perl
$b=shift @a;
($b, @a)=@a;
($b)=splice @a, 0, 1;

Perl
$b=pop @a;
($b, @a)=@a[-1..$#a-1];
($b)=splice @a, -1;

Perl
unshift @a, @b;
@a=(@b, @a);
splice @a, 0, 0, @b;

Perl
push @a, @b;
@a=(@a, @b);
splice @a, @a, 0, @b;

Удалить все элементы массива проще всего, присвоив ему пустой массив:

Perl
@a=();

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

Perl
%h=(
		'кошка',	'котёнок',
		'собака',	'щенок',
		'лошадь',	'жеребёнок',
		'овца',		'ягнёнок',
		'свинья',	'поросёнок',
		'корова',	'телёнок',
		'коза',		'козлёнок',
	);

Элементы массива в правой части присваивания, имеющие чётные индексы, станут ключами в ассоциативном массиве, а следующие за ними элементы с нечётными индексами — соответствующими этим ключам значениями.

Мы в вышеприведённом примере для наглядности разбили список в правой части присваивания на пары, разместив их на отдельных строках, хотя могли бы всё присваивание записать в одну строку или как-нибудь иначе. Для большей выразительности мы могли бы соединить вместе ключи и значения оператором =>, оставив запятые как разделители пар:

Perl
%h=(
		'кошка'=>	'котёнок',
		'собака'=>	'щенок',
		'лошадь'=>	'жеребёнок',
		'овца'=>	'ягнёнок',
		'свинья'=>	'поросёнок',
		'корова'=>	'телёнок',
		'коза'=>	'козлёнок',
	);

Конечно же остаётся возможность использовать оператор qw/…/, если ни ключи, ни значения не содержат пробелов:

Perl
%h=qw/
		кошка	котёнок
		собака	щенок
		лошадь	жеребёнок
		овца	ягнёнок
		свинья	поросёнок
		корова	телёнок
		коза	козлёнок
	/;

Читателя, возможно, интересует: что будет, если ассоциативному массиву присваивается список нечётной длины? Ничего страшного не произойдёт — просто значение, соответствующее последнему ключу, останется неопределённым. А что если среди ключей (элементов с чётными индексами в массиве справа) встретятся одинаковые? И это не беда: каждый раз, когда повторно встречается какой-нибудь ключ, старое соответствующее ему значение заменяется новым.

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

Ассоциативные массивы можно присваивать:

Perl
%i=%h;

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

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

Perl
$h{'утка'}='утёнок';
print $h{'утка'};

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

Perl
$eng2dut{salt}='zout';
$eng2dut{sugar}='suiker';
$eng2dut{matches}='lucifers';

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

Если добавить значение в несуществующий ассоциативный массив, он тихо создаётся. Здесь ситуация такая же, как и обычными массивами.

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

Perl
@elements{qw/Zn Sn Pb/}=qw/цинк олово свинец/;

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

Perl
@h{qw/a b/}=@h{qw/b a/};

Команда keys позволяет получить список ключей из ассоциативного массива:

Perl
%digits=(zero=>0, one=>1, two=>2, three=>3);
@names=keys %digits;

После выполнения этого кода массив @names будет содержать строки 'zero', 'one', 'two', 'three' в неизвестном порядке. Как мы уже упоминали, порядок, в котором хранятся пары ключ — значение в ассоциативном массиве, не определён, и полагаться на какой-то определённый порядок будет ошибкой. Если нужно работать с ключами или со значениями в ассоциативном массиве по порядку, потребуется сортировка, обсуждение которой мы отложили до главы 18. «Сортировка».

Аналогичная команда values выдаёт список значений. После выполнения

Perl
@numbers=values %digits;

в массиве @numbers окажутся числа 0, 1, 2 и 3, опять же в непредсказуемом порядке.

Команда delete используется для удаления отдельного ключа или списка ключей. Вместе с ключом удаляется и связанное с ним значение. После выполнения

Perl
delete $digits{two};

в ассоциативном массиве останутся лишь пары (zero=>0, one=>1, three=>3), а затем, после выполнения

Perl
delete @digits{qw/zero three/};

останется лишь пара (one=>1).

Можно опустошить ассоциативный массив %h вычурной командой

Perl
delete @h{keys %h}

Но короче и быстрее будет присвоить ассоциативному массиву пустой список:

Perl
%h=();