Transcript pfp

Perl for People
Singer XJ Wang
Learning Center
Available At: http://www.cs.dal.ca/~swang/4173/pfp.ppt
Perl Variables


Perl is a type-less language (no explicit types like integers, strings,
doubles etc)
Main data categories (types) are
 Scalars



Lists
Hashes
Variables are automatically created when you first use them; however to
be safe you should declare them first;
 Declaring a variable makes them valid for the block of code they are in

Putting the following in the top of the Perl script enforces you to declare
variables  use strict;



my $scalarVariable;
my @listVariable;
my %hashVariable;
Scalar Variables






Either a number or a string of characters (doesn’t matter)
Scalar variables always begin with $
No limitation on size of a scalar variable
un-initialized values are set to undef which is either 0 or “”
(empty string) depending on context
0 and “” are both considered false in conditionals
All standard operators are provided like




Arithmetic Operations  +, -, /, *
String Length  length( $scalar )
Concatenation  $newScalar = $front . $back;
Substitution is allowed for scalars

In case below $b would contain the value “hello ted”
$a = “ted”; $b = “hello $a”;
Scalar Variables (con’t)

Scalar Contexts:
$a = 5; $b = “4A”;
$c = $a + $b; $d = $a . $b;




Numerical Context: $c  since addition is number operation, $b is
internally converted to a number and added to $a; the result is 9
String Context: $d  since . is an string operation; $a is internally
converted to a string and appended to $b; the result is “54A”
the value of $a and $b are not changed
Comparison Operators:

Numerical Context  <, <=, ==, !=, >=, >

if ( $a < $b ) …


numerical comparison is made
String Context  lt, le, eq, ne, ge, gt

if ( $a eq $b )…

alphabetical comparison is made
List Variables








Similar to Vectors or Linked Lists
 can also be used like a stack and queue
Elements are indexed like an array – starting at 0
Each element in the list must be a scalar
No fixed size – up to limits of system memory
List variables names always begin with @
Any position in list that hasn’t been explicitly defined has the
value undef
@ refers to the list as a whole, $ refers to elements
 @array = (“elementA”, “elementB”, “elementC”);
 $array[2] is the 3rd element with value “elementC”
 $array[5] = “ted”;  sets the 6th element in the list to “ted”
Copying is done through assignment (each element is copied)
 @copy = @original;
List Variables (con’t)

Sorting:



Reversing:



$scalarVariable = $list[4];
$scalarVariable = $list[$index];
Setting Element: @list




@ reversed = reverse @normal;
Accessing Element: @list;


Alphabetically  @sorted = sort @unsorted;
Numerical  @sorted = sort {$a <=> $b} @unsorted;
$list[5] = ‘cat’;
$list[$index] = $nameOfPerson;
$list[8] = 5;
Getting Number of Elements in a List:

$numElements = scalar @list;
List Variables (con’t)




Operation at Head of List (low index):
 Insertion  unshift @list, $scalar;
 Deletion --> $scalar = shift @list;
Operation at Tail of List (high index):
 Insertion  push @list, $scalar;
 Deletion  $scalar = pop @list;
Combining Lists and Scalars:
 @newList = (@listA, $scalar);
 @newList = ($scalar, @listA);
Combinining Multiple Lists
 @newList = (@listA, @listB);
 @newList = (@listB, @listA);

NOTE: does not form multi-dimensional lists, instead creates one list
with elements from both parts
Hash Variables






A hash table data structure; Like a STL Map in C++, HashMap or
HashSet in Java;
Key, Value pairs – both must be scalars
No internal order is maintained
Keys must be unique; no two element can have the same key
 Attempting to insert a second value for the same key, then the
first value gets overwritten
Hash variables names always begin with %
% refers to hash as a whole, $ refers to elements
 %hash;
 $hash{$key} = $value;
 $hash{5} = “egg”;
 $hash{“ted”} = “bacon”;
Hash Variables (con’t)



Copying is done through assignment (each element is copied)
 %copy = %original;
Lists of Keys/Value
 List of Keys  @keys = keys %hash;
 List of Values  @values = values %hash;
Insertion/Deletion/Access: %hash
 Insertion  $hash{$key} = “value”;
 Deletion  delete $hash{$key};
 Access  $scalarValue = $hash{$key}


If no value exists for the given key, the value undef is returned
Reversing
 %reverseHash = reverse %normalHash;


Swaps the keys and values
If it has two values that are the same, then the result is not deterministic
Hash Variables (con’t)

Hash from List


%hash = @list;
 Every even element becomes key for odd element (the
odd element after the even one)
 If two even elements (potential keys) are the same, then
the result is not deterministic
 If the list contains an odd number of elements, the last
element (a potential key) is ignored
Hash from List

@list = %hash;
 Every even element becomes key for odd element (the
odd element after the even one)
 Order of the elments are not gauarneteed
Control Structures

Control structures in Perl are very much like C, C++, Java
with the following exceptions:




No switch or case statement
else if is written as elsif
Additional unless control which works exactly the opposite of the
if control; not used that often
curly braces are always required 
Wrong
if ($a == 5 )
print “hello world”;
else
print “world hello”;
Right
if ($a == 5 ){
print “hello world”;
}
else{
print “world hello”;
}
Control Structures (con’t)

foreach control structure:

Goes through list and set the scalar to successive values in the
list in order (low index to high) 
my $scal;
foreach $scal ( @list ){
print “element -> $scal \n”;
}

To print all keys and values in a hash 
my $scal;
foreach $scal ( keys %hash ){
print “$scal -> $hash{$scal}\n”;
}

To sort all the keys alphabetically use this line instead
foreach $scal ( sorted keys %hash ){
Input and Output

Reading from STDIN



<STDIN> is variable for standard in
Reads one line and assign it to variable $a
chomp removes the new line at the end
$a = <STDIN>;
chomp( $a );

Printing to STDOUT/STDERR


Use print to send a line to standard out
Variables are subisuted when necessary
print “Hello $world\n”;


printf() like C/C++ is also available, but slower then print
To print to STDERR: print STDERR “Hello $world\n”;
Input and Output (con’t)

Printing Large Documents




the end marker (EOF) must immediately follow the <<
the second end marker (EOF) must be at the
beginning of the line
the semi-colon ; must be on a new line
variables are substituted when appropriate
print <<EOF
blah blah $variable
blah blah blah text
EOF
;
Input and Output (con’t)

Opening/Closing Files




Reading  open(FILE, “file.txt”);
Writing  open(FILE, “>file.txt”);
Appending  open(FILE, “>>$file”);
Closing  close(FILE);



File I/O



FILE is a file handle, can be any other name
Separate from $, %, @ variables
Read from file: $line = <FILE>;
Write to file: print FILE “hello wrold”;
Sample Program:
open(FILE, "file.txt"); open(FILE2, ">out.txt");
my $line;
while( $line = <FILE> ){
print FILE2 $line;
}
close(FILE); close(FILE2);
Warn and Die

Warn and Die can be used to convey error
messages when statement fails to execute properly




warn  prints error message and continues execution
die  print error messages and halts execution
the predefined variable $! contains the error
message the system provides
Syntax:
open(FILE, “in.txt”) || die “not found: $!\n”;
open(FILE, “in2.txt”) || warn “not found $!\n”;
Subroutines





Subroutines are like functions/procedures in C/C++/Java
Subroutines are identified only by the name when called, the
arguments do not matter by default
Passing of parameters to subroutines are done by copying (like
C)
All parameters to a subroutine are put into a special list @_
 when parsing arguments in the subroutine the list or hash will
grab all remaining elements in the list @_, thus only one list or
hash can be passed in as arguments – the last argument
 except when using References (later)
Return value from a subroutine can be a scalar or an list/hash
Subroutines (con’t)
sub sample1{ # @l1 grabs all remaining arguments, @l2 empty
my ($var1, $var2, @l1, @l2) = @_;
…..
}
sub sample2{ # @rest grabs rest of arguments if any
my ($var1, $var2, @rest) = @_;
…..
}
my @list1 = (“a”,
my @list2 = (“c”,
my $v1 = “alpha”;
sample1($v1, $v2,
sample1($v1, $v2,
sample2($v1, $v2,
sample2($v1, $v2,
•
“b”, “c”);
“d”, “e”);
my $v2 = “beta”;
@list1, @list2);
@list1);
@list1, @list2);
@list1);
#
#
#
#
1
2
3
4
the first list that is part of the argument list in the subroutine takes all remaining
arguments; the second list is empty
References


References are like pointers in C/C++
the operator \ gives you reference to a variable, the reference
itsself is a scalar




Accessing the Variable being References




$scalarRef = \$scalar;
$listRef = \@list;
$hashRef = \%hash;
Scalar  $$scalarRef
List  $listRef->[$index]
Hash  $hashRef->{$key};
References provides


way to pass multiple lists/hashes into an subroutines
a way for subroutines to change a list/hash passed into it
References (con’t)
sub changeL{
my $listRef = $_[0];
$listRef->[0] = “ABA”;
}
my @list = (“BAB”);
my $listR = \@list;
print “$list[0]\n”;
changeL($listR);
print “$list[0]\n”;

Results when Run 
BAB
ABA
Sample Program
#!/usr/bin/perl -w
#
# this is a comment
use strict;
sub printHello{
my ($name, $number) =@_;
print "Hello $name, welcome to World!\n";
return ($number*2, $number+4);
}
print "Enter Your Name: ";
my $nA = <STDIN>;
chomp($nA);
print "Enter Your Age: ";
my $nB = <STDIN>;
chomp($nB);
my ($returnA, $returnB) = printHello($nA, $nB);
print "$returnA is first and $returnB is second\n";
CGI - Scripts Made Easier


Perl Modules for CGI and Web Pages
Helps with the following






Setting context types
Accessing and parsing values submitted by forms
Setting and retrieving cookies
generate forms and HTML Pages
setting and retrieving session data
Two ways of accessing it


Traditional functions
Object Oriented style
CGI (con’t)

Running Perl-CGI on Borg/Torch/Locutus:
 ensure that your web page is accessible and has correct permissions
 http://help.cs.dal.ca/faq/tutorials/web_sites/basic_site.php
 Setup the scripts as following:
 http://help.cs.dal.ca/faq/tutorials/web_sites/cgi_script.php
1. First you will need to create a cgi-bin bin directory in your public_html
directory: mkdir ~/public_html/cgi-bin
2. Next you must grant world read and execute permissions on your cgi-bin
directory: chmod a+rx ~/public_html/cgi-bin or chmod 755
~/public_html/cgi-bin
3. Next you must place your CGI scripts in the cgi-bin directory and grant
world execute permissions on each script: chomd a+x script.cgi or
chmod 711 script.cgi
4. Your scripts can now be referenced at
http://www.cs.dal.ca/~username/cgi-bin/script.cgi
CGI (con’t)

Must include the CGI module in the script
use CGI qw/:standard/;

Printing the context type for the browser
print header();


outputs something like  Content-Type: text/html;
To call a Perl-CGI script from a form



set the script as the action of the form
 GET or POST does not matter
ensure that each form element has a unique name
for check boxes, choice boxes, selects give each option an
unique value
CGI (con’t)
<form method=“GET” action=“sample.cgi”>
<input type="text" name="name" size="12">
<input value="Submit Form!">
<input type="reset" value="Clear Form!">

to get the value in the form element, simply call the
param function with the element name as argument


the return type depends on the form element, ones that
allow multiple choices return a list
Notes
 calls for check boxes return “checked” or undef
 radio buttons return the value of the one chosen
$value = param(“name”);
@values = param(“other”);
DBI - Database Interface

Database Independent Driver for Perl
 Can talk to any major database like








MySQL
Oracle
DB2
Microsoft SQL Server
PostgreSQL
You can create your tables through DBI but for convince you
typically want to do it through SQL*Plus (Oracle)
Include the module DBI in the script  use DBI;
Major Objects:
 $dbh  database handle
 $sth  statement handle
DBI (con’t)

Connecting to DB (Oracle) and Disconnecting
$ENV{'ORACLE_HOME'}="/opt/oracle/9.0.1";
my $db = "TRCH";
my $user = "username";
my $pass = "password";
my $dbh = DBI->connect("dbi:Oracle:$db",$user,
$pass)|| die "ERROR: $DBI::errstr ";
... ... ... ... ...
... ... ... ... ...
$dbh->disconnect;

Executing SQL Statements


Select Statements
Non-Select Statements
DBI – Non-Select Statement
$sth = $dbh->prepare(“insert into person
values(?)”);
$rv = $sth->execute( $baz );
$sth->finish;

The return value of the call: $rv



$rv is number of rows changed
need to call finish on the statement handle when it is
no longer needed
execute fills in the question marks (?) in the prepare
statement with the arguments;

automatically escapes any character that may be needed
such as “ or \
DBI – Select Statements


$sth = $dbh->prepare("SELECT foo, bar FROM table
WHEREbaz=?");
$sth->execute( $baz );
my @row;
while ( @row = $sth->fetchrow_array ) {
print "foo is $row[0] and bar is $row[1]\n";
}
$sth->finish;
the while loop fetches the results from the select into a list one row
at a time
Can also get number of rows returned by select statement via
$sth->rows;
CGI/DBI Example
Simple Forms

user submits name and it is put into a database




HTML Page with Form for user to input name
Perl-CGI Script to process the form and insert the data
into the Oracle Database; also print out message
Uses both CGI and DBI
display all names in the database



Perl-CGI script to extract data from Oracle Database and
Display to User
uses both CGI and DBI
CGI/DBI Example – HTML File
User Form



input.html
http://torch.cs.dal.ca/~swang/4173/input.html
Process User Input



input.cgi
http://torch.cs.dal.ca/~swang/4173/input.txt
Display All Daqta



disp.cgi
http://torch.cs.dal.ca/~swang/4173/disp.txt
CGI/DBI Example – Input Script

Filename: input.cgi (input.cgi.txt)
<html><head>
<title>CSCI 4173</title>
</head><body>
Input Name:
<form method="GET" action="cgi-bin/input.cgi">
<input type="text" name="name" size="12">
<input type="submit" value="Submit Form!">
<input type="reset" value="Clear Form!">
</body>
Other Resources

Perl Documentation : perldoc

For modules  perldoc [moduleName]



For functions  perldoc -f [functionName]



perldoc DBI
perldoc CGI
perldoc -f printf
perldoc -f chomp
CS Online Perl Books :

http://www.library.dal.ca/subjects/csci_ebks.htm



Learning Perl
Perl and CGI for the World Wide Web
Advanced Perl Programming