Exercise Solutions. Chapter 1. Chapter 2 APPENDIX. #!/usr/bin/perl -w # chap01ex1. pl. print "Hi Mom.\nThis is my second program.

Size: px

Start display at page:

Download "Exercise Solutions. Chapter 1. Chapter 2 APPENDIX. #!/usr/bin/perl -w # chap01ex1. pl. print "Hi Mom.\nThis is my second program."

Hollie Moody
6 years ago
Views:

APPENDIX Exercise Solutions This appendix contains the answers to the chapter exercises. An important note: each solution is an answer, not the answer.

$\nThis is my second program.\n"; Chapter 2 1. # chapo2ex1.$

1 APPENDIX Exercise Solutions This appendix contains the answers to the chapter exercises. An important note: each solution is an answer, not the answer. Remember that in Perl, there is more than one way to do it, and that applies to these solutions as well. Chapter 1 1. # chap01ex1. pl print "Hi Mom.\nThis is my second program.\n"; Chapter 2 1. # chapo2ex1.pl print "Currency converter\n\n"; print "Please enter the exchange rate: "; chomp(my $yen= <STDIN>); print "Enter first price to convert: "; chomp(my $price1 = <STDIN>); print "Enter second price to convert: "; chomp(my $price2 = <STDIN>); 385

2 386 APPENDIX EXERCISE SOLUTIONS print "Enter third price to convert: "; chomp(my $price3 = <STDIN>); print "$price1 Yen is ", ($price11$yen), " dollars\n"; print "$price2 Yen is ", ($price21$yen), " dollars\n"; print "$price3 Yen is ", ($price31$yen), " dollars\n"; 2. #!lusrlbinlperl -w # chap02ex2.pl print "enter a hex number: "; chomp(my $hexnum = <STDIN>); print "converted to an int: ", hex($hexnum), "\n"; print "enter an octal number: "; chomp(my $octal = <STDIN>); print "converted to an int: ", oct($octal), "\n"; 3. #!lusrlbinlperl -w # chap02ex3.pl print "enter a value less than 256: "; chomp(my $bin = <STDIN>); print((128 & $bin) I 128); print((64 & $bin) I 64); print((32 & $bin) I 32); print((16 & $bin) I 16); print((8 & $bin) I 8); print((4 & $bin) I 4); print((2 & $bin) I 2); print((1 & $bin) I 1); print "\n";

3 APPENDIX EXERCISE SOLUTIONS (6 I 4) - (3 * 5) + 1 ~ ((-3 ** 3) I 2) = (3 A (4 * 2)) : 37 ((4 + 3) >= 7) II (2 && ((4 * 2) < 4)) = 1 Chapter 3 1. #!lusrlbinlperl -w # chap03ex1. pl my $target = 12; print "Guess my numberl\n"; print "Enter your guess: "; my $guess; while ($guess = <STDIN>) { 2. if ($target == $guess) { print "That's it! You guessed correctlyl\n"; last; elsif ($guess > $target) { print "Your number is more than my number\n"; elsif ($guess < $target) { print "Your number is less than my number\n"; print "Enter your guess: "; #llusrlbinlperl -w # chap03ex2.pl for (my $i = 1; $i <= 10; $i++) { print "$i square is: ", $i*$i, "\n";

4 388 APPENDIX EXERCISE SOLUTIONS 3. # chap03ex3.pl for (my $i = 1; $i <= so; $i++) { if ($i % s == o) { print "$i is evenly divisible by 5\n"; Chapter 4 1. # chap04exl.pl = (2, 4, 6, 8); foreach (@a) { print "$_ ** 2 = ", $_ ** 2, "\n"; foreach { print "$_ ** 2 = " -,, $ ** 2 "\n" 3. Here is a program that illustrates the answer to this question. # chap04ex3.pl = ( 'a a'. ' bb' ) ; print "first array:\n"; print "@a\n";

5 APPENDIX EXERCISE SOLUTIONS = (' ao' ' bg' ) ; print " \n"; print "second array:\n"; print "@a\n"; Chapter 5 1. # chap05ex1.pl my %hash = ( scalar => 'dollar sign', array => 'at sign', hash => 'percent sign' ); foreach (sort keys %hash) { print "$_: $hash{$_\n"; 2. # chap05ex2.pl my %phonenumbers = John => ' ', Sue => ' ', Larry=> ' ', Moe => ' ' ); print "enter name: "; while (<STDIN>) { chomp; if (exists $phonenumbers{$ ) { print "$_has the phone number: $phonenumbers{$_\n";

6 390 APPENDIX EXERCISE SOLUTIONS else { print "$_is not in the phone book\n"; print "enter name: "; 3. # chaposex3.pl my %jokes = Java =>"None. Change it once, and it's the same everywhere.", Python => "One. He just stands below the socket and the world " "revolves around him.", Perl => "A million. One to change it, the rest to try and do it in " "fewer lines.", C =>'"CHANGE?!!"' ); print "enter programming language: "; while (<STDIN>) { chomp; if (exists $jokes{$_) { print "How many $_ programmers does it take to change a lightbulb?\n ; sleep 2; print $jokes{$_, "\n"; else { print "That language is not funny. \n"; print "enter programming language: "; Chapter 6 1. # chapo6exl.pl print "enter a number: "; chomp(my $input_num = <STDIN>);

7 APPENDIX EXERCISE SOLUTIONS 391 if {$input_num < o) { print "please enter a positive numberl\n"; else { my $result = factorial{$input_num); print "$input_num! = $result\n"; sub factorial { my $num = shift; if {$num == o) { return 1; else { my $answer = 1; foreach (2 $num) { $answer = $answer * $_; return $answer; # here is the solution using recursion - # a recursive function is a function that calls # itself sub factorial_recursive { my $num = shift; if {$num == o) { return 1; else { return $num * factorial_recursive{$num - 1); 2. # chap06ex2.pl my $number_of_seconds; prompt_user(); my ($hours, $minutes, $seconds) = secs2hms($number_of_seconds);

8 392 APPENDIX EXERCISE SOLUTIONS print "$number_of_seconds seconds is $hours hours, $minutes " "minutes and $seconds seconds"; print "\n"; sub prompt_user { print "please enter the number of seconds: "; chomp($number_of_seconds = <STDIN>); sub secs2hms { my ($h,$m); my $seconds = shift;; # defaults to $h = int($seconds/(6o*6o)); $seconds %= 60*60; $m = int($seconds/6o); $seconds %= 60; ($h,$m,$seconds); Chapter 7 1. Match "hello" followed by zero or more and any character but \n followed by "world"; or, in other words, any string that contains "hello" followed later by "world". Match one or more digits at the beginning of the string followed by one whitespace character followed by zero or more word characters followed by the end of the string. Match an uppercase letter at the beginning of a word followed by zero or more lowercase letters to the end of a word; or, in other words, match a word that begins with an uppercase letter followed by any number of lowercase letters. Match a character, remember it in \1, followed by any number of any characters but \n, followed by the character remembered. In other words, match any string with two occurrences of the same character. 2. /"\d.* \d$/ /"[\s\w]+$1 /"\5*$/ 3. # chap07ex3.pl

9 APPENDIX EXERCISE SOLUTIONS 383 while ( <>) { print if /[aeiouy][aeiouy]/i; 4. # chap07ex4.pl while (<>) { print if fa[aaeiouy]*[aeiouy][aaeiouy]*[aeiouy][aaeiouy]*$/i; Chapter 8 1. # chapo8ex1.pl open(infh, '<', 'gettysburg. txt') or die $1; open(outfh, '>', 'exlout.txt') or die $1; while (<INFH>) { next if fa\s*$1; = split; print OUTFH "$_\n" close INFH; close OUTFH; 2. # chapo8ex2.pl unless (@ARGV) = qw(filel.dat file2.dat file3.dat); print <>;

10 394 APPENDIX EXERCISE SOLUTIONS 3. # chapo8ex3.pl my $target; while (1) { print "What file should I write to? "; $target = <STDIN>; chomp $target; if (-d $target) { print "No, $target is a directory.\n"; next; if (-e $target) { print "File already exists. What should I do?\n"; print "(Enter 'r' to write to a different name, "; print "'o' to overwrite or\n"; print "'b' to back up to $target.old)\n"; my $choice = <STDIN>; chomp $choice; if ($choice eq "r") { next; elsif ($choice eq "o") { unless (-o $target) { print "Can't overwrite $target, it's not yours.\n"; next; unless (-w $target) { print "Can't overwrite $target: $!\n"; next; elsif ($choice eq "b") { if (-e "$target.old") { print "Backup $target.old exists. Overwrite it? [yin] "; my $choice = <STDIN>; chomp $choice; if ($choice ne 'y') { next; if ( rename($target, $target.".old") ) { print "OK, moved $target to $target.old\n";

11 APPENDIX EXERCISE SOLUTIONS 395 else { print "Couldn't rename file: $!\n"; next; else { print "I didn't understand that answer.\n"; next; last if open(output, '>', $target); print "I couldn't write to $target: $!\n"; # and round we go again. print OUTPUT "Congratulations.\n"; print "Wrote to file $target\n"; close OUTPUT; Chapter 9 1. # chap09ex1. pl open(fh, '<', 'exl.dat') or die$!; while (<FH>) { my $name = substr $_, o, 24; my $address = substr $_, 25, 18; my $city = substr $_, 52, 20; my $state = substr $_, 72, 2' my $zip = substr $_, ' 75, 5; print <<EOT; Record: name address city $name $address $city

12 396 APPENDIX EXERCISE SOLUTIONS state zip EOT $state $zip close FH; 2. # chap09ex2.pl while (<>) { tr/a-za-z/n-za-mn-za-m/; print; Chapter # chaploexl.pl my $dir =shift II ''; my $size= shift I I ''; die "usage: ex1.pl <din <size>\n" unless $dir and $size; chdir $dir or die "can't chdir: $!"; # first, a file glob # this gets hidden files too print "using glob:\n"; foreach (<.* *>) { if (-f $_and -s _ >= $size) { print 1 1, $_, 1 1 X (30 - length($_)), -s _, "\n",

13 APPENDIX EXERCISE SOLUTIONS 397 # now using a directory handle print "\n\nusing directory handle:\n"; opendir DH, I. I or die "opendir failed: $!"; while {$_ = readdir(dh)) { if (-f $_and -s _ >= $size) { closedir DH; print I ~,$_,I I x (30- length($_)), _,, -s "\n" Chapter #1/usr/bin/perl -w # chap11ex1. pl = qw(r N B Q K N B R); foreach (0.. 7) { $chessboard[o]->[$j = "W". $back[$_]; #White Back Row $chessboard[1]->[$j = "WP"; #White Pawns $chessboard[6]->[$j = "BP"; #Black Pawns $chessboard[7]->[$_] = "B". $back[$_]; # Black Back Row while (1) { # Print board foreach my $i (reverse (0.. 7)) {#Row foreach my $j (0. 7) { #Column if (defined $chessboard[$i]->[$j]) { print $chessboard[$i]->[$j]; elsif ( ($i % 2) == {$j % 2) ) { print".. "; else { print " "; print " "; # End of cell print "\n"; # End of row

14 398 APPENDIX EXERCISE SOLUTIONS print "\nstarting square [x,y]: "; my $move = <>; last unless ($move=~ fa\s*([1-8]),([1-8])/); my $startx = $1-1; my $starty = $2-1; unless (defined $chessboard[$starty]->[$startx]) { print "There's nothing on that square!\n"; next; print "\nending square [x,y]: "; $move = <>; last unless ($move=~ /([1-8]),([1-8])/); my $endx = $1-1; my $endy = $2-1; # detect if a piece is about to be taken if (defined $chessboard[$endy]->[$endx]) { print "\n$chessboard[$endy]->[$endx] at (", $endx + 1,,, $endy+1, ") is being taken!\n\n"; # Put starting square on ending square. $chessboard[$endy]->[$endx] = $chessboard[$starty]->[$startx]; # Remove from old square undef $chessboard[$starty]->[$startx]; 2. # chap11ex2.pl = qw(r N B Q K N B R); foreach (0.. 7) { $chessboard[o]->[$_] = "W". $back[$_]; # White Back Row $chessboard[1]->[$_] = "WP"; # White Pawns $chessboard[6]->[$_] = "BP"; #Black Pawns $chessboard[7]->[$_] = "B". $back[$_]; # Black Back Row while (1) { # Print board foreach my $i (reverse (0.. 7)) {#Row foreach my $j (0.. 7) { #Column

15 APPENDIX EXERCISE SOLUTIONS - if (defined $chessboard[$i]->[$j]) { print $chessboard[$i]->[$j]; elsif ( ($i % 2) == ($j % 2) ) { print~~. ~~; else { print II II; print II II; # End of cell print \nll; 11 # End of row print 11 \nstarting square [x,y]: "; my $move = <>; last unless ($move=- /A\s*([1-8]),([1-8])/); my $startx = $1-1; my $starty = $2-1; unless (defined $chessboard[$starty]->[$startx]) { print "There's nothing on that square 1\n"; next; print "\nending square [x,y]: "; $move = <>; last unless ($move=- /([1-8]),([1-8])/); my $endx = $1-1; my $endy = $2-1; if (defined $chessboard($endy]->[$endx]) { # can't take your own piece if (substr($chessboard($endy]->[$endx], 0 1 1) eq substr($chessboard($starty]->($startx], o, 1)) { print "\nyou can't take your own piecel\n\n"; next; # can't take a king if ($chessboard[$endy]->[$endx].~ /K/) { print "\nyou can't take a kingl\n\n"; next; # Put starting square on ending square. $chessboard[$endy]->[$endx] = $chessboard[$starty]->[$startx]; # Remove from old square undef $chessboard[$starty]->[$startx];

16 400 APPENDIX EXERCISE SOLUTIONS 3. # chap11ex3.pl my %addressbook; sub menu { print «EOT; Please make a choice: 1 add an entry 2 view an entry 3 view all entries 4 delete an entry 5 exit Your choice: EOT sub add_entry { print "Enter name: "; chomp(my $name = <STDIN>); if (exists $addressbook{$name) { print "Name alread exists in the address book!\n"; print "Address: "; chomp(my $address = <STDIN>); print "Phone: "; chomp(my $phone= <STDIN>); $addressbook{$name = { address => $address, phone => $phone ; sub view_entry { print "Enter name to view: "; chomp(my $name = <STDIN>); if (exists $addressbook{$name) { print "Address: $addressbook{$name{address\n"; print "Phone: $addressbook{$name{phone\n\n";

17 APPENDIX EXERCISE SOLUTIONS 401 else { print "$name is not in address book!\n\n") sub view_all { foreach my $name (sort keys %addressbook) { print "Name: $name\n"; print "Address: $addressbook{$name{address\n"; print "Phone: $addressbook{$name{phone\n\n"; sub delete_entry { print "Enter name to delete: "; chomp(my $name = <STDIN>); if (exists $addressbook{$name) { delete $addressbook{$name; else { print "$name is not in address book!\n\n"; while (1) { menu(); chomp(my $answer= <STDIN>); SWITCH: { $answer == 1 and add_entry(), $answer == 2 and view_entry(), $answer == 3 and view_all(), $answer == 4 and delete_entry(), $answer == 5 and exit(o); Chapter # chap12ex1. pl use Person&; last SWITCH; last SWITCH; last SWITCH; last SWITCH;

18 4lrl APPENDIX EXERCISE SOLUTIONS my $object1 = Person8->new( lastname => "Galilei", firstname => "Galileo", address occupation phone_no => => => "9.81 Pisa Apts.", "bombadier", " " ); my $object2 = Person8->new( last name => "Wall", firstname => "Larry", address => "123 Perl Ave.", occupation => "Programmer", phone_no => " " ); my $object3 = Person8->new( lastname => "Torvalds", first name => "Linus", address => "593 Linux Ave.", occupation => "Programmer", phone_no => " " ); print "There are ", Person8->headcount(), PersonS objects\n"; foreach my $person (Person8->everyone()) { print "\n", '-' x 80, "\n"; $person->printletter("you owe me money. Please pay it."); Chapter # chap14ex1.pl use CGI ':standard'; print header(), start_html('exercise 1');

19 APPENDIX I EXERCISE SOLUTIONS 403 if (param) { my $name = param('name') II ''; my $address= param('address') I I ''; my $phone = param('phone') II ''; print h1('thanks for your information!'), 'Thanks for entering the following information:', br(), $name, br(), $address, br(), $phone; open FH, '>>', '/tmp/ex1.dat'; print FH - x 80, "\n$name\n$address\n$phone\n"; close FH; else { print 2. print h1('please enter some information'), start_ form(), 'Name:, textfield(-name => 'name'), br(), Address:, textarea(-name => 'address', rows => 3), br(, 'Phone number:, textfield(-name => 'phone', br(), submit(), end_ form(); end html(; The solution to this problem is to include the changes shown previously in the section for Chapter 11, exercises 1 and 2.

20 404 APPENDIX EXERCISE SOLUTIONS Chapter # chap1sex1. pl use DBI; my($instrument, $musician); print "Enter instrument: "; chomp($instrument = <STDIN>); my $dbh = DBI->connect("DBI :mysql :musicians_db", "musicfan'!, "CrimsonKing"); die "connect failed: ". DBI->errstr() unless $dbh; # use a table join to query the instrument names my $sth = $dbh->prepare("select musicians.name FROM musicians,what_they_play,instruments WHERE instruments.instrument =? AND musicians.player_id = what_they_play.player_id AND what_they_play.inst_id = instruments.inst_id") or die "prepare failed: ". $dbh->errstr(); $sth->execute($instrument) or die "execute failed: ". $sth->errstr(); # loop through them, printing them while (($musician) = $sth->fetchrow()) { print " $musician\n"; $sth->finish(); $dbh->disconnect(); 2. # chap15ex2.pl use CGI ':standard'; use DBI;

21 APPENDIX EXERCISE SOLUTIONS - if (param()) { my $instrument= param('instrument') I I ''; print header(), start_html("musicians who play $instrument"); hl("musicians who play $instrument"); my $dbh = DBI->connect("DBI:mysql:musicians_db", "musicfan", "CrimsonKing") ; my $sth = $dbh->prepare("select name FROM musicians, what_they_play, instruments WHERE instruments.instrument =? AND instruments.inst_id = what_they_play.inst_id AND what_they_play.player_id = musicians.player_id") or die "prepare failed: " $dbh->errstr(); $sth->execute($instrument) or die "execute failed: " $sth->errstr(); my($name); while (($name) = $sth->fetchrow()) { print "$name plays the $instrument.<br>"; print end_html; else { print header(), start_html('my Favorite Instrument'), hl('select an Instrument', start_ form(), '<select name="instrument">'; my $dbh = DBI->connect("DBI:mysql:musicians_db", "musicfan", "CrimsonKing"); my $sth = $dbh->prepare("select instrument FROM instruments") or die "prepare failed: " $dbh->errstr(); $sth->execute() or die "execute failed: ". $sth->errstr(); my($instrument); while (($instrument) = $sth->fetchrow()) { print qq{<option value="$instrument">$instrument</option>;

22 406 APPENDIX EXERCISE SOLUTIONS print '</select>', br(), submit('show musician(s)'), end_ form(), end_html();

Index Symbols! (not) Boolean operator, 30!=(not equal to) comparison operator, 28! - (negated regex match) operator, 35 patterns not matching, 151 #(comments), 3 documenting programs, 6 #!

special variable file error, openo function, 178, 179 $#array array's last index, 95 $array accessing single array elements, 92 $_(special variables), 44 default value, 217 $1 special variable

23 Index Symbols! (not) Boolean operator, 30!=(not equal to) comparison operator, 28! - (negated regex match) operator, 35 patterns not matching, 151 #(comments), 3 documenting programs, 6 #!(hash bang), 3 $ (anchor to end) escaping metacharacters, 155 $ (scalar variables) assignment(=) operator, 37 scalars, 37 $prefix naming conventions, 111 $! special variable file error, openo function, 178, 179 $#array array's last index, 95 $array accessing single array elements, 92 $_(special variables), 44 default value, 217 $1 special variable controlling buffering, 193 %prefix naming conventions, 111 & (AND) bitwise operator, 25 && (and) Boolean operator, 29 &sub_routine declaring subroutines in Perl4, 133 * (asterisk) escaping metacharacters, 155 repetition with quantifiers, 163 **(exponentiation) operator assignment(**=) operators, 39 + (plus sign) escaping metacharacters, 155 repetition with quantifiers, 163 -> (infix dereference) arrow operator ${$ref-> arrow notation, 239 matrices, 242 methods, 255 references in references, 239. (period) escaping metacharacters, 155 pattern matching at end of string, 156 I (forward slash) character regular expressions, (zero) definitions of false, 27 =(equals) assignment operator $(scalar variables), 37 ==(equals equals) comparison operator, 27 not assignment operator(=), 37 numeric comparison operators, 54 =- (regex match) operator, 35 counting character occurrences, 210 finding patterns, 151 translating a string, 210 => (list separator) operator, 35 creating hashes, 112 dynamic CGI program, 335 named parameters, 146? (question mark) escaping metacharacters, 155 repetition with quantifiers, 162 ::(colons) translating into directory separators, array prefix character see under arrays [] square brackets escaping metacharacters, 155 patterns, 158 references to anonymous arrays, 232 modifying referenced array, 238 \ (backslash character) escape sequences, 17 double quoted string, Wmdows, 178 escaping metacharacters, 155 operators, 35 \ (reference of) operator creating reference for existing variable, (anchor), (XOR) bitwise operator, 26 II negating character class [], 158 _(underscore) default filehandle for file tests,

24 - (backquote) character backquotes,225,226 { curly brackets escaping metacharacters, 155 hashes, 114 references in references using -> shorthand, 239 references to anonymous arrays modifying referenced array, 237 references to hashes, 238 anonymous hashes, 232 repetition with quantifiers, 164 statement blocks, 7 subroutines, 128 I (OR) bitwise operator, 26 either-or operator, Regex, 161 I character escaping metacharacters, 155 pipes, 194 II (or) Boolean operator, 30 - (NOT) bitwise operator, 26 <(less-than) comparison operator, 28 < (read mode) open() function, 180 <=> spaceship comparison operator, 29 «(left shift) operator, 35 <>(diamond) see diamond(<>) > (greater-than) comparison operator, 28 > (write mode) open() function, 180» (append mode) open() function, 181» (right shift) operator, 35 A \a (alarm) escape sequence, 8 <a> tags CGI.pm module generating, 327 a() method CGI.pm module, 327 providing attributes for, 330 abstraction encapsulation,256,257 accessor methods methods, 271 Person class, 282 shift() function, 272 action= attribute CGI scripts processing form data, 331 addition(+) operator, 22 assignment(+=) operator, 39 address book example, trees, 247 adding another level, 249 deleting data, 249 extracting data, 249 making new entries, 248 printing out data, 248 alarm (\a) escape sequence, 8 alphabetical order finding character's ASCII value, 33 anchors common errors writing Regexes, 174 patterns, 155, 156 AND (&) bitwise operator, 25 AND keyword WHERE clause, 361 and (&&) Boolean operator, 29 anonymous arrays accessing referenced array, 234 actual memory location, 235 creating reference to, 232, 234 anonymous data references creating. 230 anonymous hashes creating reference to, 232 anonymous references counting. 242 Apache configuration troubleshooting CGI scripts, 318 creating CGI directory, 316 errorlogffie troubleshooting CGI scripts, 318 append mode (») open() function, 181 arguments, 21 open() function, 177 parentheses 0 for, 7 arguments, subroutines, 133 default values, 145 named parameters providing, 146 named parameters, 145 passing arrays as, 144 passing by reference, 141 passing into subroutines, passing lists, 143 stopping functions modifying, 142 $ARGV special variable, 188 arithmetic operators, 22 array functions, 104 pop() function, 105 push() function, 105 reverse() function, 104 shift() function, 107

25 409 sort() function, 108 unshift() function, 107 arrays, $#array, 95 $array, prefix character, 87 naming conventions, array, 186 command line arguments, 186 diamond(<>), 186, 187 displaying array contents, 186 mehandles, writing to rues, 191 my() function, 186 passing arguments into subroutines, 136 push() function, 188 shift() function, 143, 187 storing into variables, 186 use strict statement, accessing multiple elements, package variable, array, 262 changing, 263 lib pragma, using, 264 require statement using, passing arguments into subroutines, 133 accessing data in referenced, 239 accessing multiple elements, 97 accessing single elements, 91 using [] to identify, 92 adding elements to, 91 array elements accessing in anonymous array, 236 array functions, 104 array index, 93 array slice accessing multiple elements, 97 assigning in scalar context, 90 assigning values, 87, 112, 113 counting occurrences in hash, 123 declaring arrays, 88 double-quoted strings, 89 foreach loop, 68, 99 hashes assigning values from, 113 assigning values to, 112 compared, 111 lists, 87 looping through, 95 left to right, 97 naming conventions, 87,111 print() function, 89 references to accessing data in, 240 anonymous arrays, 232 Regexes, common errors writing, 174 stacks, 105 ASCII value finding character's ASCII value, 34 assignable lists, 86 assigning values arrays, 87 hashes, 112 lists, 78 assignment (=, +=,...) operators $(scalar variables), 37 autodecrement (--)operator, 39 autoincrement (++)operator, 39 multiple assignments, 41 operator precedence, 38 associative arrays see hashes attributes action= attribute, 331 class attributes, 273 creating classes naming/ storing attributes, 267 described, 254 get-set methods, 273 providing attributes for classes, 269 providing for CGI.pm methods, 330 a() method, 330 autodecrement ( ) operator, 39 auto increment ( ++) operator, 39 autovivification automatic creation of references, 243 chessboard example, matrix, 244 B \b (word boundaries) pattern matching, 160 \b (backspace) escape sequence, 8 backquotes C) character, 225, 226 backreferences Regular expressions, 165, 174 backslash character escape sequences, 17 double quoted string, Wmdows, 178 escaping metacharacters, 155 operators, 35 backspace (\b) escape sequence, 8 bareword warning, 16 base class see superclass Benchmark module standard modules, 302 bidirectional pipes piping in and out of a process, 198 binary numbers, 15 conversion to strings, 20,21 errors using, 16 binary system, 9

26 410 INDEX bits, 9 bitwise operators, 24 AND(&) operator, 25 NOT H operator, 26 OR (j) operator, 26 significance of bits, 25 XOR (A) operator, 26 blank line after header troubleshooting CGI scripts, 318 bless() function blessing again, 267 creating classes, 265 syntax, 265 blocks statement blocks, 7 body, subroutines, 130 Boole, George, 27 Boolean logic, 27 if statements, 53 Boolean operators, 29 and(&&) operator, 29 not (!) operator, 30 operator, 30 xor (exclusive or) operator, 30 boundaries, words pattern matching, 160 breaking the loop looping constructs, 71 buffering controlling output, 193 controlling using $1, 193 bugs, lo Bunce, Tim, 365 bundles c Bundle::libnet, 312 Bundle::LWP, 31i documentation, 312 CPAN module helping download, 311 detecting package dependencies, 311 canonpath() function File::Spec module, 301 case sensitivity i for insensitive, 153 MySQL server, 352 pattern matching, 153 catdir() function File::Spec module, 301 catfile() function File::Spec module, 301 CGI (Common Gateway Interface), creating CGI directory, 316 generating HTML, 320 processing form data, 330 webserver access, 316 writing CGI programs, 316 exported environment variables, 319 hello world program, 317 CGI scripts, 315 chessprogram, developing CGI script with DBI, dynamic CGI program, 333 example, 334 param() method, 332, 333 start_form() method, 335 textfield() method, 335 environment variables displaying,319,320 exported, 319 generating HTML web page with CGI.pm, 324 without CGI.pm, 322 state, 335 static CGI program, 332 troubleshooting perlmonks website, 318 why use Perl, 315 writing, 316 blank line after header, 317,318 hello world program, 317 permissions, 317 troubleshooting, 318 CGI.pm module, 322 example using, 326 generating <a> and <p> tags, 327 method types, 329 methods a() method, 327 calling methods, 328 dynamic CGI program using, 335 generating more than one tag, 329 generating one tag, 330 header() method, 326 invoking, 329 named parameters, 329 po method, 327 print() function, 328 start_html() method, 326, 329 processing form data, 322 tags, generating, 326 CGI::Carp module chess CGI program, 344 character classes [] negating, 158 patterns, 158 predefined character classes, 159 sequences of characters, 159 characters escaping metacharacters, 155 chdir() directory function, 219 chess CGI program, 335

27 411 chessboard example, matrix, 242 autovivification, 244 making moves, 244, 247 printing checkered effect, 246 setting up board, 244, 246 chmod command, 4 chmod() directory function, 222 chomp() function passwords, 57 standard input <STDIN>, 47 user/runtime specified patterns, 155 while loop, 66 chop() function standard input <SID IN>, 48 class attributes, 273 Person class, 282 classes attributes, providing for classes, 269 constructors, 268 creating, 264 bless() function, 265 constructors, 268 get -set methods, 273 inheritance, 269 ref() function, 265 storing attributes, 267 described, 255 inheritance, 256 instances, 255 interfaces, 256 methods, 255 methods, creating, 271 class attributes, 273 get-set methods, 273 privatizing methods, 277 utility methods, 279 naming conventions, 256 objects, 255 constructors, 257 destructors, 258 static data, 255 static methods, 255 subclass, 257 superclass, 257 close() FTP method, 261 close() function, 178 Cohen, Max patterns, 149 columns see fields comma operator (arguments), 35 command line interface (Cil), MySQL, 352 commands capturing output using backquotes, 225 flexible use of command line arguments, 298 commands, list of CREATE DATABASE, 353 CREATE TABLE, 353 DELETE, 382 DESCRIBE, 354 GRANT,354 INSERT,355 mysqlshow, 351 REPLACE, 383 SELECT,358 UPDATE,382 USE,353 comments,3 documenting programs, 6 comparison operators, 27 equals(==), 27 greater-than(>), 28 less-than(<), 28 not equal to(!=), 28 spaceship operator ( <=>), 29 string comparisons, 33 true or false, 27 complex data structures using references for, 242 matrices, 242 trees, 247 concatenation (.) operator assignment(.=) operators, 39 concatenation string operator, 31 concurrency relational databases, 347 conditional operators if... else statements, 58 if... elsif statements, 59 if statements, 52 introduced, 35 logical operators, 58 unless statement, 61 connect() method, DBI module, 366 constants, 13 constructors class constructors, 257 creating classes, 268 described, 257 Person class, 282 content type CGI scripts generating HTML, 320 troubleshooting CGI scripts, 318 conversions octal, hex and binary; 20 strings and numbers, 20 rules, 33 Conway, Damian Object Oriented Perl, 253

28 412 INDEX counting hashes,122,197 CPAN (Comprehensive Perl Archive Network), 305 accessing CPAN shell, 309 CSPAN confusion, 258 detecting package dependencies, 311 modules, finding to installihg, 308 installing manually, 308 installing with PPM, 307 modules available at, 287 search engine, 306 standard module doesn't exist, 312 using existing modules, 306 CREATE DATABASE command, 353 CREATE TABLE command, 353 curly brackets { escaping metacharacters, 155 hashes, 114 references in references, 239 references to anonymous arrays, 237 references to hashes, 238, 232 repetition with quantifiers, 164 statement blocks, 7 subroutines, 128 currency conversion program, 46 current directory, 262 cwdo FfP method, 260 D d file test, 199 -doption debugging, 10 /dmodifier removing spaces in strings, 210 \d (digit 0-9) predefined character classes, 159 \D (any nondigit) predefined character classes, 159 data data patterns, Regexes, 149 data types, 13 extracting from MySQL database, 358 reference count, 241 data structures using references for complex, 242 visual representation of, 295 database commands CREATE DATABASE, 353 CREATE TABLE, 353 DELETE,382 DESCRIBE, 354 GRANT,354 INSERT,355 REPLACE, 383 SELECT, 358 UPDATE,382 USE,353 database handler DBI connecto method, 366 databases creating a database, 352 extracting data from, 358 indexing, 383 Data::Dumper module choosing output variable name, 296 standard modules, 295 DBD (Database Driver) modules DBI (Database Independent) module, 365 DBD::mysql module installing, 365 DBI (Database Independent) module, 347, 365 database handler, 366 DBD (Database Driver) modules, 365 developing CGI script with, DSN (data source name), 366 executing SQL query with DBI, 367,369 installing, 365 joins, 374 methods connecto method, 366 disconnecto method, 367 errstro method, 367 executeo method, 368 fetchrowo method, 368 finisho method, 368 prepareo method, 368 Perl connecting to MySQL, 366 placeholders, 372 state handler, 368 debugging visual representation of data structures, 296 declaring subroutines, 128, 130 default values subroutine arguments, 145 definedo function if statements, 57 definite loops, 63 del command (Wmdows), 220 DELETE command, 382 deleteo FfP method, 260 deleteo hash function, 120 removing elements from hash, 114 delimiters Regexes changing, 170 choosing your own, 19 dereferencing accessing data in references, 233, 234 assigning values to references, 241 undefcommand,242

29 413 derived class, 257 DESC (descending) qualifier ORDER BY clause, 362 DESCRIBE command, 354 destroy() method object destruction, 281 destructors described, 258 object destruction, 281 references, 276 Devicelnfo() function Win32::Sound module, 304 Devices() function Wm32::Sound module, 304 diamond(<>), $ARGV special variable, special array, 186, 187 command line arguments, 184 data file on command line, 185 description, 158, 184 file globbing, 215 how it works, 187 no command line arguments, 184 opening and closing file, 185 reading file in list context, 188, 195 array oflast x lines read, 189 reading from <STDIN>, 184 summary, 204 working with trill, 211 die() function chess CGI program, 344 file error, open() function, 178 program errors, 49 die() method, DBI module executing SQL query with DBI, 370 digit (\d) predefined character, 159 non-digit (\D), 159 directives use warnings, 5 directories changing directory, 219 effect on shell, 219 example, 222 character indicating, 218 creating (making), 221 example, 222 current directory, 262 deleting (removing), 222,297 directory handles, 218 directory separators translating colons (::) into, 288 listing and examining contents, 216 listing example, 222 opening directory, 218 reading directory, 218, 219 setting up, 3 testing if file is a directory, 217 traversing directory trees, 297 directory functions chdir() function, 219 chmod() function, 222 mkdir() function, 221 opendiro function, 218 readdiro function, 218 rmdiro function, 222 disconnect() method, DBI module, 367 division (/) operator, 22 assignment(/=) operators, 39 do.. until loop, 69 do.. whileloop,69 do statement, 261 require statement compared, 262 documentation documenting programs, 6 online documentation, 290 double-quoted strings, 17 array variables, 89 lists, 79 qq/1, 19 quotes inside quotes, 18 variable processing, 17 downloading packages detecting package dependencies, 311 DSN (data source name) connect() method arguments, 366 debugging, 10 E -e file test, 199 \E (end of pattern) escaping metacharacters, 156 each() function hash functions, 119 piping out to a process, 198 editors choosing a text editor, 2 either-or operator Regular expressions, 161 emacs web reference for, 3 empty list, 77 empty strings definitions offalse, 27,28 encapsulation, 256 class constructors, 257 end of file characters Unix and Windows, 211 end of pattern (\E), 156 $ENV {HOMEIPATHIUSER, 213 %ENVhash, %ENY, CGI scripts, 319

30 414 INDEX environment variables CGI scripts exporting, 319 inherited from shell, 213 equal to (eq) string operator, 34 equals(=) assignment operator $(scalar variables), 37 equals equals(==) comparison operator, 27 not assignment operator(=), 37 numeric comparison operators, 54 errors bareword warning, 16 chess CGI program, 344 die() function, 49 syntax error, 16 writing into log files, 292 errstr() method, DBI module, 367 executing SQL query with DBI, 368 escape sequences, 8 \a (alarm), 8 \b (backspace), 8 \n (newline), 4, 8 \r (carriage return), 8 \t (tab), 8 \x (Unicode character), 8 backslash character, 17 strings, 17 tab representation, 17 escaping metacharacters, 155 evaluating statements short -circuited evaluation, 63 exclusive OR (") bitwise operator, 26 exclusive OR (xor) Boolean operator, 30 executability character indicating executable, 218 file tests (-x), 199 testing if file is executable, 217 execute() method, DBI module executing SQL query with DB I, 368, 370 using placeholders, 373 using placeholders and joins, 37 4 executing a program programming, 2 system() function, 223 exercise solutions chapter 1, 385 chapter2, chapter 3, chapter 4, chapter 5, chapter6, chapter7, chapter8, chapter9, chapter 10, 396 chapter11, chapter 12, 401 chapter14, chapter 15, 404 exists() hash function, 120 exit() function, 48 if statements, 61 numeric comparison operators, 55 exponentiation (**) operator, 23 negative numbers, handling, package variables, 289 %EXPORT_TAGS hash, 290 Exporter module, 288 import() subroutine, 289 using in logging module, 293 expression modifiers, 62 foreach loop, 104 looping constructs, 70 F -f file test, 199 \f (form feed) predefined character classes, 159 false, 27 fetchrow() method, DBI module executing SQL query with DBI, 368, 370 <FH> see filehandles fields creating database table, 353 relational databases, 348 showing all fields, 354 file functions chmod() function, 222 close() function, 178 link() function, 220 open()function,177 readlink() function, 221 rename() function, 203, 220 symlinko function, 220 unlink() function, 220 file globbing, reading from file glob, 215 file slurp reading file in list context, 188, 195 file tests checking status before opening, 199 directory handle, using, 218 executability, 199 file exists (-e), 199 examples, 199,201,202 file glob, using, 216 file name is directory name (-d), 199 example, 201,202 file test operators, 199 ownership (-o), 199 example, 203

31 415 perldoc perlftmc, 199 permissions, 200 plain file (-f), 199 readability (-r), 199 example, 202 size ( -s, -z), 199 unexpected response example, 201 writability (read-only) (-w), 199, 200 example, 200, 202 filehandle argument, open() function, 177 filehandles, closing, 179 default filehandle for file tests, 217 my function, 178 pipes, 194 piping out to a process, 198 print() function, 190 reading file in list context, 188 reading file in scalar context line by line until EOE 181 printing with line number, 181 reading from a pipe, 195 summary, 204 writing to files, 190 <STDIN> standard input, 177 filename argument, open() function, 177 specifying full path, 178 filenames writing portable programs, 301 files deleting from disk, 220 deleting useless files program, 298 do statement, 261 directory, testing if file is a, 217 executing/running, 3, 4 making executable, 4 testing if executable, 217 file globbing, 215 file tests, , 217 hard link, creating, 220 ownership testing if file is owned, 217 printing file size, 217 reading, testing if can be read, 217 renaming, 220 example, 222 require statement, 262 stat of the file, 217 symbolic (soft) link, creating, 220 example, 221 reading, 221 transfer to and from FTP server, 258 use statement, 263 writing to, testing if can be written, 217 File::Find module find() method, 297 standard modules, 297 wanted() subroutine, 297 File::Spec module canonpath() function, 301 catdir() function, 301 catfile() function, 301 documentation, 302 path() function, 301 splitdir() function, 301 splitpath() function, 301 standard modules, 301 trnpdir() function, 301 find() method, File::Find module, 297 finish() method, DBI module, 368 finite loops, 63 flags Getopt::Long module, 300 Getopt::Std module, 298 floating point numbers, 15 flock() function locking files, 292 flow charts, 51 if statement, 51 loops, 52 for loop, 68 arrays, looping through, 95 foreach loop, 68 arrays, looping through, 97 arrays, processing, 99 expression modifiers, 104 referenced arrays, 235 traversing trees, 250 fork() function, 226 form data CGI scripts processing, 330 action= attribute, 331 CGI.pm,322 listing parameters, 332 returning parameter value, 332 simple form example, 331 param() method, 332 widgets, 330 form feed (\f) character, 159 Format() function Wm32::Sound module, 304 forward slash (!) character regular expressions, 151 FTP methods, 260 FTPservers transferring files, 258 fullname() method Person class, 282 utility methods, 280 fully qualified variable names, 139

32 416 INDEX functions G see also subroutines array functions, described, 127 directory functions, file functions, 177, 178, hash functions, invoking,292 list functions, 78, 81 parentheses 0 for arguments, 7 string functions, subroutines compared, 128 system() function, 223 I g (global) modifier, Regexes, 171 get methods, 254 get() FfP method, 260 get() method visiting remote web sites, 311 get-set methods, 273 getopts() method, Getopt::Std module, 299 Getopt::Long module standard modules, 300 Getopt::Std module getoptso method, 299 standard modules, 298 getprinto method visiting remote web sites, 312 getpwent() function, 226 getstore() subroutine visiting remote web sites, 312 global variables, 41, 137 scope, 137 goto statement looping constructs, 76 GRANT command, 354 grave character see backquote (') character greater than (gt) string operator, 34 greater than or equal to (ge) operator, 34 greater-than(>) comparison operator, 28 H hashbang,3 hash functions, 117 delete() function, 120 each() function, 119 exists() function, 120 keys() function, 117 reverse() function, 122 values() function, 118 hash() session method, 260 hashes, accessing data in referenced, 240 address book example, trees, 248 arrays compared, 111 assigning values from an array, 112 to an array, 113 counting, 197 creating classes providing attributes, 270 curly brackets{, 114 delete() function, 114 elements adding,114 changing, 114 checking existence, 120 removing, 114, 120 examples using, 121 counting occurrences in array, 122 creating readable variables, 121 reversing information, 121 functions, 117 hash keys, 112 key/value pairs, 112 listing keys, 117 listing pairs, 119 listing values, 118 list context, 115 list separator(=>) operator, 112 my function, 114 named parameters, 146 naming conventions, 111 phone book comparison, 111 references to anonymous hashes, 232 references to hashes, 238 scalar context, 116 sort order, 111 use strict statement, 114 values, 112 working with, 113 head() method visiting remote web sites, 312 headcounto method, 273 header() method CGI.pm module, 326 developing CGI scripts, 379 helloworld.pl, 3 here-documents, 20 generating HTML with CGI.pm, 325 hex() function conversion to strings, 21 hexadecimal numbers, 15 conversion to strings, 20 errors using, 16 hexadecimal system, 9 recognizing numbers as hex, 10 HTML CGI scripts generating, 320 CGI.pm,322

33 417 with CGI.pm, 324 without CGI.pm, 322 chess CGI program, 345 HTTP header writing CGI scripts, 317 i for insensitive case sensitivity, patterns, 153 if statements, Boolean logic, 53 curly braces around statements, 52 defined() function, 57 developing CGI scripts, 380 exit() function, 61 expression modifiers, 62 flow charts, 51 if... else statements, 58 if... elsif statements, 59 logical operators, 58 numeric comparison operators, 54 short-circuited evaluation, 63 string comparison operators, 56 syntax, 52 import() subroutine, 288 module prepared to export, 289 <IN> list context filehandles, writing to files, 191 indefinite loops, 63 file tests example, 202 indentation, 7 index() string function, 206 indexes array index, 93 databases, 383 indexing into strings, 205 infinite loops, 66 looping constructs, 63 infix dereference (->) operator ${$ref-> arrow notation, 239 matrices, 242 methods, 255 references in references, 239 inheritance, 256 creating classes, 269 init() method private methods, 279 INSERT command, 355 instances of classes, 255 integers, 14 handling large numbers, 14 interfaces, 256 interpolation user/runtime specified patterns, 154 variable interpolation, 44 interpreter location of interpreter, 3 Unix users, 4 interpreting code text inside quotes, 4 invoking subroutines, 129 iteration foreach loop processing arrays, 100 modifying iterator value, 101 J join() function Regular expressions, 173 joins K DBI module using joins, 374 SELECT command, MySQL, 364 selecting without joins, 363 key/value pairs creating readable variables, 121 hashes, 112 piping out to a process, 198 keyboard standard input <STDIN>, 46 keys creating database table, 353 relational databases, 348 keys() hash function, 117 keywords avoiding use as variable names, 6 kill() function, 226 Kleene, Stephen Regular expressions, 150 L last keyword looping constructs, 71 last statement loop labels, 7 4 leo function, 198 left shift ( «) operator, 35 length() string function, 206 less than (It) string operator, 34 less than or equal to (le) operator, 34 less-than(<) comparison operator, 28 lexical variables/scope declaring arrays, 88 my function, 41, 140 scope, 137, 140 scoping variables, 41 variables, 41 array using, 264 libwin32 modules, 304

34 418 link() file function, 220 links renaming files, 220 using functions in Unix/Wmdows, 220 list context, 90 capturing output using backquotes, 225 example, 226 hashes, 115 print() function, 116 reading file in, 188 reading from file glob, 215 list functions print() function, 78, 84 reverse() function, 81 list separator(=>) operator, 35 creating hashes, 112 dynamic CGI program, 335 named parameters, 146 lists, accessing values, 83, 84 groups of values, 86 multiple values, 85 arrays,87 assignable lists, 86 assigning values, 78 double-quoted strings, 79 empty list, 77 foreach loop, 68 list slices, 85, 87 mixing strings, numbers and variables, 78 parentheses(), 78 passing as arguments, 143 qw II, creating with, 80 ranges, 81,87 single-quoted strings, 80 literal, 13 localhost, 316 localtime() function, 224 CGI scripts generating HTML, 323 locking files flock() function, 292 log files/levels, 291 logical operators, 58 login() FfP method, 260 which login() to use, 259 looping constructs, arrays, looping through, 95 breaking the loop, 71 controlling the loop, 71 definite loops, 63 do.. until loop, 69 do.. while loop, 69 expression modifiers, 70 finite loops, 63 flow charts, 52 for loop, 68 foreach loop, 68 goto statement, 76 indefinite loops, 63 file tests example, 202 infinite loops, 63 last keyword, 71 last statement, 7 4 loop control variable, 69 loop labels, 7 4 next statement, 72 redo statement, 73 reexecuting the loop, 73 until loop, 67 while loop, 63 piping out to a process, 198 lowercase leo function, 198 Is() FfP method, 260 M lm (multiple lines) modifier, Regexes, 171 Macllroy, Doug pipes, 194 matchtest.pl user/runtime specified patterns, 154, 155 matrices -> syntax, 242 chessboard example, 242 making moves, 244, 247 setting up board, 244, 246 using references, 242 memory Regular expressions, 165 metacharacters quantifiers, 162 Regular expressions, 155 common errors writing, 17 4 table summarizing, 164 methods accessor methods, 271 calling methods (->), 255 CGI.pm module, 329 class methods, 255 classes, 255 creating methods for classes, 271 class attributes, 273 get-set methods, 273 privatizing methods, 277 utility methods, 279 described, 254 FfP methods, 260 get methods, 254 get-set methods, 273 invoking, 255 private methods, 277

35 419 same name, different class, 256 set methods, 254 static methods, 255 subroutines, 255 utility methods, 279 mirror() method visiting remote web sites, 312 mkdir command, 3 mkdir() directory function, 221 mode argument, open() function, 177, 178 modifiers /d (delete), 210 Regexes, 171 modules, see also packages bundles, 311 Bundle::libnet, 312 Bundle::LWP, 311 CGI.pm module, 322 CPAN module, 308 CPAN repository, 305 creating a non-00 module, 290 Database Independent (DBI) module, 347 DBD::mysql module installing, 365 detecting package dependencies, 311 Exporter module, 288 finding and downloading, 308 import() subroutine, 288 installing modules using CPAN, 308 installing modules with PPM, 307 libwin32 modules, 304 log levels, 291 naming conventions, 288 use of.pm extension, 315 online documentation, 290 package hierarchies, 288 package relationship, 288 reasons for using, 287 standard modules, 295 flexible use of command line arguments, 298 network bundle, 312 remote web sites, 311 remote web sites bundle, 311 sound subsystem, 304 storing information in Registry, 305 testing and timing code, 302 traversing directory trees, 297 using long flags, 300 visual representation of data structures, 295 writing portable programs, 301 standard modules list Benchmark module, 302 Data::Dumper module, 295 File::Find module, 297 File::Spec module, 301 Getopt::Long module, 300 Getopt::Std module, 298 list of modules in Perl distribution, 295 Win32::Sound module, 304 Wm32::TieRegistry module, 305 modulo/modulus (%) operator assignment (%=) operators, 39 operator precedence, 24, 36 multiplication (*) operator, 22 assignment(*=) operators, 39 mvcommand renaming files, 220 my() function $ARGV special variable, special array, 186 address book example, trees, 248 chess CGI program, 339 declaring arrays, 88 declaring hashes, 114 executing SQL query with DBI, 371 filehandles, 178 lexical scope, 140 lexical variables, 41 use strict statement, 43 MySQL commands CREATE DATABASE, 353 CREATE TABLE, 353 DELETE,382 DESCRIBE, 354 GRANT,354 INSERT,355 REPlACE, 383 SELECT,358 UPDATE,382 USE,353 MySQL database connecting to, 366 executing SQL query with DBI, 367 extracting data, 358 selecting all fields, 358 selecting some fields, 358 selecting some rows, 359 inserting new rows, 355 logging in/ out, 355 non-root user, creating, 354 ordering selected rows, 361 reversing the order, 362 preparing to use, 353 showing all fields, 354 table joins, selecting using, 364 table, creating, 353

36 420 EX MySQL server case sensitivity, 352 choosing SQL server, 350 command line interface (CU), 352 creating a database, 352, 353 installation, 350 testing, 351 root user, protecting, 351 mysqlshow command, 351 N \n (newline character), 4, 8 predefined character classes, 159 named parameters, 145 CGI.pm module methods, 329 naming conventions $ prefix, 111 %prefix, prefix, 111 arrays, 87, 111 class names, 256 hashes, 111 modules, 288 packages, 140 programming, 140 scalars, 111 subroutines, 128 variables, 6, 44 variables in packages, 138 nedit web reference for, 3 negated regex match (!-) operator, 35 patterns not matching, 151 negating (A) character class[], 158 negative numbers unary minus operator, 24 Net::FfP module transferring files to/from server, 258 new() method class constructors, 259 object constructors, 257 newline character (\n), 4, 8 predefined character classes, 159 next statement loop labels, 7 4 looping constructs, 72 non-digit (\D) predefined character, 159 non-whitespace (\S) predefined character, 159 non-word(\ W) predefined character, 159 normalization relational databases, 350 NOT (-) bitwise operator, 26 not (!) Boolean operator, 30 not equal to(!=) comparison operator, 28 not equal to (ne) string operator, 34 NotePad text editor, 3 numbers, 14 binary, 15 conversion into strings, 20 converting strings into numbers, 33 floating point, 15 hexadecimal, 15 integers, 14 numeric comparison operators, 54 octal, 15 predefined character classes, 159 string comparison operators, 34 numeric operators, 22 comparing strings, o file test, 199 object destruction destroy() method, 281 object -oriented programming, 253 creating a non-00 module, 290 value in Perl, 283 objects accessormethods,271 classes, 255 described, 253 car analogy, 256 object constructors, 257 object destructors, 258 explicit destruction, 281 implicit destruction, 281 perlobj, quote from, 260 what programmers need to know, 256 oct() function conversion to strings, 21 octal numbers, 15 conversion to strings, 20 errors using, 16 octal system, 9 one-to-one correspondences see hashes online documentation perldoc program, 290 open() function append mode(»), 181 arguments, 177 filehandles, writing to files, 191 modes (read/write/append), default, 180 opening files, 177 pipes, 194 piping out to a process, 198 read mode(<), 180 return value, 204 write mode(>), 180

Beginning Perl. Third Edition. Apress. JAMES LEE with SIMON COZENS

Beginning Perl. Third Edition. Apress. JAMES LEE with SIMON COZENS Beginning Perl Third Edition JAMES LEE with SIMON COZENS Apress About the Author... About the Technical Reviewers Acknowledgements Suitrod yetion «. xvi xvii xviii «xix. Chapter 1: First Steps in Perl..