Arrays, lists, and hashes are data structures in Perl. Arrays store elements indexed by numbers, while lists are ordered collections written as comma separated values. Hashes store key-value pairs, with keys preceding values. Elements in arrays and hashes can be accessed and manipulated using indexing syntax like $array[0] or $hash{"key"}. Common list operations include shift, unshift, push, and iterating with foreach, map, and grep.

1. ARRAYS, LISTS AND HASHES
By
SANA MATEEN

2. ARRAYS
 It is collections of scalar data items which have an assigned storage space in memory,
and can therefore be accessed using a variable name.
 The difference between arrays and hashes is that the constituent elements of an array are
identified by a numerical index, which starts at zero for the first element.
 array always starts with @, eg: @days_of_week.
 An array stores a collection, and list is a collection, so it is natural to assign a list to an
array. eg.
@rainfall=(1.2, 0.4, 0.3, 0.1, 0, 0 , 0);
This creates an array of seven elements. These can be accessed like
$rainfall[0], $rainfall[1], .... $rainfall[6].
A list can also occur as elements of other list.
@foo=(1,2,3, “string”);
@foobar= (4, 5, @foo, 6);
This gives foobar the value (4,5,1,2,3, “string”,6).

3. MANIPULATING ARRAYS
 Elements of an array are selected using C like square bracket syntax, eg: $bar=$foo[2].
 The $ and [ ] make it clear that this instance foo is an element of the array foo, not the
scalar variable foo.
 A group of contiguous elements is called a slice, and is accessed using simple syntax.
 @foo[1..3]
 Is the same as the list
($foo[1],$foo[2],$foo[3])
 The slice can be used as the destination of the assignment eg:@foo[1..3]= (“hop”, “skip”,
“jump”);
 Array variables and lists can be used interchangeably in almost any sensible situation:
$front=(“bob”, “carol”, “ted”, “alice”)[0];
@rest=(“bob”, “carol”, “ted”, “alice”) [1..3];
or even
@rest=qw/bob carol ted alice/[1..3];
Elements of an array can be selected by using another array selector.
 @foo =(7, “fred”, 9);
 @bar=(2,1,0);
then
@foo=@foo[@bar];

4. LISTS
 List is a collection of variables , constants or expressions which is to be
treated as a whole . It is written as comma separated sequence of values.
Eg: “red”, “green”, “blue”
 A list often appears in a script enclosed in round brackets.
(“red”, “green”, “blue”)
 Short hand used in lists: (1..8) and (“A”.. “H”, “O”.. “Z”).
 To save the tedious typing, qw(the quick brown fox)
 Is short hand for : (“the”, “quick”, “brown”, “fox”).
 qw- quote words operator, is an obvious extension of the q and qq operator.
 qw/the quick brown fox/ (or) qw|the quick brown fox|
 The list containing variables can appear as the target of an assignment and/or
as the value to be assigned.
($a , $b , $c)= (1,2,3);

5. MANIPULATING LISTS
 Perl provides several built-in functions for list manipulation. Three useful ones are a)shift
LIST b)unshift LIST c)push LIST
 a) returns the first item of the list and moves remaining items down reducing the size of the
list by 1.
 b) the opposite of shift: puts the items in LIST at the beginning of ARRAY, moving the
original contents up by the required amount.
 c) push LIST: It is similar to unshift but adds the values in LIST to the end of ARRAY
 ITERATING OVER LISTS
Perl provides a number of mechanisms to achieve this.
I. foreach
II. map
III. grep
 foreach loop: It performs a simple iteration over all the elements of a list.
foreach $item (list){
}
This blocks takes each value from the list and repeats execution.
foreach (@array){
.... #process $_

6.  map: perl provides an inbuilt function map to create plural forms of words.
 @p1=map $_. ‘s’ , @s;
 general form of map is: map expression, list;
 and map BLOCK list;
 we can also use foreach loop to achieve the same.
@s=qw/cat, dog, rabbit, hamster, rat/;
@p1=();
foreach (@s){
push @p1, $_. ‘s’
}
 grep : In unix grep is used to print all lines of the file which contains an instance of
pattern.
grep pattern file
The perl grep function takes a pattern and a list and returns new list containing all the
elements of the original list that match the pattern.
Eg: @things = (car, bus, cardigan, jumper, carrot);
grep /car/ @things
returns the list
(car,cardigan,carrot)

7. HASHES
 A hash is a set of key/value pairs. Hash variables are preceded by a percent (%) sign. To
refer to a single element of a hash, you will use the hash variable name preceded by a
"$" sign and followed by the "key" associated with the value in curly brackets.
 Here is a simple example of using the hash variables −
 #!/usr/bin/perl
 %data = ('John Paul', 45, 'Lisa', 30, 'Kumar', 40);
 print "$data{'John Paul'} = $data{'John Paul'}n";
 print "$data{'Lisa'} = $data{'Lisa'}n";
 print "$data{'Kumar'} = $data{'Kumar'}n";
 This will produce the following result −
 $data{'John Paul'} = 45
 $data{'Lisa'} = 30
 $data{'Kumar'} = 40
 CREATING HASHES
we can assign a list to an array, so it is not surprising that we can assign a list of key-value
pairs to a hash.
for example:
%foo= (key1, value1, key2, value2,.....);
alternative syntax is provided using the => operator to associate key-value pairs
%foo =(banana => ‘yellow’ , apple=>’green’ , ...)
Key Value(age)
John Paul 45
Lisa 30
Kumar 40

8. MANIPULATING HASHES
 Perl provides a number of built-in functions to facilitate manipulation of hashes. If we
have a hash called magic.
keys %magic
Returns a list of the keys of the elements in the hash.
values %magic
These functions provide way to iterate over the elements of hash using foreach:
foreach $key(keys %magic) {
do something with $magic($key)
}
Explicit loop variable is omitted, in which case the anonymous variable $_ will be assumed.
foreach(keys %magic)
{
process $magic($_);
}
An alternative is to use “each” operator which delivers successive key-value pairs from a hash.
while(($key,$value)=each %magic){
...
}

9.  Other useful operators for manipulating hashes are delete and exists.
 delete $magic($key)
 Removes the elements whose key matches $key from the hash %magic, and
 exists $magic($key)
 Returns true if the hash %magic contains an element whose key matches
$key.common idiomis
exists($h{‘key’})&&do(statements)
To avoid using an if statement.