Chapter 9: Perl (continue) Advanced Perl Programming Some materials are taken from Sams Teach Yourself Perl 5 in 21 Days, Second Edition

Chapter 9: Perl (continue)

Advanced Perl Programming

Some materials are taken from Sams Teach Yourself Perl 5 in 21 Days, Second Edition

Announcement

• Quiz on the next class.

• Sort alphabetically (sort { $a cmp $b } @array; )

grades=(80,100,95);

foreach $grade (sort @grades) {

print "$grade\n"

} # output 100, 80, 95

• Sort numerically

foreach $grade (sort {$a<=>$b} @grades) {

print "$grade\n"

} # output 80, 95, 100

• Associative arrays%fruit = ("apples“ => 6, "cherries“ => 8, "oranges“ => 11);

$d = 2*$fruit{“apples”} +3* $fruit{“cherries”};

Advanced Perl ProgrammingObjectives

After studying this lesson, you should be able to:

• Pattern Matches

• File operations: open, read/write, close

• Use Command-Line Arguments as Values

• Define and use subroutines

Regular Expressions

• A regular expression (pattern) is a sequence of characters to be searched for in a character string. In Perl, patterns are normally enclosed in slash characters: /def/

• Match operator (=~)$result = $var =~ /def/; The result of the =~ operation is one of the following: – A nonzero value, or true, if the pattern is found in

the string – 0, or false, if the pattern is not matched

Pattern Matches

• The !~ operator is similar to =~, except that it checks whether a pattern is not matched.

• $result = $var !~ /abc/; • A program that illustrates the use of the matching operator.

#!/usr/bin/perlprint ("Ask me a question politely:\n"); $question = <STDIN>; if ($question =~ /please/) { # true if the value stored in $question

# contains the word please print ("Thank you for being polite!\n"); } else { print ("That was not very polite!\n");}

Regular Expressions * and ?

• The * special character matches zero or more occurrences of the preceding character. /de*f/ matches df, def, deef, and so on. /[eE]*/ matches the empty string as well as any combination of E

or e in any order.

• The ? character matches zero or one occurrence of the preceding character. /de?f/ matches either df or def

Regular Expressions [ ]

• [ ] special characters enable you to define patterns that match one of a group of alternatives. – For example: /d[eE]f/ matches def or dEf

• Combine [ ] with + to match a sequence of characters of any length. – For example: d[eE]+f/ matches all of the

following: def, dEf, deef, dEef, dEEEeeeEef

Regular Expressions : Escape for Special Characters

• If you want your pattern to include a character that is normally treated as a special character, precede the character with a backslash \.

• For example: – To check for one or more occurrences of * in a

string, use the following pattern: /\*+/– To include a backslash in a pattern, specify two

backslashes: /\\+/

Regular Expressions : Excluding

• When the ^ character appears as the first character after the [, it indicates that the pattern is to match any character except the ones displayed between the [ and ].

• For example, the pattern /d[^eE]f/ matches any pattern that satisfies the following criteria: – The first character is d. – The second character is anything other than e or E. – The last character is f.

Regular Expressions ^ and $

• The pattern anchors ^ ensures that the pattern is matched only at the beginning of a string. /^def/ matches def only if these are the first three characters in

the string.

• The pattern anchors $ ensures that the pattern is matched only at the end of a string./def$/ matches def only if these are the last three characters in

the string.

• What does /^def$/ mean?

Regular Expressions \b and \B

• The \b pattern anchor specifies that the pattern must be on a word boundary. – /\bdef/ matches only if def is the beginning of a word. This

means that def and defghi match but abcdef does not. – You can also use \b to indicate the end of a word. For example,

/def\b/ matches def and abcdef, but not defghi.

• The \B pattern anchor is the opposite of \b. \B matches only if the pattern is contained in a word. – /\Bdef/ matches abcdef, but not def. – /def\B/ matches defghi.– /\Bdef\B/ matches cdefg or abcdefghi, but not def, defghi, or

abcdef

• The \b and \B pattern anchors enable you to search for words in an input line without having to break up the line using split.

Regular Expressions Usages

• Conditional Matches using Regular Expressions $dataVariable =~ / please / ;

• Substitutions using Regular Expressionss/pattern/replacement/options;

$pet =~ s/\bcat\b/dog/ig ; # i: case insensitive$userinput =~ s/\n//g ; # remove the new line

characters$string =~ s/^\s+// ; # strip leading spaces from a string $string =~ s/\s+$// ; # strip trailing spaces from a string


• Pattern Matches




How Perl Accesses Disk Files

• Perl uses filehandles to reference files

• A filehandle is the name for an I/O connection between your Perl program and the operating system, and it can be used inside your program to open, read, write, and close the file

• Nearly all program functions are written to return a value that indicates whether the function was carried out successfully

File Open

Syntax: open (filehandle, filename); • filehandle represents the name you want to use in

your Perl program to refer to the file. • filename represents the location of the file on

your machine. • If open returns a nonzero value, the file has been

opened successfully. • If open returns 0, an error has occurred.

if (open(MYFILE, “test.txt")) { # here's what to do if the file opened

}

File Open Mode

Read mode: (default mode) open (FILE, "test.txt"); Enables the program to read the existing contents of the file but does not enable it to write into the file

Write mode: open (FILE, “>test.txt"); Destroys the current contents of the file and overwrites them with the output supplied by the program

Append mode: open (FILE, “>>test.txt"); Appends output supplied by the program to the existing contents of the file

Close a File

• Syntax: close (filehandle); close requires one argument: the file handle representing the file you want to close.

• Once closed, you cannot read from it or write to it without invoking open again.

Read from a File

• Syntax: $var = <filehandle>;

• A program that reads lines from a file and prints them on the screen.

#!/usr/local/bin/perl if ( open(MYFILE, “test.txt") ) { $line = <MYFILE>; # read a line from file while ($line ne "") { # loop until the end of file

print ($line); # print on the screen $line = <MYFILE>; # read a line from file

}}

close(MYFILE);

Write to a File

• Syntax: print filehandle contents;

• A program that opens two files and copies one into another.

#!/usr/local/bin/perl

open(INFILE, “test.txt") # open in read mode

open(OUTFILE, ">test.txt.bak"); # open in write mode

$line = <INFILE>;

while ($line ne "") {print OUTFILE ($line); # write into a file$line = <INFILE>;

}close(INFILE);close(OUTFILE);

A Comprehensive Example

• A program that tests whether a file exists before opening it for writing.

#!/usr/local/bin/perl unless (open(INFILE, "infile")) {

die ("Input file cannot be opened.\n");} if (-e "outfile") { die ("Output file already exists.\n");} unless (open(OUTFILE, ">outfile")) {

die ("Output file cannot be opened.\n");} $line = <INFILE>; while ($line ne "") {

print OUTFILE ($line); $line = <INFILE>;

}close(INFILE);close(OUTFILE);


• Pattern Matches




Command Line Arguments

• Perl stores the command-line arguments in @ARGV.

• $ARGV[0] contains the first argument, $ARGV[1] contains the second argument, etc

• An Example, input.pl:#!/usr/bin/perl $numArgs = $#ARGV + 1; print “You gave $numArgs command-line arguments.\n"; foreach $argnum (0 .. $#ARGV) {

print "$ARGV[$argnum], "; }

Running results:$ Input.pl 1 2 3 4You gave me 4 command-line arguments.1, 2, 3, 4


• Pattern Matches




Subroutines

• In Perl, a subroutine is a separate body of code designed to perform a particular task. A Perl program executes this body of code by calling or invoking the subroutine; the act of invoking a subroutine is called a subroutine invocation.

• Subroutines serve two useful purposes: – break down your program into smaller parts, making it easier

to read and understand. – enable you to use one piece of code to perform the same task

multiple times, eliminating needless duplication

• Definitionsub subname { statement_block }

• Invocation

&subname;

Subroutines

A program that uses a subroutine.#!/usr/local/bin/perl $total = 0; &getnumbers; foreach $number (@numbers) { $total += $number; } print ("the total is $total\n");

sub getnumbers { $line = <STDIN>; $line =~ s/^\s+|\s*\n$//g; # removes the leading and trailing white

# space (including the trailing newline)

# from the input line. @numbers = split(/\s+/, $line); }

Summery

• Regular Expressions– Conditional matches: =~. !~– Substitutions: s/pattern/replacement/options;

• File operations:

– Open: open(filehandle, filename)

– Read: $line = <filehandle>;

– Write: print filehandle $line;

– Close: close(filehandle);• Use Command-Line Arguments as Values: @ARGV


– Define: sub subname { statement_block } – Invocation: &subname;

Documents

Chapter 9: Perl (continue) Advanced Perl Programming Some materials are taken from Sams Teach Yourself Perl 5 in 21 Days, Second Edition