CS 898N – Advanced World Wide Web Technologies Lecture 8: PERL

1. CS 898N – Advanced World Wide Web Technologies Lecture 8: PERL Chin-Chih Changchang@cs.twsu.edu

2. Perl – Statements (Loop) • Loop statements: • while (expression) {statements} • until (expression) {statements} • do {statements} while (expression) • while (expression) {statements} • until (expression) {statements} • do {statements} while (expression)

3. Perl – Statements (Loop) • do {statements} until (expression) • for (initial value; test condition; increment) {statements}; • foreach $scalar (@array) {statements}; • There are several statements that modify the sequence of loop execution when placed inside the loop. These include last, next, and redo.

4. Perl – Statements (Loop) • There are several statements that modify the sequence of loop execution when placed inside the loop. These include: • last breaks out of the loop that contains it. • next skips the remainder of the loop and start at the next increment. • redo goes back to the start of the loop without incrementing. • These statements are usually part of an if or else clause.

5. Perl – Statements (Loop) • When you have a loop within another loop the last, next, and redo statements by default apply to the innermost loop. • They can apply their action to an outer loop if that loop has a label. • The following code shows the power of these statements.

6. Perl – Statements (Loop) LOOP: while (expression) do { statements if (condition) { last } POOL: until (expression) do { if (condition) { next LOOP } statements

7. Perl – Statements (Loop) for ($I = 0; $I < $j; $I++) { if (condition) { redo POOL } if (condition) { next } statements; } } }

8. Perl – Statements (Subroutines) • Subroutines are defined with the subsubname statement. • Subroutines can be called in either of two ways: • prefixing the subroutine name with an & sign as in &subname. • subname() call format. • Subroutines can return values so that subroutine calls can be used in assignment statements, as in $string = subname ()

9. Perl – Statements (Subroutines) • Take the following Warp Drive Calculator as an example: $traveltime = &warpdrive; $triptime = warpdrive(); sub warpdrive { $warpfactor = 2 ** ($warp – 1); $traveltime = ($distance / $warpfactor) * 365.25; return $traveltime }

10. Perl – Regular Expressions • An expression is a group of symbols that gives a result. • Regular expressions in Perl are used for pattern matching. • Regular expressions can be used in two types of statements: assignment and comparison. • There are three components to a statement with a regular expression:

11. Perl – Regular Expressions • The regular expression is usually contained in a forward slash // symbol pairs or m followed by the preferred symbol, for example, /target/ and m!target!. • The source string is the string that will be searched for the expression. regular expression. • If the statement is a comparison, pattern matching will return a true or false result. • If the statement is an assignment, the source string will have pattern matched substrings found in the string.

12. Perl – Regular Expressions • The operator binds the source string to the regular expression. • Only the =~ match operator can be used in an assignment statement. • Both the =~ match operator and the !~ not-match operator can be used in comparison statements. • The following match operator is a string replacement. $value =~ tr/+/ /;

13. Perl – Regular Expressions • The following line is using not-match operator to skip lines that begin with a comment mark. if ($string !~ /^#/) {.. Statements ..} • These are Perl pattern matching options: • abc : match the character string “abc”. • . : match any character except newline. • a? : match zero or one instance “a”. • a+ : match one or more repetitions of “a”.

14. Perl – Regular Expressions • a* : match zero or more repetitions of “a”. • a{2} : match exactly two repetitions of “a”. • a{2, 4} : match between two and four repetitions of “a”. • a{4,} : match four or more repetitions of “a”. • ^ : match beginning of line, e.g., /^#/. • $ : match end of line, e.g., /money.$/. • [a-b] : match any character within the range a to b.

15. Perl – Regular Expressions • [abcde] : match any character within the brackets. • [^a-b] : match any character except those in the range a to b. • [^abcde] : match any character except those within the brackets. • a|b : match a or b. • \ : match the next character literally. • \d : match any digit. Same as [0-9]. • \D : match any nondigit. Same as [^0-9].

16. Perl – Regular Expressions • \s : match any space character including newline, tab, return, and form feed. Same as [\n\t\r\f]. • \S : match any non-space character. • \w : match any word character including letters, numbers, and underscore. Same as [0-9a-zA-Z]. • \W : match any non-word character.

17. Perl – Regular Expressions • The amount of complexity that can result leaves many programmers scratching their heads to try and figure out what kind of string the writer was trying to match. • The principle is to keep it simple and write comments. • Perl statements that use pattern matching include substitution and transliteration.

18. Perl – Regular Expressions • The substitution statement directly replaces instances of pattern matching with the substitution string and is formatted as s/regular expression/substitution string/options. • This substitution statement globally replaces all + signs with a space. $value =~ s/\+/ /g;

19. Perl – Regular Expressions • The transliteration statement is a simpler version that searches for expressions on a character-by-character basis and replaces them with the respective characters in the substitution string. • Each character can be represented by a regular expression. This statement is formatted as tr/characterlist/characterlist/options.

20. Perl – Regular Expressions • This substitution statement globally replaces all + signs with a space. $value =~ tr/+/ /g; • The substitution and transliteration statements take following pattern matching options: • /e : evaluate right side as an expression • /i : ignore case in the search string. • /g: replace globally, find all matches.

21. Perl – File Operations • The basic Perl file function is contained in the diamond operator <>. This acts on a file to read in the next line. • The default file is STDIN. So the operator alone, as in $line = <>, will return a line from STDIN. • The diamond operator returns a string up to and including the line terminator which is different among systems.

22. Perl – File Operations • For example, “test” is not equal to “test\n”. chop() is used to remove the last character of a string and chomp() is used to remove the last character only if it’s a newline. • The basic Perl file function is contained in the diamond operator <>. • Basic Perl file operations are open, <>, print, and close. • When opening a file in Perl, a filename is associated with a file handle.

23. Perl – File Operations • The file handle is the only data type in Perl that has no preceding symbol. • It is suggested that such data types, which include labels and file handles, are given uppercase names to avoid conflicts with future modifications to the Perl language. For example, if you have a file handle “data” and Perl comes out with a function “data”, your script will become defunct.

24. Perl – File Operations • There are three ways to open files: for input, output, and to append data to an existing file: • Input: open (FILE, “<inputfile”); • Output: open (FILE, “>outputfile”); • Append: open (FILE, “>>biggerfile”); • The lines in the following code open a file for input, read the lines into an array, close the file, and trim the newlines.

25. Perl – File Operations • The default open method is input. • The array combined with the diamond operator reads in the entire file automatically. $filename = “data.txt”; open(FILE, “$filename”); @lines = <FILE>; close(FILE); chomp(@lines);

26. Perl – File Operations • In the situation that the script cannot open a file, the die () function can be used. • The die () function operates off the fact that Perl evaluates the results of an open statement to a Boolean value. We can use logical statement structure to create a error handling. • The following statements are all equivalent.

27. Perl – File Operations open (FILE, “$filename”) || die “Unable to open $filename” unless open (FILE, “$filename”) { die “Unable to open $filename” } die “Unable to open $filename” unless open (FILE, “$filename”) • Die will print whatever is passed to it plus a system error message and then exit the script.

28. Perl – File Operations • To exit with a message you can either use “exit 0” or die “\n” where the newline prevents the system error message from being printed. • Another way to control file input in a loop is to use the while ($line = <FILE>) control loop. • There are functions for directory: • opendir() – open a directory.

29. Perl – File Operations • closedir() – close a directory. • readdir() – read a directory. • chdir() – change the directory. • The following statements would open a directory, read the first file, change to the directory, and then open that file. opendir (DATADIR, “/www/home/database”); $nextfile = readdir (DATADIR); closedir (DATADIR)

30. Perl – File Operations chdir (“/www/home/database”); open (FILE, $nextfile); • Before opening a file, you might want to make sure if it’s really a file and not a directory or something else. • For this purpose, Perl supports a number of testing functions, all in the format: If (-flag filename)

31. Perl – File Operations • These are some file test flags: • -d : if file is a directory. • -e : if file exists. • -s : if file exists, returns file size. • -z : if file exists but is zero size. • -T: if file is a text format file. • -B: if file is a binary format file.