Section 2

Practical Report and Extraction Language
(PERL)
Introduction
• What is PERL?
– Practical Report and Extraction Language.
– It is an interpreted language optimized for scanning
arbitrary text files, extracting information from them, and
printing reports based on that information.
– Very powerful string handling features.
– Available on all platforms.
Internet & Web Based Technology 2

Main Advantages
• Speed of development
– You can enter the program in a text file, and just run it. It is an
interpretive language; no compiler is needed.
• It is powerful
– The regular expressions of Perl are extremely powerful.
– Uses sophisticated pattern matching techniques to scan large
amounts of data very quickly.
• Portability
– Perl is a standard language and is available on all platforms.
– Free versions are available on the Internet.
• Editing Perl programs
– No sophisticated editing tool is needed.
– Any simple text editor like Notepad or vi will do.

• Flexibility
– Perl does not limit the size of your data.
– If memory is available, Perl can handle the whole file as a single
string.
– Allows one to write simple programs to perform complex tasks.

How to run Perl?
• Perl can be downloaded from the Internet.
– Available on almost all platforms.
• Assumptions:
– For Windows operating system, you can run Perl programs
from the command prompt.
• Run “cmd” to get command prompt window.
– For Unix/Linux, you can run directly from the shell prompt.

Working through an example
• Recommended steps:
– Create a directory/folder where you will be storing the Perl
files.
– Using any text editor, create a file “test.pl” with the
following content:
print “Good day\n”;

print “This is my first Perl program\n”;
– Execute the program by typing the following at the

command prompt:
perl test.pl

• On Unix/Linux, an additional line has to be given at
the beginning of every Perl program.
#!/usr/bin/perl
print “Good day\n”;
print “This is my first Perl program \n”;

Variables
• Scalar variables
– A scalar variable holds a single value.
– Other variable types are also available (array and
associative array) – to be discussed later.
– A ‘$’ is used before the name of a variable to indicate that it
is a scalar variable.
$xyz = 20;

• Some examples:
$a = 10;
$name=“Indranil Sen Gupta”;
$average = 28.37;
– Variables do not have any fixed types.
– Variables can be printed as:

print “My name is $name, the average
temperature is $average\n”;

• Data types:
– Perl does not specify the types of variables.
• It is a loosely typed language.
• Languages like C or java are strongly typed.

Variable Interpolation
• A powerful feature
– Variable names are automatically replaced by values when
they appear in double-quoted strings.
• An example:
$stud = “Rupak”;
$marks = 75;
print “Marks obtained by $stud is $marks\n”;
print ‘Marks obtained by $stud is $marks\n’;

– The program will give the following output:
Marks obtained by Rupak is 75

Marks obtained by $stud is $marks
– What do we see:
• If we need to do variable interpolation, use double
quotes; otherwise, use single quotes.

• Another example:
$Expense = ‘$100’;
print “The expenditure is $Expense.\n”;

Expressions with Scalars
• Illustrated through examples (syntax similar to C)
$abc = 10;
$abc++;
$total- -;
$a = $b ** 10; # exponentiation
$a = $b % 10; # modulus
$balance = $balance + $deposit;
$balance += $deposit;

• Operations on strings:
– Concatenation: the dot (.) is used.
$a = “Good”;
$b = “ day”;
$c = “\n”;
$total = $a.$b.$c; # concatenate the strings
$a .= “ day\n”; # add to the string $a

– Arithmetic operations on strings
$a = “bat”;
$b = $a + 1;
print $a, “ and ”, $b;
will print bat and bau
– Operations carried out based on ASCII codes.

• May not always be meaningful.

– String repetition operator (x).
$a = $b x3;
will concatenate three copies of $b and assign it to $a.
print “Ba”. “na”x2;
will print the string “banana”.

String as a Number
• A string can be used in an arithmetic expression.
– How is the value evaluated?
– When converting a string to a number, Perl takes any
spaces, an optional minus sign, and as many digits it can
find (with dot) at the beginning of the string, and ignores
everything else.
“23.54” evaluates to 23.54

“123Hello25” evaluates to 123
“banana” evaluates to 0

Escaping
• The character ‘\’ is used as the escape character.
– It escapes all of Perl’s special characters (e.g., $, @, #, etc.).
$num = 20;
print “Value of \$num is $num\n”;
print “The windows path is c:\\perl\\”;

Line Oriented Quoting
• Perl supports specification of a string spanning
multiple lines.
– Use the marker ‘<<’.
– Follow it by a string, which is used to terminate the quoted
material.
• Example:
print << terminator;
Hello, how are you?
Good day.
terminator

print “<HTML>\n”;
print “<HEAD><TITLE>Test page </TITLE></HEAD>\n”;
print “<BODY>\n”;
print “<H2>This is a test document.<H2>\n”;
print “</BODY></HTML>”;

print << EOM;
<HTML>
<HEAD><TITLE>Test page </TITLE></HEAD>
<BODY>
<H2>This is a test document.<H2>
</BODY></HTML>
EOM

Lists and Arrays
Basic Difference
• List is an ordered list of scalars.

• Array is a variable that holds a list.
• Each element of an array is a scalar.
• The size of an array:
– Lower limit: 0
– Upper limit: no specific limit; depends on virtual memory.

List Literal
• Examples:
(10, 20, 50, 100)
(‘red', “blue", “green")
(“a", 1, 2, 3, ‘b')
($a, 12)
() # empty list
(10..20) # list constructor function
(‘A’..’Z’) # same, for lettere\s

Specifying Array Variable
• We use the special character ‘@’.
@months # denotes an array
The individual elements of the array are scalars, and can be

referred to as:
$months[0] # first element of @months
$months[1] # second element of @months
……

Initializing an Array
• Two ways:
– Specify values, separated by commas.
@color = (‘red’, ‘green’, “blue”, “black”);
– Use the quote words (qw) function, that uses space as the
delimiter:
@color = qw (red green blue black);

Array Assignment
– Assign from a list of literals
@numbers = (1, 2, 3);
@colors = (“red”, “green”, “blue”);
– From the contents of another array.

@array1 = @array2;
– Using the qw function:

@word = qw (Hello good morning);
– Combination of above:
@allcolors = (“white”, @colors, “brown”);

– Some other examples:
@xyz = (2..5);
@xyz = (1, @xyz);
@xyz = (@xyz, 6);

Multiple Assignments
($x, $y, $y) = (10, 20, 30);
($x, $y) = ($y, $x); # swap elements
($a, @col) = (‘red’, ‘green’, ‘blue’);
# $a gets the value ‘red’

# @col gets the value (‘green’, ‘blue’)
($first, @val, $last) = (1, 2, 3, 4);
# $first gets the value 1

# @val gets the value (2, 3, 4)
# $last is undefined

Number of Elements in Array
• Two ways:
$size = scalar @colors;
$size = @colors;

Accessing Elements
@list = (1, 2, 3, 4);
$first = $list[0];
$fourth = $list[3];
$list[1]++; # array becomes (1, 3, 3, 4)
$x = $list[5]; # $x gets the value undef
$list[2] = “Go”; # array becomes (1, 2, “Go”, 4)

• The $# is the index of the last element of the array.
@value = (1, 2, 3, 4, 5);
print “$#value \n”; # prints 4
• An empty array has the value

$#value = -1;

shift and unshift
• They operate on the front of the array.
– ‘shift’ removes the first element of the array.
– ‘unshift’ replaces the element at the start of the array.

• Example:
@color = qw (red, blue, green, black);
$first = shift @color;

# $first gets “red”, and @color becomes
# (blue, green, black)
unshift (@color, “white”);

# @color becomes (white, blue, green, black)

pop and push
• They operate on the bottom of the array.
– ‘pop’ removes the last element of the array.
– ‘push’ replaces the last element of the array.

• Example:
@color = qw (red, blue, green, black);
$first = pop @color;

# $first gets “black”, and @color becomes
# (red, blue, green)
push (@color, “white”);

# @color becomes (red, blue, green, white)

Reversing an Array
• By using the ‘reverse’ keyword.
@names = (“Mina”, “Tina”, ‘Rina”)
@rev = reverse @names;

# Reversed list stored in ‘rev’.
@names = reverse @names;

# Original array is reversed.

Printing an Array
• Example:
@colors = qw (red, green, blue);
print @colors;
# prints without spaces – redgreenblue
print “@colors”;
# prints with spaces – red green blue

Sort the Elements of an Array
• Using the ‘sort’ keyword, by default we can sort the
elements of an array lexicographically.
– Elements considered as strings.
@colors = qw (red blue green black);

@sort_col = sort @colors
# Array @sort_col is (black blue green red)

– Another example:
@num = qw (10 2 5 22 7 15);

@new = sort @num;
# @new will contain (10 15 2 22 5 7)
– How do sort numerically?
@num = qw (10 2 5 22 7 15);

@new = sort {$a <=> $b} @num;
# @new will contain (2 5 7 10 15 22)

The ‘splice’ function
• Arguments to the ‘splice’ function:
– The first argument is an array.
– The second argument is an offset (index number of the list
element to begin splicing at).
– Third argument is the number of elements to remove.
@colors = (“red”, “green”, “blue”, “black”);

@middle = splice (@colors, 1, 2);
# @middle contains the elements removed

File Handling
Interacting with the user
• Read from the keyboard (standard input).
– Use the file handle <STDIN>.
– Very simple to use.
print “Enter your name: ”;

$name = <STDIN>; # Read from keyboard
print “Good morning, $name. \n”;
– $name also contains the newline character.

• Need to chop it off.

The ‘chop’ Function
• The ‘chop’ function removes the last character of
whatever it is given to chop.
• In the following example, it chops the newline.

chop ($name = <STDIN>);
# Read from keyboard and chop newline
• ‘chop’ removes the last character irrespective of

whether it is a newline or not.
– Sometimes dangerous.

Safe chopping: ‘chomp’
• The ‘chomp’ function works similar to ‘chop’, with
the difference that it chops off the last character
only if it is a newline.

chomp ($name = <STDIN>);
# Read from keyboard and chomp newline

File Operations
• Opening a file
– The ‘open’ command opens a file and returns a file handle.
– For standard input, we have a predefined handle <STDIN>.
$fname = “/home/isg/report.txt”;
open XYZ , $fname;
while (<XYZ>) {
print “Line number $. : $_”;
}

– Checking the error code:
$fname = “/home/isg/report.txt”;
open XYZ, $fname or die “Error in open: $!”;
while (<XYZ>) {
print “Line number $. : $_”;
}
– $. returns the line number (starting at 1)

– $_ returns the contents of last match
– $i returns the error code/message

• Reading from a file:
– The last example also illustrates file reading.
– The angle brackets (< >) are the line input operators.
• The data read goes into $_

• Writing into a file:
$out = “/home/isg/out.txt”;
open XYZ , “>$out” or die “Error in write: $!”;
for $i (1..20) {
print XYZ “$i :: Hello, the time is”,
scalar(localtime), “\n”;
}

• Appending to a file:
$out = “/home/isg/out.txt”;
open XYZ , “>>$out” or die “Error in write: $!”;
for $i (1..20) {
print XYZ “$i :: Hello, the time is”,
scalar(localtime), “\n”;
}

• Closing a file:
close XYZ;
where XYZ is the file handle of the file being closed.

• Printing a file:
– This is very easy to do in Perl.
$input = “/home/isg/report.txt”;
open IN, $input or die “Error in open: $!”;
while (<IN>) {
print;
}
close IN;

Command Line Arguments
• Perl uses a special array called @ARGV.
– List of arguments passed along with the script name on the
command line.
– Example: if you invoke Perl as:
perl test.pl red blue green
then @ARGV will be (red blue green).
– Printing the command line arguments:
foreach (@ARGV) {
print “$_ \n”;
}

Standard File Handles
• <STDIN>
– Read from standard input (keyboard).
• <STDOUT>
– Print to standard output (screen).
• <STDERR>
– For outputting error messages.
• <ARGV>
– Reads the names of the files from the command line and
opens them all.

– @ARGV array contains the text after the program’s name in
command line.
• <ARGV> takes each file in turn.
• If there is nothing specified on the command line, it
reads from the standard input.
– Since this is very commonly used, Perl provides an
abbreviation for <ARGV>, namely, < >
– An example is shown.

$lineno = 1;
while (< >) {
print $lineno ++;
print “$lineno: $_”;
}
– In this program, the name of the file has to be given on the

command line.
perl list_lines.pl file1.txt
perl list_lines.pl a.txt b.txt c.txt

Control Structures
Introduction
• There are many control constructs in Perl.
– Similar to those in C.
– Would be illustrated through examples.
– The available constructs:
• for
• foreach
• if/elseif/else
• while
• do, etc.

Concept of Block
• A statement block is a sequence of statements
enclosed in matching pair of { and }.
if (year == 2000) {
print “You have entered new millenium.\n”;
}
• Blocks may be nested within other blocks.

Definition of TRUE in Perl
• In Perl, only three things are considered as FALSE:
– The value 0
– The empty string (“ ”)
– undef
• Everything else in Perl is TRUE.

if .. else
• General syntax:
if (test expression) {
# if TRUE, do this
}
else {
# if FALSE, do this
}

• Examples:
if ($name eq ‘isg’) {
print “Welcome Indranil. \n”;
} else {
print “You are somebody else. \n”;
}
if ($flag == 1) {
print “There has been an error. \n”;
}
# The else block is optional

elseif
• Example:
print “Enter your id: ”;

chomp ($name = <STDIN>);
if ($name eq ‘isg’) {
print “Welcome Indranil. \n”;
} elseif ($name eq ‘bkd’) {
print “Welcome Bimal. \n”;
} elseif ($name eq ‘akm’) {
print “Welcome Arun. \n”;
} else {
print “Sorry, I do not know you. \n”;
}

while
• Example: (Guessing the correct word)
$your_choice = ‘ ‘;
$secret_word = ‘India’;
while ($your_choice ne $secret_word) {
print “Enter your guess: \n”;
chomp ($your_choice = <STDIN>);
}
print “Congratulations! Mera Bharat Mahan.”

for
• Syntax same as in C.
• Example:
for ($i=1; $i<10; $i++) {

print “Iteration number $i \n”;
}

foreach
• Very commonly used function that iterates over a
list.
• Example:
@colors = qw (red blue green);

foreach $name (@colors) {
print “Color is $name. \n”;
}
• We can use ‘for’ in place of ‘foreach’.

• Example: Counting odd numbers in a list
@xyz = qw (10 15 17 28 12 77 56);
$count = 0;
foreach $number (@xyz) {

if (($number % 2) == 1) {
print “$number is odd. \n”;
$count ++;
}
print “Number of odd numbers is $count. \n”;
}

Breaking out of a loop
• The statement ‘last’, if it appears in the body of a
loop, will cause Perl to immediately exit the loop.
– Used with a conditional.
last if (i > 10);

Skipping to end of loop
• For this we use the statement ‘next’.
– When executed, the remaining statements in the loop will
be skipped, and the next iteration will begin.
– Also used with a conditional.

Relational Operators
The Operators Listed
Comparison Numeric String
Equal == eq
Not equal != ne
Greater than > gt
Less than < lt
Greater or equal >= ge
Less or equal <= le

Logical Connectives
• If $a and $b are logical expressions, then the
following conjunctions are supported by Perl:
– $a and $b $a && $b
– $a or $b $a || $b
– not $a ! $a
• Both the above alternatives are equivalent; first one
is more readable.

String Functions
The Split Function
• ‘split’ is used to split a string into multiple pieces using a
delimiter, and create a list out of it.
$_=‘Red:Blue:Green:White:255';
@details = split /:/, $_;
foreach (@details) {
print “$_\n”;
}
– The first parameter to ‘split’ is a regular expression that

specifies what to split on.
– The second specifies what to split.

$_= “Indranil isg@iitkgp.ac.in 283496”;

($name, $email, $phone) = split / /, $_;
• By default, ‘split’ breaks a string using space as

delimiter.

The Join Function
• ‘join’ is used to concatenate several elements into a
single string, with a specified delimiter in between.
$new = join ' ', $x1, $x2, $x3, $x4, $x5, $x6;
$sep = ‘::’;
$new = join $sep, $x1, $x2, $w3, @abc, $x4, $x5;

Regular Expressions
Introduction
• One of the most useful features of Perl.
• What is a regular expression (RegEx)?
– Refers to a pattern that follows the rules of syntax.
– Basically specifies a chunk of text.
– Very powerful way to specify string patterns.

An Example: without RegEx
$found = 0;
$_ = “Hello good morning everybody”;
$search = “every”;
foreach $word (split) {
if ($word eq $search) {
$found = 1;
last;
}
}
if ($found) {
print “Found the word ‘every’ \n”;
}

Using RegEx
$_ = “Hello good morning everybody”;
if ($_ =~ /every/) {
print “Found the word ‘every’ \n”;
}
• Very easy to use.

• The text between the forward slashes defines the
regular expression.
• If we use “!~” instead of “=~”, it means that the
pattern is not present in the string.

• The previous example illustrates literal texts as
regular expressions.
– Simplest form of regular expression.
• Point to remember:
– When performing the matching, all the characters in the
string are considered to be significant, including
punctuation and white spaces.
• For example, /every / will not match in the previous
example.

Another Simple Example
$_ = “Welcome to IIT Kharagpur, students”;
if (/IIT K/) {
print “’IIT K’ is present in the string\n”;
{
if (/Kharagpur students/) {
print “This will not match\n”;
}

Types of RegEx
• Basically two types:

– Matching
• Checking if a string contains a substring.
• The symbol ‘m’ is used (optional if forward slash used
as delimiter).
– Substitution
• Replacing a substring by another substring.
• The symbol ‘s’ is used.

Matching
The =~ Operator
• Tells Perl to apply the regular expression on the
right to the value on the left.
• The regular expression is contained within
delimiters (forward slash by default).
– If some other delimiter is used, then a preceding ‘m’ is
essential.

Examples
$string = “Good day”;
if ($string =~ m/day/) {
print “Match successful \n";
}
if ($string =~ /day/) {
}
• Both forms are equivalent.

• The ‘m’ in the first form is optional.

$string = “Good day”;
if ($string =~ m@day@) {
}
if ($string =~ m[day[ ) {
}
• Both forms are equivalent.

• The character following ‘m’ is the delimiter.

Character Class
• Use square brackets to specify “any value in the list
of possible values”.
my $string = “Some test string 1234";
if ($string =~ /[0123456789]/) {
print "found a number \n";
}
if ($string =~ /[aeiou]/) {
print "Found a vowel \n";
}
if ($string =~ /[0123456789ABCDEF]/) {
print "Found a hex digit \n";
}

Character Class Negation
• Use ‘^’ at the beginning of the character class to
specify “any single element that is not one of these
values”.
my $string = “Some test string 1234";

if ($string =~ /[^aeiou]/) {
print "Found a consonant\n";
}

Pattern Abbreviations
• Useful in common cases
. Anything except newline (\n)
\d A digit, same as [0-9]
\w A word character, [0-9a-zA-Z_]
\s A space character (tab, space, etc)
\D Not a digit, same as [^0-9]
\W Not a word character
\S Not a space character

$string = “Good and bad days";
if ($string =~ /d..s/) {
print "Found something like days\n";
}
if ($string =~ /\w\w\w\w\s/) {
print "Found a four-letter word!\n";
}

Anchors
• Three ways to define an anchor:
^ :: anchors to the beginning of string
$ :: anchors to the end of the string
\b :: anchors to a word boundary

if ($string =~ /^\w/)
:: does string start with a word character?
if ($string =~ /\d$/)
:: does string end with a digit?
if ($string =~ /\bGood\b/)
:: Does string contain the word “Good”?

Multipliers
• There are three multiplier characters.

* :: Find zero or more occurrences
+ :: Find one or more occurrences
? :: Find zero or one occurrence
• Some example usages:
$string =~ /^\w+/;
$string =~ /\d?/;
$string =~ /\b\w+\s+/;
$string =~ /\w+\s?$/;

Substitution
Basic Usage
• Uses the ‘s’ character.

• Basic syntax is:
$new =~ s/pattern_to_match/new_pattern/;
What this does?

• Looks for pattern_to_match in $new and, if found,
replaces it with new_pattern.
• It looks for the pattern once. That is, only the first
occurrence is replaced.
• There is a way to replace all occurrences (to be
discussed shortly).

Examples
$xyz = “Rama and Lakshman went to the forest”;
$xyz =~ s/Lakshman/Bharat/;
$xyz =~ s/R\w+a/Bharat/;
$xyz =~ s/[aeiou]/i/;
$abc = “A year has 11 months \n”;
$abc =~ s/\d+/12/;
$abc =~ s /\n$/ /;

Common Modifiers
• Two such modifiers are defined:

/i :: ignore case
/g :: match/substitute all occurrences
$string = “Ram and Shyam are very honest";

if ($string =~ /RAM/i) {
print “Ram is present in the string”;
}
$string =~ s/m/j/g;
# Ram -> Raj, Shyam -> Shyaj

Use of Memory in RegEx
• We can use parentheses to capture a piece of
matched text for later use.
– Perl memorizes the matched texts.
– Multiple sets of parentheses can be used.
• How to recall the captured text?
– Use \1, \2, \3, etc. if still in RegEx.
– Use $1, $2, $3 if after the RegEx.

Examples
$string = “Ram and Shyam are honest";
$string =~ /^(\w+)/;
print $1, "\n"; # prints “Ra\n”
$string =~ /(\w+)$/;
print $1, "\n"; # prints “st\n”
$string =~ /^(\w+)\s+(\w+)/;
print "$1 $2\n";
# prints “Ramnd Shyam are honest”;

$string = “Ram and Shyam are very poor";
if ($string =~ /(\w)\1/) {
print "found 2 in a row\n";
}
if ($string =~ /(\w+).*\1/) {
print "found repeat\n";
}
$string =~ s/(\w+) and (\w+)/$2 and $1/;

Example 1
• validating user input
print “Enter age (or 'q' to quit): ";

chomp (my $age = <STDIN>);
exit if ($age =~ /^q$/i);
if ($age =~ /\D/) {
print "$age is a non-number!\n";
}

Example 2: validation contd.
• File has 2 columns, name and age, delimited by one
or more spaces. Can also have blank lines or
commented lines (start with #).
open IN, $file or die "Cannot open $file: $!";
while (my $line = <IN>) {
chomp $line;
next if ($line =~ /^\s*$/ or $line =~ /^\s*#/);
my ($name, $age) = split /\s+/, $line;
print “The age of $name is $age. \n";
}

Some Special Variables
$&, $` and $’
• What is $&?
– It represents the string matched by the last successful
pattern match.
• What is $`?
– It represents the string preceding whatever was matched
by the last successful pattern match.
• What is $‘?
– It represents the string following whatever was matched by
the last successful pattern match .

– Example:
$_ = 'abcdefghi';
/def/;
print "$\`:$&:$'\n";
# prints abc:def:ghi

• So actually ….
– S` represents pre match
– $& represents present match
– $’ represents post match

Associative Arrays
Introduction
• Associative arrays, also known as hashes.
– Similar to a list
• Every list element consists of a pair, a hash key and a
value.
• Hash keys must be unique.
– Accessing an element
• Unlike an array, an element value can be found out by
specifying the hash key value.
• Associative search.
– A hash array name must begin with a ‘%’.

Specifying Hash Array
• Two ways to specify:
– Specifying hash keys and values, in proper sequence.
%directory = (
“Rabi”, “258345”,
“Chandan”, “325129”,
“Atul”, “445287”,
“Sruti”, “237221”
);

– Using the => operator.
%directory = (
Rabi => “258345”,
Chandan => “325129”,
Atul => “445287”,
Sruti => “237221”
);
– Whatever appears on the left hand side of ‘=>’ is treated as

a double-quoted string.

Conversion Array <=> Hash
• An array can be converted to hash.
@list = qw (Rabi 258345 Chandan 325129 Atul

445287 Sruti 237221);
%directory = @list;
• A hash can be converted to an array:
@list = %directory;

Accessing a Hash Element
• Given the hash key, the value can be accessed
using ‘{ }’.
• Example:

445287 Sruti 237221);
%directory = @list;
print “Atul’s number is $directory{“Atul”} \n”;

Modifying a Value
• By simple assignment:

445287 Sruti 237221);
%directory = @list;
$directory{Sruti} = “453322”;
$directory{‘Chandan’} ++;

Deleting an Entry
• A (hash key, value) pair can be deleted from a hash
array using the “delete” function.
– Hash key has to be specified.

445287 Sruti 237221);
%directory = @list;
delete $directory{Atul};

Swapping Keys and Values
• Why needed?
– Suppose we want to search for a person, given the phone
number.

445287 Sruti 237221);
%directory = @list;
%revdir = reverse %directory;

print “$revdir{237221} \n”;

Using Functions ‘keys’, ‘values’
• ‘keys’ returns all the hash keys as a list.
• ‘values’ returns all the values as a list.

445287 Sruti 237221);
%directory = @list;
@all_names = keys %directory;

@all_phones = values %directory;

An Example
• List all person names and telephone numbers.

445287 Sruti 237221);
%directory = @list;
foreach $name (keys %directory) {

print “$name \t $directory{$name} \n”;
}

Subroutines
Introduction
• A subroutine …..
– Is a user-defined function.
– Allows code reuse.
– Define ones, use multiple times.

How to use?
• Defining a subroutine
sub test_sub {
# the body of the subroutine goes here
# ……..
}
• Calling a subroutine
– Use the ‘&’ prefix to call a subroutine.
&test_sub;
&gcd ($val1, $val2); # Two parameters
– However, the ‘&’ is optional.

Subroutine Return Values
• Use the ‘return’ statement.
– This is also optional.
– If the keyword ‘return’ is omitted, Perl functions return the
last value evaluated.
• A subroutine can also return a non-scalar.
• Some examples are given next.

Example 1
$name = ‘Indranil';
welcome(); # call the first sub
welcome_namei(); # call the second sub
exit;
sub welcome {
print "hi there\n";
}
sub welcome_name {
print "hi $name\n";
# uses global $name variable
}

Example 2
# Return a non-scalar
sub return_alpha_and_beta {
return ($alpha, $beta);
}
$alpha = 15;
$beta = 25;
@c = return_alpha_and_beta;
# @c gets (5,6)

Passing Arguments
• All arguments are passed into a Perl function
through the special array $_.
– Thus, we can send as many arguments as we want.
• Individual arguments can also be accessed as $_[0],
$_[1], $_[2], etc.

Example 3
# Two different ways to write a subroutine to add two numbers

sub add_ver1 {
($first, $second) = @_;
return ($first + $second);
}
sub add_ver2 {
return $_[0] + $_[1];
# $_[0] and $_[1] are the first two
# elements of @_
}

Example 4
$total = find_total (5, 10, -12, 7, 40);
sub find_total {
# adds all numbers passed to the sub
$sum = 0;
for $num (@_) {
$sum += $num;
}
return $sum;
}

‘my’ variables
• We can define local variables using the ‘my’
keyword.
– Confines a variable to a region of code (within a block { } ).
– ‘my’ variable’s storage is freed whenever the variable goes
out of scope.
– All variables in Perl is by default ‘global’.

Example 5
$sum = 7;
$total = add_any (20, 10, -15);
# $total gets 15
sub add_any {
# local variable, won't interfere
# with global $sum
my $sum = 0;
for my $num (@_ ) {

$sum += $num;
}
return $sum;
}

Writing CGI Scripts in Perl
Introduction
• Perl provides with a number of facilities to facilitate
writing of CGI scripts.
– Standard library modules.
• Included as part of the Perl distribution.
• No need to install them separately.
#!/usr/bin/perl
use CGI qw (:standard);

• Some of the functions included in the CGI.pm (.pm
is optional) are:
– header
• This prints out the “Content-type” header.
• With no arguments, the type is assumed to be
“text/html”.
– start_html
• This prints out the <html>, <head>, <title> and <body>
tags.
• Accepts optional arguments.

– end_html
• This prints out the closing HTML tags, </body>, >/html>.
• Typical usages and arguments would be illustrated

through examples.

Example 1 (without using CGI.pm)
#!/usr/bin/perl
print <<TO_END;
Content-type: text/html
<HTML> <HEAD> <TITLE> Server Details </TITLE>

</HEAD>
<BODY>
Server name: $ENV{SERVER_NAME} <BR>
Server port number: $ENV{SERVER_PORT} <BR>
Server protocol: $ENV{SERVER_PROTOCOL}
</BODY> </HTML>
TO_END

Example 2 (using CGI.pm)
#!/usr/bin/perl -wT
use CGI qw(:standard);
print header (“text/html”);

print start_html ("Hello World");
print "<h2>Hello, world!</h2>\n";
print end_html;

Example 3: Decoding Form Input
sub parse_form_data {
my %form_data;
my $name_value;
my @nv_pairs = split /&/, $ENV{QUERY_STRING};
if ( $ENV{REQUEST_METHOD} eq ‘POST’ ) {
my $query = “”;
read (STDIN, $query, $ENV{CONTENT_LENGTH});
push @nv_pairs, split /&/, $query;
}

foreach $name_value (@nv_pairs) {
my ($name, $value) = split /=/, $name_value;
$name =~ tr/+/ /;
$name =~ s/%([\da-f][\da-f])/chr (hex($1))/egi;
$value =~ tr/+/ /;
$value =~ s/%([\da-f][\da-f])/chr (hex($1))/egi;
$form_data{$name} = $value;
}
return %form_data;
}

Using CGI.pm
• The decoded form value can be directly accessed
as:
$value = param (‘fieldname’);
• An equivalent Perl code as in the last example using

CGI.pm
– Shown in next slide.

Example 4
#!/usr/bin/perl -wT
my %form_data;
foreach my $name (param() ) {
$form_data {$name} = param($name);
}

Example 5: sending mail
#!/usr/bin/perl -wT
print header;
print start_html (“Response to Guestbook”);
$ENV{PATH} = “/usr/sbin”; # to locate sendmail
open (MAIL, “| /usr/sbin/sendmail –oi –t”);
# open the pipe to sendmail
my $recipient = ‘xyz@hotmail.com’;
print MAIL “To: $recipient\n”;
print MAIL “From: isg\@cse.iitkgp.ac.in\n”;
print MAIL “Subject: Submitted data\n\n”;

foreach my $xyz (param()) {
print MAIL “$xyz = “, param($xyz), “\n”;
}
close (MAIL);
print <<EOM;
<h2>Thanks for the comments</h2>
<p>Hope you visit again.</p>
EOM
print end_html;

Section 2

Загружено:

Сведения о документе

Авторское право

Доступные форматы

Поделиться этим документом

Поделиться или встроить документ

Параметры публикации

Этот документ был вам полезен?

Это неприемлемый материал?

Авторское право:

Доступные форматы

Section 2

Загружено:

Авторское право:

Доступные форматы

Practical Report and Extraction Language

Internet & Web Based Technology 2

Internet & Web Based Technology 3

Internet & Web Based Technology 4

Internet & Web Based Technology 5

print “Good day\n”;

– Execute the program by typing the following at the

Internet & Web Based Technology 6

Internet & Web Based Technology 7

Internet & Web Based Technology 8

– Variables do not have any fixed types.

– Variables can be printed as:

Internet & Web Based Technology 9

Internet & Web Based Technology 10

Internet & Web Based Technology 11

Marks obtained by Rupak is 75

Internet & Web Based Technology 12

Internet & Web Based Technology 13

• Illustrated through examples (syntax similar to C)

Internet & Web Based Technology 14

$a .= “ day\n”; # add to the string $a

Internet & Web Based Technology 15

will print bat and bau

– Operations carried out based on ASCII codes.

Internet & Web Based Technology 16

print “Ba”. “na”x2;

will print the string “banana”.

Internet & Web Based Technology 17

“23.54” evaluates to 23.54

Internet & Web Based Technology 18

print “The windows path is c:\\perl\\”;

Internet & Web Based Technology 19

Internet & Web Based Technology 20

Internet & Web Based Technology 21

Internet & Web Based Technology 22

• List is an ordered list of scalars.

Internet & Web Based Technology 24

Internet & Web Based Technology 25

The individual elements of the array are scalars, and can be

Internet & Web Based Technology 26

Internet & Web Based Technology 27

– From the contents of another array.

– Using the qw function:

Internet & Web Based Technology 28

@xyz = (1, @xyz);

@xyz = (@xyz, 6);

Internet & Web Based Technology 29

($x, $y) = ($y, $x); # swap elements

($a, @col) = (‘red’, ‘green’, ‘blue’);

# $a gets the value ‘red’

($first, @val, $last) = (1, 2, 3, 4);

# $first gets the value 1

Internet & Web Based Technology 30

Internet & Web Based Technology 31

$list[1]++; # array becomes (1, 3, 3, 4)

$x = $list[5]; # $x gets the value undef

$list[2] = “Go”; # array becomes (1, 2, “Go”, 4)

Internet & Web Based Technology 32

print “$#value \n”; # prints 4

• An empty array has the value

Internet & Web Based Technology 33

Internet & Web Based Technology 34

$first = shift @color;

unshift (@color, “white”);