01 - Perl Overview

by Paul Doyle

Before you get into the nitty-gritty of using Perl on World Wide Web servers, you need take some time to look at Perl itself.

This chapter provides an overview of the Perl language. It is not a detailed course in Perl, but it should be enough to give you the flavor of the language and to help you make sense of the examples in this book. When used with the reference chapters in Part V of this book, this chapter may well give you enough Perl to get by with; as you use the language; you'll probably want to delve into more deeply after you've been programming in it for a while.

When you're ready to learn more, you may want to purchase the excellent Programming Perl, by Larry Wall and Randal L. Schwartz (O'Reilly & Associates, Inc.). This book is the definitive work on Perl so far (as you might suspect with Wall's name on the cover). It's readable and humorous yet still sufficiently technical to be of genuine use in everyday Perl programming.

Incidentally, the book is called the "Camel book" after the dromedary that happens to adorn the cover. Because of the ubiquitous nature of the book in Perl-literate circles, this animal has become the emblem of the language.

We're not going to go into too much detail in this chapter; all the gory details are covered in Part V of this book. By the end of this chapter, you should know enough to find your way around the reference chapters for the answers to particular questions. If you already know Perl, you may want to just skim this chapter to refresh your memory of the language and how it works. If you don't already know how to program in at least one language, this book is not the place to start.

• Syntax - Perl's syntax is more readable than C code and a good deal more concise than shell script.

• Data types - Perl data types are few in number but sensitive to the context in which they are evaluated.

• Flow control - Syntax and data types alone do not make a language; flow control provides a program's internal structure.

• Pattern matching - Perl's capability to match complex regular expressions is superb and has many applications.

• Structural issues - Most languages allow you to abstract program functionality into subroutines and modules; Perl goes one better, allowing you to extend the language itself.

Perl

This chapter is supposed to be a snappy introduction to the language, so why am I wasting your time with this stuff? The fact is, Perl is a unique language in ways that cannot be conveyed simply by describing the technical details of the language. Perl is a state of mind as much as it is a language grammar. So we'll take a few minutes to look at the external realities that provoked Perl into being; this information should give you some insight into the way that Perl was meant to be used.

Origins

Now, here's the interesting bit: Larry could have written a utility to manage the particular job at hand and gotten on with his life. He could see, though, that it wouldn't be long before he'd have to write another special utility to handle something else that the standard tools couldn't quite hack. (He may have realized that most programmers are always writing special utilities to handle things that the standard tools can't quite hack.)

So rather than waste any more of his time, he invented a new language and wrote an interpreter for it. That statement may seem to be a paradox, but it isn't. Setting yourself up with the right tools is always an effort, but if you do it right, the effort pays off.

The new language emphasized system management and text handling. After a few revisions, it could handle regular expressions, signals, and network sockets, too. The language became known as Perl and quickly became popular with frustrated, lazy UNIX programmers-and with the rest of us.

Borrowings

Is it Perl or perl ? The definitive word from Larry Wall is that it doesn't matter. Many programmers like to refer to languages with capitalized names (Perl), but the program originated on a UNIX system, on which short lowercase names (awk, sed, and so on) are the norm. As is true of many things about the language, there's no single "right way" to use the term; just use it the way you want. Perl is a tool, after all, and not a dogma. If you're sufficiently pedantic, you may want to call it [Pp]erl after you read the " Regular Expressions " section later in this chapter.

Perl can handle low-level tasks quite well, particularly since Perl 5, when the whole messy business of references was put on a sound footing. In this sense, it has a great deal in common with C. But Perl handles the internals of data types, memory allocation, and so on automatically and seamlessly.

Perl code also bears a passing resemblance to C code, perhaps because Perl was written in C or perhaps because Larry found some of C's syntactic conventions to be handy. But Perl is less pedantic and much more concise than C is.

This magpie habit of picking up interesting features along the way-regular expressions here, database handling there-has been regularized in Perl 5. Now you can add your favorite bag of tricks to Perl fairly easily by using modules. Many of the added-on features of Perl, such as socket handling, are likely to be dropped from the core of Perl and moved out to modules in time.

Cost and Licensing

Perl is not completely a public-domain product, though, and for very good reason. If the source were completely public-domain, someone could make minor alterations in it, compile it, and then sell it-in other words, rip off its creator. On the other hand, without distributing the source code, it's hard to make sure that everyone who wants to can use Perl.

The GNU General Public License is one way to distribute free software without the danger of being taken advantage of. Under this type of license, source code may be distributed freely and used by anybody, but any programs derived from such code must be released under the same type of license. In other words, if you derive any of your source code from GNU-licensed source code, you have to release your source code to anyone who wants it.

This arrangement is often sufficient to protect the interests of the author, but it can lead to a plethora of derivative versions of the original package, which may deprive the original author of a say in the development of his or her own creation. The situation can also lead to confusion on the part of users-it becomes hard to establish which version of the package is the definitive version, whether a particular script will work with a given version, and so on.

That's why Perl is released under the terms of the Artistic License-a variation on the GNU General Public License that says that anyone who releases a package derived from Perl must make it clear that the package is not actually Perl. All modifications must be clearly flagged; executables must be renamed, if necessary; and the original modules must be distributed along with the modified version. The effect is that the original author is clearly recognized as the owner of the package. The general terms of the GNU General Public license also apply.

Distribution

The perl distribution comes with a nifty utility called Configure that tweaks the source files and the Makefile for your system. It probes your system software, shell, C compiler, and so on to determine the answers to various questions about how to build Perl-which compiler flags to use, the sizes of fundamental data types, and so on. You can override any of Configure's answers if you disagree with its findings, but it's generally very accurate indeed.

Running Configure before you make perl virtually guarantees you a perl installation that is not only successfully compiled and linked, but also well optimized for your particular system configuration-and with no tweaking or editing of source files on your part. You're more than welcome to tinker with obscure compiler flags if you want, however; that's why GNU C was invented.

Perl Programs

Invocation

Suppose that perl is correctly installed and working on your system. The simplest way to run perl on a Perl program is to invoke the perl interpreter with the name of the Perl program as an argument, as follows:

perl sample.pl 

/usr/local/hin/perl sample.pl 

That much is the same on all systems that have a command-line interface. The following will do the trick in Windows NT, for example:

c:\NTperl\perl sample.pl 

Invoking Perl in UNIX

#!/usr/local/bin/perl 

chmod +x sample.pl 

Invoking Perl in Windows NT

Usually, a few more steps are required to get a Web server to execute Perl programs automatically. Refer to Appendix A, " Perl Acquisition and Installation ," for platform-specific instructions on creating associations between scripts and interpreters.

Command-Line Arguments

Table 1.1-Perl Command-Line Switches

Option	Arguments	Purpose	Notes
-0	Octal character code	Specify record separator	Default is new line ( \n )
-a		Automatically split records	Used with -n or -p
-c		Check syntax only; do not execute
-d		Run script, using Perl debugger	If Perl debugger is installed
\-D	Flags	Specify debugging behavior	Refer to the PERLDEBUG man page on the CD-ROM that comes with this book
-e	Command	Pass a command to Perl from the command line	Useful for quick operations; see tip after this table for an example
-F	Regular expression	Expression to split by if -a is used	Default is white space
-i	Extension	Replace original file with result	Useful for modi- fying contents of files; see tip after this table for an example
-I	Directory	Specify location of include files
-l	Octal character code	Drop new lines when used with -n and -p , and use designated character as line- termination character
-n		Process the script, using each specified file as an argument	Used for performing the same set of actions on a set of files
-p		Same as -n , but each line is printed
-P		Run the script through the C preprocessor before Perl compiles it
-s		Enable passing of arbitrary switches to Perl	Use -s -what -ever to have the Perl variables $what and $ever defined within your script
-S		Tell Perl to look along the path for the script
-T		Use taint checking; don't evaluate expressions supplied in the command line	Very important for Web use
-u		Makes Perl dump core after compiling your script; intended to allow for generation of Perl executables	Very messy; wait for the Perl compiler
-U		Unsafe mode; over- rides Perl's natural caution.	Don't use this!
-v		Print Perl version number
-w		Print warnings about script syntax	Extremely useful, especially during development; warning messages browsers if sent raw can confuse.

The -e option is handy for quick Perl operations from the command line. Want to change all the foo s in WIFFLE.BAT to bar s? Try this: perl -i.old -p -e "s/foo/bar/g" wiffle.bat This code says, "Take each line of WIFFLE.BAT ( -p ), store the original in WIFFLE.OLD ( -i ), replace all instances of foo with bar ( -e ), and write the result ( -p ) to the original file ( -i )."

You can supply Perl command-line arguments in the interpreter-invocation line in UNIX scripts. Following is a good start for any Perl script:

#!/usr/local/bin/perl -w -T 

The -w switch is best omitted in versions of Perl older than 5.002, because it may produce spurious warnings. Also, take care when you use the -w switch in scripts that send data to Web browsers. Warning messages sent before the browser receives a content-type line may result in an error message.

Program Layout

Perl code can be quite free-flowing. The broad syntactic rules governing where a statement starts and ends are:

• Leading white space is ignored. You can start a Perl statement anywhere you want: at the beginning of the line; indented, for clarity (recommended); or even right-justified (definitely frowned on), if you like.

• Commands are terminated with a semicolon.

• White space outside string literals is irrelevant; one space is as good as a hundred, which means that you can split statements over several lines for clarity.

• Anything after a hash sign ( # ) is ignored. Use this fact to pepper your code with useful comments.

Here's a Perl statement inspired by Kurt Vonnegut:

print "My name is Yon Yonson\n"; 

Printing more text is a matter of either stringing together statements like the following or giving multiple arguments to the print function:

print "My name is Yon Yonson,\n";
print "I live in Wisconsin,\n",
 "I work in a lumbermill there.\n"; 

We'll have much more to say about lists and arrays in " Data Types " later in this chapter. You'll find a few more examples of the more common functions in the remainder of this chapter, but refer to Chapter 15, "Function List," for a complete rundown on Perl's built-in functions.

For now, if you're uncomfortable with functions that take arbitrary numbers of arguments with no parentheses to corral them, pretend that you see parentheses. You can use them in Perl programs, if you like, but it would be better to get used to the idea that Perl syntax is loose and groovy in a way that C, for example, is not.

What does a complete Perl program look like? Here's a trivial UNIX example, complete with the invocation line at the top and a few comments:

#!/usr/local/bin/perl -w # Show warnings

print "My name is Yon Yonson,\n"; # Let's introduce ourselves
print "I live in Wisconsin,\n",
 "I work in a lumbermill there.\n"; # Remember the line breaks 

Data Types

Scalars

All Perl variable names, including scalars, are case-sensitive. $Name and $name , for example, are completely different quantities.

Perl converts automatically between numbers and strings as required, so that

$a = 2;
$b = 6;
$c = $a . $b; # The "." operator concatenates two strings
$d = $c / 2;
print $d; 

13 

This situation might be a problem if Perl were regularly used for tasks in which explicit memory offsets were used, for example, and data types were critical. But for the type of task for which Perl is normally used-and certainly for the types of tasks that we'll be using it for in this book-these automatic conversions are smooth, intuitive, and generally a Good Thing.

We can develop the earlier example script with some string variables, as follows:

#!/usr/local/bin/perl -w # Show warnings

$who = 'Yon Yonson';
$where = 'Wisconsin';
$what = 'in a lumbermill';

print "My name is $who,\n"; # Let's introduce ourselves
print "I live in $where,\n",
 "I work $what there.\n"; # Remember the line breaks

print "\nSigned: \t$who,\n\t\t$where.\n"; 

My name is Yon Yonson,
I work in Wisconsin,
I work in a lumbermill there.

Signed:	Yon Yonson,
		Wisconsin. 

Arrays

@trees = ("Larch", "Hazel", "Oak"); 

Mixing scalar types in an array is not a problem. The code

@items = (15, '45.67', "case");
print "Take $items[0] $items[2]s at \$$items[1] each.\n"; 

Take 15 cases at $45.67 each. 

@A = (1, 2, 3);
@B = (4, 5, 6);
@C = (7, 8, 9);
@D = (@A, @B, @C); 

 @Annual = (@Spring, @Summer, @Fall, @Winter); 

An aspect of Perl that often confuses newcomers (and occasionally old hands, too) is the context-sensitive nature of evaluations. Perl keeps track of the context in which an expression is being evaluated and can return a different value in an array context than in a scalar context. In this example, the array @B contains 1-4, whereas $C contains 4 (the number of values in the array): @A = (1, 2, 3, 4); @B = @A; $C = @A; This context sensitivity becomes more of an issue when you use functions and operators that can take either a single argument or multiple arguments. The function or argument behaves one way when it is passed a single scalar argument and another when it is passed multiple arguments, which it may interpret as a single array argument.

Many of Perl's built-in functions take arrays as arguments. One example is sort , which takes an array as an argument and returns the same array, sorted alphabetically. The code

print sort ( 'Beta', 'Gamma', 'Alpha' ); 

You can make this code neater by using another built-in function, called join . This function takes two arguments: a string to connect with, and an array of strings to connect. join returns a single string that consists of all elements in the array joined with the connecting string. The code

 print join ( ' : ', 'Name', 'Address', 'Phone' ); 

Because sort returns an array, you can feed its output straight into join . The code

 print join( ', ', sort ( 'Beta', 'Gamma', 'Alpha' ) ); 

Notice that this code doesn't separate the initial scalar argument of join from the array that follows it. The first argument is the string to join things with. The rest of the arguments are treated as a single argument: the array to be joined. This is true even if you use parentheses to separate groups of arguments. The code

 print join( ': ', ('A', 'B', 'C'), ('D', 'E'), ('F', 'G', 'H', 'I')); 

You can use one array or multiple arrays in a context such as this because of the way that Perl treats arrays; adding an array to an array gives you one larger array, not two arrays. In this case, all three arrays are bundled into one.

For even more powerful string-manipulation capabilities, refer to the splice function in Chapter 15, "Function List."

Associative Arrays

Arrays of the type that you've already seen are lists of values indexed by subscripts . In other words, to get an individual element of an array, you supply a subscript as a reference, as follows:

@fruit = ( "Apple", "Orange", "Banana" );
print $fruit[2]; 

Now, here's the point of all this: Associative arrays are lists of values indexed by strings . Conceptually, that's all there is to them. The implementation of associative arrays is more complex, because all the strings ( keys ) need to be stored in addition to the values to which they refer.

When you want to refer to an element of an associative array, you supply a string (the key) instead of an integer (the subscript). Perl returns the corresponding value. Consider the following example:

%fruit = ("Green", "Apple", "Orange", "Orange", "Yellow", "Banana" );
print $fruit{"Yellow"}; 

On a superficial level, you can use string subscripts to provide mnemonics for array references, allowing you to refer to $Total{'June'} instead of $Total[5] . But you wouldn't even be beginning to use the power of associative arrays. Think of the keys of an associative arrays as you might think of a key that links tables in a relational database, and you're closer to the idea. Consider this example:

%Folk = ( 'YY', 'Yon Yonson',
 'TC', 'Terra Cotta',
 'RE', 'Ron Everly' );

%State = ( 'YY', 'Wisconsin',
 'TC', 'Minnesota',
 'RE', 'Bliss' );

%Job = ( 'YY', 'work in a lumbermill',
 'TC', 'teach nuclear physics',
 'RE', 'watch football');

foreach $person ( 'TC', 'YY', 'RE' ) {
 print "My name is $Folk{$person},\n",
 "I live in $State{$person},\n",
 "I $Job{$person} there.\n\n";
 } 

You also can treat the keys and values of an associative array as separate (ordinary) arrays by using the keys and values keywords, respectively. The code

 print keys %Folk;
print values %State; 

Looks as though we need to do some more work on string handling. That task is best left until after we cover some flow-control mechanisms, however.

A special associative array called %ENV stores the contents of all environment variables, indexed by variable name. $ENV{'PATH'} , for example, returns the current search path. Following is a way to print the current values of all environment variables, sorted by variable name for good measure: foreach $var (sort keys %ENV ) { print "$var: \"$ENV{$var}\".\n"; } The foreach clause sets $var to each of the environment-variable names in turn (in alphabetical order), and the print statement prints each name and value. The backslash- quote ( \" ) in there produces quotation marks around the values.

File Handles

You can regard a file handle as being a pointer to a file from which Perl is to read or to which it will write. (C programmers are familiar with the concept.) The basic idea is that you associate a handle with a file or device, and then refer to the handle in the code whenever you need to perform a read or write operation.

File handles generally are written in uppercase. Perl has some useful predefined file handles, as Table 1.2 shows.

Table 1.2-Perl's Predefined File Handles

File Handle	Points to...
STDIN	Standard input (normally, the keyboard)
STDOUT	Standard output (normally, the console; in many Web applications, the browser)
STDERR	Device where error messages should be written (normally, the console; in a Web server environment, normally the server-error log file)

The print statement can take a file handle as its first argument, as follows:

print STDERR "Oops, something broke.\n"; 

print (STDERR "Oops, something broke.\n"); 

Use the standard file handles explicitly, especially in complex programs. Redefining the standard input or output device for a while is convenient sometimes; make sure that you don't accidentally wind up writing to a file what should have gone to the screen.

You can use the open function to associate a new file handle with a file, as follows:

open (INDATA, "/etc/stuff/Friday.dat");
open (LOGFILE, ">/etc/logs/reclaim.log");
print LOGFILE "Log of reclaim procedure\n"; 

Table 1.3-Perl File-Access Symbols

Symbol	Meaning
<	Open the file for reading (the default action)
>	Open the file for writing
>>	Open the file for appending
+<	Open the file for both reading and writing
+>	Open the file for both reading and writing
| (before file name)	Treat file as command into which Perl is to pipe text
| (after file name)	Treat file as command from which input is to be piped to Perl

To take a more complex example, here's one way to feed output to the mypr printer on a UNIX system:

open (MYLPR, "|lpr -Pmypr");
print MYLPR "A line of output\n";
close MYLPR; 

A construct such as

while (<STDIN>) {
print;
} 

If the user types

A
Bb
Ccc
^D 

A
A
Bb
Bb
Ccc
Ccc
^D 

print <STDIN> 

 A
Bb
Ccc
^D
A
Bb
Ccc 

open (SIGFILE, ".signature");
while ( <SIGFILE> ) {
	print; print "\n";
	} 

If no files are listed in the command line, Perl instead assumes that STDIN is intended. The following code, therefore, keeps printing more... as long as something other than Ctrl+D appears in standard input:

 while (<>) {
print "more.... ";
} 

Perl 5 allows array elements to be references to any data type. As a result, you can build arbitrary data structures of the kind used in C and other high-level languages, but with all the power of Perl. You can have an array of associative arrays, for example.

Special Variables

Environment Variables

print "Looking for files along the path ($ENV{'PATH'})...\n"; 

Program Arguments

C programmers, beware: The first element of this array is the first actual argument, not the name of the program. The special variable $0 contains the name of the Perl script that is being executed.

The following code prints the command-line arguments one per line, sorted alphabetically:

print join("\n", sort @ARGV); 

Current Line

 $line=0;
while ( <SOMEFILE> ) {
	++$line;
	print "Line $line : ", $_;
	} 

$oldvalue = $_; 

$_ = $oldvalue; 

System Error Messages

This example reports failure if the open call failed:

open ( INFILE, "./missing.txt") || die "Couldn't open \"./missing.txt\" ($!).\n"; 

If the file does not exist, Perl terminates after displaying something like this:

Couldn't open "./missing.txt" (No such file or directory). 

Flow Control

Logical Operators

$Weekend = $Saturday || $Sunday; 

$Solvent = ($income > 3) && ($debts < 10); 

This means that when the left side of an or expression is evaluated as true, the right side is not be evaluated. Combine this with Perl's easy way with data types, and you can say things like the following:

$value > 10 || print "Oops, low value...\n"; 

OK, it's a trick, but it's a very useful one.

Something analogous applies to the && operator. In this case, if the left side of an expression is false, the expression as a whole is false, so Perl does not evaluate the right side. The && operator can, therefore, be used to produce the same kind of effect as the || trick, but with the opposite sense, as in the following example:

$value > 10 && print "OK, value is high enough...\n"; 

$length <= 80 || die "Line too long.\n";
$errorlevel > 3 && warn "Hmmm, strange error level ($errorlevel)...\n";
open ( LOGFILE, ">install.log") || &bust("Log file"); 

Conditional Expressions

open ( INFILE, "./missing.txt") if $missing; 

The expression is evaluated as either true or false and can contain any of the relational operators listed in Table 1.4 (although it need not). Following are a few examples of valid expressions:

$full
$a == $b
<STDIN> 

When we're comparing strings, less than means lexically less than . If $left comes before $right when the two are sorted alphabetically, $left is less than $right .

Perl has four modifiers, each of which behaves the way that you might expect from the corresponding English word:

• if . The statement is executed if the logical expression is true and is not executed otherwise. Examples:

  $max = 100 if $min < 100;
  print "Empty!\n" if !$full; 

• unless . The statement is not executed if the logical expression is true and is executed otherwise. Examples:

  open (ERRLOG, "test.log") unless $NoLog;
  print "Success" unless $error>2; 

• while . The statement is executed repeatedly until the logical expression is false. Examples:

  $total -= $decrement while $total > $decrement;
  $n=1000; "print $n\n" while $n-- > 0; 

• until . The statement is executed repeatedly until the logical expression is true. Examples:

$total += $value[$count++] until $total > $limit;
print RESULTS "Next value: $value[$n++]" until $value[$n] = -1; 

Compound Statements

The following example is somewhat similar to C's if syntax:

if ( ( $total += $value ) > $limit ) {
 print LOGFILE "Maximum limit $limit exceeded. Offending value was $value.\n";
 close (LOGFILE);
 die "Too many! Check the log file for details.\n";
 } 

if ( !open( LOGFILE, "install.log") ) {
 close ( INFILE );
 die "Unable to open log file!\n";
 }
elsif ( !open( CFGFILE, ">system.cfg") ) {
 print LOGFILE "Error during install: Unable to open config file for writing.\n";
 close ( LOGFILE );
 die "Unable to open config file for writing!\n";
 }
else {
 print CFGFILE "Your settings go here!\n";
 } 

Loops

until ( $total >= 50 ) {
 print "Enter a value: ";
 $value = scalar (<STDIN>);
 $total += $value;
 print "Current total is $total\n";
 }
print "Enough!\n"; 

for ( $count = 0; $count < 100; $count++ ) {
 print "Something";
 } 

@numbers = ("one", "two", "three", "four");
foreach $num ( @numbers ) {
 print "Number $num...\n";
 } 

foreach $arg ( @ARGV ) {
 print "Argument: \"$arg\".\n";
 } 

foreach $namekey ( sort keys %surnames ) {
 print REPORT "Surname: $value{$namekey}.\n",
 "Address: $address{$namekey}.\n";
 } 

Labels

RECORD: while ( <INFILE> ) {
 $even = !$even;
 next RECORD if $even;
 print;
 } 

• next . Jumps to the next iteration of the loop marked by the label or to the innermost enclosing loop, if no label is specified.

• last . Immediately breaks out of the loop marked by the label or out of the innermost enclosing loop, if no label is specified.

• redo . Jumps back to the loop marked by the specified label or to the innermost enclosing loop, if no label is specified. redo causes the loop to execute again with the same iterator value.

Subroutines

sub Usage {
 print "Usage: \n",
 "twiddle [-args] infile outfile\n";
 print "Copyleft 1996, Jonathan F. Squirmsby.";
 } 

sub bust {
 print "Oops, some kind of error seems to have occurred.\n";
 die "Fatal error, terminating.\n";
 }
open ( LOGFILE, ">install.log") || &bust; 

Passing Arguments

open ( LOGFILE, ">install.log") || &bust("Failed to open log file \"install.log\"."); 

All Perl subroutines receive their arguments as an arbitrarily long array of scalars with the special name of @_ . There is no mechanism for declaring the arguments when the subroutine is declared. There is no fixed number of arguments. Also, the calling function can pass any mixture of scalars and arrays; they are all be treated as one big @_ array when they get to the subroutine.

In the example earlier in this section, in which bust is called with a single argument, you can pick it up in the subroutine and use it to provide a more sensible error message, as in the following example:

sub bust {
 ($errortext) = @_;
 print "Oops, an error occurred ($errortext).\n";
 die "Fatal error, terminating.\n";
 } 

 print "Error $_[0] opening file $_[1].\n"; 

($errfile, $errtext) = @_;
print "Error $errtext opening file $errfile.\n"; 

In " Variable Scope " later in this chapter, you learn how to protect local variables such as $errortext in subroutines by using the local and my keywords.

Passing Arrays

&PrintRes( "alpha", (1, 3, 5, 7), "beta", (2, 4, 6, 8) ); 

$p1 = "alpha";
@p2 = (1, 3, 5, 7);
$p3 = "beta";
@p4 = (2, 4, 6, 8); 

( $p1, @p2, $p3, @p4 ) = @_; 

1. The first variable in the list, $p1 , is assigned the value of the first scalar in the @_ argument array, which is alpha .

2. Then the next variable in the list, @p2 , is assigned the value of the next argument in the @_ argument array. This is an array assignment because @p2 is an array, so the entire @_ array, from its second element on, is assigned to @p2 - (1, 3, 5, 7, "beta", 2, 4, 6, 8) , in other words.

3. The next variable to be assigned is $p3 . This variable is assigned the value of the next element in the @_ argument array-but there aren't any left, because they've all been slurped by @p2 . $p3 , therefore, is null.

4. The final variable, @p4 , suffers the same fate and is also null.

There's no point in trying to specify subarrays, as in the following example, because Perl expands the array on the left to the same thing as before:

( $p1, (@p2), $p3, (@p4) ) = @_; 

Returning Values

sub AddIt {
 ( $a, $b ) = @_;
 $a + $b;
 } 

print "Summing 4 and 3 yields ", &AddIt(4, 3), ".\n"; 

Summing 4 and 3 yields 7. 

It isn't always clear which statement is the last to be executed in a subroutine, particularly if it contains loops or conditional statements. One way to ensure that the correct value is returned is to place a reference to the variable on a line by itself at the end of the subroutine, as follows:

sub Maybe {
 # Various loops and conditionals here which set the value of "$result"...
 $result;
 }

Take care not to add seemingly innocuous statements near the end of a subroutine. A print statement returns a value of 1 (if successful) for example, so a subroutine that prints something just before it returns always returns 1.

The return value can be a scalar, an array, or an associative array. Listing 1.1 shows a complete example in which a subroutine builds an associative array of names keyed by initials and then returns the associative array. The keys of this array-the initials-are then printed in sorted order. Take your time reading through this example; a lot is going on in there, but it's comprehensively commented.

Listing 1.1-INITIALS.PL: Returning an Associative Array from a Subroutine

#!/usr/local/bin/perl -w

# Pass the names into the subroutine.
# Store the results in an associative array called "keyedNames".
%keyedNames = &GetInitials("Jane Austen", "Emily Bronte", "Mary Shelley" );

# Print out the initials, sorted:
print "Initials are ", join(', ', sort keys %keyedNames), ".\n";

# The GetInitials subroutine.
sub GetInitials {

 # Let's store the arguments in a "names" array for clarity.
 @names = @_;

 # Process each name in turn:
 foreach $name ( @names ) {

 # The "split" function is explained in Chapter 15, "Function List".
 # In this statement, we're getting split to look for the ' ' in the name;
 # It returns an array of chunks of the original string (i.e. $name) which were
 # separated by spaces, i.e. the forename and surname respectively in our case.
 # The variables "$forename" and "$surname" are then assigned to this array
 # using parentheses to force an array assignment.
 ( $forename, $surname ) = split( ' ', $name );

 # OK, now we have the forename and surname. We use the "substr" function,
 # also explained in chapter 15, to extract the first character from each of these.
 # The "." operator concatenates two strings (for example, "aa"."bb" is "aabb")
 # so the variable "$inits" takes on the value of the initials of the name:
 $inits = substr( $forename, 0, 1 ) . substr( $surname, 0, 1 );

 # Now we store the name in an associative array using the initials as the key:
 $NamesByInitials{$inits} = $name;
 }

 # Having built the associative array, we simply refer to it at the end of the
 # subroutine so that it's value is the last thing evaluated here. It will then
 # be passed back to the calling function.
 %NamesByInitials;
 }

Variable Scope

$name = "Dana";
@name = ("Donna", "Dana", "Diana");
%name = ("Donna", "Elephants", "Dana", "Finches", "Diana", "Parakeets");
print "I said $name{$name}, not $name{$name[0]}!\n"; 

That's where the local (Perl 4 and 5) and my (Perl 5 only) functions come in. These functions force Perl to treat variables as though they are local to the current code block, whether that block is a loop, an if-block, or a subroutine.

The following example uses two variables called $temp (one outside and one inside a while loop):

$temp = "Still here!\n";
print "Enter a few words at a time, Ctrl+D to terminate:\n";
while (<>) {
 local( $temp, @etc ) = split(' ', $_ );
 print "You said $temp";
 @etc && print " and then you said @etc";
 print ". Enter some more, or press Ctrl+D to end:\n";
 }
print $temp; 

Patterns

The basic pattern-matching operations discussed in this section are:

• Matching , in which we want to know whether a particular string matches a pattern

• Substitution , in which we want to replace portions of a string based on a pattern

The patterns referred to here are more properly known as regular expressions, and we'll start by looking at them.

Regular Expressions

A few concrete examples usually help after an overblown definition like that one. The regular expression b. matches the strings bovine, above, Bobby , and Bob Jones , but not the strings Bell, b , or Bob . That's because the expression insists that the letter b (lowercase) must be in the string and must be followed immediately by another character.

The regular expression b+ , on the other hand, requires the lowercase letter b at least once. This expression matches b and Bob in addition to the example matches for b. in the preceding paragraph. The regular expression b* requires zero or more b s, so it matches any string. That seems to be fairly useless, but it makes more sense as part of a larger regular expression. Bob*y , for example, matches all of Boy, Boby , and Bobby but not Boboby .

Assertions

Table 1.5-Perl's Regular-Expression Assertions

Assertion	Matches	Example	Matches	Doesn't Match
^	Start of string	^fool	foolish	tomfoolery
$	End of string	fool$	April fool	foolish
\b	Word boundary	be\bside	be side	beside
\B	Nonword boundary	be\Bside	beside	be side

Atoms

Table 1.6-Perl's Regular-Expression Atoms

Atom	Matches	Example	Matches	Doesn't Match
period (.)	Any character except new line	b.b	bob	bb
List of characters in brackets	Any one of those characters	^[Bb]	Bob, bob	Rbob
Regular expression in parentheses	Anything that regular expression matches	^a(b.b)c$	abobc	abbc

Quantifiers

Table 1.7-Perl's Regular-Expression Atom Quantifiers

Quantifier	Matches	Example	Matches	Doesn't Match
*	Zero or more instances of the atom	ab*c	ac, abc	abb
+	One or more instances of the atom	ab+c	abc	ac
?	Zero or one instances of the atom	ab?c	ac, abc	abbc
{n}	n instances of the atom	ab{2}c	abbc	abbbc
{n,}	At least n instances of the atom	ab{2,}c	abbc, abbbc	abc
{nm}	At least n , at most m instances of the atom	ab{2,3}c	abbc	abbbbc

Special Characters

Table 1.8-Perl's Regular-Expression Special Characters

Symbol	Matches	Example	Matches	Doesn't Match
\d	Any digit	b\dd	b4d	bad
\D	Nondigit	b\Dd	bdd	b4d
\n	New line
\r	Carriage return
\t	Tab
\f	Form feed
\s	White-space character
\S	Non-white-space character
\w	Alphanumeric character	a\wb	a2b	a^b
\W	Nonalphanumeric character	a\Wb	aa^b	aabb

Backslashed Tokens

This mechanism is a backslash ( \ ), followed by a numeric quantity. This quantity can take any of the following formats:

• Single or double digit: matched quantities after a match. These matched quantities are called backreferences and are explained in the following section.

• Two-or three-digit octal number: the character with that number as character code, unless it's possible to interpret it as a back reference.

• x , followed by two hexadecimal digits: the character with that number as its character code. \x3e , for example, is > .

• c , followed by a single character: the control character. \cG , for example, matches Ctrl+G .

• Any other character: the character itself. \& , for example, matches the & character.

Matching

Matching on $_

$prompt = "Enter some text or press Ctrl+D to stop: ";
print $prompt;
while (<>) {
 /^[aA]/ && print "Starts with a or A. ";
 /[0-9]$/ && print "Ends with a digit. ";
 /perl/ && print "You said it! ";
 print $prompt;
 } 

Bound Matches

?$filename =~ /dat$/ && die "Can't use .dat files.\n"; 

$ENV{'PATH'} !~ /perl/ && warn "Not sure if perl is in your path..."; 

Alternative Delimiters

$installpath =~ m!^/usr/local! || warn "The path you have chosen is odd.\n"; 

Match Options

Table 1.9-Perl's Match-Operator Optional Switches

Switch	Meaning
g	Perform global matching
i	Perform case-insensitive matching
o	Evaluate the regular expression one time only

The g switch continues matching even after the first match has been found. This switch is useful when you are using backreferences to examine the matched portions of a string, as described in the " Backreferences " section later in this chapter.

The i switch forces a case-insensitive match.

Finally, the o switch is used inside loops in which a great deal of pattern matching is taking place. This switch tells Perl that the regular expression (the match operator's operand) is to be evaluated one time only. The switch can improve efficiency when the regular expression is fixed for all iterations of the loop that contains it.

Backreferences

while (<>) {
 /\b(\S{4})\s(\S{4})\s(\S{4})\b/ && print "Gosh, you said $1 $2 $3!\n";
 } 

What if you don't know in advance how many matches to expect? Perform the match in an array context; Perl returns the matches in an array. Consider this example:

@hits = ("Yon Yonson, Wisconsin" =~ /(\won)/g);
print "Matched on ", join(', ', @hits), ".\n"; 

Matched on Yon, Yon, son, con. 

Substitution

The pattern to be replaced goes between the first and second delimiters, and the replacement pattern goes between the second and third delimiters. This simple example changes $house from henhouse to doghouse :

$house = "henhouse";
$house =~ s/hen/dog/; 

From Here...

This book now moves on to Web matters, but look in the following places for more information about Perl:

• Refer to Part V of this book for comprehensive information on Perl special variables, operators, and built-in functions.

• Also refer to Part V to learn how to use modules and libraries to compartmentalize your code for greater robustness and extensibility.

• Consider buying a book that deals in detail with the Perl language. The definitive work is the "Camel" book, cited at the beginning of this chapter.

Copyright ©1996, Que Corporation. All rights reserved. No part of this book may be used or reproduced in any form or by any means, or stored in a database or retrieval system without prior written permission of the publisher except in the case of brief quotations embodied in critical articles and reviews. Making copies of any part of this book for any purpose other than your own personal use is a violation of United States copyright laws. For information, address Que Corporation, 201 West 103 ^rd Street, Indianapolis, IN 46290.

Notice: This material is from Special Edition, Using Perl for Web Programming , ISBN: 0-7897-0659-8. The electronic version of this material has not been through the final proof reading stage that the book goes through before being published in printed form. Some errors may exist here that are corrected before the book is published. This material is provided "as is" without any warranty of any kind.