Professional Documents
Culture Documents
By
Tanuj Maheshwari
Introduction
Perl stands for "Practical Extraction and
Report Language"
Created by Larry Wall when awk ran out of
steam
Perl grew at almost the same rate as the
Unix operating system
Introduction (cont.)
Perl fills the gaps between program
languages of different levels
A great tool for leverage
High portability and readily available
Availability
It's free and runs rather nicely on nearly
everything that calls itself UNIX or UNIX-
like
Perl has been ported to the Amiga, the
Atari ST, the Macintosh family, VMS,
OS/2, even MS/DOS and Windows
The sources for Perl (and many
precompiled binaries for non-UNIX
architectures) are available from the
Comprehensive Perl Archive Network
(the CPAN). http://www.perl.com/CPAN
Running Perl on Unix
Setup path variable to point to the
directory where Perl is located
Check /usr/local/bin or /usr/bin for “perl”
Run a Perl script by typing “perl
<filename>”
Alternatively, change the file attribute to
executable and include “#!/usr/bin/perl” in
the first line of your perl script
The .pl extension is frequently associated
to Perl scripts
Running Perl on Win32
ActivePerl allows Perl scripts to be executed in
MS-DOS/Windows
Perl is being ported faithfully
The #! directive is no longer used because it
does not mean anything to MS-DOS/Windows
Perl scripts are executed by typing “perl
<filename>
Alternatively, double clicking on the file if the
extension .pl is being associated to the Perl
interpreter
An Example
#!/usr/bin/perl
print “Hello World!”;
The #! directive directs subsequent
lines in the file to the perl executable
All statements are terminated with ; as
in C/C++/Java
print by default outputs any strings to
the terminal console. (such as printf in C
or cout in C++)
Perl completely parses and compiles the
script before executing it
Variables
Three main types of variables,
Scalar
Array
Hash
Variables are all global in scope unless
defined to be private or local
Note: remember that hash and array are
used to hold scalar values
Examples
Assigning values to a scalar
$i = “hello world!”;
$j = 1 + 1;
($i,$j) = (2, 3)
Assigning values to an array
$array[0] = 1;
$array[1] = “hello world!”;
push(@array,1); #stores the value 1 in the
end of @array
$value = pop(@array); #retrieves and removes the
last element
#from @array
@array = (8,@array); #inserts 8 in front of @array
Examples (cont.)
Assigning values to a hash
$hash{‘greeting’} = “Hello world!”;
$hash{‘available’} = 1;
#or using a hash slice
@hash{“greeting”,”available”} =
(“Hello world!”, 1);
Deleting a key-value pair from a hash:
delete $hash{‘key’};
Conditional Statements
Variables alone will not support switches or
conditions
If-Then-Else like clauses are used to make
decisions based on certain preconditions
Keywords: if, else, elsif, unless
Enclosed by ‘{‘ and ‘}’
A Conditional Statement
Example
print "What is your name? ";
$name = <STDIN>;
chomp ($name);
if ($name eq "Randal") {
print "Hello, Randal! How good of you to be here!\n";
} else {
print "Hello, $name!\n"; # ordinary greeting
}
unless($name eq “Randal”)
{
print “You are not Randal!!\n”; #part of the ordinary
greeting
}
$name = <STDIN> reads from standard
input
chomp is a built-in function that removes
Loops
Conditional statements cannot handle
repetitive tasks
Keywords: while, foreach, for , until, do-while,
do-until
Foreach loop iterates over all of the elements
in an array or hash, executing the loop body
on each element
For is a shorthand of while loop
until is the reverse of while
Loops (cont.)
Do-while and do-until loops executes the
loop body once before checking for
termination
Statements in the loop body are enclosed
by ‘{‘ and ‘}’
While Loop
Syntax:
while(some expression){
statements;
…
}
Example:
#prints the numbers 1 – 10 in reverse order
$a = 10;
while ($a > 0) {
print $a;
$a = $a – 1;
}
Until Loop
Syntax:
until(some expression){
statements;
…
}
Example:
#prints the numbers 1 – 10 in reverse order
$a = 10;
until ($a <= 0) {
print $a;
$a = $a – 1;
}
Foreach Loop
Syntax:
foreach [<variable>] (@some-list){
statements…
}
Example:
#prints each elements of @a
@a = (1,2,3,4,5);
foreach $b (@a) {
print $b;
}
Foreach Loop (cont.)
Accessing a hash with keys function:
foreach $key (keys (%fred)) {
# once for each key of %fred
print "at $key we have $fred{$key}\n";
# show key and value
}
For Loop
Syntax:
For(initial_exp; test_exp; re-init_exp ) {
statements;
…
}
Example:
#prints numbers 1-10
for ($i = 1; $i <= 10; $i++) {
print "$i ";
}
Do-While and Do-Until Loops
Syntax:
do {statments; do{ statements;
} while some_expression; }until
some_expression;
“asdffdscedfssadfz”
Creating Patterns: Exercises
Construct patterns for the following
strings:
1. "a xxx c xxxxxxxx c xxx d“
2. a sequence of numbers
3. three or more digits followed by
the string “abc”
4. Strings that have an “a”, one or
more “b”s and at least
five “c”s
5. Strings with three vowels next to
each other. Hint: try
Creating Patterns: Exercises
Answers:
/a.*c.*d/
/\d+/ or /[0-9]+/
/\d\d\d.*abc/ or /\d{3,}abc/
/ab+c{5,}/
/[aeiouAEIOU]{3}/
Other possible answers?
Anchoring Patterns
No boundaries are defined by the previous
patterns
Word boundary: \w and \W
\b and \B is used to indicate word boundaries
and vice verse
Examples:
/fred\b/ #matches fred, but not frederick
/\b\+\b/ #matches “x+y”, but not “x + y”, “++”
and ”+”. Why?
/\bfred\B/ #matches “frederick” but not “fred
Anchoring Patterns (cont.)
^ and $
^ matches beginning of a string
$ matches end of a string
Exampls:
/^Fred$/ #matches only “Fred”
/aaa^bbb/ #matches nothing
More on matching operators
Additional flags for the matching operator:
/<pattern>/i #ignores case differences
/fred/i #matches FRED,fred,Fred,FreD and etc…
/<pattern>/s #treat string as single line
/<pattern>/m #treat string as multiple line
More on Matching Operators
(cont.)
“(“ and “)” can be used in patterns to
remember matches
Special variables $1, $2, $3 … can be used
to access these matches
For example:
$string = “Hello World!”;
if( $string =~/(\w*) (\w*))
{
#prints Hello World
print “$1 $2\n”;
}
More on Matching Operators
(cont.)
Alternatively:
$string = “Hello World!”;
($first,$second) = ($string =~/(\w*) (\w*));
print “$first $second\n”; #prints Hello World
$three = add(1,2);
Functions (cont.)
Variables are all global even if they are
defined within a function
my keyword defines a variable as being
private to the scope it is defined
For example:
sub add
{
my($left,$right) = @_;
return $left + $right;
}
Functions (cont.)
$three = add(1,2); #$three gets the value of
3
print “$one\n”; #prints 0
Print “$two\n”; #prints 0
Exercises
A trim() function that removes leading and
trailing spaces in a string
Hint: use the s/// operator in conjunction with
anchors
A date() function that converts date string,
“DD:MM:YY” to “13th of December, 2003”
Hint: use a hash table to create a lookup
table for the month strings.
File I/O
Filehandle
Automatic filehandles: STDIN, STDOUT and
STDERR
Syntax:
open(<handle name>,”(<|>|>>)filename”);
close(<handle name>);
Example:
open(INPUTFILE,”<inputs.txt”); #opens file
handle
…
Close(INPUTFILE); #closes file handle
File I/O (cont.)
Handle access does not always yield true
Check for return value of the open function
Example:
if(open(INPUT,”<inputs.txt”))
… #do something
else
print “File open failed\n”;
File I/O (cont.)
The previous method is the standard practice
Unlike other languages, Perl is for lazy people
Ifs can be simplified by the logical operator “||”
For example:
open(INPUT,”<inputs.txt”) ||die “File open
failed\n”;
Use $! variable to display additional operating
system errors
die “cannot append $!\n”;
File I/O (cont.)
Filehandles are similar to standard I/O handles
<> operator to read lines
For example:
open(INPUT,”<inputs.txt”);
while(<INPUT>){
chomp;
print “$_\n”;
}
Use print <handle_name> <strings> to output
to a file
File I/O (cont.)
File copy example:
open(IN,$a) || die "cannot open $a for
reading: $!"; open(OUT,">$b") || die "cannot
create $b: $!";
while (<IN>) { # read a line from
file $a into $_
print OUT $_; # print that line to file
$b
}
close(IN) || die "can't close $a: $!";
close(OUT) || die "can't close $b: $!";
File I/O (cont.)
File tests provides convenience for
programmers
-e –r –w –x –d –f –l –T –B
For example:
if(-f $name){
print “$name is a file\n”;
}
elsif(-d $name){
print “$name is a directory\n”;
}
Special Variables
$_, @_
$1, $2… - backreferencing variables
$_ = "this is a test";
/(\w+)\W+(\w+)/; # $1 is "this" and $2 is "is"
$`, $& and $’ - match variables
$string = “this is a simple string”;
/si.*le/; #$& is now “sample”, $` is “this is a” and $’
is #“string”
And many more…refer to ActivePerl’s online
documentations for their functions
Packages and Modules
Concentrate only on their usage in the
Greenstone environment
Package: a mechanism to protect codes from
tempering each other’s variables
Module: reusable package that is stored in
<Name of Module>.dm
The ppm (Perl Package Manager) for Linux
and Win32 version of Perl manages
installation and uninstallation of Perl packages
Packages and Modules
(cont.)
Install the module and put “use ModuleName”
or “require ModuleName” near the top of the
program
:: qualifying operator allow references to things
in the package, such as $Module::Variable
So “use Math::Complex module” refers to the
module Math/Complex.pm
new creates an instance of the object, then use
the handle and operator -> to access its
functions
Packages and Modules
(cont.)
use accepts a list of strings as well, such that the
we can access the elements directly without the
qualifying operator
For example:
use Module qw(const1 const2 func1 func2
func3);
const1, const2, func1, func2 and func3 can now
be used directly in the program
Packages and Modules
(cont.)
Perl locates modules by searching the @INC
array
The first instance found will be used for the
module referenced within a program
Where to locate modules are an automatic
process as the Makefiles and PPM take care
placing modules in the correct path
Packages and Modules
(cont.)
An example that uses the package CGI.pm:
use CGI; #uses the CGI.pm
module
$query = CGI::new(); #creates an
instance of CGI
$bday = $query->param("birthday"); #gets a
named parameter
print $query->header(); #outputs
html header
print $query->p("Your birthday is $bday.");
#outputs text to html
Packages and Modules
(cont.)
Advantages: Encourages code reuse and
less work
Disadvantages: 33% as fast as procedural
Perl according to the book “object-oriented
Perl”, generation of Perl modules involves
some ugly codes
Packages and Modules
(cont.)
Huge library
Thanks
Tanuj maheshwari