Web based School

Perl is a simple yet useful programming language that provides the convenience of shell scripts and the power and flexibility of high-level programming languages. Perl programs are interpreted and executed directly, just as shell scripts are; however, they also contain control structures and operators similar to those found in the C programming language. This gives you the ability to write useful programs in a very short time.

Where Can I Get Perl?

Perl is freeware: it can be obtained by file transfer (ftp) from the Free Software Foundation at prep.ai.mit.edu (in the directory pub/gnu). Perl is also available from several other sites on the Internet, including any site that archives the newsgroup comp.sources.unix.

The Free Software Foundation gives you the right to obtain Perl and its source, provided others have the right to obtain them from you. For more details on the Free Software Foundation licensing policy, refer to the file GETTING.GNU.SOFTWARE, also available from the foundation.

A Simple Sample Program

To show easy it is to use Perl, here is a simple program that echoes (writes out) a line of input typed in at a terminal.

Listing 16.1. A Sample Perl Program.

#!/usr/bin/perl

$inputline = <STDIN>;

print ("$inputline");

To run this program, do the following:

Type in the program and save it in a file (say, foo).
Tell the system that this file contains executable statements. To do this, enter the command chmod +x foo.
Run the program by entering the command foo.

If you receive the error message foo not found or some equivalent, either enter the command ./foo or add the current directory . to your PATH environment variable.

At this point, the program waits for you to type in an input line. Once you have done so, it echoes your input line and exits.

The following sections describe each of the components of this simple program in a little more detail.

Using Comments

The first line of this program is an example of a Perl comment. In Perl, anytime a # character is recognized, the rest of the line is treated as a comment:

# this is a comment that takes up the whole line

$count = 0;     # this part of the line is a comment

A comment appearing as the first line of a program is special. This header comment indicates the location of the program interpreter to use. In this example, the string !/usr/bin/perl indicates that this file is a Perl program.

The Perl interpreter should be located in /usr/bin/perl on your system. If it is not, replace /usr/bin/perl in the header comment with the location of the Perl interpreter on your system.

Reading from Standard Input

Like C, Perl recognizes the existence of the UNIX standard input file, standard output file, and standard error file. In C, these files are called stdin, stdout and stderr; in Perl, they are called STDIN, STDOUT and STDERR.

The Perl construct <STDIN> refers to a line of text read in from the standard input file. This line of text includes the closing newline character.

Storing Values The Scalar Variable

The construct $inputline is an example of a scalar variable. A scalar variable is a variable that holds exactly one value. This value can be a string, integer, or floating point number.

All scalar variables start with a dollar sign, $. This distinguishes them from other Perl variables. In a scalar variable, the character immediately following the dollar sign must be a letter. Subsequent characters can be letters, digits, or underscores. Scalar variable names can be as long as you like.

For more information on scalar variables and their values, see the section "Working with Scalar Variables" later in this chapter.

Assigning a Value to a Scalar Variable

The statement $inputline = <STDIN>; contains the = character, which is the Perl assignment operator. This statement tells Perl that the line of text read from standard input, represented by <STDIN>, is to become the new value of the scalar variable $inputline.

Perl provides a full set of useful arithmetic, logical, and string operators. For details, refer to the sections "Working with Scalar Variables" and "Using Lists and Array Variables" later in this chapter.

CAUTION: All scalar variables are given an initial value of the null string, "". Therefore, a Perl program can be run even when a scalar variable is used before a value has been assigned to it. Consider the statement

$b = $a;

This statement assigns the value of the variable $a to $b. If $a has not been seen before, it is assumed to have the value "", and "" is assigned to $b. Since this behavior is legal in Perl, you must check your programs for "undefined" variables yourself.

Scalar Variables Inside Character Strings

The final statement of the program, print ("$inputline");, contains a character string, which is a sequence of characters enclosed in double quotes. In this case, the character string is "$inputline".

The string "$inputline" contains the name of a scalar variable, $inputline. When Perl sees a variable inside a character string, it replaces the variable with its value. In this example, the string "$inputline" is replaced with the line of text read from the standard input file.

Writing to Standard Output

The built-in function print() writes its arguments (the items enclosed in parentheses) to the standard output file. In this example, the statement print ("$inputline"); sends the contents of the scalar variable $inputline to the standard output file.

The print() function can also be told to write to the standard error file or to any other specified file. See the section "Reading from and Writing to Files" later in this chapter for more details.

Working with Scalar Variables

Now that you know a little about Perl, it's time to describe the language in a little more detail. This section starts you off by discussing scalar variables and the values that can be stored in them.

Understanding Scalar Values

In Perl, a scalar value is any value that can be stored in a scalar variable. The following are scalar values:

Integers
Double and single-quoted character strings
Floating-point values

The following assignments are all legal in Perl:

$variable = 1;

$variable = "this is a string";

$variable = 3.14159;

The following assignments are not legal:

$variable = 67M;

$variable = ^803;

$variable = $%$%!;

Using Octal and Hexadecimal Representation

Normally, integers are assumed to be in standard base 10 notation. Perl also supports base 8 (octal) and base 16 (hexadecimal) notation.

To indicate that a number is in base 8, put a zero in front of the number:

$a = 0151;          # 0151 octal is 105

To indicate base 16, put 0x (or 0X) in front of the number:

$a = 0x69;          # 69 hex is also 105

The letters A through F (in either upper- or lowercase) represent the values 10 through 15:

$a = 0xFE;          # equals 16 * 15 + 1 * 14, or 254

NOTE: Strings containing a leading 0 or 0x are not treated as base 8 or base 16:

$a = "0151";
$a = "0x69";

These strings are treated as character strings whose first character is "0."

Using Double- and Single-Quoted Strings

So far, all of the strings you have seen have been enclosed by the " (double quotation mark) characters:

$a = "This is a string in double quotes";

Perl also allows you to enclose strings using the ' (single quotation mark) character:

$a = 'This is a string in single quotes';

There are two differences between double-quoted strings and single-quoted strings. The first difference is that variables are replaced by their values in double-quoted strings, but not in single-quoted strings:

$x = "a string";

$y = "This is $x";  # becomes "This is a string"

$z = 'This is $x';  # remains 'This is $x'

Also, double-quoted strings recognize escape sequences for special characters. These escape sequences consist of a backslash (\) followed by one or more characters. The most common escape sequence is \n, representing the newline character:

$a = "This is a string terminated by a newline\n";

Table 16.1 lists the escape sequences recognized in double-quoted strings.

Table 16.1. Escape Sequences in Double-Quoted Strings.

\a	bell (beep)
\b	backspace
\cn	the control-n character
\e	escape
\f	form feed
\l	force next letter into lowercase
\L	all following letters are lowercase
\n	newline
\r	carriage return
\t	tab
\u	force next letter into uppercase
\U	all following letters are uppercase
\v	vertical tab

\L and \U can be turned off by \E:

$a = "T\LHIS IS A \ESTRING";  # same as "This is a STRING"

To include a backslash or double quote in a double-quoted string, precede it with another backslash:

$a = "A quote \" in a string";

$a = "A backslash \\ in a string";

You can specify the ASCII value for a character in base 8 or octal notation using \nnn, where each n is an octal digit:

$a = "\377";        # this is the character 255, or EOF

You can also use hexadecimal to specify the ASCII value for a character. To do this, use the sequence \xnn, where each n is a hexadecimal digit:

$a = "\xff";        # this is also 255

None of these escape sequences is supported in single-quoted strings, except for \' and \\, which represent the single quote character and the backslash, respectively:

$a = '\b is not a bell'

$a = 'a single quote \' in a string'

$a = 'a backslash \\ in a string'

NOTE: In Perl, strings are not terminated by a null character (ASCII 0), as they are in C. In Perl, the null character can appear anywhere in a string:

$a = "This string \000 has a null character in it";

Using Floating-Point Values

Perl supports floating-point numbers in both conventional and scientific notation. The letter E (or e) represents the power of ten to which a number in scientific notation is to be raised.

$a = 11.3;          # conventional notation

$a = 1.13E01;       # 11.3 in scientific notation

$a = -1.13e-01;     # the above divided by -10

CAUTION: Note that Perl uses your machine's floating point representation. This means that only a certain number of digits (in mathematical terms, a certain precision) are supported. For example, consider the following very short program:

#!/usr/bin/perl
$pi = 3.14159265358979233;
print ("pi is $pi\n");

This program prints the following:

pi = 3.1415926535897922

This is because there just isn't room to keep track of all of the digits of pi specified by the program.

This problem is made worse when arithmetic operations are performed on floating point numbers; see "Performing Comparisons" for more information on this problem.

Note that most programming languages, including C, have this problem.

Interchangeability of Strings and Numeric Values

In Perl, as you have seen, a scalar variable can be used to store a character string, an integer, or a floating point value. In scalar variables, a value that was assigned as a string can be used as an integer whenever it makes sense to do so, and vice versa. For example, consider the program in file LIST 16_2 on the CD-ROM, which converts distances from miles to kilometers and vice versa. In this example, the scalar variable $originaldist contains the character string read in from the standard input file. The contents of this string are then treated as a number, multiplied by the miles-to-kilometers and kilometers-to-miles conversion factors, and stored in $miles and $kilometers.

This program also contains a call to the function chop(). This function throws away the last character in the specified string. In this case, chop() gets rid of the newline character at the end of the input line.

If a string contains characters that are not digits, it is converted to 0:

# this assigns 0 to $a, since "hello" becomes 0

$a = "hello" * 5;

In cases like this, Perl does not tell you that anything has gone wrong, and your results may not be what you expect.

Also, strings containing misprints yield unexpected results:

$a = "12O34"+1       # the letter O, not the number 0

When Perl sees a string in the middle of an expression, it converts the string to an integer. To do this, it starts at the left of the string and continues until it sees a letter that is not a digit. In this case, "12O34" is converted to the integer 12, not 12034.

Using Scalar Variable Operators

The statement $miles = $originaldist * 0.6214; uses two scalar variable operators: =, the assignment operator, which assigns a value to a variable, and *, the multiplication operator, which multiplies two values.

Perl provides the complete set of operators found in C, plus a few others. These operators are described in the following sections.

Performing Arithmetic

To do arithmetic in Perl, use the arithmetic operators.

Perl supports the following arithmetic operators:

$a = 15;            # assignment: $a now has the value 15

$a = 4 + 5.1;       # addition: $a is now 9.1

$a = 17 - 6.2;      # subtraction: $a is now 10.8

$a = 2.1 * 6;       # multiplication: $a is now 12.6

$a = 48 / 1.5;      # division: $a is now 32

$a = 2 ** 3;        # exponentiation: $a is now 8

$a = 21 % 5;        # remainder (modulo): $a is now 1

$a = - $b;          # arithmetic negation: $a is now $b * -1

Non-integral values are converted to integers before a remainder operation is performed:

$a = 21.4 % 5.1;    # identical to 21 % 5

Performing Comparisons

To compare two scalar values in Perl, use the logical operators.

Logical operators are divided into two classes: numeric and string. The following numeric logical operators are defined:

11.0 < 16           # less than

16 > 11             # greater than

15 == 15            # equals

11.0 <= 16          # less than or equal to

16 >= 11            # greater than or equal to

15 != 14            # not equal to

$a || $b            # logical OR:  true if either is non-zero

$a && $b            # logical AND:  true only if both are non-zero

! $a                # logical NOT:  true if $a is zero

In each case, the result of the operation performed by a logical operator is non-zero if true and zero if false, just like in C.

The expression on the left side of a || (logical or) operator is always tested before the expression on the right side, and the expression on the right side is only used when necessary. For example, consider the following expression:

$x == 0 || $y / $x > 5

Here, the expression on the left side of the ||, $x == 0, is tested first. If $x is zero, the result is true regardless of the value of $y / $x > 5, so Perl doesn't bother to compute this value. $y / $x > 5 is only evaluated if s is not zero. This ensures that division by zero can never occur.

Similarly, the expression on the right side of a && operator is only tested if the expression on the left side is true:

$x != 0 && $y / $x > 5

Once again, a division by zero error is impossible, because $y / $x > 5 is only evaluated if $x is non-zero.

Perl also defines the <=> operator, which returns 0 if the two values are equal, -1 if the left value is larger, and 1 if the right value is larger:

4 <=> 1             # returns -1

3 <=> 3.0           # returns 0

1 <=> 4.0           # returns 1

CAUTION: Be careful when you use floating point numbers in comparison operations, because the result may not be what you expect. Consider the following code fragment:

$val1 = 14.3;
$val2 = 100 + 14.3 - 100;
print "val1 is $val1, val2 is $val2\n";

On first examination, $val1 and $val2 appear to contain the same value, 14.3. However, the print statement produces the following:

val1 is 14.300000000000001, val2 is 14.299999999999997

Adding and subtracting 100 affects the value stored in $val2 because of the way floating point values are calculated and stored on the machine. As a result, $val1 and $val2 are not the same, and $val1 == $val2 is not true.

This problem occurs in most programming languages (including C).

Besides the preceding numeric logical operators, Perl also provides logical operators that work with strings:

"aaa" lt "bbb"      # less than

"bbb" gt "aaa"      # greater than

"aaa" eq "aaa"      # equals

"aaa" le "bbb"      # less than or equal to

"bbb" ge "aaa"      # greater than or equal to

"aaa" ne "bbb"      # not equal to

Perl also defines the cmp operator, which, like the numeric operator <=>, returns -1, 0 or 1:

"aaa" cmp "bbb"     # returns -1

"aaa" cmp "aaa"     # returns 0

"bbb" cmp "aaa"     # returns 1

This behavior is identical to that of the C function strcmp().

Note that the logical string operators perform string comparisons, not numeric comparisons. For example, "40" lt "8" is true—if the two strings are sorted in ascending order, "40" appears before "8".

Manipulating Bits

Any integer can always be represented in binary or base-2 notation, of course. For example, the number 38 is equivalent to the binary value 100110: 32 plus 4 plus 2. Each 0 or 1 in this binary value is called a bit.

If a Perl scalar value happens to be an integer, Perl allows you to manipulate the bits that make up that integer. To do this, use the Perl bitwise operators.

The following bitwise operators are supported in Perl:

The & (bitwise AND) operator
The | (bitwise OR) operator
The ^ (bitwise EXOR, or exclusive OR) operator
The ~ (bitwise NOT) operator
The << (left shift) and >> (right shift) operators

If a scalar value is not an integer, it is converted to an integer before a bitwise operation is performed:

$a = 24.5 & 11.2    # identical to $a = 24 & 11

The & operator works as follows: first, it examines the values on either side of the &. (These values are also known as the operands of the & operator.) These values are examined in their binary representations. For example, consider the following bitwise operation:

$a = 29 & 11;

In this case, the 29 is converted to 11101, and the 11 is converted to 01011. (A binary representation can have as many leading zeroes as you like.)

Next, Perl compares each bit of the first operand with the corresponding bit in the second operand:

11101

01011

In this case, only the second and fifth bits (from the left) of the two operands are both 1; therefore, the binary representation of the result is 01001, or 9.

The | operator works in much the same way. The bits of the two operands are compared one at a time; if a bit in the first operand is 1 or its corresponding bit in the second operand is 1, the bit in the result is set to 1. Consider this example:

$a = 25 | 11;

Here, the binary representations are 11001 and 01011. In this case, only the third bits are both 0, and the result is 11011 or 27.

The ^ operator sets a result bit to 1 if exactly one of the corresponding bits in an operand is 1. If both bits are 1 or both are 0, the result bit is set to 0. In the example $a = 25 ^ 11; the binary representations of the operands are 11001 and 01011, and the result is 10010, or 18.

The ~ operator works on one operand. Every 0 bit in the operand is changed to a 1 and vice versa. For example, consider the following:

$a = ~ 25;

Here, the binary representation of 25 is 11001. The result, therefore, is 00110, or 6.

The << operator shifts the bits of the left operand the number of places specified by the right operand, and fills the vacated places with zeroes:

$a = 29 << 2;

Here the value 29, whose binary representation is 11101, is shifted left two positions. This produces the result 1110100, or 116.

Similarly, the >> operator shifts the bits rightward, with the rightmost bits being lost:

$a = 29 >> 2;

In this case, 29, or 11101, is shifted right two places. The 01 on the end is thrown away, and the result is 111, or 7.

Shifting left one bit is equivalent to multiplying by 2:

$a = 54 << 1;       # this result is 108

$a = 54 * 2;        # this result is also 108

Shifting right one bit is equivalent to dividing by 2:

$a = 54 >> 1;       # this result is 27

$a = 54 / 2;        # this result is also 27

Similarly, shifting left or right n bits is equivalent to multiplying or dividing by 2**n.

Using the Assignment Operators

The most common assignment operator is the = operator, which you've already seen:

$a = 9;

Here, the value 9 is assigned to the scalar variable $a.

Another common assignment operator is the += operator, which combines the operations of addition and assignment:

$a = $a + 1;        # this adds 1 to $a

$a += 1;            # this also adds 1 to $a

Other assignment operators exist that correspond to the other arithmetic and bitwise operators:

$a -= 1;            # same as $a = $a - 1

$a *= 2;            # same as $a = $a * 2

$a /= 2;            # same as $a = $a / 2

$a %= 2;            # same as $a = $a % 2

$a **= 2;           # same as $a = $a ** 2

$a &= 2;            # same as $a = $a & 2

$a |= 2;            # same as $a = $a | 2

$a ^= 2;            # same as $a = $a ^ 2

Using Autoincrement and Autodecrement

Another way to add 1 to a scalar variable is with the ++, or autoincrement, operator:

++$a;               # same as $a += 1 or $a = $a + 1

This operator can appear either before or after its operand:

$a++;               # also equivalent to $a += 1 and $a = $a + 1

The ++ operator can also be part of a more complicated sequence of operations. (A code fragment consisting of a sequence of operations and their values is known as an expression.) Consider the following statements:

$b = ++$a;

$b = $a++;

In the first statement, the ++ operator appears before its operand. This tells Perl to add 1 to $a before assigning its value to $b:

$a = 7;

$b = ++$a;          # $a and $b are both 8

If the ++ operator appears after the operand, Perl adds 1 to $a after assigning its value to $b:

$a = 7;

$b = $a++;          # $a is now 8, and $b is now 7

Similarly, the —, or autodecrement, operator subtracts 1 from the value of a scalar variable either before or after assigning the value:

$a = 7;

$b = —$a;          # $a and $b are both 6

$a = 7;

$b = $a—;          # $a is now 6, and $b is now 7

The ++ and — operators provide a great deal of flexibility, and are often used in loops and other control structures.

Do not use the ++ and — operators on the same variable more than once in the same expression:

$b = ++$a + $a++;

The value assigned to $b depends on which of the operands of the + operator is evaluated first. On some systems, the first operand (++$a) is evaluated first. On others, the second operand ($a++) is evaluated first.

You can ensure that you get the result you want by using multiple statements and the appropriate assignment operator:

$b = ++$a;

$b += $a++;

Concatenating and Repeating Strings

Perl provides three operators that operate on strings: The . operator, which joins two strings together; the x operator, which repeats a string; and the .= operator, which joins and then assigns.

The . operator joins the second operand to the first operand:

$a = "be" . "witched";      # $a is now "bewitched"

This join operation is also known as string concatenation.

The x operator (the letter x) makes n copies of a string, where n is the value of the right operand:

$a = "t" x 5;               # $a is now "ttttt"

The .= operator combines the operations of string concatenation and assignment:

$a = "be";

$a .= "witched";            # $a is now "bewitched"

Using Other C Operators

Perl also supports the following operators, found in the C programming language: The , (comma) operator, and the ? and : (conditional) operator combination.

The , operator ensures that one portion of an expression is evaluated first:

$x += 1, $y = $x;

The , operator breaks this expression into two parts:

$x += 1

$y = $x

The part before the comma is performed first. Thus, 1 is added to $x and then $x is assigned to $y.

The ? and : combination allows you to test the value of a variable and then perform one of two operations based on the result of the test. For example, in the expression $y = $x == 0 ? 15 : 8 the variable $x is compared with zero. If $x equals zero, $y is assigned 15; if $x is not zero, $y is assigned 8.

Matching Patterns

Perl allows you to examine scalar variables and test for the existence of a particular pattern in a string. To do this, use the =~ (pattern matching) operator:

$x =~ /jkl/

The character string enclosed by the / characters is the pattern to be matched, and the scalar variable on the left of the =~ operator is the variable to be examined. This example searches for the pattern jkl in the scalar variable $x. If $x contains jkl, the expression is true; if not, the expression is false. In the statement $y = $x =~ /jkl/;, $y is assigned a non-zero value if $x contains jkl, and is assigned zero if $x does not contain jkl.

The !~ operator is the negation of =~:

$y = $x !~ /jkl/;

Here, $y is assigned zero if $x contains jkl, and a non-zero value otherwise.

Using Special Characters in Patterns

You can use several special characters in your patterns. The * character matches zero or more of the character it follows:

/jk*l/

This matches jl, jkl, jkkl, jkkkl, and so on.

The + character matches one or more of the preceding character:

/jk+l/

This matches jkl, jkkl, jkkkl, and so on.

The ? character matches zero or one copies of the preceding character:

/jk?l/

This matches jl or jkl.

The character . matches any character except the newline character:

/j.l/

This matches any pattern consisting of a j, any character, and an l.

If a set of characters is enclosed in square brackets, any character in the set is an acceptable match:

/j[kK]l/            # matches jkl or jKl

Consecutive alphanumeric characters in the set can be represented by a dash (-):

/j[k1-3K]l/         # matches jkl, j1l, j2l, j3l or jKl

You can specify that a match must be at the start or end of a line by using ^ or $:

/^jkl/              # matches jkl at start of line

/jkl$/              # matches jkl at end of line

/^jkl$/             # matches line consisting of exactly jkl

You can specify that a match must be either on a word boundary or inside a word by including \b or \B in the pattern:

/\bjkl/             # matches jkl, but not ijkl

/\Bjkl/             # matches ijkl, but not jkl

Some sets are so common that special characters exist to represent them:

\d matches any digit, and is equivalent to [0-9].
\w matches any character that can appear in a variable name; it is equivalent to [A-Za-z_0-9].
\s matches any whitespace (any character not visible on the screen); it is equivalent to [ \r\t\n\f]. (These backslash characters were explained in "Using Double- and Single-Quoted Strings" earlier in this chapter.)

To match all but a specified set of characters, specify ^ at the start of your set:

/j[^kK]l/

This matches any string containing j, any character but k or K, and l.

To use a special character as an ordinary character, precede it with a backslash (\):

/j\*l/              # this matches j*l

This matches j*l.

In patterns, the * and + special characters match as many characters in a string as possible. For example, consider the following:

$x = "abcde";

$y = $x =~ /a.*/;

The pattern /a.*/ can match a, ab, abc, abcd, or abcde. abcde is matched, since it is the longest. This becomes meaningful when patterns are used in substitution.

Substituting and Translating Using Patterns

You can use the =~ operator to substitute one string for another:

$val =~ s/abc/def/;    # replace abc with def

$val =~ s/a+/xyz/;     # replace a, aa, aaa, etc., with xyz

$val =~ s/a/b/g;        # replace all a's with b's

Here, the s prefix indicates that the pattern between the first / and the second is to be replaced by the string between the second / and the third.

You can also translate characters using the tr prefix:

$val =~ tr/a-z/A-Z/;   # translate lower case to upper

Here, any character matched by the first pattern is replaced by the corresponding character in the second pattern.

The Order of Operations

Consider the following statement:

$a = 21 * 2 + 3 << 1 << 2 ** 2;

The problem: Which operation should be performed first?

The following sections answer questions of this type.

Precedence

In standard grade-school arithmetic, certain operations are always performed before others. For example, multiplication is always performed before addition:

4 + 5 * 3

Because multiplication is performed before addition, it has higher precedence than addition.

Table 16.2 defines the precedence of the Perl operators described in these sections. The items at the top of the table have the highest precedence, and the items at the bottom have the lowest.

Table 16.2. Operator Precedence in Perl.

++, —	Autoincrement and autodecrement
-, ~, !	Operators with one operand
**	Exponentiation
=~, !~	Matching operators
*, /, %, x	Multiplication, division, remainder, repetition
+, -, .	Addition, subtraction, concatenation
<<, >>	Shifting operators
-e, -r, etc.	File status operators
<, <=, >, >=, lt, le, gt, ge	Inequality comparison operators
==, !=, <=>, eq, ne, cmp	Equality comparison operators
&	Bitwise AND
\|, ^	Bitwise OR and exclusive OR
&&	Logical AND
\|\|	Logical OR
..	List range operator
? and :	Conditional operator
=, +=, -=, *=, etc.	Assignment operators
,	Comma operator

For example, consider the following statement:

$x = 11 * 2 + 6 ** 2 << 2;

The operations in this statement are performed in the following order:

6 ** 2, yielding 36.
11 * 2, yielding 22.
36 + 22, yielding 58.
58 << 2, yielding 116.

Therefore, 116 is assigned to $x.

This operator precedence table contains some operators that are defined in later sections. The .. (list range) operator is defined in "Using Lists and Array Variables." The file status operators are described in "Reading from and Writing to Files."

Associativity

Consider the following statement:

$x = 2 + 3 - 4;

In this case, it doesn't matter whether the addition (2 + 3) or the subtraction (3 - 4) is performed first, because the result is the same either way. However, for some operations, the order of evaluation makes a difference:

$x = 2 ** 3 ** 2;

Is $x assigned 64 (8 ** 2) or 512 (2 ** 9)?

To resolve these problems, Perl associates a specified associativity with each operator. If an operator is right-associative, the rightmost operator is performed first when two operators have the same precedence:

$x = 2 ** 3 ** 2;    # the same as $x = 2 ** 9, or $x = 512

If an operator is left-associative, the leftmost operator is performed first when two operators have the same precedence:

$x = 29 % 6 * 2;     # the same as $x = 5 * 2, or $x = 10

The following operators in Perl are right-associative:

The assignment operators (=, +=, and so on)
The ? and : operator combination
The ** operator (exponentiation)
The operators that have only one operand (!, ~ and -)

All other operators are left-associative.

Forcing Precedence Using Parentheses

Perl allows you to force the order of evaluation of operations in expressions. To do this, use parentheses:

$x = 4 * (5 + 3);

In this statement, 5 is added to 3 and then multiplied by 4, yielding 32.

You can use as many sets of parentheses as you like:

$x = 4 ** (5 % (8 - 6));

Here, the result is 4:

8 - 6 is performed, leaving 4 ** (5 % 2)
5 % 2 is performed, leaving 4 ** 1
4 ** 1 is 4

Using Lists and Array Variables

So far, the Perl programs you have seen have only used scalar data and scalar variables. In other words, they have only dealt with one value at a time.

Perl also allows you to manipulate groups of values, known as lists or arrays. These lists can be assigned to special variables known as array variables, which can be processed in a variety of ways.

This section describes lists and array variables, and how to use them. It also describes how to pass command-line arguments to your program using the special-purpose array @ARGV.

Introducing Lists

A list is a collection of scalar values enclosed in parentheses. The following is a simple example of a list:

(1, 5.3, "hello", 2)

This list contains four elements, each of which is a scalar value: the numbers 1 and 5.3, the string "hello", and the number 2. As always in Perl, numbers and character strings are interchangeable: each element of a list can be either a number or a string.

A list can contain as many elements as you like (or as many as your machine's memory can store at one time). To indicate a list with no elements, just specify the parentheses:

()                  # this list is empty

Scalar Variables and Lists

Lists can also contain scalar variables:

(17, $var, "a string")

Here, the second element of the list is the scalar variable $var. When Perl sees a scalar variable in a list, it replaces the scalar variable with its current value.

A list element can also be an expression:

(17, $var1 + $var2, 26 << 2)

Here, the expression $var1 + $var2 is evaluated to become the second element, and the expression 26 << 2 is evaluated to become the third element.

Scalar variables can also be replaced in strings:

(17, "the answer is $var1")

In this case, the value of $var1 is placed into the string.

Using List Ranges

Suppose that you want to define a list consisting of the numbers 1 through 10, inclusive. You can do this by typing in each of the numbers in turn:

(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)

However, there is a simpler way to do it: use the list range operator, which is .. (two consecutive periods). The following is a list created using the list range operator:

(1..10)

This tells Perl to define a list whose first value is 1, whose second value is 2, and so on up to 10.

The list range operator can be used to define part of a list:

(2, 5..7, 11)

This list consists of five elements: the numbers 2, 5, 6, 7 and 11.

List range operators can also be used with floating-point values:

(2.1..5.3)

This list consists of four elements: 2.1, 3.1, 4.1, and 5.1. Each element of the list is one greater than the previous element, and the last element of the list is the largest possible number less than or equal to the number to the right of the .. operator. (If the value to the left of the .. operator is greater than the value to the right, an empty list is created.)

Elements that define the range of a list range operator can be expressions, and these expressions can contain scalar variables:

($a..$b+5)

This list consists of all values between the current value of $a and the current value of the expression $b+5.

Storing Lists in Array Variables

Perl allows you to store lists in special variables designed for that purpose. These variables are called array variables.

The following is an example of a list being assigned to an array variable:

@array = (1, 2, 3);

Here, the list (1, 2, 3) is assigned to the array variable @array.

Note that the name of the array variable starts with the character @. This allows Perl to distinguish array variables from other kinds of variables, such as scalar variables, which start with the character $. As with scalar variables, the second character of the variable name must be a letter, and subsequent characters of the name can be letters, numbers, or underscores.

When an array variable is first created (seen for the first time), it is assumed to contain the empty list () unless something is assigned to it.

Because Perl uses @ and $ to distinguish array variables from string variables, the same name can be used in an array variable and in a string variable:

$var = 1;

@var = (11, 27.1, "a string");

Here, the name var is used in both the string variable $var and the array variable @var. These are two completely separate variables.

Assigning to Array Variables

As you have already seen, lists can be assigned to array variables with the assignment operator =:

@x = (11, "my string", 27.44);

You can also assign one array variable to another:

@y = @x;

A scalar value can be assigned to an array variable:

@x = 27.1;

@y = $x;

In this case, the scalar value (or value stored in a scalar variable) is converted into a list containing one element.

Using Array Variables in Lists

As you have already seen, lists can contain scalar variables:

@x = (1, $y, 3);

Here, the value of the scalar variable $y becomes the second element of the list assigned to @x.

You can also specify that the value of an array variable is to appear in a list:

@x = (2, 3, 4);

@y = (1, @x, 5);

Here, the list (2, 3, 4) is substituted for @x, and the resulting list (1, 2, 3, 4, 5) is assigned to @y.

Assigning to Scalar Variables from Array Variables

Consider the following assignment:

@x = ($a, $b);

Here, the values of the scalar variables $a and $b are used to form a two-element list that is assigned to the array variable @x.

Perl also allows you to take the current value of an array variable and assign its components to a group of scalar variables:

($a, $b) = @x;

Here, the first element of the list currently stored in @x is assigned to $a, and the second element is assigned to $b. Additional elements in @x, if they exist, are not assigned.

If there are more scalar variables than elements in an array variable, the excess scalar variables are given the value "" (the null string), which is equivalent to the numeric value 0:

@x = (1, 2);

($a, $b, $c) = @x;  # $a is now 1, $b is now 2, $c is now ""

Retrieving the Length of a List

As you have already seen, when a scalar value is assigned to an array variable, the value is assumed to be a list containing one element. For example, the following statements are equivalent:

@x = $y;

@x = ($y);

However, the converse is not true. In the statement $y = @x;, the value assigned to $y is the number of elements in the list currently stored in @x:

@x = ("string 1", "string 2", "string 3");

$y = @x;            # $y is now 3

To assign the value of the first element of a list to a scalar variable, enclose the scalar variable in a list:

@x = ("string 1", "string 2", "string 3");

($y) = @x;          # $y is now "string 1"

Using Array Slices

Perl allows you to specify what part of an array to use in an expression. The following example shows you how to do this:

@x = (1, 2, 3);

@y = @x[0,1];

Here, the list (1, 2, 3) is first assigned to the array variable @x. Then, the array slice [0,1] is assigned to @y: in other words, the first two elements of @x are assigned to @y. (Note that the first element of the array is specified by 0, not 1.)

You can assign to an array slice as well:

@x[0,1] = (11.5, "hello");

This statement assigns the value 11.5 to the first element of the array variable @x, and assigns the string "hello" to the second.

Array variables automatically grow when necessary, with null strings assigned to fill any gaps:

@x = (10, 20, 30);

@x[4,5] = (75, 85);

Here, the second assignment increases the size of the array variable @x from three elements to six, and assigns 75 to the fifth element and 85 to the sixth. The fourth element is set to be the null string.

Using Array Slices with Scalar Variables

An array slice can consist of a single element. In this case, the array slice is treated as if it is a scalar variable:

@x = (10, 20, 30);

$y = $x[1];         # $y now has the value 20

Note that the array slice is now preceded by the character $, not the character @. This tells Perl that the array slice is to be treated as a scalar variable.

Recall that array variables and scalar variables can have the same name:

$x = "Smith";

@x = (47, "hello");

Here, the scalar variable $x and the array variable @x are both defined, and are completely independent of one another. This can cause problems if you want to include a scalar variable inside a string:

$y = "Refer to $x[1] for more information.";

In this case, Perl assumes that you want to substitute the value of the array slice $x[1] into the string. This produces the following:

$y = "Refer to hello for more information.";

To specify the scalar variable and not the array slice, enclose the variable name in braces:

$y = "Refer to ${x}[1] for more information.";

This tells Perl to replace $x, not $x[1], and produces the following:

$y = "Refer to Smith[1] for more information.";

Using the Array Slice Notation as a Shorthand

So far, we have been using the array slice notation @x[0,1] to refer to a portion of an array variable. As it happens, in Perl the above is exactly equivalent to a list of single-element array slices:

@y = @x[0,1];

@y = ($x[0], $x[1]);   # these two statements are identical

This allows you to use the array slice notation whenever you want to refer to more than one element in an array:

@y = @x[4,1,5];

In this statement, the array variable @y is assigned the values of the fifth, second, and sixth elements of the array variable @x.

@y[0,1,2] = @x[1,1,1];

Here, the second element of @x is copied to the first three elements of @y.

In Perl, assignments in which the operands overlap are handled without difficulty. Consider this example:

@x[4,3] = @x[3,4];

Perl performs this assignment by creating a temporary array variable, copying @x[3,4] to it, and then copying it to @x[4,3]. Thus, this statement swaps the values in the fourth and fifth elements of @x.

Other Array Operations

Perl provides a number of built-in functions that work on lists and array variables. For example, you can sort array elements in alphabetic order, reverse the elements of an array, remove the last character from all elements of an array, and merge the elements of an array into a single string.

Sorting a List or Array Variable

The built-in function sort() sorts the elements of an array in alphabetic order and returns the sorted list:

@x = ("this", "is", "a", "test");

@x = sort (@x);     # @x is now ("a", "is", "test", "this")

Note that the sort is in alphabetic, not numeric, order:

@x = (70, 100, 8);

@x = sort (@x);     # @x is now ("100", "70", "8")

The number 100 appears first because the string "100" is alphabetically ahead of "70" (since "1" appears before "7").

Reversing a List or Array Variable

The function reverse() reverses the order of the elements in a list or array variable and returns the reversed list:

@x = ("backwards", "is", "array", "this");

@x = reverse(@x);   # @x is now ("this", "array", "is", "backwards")

You can sort and reverse the same list:

@x = reverse(sort(@x));

This produces a sort in reverse alphabetical order.

Using chop() on Array Variables

The chop() function can be used on array variables as well as scalar variables:

$a[0] = <STDIN>;

$a[1] = <STDIN>;

$a[2] = <STDIN>;

chop(@a);

Here, three input lines are read into the array variable @a—one in each of the first three elements. chop() then removes the last character (in this case, the terminating newline character) from all three elements.

Creating a Single String from a List

To create a single string from a list or array variable, use the function join():

$x = join(" ", "this", "is", "a", "sentence");

The first element of the list supplied to join() contains the characters that are to be used to glue the parts of the created string together. In this example, $x becomes "this is a sentence".

join() can specify other join strings besides " ":

@x = ("words","separated","by");

$y = join("::",@x,"colons");

Here, $y becomes "words::separated::by::colons".

To undo the effects of join(), call the function split():

$y = "words::separated::by::colons";

@x = split(/::/, $y);

The first element of the list supplied to split() is a pattern to be matched. When the pattern is matched, a new array element is started and the pattern is thrown away. In this case, the pattern to be matched is ::, which means that @x becomes ("words", "separated", "by", "colons").

Note that the syntax for the pattern is the same as that used in the =~ operator; see "Matching Patterns" for more information on possible patterns to match.

Example: Sorting Words in a String

The example in LIST 16_2 on the CD-ROM uses split(), join(), and sort() to sort the words in a string.

Using Command Line Arguments

The special array variable @ARGV is automatically defined to contain the strings entered on the command line when a Perl program is invoked. For example, if the program

#!/usr/bin/perl

print("The first argument is $ARGV[0]\n");

is called printfirstarg, entering the command

printfirstarg 1 2 3

produces the following output:

The first argument is 1

You can use join() to turn @ARGV into a single string, if you like:

#!/usr/bin/perl

$commandline = join(" ", @ARGV);

print("The command line arguments: $commandline\n");

If this program is called printallargs, entering

printallargs 1 2 3

produces

The command line arguments: 1 2 3

Note that $ARGV[0], the first element of the @ARGV array variable, does not contain the name of the program. For example, in the invocation

printallargs 1 2 3

$ARGV[0] is "1", not "printallargs". This is a difference between Perl and C: in C, argv[0] is "printallargs" and argv[1] is "1".

Standard Input and Array Variables

Since an array variable can contain as many elements as you like, you can assign an entire input file to a single array variable:

@infile = <STDIN>;

This works as long as you have enough memory to store the entire file.

Controlling Program Flow

Like all programming languages, Perl allows you to include statements that are only executed when specified conditions are true; these statements are called conditional statements.

The following is a simple example of a conditional statement:

if ($x == 14) {

        print("\$x is 14\n");

}

Here, the line if ($x == 14) { tells Perl that the following statements—those between the { and }—are only to be executed if $x is equal to 14.

Perl provides a full range of conditional statements; these statements are described in the following sections.

Conditional Execution The if Statement

The if conditional statement has the following structure:

if (expr) {

        ...

}

When Perl sees the if, it evaluates the expression expr to be either true or false. If the value of the expression is the integer 0, the null string "", or the string "0", the value of the expression is false; otherwise, the value of the expression is true.

CAUTION: The only string values that evaluate to false are "" and "0". Strings such as "00" and "0.0" return true, not false.

Two-Way Branching Using if and else

The else statement can be combined with the if statement to allow for a choice between two alternatives:

if ($x == 14) {

        print("\$x is 14\n");

} else {

        print("\$x is not 14\n");

}

Here, the expression following the if is evaluated. If it is true, the statements between the if and the else are executed. Otherwise, the statements between the else and the final } are executed. In either case, execution then proceeds to the statement after the final }.

Note that the else statement cannot appear by itself: it must follow an if statement.

Multi-Way Branching Using elsif

The elsif statement allows you to write a program that chooses between more than two alternatives:

if ($x == 14) {

        print("\$x is 14\n");

} elsif ($x == 15) {

        print("\$x is 15\n");

} elsif ($x == 16) {

        print("\$x is 16\n");

} else {

        print("\$x is not 14, 15 or 16\n");

}

Here, the expression $x == 14 is evaluated. If it evaluates to true (if $x is equal to 14), the first print() statement is executed. Otherwise, the expression $x == 15 is evaluated. If $x == 15 is true, the second print() is executed; otherwise, the expression $x == 16 is evaluated, and so on.

You can have as many elsif statements as you like; however, the first elsif statement of the group must be preceded by an if statement.

The else statement can be omitted:

if ($x == 14) {

        print("\$x is 14\n");

} elsif ($x == 15) {

        print("\$x is 15\n");

} elsif ($x == 16) {

        print("\$x is 16\n");

} # do nothing if $x is not 14, 15 or 16

If the else statement is included, it must follow the last elsif.

Conditional Branching Using unless

The unless statement is the opposite of the if statement:

unless ($x == 14) {

        print("\$x is not 14\n");

}

Here, the statements between the braces are executed unless the value of the expression evaluates to true.

You can use elsif and else with unless, if you like; however, an if-elsif-else structure is usually easier to follow than an unless-elsif-else one.

Repeating Statements Using while and until

In the examples above, each statement between braces is executed once, at most. To indicate that a group of statements between braces is to be executed until a certain condition is met, use the while statement:

#!/usr/bin/perl

$x = 1;

while ($x <= 5) {

        print("\$x is now $x\n");

        ++$x;

}

Here, the scalar variable $x is first assigned the value 1. The statements between the braces are then executed until the expression $x <= 5 is false.

When you run the program shown above, you get the following output:

$x is now 1

$x is now 2

$x is now 3

$x is now 4

$x is now 5

As you can see, the statements between the braces have been executed five times.

The until statement is the opposite of while:

#!/usr/bin/perl

$x = 1;

until ($x <= 5) {

        print("\$x is now $x\n");

        ++$x;

}

Here, the statements between the braces are executed until the expression $x <= 5 is true. In this case, the expression is true the first time it is evaluated, which means that the print() statement is never executed. To fix this, reverse the direction of the arithmetic comparison:

#!/usr/bin/perl

$x = 1;

until ($x > 5) {

        print("\$x is now $x\n");

        ++$x;

}

This now produces the same output as the program containing the while statement above.

CAUTION: If you use while, until, or any other statement that repeats, you must make sure that the statement does not repeat forever:

$x = 1;
while ($x == 1) {
print("\$x is still $x\n");
}

Here, $x is always 1, $x == 1 is always true, and the print() statement is repeated an infinite number of times.

Perl does not check for infinite loops such as this one above. It is your responsibility to make sure that infinite loops don't happen!

Using Single-Line Conditional Statements

If only one statement is to be executed when a particular condition is true, you can write your conditional statement using a single-line conditional statement. For example, instead of writing

if ($x == 14) {

        print("\$x is 14\n");

}

you can use the following single-line conditional statement:

print("\$x is 14\n") if ($x == 14);

In both cases, the print() statement is executed if $x is equal to 14.

You can also use unless, while, or until in a single-line conditional statement:

print("\$x is not 14\n") unless ($x == 14);

print("\$x is less than 14\n") while ($x++ < 14);

print("\$x is less than 14\n") until ($x++ > 14);

Note how useful the autoincrement operator ++ is in the last two statements: it allows you to compare $x and add one to it all at once. This ensures that the single-line conditional statement does not execute forever.

Looping with the for Statement

Most loops—segments of code that are executed more than once—use a counter to control and eventually terminate the execution of the loop. Here is an example similar to the ones you've seen so far:

$count = 1;                 # initialize the counter

while ($count <= 10) {      # terminate after ten repetitions

        print("the counter is now $count\n");

        $count += 1;        # increment the counter

}

As you can see, the looping process consists of three components:

The initialization of the counter variable
A test to determine whether to terminate the loop
The updating of the counter variable after the execution of the statements in the loop

Because a loop so often contains these three components, Perl provides a quick way to do them all at once by using the for statement. The following example uses the for statement and behaves the same as the example you just saw:

for ($count = 1; $count <= 10; $count += 1) {

        print("the counter is now $count\n");

}

Here the three components of the loop all appear in the same line, separated by semicolons. Because the components are all together, it is easier to remember to supply all of them, which makes it more difficult to write code that goes into an infinite loop.

Looping Through a List The foreach Statement

So far, all of the examples of loops that you've seen use a scalar variable as the counter. You can also use a list as a counter by using the foreach statement:

#!/usr/bin/perl

@list = ("This", "is", "a", "list", "of", "words");

print("Here are the words in the list: \n");

foreach $temp (@list) {

        print("$temp ");

}

print("\n");

Here, the loop defined by the foreach statement executes once for each element in the list @list. The resulting output is

Here are the words in the list:

     This is a list of words

The current element of the list being used as the counter is stored in a special scalar variable, which in this case is $temp. This variable is special because it is only defined for the statements inside the foreach loop:

#!/usr/bin/perl

$temp = 1;

@list = ("This", "is", "a", "list", "of", "words");

print("Here are the words in the list: \n");

foreach $temp (@list) {

        print("$temp ");

}

print("\n");

print("The value of temp is now $temp\n");

The output from this program is the following:

Here are the words in the list:

     This is a list of words 

The value of temp is now 1

The original value of $temp is restored after the foreach statement is finished.

Variables that only exist inside a certain structure, such as $temp in the foreach statement in the preceding example, are called local variables. Variables that are defined throughout a Perl program are known as global variables. Most variables you use in Perl are global variables. To see other examples of local variables, refer to "Using Subroutines."

CAUTION: Changing the value of the local variable inside a foreach statement also changes the value of the corresponding element of the list:

@list = (1, 2, 3, 4, 5);
foreach $temp (@list) {
if ($temp == 2) {
$temp = 20;
}
}

In this loop, when $temp is equal to 2, $temp is reset to 20. Therefore, the contents of the array variable @list become (1, 20, 3, 4, 5).

Exiting a Loop with the last Statement

Normally, you exit a loop by testing the condition at the top of the loop and then jumping to the statement after it. However, you can also exit a loop in the middle. To do this, use the last statement.

File LIST 16_5 on the CD-ROM totals a set of receipts entered one at a time; execution is terminated when a null line is entered. If a value entered is less than zero, the program detects this and exits the loop.

Using next to Start the Next Iteration of a Loop

In Perl, the last statement terminates the execution of a loop. To terminate a particular pass through a loop (also known as an iteration of the loop), use the next statement.

File LIST 16_4 on the CD-ROM sums up the numbers from 1 to a user-specified upper limit, and also produces a separate sum of the numbers divisible by two.

Be careful when you use next in a while or until loop. The following example goes into an infinite loop:

$count = 0;

while ($count <= 10) {

        if ($count == 5) {

                next;

        }

        $count++;

}

When $count is 5, the program tells Perl to start the next iteration of the loop. However, the value of $count is not changed, which means that the expression $count == 5 is still true.

To get rid of this problem, you need to increment $count before using next, as in:

$count = 0;

while ($count <= 10) {

        if ($count == 5) {

                $count++;

                next;

        }

        $count++;

}

This, by the way, is why many programming purists dislike statements such as next and last: it's too easy to lose track of where you are and what needs to be updated.

Perl automatically assumes that variables are initialized to be the null string, which evaluates to 0 in arithmetic expressions. This means that in code fragments such as

$count = 0;

while ($count <= 10) {

        ...

        $count++;}

you don't really need the $count = 0; statement. However, it is a good idea to explicitly initialize everything, even when you don't need to. This makes it easier to spot misprints:

$count = $tot = 0;

while ($count <= 10) {

   $total += $count;  # misprint: you meant to type "$tot"

        $count += 1;

}

print ("the total is $tot\n");

If you've gotten into the habit of initializing everything, it's easy to spot that $total is a misprint. If you use variables without initializing them, you first have to determine whether $total is really a different variable than $tot. This may be difficult if your program is a large and complicated one.

Using Labelled Blocks for Multi-Level Jumps

In Perl, loops can be inside other loops: such loops are said to be nested. To get out of an outer loop from within an inner loop, label the outer loop and specify its label when using last or next:

$total = 0;

$firstcounter = 1;

DONE: while ($firstcounter <= 10) {

        $secondcounter = 1;

        while ($secondcounter <= 10) {

                $total += 1;

                if ($firstcounter == 4 && $secondcounter == 7) {

                        last DONE;

                }

                $secondcounter += 1;

        }

        $firstcounter += 1;

}

The statement

last DONE;

tells Perl to jump out of the loop labelled DONE and continue execution with the first statement after the outer loop. (By the way, this code fragment is just a rather complicated way of assigning 37 to $total.)

Loop labels must start with a letter, and can consist of as many letters, digits, and underscores as you like. The only restriction is that you can't use a label name that corresponds to a word that has a special meaning in Perl:

if: while ($x == 0) {    # this is an error in perl

...

}

When Perl sees the if, it doesn't know whether you mean the label if or the start of an if statement.

Words such as if that have special meanings in Perl are known as reserved words or keywords.

Terminating Execution Using die

As you have seen, the last statement terminates a loop. To terminate program execution entirely, use the die() function.

To illustrate the use of die(), see File LIST 16_6 on the CD-ROM, a simple program that divides two numbers supplied on a single line. die() writes its argument to the standard error file, STDERR, and then exits immediately. In this example, die() is called when there are not exactly two numbers in the input line, or if the second number is zero.

If you like, you can tell die() to print the name of the Perl program and the line number being executed when the program was terminated. To do this, leave the closing newline character off the message:

die("This prints the filename and line number");

If the closing newline character is included, the filename and line number are not included:

die("This does not print the filename and line number\n");

Reading from and Writing to Files

So far, all of the examples have read from the standard input file, STDIN, and have written to the standard output file, STDOUT, and the standard error file, STDERR. You can also read from and write to as many other files as you like.

To access a file on your UNIX file system from within your Perl program, you must perform the following steps:

First, your program must open the file. This tells the system that your Perl program wants to access the file.
Then, the program can either read from or write to the file, depending on how you have opened the file.
Finally, the program can close the file. This tells the system that your program no longer needs access to the file.

The following sections describe these operations, tell you how you can read from files specified in the command line, and describe the built-in file test operations.

Opening a File

To open a file, call the built-in function open():

open(MYFILE, "/u/jqpublic/myfile");

The second argument is the name of the file you want to open. You can supply either the full UNIX pathname, as in /u/jqpublic/myfile, or just the filename, as in myfile. If only the filename is supplied, the file is assumed to be in the current working directory.

The first argument is an example of a file variable. Once the file has been opened, your Perl program accesses the file by referring to this variable. Your file variable name must start with a letter, and can then contain as many letters and digits as you like. (You must ensure, however, that your file variable name is not the same as a reserved word, such as if. See the note in "Using Labelled Blocks for Multi-Level Jumps" for more information on reserved words.)

By default, Perl assumes that you want to read any file that you open. To open a file for writing, put a > (greater than) character in front of your filename:

open(MYFILE, ">/u/jqpublic/myfile");

When you open a file for writing, any existing contents are destroyed. You cannot read from and write to the same file at the same time.

To append to an existing file, put two > characters in front of the filename:

open(MYFILE, ">>/u/jqpublic/myfile");

You still cannot read from a file you are appending to, but the existing contents are not destroyed.

Checking Whether the Open Succeeded

The open() function returns one of two values:

open() returns true (a non-zero value) if the open succeeds
open() returns false (zero) if an error occurs (that is, the file does not exist or you don't have permission to access the file)

You can use the return value from open() to test whether the file is actually available, and call die() if it is not:

unless (open(MYFILE, "/u/jqpublic/myfile")) {

        die("unable to open /u/jqpublic/myfile for reading\n");

}

This ensures that your program does not try to read from a nonexistent file.

You can also use the || (logical or) operator in place of unless:

open(MYFILE, "/u/jqpublic/myfile") ||

     die("unable to open /u/jqpublic/myfile for reading\n");

This works because the right side of the || operator is only executed if the left side is false. See "Performing Comparisons" for more information on the || operator.

Reading from a File

To read from a file, enclose the name of the file in angle brackets:

$line = <MYFILE>;

This statement reads a line of input from the file specified by the file variable MYFILE, and stores the line of input in the scalar variable $line. As you can see, you read from files in exactly the same way you read from the standard input file, STDIN.

Writing to a File

To write to a file, specify the file variable when you call the function print():

print MYFILE ("This is a line of text to write \n",

       "This is another line to write\n");

The file variable must appear before the first line of text to be written to the file.

This method works both when you are writing a new file and when you are appending to an existing one.

Closing a File

When you are finished reading from or writing to a file, you can tell the system that you are finished by calling close():

close(MYFILE);

Note that close() is not required: Perl automatically closes the file when the program terminates or when you open another file using a previously defined file variable.

Determining the Status of a File

As you have seen, when you open a file for writing, the existing contents of the file are destroyed. If you only want to open the file for writing if the file does not already exist, you can first test to see if a file exists. To do this, use the -e operator:

if (-e "/u/jqpublic/filename") {

        die ("file /u/jqpublic/filename already exists");

}

open (MYFILE, "/u/jqpublic/filename");

The -e operator assumes that its operand—a scalar value—is the name of a file. It checks to see if a file with that name already exists. If the file exists, the -e operator returns true; otherwise, it returns false.

Similar tests exist to test other file conditions. The most commonly used file status operators are listed in Table 16.3.

Table 16.3. File Status Operators.

-d	Is this file really a directory?
-e	Does this file exist?
-f	Is this actually a file?
-l	Is this file really a symbolic link?
-o	Is this file owned by the person running the program?
-r	Is this file readable by the person running the program?
-s	Is this a non-empty file?
-w	Is this file writeable by the person running the program?
-x	Is this file executable by the person running the program?
-z	Is this file empty?
-B	Is this a binary file?
-T	Is this a text file?

Reading from a Sequence of Files

Many UNIX commands have the form

command file1 file2 file3 ...

These commands operate on all of the files specified on the command line, starting with file1 and continuing on from there.

You can simulate this behavior in Perl. To do this, use the <> operator.

File LIST 16_7 on the CD-ROM counts all the times the word "the" appears in a set of files.

Suppose that this example is stored in a file named thecount. If the command thecount myfile1 myfile2 myfile3 is entered from the command line, the program starts by reading a line of input from the file myfile1 into the scalar variable $inputline. This input line is then split into words, and each word is tested to see if it is "the." Once this line is processed, the program reads another line from myfile1.

When myfile1 is exhausted, the program then begins reading lines from myfile2, and then from myfile3. When myfile3 is exhausted, the program prints the total number of occurrences of "the" in the three files.

Using Subroutines

Some programs perform the same task repeatedly. If you are writing such a program, you may soon get tired of writing the same lines of code over and over again. Perl provides a way around this problem: frequently used segments of code can be stored in separate sections, known as subroutines.

The following sections describe how subroutines work, how to pass values to subroutines and receive values from them, and how to define variables that only exist inside subroutines.

Defining a Subroutine

A common Perl task is to read a line of input from a file and break it into words. Here is an example of a subroutine that performs this task. Note that it uses the <> operator described in "Reading from a Sequence of Files."

sub getwords {

        $inputline = <>;

        @words = split(/\s+/, $inputline);

}

All subroutines follow this simple format: The reserved word sub, followed by the name of the subroutine (in this case, getwords), a { (open brace) character, one or more Perl statements (also known as the body of the subroutine), and a closing } (close brace) character.

The subroutine name must start with a letter, and can then consist of any number of letters, digits, and underscores. (As always, you must ensure that your variable name is not a reserved word. See the note in "Using Labelled Blocks for Multi-Level Jumps" for more information on reserved words.)

A subroutine can appear anywhere in a Perl program—even right in the middle, if you like. However, programs are usually easier to understand if the subroutines are all placed at the end.

Using a Subroutine

Once you have written your subroutine, you can use it by specifying its name. Here is a simple example that uses the subroutine getwords to count the number of occurrences of the word "the":

#!/usr/bin/perl

$thecount = 0;

&getwords;

while ($words[0] ne "") {     # stop when line is empty

        for ($index = 0; $words[$index] ne ""; $index += 1) {

                $thecount += 1 if $words[$index] eq "the";

        }

        &getwords;

}

print ("Total number of occurrences of the: $thecount\n");

The statement &getwords; tells Perl to call the subroutine getwords. When Perl calls the subroutine getwords, it executes the statements contained in the subroutine, namely

$inputline = <>;

@words = split(/\s+/, $inputline);

Once these statements have been executed, Perl then executes the statement immediately following the &getwords statement.

Returning a Value from a Subroutine

The getwords subroutine defined above is useful, but it suffers from one serious limitation: it assumes that the words from the input line are always going to be stored in the array variable @words. This may lead to problems:

@words = ("These", "are", "some", "words");

&getwords;

Here, calling getwords destroys the existing contents of @words.

To solve this problem, consider the subroutine getwords you saw earlier:

sub getwords {

        $inputline = <>;

        @words = split(/\s+/, $inputline);

}

In Perl subroutines, the last value seen by the subroutine becomes the subroutine's return value. In this example, the last value seen is the list of words assigned to @words. In the call to getwords, this value can be assigned to an array variable:

@words2 = &getwords;

Note that this hasn't yet solved the problem, since @words is still overwritten by the getwords subroutine. However, now you don't need to use @words in getwords, because you are assigning the list of words by using the return value. You can now change getwords to use a different array variable:

sub getwords {

        $inputline = <>;

        @subwords = split(/s+/, $inputline);

}

Now, the statements

@words = ("These", "are", "some", "words");

@words2 = &getwords;

work properly: @words is not destroyed when getwords is called. (For a better solution to this problem, see the following section, "Using Local Variables.")

Since the return value of a subroutine is the last value seen, the return value may not always be what you expect.

Consider the following simple program that adds numbers supplied on an input line:

#!/usr/bin/perl

$total = &get_total;

print("The total is $total\n");

sub get_total {

        $value = 0;

        $inputline = <STDIN>;

        @subwords = split(/\s+/, $inputline);

        $index = 0;

        while ($subwords[$index] ne "") {

                $value += $subwords[$index++];

        }

}

At first glance, you might think that the return value of the subroutine get_total is the value stored in $value. However, this is not the last value seen in the subroutine!

Note that the loop exits when $subwords[index] is the null string. Since no statements are processed after the loop exits, the last value seen in the subroutine is, in fact, the null string. Thus, the null string is the return value of get_total, and is assigned to $total.

To get around this problem, always have the last statement of the subroutine refer to the value you want to use as the return value:

sub get_total {

        $value = 0;

        $inputline = <STDIN>;

        @subwords = split(/\s+/, $inputline);

        $index = 0;

        while ($subwords[$index] ne "") {

                $value += $subwords[$index++];

        }

        $value;     # $value is now the return value

}

Now, get_total actually returns what you want it to.

Using Local Variables

As you saw in "Returning a Value from a Subroutine," defining variables that appear only in a subroutine ensures that the subroutine doesn't accidentally overwrite anything:

sub getwords {

        $inputline = <>;

        @subwords = split(/s+/, $inputline);

}

Note, however, that the variables $inputline and @subwords could conceivably be added to your program at a later time. Then, a call to getwords would once again accidentally destroy values that your program needs to keep.

You can ensure that the variables used in a subroutine are known only inside that subroutine by defining them as local variables. Here is the subroutine getwords with $inputline and @subwords defined as local variables:

sub getwords {

        local($inputline, @subwords);

        $inputline = <>;

        @subwords = split(/s+/, $inputline);

}

The local() statement tells Perl that versions of the variables $inputline and @subwords are to be defined for use inside the subroutine. Once a variable has been defined with local(), it cannot accidentally destroy values in your program:

@subwords = ("Some", "more", "words");

@words = getwords;

Here, @subwords is not destroyed, because the @subwords used in getwords is known only inside the subroutine.

Passing Values to a Subroutine

You can make your subroutines more flexible by allowing them to accept values.

As an example, here is the getwords subroutine modified to split the input line using a pattern that is passed to it:

sub getwords {

        local($pattern) = @_;

        local($inputline, @subwords);

        $inputline = <>;

        @subwords = split($pattern, $inputline);

}

The array variable @_ is a special system variable that contains a copy of the values passed to the subroutine. The statement local($pattern) = @_; creates a local scalar variable named $pattern and assigns the first value of the array, @_, to it.

Now, to call getwords you must supply the pattern you want it to use when splitting words. To split on white space, as before, call getwords as follows:

@words = getwords(/\s+/);

If your input line consists of words separated by colons, you can split it using getwords by calling it as follows:

@words = getwords(/:/);

If you like, you can even break your line into single characters:

@words = getwords(//);

For more information on patterns you can use, see "Matching Patterns."

The array variable @_ behaves like any other array variable. In particular, its components can be used as scalar values:

$x = $_[0];

Here, the first element of @_—the first value passed to the subroutine—is assigned to $x.

Usually, assigning @_ to local variables is the best approach, because your subroutine becomes easier to understand.

Calling Subroutines from Other Subroutines

If you like, you can have a subroutine call another subroutine you have written. For example, here is a subroutine that counts the number of words in an input line:

sub countline {

        local(@words, $count);

        $count = 0;

        @words = getwords(/\s+/);

        foreach $word (@words) {

                $count += 1;

        }

        $count;      # make sure the count is the return value

}

The subroutine countline first calls the subroutine getwords to split the input line into words. Then it counts the number of words in the array returned by getwords and returns that value.

Once you have written countline, it is easy to write a program called wordcount that counts the number of words in one or more files:

#!/usr/bin/perl

$totalwordcount = 0;

while (($wordcount = &countline) != 0) {

        $totalwordcount += $wordcount;

}

print("The total word count is $totalwordcount\n");

# include the subroutines getwords and countline here

This program reads lines until an empty line—a line with zero words—is read in. (It assumes that the files contain no blank lines. You can get around this problem by having getwords test whether $inputline is empty before breaking it into words, returning a special "end of file" value in this case. This value could then be passed from getwords to countline, and then to the main program.)

Because getwords uses the <> operator to read input, the files whose words are counted are those listed on the command line:

wordcount file1 file2 file3

This counts the words in the files file1, file2, and file3.

The variable @_ is a local variable whose value is only defined in the subroutine in which it appears. This allows subroutines to pass values to other subroutines: each subroutine has its own copy of @_ and none of the copies can destroy each other's values.

Associative Arrays

A common programming task is to keep counts of several different things at once. You can, of course, use scalar variables or array variables to solve this problem, but this requires a rather messy if-elsif structure:

if ($fruit eq "apple") {

        $apple += 1;

} elsif ($letter eq "banana") {

        $banana += 1;

} elsif ($letter eq "cherry") {

        $cherry += 1;

...

This takes up a lot of space, and is rather boring to write.

Fortunately, Perl provides an easier way to solve problems like these—associative arrays. The following sections describe associative arrays and how to manipulate them.

Defining Associative Arrays

In ordinary arrays, you access an array element by specifying an integer as the index:

@fruits = (9, 23, 11);

$count = $fruits[0];     # $count is now 9

In associative arrays, you do not have to use numbers such as 0, 1, and 2 to access array elements. When you define an associative array, you specify the scalar values you want to use to access the elements of the array. For example, here is a definition of a simple associative array:

%fruits = ("apple", 9,

           "banana", 23,

           "cherry", 11);

$count = $fruits{"apple"};  # $count is now 9

Here, the scalar value "apple" accesses the first element of the array %fruits, "banana" accesses the second element, and "cherry" accesses the third. You can use any scalar value you like as an array index, or any scalar value as the value of the array element:

%myarray = ("first index", 0,

            98.6, "second value",

            76, "last value");

$value = $myarray{98.6};   # $value is now "second value"

Associative arrays eliminate the need for messy if-elsif structures. To add 1 to an element of the %fruits array, for example, you just need to do the following:

$fruits{$fruit} += 1;

Better still, if you decide to add other fruits to the list, you do not need to add more code, because the preceding statement also works on the new elements.

The character % tells Perl that a variable is an associative array. As with scalar variables and array variables, the remaining characters of the associative array variable name must consist of a letter followed by one or more letters, digits, or underscores.

Accessing Associative Arrays

Since an associative array value is a scalar value, it can be used wherever a scalar value can be used:

$redfruits = $fruits{"apple"} + $fruits{"cherry"};

print("yes, we have no bananas\n") if ($fruits{"banana"} == 0);

Note that Perl uses braces (the { and } characters) to enclose the index of an associative array element. This makes it possible for Perl to distinguish between ordinary array elements and associative array elements.

Copying to and from Associative Arrays

Consider the following assignment, which initializes an associative array:

%fruits = ("apple", 9,

           "banana", 23,

           "cherry", 11);

The value on the right of this assignment is actually just the ordinary list, ("apple", 9, "banana", 23, "cherry", 11), grouped into pairs for readability. You can assign any list, including the contents of an array variable, to an associative array:

@numlist[0,1] = ("one", 1);

@numlist[2,3] = ("two", 2);

%numbers = @numlist;

$first = $numbers{"one"};    # $first is now 1

Whenever a list or an array variable is assigned to an associative array, the odd-numbered elements (the first, third, fifth, and so on) become the array indexes, and the even-numbered elements (the second, fourth, sixth, etc.) become the array values.

You can also assign an associative array to an array variable:

%numbers = ("one", 1,

            "two", 2);

@numlist = %numbers;

$first = $numlist[3];        # first is now 2

Here, the array indexes and array values both become elements of the array.

Adding and Deleting Array Elements

To add a new element to an associative array, just create a new array index and assign a value to its element. For example, to create a fourth element for the %fruits array, use the following:

$fruits{"orange"} = 1;

This statement creates a fourth element with index "orange" and gives it the value 1.

To delete an element, use the delete() function:

delete($fruits{"orange"});

This deletes the element indexed by "orange" from the array %fruits.

Listing Array Indexes and Values

The keys() function retrieves a list of the array indexes used in an associative array:

%fruits = ("apple", 9,

           "banana", 23,

           "cherry", 11);

@fruitindexes = keys(%fruits);

Here, @fruitindexes is assigned the list consisting of the elements "apple", "banana", and "cherry". Note that this list is in no particular order. To retrieve the list in alphabetic order, use sort() on the list:

@fruitindexes = sort(keys(%fruits));

This produces the list ("apple", "banana", "cherry").

To retrieve a list of the values stored in an associative array, use the function values():

%fruits = ("apple", 9,

           "banana", 23,

           "cherry", 11);

@fruitvalues = values(%fruits);

@fruitvalues now contains a list consisting of the elements 9, 23, and 11 (again, in no particular order).

Looping with an Associative Array

Perl provides a convenient way to use an associative array in a loop:

%fruits = ("apple", 9,

           "banana", 23,

           "cherry", 11);

while (($fruitname, $fruitvalue) == each(%fruitnames) {

        ...

}

The each() function returns each element of the array in turn. Each element is returned as a two-element list (array index, then array value). Again, the elements are returned in no particular order.

Formatting Your Output

So far, the only output produced has been raw, unformatted output produced using the print() function. However, you can control how your output appears on the screen or on the printed page. To do this, define print formats and use the write() function to print output using these formats.

The following sections describe print formats and how to use them.

Defining a Print Format

Here is an example of a simple print format:

format MYFORMAT =

===================================

Here is the text I want to display.

===================================

.

Here, MYFORMAT is the name of the print format. This name must start with a letter, and can consist of any sequence of letters, digits, or underscores.

The subsequent lines define what is to appear on the screen. Here, the lines to be displayed are a line of = characters followed by a line of text and ending with another line of = characters. A line consisting of a period indicates the end of the print format definition.

Like subroutines, print formats can appear anywhere in a Perl program.

Displaying a Print Format

To print using a print format, use the write() function. For example, to print the text in MYFORMAT, use

$~ = "MYFORMAT";

write();

This sends

===================================

Here is the text I want to display.

===================================

to the standard output file.

$~ is a special scalar variable used by Perl; it tells Perl which print format to use.

Displaying Values in a Print Format

To specify a value to be printed in your print format, add a value field to your print format. Here is an example of a print format that uses value fields:

format VOWELFORMAT =

==========================================================

Number of vowels found in text file:

          a: @<<<<< e: @<<<<< i: @<<<<< o: @<<<<< u: @<<<<<

$letter{"a"}, $letter{"e"}, $letter{"i"}, $letter{"o"}, $letter{"u"}

==========================================================

.

The line

a: @<<<<< e: @<<<<< i: @<<<<< o: @<<<<< u: @<<<<<

contains five value fields. Each value field contains special characters that provide information on how the value is to be displayed. (These special characters are described in the following section, "Choosing a Value Field Format.")

Any line that contains value fields must be followed by a line listing the scalar values (or variables containing scalar values) to be displayed in these value fields:

$letter{"a"}, $letter{"e"}, $letter{"i"}, $letter{"o"}, $letter{"u"}

The number of value fields must equal the number of scalar values.

Choosing a Value Field Format

The following value field formats are supported:

@<<<<	Left-justified output: width equals the number of characters supplied
@>>>>	Right-justified output: width equals the number of characters supplied
@\|\|\|\|	Centered output: width equals the number of characters supplied
@##.##	Fixed-precision numeric: . indicates location of decimal point
@*	Multi-line text

In all cases, the @ character is included when the number of characters in the field are counted. For example, the field @>>>> is five characters wide. Similarly, the field @###.## is seven characters wide: four before the decimal point, two after the decimal point, and the decimal point itself.

Writing to Other Output Files

You can also write to other files by using print formats and write(). For example, to write to the file represented by file variable MYFILE using print format MYFORMAT, use the following statements:

select(MYFILE);

$~ = "MYFORMAT";

write(MYFILE);

The select() statement indicates which file is to be written to, and the $~ = "MYFORMAT"; statement selects the print format to use.

Once an output file has been selected using select(), it stays selected until another select() is seen. This means that if you select an output file other than the standard output file, as in select(MYFILE);, output from write() won't go to the standard output file until Perl sees the statement select (MYFILE);.

There are two ways of making sure you don't get tripped up by this:

Always use STDOUT as the default output file. If you change the output file, change it back when you're done:

select(MYFILE);

$~ = "MYFORMAT";

write(MYFILE);

select(STDOUT);

Always specify the output file with select() before calling write():

select(STDOUT);

$~ = "MYFORMAT";

write();    # STDOUT is assumed

It doesn't really matter which solution you use, as long as you're consistent.

If you are writing a subroutine that writes to a particular output file, you can save the current selected output file in a temporary variable and restore it later:

$temp = select(MYFILE);   # select the output file

$~ = "MYFORMAT";

write(MYFILE);

select($temp); # restore the original selected output file

This method is also useful if you're in the middle of a large program and you don't remember which output file is currently selected.

Specifying a Page Header

You can specify a header to print when you start a new page. To do this, define a print format with the name filename_TOP, where filename is the name of the file variable corresponding to the file you are writing to. For example, to define a header for writing to standard output, define a print format named STDOUT_TOP:

format STDOUT_TOP =

page @<

$%

The system variable $% contains the current page number (starting with 1).

Setting the Page Length

If a page header is defined for a particular output file, write() automatically paginates the output to that file. When the number of lines printed is greater than the length of a page, it starts a new page.

By default, the page length is 60 lines. To specify a different page length, change the value stored in the system variable $=:

$= = 66;     # set the page length to 66 lines

This assignment must appear before the first write() statement.

Formatting Long Character Strings

A scalar variable containing a long character string can be printed out using multiple value fields:

format QUOTATION =

Quotation for the day:

—————————————————————————————

   ^<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<

   $quotation

   ^<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<

   $quotation

   ^<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<

   $quotation

.

Here the value of $quotation is written on three lines. The @ character in the value fields is replaced by ^: this tells Perl to fill the lines as full as possible (cutting the string on a space or tab). Any of the value fields defined in "Choosing a Value Field Format" can be used.

If the quotation is too short to require all of the lines, the last line or lines are left blank. To define a line that is only used when necessary, put a ~ character in the first column:

~  ^<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<

To repeat a line as many times as necessary, put two ~ characters at the front:

~~ ^<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<

CAUTION: The contents of the scalar variable are destroyed by this write operation. To preserve the contents, make a copy before calling write().

Using Built-In Functions

The examples you have seen so far use some of the many built-in functions provided with Perl. The following table provides a more complete list.

For more details on these functions and others, see the online manual page for Perl.

Table 16.4. Built-In Functions.

alarm($scalar)	Deliver SIGALRM in $scalar seconds
atan2($v1, $v2)	Return arctangent of $v1/$v2
caller($scalar)	Return context of current subroutine
chdir($scalar)	Change working directory to $scalar
chmod(@array)	Change permissions of file list
chop($scalar)	Remove the last character of a string
chown(@array)	Change owner and group of file list
close(FILE)	Close a file
cos($scalar)	Return cosine of $scalar in radians
crypt($v1, $v2)	Encrypt a string
defined($scalar)	Determine whether $scalar is defined
delete($array{$val})	Delete value from associative array
die(@array)	Print @array to STDERR and exit
each(%array)	Iterate through an associative array
eof(FILE)	Check whether FILE is at end of file
eval($scalar)	Treat $scalar as a subprogram
exec(@array)	Send @array to system as command
exit($scalar)	Exit program with status $scalar
exp($scalar)	Compute e ** $scalar
fileno(FILE)	Return file descriptor for FILE
fork()	Create parent and child processes
getc(FILE)	Get next character from FILE
getlogin()	Get current login from /etc/utmp
gmtime($scalar)	Convert time to GMT array
grep($scalar, @array)	Find $scalar in @array
hex($scalar)	Convert value to hexadecimal
index($v1, $v2, $v3)	Find $v2 in $v1 after position $v3
int($scalar)	Return integer portion of $scalar
join($scalar, @array)	Join array into single string
keys(%array)	Retrieve indexes of associative array
length($scalar)	Return length of $scalar
link(FILE1, FILE2)	Hard link FILE1 to FILE2
localtime($scalar)	Convert time to local array
log($scalar)	Get natural logarithm of $scalar
mkdir(DIR, $scalar)	Create directory
oct($string)	Convert value to octal
open(FILE, $scalar)	Open file
ord($scalar)	Return ASCII value of character
pack($scalar, @array)	Pack array into binary structure
pipe(FILE1, FILE2)	Open pair of pipes
pop(@array)	Pop last value of array
print(FILE, @array)	Print string, list or array
push(@array, @array2)	Push @array2 onto @array
rand($scalar)	Return random value
readlink($scalar)	Return value of symbolic link
require($scalar)	include library file $scalar
reverse(@list)	Reverse order of @list
rindex($v1, $v2)	Return last occurrence of $v2 in $v1
scalar($val)	Interpret $val as scalar
shift(@array)	Shift off first value of @array
sin($scalar)	Return sine of $scalar in radians
sleep($scalar)	Sleep for $scalar seconds
sort(@array)	Sort @array in alphabetical order
splice(@a1, $v1, $v2, @a2)	Replace elements in array
split($v1, $v2)	Split scalar into array
sprintf($scalar, @array)	Create formatted string
sqrt($expr)	Return square root of $expr
srand($expr)	Set random number seed
stat(FILE)	Retrieve file statistics
substr($v1, $v2)	Retrieve substring
symlink(FILE1, FILE2)	Create symbolic link
system(@array)	Execute system command
time()	Get current time
undef($scalar)	Mark $scalar as undefined
unlink(@array)	Unlink a list of files
unpack($v1, $v2)	Unpack array from binary structure
unshift(@a1, @a2)	Add @a2 to the front of @a1
utime(@array)	Change date stamp on files
values(%array)	Return values of associative array
vec($v1, $v2, $v3)	Treat string as vector array
wait()	Wait for child process to terminate
write(FILE)	Write formatted output

The $_ Variable

By default, any function that accepts a scalar variable can have its argument omitted. In this case, Perl uses $_, which is the default scalar variable.

$_ is also the default variable when reading from a file. So, for example, instead of writing

$var = <STDIN>;

chop($var);

you can write

chop(<STDIN>);

Summary

Perl is a programming language that allows you to write programs that manipulate files, strings, integers, and arrays quickly and easily. The features of Perl include: