Perl scripting

PERL (Practical Extraction Report language)

Perl is developed by "Larry Wall" in 1986.


The home of the Perl is Unix


Perl is written in "C" language.


Perl is interpreter based language.


Perl is a case sensitive scripting language.

Differences between Scripting Language and Programming Language

Scripting Language

It is an Interpreter based language.

Interpreter converts high level instructions into machine language line by line.

It doesn’t create .exe file.

No need to compile the source code.

It takes less lines of code.

It reduces cost of maintenance

Basically this executes at server side.

Programming Language

It is a compiler based language.

Compiler converts whole program in single shot into machine language.

It creates .exe file.

Needs to compile the program.

It takes numerous lines of code.

It increases cost of maintenance.

These are used for client based applications.

The perl borrowed many features from Unix utilities (like awk, sed, grep, tr ) and added "C" language functionality.

The features of Perl

Free software.

Open source code.

It is simple and easy to learn.

It is rich in procedural and object oriented.

It is highly portable language i.e The Perl programs are written in one platform allows to run in another platform with or without modifications.

Perl supports DB Connectivity.

Perl supports CPAN (Comprehensive Perl Archive Network) modules. You can refer the following website for CPAN modules ;

www.cpan.org

The Perl initially designed for to do manipulations in text files, later it is used in wide range of the following areas

System Administration


Database Administration


Web Development (CGI)


Networking (Net)


Bioinformatics (Bio)


Testing (Test)


VLSI


Telecom


GUI development

The extension of the Perl program is ".pl".

The name of the Perl interpreter is "perl"

The motto of the Perl is more than one way to do it.

Perl supports 2 types of comments.

Single line comment (#)


Multi line comment

=pod (plan old documentation)

------------------

------------------

------------------

=cut

How to run Perl programs on windows platform

Open text editor (notepad)

Write Perl program

Save program with .pl extension

Run program at command prompt C:\>perl program.pl

How to run Perl programs on Linux platform

Open text editor (vi)

Write Perl program

Save and quit from the vi editor

Run the program at $ prompt ;

$perl program.pl

$chmod a+x program.pl

$./program.pl

How to see location of the Perl?

$which perl ß

/usr/bin/perl

How to see the help in Linux?

$man perl

How to see the version of the perl?

$perl –v

Write a program to print welcome message?

#!/usr/bin/perl -w

#Author: Pavankumar

# -w displays warnings

print "welcome to SEI \n";

print "This is my first perl program \n";

Variable

It is a data name or memory location

It is a temporary storage location

It value can change during the execution of the program

Perl allows implicit variable declaration i.e. No need to declare the variables explicitly by programmer

Every variable occupies memory during execution time

Variables are classified into 3 types

Scalar variables


Array variables or Indexed array variables


Hash array variables or Associated array variables

Scalar variables

It holds only one value

The value may be integer/float/string

It should begin with "$" symbol

Array variables

It is a group of scalar variables

It should begin with "@" symbol

Hash array variables

It is a group of key pair values

It should begin with "%" symbol

Print:

"print" is a predefined function and it is used for to write data to the output screen.

Ex: print ("Hello");

print "Hello";

print STDOUT "Hello";

#hello.pl

#!/usr/bin/perl -w

print ("hello, perl\n");

print "hello, perl\n";

print STDOUT "hello, perl\n";

The standard input/output/error buffers are

STDIN


STDOUT


STDERR

<STDIN> is the standard input handler used to take input from user.

<STDOUT> is the standard output handler used to write data to the screen.

<STDERROR> is the standard error handler used to write errors.

#Write a program to accept the name and display

#prg2-chomp.pl

#!/usr/bin/perl -w

print "Enter a name:";

$name=<STDIN>; #<> -- Diamond operator

chomp($name);

print "Hello, $name, How are you?\n";

print "Enter a name:";

chomp($name=<STDIN>);

print "Hello $name, How are you?\n";

print "Enter a name:";

chomp($name=<>); # By default it reads input from the keyboard

print "Hello $name, How are you?\n";

Note:

"chomp" is a predefined function, it deletes the given string last character, if it is new line character

Scalar variable Examples

$a=100; # integer

$b=10.5; # float

$course="perl"; # String

$name=’Tecno soft’; #String

$k="100"; # String

$m="25.67"; #String

#prg-scalar.pl

#!/usr/bin/perl -w

$a=100; # integer

$b=10.5; # float

$course="perl"; # String

$name='Tecno soft'; #String

$k="100"; # String

$m="25.67"; #String

print "a=$a, b=$b, course=$course, name=$name, k=$k, m=$m\n";

Strings are classified into 3 types

Double quoted strings (" ") qq// or qq{} or qq() or qq<> or qq[]

Single quoted string (‘ ‘) q// or q{} or q() or q<> or q[]

Back quoted strings or Back tick strings (` `) qx// or qx{} or qx() or qx<> or qx[]

Ex1:

$str="perl";

$x="I like $str";

print $x;

Ex2:

$str="perl";

$x=’I like $str’;

print $x;

Ex3:

$str="perl";

$x="I like \n $str";

print $x;

Ex4:

$str="perl";

$x=’I like \n $str";

print $x;

Note:

In double quoted strings, variable substitution takes place but in single quoted strings, every thing it treats as normal text.

$str = "I said, "Don’t write to dist""; -- Incorrect

$str = "I said, \"Don’t write to disk\"’; -- Correct

$str = ‘I said, "Don\’t write to disk"’; -- Correct

#!/usr/bin/perl -w

$x = "disk";

$str = qq/I said, "Don’t write to $x"\n/;

print $str;

Output:

I said, "Don’t write to disk

#!/usr/bin/perl -w

$x = "disk";

$str = "q/I said, "Don’t write to $x"\n/;

print $str;

Output:

I said, "Don’t write to $x\n"

Back quote (``): It is used to execute operating system commands.

#!/usr/bin/perl -w

$x=`ls -lrt`;

print $x;

#!/usr/bin/perl -w

$x=qx/who/;

print $x;

Operators:

Arithmetic operators

: + - * / % **

Ex1:

$a=10;

$b=4;

print $a+$b; #14

Ex2:

$a=10;

$b="25abc";

print $a+$b; #35

Ex3:

$a=10;

$b="abc25";

print $a+$b; #10

Ex4:

$a="Hello";

$b="Pavan";

print $a+$b; #0

Ex5:

$a=10;

$b="456abc";

print $a+$b; #466

Ex6:

$a=10;

$b="25abc";

print $a+$b; #35

print $a.$b; #1025abc

Ex7:
$a=2

$b=4

print $a**$b; #2**4=16

Relation operators:

a) Numeric comparison operators

: <, >, <=, >=, = =, ! =, <=> (Three way comparison operator)

b) String comparison operators:

lt, gt, le, ge, eq, ne, cmp (Three way comparison operator)

Ex1:

$a=100;

$b=20;

$a>$b ---- True

$a gt $b ---- False

Ex2:

$x ="hello";

$y ="pavan";

$x gt $y --- True

$x > $y --- False

Ex3:

$c = $a <=> $b;

If a>b à 1

a<b à -1

a= =b à 0

Ex4:

$k = $x cmp $y

If x>y à 1

x<y à -1

x= =y à 0

Logical operators:

&&, ||, ! or and, or, not

Sting multiplication operator:

x

$str = "perl";

$k = $str x 5; # It multiplies str by 5 times

print $k; # perlperlperlperlperl

String concatenation operator:

$str1 = "SEI";

$str2 = "Investments";

a) $k = $str1.$str2;

print $k; #SEIInvestments

b) $k = $str1." ".$str2;

print $k; #SEI Investments

Range operator:

1..10 ----- Correct

a..z ------ Correct

-10..-1 ---- Correct

10..1 ---- Incorrect

z..a ----- Incorrect

-1..-10 ---- Incorrect

print 1..10 # It prints no’s 1 to 10

Assignment operators:

$a = 10;

$b = 20;

$c = 30;

Or ($a,$b,$c)=(10,20,30)

Short hand assignment operator:

+=, -=, *=, !=, %=, .=, x=

Ex:

$a=10;


$a=$a+5; (or) $a+=5;
$str="load";

$str=$str."ing"; (or) $str.="ing";

Increment operator: ++

$a = 10;

$a = $a+1; (or) $a+=1; (or) $a++;

Decrement operator: --

$a = 10;

$a = $a-1; (or) $a-=1; (or) $a--;

IF Statements:

Simple if
if(condition)
{
------------
------------
}
-------------
-------------
simple unless
unless(condition)
{
-------------
-------------
}
-------------
-------------
if….else
if(condition)
{
------------
------------
}
else
{
-----------
-----------
}
-----------
-----------
unless…else
unless(condition)
{
------------
------------
}
else
{
------------
------------
}
--------------
--------------
if…elseif…
if(condition)
{
------------
------------
}
elsif(condition)
{
-------------
-------------
}
else
{
------------
------------
}
single line if statement
statement1 if(condition);
---------------
---------------
Single line unless statement

Statement1 unless(condition);

------------------

------------------

Looping statements:

while loop

while(condition)

{

-----------

-----------

}

---------

---------

until loop

until(condition)

{

-----------

-----------

}

-----------

-----------

do…while loop

do

{

-----------

-----------

}

while(condition);

do…until loop

do

{

-----------

-----------

}

while(condition);

------------

------------

for loop

for(initialization;condition;incr/decr)

{

---------------

---------------

}

--------------

--------------

foreach loop

foreach variable(list of values)

{

--------------

--------------

}

------------

------------

last :

It is used for to terminate the loop.

next:

It is used for to start the loop again.

while(condition)

{

------------

------------

last;

------------

------------

}

-----------

-----------

while(condition)

{

-------------

-------------

next;

-------------

-------------

}

-------------

-------------

Programs on if statements:

#write a program to accept a number and check the no is an even or odd?

#!/usr/bin/perl -w

print "\nEnter number:";

chomp($n=<STDIN>);

if($n%2==0)

{

print "\n$n is an Even no\n";

}

else

{

print "\n$n is an Odd no\n";

}

#WAP Accept a number and check the no is 3 digit no or not?

#!/usr/bin/perl -w

print "\nEnter a number:";

chomp($n=<STDIN>);

if($n>=100&&$n<=999)

{

print "\n$n is a 3 digit number\n";

}

else

{

print "\n$n is not a 3 digit number\n";

}

#WAP to accept username and password and check the user is valid or not?

#!/usr/bin/perl -w

print "\nEnter Username:";

chomp($username=<STDIN>);

print "\nEnter Password:";

chomp($password=<STDIN>);

if($username eq "pbandaru" && $password eq "pbandaru")

{

print "\nWelcome to SEI\n";

}

else

{

print "\nInvalid username or password\n";

}

#WAP to accept 2 strings and check string1 >string2 or string1<string2 or both strings are equal?

#!/usr/bin/perl -w

print "\nEnter a string1:";

chomp($str1=<STDIN>);

print "\nEnter a string2:";

chomp($str2=<STDIN>);

$x=($str1 cmp $str2);

if($x = =1)

{

print "\n$str1 is greater than $str2\n";

}

elsif($x = =-1)

{

print "\n$str1 is less than $str2\n";

}

elsif($x = =0)

{

print "\nboth are equal\n";

}

#WAP to check whether variable exist or not?

#!/usr/bin/perl -w

$a=10;

undef($a); #undef function is used for to delete a variable

if(defined($a)) #defined function returns true, if the variable defined otherwise false

{

print "variable exist\n";

}

else

{

print "No such variable\n";

}

Looping Statements:

#WAP to print numbers from 1 to 10

#!/usr/bin/perl -w

$i=1;

while($i<=10)

{

print "$i\t";

$i++;

}

print "\n\n\n";

for($i=1;$i<=10;$i++)

{

print "$i\t";

}

print "\n\n\n";

foreach $i (1..10)

{

print "$i\t"

}

print "\n\n\n";

foreach (1..10)

{

print "$_\t"; #$_ is a special variable which stores the default values

}

print "\n";

Arrays:

It is a collection of scalar variables. i.e collection of dissimilar type of values

It should begin with @ symbol

It has an infinite length

The array index starts with ‘0’

Syntax: @array_variable=(list of scalars);

Ex: @num=(10,20,30,40,50,60);

@x=(10,’perl’,4.5,60,"unix");

@days=("sun","mon","tue","wed",’thu","fri","sat");

@days=qw(sun mon tue wed thu fri sat);

Accessing array elements

print "@num"; #10 20 30 40 50 60 à With space

print @num; #102030405060 à Without space

print $num[2]; #30 à Prints third element

print "@num[1..4]";#20 30 40 50 à Prints elements 1 to 4

print "$num[-1]"; #60 à It prints the last element

print "@num[0,1,-1,-2]";10 20 60 50 à More than one element array representation

EX:

#!/usr/bin/perl -w

@num=(10,20,30,40,50,60);

print "@num"; #10 20 30 40 50 60 With space

print "\n";

print @num; #102030405060 Without space

print "\n";

print $num[2]; #30 Prints third element

print "\n";

print "@num[1..4]"; #20 30 40 50 Prints elements 1 to 4

print "\n";

print "$num[-1]"; #60 It prints the last element

print "\n";

print "@num[0,1,-1,-2]"; #10 20 60 50 More than one element array representation

print "\n";

Writing elements to array

$num[6]=70;

$num[3]=100;

@num[7..10]=(100,200,300,400); # It overwrites if it exists, if not creates.

$num[100]="abc"; # If the last index is 50 then it creates remaining indexes before 100.

EX:

#!/usr/bin/perl

@num=(10,20,30,40,50,60);

$num[6]=70; # It will create a new index and add an element

print $num[6];

print "\n";

$num[3]=100; # It will overwrite the existing element

print $num[3];

print "\n";

@num[7..10]=(100,200,300,400);

print "@num";

print "\n";

$num[100]="abc";

print "$num[100]";

print "\n";

$#array:

It returns the last index of the array.

EX:

#!/usr/bin/perl -w

@num=(10,20,30,40,50,60);

print "\nnum array last index is: $#num"; #5

print "\nTotal elements in num array is:",$#num+1; #6

print "\n";

$num[$#num+1]="hello";

@k=@num; #copying array

print "Copied array elements are:@k";

print "\n";

$n=@num; #Assigining lenth of the array

print "Length of the array is:$n"; #7

print "\n\n";

EX:

#!/usr/bin/perl -w

@x=(10,20,30,40,50,60);

$i=0;

while($i<=$#x)

{

print "$x[$i]\n";

$i++;

}

print "\n";

@y=(10,20,30,40,50,60);

for($i=0;$i<=$#y;$i++)

{

print "$y[$i]\n";

}

print "\n";

@z=(10,20,30,40,50,60);

foreach (@z)

{

print "$_\n";

}

print "\n";

EX:

#!/usr/bin/perl -w

print "Enter elements to store into array at end press ctl+d:";

chomp(@a=<STDIN>);

print "Entered elements are\n";

foreach $x (@a)

{

print "$x \n";

}

print "\n Total no of elements:",$#a+1;

print "\n";

EX:

#!/usr/bin/perl -w

#Accept n integer elements and store into array and find sum and display

print "Enter no of elements:";

chomp($n=<STDIN>);

$i=0;

$total=0;

while($i<$n)

{

print "\n Enter number:",$i+1,":";

chomp($a[$i]=<STDIN>);

$total=$total+$a[$i];

$i++;

}

print "\n given elements are:\n";

print "@a\n";

print "\nSum of above elements:$total";

print "\n"

Hash Array Variable:

It is a group of key pair values

It should begin with % symbol

%variable = (list of key pairs)

Examples

%names=("hari",10000,"venkat",9500,"neeraja",8000,"sai",9800);

%name=("hari"=>10000,"venkat"=>9500,"neeraja"=>8000,"sai"=>9800);

%cities=("ap"=>"hyd","tn",=>"chennai","kn"=>"bangalore");

Hash Array Functions:

Keys:

It returns the given hash array keys

keys%hasharrayname;

eg: keys%cities

output: ap tn kn

Values:

It returns the given hash array values

values%hasharrayname;

eg: values%cities

output: hyd chennai bangalore

each:

It returns the given hash array one key pair value

each%hasharrayname

eg: each%cities

output: tn chennai

exists:

It returns true if the given key exist in the given array

exists%hasharrayname

delete:

It deletes the given key pair from the given hash array

delete $hasharrayname{key};

eg: delete $cities{m};

Ex: print-hash-array-element.pl

#!/usr/bin/perl -w

%names=("anu"=>4000,"madhu"=>8000,"latha"=>3000,"hari"=>9000,"babu"=>5000,"balu"=>4000,"anu"=>2000);

foreach $x (keys%names)

{

print "\n$x salary is: $names{$x}\n";

}

print "\n";

EX: print-hash-array-element1.pl

#!/usr/bin/perl -w

%names=("anu"=>4000,"madhu"=>8000,"latha"=>3000,"hari"=>9000,"babu"=>5000,"balu"=>4000,"anu"=>2000);

while(($x,$y)=(each%names))

{

print "\n$x salary is: $y\n";

}

$x=keys%names;

print "\n";

print "total no of variables:$x";

print "\n";

File Handling:

File:

It is collection of data or group of records

The following are functions to handle files

open():

It is used for to create a new file or to open an existing file or to append data to the existing files.

open(FILEHANDLE,"mode Filename");

FILEHANDLE is a user defined name

Modes are classified into 3 types

read mode (<) – Default mode


write mode (>)


append mode (>>)

How to open a file

Syn: open(FILEHANDLE,"<filename");

Ex: open(FH,"<sample.txt");

Note: In read mode if the given file exists, it opens a file and places a file pointer at the beginning of the file and returns true. If the file doesn’t exist, it fails to open file and returns false.

How to create a file

Syn:open(FILEHANDLE,">filename");

Ex: open(FH,">sample.txt");

Note: In write mode if the given file exists, it opens a file and deletes all file contents and places a file pointer at the beginning of the file. If the file doesn’t exist, it creates a new file and places file pointer at the beginning of the file.

How to append data to the file

Syn: open(FILEHANDLE,">>filename");

Ex: open(FH,">>sample.txt");

Note: In append mode if the given file exists, it opens a file and places a file pointer at the end of the file. If the file doesn’t exist, it creates a new file and places file pointer at beginning of the file.

close():

It is used for to close file, which is already opened

Syn: close(FILEHANDLE);

File Test commands:

-f:

It returns true if the given file is a regular file

-d:

It returns true if the given file is a directory file

-l:

It returns true if the given file is a link file

-e:

It returns true if the given file is exist

-z:

It returns true if the given file is empty

-r:

It returns true if the given file has read permission

-w:

It returns true if the given file has write permission

-x:

It returns true if the given file has execute permission

-T:

It returns true if the given file is a Text file

-B:

It returns true if the given file is a Binary file

Ex: file-existence.pl

#!/usr/bin/perl -w

#Program to check the given file exists or not

print "\n Enter a filename::";

chomp($fname=<STDIN>);

if(open(FH,"<$fname"))

{

print "$fname file exists\n";

close(FH);

}

else

{

print "\n $fname file doesn't exist\n";

}

Ex: file-existence1.pl

#!/usr/bin/perl -w

print "\n Enter a filename:";

chomp($fname=<STDIN>);

#die: Predefined function, used to terminate the program

#$!: It displays perl generated error message

die "cann't open a file. $!" unless(open(FH,"$fname"));

print "\n$fname file exists";

close(FH);

print "\n";

Ex: file-open.pl

#!/usr/bin/perl -w

#Program for opening a file

print "\n Enter a file name:";

chomp($fname=<STDIN>);

die "cann't open a file. $!" unless(open(FIN,"$fname"));

while($x=<FIN>)

{

print "$x";

}

close(FIN);

Ex: file-open1.pl

#!/usr/bin/perl -w

print "\n Enter a filename:";

chomp($fname=<STDIN>);

die "Can't open a file. $! unless(open(FH,"$fname"));

@x=<FIN>;

print "@x";

print "\n Total lines:",$#x+1;

close(FIN);

Ex: print-oddlines-from-file.pl

#!/usr/bin/perl -w

print "\nEnter a filename:";

chomp($fname=<STDIN>);

die "Cann't open a file.$!" unless(open(FIN,"$fname"));

$i=0;

while($x=<FIN>)

{

$i++;

next if($i%2==0);

print "$i.$x";

}

close(FIN);

Ex:

create-file.pl

#!/usr/bin/perl -w

print "\nEnter a filename to be created:";

chomp($fname=<STDIN>);

open(FOUT,">>$fname");

print "Enter data to the file and press ctl+d:";

while($x=<STDIN>)

{

print FOUT "$x";

}

print "**********$fname file created*********\n";

close(FOUT);

Ex: check-file-type.pl

#!/usr/bin/perl -w

print "\nEnter a file name:";

chomp($fname=<STDIN>);

if(-e $fname)

{

if(-f $fname)

{

print "\n $fname is a regular file\n";

}

elsif(-d $fname)

{

print "\n $fname is a directory\n";

}

}

else

{

print "\n$fname file doesn't exist\n";

}

Directory Handling

Directory is a collection of files

Directory Functions

opendir()

: It is used for to open directory

opendir(DIRHANDLE,"dirname");

ex: opendir(DH,"abc");

readdir():

It is used for to read files from given directory

readdir(DIRHANDLE);

ex: readdir(DH);

rewinddir():

It places pointer at the beginning of the given directory

rewinddir(DIRHANDLE);

ex: rewinddir(DH);

closedir():

It is used for to close the directory which is already opened

closedir(DIRHANDLE);

ex:closedir(DH);

mkdir():

To create a new directory

mkdir(dirname);

ex: mkdir("dirname");

chdir():

To change directory

chdir(dirname);

ex: chdir("abc");

rmdir():

To remove a directory

rmdir(dirname);

ex: rmdir("abc");

Ex:file-count.pl

#!/usr/bin/perl -w

#WAP to accept a directory and print all files and count no of file

print "\nEnter a directory name:";

chomp($dname=<STDIN>);

die "Can't open a directory. $!" unless(opendir(DH,"$dname"));

$cnt=0;

while($x=readdir(DH))

{

print "$x\n";

$cnt++;

}

print "\nTotal no of files in $dname directory: $cnt\n";

closedir(DH);

Ex:

dir-subdir-count.pl

#!/usr/bin/perl -w

#WAP to accept a directroy and count no of files and no of sub directories

print "\nEnter a directory name:";

chomp($dname=<STDIN>);

die "Can't open a directory. $!" unless(opendir(DH,"$dname"));

$fcnt=0;

$dcnt=0;

while($x=readdir(DH))

{

if(-f $x)

{

$fcnt++;

}

elsif(-d $x)

{

$dcnt++;

}

}

print "\nTotal no of files in $dname directory:$fcnt";

print "\nTotal no of subdirectories : $dcnt\n";

closedir(DH);

Ex: rem-directory.pl

#!/usr/bin/perl -w

#WAP to remove directory

print "\nEnter a dir name to remove:";

chomp($dname=<STDIN>);

rmdir($dname);

print "*******$dname directory has been deleted********\n";

Regular Expressions

Any string contains wild card character known as regular expression

Wild card characters: *, ., ?, [, ], -

t.*t à Regular expression

/t.*t/ à Pattern

The 2 binding operators are

=~ à It returns true if the given pattern found

!~ à It returns true if the given pattern not found

Wild card characters or Meta characters

1)* à It matches Zero or more occurrence of preceding character

2) + à It matches one or more occurrence of preceding character

3)? à It matches Zero or one occurrence of preceding character

4). à It matches any single character

5)[ ] à It matches any single character in the given list

6)[^] à It matches any single character other than in the given list

7)[-] à It matches any single character in the given range

8)(|) à It matches any one string in the list

9){m} à It matches exact occurrence of preceding character

10){m,n} à It matches min m occurrence and max n occurrence of its preceding character

11){m,} à It matches min m occurrence and max no limit of its preceding

12)^ à Start of the line

13)$ à End of the line

14)\d or [0-9] à Any single digit

[0-9] [0-9] [0-9] [0-9] or [0-9]{4} or \d\d\d\d or \d{4}

15)\D or [^0-9] à Any single non digit

16)\w or [a-zA-Z0-9_] à Any alphanumeric

17)\W or [^a-zA-Z0-9_] à Any non alphanumeric or special character

18)\s à ‘ ‘, ‘\t’, ‘\n’

19)\b à Word Boundary

Examples:

$str=~/perl/ à It searches the perl sting ( It will search character by character)

$str=~/\bperl/ à Word starting with perl

$str=~/perl\b/ à Word ending with perl

$str=~/^perl/ à Line starting with perl

$str=~/perl$/ à Line ending with perl

If($str=~/^perl$) à Line should contain only perl

If($str=~/^perl.*perl$/) à line starting with perl and line ending with perl

If($str=~/^$/) à blank lines

If($str=~/\b\d{4}\b/) à 4 digit number

If($str=~/\b\d{3,5}\b/) à searching 3 or 4 or 5 digit number

If($str=~/\b\w{3,5}\b/) à searching 3 or 4 or 5 digit character word

If($str=~/^\w+\s\w+\s\w+\s$/) à the line is having exactly 3 words

If($str=~/\b(2[6-9][34][0-9]5[0-5]\b/) à searching no b/w 26 to 55

If($str=~/\b\d{2}-\d{2}-\d{2}\b/) à 02-08-13

If($str=~/\b\d{2}-\d{2}-(\d{2}|\d{4}\b})\b/) à 02-08-13 or 02-08-2013

If($str=~m{\b\d{2}[-/]\d{2}[-/](\d[2]|\d{4})\b}) à 02-0-13 or 02-08-2-13 or 02/08/13 or 02/08/2013 or 02-05/13

If($str=~m{\b\d{2}([-/#])\d{2}/1(\d[2]|\d{4})\b}) à 02-0-13 or 02-08-2-13 or 02/08/13 or 02/08/2013 or 02/05/13

Substitution string by string

if($str=~s/Perl/linux/gi) à Every line all the occurrences

if($str=~s/^Perl/linux/gi) à Ever line first occurrence

if($str=~s/Perl//gi) à Replacing empty string

Translation character by character

If($str=~tr/a/t)

If($str=~tr/am/tp)

If($str=~tr/[a-z]/[A-Z]/)

PERL Predefined Functions

String Functions

1)ord():

It returns given character ASCII value

Print ord(‘a’); #97

Print ord(‘A’); #65

2)chr():

It returns given ASCII code character

Print chr(65); #A

Print chr(97); #a

3)uc():

It returns the given string in upper case

Print uc("pavan"); #PAVAN

4)lc():

It returns the given string in lower case

Print lc("PAVAN") #pavan

5)ucfirst():

It returns the given sting first character into upper case

Print ucfirst("pavan") #Pavan

6)lcfirst():

It returns the given string character into lower case

Print lcfirst("PAVAN") #pAVAN

7)length():

It returns the length of the given string

Print length("pavan") #5

8)substr("string,start,length) :

It extracts the specified portion from the string

Print substr("I like Perl",4,5); #ke pe

9) index(mainstring,substring):

It returns position of the substring in main string,

if substring not found in main string, it returns -1

print index("I like perl","perl"); #7

print index("I like perl","unix"); #-1

10) chop():

It deletes the given string last character

$str="I like perl";

chop($str);

print $str; #i like per

11) split():

It is used for to split the string into multiple values based on one or more delimiters.

$str="This is perl scripting class";

@x=split(" ",$str);

print "total elements:",$#x+1;

$str="This is,perl scripting:class";

@x=split(",| |:",$str);

Print "\n Total elements: ",$#x+1;

12) join():

It is used for to join multiple values into single string based on delimiter @num=(10,20,30,40,50,60);

$x=join(":",@num);

Print "$x"; #10:20:30:40:50:60

Array Functions:

push() :

it adds elements at end of the array

@x=(10,20,30,40);

Push(@x,50,60,70);

Print "@x"; # 10 20 30 40 50 60 70

unshift():

it adds elements at beginning of the array

@x=(10,20,30,40);

unshift(@x,50,60,70);

Print "@x"; 50 60 70 10 20 30 40

pop():

it returns and deletes last element from the array

@x=(10,20,30,40);

$k=pop(@x);

Print "The deleted element is : $k"; #40

Print "@x"; # 10 20 30

shift():

it returns and deletes first element from the array

@x=(10,20,30,40);

$k = shift(@x);

Print "The deleted element is : $k"; #10

Print "@x"; #20 30 40

sort():

it sorts given array elements in asc order

@x=qw(one two three four five);

@y=sort(@x);

Print "@y"; #five four one three two

Print "@x"; #one two three four five

reverse():

It returns elements last first from the given array

@x=qw(one two three four five);

@y=reverse(@x);

Print "@y"; #five four three two one

Print "@x"; #one two three four five

reverse(sort(@x));

splice():

It is used for to replace particular portion from the array or to append elements at end of the array

splice(@oldarray,start,length,@newarray)

@x=qw( a b c d e f);

@num=(1,2,3,4);

splice(@x,2,3,@num);

print "@x"; #a b 1 2 3 4 f

splice(@x,2,0,@num);

print "@x"; #a b 1 2 3 4 c d e f

splice(@x,2,3)

print "@x"; #a b f

Mathematical Functions

abs():

it returns absolute value

print abs(-45);#45

sqrt():

it returns square root of the given number

print sqrt(100); #10

print sqrt(abs(-100)); #10

rand:

it returns random number between 0 to 1

rand(n)

: it returns random number between 0 to n

sin(x):

it returns sin value

cos(x):

it returns cos value

tan(x):

it returns tan value

log(x):

it returns log value

Date and Time Functions

localtime():

it returns date and time

Sub Routines or User defined functions

Function is a group of statements to perform certain task and it must return a value. The main concept of function is to reduce length code of the program, easy to maintain, supports reusability, reduces cost of maintenance.

Syntax:

&functionname(arg1,arg2,……); ---- > Calling Function

-----------

-----------

-----------

-----------

Sub funcationname ---- > called function or defining function

{

-----------

-----------

-----------

-----------

}

@_ is a special variable; it holds all function call arguments

Example 1:

sub hello

{

print "\n , hello, good evening";

}

hello;

print "\n bye, have a nice day";

Example 2:

&hello; #forward reference

hello;

print "\n bye, have a nice day";

sub hello

{

Print "\n hello, good evening";

}

Example 3:

display("hello","good","evening");

sub display

{

Print "Total no of args:", $#_+1;

Print "\n @_";

}

Example 4:

sum(10,20,30);

sub sum

{

($x,$y)=@_;

Print "\n sum=$n";

}

Example 5:

sum(10,20);

sub sum

{

$x=$_[0];

$y=$_[1];

$n=$x+$y;

Print "\n sum=$n";

}

Example 6:

sum(10,20);

sub sum

{

$x=shift(@_);

$y=shift(@_);

$n=$x+$y;

Print "\n sum =$n";

}

Example 7:

$n=&sum(10,20,30);

Print "\n sum1 = $n";

$n=$sum(10,20,30,40,50,60,70);

Print "\n sum2= &n";

sub sum

{

$total=0;

foreach $k (@_)

{

$total=$total+$k;

}

Return $total;

}

Example 8:

%days=("mon"=>1,"tue"=2,"wed"=>3,"thu"=>4,"fri"=>5);

&display(%days,"sat",6,"sun",7);

sub display

{

%h=@_;

while($x,$y)=each%h)

{

Print "\n $x week day no is : $y";

}

}

Example 9:

sub sum($\$); #prototype declaration

$a=10;

$b=20;

@x=(10,20,30,40,50);

sum($a,$b); #calling function

#sum($a); - wrong

#sum($a,$b,30,40); - wrong

#sum($a,@x); - wrong

sub sum($/$) # prototype declaration

{

$x=$_[0];

$y=$_[1];

$n=$x+$y;

print "\n sum=$n";

}

Scope of variables

1)our

2)my

3)local

The default scope is our scope.

The our scope variables can be accessed any where in the program

The my scope variables can be accessed within that block only.

The local scope variable can be accessed within that function and it child functions

Example 1:

$x=100;

&f1();

&f2();

Print "\n In main, x=$x, y=$y,z=$z"; # 110,empty,empty

sub f1

{

my $y=200;

local $z=300;

print "\n In f1, x=$x, y=$y,z=$z"; # 100,200,300

$x=$x+10;

&f3();

}

sub f3

{

print "\n In f3, x=$x, y=$y,z=$z"; # 110,empty,300

&f2();

}

sub f2

{

print "\n In f2, x=$x, y=$y,z=$z"; # 100,empty,empty

}

Example 2:

use strict; #It forces the user to declare variables explicitly

use warnings;

our $count=1;

our $x=10;

while($count<=3)

{

print "$x \n";

$x=$x+10;

$count=$count+1;

}

Command line arguments

At the time of execution of perl script, if user passes any arguments known as command line arguments. @ARGV is a special variable, it holds all command line argument values

Example 1:

#perl hello.pl pavan kumar Bangalore

print "\n Total no of Args:",$#ARGV+1;

Example 2:

#perl sum.pl 10 20

$n=@ARGV;

if($n= =2)

{

my($a,$b)=@ARGV;

my $c=$a+$b;

print "\n sum: $c";

}

else

{

print "\n Invalid Arguments";

}

Example 3:

#perl copy.pl sample.txt temp.txt

$n=@ARGV;

if($n= =2)

{

$src=$ARGV[0];

$tar=$ARGV[1];

die "can’t open a source file. $!" unless(open(FIN,"<$src"));

open(FOUT,">$tar");

while($str=<FIN>)

{

print FOUT "$str";

}

print "\n File copied successfully";

close(FIN);

close(FOUT);

}

else

{

Print "Invalid no of Arguments";

}

Modules:

Module is a collection of properties (variables, methods, functions)

pakage is a keyword to create a module


pakage name and module name must be same


extension of the perl module is .pm


the perl module must register in perl/site/lib directory


module must return a true value


main concept is reusability


use and require are the keywords to import perl modules


use keyword imports perl module properties and methods at compile time


require keyword imports perl modules and methods at runtime

How to access perl properties and methods

<Module name>::<Method name>

Or

<Module name>;

$object_name=new

$object_nameà Method name