perl basics for unix administrators
DESCRIPTION
Perl scripting basics for unix administrators.TRANSCRIPT
-
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
-
Numeric and String Operators
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
-
Numeric and String Operators
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
-
Interpolation of Scalars into Strings
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
-
Interpolation of Scalars into Strings
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
-
Interpolation of Scalars into Strings
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 if/unless statement
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++;
}
-
The if/unless statement
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.
-
The if/unless statement
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 Operators and functions
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)
-
Array Operators and functions
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.
-
Array Operators and functions
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)
-
Array Element Access
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
-
Array Element Access
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
-
Array Element Access
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)
-
Array Element Access
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++}
when(/part2/){$part2++}
when(/part3/){$part3++}
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 (
asterix cleveroblix fatdogmatix dog );
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);}
} # end of not Larry
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
-
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;
Expression Modifiers
-
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.
Expression Modifiers
-
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}
Subroutines - Example
-
#!/usr/bin/perl%words = qw (
asterix cleveroblix fatdogmatix dog );
print What is your Name ?; chomp($name = );if ($name =~ /^larry\b/i ) {
print Hello, Larry!\n;} else {
print Hello, $name!\n; $passwd = $words{$name};
Subroutines - Example
-
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
} # end of not Larry
Subroutines - Example
-
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.
-
Private Variables in Functions
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
}
-
Private Variables in Functions
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.
-
Semi Private Variable using Local
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
-
Semi Private Variable using Local
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
-
Single Char. Pattern
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 (^).
-
Single Char. Pattern
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.
-
Parentheses as memory
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 ).
-
Parentheses as memory
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
-
Extracting and Replacing a substring
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.
-
Extracting and Replacing a substring
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