Списки и массивы

Списки и списочные литералы

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

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

(256, 512, 1024, 2048, 4096) # список из 5 чисел
('John', 'Paul', 'George', 'Ringo') # список из 4 строк
("Perl", 5.8) # список из строковых и числовых значений

Для записи списка текстовых строк, состоящих из одного слова, предусмотрена специальная форма списочного литерала, в которой после ключевого слова qw (сокращение от quoted words - "слова в кавычках") в скобках записываются строки, не заключенные в кавычки и разделяемые пробельными символами. В качестве скобок могут использоваться традиционные символы: (), {}, //, \\, [] , <> и даже просто парные символы, такие как !! или ##. Например:

qw(это очень удобно) # вместо ('это', 'очень', 'удобно')
qw/John Paul
    George Ringo/ # список слов, расположенный на 2 строках

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

('One', $x, $x+$y-$z, 2*5) # список литералов и выражений
() # пустой список

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

начальное_значение .. конечное_значение

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

5 .. 10    # возвратит список (5, 6, 7, 8, 9, 10)
5.3 .. 7.1 # возвратит список (5.3, 6.3), т. к. 7.3 > 7.1
7 .. 5     # возвратит пустой список (), т. к. 5 < 7
$m .. $n   # диапазон, заданный значениями от $m до $n

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

(-2 .. 2)           # список чисел (-2, -1, 0, 1, 2)
(25, 53, 77 .. 79)  # список (25, 53, 77, 78, 79)
('A'..'Z','a'..'z') # список заглавных и строчных букв 
($start .. $finish) # список значений от $start до $finish

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

($a, $b, $c) = (10 .. 12); # $a = 10; $b = 11; $c = 12;
($day, $month, $year) = (18, 12, 1987); # день рождения Perl
($m, $n) = ($n, $m); # поменять местами значения $n и $m

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

($hh, $mm, $ss, $ms) = (10, 20, 30); # $ms не определено

Если в левой части присваивания переменных меньше, чем значений в правой, то лишние значения не используются.

($hh, $mm, $ss) = (10, 20, 30, 400); # 400 отброшено

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

$scalar = (10, 20, 30, 400); # то же, что $scalar = 400;

Массивы

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

@variable		# массив для хранения списка 
$variable		# скаляр для хранения строки или числа

Списочное значение помещается в массив с помощью операции присваивания. Присваивание выполняется по-разному в зависимости от контекста, который определяется левым операндом присваивания. Если в левой части присваивания стоит массив или список, то и в правой части ожидается список. Например:

@empty = (); # пустой массив после присвоения пустого списка
@months = (1 .. 12); # массив со списком номеров месяцев 
@days = qw(Пн Вт Ср Чт Пт Сб Вс); # массив дней недели
@week = @days; # копирование значения массива @days в @week
@array = 25; # литерал 25 рассматривается как список (25)
($first) = @array; # в $first скопируется 1-й элемент массива
@first = @second = (1, 2, 3); # каскадное присваивание

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

$array_size = @months; # число элементов (размер) массива
$array_size = scalar @months; # размер массива

В зависимости от контекста, системная функция localtime возвращает разные значения: в скалярном контексте она вернет строку с текущей датой и временем, а в списочном - список из девяти значений с данными о дате и времени:

$date_and_time = localtime;
($sec, $min, $hour, # секунды, минуты, часы
$mday, $mon, $year, # день, месяц, год,
$wday, $yday, $isdst) # день недели, день года, часовая зона
= localtime;

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

@small = (3, 4, 5); # этот массив будет вставлен в список
@big = (1, 2, @small, 6 .. 9); # то же, что @big = (1 .. 9);
@big = ((1, 2), (3 .. 5), (6 .. 9)); # то же, что и выше

С помощью списка можно легко добавить новые элементы в начало или в конец существующего массива:

@array = ($new_element, @array); # добавить элемент в начало
@array = (@array, $new_element); # добавить элемент в конец
@all = (@first, @second); # объединить два массива в один

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

($element1, @array) = @array; # извлечь элемент из начала

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

(@array,$a,$b) = (1,2,3,4,5); # все 5 чисел попадут в @array

Элементы массива

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

@array     # переменная-массив, хранящая список
$array[0]  # первый элемент массива с индексом 0
$array[1]  # второй элемент массива с индексом 1
$array[$i] # i-й элемент массива, считая с 0
$array     # скаляр, не имеющий отношения к массиву @array

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

$array[-1]  # последний элемент, то есть 1-й от конца 
$array[-2]  # предпоследний элемент, то есть 2-й от конца 
$array[-$n] # n-й элемент массива, считая с конца

Индекс последнего элемента массива, который всегда на единицу меньше размера массива, можно узнать, указав специальный префикс $# перед именем массива:

$last_index = $#array; # индекс последнего элемента @array

Так, например, можно выбрать элемент массива с помощью встроенного генератора случайных чисел rand, который возвращает дробное число от 0 до числа, указанного ему в качестве аргумента. Ограничим случайные числа номером последнего индекса в массиве и будем округлять их до целых значений функцией int:

$random_element = $array[int(rand($#array))];

В $#array можно присвоить новое значение последнего индекса, при этом размер массива изменится. Но такое действие обычно не требуется, так как массив при необходимости увеличивается автоматически. Размер массива в Perl не ограничивается, то есть массив может занимать всю отведенную программе память.

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

$birthday[0] = 18; $birthday[1] = 12; $birthday[2] = 1987;
($birthday[0], $birthday[1], $birthday[2]) = (18, 12, 1987);

(Хотя более естественно для подобного присваивания воспользоваться срезом массива: @birthday[0, 1, 2] = (18, 12, 1987), но о срезах пойдет речь чуть позже в этой лекции.)

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

$birthday[5] = 'Perl'; # размер @birthday теперь 5
# значение $birthday[3] и $birthday[4] не определено

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

$array[$#array+100] # неопределенно

При использовании в качестве индекса массива дробного числа будет взята его целая часть, то есть $array[3.5] рассматривается как $array[3].

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

for (my $i = 0; $i < scalar @array; $i++) {
   print "$array[$i] ";
}

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

foreach my $element (@array) { # $element это синоним
   print "$element ";       # очередного элемента $array[$i]
}

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

print "$_ " foreach @array;

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

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

$" = ':'; # установим разделитель элементов
print "@array";

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

$fifth = (10..15)[5]; # то же, что $fifth = 15;

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

$hex = (0..9,'A'..'F')[$dec]; # при $dec==12 в $hex будет 'C'

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

$month_day = (localtime)[3]; # элемент списка с индексом 3

Срезы

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

@array[0,1]      # то же, что ($array[0], $array[1])
@array[5..7]     # то же, что ($array[5],$array[6],$array[7])
@array[3,7,1]    # то же, что ($array[3],$array[7],$array[1])
@array[@indexes] # срез, заданный массивом индексов
@array[5]        # список ($array[5]), а не скаляр $array[5]

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

# присвоить значения пяти элементам:
@array[5..9] = qw(FreeBSD Linux MacOS NetWare Windows); 
# поменять местами значения 1-го и последнего элементов:
@array[0,-1] = @array[-1,0];
# напечатать элементы с индексами от $start до $finish
print @array[$start .. $finish];

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

Функции работы с массивами

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

$first = shift @array; # извлечь первый элемент в $first
# синоним: ($first, @array) = @array;

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

while (my $first = shift @array) { # пока @array не опустеет
   print "Обработан элемент $first.";
   print "Осталось ", scalar @array, " элементов\n";
}

Обратите внимание, что для вывода текущего размера массива нужно использовать scalar @array потому, что иначе print воспримет @array как список для печати и выведет значения массива. Существует противоположная shift функция unshift, которая вставляет свои аргументы в массив перед первым элементом, сдвигая существующие элементы вправо.

unshift @array, $e1,$e2,$e3; # вставить значения в начало 
# синоним: @array = ($e1,$e2,$e3, @array);

С помощью массива можно организовать стек, данные в котором обрабатываются по алгоритму LIFO ("last in, first out", "последним пришел - первым ушел"). Для добавления данных в стек применяется операция push, которая добавляет элементы в конец массива:

push @stack, $new; # добавить элемент в конец массива 
# синоним: @stack = (@stack, $new);

Для извлечения одного значения из стека служит встроенная функция pop, которая удаляет последний элемент массива, возвращая его значение:

$last = pop @stack; # изъять последний элемент массива

При помощи комбинации функций push и shift можно организовать список, реализующий очередь данных, у которой элементы добавляются в конец, а извлекаются из начала (в соответствии с алгоритмом FIFO, "first in, first out", "первым пришел - первым ушел").

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

@array = (1..7);        # исходный массив
$offset = 2; $size = 4; # смещение и размер удаляемого списка
@deleted = splice @array, $offset, $size, qw(новый список);
# в @array теперь (1, 2, 'новый', 'список', 7)
# в @deleted попали 4 удаленных элемента (3, 4, 5, 6)

Если список для вставки не указан, то подсписок от элемента с индексом $offset в количестве $size элементов просто удаляется.

Операция сортировки списка выполняется встроенной функцией sort, которая, не изменяя своего аргумента, возвращает список, отсортированный по возрастанию строковых значений элементов исходного списка. Поясним на примере:

@unsorted = (12, 1, 128, 2, 25, 3, 400, 53);
@sorted = sort @unsorted;
# в @sorted будет (1, 12, 128, 2, 25, 3, 400, 53)

Если нужно упорядочить список другим образом, то нужно в качестве первого аргумента функции указать блок, выполняющий сравнение двух элементов сортируемого списка и возвращающий значения -1, 0, 1 - они означают, что первый элемент меньше, равен или больше второго. При сравнении чисел это проще всего сделать с помощью операции <=>, например:

@sorted = sort {$a <=> $b } @unsorted;
# в @sorted будет (1, 2, 3, 12, 25, 53, 128, 400)

В блоке сравнения переменные $a и $b содержат значения двух текущих сравниваемых элементов. Для выполнения сортировки по убыванию достаточно поменять переменные местами {$b <=> $a }. Помните, что для сортировки в обратном порядке строковых значений нужно применить операцию сравнения строк {$b cmp $a }. Вместо блока можно вызвать пользовательскую подпрограмму, выполняющую сколь угодно сложные сравнения элементов сортируемого списка.

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

@array = qw(Do What I Mean); # исходный список
@backwards = reverse @array; # остается неизменным
# в @backwards будет ('Mean', 'I', 'What', 'Do')

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

@backwards = reverse(sort(@array));
# в @backwards будет ('What', 'Mean', 'I', 'Do')

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

my @array = qw/Н А Ч А Л О К О Н Е Ц/; # исходный массив
my $i = 3;        # сдвиг массива ВЛЕВО на 3 элемента                          
my $n = @array;   # число элементов массива                               
                  # алгоритм сдвига Кена Томпсона (1971)
@array[0 ..$i-1]   = reverse @array[0 .. $i-1];  
@array[$i .. $n-1] = reverse @array[$i .. $n-1]; 
@array[0 .. $n-1]  = reverse @array[0 .. $n-1]; 
print "@array\n"; # результат: А Л О К О Н Е Ц Н А Ч

Функция map позволяет выполнить действия над всеми элементами массива, поэтому ее нередко используют вместо цикла. У этой функции есть две формы вызова:

@result = map ВЫРАЖЕНИЕ, СПИСОК
@result = map БЛОК СПИСОК

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

@result = map $_*10, (11, 32, 55); # работа со списком
# в @result будет (110, 320, 550)

При работе map специальная переменная $_ локально устанавливается как синоним текущего элемента списка, поэтому изменение переменной $_ приводит к изменению соответствующего элемента массива. Таким способом можно изменять значения элементов массива. В этом примере воспользуемся блоком, куда поместим операторы вычисления нового значения (если значение элемента больше 20, оно будет удесятеряться):

@array = (11, 32, 55); # исходный массив
@result = map {if ($_ > 20) {$_*=10;} else {$_;} } @array;
# в @result будет (11, 320, 550)

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

@array = (5..10); # объединяемый список
$delimiter = ':'; # разделитель элементов списка в строке
$string = join $delimiter, @array;  # объединение в строку
# теперь $string содержит '5:6:7:8:9:10'

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

$string = '5:6:7:8:9:10'; # исходная строка
$delimiter = ':';         # разделитель подстрок
$limit = 3;               # число элементов
@strings = split $delimiter, $string, $limit; # разделение
# в @strings содержится ('5', '6', '7:8:9:10')

Функция split имеет гораздо больше возможностей, о которых будет сказано в лекции, посвященной регулярным выражениям. Подробно познакомиться с которыми можно из системной документации с помощью утилиты perldoc (после флага -f указывается имя искомой функции):

perldoc -f split

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

Операции в скалярном и списочном контекстах

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

@two = ('A', 'B') x 2; # будет: ('A', 'B', 'A', 'B')
@three = (@one) x 3; # в @three трижды повторится @one

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

@array = (undef()) x @array; # или (undef) x scalar(@array)

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

for (@stdin = (), $n = 0; $n < 5; $n++) {
   print 'Введите значение N ', $n+1, ':';
   $stdin[$n] = <>; # считать строку в $n-й элемент массива
}

В списочном контексте "кристалл" читает в массив за одну операцию все строки файла. Например, так можно заполнить массив данными, вводимыми с консоли:

print "Введите значения - по одному в строке.",
      "Для окончания ввода нажмите Ctrl-Z (или Ctrl-D).\n";
@stdin = <>; # считать все строки и поместить их в массив
print "Вы ввели ", scalar @stdin, " значений.\n";

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

chomp @stdin; # убрать \n в конце всех элементов массива
$n_count = chomp $string; # убрать \n в конце строки

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

$last_char = chop $string; # отсечь последний символ строки 
chop @array; # отсечь последний символ в элементах массива

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

Специальные массивы

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

@ARGV  аргументы командной строки для выполняемой программы
@INC   список каталогов для поиска внешних Perl-программ
@_     массив параметров для подпрограмм или буфер для split

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