1. Perl for People Singer XJ Wang Learning Center Available At: http://www.cs.dal.ca/~swang/4173/pfp.ppthttp://www.cs.dal.ca/~swang/4173/pfp.ppt

2. 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;

3. 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”;

4. 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

5. 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;

6. List Variables (con’t) Sorting: Alphabetically  @sorted = sort @unsorted; Numerical  @sorted = sort {$a $b} @unsorted; Reversing: @ reversed = reverse @normal; Accessing Element: @list; $scalarVariable = $list[4]; $scalarVariable = $list[$index]; Setting Element: @list $list[5] = ‘cat’; $list[$index] = $nameOfPerson; $list[8] = 5; Getting Number of Elements in a List: $numElements = scalar @list;

7. 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

8. 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”;

9. 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

10. 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

11. 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  WrongRight if ($a == 5 ) print “hello world”; else print “world hello”; if ($a == 5 ){ print “hello world”; } else{ print “world hello”; }

12. 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 ){

13. Input and Output Reading from STDIN is variable for standard in Reads one line and assign it to variable $a chomp removes the new line at the end $a = ; 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”;

14. 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 ;

15. 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 is a file handle, can be any other name Separate from $, %, @ variables File I/O Read from file: $line = ; Write to file: print FILE “hello wrold”; Sample Program: open(FILE, "file.txt"); open(FILE2, ">out.txt"); my $line; while( $line = ){ print FILE2 $line; } close(FILE); close(FILE2);

16. 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”;

17. 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

18. 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”, “b”, “c”); my @list2 = (“c”, “d”, “e”); my $v1 = “alpha”; my $v2 = “beta”; sample1($v1, $v2, @list1, @list2); # 1 sample1($v1, $v2, @list1); # 2 sample2($v1, $v2, @list1, @list2); # 3 sample2($v1, $v2, @list1); # 4 the first list that is part of the argument list in the subroutine takes all remaining arguments; the second list is empty

19. References References are like pointers in C/C++ the operator \ gives you reference to a variable, the reference itsself is a scalar $scalarRef = \$scalar; $listRef = \@list; $hashRef = \%hash; Accessing the Variable being References 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

20. 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

21. 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 = ; chomp($nA); print "Enter Your Age: "; my $nB = ; chomp($nB); my ($returnA, $returnB) = printHello($nA, $nB); print "$returnA is first and $returnB is second\n";

22. 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

23. 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

24. 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

25. CGI (con’t) 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”);

26. 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

27. 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

28. 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 \

29. 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;

30. 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

31. 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

32. CGI/DBI Example – Input Script Filename: input.cgi (input.cgi.txt) CSCI 4173 Input Name:

33. Other Resources Perl Documentation : perldoc For modules  perldoc [moduleName] perldoc DBI perldoc CGI For functions  perldoc -f [functionName] 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