1 / 33

Perl for People

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

gemma-lyons
Download Presentation

Perl for People

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript


  1. Perl for People Singer XJ Wang Learning Center Available At: http://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 switchor casestatement • 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 

  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 • <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”;

  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 = <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);

  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 = <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";

  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 • First you will need to create a cgi-bin bin directory in your public_html directory: mkdir ~/public_html/cgi-bin • 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 • 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 • 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) <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”);

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

  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

More Related