Perl

References
Conditional Statements
Subroutines

References

Arrays and hashes can only contain scalars
Problem: How can we construct nested data structures?
- array of an array (e.g. a matrix)
- hash of a hash (e.g. a table with rows and columns)
Solution: Create references to variables (or values) that point to the variables (or values)
References themselves are scalars, and can therefore appear in an array or hash

References (Syntax)

Prefix the variable with "\" to create a reference to it
```
@fruits = qw(apple orange pear);$refFruits = \@fruits
```
This can be visualized as a pointer to the variable
Later, the reference can be used to access the variable by prefixing it with the symbol for its type
- "$" for scalar references
- "@" for array references
- "%" for hash references
- "&" for subroutine references
- "*" for file references
```
$fruit = @$refFruits[1];
```

Nested Data Structures

For example we want to create a directory of user profiles
- The directory should be realized as a hash, using the user name as its key
- Each user profile is itself represented by a hash

In the following example, we create the user profiles, then add references to them to the directory

%profile1 = (name => "Alice",   email => "alice\@home.com");%profile2 = (name => "Bob",   email => "bob\@home.com");$directory{"Alice"} = \%profile1;$directory{"Bob"} = \%profile2;

Accessing Elements

Later, we can access profiles like this:

$refProfile = $directory{"Alice"};%profile = %$refProfile;$email = $profile{"email"};

This can be expressed more succinctly using a block:
```
$email = ${ $directory{"Alice"} }{"email"};
```
The expression between { and } can be any Perl expression that returns a reference (e.g. a subrouting call)

Accessing Elements (Syntactic Sugar)

Since the previous methods can become cumbersome, a simpler syntax is available
```
$email = $directory{"Alice"}->{"email"};
```

Syntax for using the "->" operator:

$refArray->[0] = "Bob";          # Array element$refHash->{"key"} = "value";     # Hash element$refCode->(1, 2, 3);             # Subroutine call

Anonymous Arrays and Hashes

In the previous example, it was inconvenient to create intermediary variables that weren't used later on
It is possible to create references to arrays or hashes without assigning them to a variable first

Syntax of an anonymous array:

$refArray = [ element-1, element-2, ... ];

Syntax of an anonymous hash:

$refHash = {   key-1 => "value-1",   key-2 => "value-2",   ... };

Anonymous Arrays and Hashes (Example)

Example of an anymous array
```
$refArray = [ 1, 2, 3 ];
```

Example of an anymous hash

$refHash = {  "Adam" => "Eve",  "Clyde" => "Bonnie",};

Nested Data Structures (Again)

Using anonymous hashes we can now define the directory of user profiles quite succinctly:

$directory = (  "Alice" => {     name => "Alice",    email => "alice\@home.com"   },  "Bob" => {     name => "Bob",    email => "bob\@home.com"   },);

Nested Data Structures (Example)

Suppose you were asked to create a matrix
Solution
- Use one array to store the rows of the matrix
- For each row create an anonymous array
```
$matrix = (  [1, 2, 3],  [0, 4, 5],  [0, 0, 6],);
```

Access matrix elements using the "->" operator:

$matrix[0]->[0] == 1$matrix[1]->[1] == 4$matrix[2]->[2] == 6

Conditional Statments

Perl has the usual set of conditional statements
- if, while, etc.
Each conditional statement has three pieces:
- Type of conditional
- Condition
- Block of executable statements

Conditions

A few things worth pointing out about conditions in Perl
There are no booleans
- 0, the empty string, or an undefined variable are interpreted as false
- Everything else (e.g. a number != 0, a non-empty string) is interpreted as true
Thus the following is a valid condition
```
$number
```
It is true if the variable $number has been assigned a value, and false otherwise

Conditions with Comparisons

Conditions include comparisions
To compare numbers, use the following comparison operators
```
==   !=   <    >    <=   >=
```
To compare strings, a separate set of comparison operators must be used
```
eq   ne   lt   gt   le   ge
```

Complex Conditions

Conditions can be created from multiple simple conditions using the following logical operators
```
&&         AND||         OR!          NOT
```
Parentheses should be used to make complex conditions easy to read
```
(($name eq "Lucy") && ($age >= 18))
```

Conditional Branches

if (condition) {
statements
}
statement if (condition);
if (condition) {
  statements
} elsif (condition) {
  statements
} else {
  statements
}
unless (condition) {
statements
}

Conditional Loops

while (condition) {
statements
}
until (condition) {
statements
}
do {
statements
} while (condition)
do {
statements
} until (condition)

Fixed Loops

foreach $i (@array) {
statements
}

Example:

@fruits = qw(apple orange pear);%prices = (  apple => 0.99,  orange => 1.29,  pear => 0.69);foreach $fruit (@fruits) {  print "<p>Price for $fruit is $$ $prices{$fruit}";}

for (initialize loop index; condition; update loop index) {
statements
}

Example:

@fruits = qw(apple orange pear);for ($i=0; $i<@fruits; $i++) {  print "<p>Fruit for sale: $fruits[$i]\n";}

Subroutines

A block of statements can be assigned a name, and called later, as well as passed a list of arguments

sub name {
statements
}

sub header {  my $title = shift @_;  print << END_OF_HEADER;Content-Type: text/html<html><head>  <title>$title</title></head><body>END_OF_HEADER;}

Subroutine Arguments

Subroutines store their arguments in an array @_
The first statement of a subroutine body typically assigns the argument array to a list of variables
```
 my ($x, $y, ...) = @_;
```
If there are only few, or a variable number of arguments, we often use the shift operator to read the arguments
```
 my $title = shift @_;
```
Local variables should be declared using my (otherwise they will be made global)

Calling a Subroutine

There are several ways to call a subroutine
- name(args);
- name args;
- &name(args);
- &name;
name(args);
& is optional with parentheses since Perl 5.0
name args;
Parenthesis are optional subroutine predeclared (declared before it is used), or imported
&name(args);
Before Perl 5.0, & was required (& is still required when naming a subroutine, e.g. when creating a reference)
&name;
Passes current arguments (@_) to subroutine

Return Value

A subroutine returns the value of the last expression, if not specified otherwise
```
sub square {  my $x = shift @_;  $x * $x; }
```

Use return to explicitly return a value

sub grade {  my $marks = shift @_;  if ($marks >= 90) {    return "A+";  } elsif ($marks >= 85) {    return "A";  } elsif ($marks >= 80) {    return "A-";  } elsif ...    # other cases  }}

Here is how the functions could be called:

$result = square($value);print "Square of $value is $result\n";$grade = &grade(95);print "Final grade: $grade\n";

Subroutines and Libraries

Subroutines can be described in a separate library file, and imported into many scripts (reuse!)
Library files often carry the extension ".lib"
File should end with a line that indicates the library was successfully loaded
```
1;
```
Alternatively subroutines can be declared in a Perl Module (see CGI.pm)

Subroutines and Libraries (Example)

Suppose we wanted to define commonly used code to create the header and footer of a web page in a library

header_footer.lib

sub Header {	my $title = shift(@_);	print "Content-Type: text/html\n\n";	print "<html><head><title>";	print "$title";	print "</title></head><body>\n";}sub Footer {	print "\n</body></html>";}1;  # OK

Importing a Library

A require statement tells the interpreter to incorporate the file specified into the current execution context
```
require "header_footer.lib";
```
All global variables and subroutines in the library become visible in the execution context

No special syntax is required to call imported subroutines

Header();print << END_OF_BODY;<h1 align="center">Order confirmation</h1>Thank you for your order.Your confirmation number is $orderId.END_OF_BODYFooter();

Readings

For the next class read Chapter 14 in Perl and CGI
Also give Chapter 11 another good review