Списъка в Perl е представлява последователност от скалари. В списъка може да се съхраняват редове от файл, имената на футболен отбор или покупките, които трябва да направите.
   Най-простия списък в Perl е празния списък (този, който не съдържа елементи) - (). С него разбира се не може да се правят много неща. Затова нека да добави няколко стойности - (34, "cars",' and ',"trucks","n"). Сега ще подадем този списък на функцията print :

CODE

1 2 3 4 5 6 7 8 9

#!/usr/bin/perl #ex4.plx use warnings; print (34, "cars",' and ',"trucks","n"); print 34, "cars",' and ',"trucks","n"; >perl ex4.plx 34cars and trucks 34cars and trucks >

В горния пример виждате два начина за записване на списъци. Perl не поставя автоматично интервали между елементите (интервалите около and са поставени от мен). Всеки един списък може да съдържа в себе си произволна комбинация от низове, скалари и променливи, като за разделители може да изплзвате кавички, апострофи или операторите q// и qq//. Освен тези два оператора, perl добавя и трети, който автоматично разделя отделните елементи - т.е. няма нужда от запетаи. В този смисъл следните списъци са единтични:

CODE

1 2 3

('apple','grapes','peach'); qw/apple grapes peach/; qw|apple grapes peach|;

Използването на оператора qw//, е аналогично на операторите q// и qq//, с тази разлика, че няма нужда от разделянето на елементите със запетаи - даже напротив, ако решите да ги разделите със запетаи perl ще даде предупреждение. Много важна особенност на perl е, че ако сложите един списък вътре в друг списък, то вътрешния списък ще се слее с външния. Всъщност това, което прави perl е да премахне всички вътрешни скоби, като остави само най-външните. Следващите три списъка са напълно единтични:

CODE

1 2 3

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

По - късно, ще научим как да слагаме един списък в друг, но сега е време да покажа как се осъществява достъпа до елементите на списъците. Това се прави като поставим номера на желания елемент в квадратни скоби непоспедствено след списъка. Запомнете, че и тук подобно на Java Script, броенето на елементите започва от нула.

CODE

1 2 3 4 5 6 7 8

#!/usr/bin/perl #ex14.plx use warnings; use strict; print (('apple','grapes','peach')[1]); >perl ex14.plx grapes>

Важното тук е, че се налага използването на скоби около списъка, поради високия приоритет на print. Ако напишете конструкцията така : print ('apple','grapes','peach') [1];, то perl ще предаде на print целия списък и след това, ще извлече втория елемент от print, което както може би се досещате е невъзможно - просто print не е списък. Задаването на елемент от списъка може да стане и чрез променлива. Например така:

CODE

1 2 3 4 5 6 7 8 9 10 11 12

#!/usr/bin/perl #ex15.plx use warnings; use strict; my $fruit = 3; print qw(         apple   strawberry  peach         orange  grapes      plurn     )[$fruit]; >perl ex15.plx orange>

Perl позволява подаването и на нецелочислени стойности за елементи от списък. В този случай той ще закръгли числото винаги към по - ниската цяла стойност. По интересно е ако се подаде отрицателна стойност. В този случай perl започва да брои отзад напред. Например ако $fruit = -1, perl ще изведе като резултат plurn.
   Когато искаме да получим повече от един елемент, то в квадратните скоби трябва да подадем списък със всички номера на елементи, които искаме да извлечем.

CODE

1 2 3 4 5 6 7 8

#!/usr/bin/perl #ex16.plx use warnings; use strict; print (("apple ","strawberry ","peach ")[(0,2)]); >perl ex16.plx apple peach >

 Когато се налага да попълвате списък с последователни елементи, можете да го направите автоматично с конструкцията (1 .. 10). Това ще създаде списък с елемнти от 1 до 10. Правилото, което трябва да спазвате е, че от дясно винаги стои по-малкото число. Например (10 .. 1) е невалидна конструкция (тук може да използвате функцията reverse(1 .. 10), която ще ви даде желания резултат). Можете да задавате подобни диапазони и на букви, например : print ('a'..'z').
   Друго приложение на диапазоните е използването им за задаване на номера на елемнтите от даден списък, например :

CODE

1 2 3 4 5 6 7 8

#!/usr/bin/perl #ex17.plx use warnings; use strict; print ((1 .. 10)[1 .. 5]); >perl ex17.plx 23456>

Променливата, в която се съхраняват списъците се нарича масив. Тя винаги започва със знака @ , като правилата за образуването й са същитите както и на скаларните променливи. Присвояването на стойност на масив става така:

CODE

1	@numbers = (1,2,3,4,5);

Достъпа до елементите на масив се подчинява на същите правила, както и достъпа до елементите на списък.

CODE

1	print $numbers[1]

Тъй като резултата е скаларна променлива, вие трябва да я напишете като такава. Имайте впредвид, че ако имате обикновенна скаларна променлива със същото име ($numbers), то тя е различна от променливата $numbers[1] и конфликт с имената няма да има. Ето и пример за работата с масиви:




CODE

1 2 3 4 5 6 7 8 9 10 11 12 13

#!/usr/bin/perl #ex18.plx use warnings; use strict; my @array = ("apple","grapes","peach"); print @array,"n"; print $array[1],"n"; print @array[0..2]; >perl ex18.plx apple grapes peach grapes apple grapes peach>

 Както виждате, за разлика от списъците, тук автоматично се добавя интервал между елементите.
   Копиране на масив в друг масив става лесно : @array2 = @array1. Какво ще стане, обаче ако присвоим масив на скаларна променлива :

CODE

1 2 3 4 5 6 7 8 9 10 11

#!/usr/bin/perl #ex19.plx use warnings; use strict; my @array = ("apple","grapes","peach"); my $elements = @array; print $elements, "n"; >perl ex19.plx 3 >

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

CODE

1	print scalar @array1; #Резултата е отново 3.

Обхождането на масив ще става чрез цикъла for , с който ще се запознаете по - късно. Сега е време да ви запозная и с функциите за работа с масиви. Първата функция трябва да ви е позната от списъците, това е функцията reverse. Тя обръща реда на елементите на масива.

CODE

1 2 3 4 5 6 7 8 9 10 11 12

#!/usr/bin/perl #ex20.plx use warnings; use strict; my @array = ("apple","grapes","peach"); print "Array before reverse :",@array,"n"; print "Array after reverse :",reverse @array,"n"; >perl ex20.plx Array before reverse :apple grapes peach Array after reverse : peach grapes apple >

Чрез функцията sort можете да сортирате масива по азбучен или числов ред.

CODE

1 2 3 4 5 6 7 8 9 10

#!/usr/bin/perl #ex21.plx use warnings; use strict; my @array = ("peach","apple","grapes"); print "Sorted array :",sort @array,"n"; >perl ex21.plx Sorted array : apple grapes peach >

Това обаче действа само когато сравнявате низове. Ако сравнявате числа, обаче положението е малко по различно. Това е така, защото perl сравнява елементите като низове. Точно поради тази причина и следния пример няма да работи както очаквате:

CODE

1 2 3 4 5 6 7 8 9

#!/usr/bin/perl #ex21a.plx use warnings; use strict; my @array = (2,1,11,3); print "Sorted array :",sort @array,"n"; >perl ex21a.plx Sorted array :1 11 2 3

Според perl 11 е преди 2, което както знаем не е вярно. Разбира се perl позволява да заобиколите този проблем, като към функцията sort се добавя допълнителен блок, който и казва как да сравнява елементите - като низове или като числа. Как се сравняваха числа - ами с оператора <=>. Нека да модифицираме горния пример, така че да може правилно да сравнява числа:

CODE

1 2 3 4 5 6 7 8 9 10 11 12

#!/usr/bin/perl #ex21b.plx use warnings; use strict; my @array = (2,1,11,3); print "String sort :",sort{$a cmp $b} @array,"n"; print "Number sort :",sort{$a <=> $b} @array,"n"; >perl ex21b.plx String sort :1 11 2 3 Number sort :1 2 3 11 >

Ако искате да добавите елемент към масив може да използвате конструкцията @array = (@array, $scalar) и променливата $scalar ще бъде добавена към масива. Perl обаче разполага със специални функции за тази цел, които оперират с масива, като стек. Чрез оператора push можете да добавяте елемент или списък от елементи към края на масив. Съответно, за да отстраним най-горния елемент от масива, използваме оператора pop.

CODE

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18

#!/usr/bin/perl #ex22.plx use warnings; use strict; my @array = (1,2,3,4,5); my $element; print "Initial array is :",@array,"n"; $element = pop (@array); print "Now our array is :",@array,"n"; print '$element have value :',$element,"n"; @array = push (@array,$element); print "At the end our array is :",@array,"n" >perl ex22.plx Initial array is :1 2 3 4 5 Now our array is :1 2 3 4 $element have value :5 At the end our array is :1 2 3 4 5

Функциите push и pop действат върху "горния край" на стека, за разлика от shift и unshift, които действат върху неговия "долен край". Ето и пример:

CODE

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19

#!/usr/bin/perl #ex23.plx use warnings; use strict; my @array = (1,2,3); my $element; print "Initial array is :",@array,"n"; unshift(@array,0); print "Array now is :",@array,"n"; $element = shift(@array); print "Array again is :",@array,"n"; print 'Value of $element is :',$element,"n"; >perl ex23.plx Initial array is :1 2 3 Array now is :0 1 2 3 Array again is :1 2 3 Value of $element is :0 >

Последният тип променливи, които ще използваме е хешът. Хешът (някои го наричат асоциативен масив) представлява множество еднозначни съответствия. Той е подобен на телефонен указател, в който се прави съответстиве между номера на абоната и неговия адрес. В хеша номера на абоната са нарича ключ и трябва да е единствен в рамките на хеша. Адреса на абоната се нарича стойност и тя може да се повтаря в един хеш. Разликата между телефонния указател и хеша е, че телефонния указател е подреден по определен признак, а хеша не е. Всяка една от двойките ключ/стойност се намира в произволен порядък. Хеша започва със знака за процент % и след това името му се образува по общите правила за имена на променливи.Сега нека да създадем нашия първи хеш (има два начина за това):

CODE

1 2 3 4 5 6 7 8 9 10 11 12

#Първи начин - като обикновен списък от двойки %city = (         "Ivan"  ,"Sofia",         "Petko" ,"Plovdiv",         "Josh"  ,"Dalas",         ); #Втори начин - с оператора => %city = (         Ivan => "Sofia",         Petko => "Plovdiv",         Josh => "Dalas"         );

Резултата и при двата начина е един и същ, но втория начин и по-прегледен и акцентира върху това, че работим с хешове. Това, което направихме е, че създадохме съответствие между името на човека и града, в който живее. Perl позволява свободното конвертиране на хешове в масиви и обратно. Това става с просто присвояване:

CODE

1 2	@array = %hash; %hash = @array;

 Трябва да имате впредвид, че при конвертирането от масив в хеш подредбата се губи. Ако масива има нечетен брой елементи няма да можете да го конвертирате в хеш.
   За да търсим стойности в хеш, използваме нещо подобно на индексите в масивите. Вместо по номер, обаче сега търсим стойноста по име - името на ключа. Вместо квадратни използваме фигурни скоби :

CODE

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18

#!/usr/bin/perl #ex24.plx use warnings; use strict; my $place = "Dalas"; my %city = ( Ivan => "Sofia", Petko => "Plovdiv", Josh => "Dalas" ); my %people = reverse %city; print "Ivan lives in ",$city{Ivan},"n"; print "$people{$place} lives in $placen"; >perl ex24.plx Ivan lives in Sofia Josh lives in Dalas >

В горния пример е показано и обръщането на стойностите в ключове. Трябва да внимавате, когато правите това, защото е възможно да има едни и същи стойности. Тъй като ключовете трябва да са уникални, то ще се получи загуба на информация.
   Добавянето на нов елемент към хеш става така:

CODE

1	$city{Maria} = "Varna";

За отстраняването на елемент от хеша се използва функцията delete, която получава като аргумент ключа, който трябва да бъде изтрит.Нека да изтрием Ivan от хеша:

CODE

1	delete $city{Ivan};

Обхождането на хешове ще бъде показано в следващата глава, където се разглеждат различните цикли и условия в Perl.