Perl Scripting

Course Contents
1. 2. 3. 4. 5. 6. 7.

Introduction to Perl Working with scalars (numbers & strings) Operators and functions Conditions & loops Working with lists (arrays & hashes) Sub-routines Regular expressions

Contd..
8. 9. 10. 11. 12. 13.

references and complex data structures debugging in Perl Packages & Modules managing files and directories working with files and I/O handling databases in Perl

1. Introduction to Perl
Perl stands for Practical Extraction and Report Language. y Perl is a mixture of UNIX tools (sed, grep, awk etc.), Shell Scripting, C and Object Oriented features. y Perl was created by Larry Wall. It is now not owned by any single Organization. Perl is defined and maintained by a group of volunteer programmers including Larry Wall.
y

Features of Perl
1. 2. 3. 4. 5.

Perl is free Perl is both a compiled and interpreted language Perl is portable Perl can interface with other languages Perl is easy to use and debug

How to get Perl

Perl can be downloaded from the Internet thru www.perl.org (or) www.perl.com The current version of Perl is 5.10.0. Perl is available on different platforms, Unix,Windows, MacOS etc.

Writing the first program $ vi first.pl # program to print a message print Hello, World\n ; To run the program, $ perl first.pl

About the Program

 Any  To

line that starts with a #, is a comment

display messages, print command is used perl statement must end with a ;

 Every

Command Line Options To know the current version of Perl $ perl v To check the syntax errors only but does not run the script $ perl c first.pl To turn on the warnings $ perl w first.pl

Perl Online Help The online help is available in pod (plain old documentation) format and can be invoked using perldoc command. $ perldoc perlfunc $ perldoc f <command> ($ perldoc f print) $ perldoc perldoc

Data Types Perl has two types of data: 1. scalars: data consisting of a single thing ex: Numbers, Strings, References 2. lists: data consisting of a collection of single things or scalars ex: Arrays, Hashes

2. Scalars
A)

Numbers: 4 45e-4 3.2 0xbeef .234567 012 5. 1_234_456 10E2 Perl does not differentiate between integers and floats, signed or unsigned, or short and long numbers. Perl converts between the number types as needed in our scripts

Scalars

B) Strings : A string is zero or more characters

surrounded by single quotes ( ) or by double quotes ( ) Escape sequences are used for string formatting in print function. new line tab backspace

\n \t \b

Scalars \a bell sound \0nn octal \0xnn hexadecimal \l make next letter lower case \u make next letter upper case \L make all the following letters lower \U make all the following letters upper

Scalars

Converting between numbers and strings: Since, numbers and strings are scalar data, they are interchangeable. ex: 5 + 14 foo + 5 23abc + 7 gives 19 gives 5 gives 30

Scalar Variables
$a=5; $a=$b=5; $a=$b=5, $c=7; $s=abc; $t=xyz; Rules for variable names: 1.should start with a letter, underscore 2.case sensitive 3.can be up to 255 characters. We dont have to declare or initialize variables in the beginning.

Input

Reading scalar values from Keyboard: $a=<STDIN>; chomp ($a); When we enter values from the keyboard, \n is automatically attached to the input value. To remove \n from the input, we use chomp function.

Output

Displaying the values on the screen: print ($a\n); printf (%.2f\n,$b); $c=sprintf(%.2f, $b);

3. Operators & Functions

Arithmetic operators: + (addition), (subtraction), * (multiplication), / (division), % (remainder), ** (exponent)

Operators

Relational Operators: Numeric Operators: ==, !=, <, >, <=, >= String Operators: eq, ne, lt, gt, le, ge Logical Operators: and (&&), or (||), not (!)

Operators

Assignment Operators: +=, -=,*=, /=, %=, **= Increment and Decrement Operators: ++, -Conditional Operator: exp1?exp2:exp3

Operators

Bitwise Operators: <<, >> String catenation operator: . String repetition operator: x

Operators

Quoting the strings: Single quotes: q/how are you/ Double quotes: qq/how are you/ General quotes: qw (abc);

Number Functions
abs () int () sin () cos () rand () exp () atan2 () ord () sqrt () absolute value converts to integer sine value cosine value random number e to the power of arctangent ascii number square root

String Functions
chr () index () length () reverse () rindex () substr () lc () conversion uc () conversion lcfirst () uc first() ascii character returns the pos. of chr. length reverses a scalar reverse index substring lowercase upper case first character lower first character upper

4. Conditions and Loops

if if (condition) if else {statements} { statements}

(condition) {statements}

Conditions and Loops

if (condition) { statements } elsif (condition) { statements }

Conditions and Loops

unless unless (condition) { statements }

Conditions and Loops

while while (condition) { statements }

Conditions and Loops

until until (condition) { statements }

Conditions and Loops

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

Conditions and Loops

for
for (init; test; change) { statements }

Conditions and Loops

foreach foreach value (list) { statements }

Conditions and Loops

Infinite loops
while () { statements } for (;;) { statements }

Conditions and Loops

break from a control statement last continue next

Conditions and Loops

$_ variable
It is the default placeholder for scalar values example foreach (`dir`) { print ($_\n); }

Conditions and Loops

switch use Switch; switch ($value) { case 1 {print 1; } . else {print 0 ;} }

5. Arrays and Hashes

Creating Arrays: @nums = (1,2,3,4); @nums = (1..4); @strings = (ab , cd , ef); @strings = (a ,z); @strings = (); @combine=(@nums, @strings);

Arrays and Hashes

Printing the Array: print (@nums\n); print (@strings\n); print (@combine\n); Processing each element: foreach $x (@nums) { print ($x\n); }

Arrays and Hashes

Accessing Array elements: $nums[3]; The subscript starts from 0 to n-1 Negative Array Indexes: $nums[-1]; Negative array subscripts will count back from the end of the array.

Arrays and Hashes

Growing Arrays: @nums=(1..4); $nums[6]=7; Result is 1,2,3,4,undefined, undefined,7 Finding the end of the Array: $end=$#nums; Finding the length of the Array: $len=@nums;

Arrays and Hashes

Sorting the Array: cmp (strings), < = > (numbers) @sorted=sort {$a cmp $b} @strings; @sorted=sort {$a < = > $b} @nums; Reversing the Array: @new=reverse (@old);

Arrays and Hashes

push and pop functions allow you to add or remove elements from the end of the list $new=push (@nums,5); $new1=pop (@nums);

Arrays and Hashes

shift and unshift remove the elements from the beginning of the Array $new=shift (@nums); $new1=unshift (@nums, 10); splice removes the elements from the Array @new=splice (@nums,5,3);

Arrays and Hashes

slice creates pieces of the Array @array=(1..10); @slice=@array[0,1,2]; splitting the data into an Array

$strings=12 23 43; @nums=split( ,$strings);

joining the data from an Array $strings=join(+, @nums);

Arrays and Hashes

Creating a Hash: %hash=(key=>value, key=>value, key=>value); Ex: %pairs=(red=>255, blue=>355, green=>455); Accessing Hash Elements: $hash {$key}; Ex: $pairs {red}; Printing the Hash: print %hash; Ex: print %pairs;

Arrays and Hashes

Processing a Hash: foreach $key (sort keys %hash) { print $hash {$key}\n; } while (($key, $value) = each (%hash) { print $hash {$key} \n; }

Arrays and Hashes

Ex: foreach $key (sort keys %pairs) { print $pairs {$key}\n; } or while (($key, $value) = each (%pairs)) { print $pairs {$key} \n; }

Arrays and Hashes

Adding an element to a Hash: $hash {$key} = $value; Ex: $pairs {yellow}=555; Deleting an element from a Hash: delete ($hash {$key}); Ex: delete ($pairs {red});

Arrays and Hashes

Inverting a Hash: %new=reverse %hash; Ex: %newpairs = reverse %pairs; Finding the no. of keys in a Hash: $n=keys %hash; Ex: $n=keys %pairs;

6. Subroutines

The terms function and subroutine are entirely equivalent in Perl. Perl handles three types of functions. 1. Built-in: These are the functions that are defined by the standard Perl library that we can use any where in our Perl scripts.

Subroutines

2. Additional: These are the functions that are

available to us by using the additional Perl modules or libraries, written by other Perl programmers, that we can load in at the start of the script. 3. Subroutines: These are user defined functions. By convention, the term subroutine is used to identify the function as user defined one.

Subroutines

Defining & Calling basic subroutines:

print enter temperature in forenheight \n; chomp ($f=<STDIN>); &cal(); print The result is $cel\n; sub cal () { $cel=($f-32)*5/9; }

Subroutines

Returning values from a subroutine:

$sum=&cal(); print The sum is $sum\n; sub cal () { print enter two nos. \n; chomp ($n1=<STDIN>); chomp ($n2=<STDIN>); return ($n1 + $n2); }

Subroutines

Using local variables inside a subroutine: We can create local variables inside a subroutine using my modifier. $sum=&cal(); print The sum is $sum\n; sub cal () { my ($n1,$n2); print enter two nos. \n; chomp ($n1=<STDIN>); chomp ($n2=<STDIN>); return ($n1 + $n2);

Subroutines

Passing Arguments to a subroutine:

$sum=&cal(3,5); print The sum is $sum\n; sub cal () { my ($m, $n)= @_; my $p=1; while ($n>0) { $p=$p*$m; $n--; } return ($p); }

Subroutines

Anonymous subroutines: These are subroutines without names and they operate sort of like pointers to functions in C.

7. REGULAR EXPRESSIONS

REGULAR EXPRESSION OPERATORS: m//, s///, tr/// @x = grep /x/, @words; PATTERN MATCHING OPERATORS: =~, !~ REs: abc exact character sequence

REGULAR EXPRESSIONS

^abc abc$ a|b ab {2,4}c ab{2,}c

abc at the beginning abc at the ending a or b a followed by 2,3,4 bs followed by c a followed by at least 2 bs followed by c

REGULAR EXPRESSIONS
ab*c ab+c ab?c a.c a followed by zero or more bs followed by c a followed by one or more bs followed by c a followed by optional b followed by c (abc or ac) an a followed by any single character (no newline) followed by c

REGULAR EXPRESSIONS

a\.c [abc] [Aa]bc [^abc]

a.c exactly any one of a , b or c Abc or abc not containing a or b or c

8. References

A reference is similar to a pointer in C. The reference itself is a scalar, it can be assigned to a scalar variable, printed, added to, passed to subroutine etc. To find out what the reference points to, we can dereference the reference. Creating a reference for a scalar: $str=This is a string; $strref=\$str;

References

Dereferencing a scalar reference: $originalstr=$$strref; Creating a reference for an Array: @array=(1..10); $arrayref=\@array; Dereferencing an array reference: @originalarray=@$arrayref; To refer to individual elements: $originalarray[0] or $$arrayref[0];

References

Creating a reference for a hash: %hash=(a=>255,b=>355,c=>455); $hashref=\%hash; Dereferencing a hash reference: %originalhash=%$hashref; To refer to individual keys: $originalhash{a} or $$hashref{a};

References

Creating a reference for a subroutine: $subref=\&mysub; Dereferencing a subroutine: $result=&$subref(3,5); Creating anonymous subroutines: $subref=sub {.}; Dereferencing a subroutine: $result=&$subref();

References
Anonymous data: The term anonymous means without a name. Anonymous data refers to data (usually arrays, hashes and subroutines) that we can only access through a reference i.e. the data does not have an associated variable name. Using anonymous data, we can create nested data structures such as, 1.Arrays of Arrays 2. Hashes of Arrays 3. Hashes of Hashes

References

Arrays of Arrays: @array= ( [0,1,2], [23,33,43], [53,54,55] ); Referring to individual elements: $array[0][1] or $array[0]->[1]

References

Hashes of Arrays: %hash= ( b=>[0,1,2], g=> [23,33,43], r=>[53,54,55] ); Referring to individual elements: $hash{b}[1] or $array{b}->[1]

References

Hashes of Hashes: %hash=(a=>{x=>0,y=>1,z=>2}, b=>{l=>3,m=>4,n=>5}, c=>{p=>53,q=>54,r=>55} ); Referring to individual elements: $hash{a}{x} or $array{a}->{x}

9. Debugging in Perl

Perl comes with a source level debugger. The debugger can help us track down subtle problems in our code. We shall see, 1. how to start and run the debugger 2. step through the execution of the script 3. trace the execution of the script 4. list the source in various ways

Debugging in Perl 5. print out the values of the variables 6. set the breakpoints To invoke the debugger, $ perl d temp.pl After the display of some messages, we see main::(temp.pl:1): system (cls); DB<1>

Debugging in Perl

DB <1>

debugger prompt with command number main package name temp.pl script name 1 line no. of the script system (cls) line in the script to be run

Debugging in Perl

Debugger Commands: n runs a line of the script, silently executes subroutines s runs a line of the script, steps into subroutines l list 10 lines after the current line list the lines before the current line x prints the value of any scalar, list

Debugging in Perl
Debugger Commands: X print out all the variables in the current package V same as X except it takes an optional name of a package r stops stepping thru the subroutine, executes rest of it, returns to the calling place. c runs the script without stepping thru

Debugging in Perl

Debugger Commands: b to set a break point S prints all the available subroutines t turns tracing on or off h help |h pause help with breaks !3 refers to the command no. 3 H -3 lists last 3 commands

Debugging in Perl

Debugger Commands: T show the stack trace w shows a window around the current line L lists all break points d deletes a break point D deletes all set break points

10.PACKAGES & MODULES What is a Package? A package is a namespace It is a space that provides its own global scope for identifiers. It functions as a private programming space. How to create Packages? We can place the code for a Package in its own file, or in multiple files, or even create several packages in the same file. To switch into another package, we use the package statement.

PACKAGES & MODULES

$ vi packages.pl package package1; BEGIN {} $x=1; sub subroutine1 { print one\n ;} return 1; END {}

PACKAGES & MODULES

$ vi prg1.pl require packages.pl; package1::subroutine1(); print $package1::x; To run, $ perl prg1.pl To know in which package we are, print __PACKAGE__;

PACKAGES & MODULES

Splitting a Package across files: $ vi file1.pl package package1; BEGIN {} sub sub1 { print hello\n; } return 1; END {}

PACKAGES & MODULES

$ vi file2.pl package package1; BEGIN {} sub sub2 { print bye\n; } return 1; END {}

PACKAGES & MODULES

$ vi original.pl require file1.pl; require file2.pl; package1::sub1(); package1::sub2(); The result is, hello bye

PACKAGES & MODULES

Multiple Packages in a single file:

$ vi packages.pl package package1; BEGIN{} sub sub1 { print hello\n; } return 1 END {} package package2; BEGIN{} sub sub2 { print bye\n; } return 1; END {}

PACKAGES & MODULES Our Declaration: Our declaration sets global scope across packages, i.e. variable of one package can be accessed in another package.

$ vi packages.pl
package package1; our $data=1; sub sub1 { print hello\n; } return 1 END {}

PACKAGES & MODULES

package package2; sub sub2 { print $data\n; } return 1; END {} To run this, package1::sub1(); package2::sub2();

PACKAGES & MODULES Creating Modules: A Perl Module is just a package in which the package is defined in a file with the same name as the package and has the extension pm. This allows subroutine names automatically exported to the code when we include a Module.

PACKAGES & MODULES

$ vi Module1.pm package Module1; BEGIN { use Exporter(); @ISA=qw (Exporter); @EXPORT=qw (&subroutine1 &subroutine2); } sub subroutine1 { print hello\n ;} sub subroutine2 { print thanks\n; } return 1; END {}

PACKAGES & MODULES

$ vi final.pl use Module1; subroutine1(); subroutine2(); $ perl final.pl; CPAN:There are literally hundreds of modules that have been developed for use with Perl.

PACKAGES & MODULES Many are available with the Perl Distribution itself. CPAN (Comprehensive Perl Archive Network) serves as a repository for user developed modules. An up-to-date survey of the contents of CPAN can be found at www.perl.com However, there are two drawbacks to the CPAN modules. The first is that we have to download, build and install modules before they can be used. Some modules may require

PACKAGES & MODULES compilation which means that we need a working C compiler. Secondly, most of the CPAN modules are developed for UNIX Perl. For installing Windows specific modules, there is a special tool called ppm. C:\> ppm PRAGMAS:These are the modules that

PACKAGES & MODULES provide instructions for Perl to behave at both compile time and run time. ex: subs: allows you to pre-declare subroutine names. vars: allows you to pre-declare global variables so that they can be accepted under strict pragma.

PACKAGES & MODULES

strict: disallows bare words, global variables and symbolic references. integer: allows only integer arithmetic. constant: allows to create constant variables at compile time.

PACKAGES & MODULES

Global variable: Any variable that is not explicitly declared with my or local, automatically becomes a global variable and is available at any point in that script. Any variable declared in a block with my or local becomes a local variable to that block. Difference between my and local:

PACKAGES & MODULES A my variable is only available to the code up until the nearest enclosing block or subroutine definition. If we call another subroutine within that one, the second subroutine will not have access to those variables. Local variables declared with local are available to the code inside that block and subroutine and to the nested subroutines called from the same subroutine.

MANAGING FILES & DIRECTORIES Renaming files: rename myfile myfile.bak; Creating and following links: link file1, file2; (for hard links) symlink file1, file2; ( for soft links) # follow the link (symbolic links) if ( -l $file) { $realfile = readlink $file; }

MANAGING FILES & DIRECTORIES

Removing files & links: unlink temp, config, foo; Other file commands: chmod changing the file permissions chown changing the owner of the file fileno returns the file descriptor utime changes the time stamp

MANAGING FILES & DIRECTORIES

Directory Commands: chdir: chdir images; use Cwd; $curr=cwd(); print $curr\n; File Listing (File Globbing): @files=<*.pl>; while (<*.pl>) { print $_ ,\n; }

MANAGING FILES & DIRECTORIES

Directory Commands: mkdir: mkdir temp, 0777; rmdir: rmdir temp; Perl and the Environment: Perl environment variables are stored in a special hash called %ENV.

MANAGING FILES & DIRECTORIES

Environment Variables are commonly in upper case. To view all the Environment Variables, foreach $key (keys %ENV) { print $key -> $ENV {$key} \n; }

MANAGING FILES & DIRECTORIES

To run OS commands, system (ls); $ls=`ls`;

WORKING WITH FILES & I/O

Creating a file:
open (FH,>myfile) or die can not create\n;

Reading a file: while (<FH>) { . }

WORKING WITH FILES & I/O

Writing to a file: print FH $input\n; Closing a file: close FH; open options: > writing < reading +> read and write

WORKING WITH FILES & I/O

File Tests: -d -e -f -l -r -s -w

directory ? file exists ? plain file ? symbolic link ? readable ? ? Big is the file ? writable ?

WORKING WITH FILES & I/O

File Tests: -x executable ? -z empty file ? -B binary file ? -T text file ? Command line arguments: Command line arguments are stored in a special list @ARGV.

WORKING WITH FILES & I/O

foreach $arg (@ARGV) { print $arg \n; }

Use the DBI Module

#!/usr/local/bin/perl use DBI;

Establish connection and get a handle to it

#!/usr/local/bin/perl use DBI; $db_handle = DBI->connect(DBI:mysql:sanskar_club:sql.njit.edu, sanskar, pswd) || die (Couldnt connect\n);

Syntax of DBI->connect()
DBI->connect(data_source, username, password); data_source will be DBI:driver_name:driver_parameters For MYSQL at NJIT driver_name = mysql driver_parameters = database_username:sql.njit.edu username = ucid/club account name password = afs password

Prepare an SQL query

#!/usr/local/bin/perl use DBI; $db_handle = DBI->connect(DBI:mysql:sanskar_club:sql.njit.edu, sanskar, pswd) || die (Couldnt connect\n); $stmt_handle = $db_handle->prepare("SELECT name, email, numpeople, accomdetails FROM user_detail");

Execute the SQL query

#!/usr/local/bin/perl use DBI; $db_handle = DBI->connect(DBI:mysql:sanskar_club:sql.njit.edu, sanskar, pswd) || die (Couldnt connect\n); $stmt_handle = $db_handle->prepare("SELECT name, email, numpeople, accomdetails FROM user_detail");

$stmt_handle ->execute;

Finish with statement handle

#!/usr/local/bin/perl use DBI; $db_handle = DBI->connect(DBI:mysql:sanskar_club:sql.njit.edu, sanskar, pswd) || die (Couldnt connect\n); $stmt_handle = $db_handle->prepare("SELECT name, email, numpeople, accomdetails FROM user_detail"); $stmt_handle ->execute; while (@row = $stmt_handle->fetchrow()) { foreach $field (@row){ print "$field "; } print \n; } $stmt_handle->finish();

Close the connection

#!/usr/local/bin/perl use DBI; $db_handle = DBI>connect(DBI:mysql:sanskar_club:sql.njit.edu, sanskar, pswd) || die (Couldnt connect\n); $stmt_handle = $db_handle->prepare("SELECT name, email, numpeople, accomdetails FROM user_detail"); $stmt_handle ->execute;

Contd..
while (@row = $stmt_handle->fetchrow()) { foreach $field (@row){ print "$field "; } print \n; } $stmt_handle->finish(); $db_handle->disconnect();