PERL basics for UNIX Administrators

Practical Extraction and Reporting Language

Chapter 1

Introduction to PERL

Introduction to Perl

Practical Extraction and Report Language Developed by Larry Wall Optimized for:

Scanning arbitrary text files extracting information from those text files printing Reports

Available in almost all OS platforms: UNIX, DOS, Windows and Macintosh

Current Version 5.14.2 (V6 under development) Backward compatibility

Introduction to Perl

Perl combines some of the best but simple features of c sh awk sed

Syntax corresponds quite closely to C expressions Free-format language Typically Perl program is indented much like C

Home page: http://www.perl.org The main distribution point of perl is CPAN (Comprehensive Perl

Archive Network). This archive contains all things related to perl. You can use your web browser to access CPAN at http://www.cpan.perl.org

Under the CPAN directory, youll see at least the following subdirectories. Documentation Modules Perl Source

How to get Perl

http://www.perl.org/http://www.cpan.perl.org/

Perl is both a Compiler and Interpreter

It is compiler because the program is completely read and parsed before the first statement is executed.

It is an Interpreter because there is no object code gets generated after compilation.

Basic Concepts

Basic Concepts

Shell script - a sequence of shell commands$ echo date > somescript$ echo who >> somescript$ cat somescriptdatewho$ chmod +x somescript$ somescript[output of date and who commands will be displayed]

Perl program is a bunch of perl statements and definitions thrown into a file

The first statement is #! /usr/bin/perl

Perl comments are like shell comments:# Anything from here till end of line# NO C like multiline comments

Basic Concepts

#! /usr/bin/perl -w

print (Hello, World!\n);

First Example

Chapter 2

Scalar Data

Scalar Data

A scalar is the simplest form of data used in perl.

It can be a number or a string.

Perl does not differentiate between a number and string and uses them interchangeably.

Scalar Variable

A scalar variable is a conventional variable and holds a scalar value ( a number, a string or a reference ).

The variable name begins with a $ followed by a letter or more letters or digits or underscores.

There is distinction between upper and lowercase variables. Such that $A is different from $a.

Numbers

can specify both integers and floating-point numbers perl computes only with double precision floating point

value. There is no integer in perl Perl accepts the complete set of floating-point literals like

numbers with or without decimals and exponential notations.

Octal numbers start with leading 0, and hex numbers start with leading 0x or 0X.

Therefore do not start a number with 0

Numbers

Ex. 1.25 # decimal number 7.25e12 # 7.25 time 10 to power of 12 -6.5e12 # 6.5 times 10 to the 12th power -6.65 # negative decimal number 12 12 # simple integerOctal & HexEx.

0377 # 377 octal, same as 255 decimal0xff # FF hex, same as decimal 255

Strings

Each char. is an 8 bit by default. There is nothing like NULL. String can be of any length, up to the end of memory. String literals are enclosed in single quotes or double

quotes. There is difference between single quotes and double

quotes.

Strings

In a single quote stringcharacter within the quote is legal (including \n, \t etc.) except when a quote is to be used, precede it with \ and for a backslash precede it with another backslash.

Ex.hello # simple string of five chars.don\t # quote of dont is preceded with \silly\\boy # silly\boy, the backslash is preceded with \hello\n # a string as is hello backslash and nhello # word hello a newline and word therethere

Strings

In a double quoted string the backslash specifies the control characters or any character through octal and hex representations.

Ex.hello world\n #string hello world and newlinenew \127 #new, space and the del char. In octal.coke\tsprite #coke, a tab and spritecant #cant word

Operators

Number operators :Perl provides the normal addition, subtraction,

multiplication , division and the exponentiation operators including the modulus.

Ex. 2 + 3 # 2 plus 3, or 55.1 2.4 # 5.1 minus 2.4 i.e., 2.73 * 12 # 3 times 12 = 3614 /2 # 14 divided by 2, or 710.2 / 0.3 # 10.2 divided by 0.3, or approx. 342 ** 3 # 2 to the power of 3, or 810 % 3 # 10 divided by 3 with the remainder as the

modulus , or 110.5 % 3.2 # the decimals are first converted to

integers 10 & 3 and mod is 1

OperatorsLogical comparison operator :

These are operators such as which compare two values numerically and return a true or false

String Operators :

String values can be concatenated with the . operator (period). Ex.

hello . world #same as helloworldhello world . \n # same as hello world\n

OperatorsNumeric and String comparison operators :

Separate operators for string and numbers in perl, to keep the two comparison different.

As 7 and 30 compares as 7 is less than 30 in numbers, In string 7 and 30, the 30 is less than 7 as ascii value

of 3 is less than ascii value of 7.

These comparison operators are opposite to that as used in Unix shells where eq is for numeric and = is for strings.

Numeric and String Operators

Numeric and String comparison operators :

Comaprison Numeric String

Equal = = eqNot Equal != neLess Than < ltGreater than > gtLess than or equal = ge


String repetition operator :

The repetition operator is the lower case letter x.Ex.

friend x 3 # is friendfriendfriendboy x (4+1) # is boy x 5, or

boyboyboyboyboy(3+2) x 4 # is 5 x 4, x is a string

operator, thus 5 x 4 or 5555


Operator Precedence :

Perl uses the common mathematical definition in using the precedence norm.

Those of the same precedence are in the order of left to right. You can provide your precedence by using Parentheses.

#! /usr/bin/perl -w

print What is your name? ;

$name = ;

chomp($name);

# Last two statements can be combined as:

# chomp($name = );

print Hello $name! \n;

Inputting Data from Standard Input

Conversion between Numbers and Strings

A string used as an operand for a numeric operator ( say + ) , Perl automatically converts the string to numeric.

During conversion of string to numeric trailing non-numericsand leading white spaces are ignored, thus 123.45fred converts to 123.45.

Similarly, if a numeric is used in place of a string, the numeric is converted to string.

Such as ; X . (4 * 5) # same as X . 20, or X20

Scalar operators and Functions

To assign a value to a variable, the equal sign is used.

$a = 17; # assigns 17 to variable $a$b = $a + 3; # give $b the value of $a plus 3 , (20)$b = $b * 2; # give $b the value of $b * 2 (40)

In Perl you can assign a value in an operation too, as in:

$b = 4 + ($a = 3); # assign 3 to $a, then add 4 to store result in $b

$d = ($c = 5); #assign 5 to $c and then assign $c to $d$d = $c = 5; #same as above without parenthesis

Binary assignment Operators

Instead of writing $a = $a + 5, perl makes use of binary operators to do the same. As in;

$a += 5; # same as $a = $a + 5, but with binary operator +=

$b *= 3; # same as $b = $b * 3, but with binary operator *=

$str .= K; # same as $str = $str . K, concatenates a K to value of $str

Other binary operators can be ;$a **= 3; # $a = $a ** 3$b = ($a += 4); # add 4 to $a, and assign $a to $b

Autoincrement and Autodecrement

The ++ operator (autoincrement operator) adds one to the operand, and returns the incremented value.

$a += 1; #with increment operator++$a; #same as above with prefix increment

$d = 17;$e = ++$d; # $d is incremented and assigned to $e,

both are 18 now.

Autoincrement and Autodecrement

The ++ operator to the left of the variable is the prefix operator. It can also be used on the right as the suffix operator.

In the case of suffix, the value of the expression is the old value before the variable is incremented.

Ex.$c = 17;$d = $c++; #$d is 17 and $c is 18. $c is incremented after assigning old value to $d.The -- is the autodecrement operator and functions the same as the autoincrement operator ++.

The chop and the chomp functions

The chop function takes a single argument, which must be a scalar variable, and removes the last char. From the string value of the argument.Ex. $x = hello world;

chop($x); # $x is now hello worl

The chomp function discards the newline char. of a string, only if one exits.Ex. $a = hello world\n;

chomp ($a); # $a is now hello world$b = hello world;chomp ($b) # $b is still hello world

Interpolation of Scalars into Strings

A double quoted string is subject to variable interpolation. That is, the string is checked for variable names ($ sign followed by letters, digits and underscores) and when one is found, it is replaced by its current value.Ex.$a = obelix;$b = A fat guy called $a; # $b is now A fat guy

called obelix$c = No such variable $what ; # $c is No such

variable


A string is replaced only once. So if a string has a variable which itself stores another, only one replacement takes place.Ex.$x = $name # a literal string with $ followed by word

name$y = name is $x # value of $y is name is $name : no

double substitution


Perl searches a matching variable name from the environment for the replacement. Thus if words are joined as part variable and part text, and these together exists as a variable, the variable is replaced instead.

To do so perl provides a delimiter as curly braces. You can also separate them with string concatenating operator as;Ex.

$your = its ${my}day; # result is its payday$your = its $my. day; # same as above$your = its . $my. day # same as above


Case shifting can also be used in the sting to convert cases. As;Ex.

$cname = \Uasterix #results in ASTERIX$capname = \uasterix # results in Asterix$lname = \LOBELIX # results in obelix$lowname = \lobelix # results in obelix

$name = \uganesh bhat # results in Ganesh bhat$name = \lGanesh Bhat # results in ganesh Bhat$name = \Uganesh bhat # results in GANESH BHAT$name = \LGANESH BHAT # results in ganesh bhat

\u and \l is applied only on the immediate character whereas \U and \L is applied on the entire string.

Defined ORUse ? : operator to evaluate an expression and return a value based on

whether the expression is true or false.$var1 = part1;$var2 = part2;$var3 = defined($var1) ? $var1 : $var2;

# defined function evaluates whether var1 is defined or not# returns var1 if var1 is defined else returns var2

This can also be written using a simpler operator // (available from V5.10)

$var3 = $var1 // $var2;

Inputting Data From Terminal

The in used to accept data from the terminal. Perl waits for data to be input and reads the data line up to the

newline char. (carriage return). Data read using has a newline (\n) at the end.

To get rid of it use the chomp function. As;

$a = ; # read a line of input into $achomp($a); # get rid of the \n at the end of line.

You can also use;chomp($a = );

Output with print

The print function is used to print thing out. It takes parameters and dumps them to the standard output.

Ex.print (hello world\n); # prints hello worlds followed

by newlineprint hello world\n; # same as above.

Undefined or uninitialized variables in perl have an undef value to them. This value is empty string. You get a warning with w switch on the perl call line.

Control Structures

Control Structures

A statement block is a sequence of statements, enclosed in matching curly braces.

{statement;statement;statement;

}

The if/unless statement

if (expression ) {True statement;True statement;True statement;

} else {false statement;false statement;false statement;

}The true statements are executed if the expression is true else the false statements are executed.


The control expression is evaluated for a string value If it is numeric, it is converted to string. If the value of the string is empty or 0, then the value of the

expression is false. Anything else is true.

Ex.0 # converts to 0, so false

1-1 # computes to 0, the converts to 0, so false1 # converts to 1 , so true

# Blank string, converts to false1 # not or 0, therefore true

undef # evaluates to , therefore false

The if-else statement

Ex.print how old are you ?;

$age = ;chomp($a);if ($age < 18) {

print Kid, you are not old enough to vote\n;

}

Ex.print how old are you ?;$age = ;chomp($a);if ($age < 18) {

print Kid, you are not old enough to vote\n;

} else {print Old enough. Go

vote !\n;$voter++;

}


Ex.print how old are you ?;$age = ;chomp($a);unless ($age < 18) {

print Old enough. Go vote !\n;$voter++;

}

Replace if with unless, is in effect saying, if the control expression is false do. An unless can also have an else, just like an if.


if (expression1 ) {

One_true_statement_1;

One_true_statement_2;} elsif ( expression2 ) {

two_true_statement_1;

two_true_statement_2;} else {

all_false_statement_1;

all_false_statement_2;}

If an expression is true, the corresponding branch is executed, and all remaining control expressions and blocks are skipped.

If all expressions are false, the else branch is executed, if one exists.

In perl you use elsif like a case or switch statement;

#! /usr/bin/perl wprint What is your name? ;$name = ;chomp($name);if ($name eq Larry) {

print Hello, Larry, How are you! \n; }else {

print Hello, $name!\n; }

Condition checking and comparison operators

The While/until statement

The while statement is used for iteration (repeated execution of block of statements ).

while ( expression ) {statement_1;statement_2;

}

Perl evaluates the control expression , if the result is true the body of the while statement is executed.

This is repeated until the control expression becomes false, at which point Perl goes on to the next statement after the while loop.

The While/until statement

Ex.$voter = 0;while ( $voter

The do {} while/until Statement

To test the condition at the bottom of the loop, Perl provides the do {} while statement.

Here the loop is executed at least once, and the condition is checked at the bottom.

You can invert the sense of the test by changing do {} while to do {} until.

#stop = 0;do {

$stop++;print Next stop ? ;chomp ($location = );

} until $stop > 5 | | $locatioin eq home;

do {statement_1;statement_2;

} while expression

#! /usr/bin/perl -w# Guessing a secret word$secretword = Guess;print What is your name? ;chomp($name = );print Hello $name! \n;print what is the secret word? ;chomp($guess = );# This is a while loopwhile ($guess ne $secretword) {

print Wrong, Try again. what is the secret word?; chomp($guess = );

}

Looping - Example

The for Statement

for ( initial_exp; test_exp; re-init_exp ) {statement_1;statement_2;

}

The initial_exp is executed first. This expression provides an initial value to the iterator

variable. Then the test_exp is evaluated for true or false. If the value is true, the body is executed. The re-init_exp is executed at the end of the block, which is

typically used to increment the iterator. Perl then reevaluates the test_exp, repeating as necessary.

The for Statement

Ex.for ( $i = 1; $i

Arrays and List Data

Arrays and List Data

A list is an ordered scalar data. An array is a variable that holds a list. Each element of an array is a scalar variable with a value. Arrays can have any number of elements without any limits

(available memory).

List Data

A literal list consists of comma separated values enclosed in parentheses. Ex.

(1,2,3) #list of three values 1,2 & 3(dog,10.5) # list of two values, dog and 10.5

The elements of a list can also be expressions. The expression is reevaluated each time it is referred.

($a, 17); # two values: current value of $a and 17($a+$c, $d+$e) # two expressions as values

Empty list is a pair of parenthesis as ().

List constructor operator

Two scalar values separated by two periods (..) is a list constructor operator.

It creates a list of values starting from left value up through the right value, with an increment of one.

Ex.( 1 .. 5 ) # value as 1,2,3,4,5(1.2 .. 5.2) # values as 1.2, 2.2, 3.2, 4.2, 5.2(2 .. 4, 10, 12) # values as 2,3,4,10,12($a .. $b) # range determined by current value of $a and $b

@words = (Gold, Silver, Pearl); or as @words = qw(Gold Silver Pearl);

The @ symbol is used to indicate an array and to distinguish from scalar variables $.

To access an element of an array, we use subscript as $words[0], $words[1] etc.

The subscript can be a numeric constant or an expression like $j as in $words[$j].

Arrays in Perl

Array Variables

Array variable names are similar to scalar variable names, except that the first char. $ is replaced by @.

Ex. @myarray # the array variable myarray

You can refer to the array as a whole, or as individual elements of the array.

Initializing Arrays

Assigning a literal list to Arrays@a = ( dog, cat, mouse, goat );

you can also write as@a = qw(dog cat mouse goat ) ;

The quote word function uses the space character as the delimiter.

You can also write as; @a = qw(dog catmousegoat );

#!/usr/bin/perl w@words = qw(Gold Silver Pearl);print What is your Name ?;name = ;chomp ($name);if ($name eq Larry) {

print Hello, Larry!\n;} else {

print Hello, $name!\n; print What is the Password ?\n;$pwd = ;chomp ($pwd); $j = 0; # initializing count$ok = No;

More than one secret word

while ($ok eq No) {if ($pwd eq $words[$j]) {

$ok = Yes; } elsif ($j < 2) {

$j = $j + 1;} else {

print wrong password, try again!\n;print What is the Password ?\n;chomp ($pwd = ); $j = 0;

} } # end of while not correct

} # end of not Larry

More than one secret word

Array Operators and functions

The assignment operator (=) can be used to assign a scalar value or an array.

Ex.@myarr = (1,2,3); # assigns list of 1,2,3 to a 3-elemet

array@yourarr = @myarr # an array is copied to another array

Assigning a scalar value to array variable, the array becomes a single element array

Ex.@onearr = 1; #array is single element array


Array variable names may appear in an array list, whereby the current value is used when the list is computed.

Ex.@arr1 = qw(one, two);@arr2 = (4,5, @arr1 ,6 ,7 ); # arr2 contains 4,5, one, two,

6, 7@arr2 = (@arr2, last);# arr2 now contains

(4,5,one,two,6,7,last)


A list containing only variables, not expressions, can be assigned value in the order of the assignment. As;

Ex.($a, $b, $c) = (1,2,3) #assigns values 1 to $a, 2 to

$b and 3 to $c($a, $b) = ($b, $a) # swap $a and $b($d, @arr1) = ($a, $b, $c) # gives $a to $d and ($b, $c) to array arr1

If the number of elements on the left (to be assigned) does not match the number on the right (being assigned), excess values (on the right) are dropped and excess variables(on the left) are given the value of undef.


To find the number of elements in the array, assign the array to a scalar variable. The scalar variable would then contain the number of elements in the array, as in;

@myarr = (4,5,6); #initialize array$cnt = @myarr; # $cnt will get 3, the current length

of array

Array Element Access

To access an array element, Perl uses the conventional index for subscripting.

For the subscripting function, array elements are numbered using sequential integers, from 0 and increasing by one for each element.

Like; $myarr[0], $myarr[1] and so on. The @ changes to $ when referring to an element of the array,

which is a scalar.

Array elements can be assigned or used in expressions.Ex. @fred = (7,8,9);

$b = $fred[0]; # gives the value 7 to $b$fred[0] = 11; # now fred has (11,8,9)


Other ways of accessing elements are;

$myarr[2]++; # increment the 3rd element of array myarr

$myarr[1] += 4 # add 4 to the value of the 2nd element

( $myarr[0], $myarr[1] ) = ( $myarr[1], $myarr[0] ) # swap the first two


Accessing a list of elements from the same array is called slice. There is a special representation for slice. Ex.@myarr[0,1] = @myarr[1,0]; # swap first 2 elements@myarr[0,1,2] = @myarr[1,1,1]; # make all 3 elements like the

2nd@myarr[1,2] = (9,10); # change the 2 element values to 9

and 10Indexes can also be expression that return a number. Ex.@myarr = (7,8,9);$a = 2;$b = $myarr[$a]; # like $myarr[2], or the value of 9$c = $myarr[$a 1] # like $myarr[1], or 8


Accessing beyond the end or start of array index results in an undef assignment as;Ex.

@myarr = (1,2,3);$a = $myarr[7]; # results in an undef assignment for $a

Assigning beyond the end of current array automatically extends the array, and assigns undef to all intermediate values, if any.Ex.

@myarr = (1,2,3);$myarr[4] = hi; # @myarr is now ( 1, 2, 3, undef, hi)


Assignment to an array element less than 0 is a fatal error. A ve subscript on an array counts from back to start. To get the last element you can use a subscript of 1 as ;$myarr[-1] # will return 3 from the above.

You can also use $#myarr to get the last index of array myarr. This value can also be used in making the array grow or shrink, as;

$lenarr = $#myarr; # Gives the length of array$#myarr = 2 # Redimensions array to 2 elements

preserving the 1st two elements, if any

The push and pop functions

The function push is used to add an element to the end of list pop is used to remove the last element from end of list.

Ex.push(@myarr, $newval); # same as @myarr =

(@myarr, $newval);$oldval = pop( @myarr ); # remove the last element

from myarr

The shift and unshift functions

The unshift and shift functions add/remove data to the start of the list.

Ex.@myarr = (5,6,7) ;

unshift ( @myarr ,2 ,3 ,4); # @myarr is now (2,3,4,5,6,7)$x = shift(@myarr); # $x gets 2 and @myarr is

now (3,4,5,6,7)

The reverse function

This function reverses the order of the elements of its argument.Ex.

@a = (7,8,9);@b = reverse( @a ); # gives @b the value of (9,8,7)@b = reverse (7,8,9); # same as above

The argument list is unaltered.The reverse function works on a copy.To reverse an array in place, assign it back to the same

variable.

@b = reverse (@b); give @b the reverse of itself

The sort function

The sort function takes arguments, and sorts in ascending ASCII order.

Ex.@x = sort( small, medium, large); # @x gets

large, medium, small@y = (1,2,4,8,16,32,64);@y = sort( @y ); # @y gets 1,16,2,32,4,64,8

In the last example the sorting does not take place in the numeric order, but in the string value of in ASCII order.

as an Array

The can be used with an array variable. When used with an array variable, each line input becomes an

element for the array which is terminated with a newline. Input to array can be stopped with a CTRL-Z to indicate end-

of-file or input.

Ex.@a = ; #reads standard input in a line

context

Variable Interpolation of Arrays

Array values can be interpolated in a double quoted string. A single element of an array will be replaced by its value.

Ex.@myarr = (hello, dolly);$x = This is $myarr[1]s place; # $x contains This is

dollys place$x = this is $myarr[1]; # returns this is dolly $x = this is ${myarr[1]}; # this returns correct because

of braces$x = this is . $myarr[1]; # also correct

Variable Interpolation of Arrays

A list of values from an array variable can also be interpolated. The interpolation can be the full array or part of it. The elements are interpolated with a space char. between

them.Ex.

@arr1 = (sue, sam, harry);$all = The kids @arr1 are here; # $all gets the kids sue

sam harry are hereYou can also use portion of array with a slice .Ex.

@arr1 = (sue, sam, harry, john);$all = Now only @arr1[2,3] are here; # $all gets Now

only harry john are here

The foreach statement

The foreach statement takes a list of values (array) and assigns them one at a time to a scalar variable, executing a block of code with each successive assignment.

foreach $i ( @some_list )statement_1;statement_2;

}

Here the original value of the scalar variable is automatically restored when the loop exits, as the variable is local to the loop.

The foreach statement

Ex.@a = (1,2,3,4,5);foreach $b ( reverse @a ) {

print $b;}

The output is 5,4,3,2,1. The list used in the foreach can be an

arbitrary list expression, not just an array.

You can omit the scalar variable also, and perl would use a dummy $_ variable instead and the print using this $_.

Ex.@a = (1,2,3,4,5);foreach ( reverse @a ) {

print ;}

Switch Operationuse feature qw (switch say); # feature introduced in V5.10

my @guessed_num;my $num = int (rand 100)+1;while (my $guess = ) {

chomp $guess;given($guess){

when(/\D/){say "Please enter an integer"}when(@guessed_num){say "tried already"}when($num){say "perfect"; last}when(10){say "Tired?"; last}push (@guessed_num, $_);

}}

Switch Operationuse feature switch; # feature introduced in V5.10

for each (@parts) {

when(/part1/){$part1++}



say This part is not required!;

}

# when automatically calls next at the end of its block.

Hashes

Hashes/Tables in Perl Program

A table in perl is called a hash.

A hash is like an array of scalar data

The elements are retrieved using an index called the key value.

Unlike the array, the index in a hash can be any arbitrary scalars.

The elements of an array have no particular order and access is always through the key.

You cannot control the order.

Each element of the table has a scalar value (like an array) and is referenced by a key value.

The hash is designated as % and is assigned values as:%words = qw (

asterix cleveroblix fatdogmatix dog );

Each pair of values in list represents one key and its corresponding value in the hash.

To find the word for oblix, which is the key, we can write an expression as $words{oblix}. The value referenced would be fat.

Hashes/Tables in Perl Program

Hash Variable Hash variable names are indicated by a percent sign

(%) followed by the same characters as in defining a scalar (letter, digits and underscore).

Thus $myvar and @myvar and %myvar are unrelated to one other.

To refer to an element of a hash %myvar, use

$myvar{$key} # where $key is any scalar expression.

Hash Variable To create a new element of a hash use the assignment as;

$myvar{aaa} = bbb; # creates a key aaa with value bbb

$myvar{234.5} = 456.8; # creates key 234.5 with value 456.8

Now, to access the above;

print $myvar{aaa} ; # prints bbb$myvar{234.5} += 3 # makes the value 459.8

Referencing an element whose key does not exist returns the undef value.

Literal Representation of a Hash

A hash can be accessed as a whole to initialize it or copy it to another hash.

A hash is represented as a list Each pair of elements form the key and the value. The list can be assigned into another hash, which will then

recreate the same hash.

@my_list = %myvar; # @my_list gets (aaa, bbb, 234.5, 456.8)

%newvar = @my_list; # create %newvar like %myvar%newvar = %myvar ; # using hash to create a hash%newvar = (aaa, bbb, 234.5, 456.8); # create hash from

literals

Literal Representation of a Hash

You can construct a hash with keys and values swapped using the reverse operator.

%backwards = reverse %normal;

If %normal has two identical values, those will end up as a single element in backwards.

The keys function The keys (%hashname) function lists all current keys in the

hash %hashname. If there are no elements in the hash, the keys function returns

an empty string.Ex.

$myhash{ aaa } = bbb;$myhash{ 123 } = 456.8;

@list = keys(%myhash);# @list gets (aaa, 123) or (123, aaa)

Ex.foreach $key (keys (%myhash) ) {

# once for each key of %myhashprint at $key we have data as $myhash{$key} \n;

# show key and value}

The Values function

The values (%hashname) function returns a list of all thecurrent values of the hash, in the order of the keys in the hash.

Example

%myhash = (); #force empty %myhash$myhash{one} = asterix;$myhash{two} = obelix;@lastname = values(%myhash); #grab the values

The last statement will put (asterix,obelix) or (obelix, asterix)in @lastname.

#!/usr/bin/perl w%words = qw (


print What is your Name ? chomp($name = );if ($name eq Larry){

print Hello, Larry!\n; } else {

print Hello, $name!\n; $passwd = $words{$name};print What is the Password ?\n;

Giving each person a different secret word

chomp($pwd = );while ($pwd ne $passwd) {

print wrong password, try again!\n;print What is the Password ? ;$pwd = ;chomp ($pwd);}


Giving each person a different secret word

The each function To iterate over an hash use each (%hashname) which returns

a key-value pair until all the values have been accessed.Ex.

while (( $first, $last ) = each (%lastname)) {print The last name of $first is $last\n;

}

Note: Assigning new value to the hash resets the each function tothe beginning. Adding or deleting elements of hash is likely toconfuse each.

The Delete function Perl provides the delete function to remove hash elements.

Ex.

%myhash = (aaa, bbb, 123, 455.5 ); #assign two valuesto hash

delete $myhash{aaa}; # now %myhash has only123,455.5

Hash Slices A hash can be sliced to access a collection of elements

instead of one element at a time.

$score {asterix} = 210;$score{obelix} = 215;$score{dogmatix} = 300;

This can be done better using slice as;@score{asterix, obelix, dogmatix} = (210,215,300);

We can use hash slice with variable interpolation as well.

@players = qw(asterix obelix dogmatix);print scores are : @score{@players}\n;

Miscellaneous Control Structures

Like Cs break to get out of a loop, Perl provides the last statement.

The last statement comes out of the innermost enclosing block and continues with statement following the block.

While (something) {:if (somecondition) {

:last; #break out of loop

}:

}# last comes here The last statement in the if condition terminates the while loop. The last statement counts only looping blocks, not other

blocks like if else and also the ones for do { } while/until.

The Last Statement

The blocks that count are for, foreach, while, until and naked blocks.

A naked block is a block that is not part of a larger construct such as a loop, subroutine or an if/then/else statement.

The Last Statement

Ex. To check if a mail message in a file is from merlyn.From: [email protected]: [email protected]: 01-may-09 10:30:15 AMSubject: A sample mail message

The body of the mail message.

To find if the mail message is from merlyn, we look for From line and then see if the id is merlyn.

The Last Statement

mailto:[email protected]:[email protected]

while () { # read the input linesIf (/^From: /) { # if the line begins with From :

If ( /merlyn/ ) { # if its from merlynPrint There is Email from merlyn \n;

}last; #No need to keep looking for From ; so exit

} # end if Fromif (/^$/) { # if its a blank line ?

last; # no need to check more lines}

} # end while Once the line with From is found, the main loop exits. Since the mail header ends with a blank line we exit the main

loop there as well.

The Last Statement

Ex.while ( something ) {

:if ( somecondition)

somepart;:next;

}otherpart;:# next comes here

}

The next statement causes execution to skip past the rest of the innermost enclosing looping block without terminating the block.

If somecondition is true, then somepart is executed, and otherpart is skipped.

Like last, even in next the if statement does not count as a looping block.

The Next Statement

Ex.while ( something ) {

# redo comes here:

if ( somecondition) somepart;:redo;

}otherpart;:

}

The redo construct causes a jump to the beginning of the current block ( without reevaluating the control expression ).

Like last and next, even in redo the if statement does not count as a looping block.

With redo and last and a naked block, you can have an infinite loop (redo) and exit from an intermediate point (last).

The Redo Statement

To jump out of block, or exit from two nested blocks at once, you can use last, next and redo on an enclosing block by giving it a name with a label.

The label follows the same naming conventions and is in a separate namespace.

It is better to use labels as uppercase consisting of letter and digits.

Labeled Blocks

Ex. 1SOMELABEL: while ( condition ) {

Statement;::

if ( othercondition ) {last SOMELABEL;

}}

The last statement with label as parameter, tells perl to exit the block named SOMELABEL, rather than just innermost block.

Labeled Blocks

Ex. In nested loops:OUTER: for ($i = 1; $i

Perl allows usage of an if modifier onto an expression that is a standalone statement.

Some-expression if control_expression;

Here the control_expression is evaluated first for truth value, and if true, some-expression is evaluated next. This is similar to

If ( control_expression ) {Some_expression;

}

Expression Modifiers

Ex.LINE: while {

Last LINE if /^From: /; # if 1st word is From: then exit block

}

Other variants include;

Exp2 unless exp1;Exp2 while exp1;Exp2 until exp1;


Ex.

To find first power of two greater than a given number;

Chomp($n = );$i = 1;$i *= 2 until $i > $n;print The value of power of two Greater than $n is $i \n;

Note: This form does not nest. Exp2 consists of single statement.


In statements like if this, then that, you can use logical operators && ( logical AND ) and || (logical OR).

They evaluate from left to right, for a truth statement.

In a && operator, If the left operand is false, there is no point in evaluating the right operand.

Similarly, the || operator, evaluates left operand and right, only if the left return false.

&& and || as control structures

Ex.Open (FILE, myfile) || die cannot open myfile: $!\n;

Here, the open function is evaluated. If it is successful, it proceeds with next statement. If the open fails, the die function statement prints error and terminates.

The message has the perl program name and line number. When the $! is used, it prints the full OS error also.

Similar to die, perl also has a warn, which does everything die does except terminate.

Ex.Open (FILE, myfile) || warn cannot open myfile: \n;

&& and || as control structures

Basic IO

The standard input is called STDIN.

Ex.

$a = ; # reads the next line

In a scalar form it gives one line of input or undef if there areno more lines.

The inputs can also be taken in a list rather than a scalar as;

@a = ;

Input from STDIN

Input from STDIN

Instead of taking the input to a $line variable, Perl copies theinput of to a $_ variable, as;

While () { # similar to the aboveChomp; # similar to chomp ($_) # other processings

}

You can use the $_ variable as default for many operation.

Input from Diamond Operator

This is similar to It returns a single line in scalar, until an undef. It differs from , in that the diamond operator gets

its data from a file or files, if specified on the commandline.

Ex.Suppose we have a program name kitty.pl as;

#!/usr/bin/perlwhile () {

print $_;}and you invoke perl kitty.pl file1 file2

The diamond operator reads each line of file1 followed by each line of file2, returning undef at end of all lines.

The function is like the Unix cat command

Input from Diamond Operator

The operator works with the @ARGV array. This array is a special array, initialized by the Perl

interpretor to the commmand-line arguments, Each command line arguments goes into a separate

element of the @ARGV array.

This @ARGV list can be interpreted in the program, as;

@ARGV = (aaa, bbb, ccc);while () { # process files aaa, bbb, ccc

print the line value input is: $_;}

Output to STDOUT

Perl uses the print and printf function to write to standardoutput.

The print function takes a list of strings and sends eachstring to standard output as is, in turn.

The print function returns a true (1), if the printing wassuccessful.

Print (2+3), hello; # This print 5 and ignores helloPrint ((2+3), hello); # prints 5helloPrint 2+3, hello; # prints 5hello also

Using Printf for formatted output

Similar to Cs printf to produces formatted outputs. The printf function takes a list of arguments ( enclosed in

optional parentheses). The arguments contains the format and width in quotes,

and the scalar variables to print.

Ex.Printf %15s %5d %10.2f\n, $s, $n, $r;

This prints $s in as a 15 char. String, followed by $n as adecimal integer of width 5 and $r as a floating point valuewith 2 decimal places in a 10-Char field and last a new-line.

The data for the hash is stored in a file and read from the file into a hash in the program. The program then uses this hash.

Perl program automatically gets three file handles called STDIN, STDOUT and STDERR, corresponding to three standard I-O channels.

We had earlier used STDIN handle to read data from standard input ( keyboard).

Using files in Perl

sub init_file {open (DATAFILE, datafile);while ($name = ) {

chomp ($name);$pwd = ; chomp ($pwd) ;$words{$name} = $pwd;

}close (DATAFILE);

} The subroutine for file function is called from the main program. In

the datafile the data has to be stored on separate line for name and pwd:

asterixclever

To read from a file

The Open initializes a filehandle named DATAFILE by linking it to datafile in the current directory.

Each record from the file is read and stored in scalar variables $name and $pwd in a loop. After every two reads the hash is created with the $name as key and $pwd as data.

The loop is repeated and at end of file the value returned is empty which is false for the loop and it terminates.

To read from a file

Reading a Paragraph at a time

The $/ variable controls the termination of read operation; it is set to "\n" by default.

The file handle or operator will only return one line at a time.

Set $/ variable to read a paragraph at a time. This will terminate the read on Ctrl+d.

$/ = "";

PERL Flip Flop Operator Use current input line number operator ($.) to control reading

the required lines.

while () {

print if 5 .. undef;

}

# It skips lines 1..4 then prints the rest of the file.

If either operand of scalar ".." is a constant expression, that operand is considered true if it is equal (==) to the current input line number (the $. variable).

he use of a bare number in the flip-flop is treated as a test against the line count variable, $.

PERL Flip Flop Operator

The same is not true for a scalar variable as it is not a constant expression. This is why it is not tested against $.

my $start_line = 5; while () {

print if $start_line .. undef; }

# It prints from line 1.

There are operators in Perl to return the attributes of files. The M operator returns the age in days since a file or filehandle has last been modified.

If in our example we wanted to check whether the file has been modified in the last 7 days, we need to check whether the M operator return a value >= 7 as

sub init_words {open (WORDLIST, wordlist) | | die cant open wordlist: $!;if (-M WORDLIST >= 7.0 ) {

print The file wordlist is not modified for Seven days at least;}

close ( WORDLIST ) | | die cant close file: $!;}

Checking File Attributes through Perl

Finding a file in the directory or listing files in directory using wild cards is done using a glob function. It works like , in that each time it is accessed, it returns the next value.

Sub init_words {While (defined($filename = glob(*.pwd)) ) {Open (FILELIST, $filename ) | | die cant open file: $!;If (-M FILELIST >= 7.0 ) {

Print The file is not modified for Seven days at least;}

close ( FILELIST ) | | die cant close file: $!;}

}

Using a Wild Card to List files in a Directory

Functions

Subroutines can be created and called from other places in a perl code.

A subroutine has: Name Parameters Return Value

Subroutines in Perl

Functions

A user function is called a subroutine or sub.

It is defined in a perl program as;

sub subname {Statement_1;Statement_2;Statement_3;

}

The subname is the name of the subroutine. The name does not have @ or $ or % so can have the same name as a variable or array or hash.

Functions

Ex.

Sub say_hello{Print hello, world \n;

}

Subroutines can be defined anywhere in the program However, generally they are put at the end of the file. Subroutines are global. If two subroutines have the same name, the later one

overwrites the earlier one. Generally, subroutines access global variables.

Invoking a user function

Ex.

Say_hello();$a = 3 + say_hello();for ($x = start_value(); $x < end_value(); $x +=

increment() {::

}

A subroutine can invoke another in a nested fashion.

Return Values

The return value of a subroutine is the value of the returnstatement or of the last expression evaluated in thesubroutine.

Ex.$a = 3; $b = 4;$c = sum_of_a_and_b();$d = 3 * sum_of_a_and_b();

Sub sum_of_a_and_b {return $a + $b;

}

A subroutine can also return a list of values ( multiple values ).Ex.

$a = 5; $b = 6;@c = list_of_a_and_b();

# @c gets 5 and 6

Sub list_of_a_and_b {return($a, $b);

}

Function Arguments

A subroutine invocation followed by list within parameters,is assigned to special variable @_ for the duration of thesubroutine.

Ex.

Sub say_hello_to {Print hello, $_[0]!\n; # prints first parameter

}

$_[0] is the 1st element of the @_ array. This is not the sameas $_.

Function Arguments

Less or more parameters in perl are ignored. The @_ is private to the subroutine. If there is global value for @_, it is saved away before the

subroutine is invoked and restored to previous value uponreturn to previous value.

Therefore a subroutine can pass arguments to othersubroutines without losing its own @_ values.

Ex.

$a = add(4,5,6);print add(1,2,3,4,5);print add(1..5);

Sub add {$sum = 0;

foreach $_ ( @_ ) {$sum += $_;

}return $sum;

}

The example below is for finding the validity of the password in our example. It takes the name and the password, and return true if the password is correct and false if not from the hash.

Subroutines - Example

sub pass_word {my($key, $passwd) = @_; # name the parameters$key =~ s/\W.*//; # get rid of everything after first word$key =~ tr/A-Z/a-z/; # convert to lower caseif ($key eq larry) {

return 1; } # return trueelsif ( ($words{$key} || guest) eq $passwd ) {

return 1 ; }else {

return 0; } # return false}


#!/usr/bin/perl%words = qw (


print What is your Name ?; chomp($name = );if ($name =~ /^larry\b/i ) {

print Hello, Larry!\n;} else {

print Hello, $name!\n; $passwd = $words{$name};


if ($passwd eq ) { # not found in hash$passwd = guest;

}print What is the Password ?\n; chomp($pwd = );while ( ! pass_word($name, $pwd)) {

print wrong password, try again!\n;print What is the Password ?\n;chomp($pwd = );} # end of while



Private Variables in Functions

You can create private scalar, hash or array variables withina subroutine with the my operator.

The my operator takes a list of variable names and creates alocal versions (instantiations) of them.

Ex.

Sub add {my ($sum);$sum = 0;foreach $_ ( @_ ) {

$sum += $_;}return $sum;

}

The first declaration saves the global $sum, if any, and a new variable $sum is created.

When the subroutine exits, local $sum is discarded and the global $sum is restored.

This works even in nested local versions, though you can access only one at a time.


Ex. Creating a list of all elements of an array greater than n;

sub bigger_than {my ($n, @values); # creates some local variables( $n, @values) = @_; # spilt args into limit and valuesmy ( @result ); # temporary for holding the

return valueforeach $_ ( @values ) { # step through the arg list

if ($_ > $n) { # if eligible, add itpush( @result, $_ );

}}return @result; # return final list

}


The previous sub can be used with;

@new = bigger_than(100,@list); # new gets all @list >100@this = bigger_than(5,1,5,15,20); # this gets (15,20)

You can initialize a variable at the time of declaration also as;

my($n,@values) = @_

or

my($sum) = 0;

Semi Private Variable using Local

Perl allows creation of semi private variable with the localfunction.

The my is local to the subroutine where it is declared and isnot visible outside it

local declaration causes the variable to be visible insubroutines called by the subroutine where it was originallydeclared.


Ex.$value = original;tellme();spoof();tellme();

sub spoof() {local ($value) = temporary;tellme();

}

sub tellme {print Current value is $value \n;

}

This prints;

Current value is originalCurrent value is temporaryCurrent value is original


Using my in declaration can be used for scalar, array andhash only.

Local can be used for the perls built-ins also, like $_, @_,@ARGV.

Explicit Declaration of Variables

Perl allows use of variables as and when required. However, this may cause wrong reference or assignment Therefore, it is best to declare all variables before using them. To force a variable declaration use the pragma use strict. when use strict is used at the start of program, it gives error

for any undeclared variables during compilation. Declaring a variable before using causes the perl program to

run faster and any typing error can be detected at compiletime.

Explicit Declaration of Variables

Ex.

use strict;my $a;my @b = qw(fred barney betty);push @b, qw(wilma);$c = sort @b; #Give compile error because $c is not

declared

AUTOLOAD The AUTOLOAD mechanism, built into the definition of Perl packages,

is simple to use. If a subroutine named AUTOLOAD is declared within a package, it is called whenever an undefined subroutine is called within the package. AUTOLOAD is a special name, and must be capitalized as shown, because Perl is designed that way. Don't use the subroutine name AUTOLOAD (or DESTROY) for any other purpose.

Without an AUTOLOAD subroutine defined in a package, an attempt to call some undefined subroutine simply produces an error when the program runs. But if an AUTOLOAD subroutine is defined, it is called instead and is passed the arguments of the undefined subroutine. At the same time, the $AUTOLOAD variable is set to the name of the undefined subroutine.

AUTOLOADuse strict;

use warnings;

use vars '$AUTOLOAD'; # global variable declaration

print "I started the program\n";

report_magical_function("one", "two");

print "I got to the end of the program\n";

sub AUTOLOAD {

print "AUTOLOAD is set to $AUTOLOAD\n";

print "with arguments ", "@_\n";

}

BEGINBEGIN {

print Executed at the start of the process and before any other code.\n";

}

print Programs execution sequence...\n"; die Terminate the program...\n";

END {

print " Executed at the end of the process even if there is an error in normal program sequence.\n";

}

Typeglob Variable of same name but different context can coexist at any point in

time. They all are stored together and can be accessed using one reference.

Use the variable type (context) to access them individually.

$test = "This is a new line";@test = (124, 464, "Whats the matter?");%test = (987, "First", 394, "Second");

$a1 = *test{SCALAR};$a2 = *test{ARRAY};$a3 = *test{HASH};

Regular Expressions

Regular Expressions

A regular expression ( also called template) is a pattern to be matched against a string.

The pattern can be used for replacement of a new pattern etc.

Regular expression is used by programs such as grep, awk, sed, vi etc.

Perl is a semantic superset of these.

Simple uses of regular expressions

Ex. grep:

To find all lines of a file that contain a string abc using grep as;grep abc infilename > outfilename

In perl abc is the regular expression and it is used as;

Ex.

While () {If (/abc/) {

Print $_;}

}

Here, $_ is tested against the regular expression, and if it is a match it is printed.

Simple uses of regular expressions

For an expression like ab*c , which means ab followed by any number ofcharacters between b and c.in Unix using grep;grep ab*c infile > outfile

Ex.

In perl;

While () {If (/ab*c/) {

Print $_;}

}

In perl, the regular expression has vast and flexible templates which have many operators.

Searching for a string beginning with Larry rather than exact match would be as ^Larry. Thus we can check asIf ($name =~ /^Larry/ ) {

## Yes, a match } else {

## No match }

The above can handle strings beginning with Larry, but not larry. Thus to ignore case, we use an i appended at end after the closing slash as /^larry/i .

Suppose we also want to check that the spelling is Larry and not Larryy, then we set a word boundary as \b in the expression as ;/^larry\b/i.

This means larry at the beginning of the string and no letters or digits following and any case.

String handling in Perl

To remove all the nonword char. (anything which is not a letter, digit or underscore), we use:

/\W.*/

where the \W finds the first occurrence of a nonwordand .* is for all chars upto the end of line.

Now, to replace all chars from nonword to the end of the line, we use:

$name =~ s/\W.*//;

where s is the substitute operator and the / is the delimiter specifying search string (\W.*) to be replaced with string (//).

Substituting a part of a String

The substituted strings case can now be changed by the translate operator tr as

$name =~ tr/A-Z/a-z/;

Therefore, $name =~ s/\W.*//; # gets rid of all chars after first word

and $name = tr/A-Z/a-z/; # changes string name to lowercase.

Now Larry, larry or Larry Wall all get converted to larry

Converting Case of a string

The substitute operator

This operator replaces the part of a string which matches theregular expression with another string.

It is like the s command in the vi editor.

s/ab*c/def/;

The line ( $_ ) is matched against ( ab*c ) and if the match issuccessful, the part is replaced by a new string (def).

Nothing happens if there is no match.

Patterns

A regular expression is a pattern.

Some patterns are for a single char.

Patterns are also for multiple chars.

Single Char. Pattern

A pattern-matching character class is represented by a list of characters between apair of square brackets.

Only one of these characters need to match for the pattern to match.Ex./[abcde]/ or /[aeiouAEIOU]/.

Ranges of chars. can be given with a hyphen as [0-9].

Example of patterns:[0-9\-] # matches 0 to 9 or [a-z0-9] # matches any lowercase char or digit[a-zA-Z_] # matches a-z or A-Z or underscore


Negated character class (^), is the same as a character class, but the caret(^) isimmediately after the opening bracket.

It matches any single char. that is not in the list.

Example

[^0-9] # any non digit char.[^aeiouAEIOU] # anything which is not a vowel[^\^] $ any single char which is not a caret (^).


Contruct Equivalent Class

Negated Construct

Equivalent Negated Class

\d ( a digit ) [0-9] \D (digits not! ) [^0-9]

\w ( a word) [a-zA-Z0-9_] \W (words, Not! ) [^a-zA-Z0-9_]

\s ( space char, ) [ \r \t \n \f] \S (space, not! ) [^ \r \t \n ]

The \d matches one digit. The \w one word and the \s a space char. The negated chars. are \D, \W and \S.

These abbreviated classes can be used as part of other char. classes as well; like

[\da-fA-F] # match one hex digit

Pattern Types

Grouping Patterns In groups you can say one or more of these or up to five of those etc.

Sequence In a sequence, all must be in the same order, As abc means a followed by b

followed by c.

Multipliers A multipler can be asterisk (*) indicating zero or more of the previous char. or

char. class.

A plus (+), one or more of immediately previous char., and quistion mark (?)meaning zero or one of the immidiately previous character.

Pattern Types

Ex. 1

/fo+ba?r/which is an f followed by one or more of os followed by b,followed by an optional a followed by r.

Ex. 2$_ = home xxxxxxx home;s/x+/sweet/;

Replaces all xs with sweet and results in home sweethome.

General Multipliers

To say five to Ten xs, we use general multipliers as; /x{5,10}/. The general multiplier has curly braces with one or two numbers inside. In this case

letter x must have 5 to 10 repetitions.

leaving off the second number as /x{5,}, means 5 or more. If its /x{5}/, it means exactly five xs. To get five or less use /x{0,5}/.

Now, a regular expression /a.{5}b/ is interpreted as, a separated from b by any 5non-newline chars. at a point in the string.

Now, seems you can get rid off *, + and ? as they are equivalent to {0, }, {1, } and {0,1},however it is easier to type the equivalent single punctuation character.

Parentheses as memory

Another grouping operator is a pair of brackets around apattern.

This is used to remember the part of the string matched bypattern to be stored and used later.

Example

([a]) matches an a, and ( [a-z] ) matches any singlelowercase letter.


To recall a memorized string, you must include a backslashfollowed by an integer.Ex./Asterix(.)obelix\1/;

The above example matches a string consisting of Asterix,followed by any char other than newline char. (dot is inparentheses for any char and brackets for memorizing ),followed by obelix and again any single char. ( i.e. repetition ofmemorized 1st pattern (.) indicated by \1 ).


In the previous example, the \1 indicated the first parenthesized part of a regularexpression.

If there are more than one, the second part is referred as \2, the third as \3 and soon. Counting is from left to right

Example/a(.)b(.)c\2d\1/;

Here the 1st group (.) after a is #1 and (.) after b is #2, and c is followed by repetition of#2 and d that of #1.

The refernece part can also be multi char. as;/a(.*)b\1c/;

This matches any chars after a as axxxbxxxc.

Alternation

Another grouping construct where a|b|c means a or b or c.

It can also be used for words as in /song|blue/.

However, for single class construct like /[abc]/ is definitelybetter.

Anchoring Patterns

Matching a string to a pattern generally takes from left to right, at the first possibleopportunity.

Anchors allow you to ensure pattern line up with particular parts of the string.

The \b anchor is for a word boundary.

Ex.

/fred\b/; # matches fred and not fredrick/\bmo/; # matches mo and mole, not elmo/\bfred\b/; # matches fred but not fredrick or alfred/\b\+\b/; # matches x+y but not xx or +

Anchoring Patterns

Likewise, \B requires that there be no boundary at theindicated point in the string.

Example

/\bfred\B/; matches fredrick but not fred flinstone

Anchoring Patterns

Two anchors for beginning and end of string are ^ and $. The ^ matches beginning of string.Ex. ^a matches an a if a is the first letter of the string. Whereas a\^ matches the two chars a and ^ anywhere in the string. To check for literal ^ put a backslash in front of it as \^. The $, anchors the pattern at the end of a string.Ex.c$ matches a c only if it occurs at the end of the string. A $ anywhere else is interpreted

as a scalar value. Thus to mean a literal $, precede it with \$.

Precedence of Anchors

Examples of regular expressions and effect of parenthesis

Abc* # matches ab, abc, abcc, abccc and so on(abc)* # matches , abc, abcabc, abcabcabc, and so on^x|y # matches x at the beginning of line, or y anywhere^(x|y) # matches either x or y at the beginning of a linea|bc|d # a, or bc, or d(a|b) (c|d) # ac, ad, bc or bd(song|blue)bird # songbird or bluebird

The Matching operator

The matching operator ( an expression enclosed in slashes) can be used in many ways.

The =~ Operator : This operator takes a regular expression operator on the right side,and changes the target of the operator to some value named on the left side of theoperator.

Example$a = hello world;$a =~ /^he/; # true$a =~ /(.)\1/; # also true (matches the double l)if ($a =~ /(.)\1/) { # true, so yes

: # some stuff}

The Matching operator

The target of the =~ operator can be any expression that yields some scalar string value.Ex, yields a scalar string value when used in a scalar context, so it can becombined with the =~ operator and a regular expression match operator to get a checkfor particular input, as in;

Print any last request ? ;If ( =~ /^[Yy]/) { # input beginning with a Y or y

Print What might that be ? ;;print Sorry, Unable to comply\n;

}

Ignoring Case

In the previous case we used [Yy] to match either a lower or upper case y.To match a string with ignore case, you can use /somestring/i, which will match witheither case.

Print any last request ? ;If ( =~ /^y/i) { # input beginning with a Y or y

:}

Variable Interpolation

A regular expression can be variable interpolated before it is considered for specialchars.Thus, you can construct a regular expression from computed strings rather than justliterals.

Example$what = bird;$sentence = Every bird has wings;if ($sentence =~ /\b$what\b/) { # use of variable reference for/\bbird\b/

print the sentence contains the word $what!\n;}

Special Read-only Variables

After a successful pattern match, the variables $1, $2, $3 and so on are set to samevalues as \1, \2, \3 and so on. These can be used in later code.

Example$_ = this is a test;/ (\w+) \W+ (\w+)/; # match first two words

# $1 is now this and $2 is now is

another way;$_ = this is a test;($first, $second) = / (\w+) \W+ (\w+)/; # match first two words

# $first is now this and $second is now is

Special Read-only Variables

Other predefined read-only variables are $&, which is the part that matched regularexpression

and $`, which is the part of string before the part that matched

and $ which is the part of string after the part that matched.

Example$_ = "this is a sample string";/sa.*le/; # matches "sample" within the string

# $` is now "this is a "# $& is now "sample"# $ is now " string"

Substitution

Apart from the simple substitution operator s/old-string/new-string/, there are severalvariations also.

To substitute multiple occurrences, use g at the end;

Example

$_ = "foot fool buffoon";s/foo/bar/g; # now $_ is "bart barl bufbarn"

An i before or after g, causes the regular substitute operator to ignore case.

Substitution

To have variable interpolation in the replacement string ;

Ex.

$_ = "Hello world";$new = "Goodbye";s/Hello/$new/; # replaces Hello with Goodbye

Pattern chars can be used in regular expression to allow pattern matching, rather thanjust fixed chars.

$_ = "this is a test";s/(\w+)//g; # $_ is now " "

Non Destructive Substitution

To preserve the original string and get the replaced string in a new variable, use/r

Ex.

$old = "Hello world";$new = $old =~ s/Hello/Goodbye/r;

# replaces Hello with Goodbye and stores it in $newprint $old;print $new;

This feature was released in v5.14

The Split and Join Functions

The split function is used to break a string into fields, while join is used to form a stringfrom fields.Spilt functionThe split function takes a regular expression and looks for occurrences of the expressionin the string. The parts that do not match the expression are returned in sequence as alist of values.Example$line = merlyn::118:10:randal:/home/merlyn:/usr/bin/perl;@fields = split(/:/,$line); # spilt $line, using : as delimiter

# now @fields is merlyn , , 118, 10,randal, /home/merlyn, /usr/bin/perl

Note the empty 2nd field becomes empty string.

The Split and Join Functions

Join Function

The join function takes a list of values and glues them together with the glue string intoa string.

Example

$bigstring = join($glue, @list);

To join the example of split after the split you would use;

$outline = join(:, @fields);

Other Data Transformations

Finding a string

To locate a string (substring) within a string, you can use index function. The index locates the first occurrence of the substring within the string.

Ex.

$x = index($string, $substring);

The $x returns the position of the substring within the string. Here 0 means substring is at start i.e. at position n-1, and 1 is not found.

Finding a string

Ex.$where = index(hello, e); # $where gets 1$name = barney;$where = index (fred barney,$name); # $where gets 5@rockers = (fred, barney);$where = index(join( ,@rockers),$name); #$where gets 5$which = index(a very long long string, lame); # $which gets 1

To get the 2nd occurrence instead of the 1st, use the third parameter of index, which is the start posn.

$x = index($string, $substring,$startpos);Ex.$which = index(a very long long string, long, 9); #$which gets

12

Finding a string

You can do a reverse search using rindex. The search starts from the right side, but the position returned is from left.

Example

$where = rindex(hello world, l); # $where gets 9 forrightmost l

$where = rindex(hello world, o); # $where gets 7 forrightmost o

$where = rindex(hello world, o,6); # $where gets 4 forfirst o before 6

Extracting and Replacing a substring

The substr function is used to pull out a part of a string from a string. The substr function takes three arguments. A string value, a start position (1st pos is 0 or pos-1 is the start pos ) and a length

(which can be longer than remaining chars in string).

Ex.

$s = substr($string, $start, $length);

$hello = hello;$s = substr($hello, 3,2); # $s gets lo$s = substr($hello, 3,200); # $s gets lo


In perls substr function, the $start argument can be ve. In case it is negative, the position is counted from the end of the string. -1 for start posn is the last char of the string.

$s = substr($hello, -3,2); # $s gets ll$s = substr($hello, -1,1); # $s gets o

If the start is big ve number (greater than length of string), the start posn. defaults to the beginning i.e. 0.

Omitting the legth is same as including a large length, or up to the end.


To replace a substr, you can have the substr in the left side of an expression as;

$hw = hello world;substr($hw, 0,5) = howdy; # replaces hello with howdy

Here the chars returned by substr function are removed and the assigned chars ( onright ) are substitued in place.

The length of string being assigned (right side) is immaterial as in;$hw = hello world;substr($hw, 0,5) = hi; # replaces hello with hi

Advanced Sorting

The sort function earlier sorted a list in ascending ASCII order. In perl you can decide what kind of sort you want, descending order, numeric order,

or any general order. Sort order is specified by how two elements compare to each other.

The comparison routine is a standard subroutine. This subroutine is called repeatedly with two elements of the list to be sorted. The subroutine returns one of three values; If First < Second then return 1, If First = Second then return 0 If First > Second then return 1.

The two values are passed as $a and $b.

Advanced Sorting

Here, the comparison is your comparison, only the return values are fixed. It can be any logic which you choose and this makes the perl sort so flexible.

Ex. Sorting in Numeric orderSub by_number {

If ($a < $b) {Return 1;

} elsif ($a == $b) {Return 0;

} elsif ($a > $b) {Return 1;

} }

Advanced Sorting

In ordinary sort ;

@somelist = (1,2,4,8,16,32,64,128,256);@outlist = sort @somelist; # @outlist is now

(1,128,16,2,256,32,4,68,8)

Using sort with our subroutine;

@outlist = sort by_number @somelist;# outlist is now (1,2,4,8,16,32,64,128,256)

Advanced Sorting

Since, numeric comparison is quite common in sort, perl has a special operator to do this called the spaceship operator ().Using this the earlier by_number subroutine can be written as;

Sub by_number {$a $b;

}

In fact instead of writing as ;@outlist = sort by_number @somelist;

You can now write as ;@outlist = sort { $a $b} @somelist;

Advanced Sorting

Just as the spaceship operator is for numeric comparison, perl has a stringcomparison char cmp.

To sort a hash on names which contains ids as keys and names as values.

@sortedkeys = sort by_names keys(%names);

sub by_names {($names{$a} cmp $names{$b} ) || ($a cmp $b ); # return cmp on ids

# if names are same}

Directory Access

Changing Directory

Similar to cd command in MS-Dos and Unix to move around the directories, perl used chdir function.

The chdir function takes a single argument/expression evaluating to a directory name, to which the current directory will be set.

chdir returns true when you have successfully changed to the requested directory, and false if not.

Example 1

chdir(/usr/bin/perl) || die cannot change directory :$!);

Example 2

Print Enter directory to change to ?;chomp ($where = );If (chdir($where)) {

Print new directory is $where;} else {

print cannot change to $where;}

The chdir function without parameter defaults to your home directory.

Changing Directory

Asterisk (*) is the wild card char used to indicate a list of files. The expansion of * into a list of matching filenames is called globbing. Like /etc/host* means all files that begin with host in the /etc directory. Perls globbing is by putting the * in a pair of angled brackets or to use the

function glob.Ex. @a = ;@a = glob(/etc/host*);

The glob returns a list of all names that match a pattern or an empty list.

Globbing

Ex.To look at one name at a time;

While ( defined($nextname = )) {Print listed file is $nextname\n; # dir path is included in

$nextname$nextname =~ s/.*\\//; # removes part before last

back slashprint listed file is $nextname\n; # only name is printed}

glob function can have multiple patterns inside, which are constructed separately and finally concatenated as one list.

@fred_barney_files = ;

Globbing

Ex.

If (-d /usr/etc) { # if dir /usr/etc exists$where = /usr/etc;

} else {$where = /etc;

}@files = ;

Globbing

If your OS provides the readdir library function, or its equivalent, perl provides access to it using directory handles.

Directory handles are names in separate namespace and have the same general restrictions.

Thus a filehandle FRED and a directory handle FRED are unrelated. The directory handles is a connection to a particular directory which you use to

read a list of filenames within the directory. Directory handles are read only.

Note : if your OS does not support readdir, then action with directory handle will resultin a fatal error.

Directory Handles

The opendir function takes a name for the directory handle and a string value ofthe directory to open.

It returns true or false.

Ex.

opendir(ETC, /etc) || die cannot opendir /etc: $!;

To close a directory handle;closedir(ETC);

Opening and Closing a Directory Handle

The readdir function uses a directory file handle to read a list of file names.Each invocation of readdir returns the next filename, in no particular order.

Ex.

opendir (ETC, /etc) || die no etc ? $!;foreach $name (sort readdir(ETC)) {# sorted list context

Print $name\n; # prints filename}closedir (ETC);

Reading from a Directory Handle

The unlink function of perl is used to delete one or more files. This is similar to Unix rm command.

Ex.

unlink (fred); # deletes file named fredunlink (myfile, yourfile); #deleting multiple filesunlink (*.c); # multi files delete with wildcard

Print Enter a file name to delete !;Chomp($name = );unlink $name;

Removing a File

The return value of unlink is the number of files successfully deleted. unlink does not specify which files were deleted In group delete, you have to delete individually in a loop and report failed

deletions as;Ex.Foreach $file () { # step through a list of files

unlink ($file) || warn cannot delete file $file: $!;}

unlink with no arguments, the $_ variable is used as a default. Ex.Foreach () { # step through a list of files

unlink || warn cannot delete file $_: $!;}

Removing a File

The Unix mv command to rename a file is done in perl using the rename($old,$new).

Examplerename (fred, barney) || die cannot rename fred to barney: $!;

Rename returns true if successful. To rename a file from one directory to another;

rename(file, some-dir/file);

Renaming a File

Similar to the Unix mkdir command to create a directory, Perls equivalent is alsomkdir function.

Perls mkdir function takes the name of the directory and mode for thepermissions of the directory to be created.

Ex.mkdir (mydir, 0777) || die cannot create directory mydir: $!;

The Unix command rmdir to remove a directory, is the same name used in perl as a function.

Ex.Rmdir (mydir)|| die cannot remove directory mydir: $!;

Making and Removing Directories

Permissions on a file or directory, uses the chmod function, The chmod takes an octal number for mode and a list of filenames.Ex.chmod (0666, fred, barney); #makes files fred and barney

read/write for all The value 0666 is read/write for user, group and other. The return value of chmod is the number of files successfully adjusted.Octal Value & Meanings;

4 - Read2 - Write1 - Execute

Modifying Permissions

The chown function is used to change the owner and group and works in the same manner as unlink and chmod.

The chown takes as parameters for UID, GID, and files names.

Ex.

Chown (1234, 35,fred,barney); # changes files fred and # barney to belong to

# uid 1234 of group 35.

Modifying Permissions

Packages and Modules

References

References are like Pointers in C

A Reference is a Scalar Variable that holds the address of a Variable or Function

There are various ways to Create References in Perl Using the \ operator Creating a reference to an unnamed Array Creating a reference to an unnamed Hash Creating a reference to an unnamed Subroutine Creating a reference to an unnamed Scalar

References

USING THE \ OPERATOR$a = 10;$scalar_ref = \$a; # Gives the Reference to $a.

@arr = (1, 2, 3, 4);$array_ref = \@arr; # Gives the Ref to Array

%hash = ("Apples", 10, "Bananas", 20);$hash_ref = \%hash; #The Ref itself is still a Scalar

$sub_ref = \&mySub; # Gives a Ref to mySub.sub mySub {

print("Hello World");}

References

CREATING A REFERENCE TO AN UNNAMED ARRAY$array_ref = [1, 2, 3, 4]; $new_ref = [] # Ref to an empty Array

CREATING A REFERENCE TO AN UNNAMED HASH$hash_ref = {1, 2, 3, 4, 5};$new_ref = {} # Ref to an empty Hash

References

CREATING A REFERENCE TO AN UNNAMED SUBROUTINE$sub_ref = sub # Same here. No SubName given. Just a Ref.{

print "Hello World" ;}

CREATING A REFERENCE TO AN UNNAMED SCALAR$scalar_ref = \"Hello World"; THIS IS A CONSTANT IN PERL

Using a Reference

Scalar$a = 10;$scalar_ref = \$a;print($$scalar_ref);

Array@arr = (1, 2, 3, 4);$array_ref = \@arr;print(@$array_ref); The First @ stands for De-reference as an ARRAY

Using a Reference

Hash%hash = ("Apples", 10, "Bananas", 20);$hash_ref = \%hash;print(%$hash_ref); The First % stands for "Deref as a HASH

Subroutine$sub_ref = \&mySub; # Gives a Ref to mySub&$sub_ref("Hello", "World"); # The & stands for "Deref as CODEsub mySub {

($a, $b) = @_; # 2 parametersprint("$a, $b");

}

Objects

Objects are Special Modules and Modules in turn are Reusable Packages

The idea of Packages comes from the implementation of Symbol Tables in Perl

A Symbol Table of a Perl Program contains a list of all Global Variables and 'Functions' Declared or Defined in the Program

Symbol Table

Each Package in Perl has its own Private Symbol Table

The Default Package is main and its Symbol Table is available using the Hash %main:: (%packagename::)

Change the current package using the statementpackage package_name;

This shifts the context of your application to the new package and program can access only the symbols available in package_name

To switch back to main package usepackage main;

Symbol Table

foreach $element(keys %main::)

{

print "$element \n"; # Will print all the Symbols available.

}

Creating Modules

Reusable Packages are Created through Perl Modules

Perl Modules are .pm files with the same name as the Package

package myPackage; SAVE THE FILE AS myPackage.pmAND YOU HAVE A PERL MODULE In this module you can create Variables and Subroutines which can then be

used by another Perl Program

Set an environment variable PERL5LIB to locate PERL modules

Creating Modules

# myModule.pmpackage myModule;require Exporter; # Need Exporter Module to help Export Symbols

@EXPORT = ('$sally', 'mySub'); # No var Substitution here!!@EXPORT_OK = ('$harry');@ISA = (Exporter);

$sally = 'Met Harry';$harry = 'Met Sally';sub mySub {

print("When Harry met Sally");}

Using the Module

In Perl a Module can be used in two ways The Module Exports Symbols (Functions and Variables) to the outside world The outside world use's OR require's the Module

use myModule;

print $sally; # This one's been EXPORTED TO %main::&mySub; # This one too...

Using the Module

require myModule;

myModule->import('$sally', '$harry', 'mySub');

print $sally; # Explicitly Imported.

&mySub; # Explicitly Imported.

print $harry; # Explicitly Imported.

Using the Module

If your Module does not Export any Symbol then the User of your Module can still use the Subroutines in your Module using the Module::subname() syntax

Moment you say require Module OR use Module A reference of the Module's Symbol Table (Module::) is added to your

Symbol Table

Hence Exporting and Importing is relevant only for ensuring that we don't have to type module::symbol and can use symbol directly

Database Access

Database Access Introduction

Three ways of Connecting to Database Using DAO object model Using ODBC Using OLEDB Provider

Data Access Objects (DAO)

use DBI; # Module DBI$ConnObj = DBI->connect('dbi:ODBC:source_db', 'sa', '');$sth = $ConnObj->prepare("SELECT au_fname, au_lname FROM authors

WHERE au_lname LIKE ?");$sth->bind_param(1, 'R%');$sth->execute();while(@array = $sth->fetchrow_array()) {$fname = $array[0];

$lname = $array[1];print "$fname, $lname \n";

}

Open Database Connectivity (ODBC)

use Win32::ODBC;$db = Win32::ODBC->new("DSN=source_db;UID=sa;PWD=");$sql=SELECT au_fname, au_lname FROM authors WHERE au_name=" .

$name;$db->Sql($sql); # Sql Function Executes the SELECTwhile($db->FetchRow()) {

$fname = $db->Data('au_fname');$lname = $db->Data('au_lname'); print "$fname, $lname \n";

}$db->Close();

Object Linking and Embedding (OLEDB)

use Win32::OLE; # Module Win32::OLE$ConnObj = Win32::OLE->new("ADODB.Connection");

# Create Object$ConnObj->open(source_db_conn'); # Open Connection$sql = "SELECT au_fname, au_lname FROM authors";$RstObj= $ConnObj->Execute($sql);while(!$RstObj->EOF()) {

$fname = $RstObj->Fields('au_fname')->Value(); $lname = $RstObj->Fields('au_lname')->Value();print "$fname, $lname \n";$RstObj->MoveNext();

}$RstObj->close();$ConnObj->close();

Installing CPAN Modules First, identify the module to be installed by searching for it in

CPAN site using CPAN Index

Using the PPM command, install the module

Verify using PPM GUI interface

Search for Module in CPAN

PPM GUI

PPM Command to Install a Module

Verify Module After Installation

Chapter 12

Common Gateway Interface (CGI)

Introduction

HTTP server works on Request/Response mechanism

Normally, HTTP server sends the document (Response) to the Browser when the client requests for it

To execute the file on the server, instead of just sending, application extension (MIME type) must be registered

For CGI applications, MIME type is application/cgi

Environment

Common Gateway Interface is a protocol not a language

As part of the CGI Protocol, the Server will set up all CGI Variables as Environment Variables

STDOUT of the CGI Application is redirected to the Socket of the Client's Connection

In the CGI application: %ENV contains information about the Request Use print function to send the Response to the Browser

Request

The client can use GET or POST method to submit the Request The form contents will be appended to URL in Get method The form contents will be sent as stream to the server in POST method

If the Request method is POST then the Query String is not available in the Env Variable; instead it is available at the STDIN

Request

For GET method:If the URL for a file request is

http://user45/Test.pl?fname=Ganesh&age=26&telno=234234 $ENV{QUERY_STRING} => fname=Ganesh&age=26&telno=234234 $ENV{REQUEST_METHOD} => GET/POST

For POST method: Use read(STDIN, $noofbytes, $qs, 0); to extract the query string information since

query string does not terminate with \n You can get the no of bytes from CONTENT_LENGTH ENV Variable

Response

CGI program must generate the output in HTML format so that Browser can interpret and print

Every Response has two parts The response header (which must compulsorily have at least one header

"Content-type:") Followed by a blank line (this separates the header from the body) The HTML Body (content of HTML Document)

Example

print Content-type : text/html\n\n;

print ;

print $ENV{QUERY_STRING} ;

print $ENV{REQUEST_METHOD} ;

@arr = %ENV ;

foreach $val(@arr){

print $val, \t ;

}

print ;

Thank You.

Practical Extraction and Reporting LanguageIntroduction to PERLIntroduction to PerlIntroduction to PerlSlide Number 5Slide Number 6Basic ConceptsSlide Number 8Slide Number 9Scalar DataScalar Data Scalar VariableNumbersNumbersStringsStringsStringsOperatorsOperatorsOperatorsNumeric and String OperatorsNumeric and String Operators Numeric and String Operators Slide Number 24Conversion between Numbers and StringsScalar operators and Functions Binary assignment OperatorsAutoincrement and AutodecrementAutoincrement and AutodecrementThe chop and the chomp functionsInterpolation of Scalars into StringsInterpolation of Scalars into StringsInterpolation of Scalars into StringsInterpolation of Scalars into StringsDefined ORInputting Data From TerminalOutput with printControl StructuresControl Structures The if/unless statementThe if/unless statementThe if-else statementThe if/unless statementThe if/unless statementSlide Number 45The While/until statementThe While/until statementThe do {} while/until StatementSlide Number 49The for Statement The for Statement Arrays and List DataArrays and List DataList DataList constructor operatorSlide Number 56Array Variables Initializing ArraysSlide Number 59Slide Number 60Array Operators and functions Array Operators and functions Array Operators and functions Array Operators and functions Array Element AccessArray Element AccessArray Element AccessArray Element AccessArray Element AccessThe push and pop functionsThe shift and unshift functionsThe reverse functionThe sort function as an ArrayVariable Interpolation of ArraysVariable Interpolation of ArraysThe foreach statementThe foreach statementSwitch OperationSwitch OperationHashesHashes/Tables in Perl ProgramHashes/Tables in Perl ProgramHash Variable Hash Variable Literal Representation of a Hash Literal Representation of a Hash The keys functionThe Values functionSlide Number 90Slide Number 91The each functionThe Delete functionHash SlicesMiscellaneous Control StructuresSlide Number 96Slide Number 97Slide Number 98Slide Number 99Slide Number 100Slide Number 101Slide Number 102Slide Number 103Slide Number 104Slide Number 105Slide Number 106Slide Number 107Slide Number 108Slide Number 109Basic IOSlide Number 111Input from STDINInput from Diamond OperatorInput from Diamond OperatorOutput to STDOUTUsing Printf for formatted outputUsing files in PerlTo read from a fileTo read from a fileReading a Paragraph at a timePERL Flip Flop OperatorPERL Flip Flop OperatorChecking File Attributes through PerlUsing a Wild Card to List files in a DirectoryFunctionsSubroutines in PerlFunctionsFunctionsInvoking a user functionReturn ValuesFunction ArgumentsFunction ArgumentsSubroutines - ExampleSubroutines - ExampleSubroutines - ExampleSubroutines - ExamplePrivate Variables in FunctionsPrivate Variables in FunctionsPrivate Variables in FunctionsSemi Private Variable using LocalSemi Private Variable using LocalSemi Private Variable using LocalExplicit Declaration of VariablesExplicit Declaration of VariablesAUTOLOADAUTOLOADBEGINTypeglobRegular ExpressionsRegular Expressions Simple uses of regular expressionsSimple uses of regular expressionsString handling in PerlSubstituting a part of a StringConverting Case of a stringThe substitute operatorPatternsSingle Char. PatternSingle Char. PatternSingle Char. PatternPattern TypesPattern TypesGeneral MultipliersParentheses as memoryParentheses as memoryParentheses as memoryAlternationAnchoring PatternsAnchoring PatternsAnchoring PatternsPrecedence of AnchorsThe Matching operatorThe Matching operatorIgnoring CaseVariable

PERL basics for UNIX Administrators

Documents

Transcript of PERL basics for UNIX Administrators