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_BODY
  Footer();

Readings

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