Perl Notes(I)

Part I Programming Perl

1 Perl Data Types

1.1 Funny Characters

Type Character Example Is a name for:

Scalar	$	$cents	An individual value (number or string)
Array	@	@large	A list of values, keyed by number
Hash	%	%interest	A group of values, keyed by string
Subroutine	&	&how	A callable chunk of Perl code
Typeglob	*	*struck	Everything namedstruck

1.2Singularities

Strings and numbers are singular pieces of data, while lists of strings or numbers are plural.Scalar variables can be assigned any form of scalar value: integers, floating-point numbers, strings, and even esoteric things like references to other variables, or to objects.

As in the Unixshell, you can use different quoting mechanisms to make different kinds of values. Double quotation marks (double quotes) dovariable interpolationandbackslash interpolation(such as turning/ninto a newline) while single quotes suppress interpolation. And backquotes (the ones leaning to the left``) will execute an external program and return the output of the program, so you can capture it as a single string containing all the lines of output.

$answer = 42; # an integer
$pi = 3.14159265; # a "real" number
$avocados = 6.02e23; # scientific notation
$pet = "Camel"; # string
$sign = "I love my $pet"; # string with interpolation
$cost = 'It costs $100'; # string without interpolation
$thence = $whence; # another variable's value
$salsa = $moles * $avocados; # a gastrochemical expression
$exit = system("vi $file"); # numeric status of a command
$cwd = `pwd`; # string output from a command

And while we haven't covered fancy values yet, we should point out that scalars may also hold references to other data structures, including subroutines and objects.

$ary = /@myarray; # reference to a named array
$hsh = /%myhash; # reference to a named hash
$sub = /&mysub; # reference to a named subroutine

$ary = [1,2,3,4,5]; # reference to an unnamed array
$hsh = {Na => 19, Cl => 35}; # reference to an unnamed hash
$sub = sub { print $state }; # reference to an unnamed subroutine

$fido = new Camel "Amelia"; # reference to an object

Following the principle of least surprise, the variable is created with a null value, either ""or 0. Depending on where you use them, variables will be interpreted automatically as strings, as numbers, or as "true" and "false" values (commonly called Boolean values).Perl will automatically convert the data into the form required by the current context, within reason. For example, suppose you said this:

$camels = '123';
print $camels + 1, "/n";

The original value of $camelsis a string, but it is converted to a number to add 1to it, and then converted back to a string to be printed out as 124.

Similarly, a reference behaves as a reference when you give it a "dereference" context, but otherwise acts like a simple scalar value. For example, we might say:

$fido = new Camel "Amelia";
if (not $fido) { die "dead camel"; }
$fido->saddle();

1.3Pluralities

Perl has two types of multivalued variables: arrays and hashes.

1.3.1 Array

An arrayis an ordered list of scalars, accessed[6] by the scalar's position in the list.To assign a list value to an array, you simply group the values together (with a set of parentheses):

@home = ("couch", "chair", "table", "stove");

Conversely, if you use @homein a list context, such as on the right side of a list assignment, you get back out the same list you put in. So you could set four scalar variables from the array like this:

($potato, $lift, $tennis, $pipe) = @home;

These are called list assignments. They logically happen in parallel, so you can swap two variables by saying:

($alpha,$omega) = ($omega,$alpha);

Arrays are zero-based.Array subscripts are enclosed in square brackets [like this], so if you want to select an individual array element, you would refer to it as $home[ n ].

Since arrays are ordered, you can do various useful operations on them, such as the stack operations pushand pop.Perl regards the endof your array as the top of a stack.

1.3.2 Hash

A hashis an unordered set of scalars, accessedby some string value that is associated with each scalar. For this reason hashes are often called associative arrays. A hash has no beginning or end.Since the keys to a hash are not automatically implied by their position, you must supply the key as well as the value when populating a hash.

Suppose you wanted to translate abbreviated day names to the corresponding full names. You could write the following list assignment:

%longday = ("Sun", "Sunday", "Mon", "Monday", "Tue", "Tuesday",
 "Wed", "Wednesday", "Thu", "Thursday", "Fri",
 "Friday", "Sat", "Saturday");

But that's rather difficult to read, so Perl provides the =>(equals sign, greater-than sign) sequence as an alternative separator to the comma. Using this syntactic sugar (and some creative formatting), it is much easier to see which strings are the keys and which strings are the associated values.

%longday = (
 "Sun" => "Sunday",
 "Mon" => "Monday",
 "Tue" => "Tuesday",
 "Wed" => "Wednesday",
 "Thu" => "Thursday",
 "Fri" => "Friday",
 "Sat" => "Saturday",
);

You can select an individual hash element by enclosing the key in braces (those fancy brackets also known as "curlies"). For example, if you want to find out the value associated with Wedin the hash above, you would use $longday{"Wed"}. Note again that you are dealing with a scalar value, so you use $on the front, not %, which would indicate the entire hash.

Linguistically, the relationship encoded in a hash is genitive or possessive, like the word "of" in English, or like "'s". The wifeofAdam is Eve, so we write:

$wife{"Adam"} = "Eve";

1.3.3Complexities

Perl lets you manipulate simple scalar references that happen to refer to complicated arrays and hashes.To extend our previous example, suppose we want to switch from talking about Adam's wife to Jacob's wife. Now, as it happens, Jacob had four wives. (Don't try this at home.) In trying to represent this in Perl, we find ourselves in the odd situation where we'd like to pretend that Jacob's four wives were really one wife. (Don't try this at home, either.) You might think you could write it like this:

$wife{"Jacob"} = ("Leah", "Rachel", "Bilhah", "Zilpah"); # WRONG

But that wouldn't do what you want, because even parentheses and commas are not powerful enough to turn a list into a scalar in Perl. (Parentheses are used for syntactic grouping, and commas for syntactic separation.) Rather, you need to tell Perl explicitly that you want to pretend that a list is a scalar. It turns out that square brackets are powerful enough to do that:

$wife{"Jacob"} = ["Leah", "Rachel", "Bilhah", "Zilpah"]; # ok

That statement creates an unnamed array and puts a reference to it into the hash element $wife{"Jacob"}.

suppose we wanted to list not only Jacob's wives but all the sons of each of his wives. In this case we want to treat a hash as a scalar. We can use braces for that. (Inside each hash value we'll use square brackets to represent arrays, just as we did earlier. But now we have an array in a hash in a hash.)

$kids_of_wife{"Jacob"} = {
 "Leah" => ["Reuben", "Simeon", "Levi", "Judah", "Issachar", "Zebulun"],
 "Rachel" => ["Joseph", "Benjamin"],
 "Bilhah" => ["Dan", "Naphtali"],
 "Zilpah" => ["Gad", "Asher"],
};

That would be more or less equivalent to saying:

$kids_of_wife{"Jacob"}{"Leah"}[0] = "Reuben";
$kids_of_wife{"Jacob"}{"Leah"}[1] = "Simeon";
$kids_of_wife{"Jacob"}{"Leah"}[2] = "Levi";
$kids_of_wife{"Jacob"}{"Leah"}[3] = "Judah";
$kids_of_wife{"Jacob"}{"Leah"}[4] = "Issachar";
$kids_of_wife{"Jacob"}{"Leah"}[5] = "Zebulun";
$kids_of_wife{"Jacob"}{"Rachel"}[0] = "Joseph";
$kids_of_wife{"Jacob"}{"Rachel"}[1] = "Benjamin";
$kids_of_wife{"Jacob"}{"Bilhah"}[0] = "Dan";
$kids_of_wife{"Jacob"}{"Bilhah"}[1] = "Naphtali";
$kids_of_wife{"Jacob"}{"Zilpah"}[0] = "Gad";
$kids_of_wife{"Jacob"}{"Zilpah"}[1] = "Asher";

1.3.4Simplicities

Perl also has several ways of topicalizing. One important topicalizer is thepackagedeclaration. Suppose you want to talk aboutCamels in Perl. You'd likely start off yourCamelmodule by saying:

package Camel;

Perl will assume from this point on that any unspecified verbs or nouns are about Camels. It does this by automatically prefixing any global name with the module name " Camel::".

When you saypackage Camel, you're starting a new package. But sometimes you just want to borrow the nouns and verbs of an existing package. Perl lets you do that with ausedeclaration, which not only borrows verbs from another package, but also checks that the module you name is loaded in from disk. In fact, youmustsay something like:

use Camel;

before you say:

$fido = new Camel "Amelia";

In fact, some of the built-in modules don't actually introduce verbs at all, but simply warp the Perl language in various useful ways. These special modules we callpragmas. For instance, you'll often see people use the pragmastrict, like this:

use strict;

1.4 Verbs

Many of the verbs in Perl are commands: they tell the Perl interpreter to do something.A statement starting with a verb is generally purely imperative and evaluated entirely for its side effects. (We sometimes call these verbs procedures, especially when they're user-defined.)

Other verbs translate their input parameters into return values, just as a recipe tells you how to turn raw ingredients into something (hopefully) edible. We tend to call these verbs functions.

Verbs are also sometimes called operators (when built-in), or subroutines (when user-defined).Historically, Perl required you to put an ampersand character ( &) on any calls to user-defined subroutines (see $fido = &fetch();earlier). But with Perl version 5, the ampersand became optional, so that user-defined verbs can now be called with the same syntax as built-in verbs ( $fido = fetch();).We still use the ampersand when talking about the nameof the routine, such as when we take a reference to it ( $fetcher = /&fetch;).

1.5 Filehandles

A filehandle is just a name you give to a file, device, socket, or pipe to help you remember which one you're talking about, and to hide some of the complexities of buffering and such. (Internally, filehandles are similar to streams from a language like C++ or I/O channels from BASIC.)

You create a filehandle and attach it to a file by using open. The openfunction takes at least two parameters: the filehandle and filename you want to associate it with. Perl also gives you some predefined (and preopened) filehandles. STDINis your program's normal input channel, while STDOUTis your program's normal output channel. And STDERRis an additional output channel that allows your program to make snide remarks off to the side while it transforms (or attempts to transform) your input into your output.

open(SESAME, "filename") # read from existing file
open(SESAME, "<filename") # (same thing, explicitly)
open(SESAME, ">filename") # create file and write to it
open(SESAME, ">>filename") # append to existing file
open(SESAME, "| output-pipe-command") # set up an output filter
open(SESAME, "input-pipe-command |") # set up an input filter

As you can see, the name you pick for the filehandle is arbitrary. Once opened, the filehandle SESAMEcan be used to access the file or pipe until it is explicitly closed (with, you guessed it, close(SESAME)), or until the filehandle is attached to another file by a subsequent openon the same filehandle.

Once you've opened a filehandle for input, you can read a line using the line reading operator, < >. The angle operator encloses the filehandle ( <SESAME> ) you want to read lines from. The empty angle operator, <> , will read lines from all the files specified on the command line, or STDIN , if none were specified.

An example using theSTDINfilehandle to read an answer supplied by the user would look something like this:

print STDOUT "Enter a number: "; # ask for a number
$number = <STDIN>; # input the number
print STDOUT "The number is $number./n"; # print the number

If you try the previous example, you may notice that you get an extra blank line. This happens because the line-reading operation does not automatically remove the newline from your input line (your input would be, for example, "9/n"). For those times when you do want to remove the newline, Perl provides thechopandchompfunctions.chopwill indiscriminately remove (and return) the last character of the string, whilechompwill only remove the end of record marker (generally, "/n") and return the number of characters so removed.You'll often see this idiom for inputting a single line:

chop($number = <STDIN>); # input number and remove newline

2 Operators

2.1Some Binary Arithmetic Operators

Example Name Result

$a + $b	Addition	Sum of$aand$b
$a * $b	Multiplication	Product of$aand$b
$a % $b	Modulus	Remainder of$adivided by$b
$a ** $b	Exponentiation	$ato the power of$b

2.2String Operators

Perl defines a separate operator (.) for string concatenation:

$a = 123;
$b = 456;
print $a + $b; # prints 579
print $a . $b; # prints 123456

There's also a "multiply" operator for strings, called therepeatoperator. Again, it's a separate operator (x) to keep it distinct from numeric multiplication:

$a = 123;
$b = 3;
print $a * $b; # prints 369
print $a x $b; # prints 123123123

Thexoperator may seem relatively worthless at first glance, but it is quite useful at times, especially for things like this:

print "-" x $scrwid, "/n";

which draws a line across your screen, presuming $scrwidcontains your screen width, and not your screw identifier.

2.3 Assignment Operators

You can do shortcut with almost any binary operator in Perl, even some that you can't do it with in C:

$line .= "/n"; # Append newline to $line.
$fill x= 80; # Make string $fill into 80 repeats of itself.
$val ||= "2"; # Set $val to 2 if it isn't already "true".

2.4 Unary Arithmetic Operators

Example Name Result

++$a, $a++	Autoincrement	Add 1 to$a
--$a, $a--	Autodecrement	Subtract 1 from$a

The same with C.

2.5 Logical Operators

Example Name Result

$a && $b	And	$aif$ais false,$botherwise
$a || $b	Or	$aif$ais true,$botherwise
! $a	Not	True if$ais not true
$a and $b	And	$aif$ais false,$botherwise
$a or $b	Or	$aif$ais true,$botherwise
not $a	Not	True if$ais not true
$a xor $b	Xor	True if$aor$bis true, but not both

2.6Some Numeric and String Comparison Operators

Comparison Numeric String Return Value

Equal	==	eq	True if$ais equal to$b
Not equal	!=	ne	True if$ais not equal to$b
Less than	<	lt	True if$ais less than$b
Greater than	>	gt	True if$ais greater than$b
Less than or equal	<=	le	True if$anot greater than$b
Comparison	<=>	cmp	0 if equal, 1 if$agreater, -1 if$bgreater

2.7Some File Test Operators

Here are a few of the file test operators:

Example Name Result

-e $a	Exists	True if file named in$aexists
-r $a	Readable	True if file named in$ais readable
-w $a	Writable	True if file named in$ais writable
-d $a	Directory	True if file named in$ais a directory
-f $a	File	True if file named in$ais a regular file
-T $a	Text File	True if file named in$ais a text file

You might use them like this:

-e "/usr/bin/perl" or warn "Perl is improperly installed/n";
-f "/vmlinuz" and print "I see you are a friend of Linus/n";

3 Control Structures

3.1 Truth

Truth in Perl is always evaluated in a scalar context.Other than that, no type coercion is done. So here are the rules for the various kinds of values a scalar can hold:

1. Any string is true except for""and"0".

2. Any number is true except for 0.

3. Any reference is true.

4. Any undefined value is false.

For example:

"0.00" + 0 # would become the number 0 (coerced by the +), so false.
/$a # is a reference to $a, so true, even if $a is false.
undef() # is a function returning the undefined value, so false.

3.2 The if and unless statements

if ($city eq "New York") {
 print "New York is northeast of Washington, D.C./n";
}
elsif ($city eq "Chicago") {
 print "Chicago is northwest of Washington, D.C./n";
}
elsif ($city eq "Miami") {
 print "Miami is south of Washington, D.C. And much warmer!/n";
}
else {
 print "I don't know where $city is, sorry./n";
}

Note that:Braces are optional in C if you have a single statement, but the braces are not optional in Perl.

If you want to do something only if it is false, you can use unless statement:

unless ($destination eq $home) {
 print "I'm not going home./n";
}

3.3Iterative (Looping) Constructs

Perl has four main iterative statement types:while,until,for, andforeach. These statements allow a Perl program to repeatedly execute the same code.

3.3.1 while & until

In fact, almost everything is designed to work smoothly in a conditional (Boolean) context. If you mention an array in a scalar context, thelengthof the array is returned. So you often see command-line arguments processed like this:

while (@ARGV) {
 process(shift @ARGV);
}

The shiftoperator removes one element from the argument list each time through the loop (and returns that element). The loop automatically exits when array @ARGVis exhausted, that is, when its length goes to 0. And 0 is already false in Perl. In a sense, the array itself has become "false". [21]

[21] This is how Perl programmers think. So there's no need to compare 0 to 0 to see if it's false. Despite the fact that other languages force you to, don't go out of your way to write explicit comparisons likewhile (@ARGV != 0). That's just inefficient for both you and the computer. And anyone who has to maintain your code.

3.3.2 for & foreach

"for" example:

for ($sold = 0; $sold < 10000; $sold += $purchase) {
 $available = 10000 - $sold;
 print "$available tickets are available. How many would you like: ";
 $purchase = <STDIN>;
 chomp($purchase);

}

foreachstatementis used to execute the same code for each of a known set of scalars, such as an array:

foreach $user (@users) {
 if (-f "$home{$user}/.nexrc") {
 print "$user is cool... they use a perl-aware vi!/n";
 }
}

Unlike the ifand whilestatements, which provide scalar context to a conditional expression, the foreachstatement provides a list context to the expression in parentheses. So the expression is evaluated to produce a list (not a scalar, even if there's only one scalar in the list).

3.4Breaking out: next and last

The nextoperator would allow you to skip to the end of your current loop iteration, and start the next iteration. The lastoperator would allow you to skip to the end of your block, as if your loop's test condition had returned false.

foreach $user (@users) {
 if ($user eq "root" or $user eq "lp") {
 next;
 }
 if ($user eq "special") {
 print "Found the special account./n";
 # do some processing
 last;
 }
}

It's possible to break out of multilevel loops by labeling your loops and specifying which loop you want to break out of. Together with statement modifiers (another form of conditional which we'll talk about later), this can make for extremely readable loop exits (if you happen to think English is readable):

LINE: while ($line = <ARTICLE>) {
 last LINE if $line eq "/n"; # stop on first blank line
 next LINE if $line =~ /^#/; # skip comment lines
 # your ad here
}

4Regular Expressions

First and foremost, they're used in conditionals to determine whether a string matches a particular pattern, because in a Boolean context they return true and false. So when you see something that looks like/foo/in a conditional, you know you're looking at an ordinarypattern-matchingoperator:

if (/Windows 95/) { print "Time to upgrade?/n" }

Second, if you can locate patterns within a string, you can replace them with something else. So when you see something that looks likes/foo/bar/, you know it's asking Perl to substitute "bar" for "foo", if possible. We call that thesubstitutionoperator. It also happens to return true or false depending on whether it succeeded, but usually it's evaluated for its side effect:

s/Windows/Linux/;

Finally, patterns can specify not only where something is, but also where itisn't. So thesplitoperator uses a regular expression to specify where the data isn't. That is, the regular expression defines theseparatorsthat delimit the fields of data. Our Average Example has a couple of trivial examples of this. Lines 5 and 12 each split strings on the space character in order to return a list of words. But you can split on any separator you can specify with a regular expression:

($good, $bad, $ugly) = split(/,/, "vi,emacs,teco");

Because certain classes like the alphabetics are so commonly used, Perl defines shortcuts for them:

Name ASCII Definition Code

Whitespace	[ /t/n/r/f]	/s
Word character	[a-zA-Z_0-9]	/w
Digit	[0-9]	/d

Note that these matchsinglecharacters. A/wwill match any single word character, not an entire word. (Remember that+quantifier? You can say/w+to match a word.) Perl also provides the negation of these classes by using the uppercased character, such as/Dfor a nondigit character.

" ." will match any character whatsoever.

4.1Quantifiers

Certain combinations of minimum and maximum occur frequently, so Perl defines special quantifiers for them. We've already seen+, which is the same as{1,}, or "at least one of the preceding item". There is also*, which is the same as{0,}, or "zero or more of the preceding item", and?, which is the same as{0,1}, or "zero or one of the preceding item" (that is, the preceding item is optional).

You need to be careful of a couple things about quantification. First of all, Perl quantifiers are by defaultgreedy. This means that they will attempt to match as much as they can as long as the whole pattern still matches.The other point to be careful about is that regular expressions will try to match asearlyas possible. This even takes precedence over being greedy. Since scanning happens left-to-right, this means that the pattern will match as far left as possible, even if there is some other place where it could match longer.

There's one other thing you need to know. By default, quantifiers apply to a single preceding character, so/bam{2}/will match "bamm" but not "bambam". To apply a quantifier to more than one character, use parentheses. So to match "bambam", use the pattern/(bam){2}/.

4.2Minimal Matching

You can forcenon greedy, minimal matching by placing a question mark after any quantifier.That.*?will now try to match as few characters as possible, rather than as many as possible.

4.3Nailing Things Down

The special symbol/bmatches at a word boundary.

If it is the first character of a pattern, the caret (^) matches the "nothing" at the beginning of the string.

The dollar sign ($) works like the caret, except that it matches the "nothing" at the end of the string instead of the beginning.