Perl statements tell the computer to do something. As a simple example, let’s write a short program to print something:

	print "hello world
";

(Notice the semicolon at the end of the statement. You need to put a semicolon after the end of every statement in Perl. Oh, and the means “start a new line.”) If you save this to a file called helloworld.pl, you can run the program like this:

	% perl helloworld.pl
	hello world

We’ll get back to statements soon, but first we need to introduce variables.

In Perl, you can give a convenient name to a value and then use it later. The named thing is called a variable. (If that statement bothers you, you know too much to be reading this chapter. This book is about saving time! Don’t read this. Skip to another hack.) Here are a couple of examples:

	$name = "Barry Bonds";
	$OPS2004 = 1.422;
	print "The OPS of $name in 2004 was $OPS2004
";

Running this program will produce the following:

As you might guess, it can be nice to keep lists of things, where you can refer to each item in the list by a name or position. These lists of things are called data structures. In this book, I use only four different datatypes in Perl.

The first one is scalar values. Scalar values include numbers and strings, like the ones I used in the earlier example for variables. Notice that there is a dollar sign ($) in front of scalar values.

The second one is arrays. An array is a simple list of items. Here’s an example:

	@positions = ("P", "C", "1B","2B","3B","SS","LF","CF","RF","DH")
	print "The third position in the list is $positions[2]
";

You might have read that and said, “Hey, you wrote a two, but said third.” You’re right about that. Array positions are numbered from zero, not one. (You’ll also notice that I put an at sign [@] in front of the variable name when I defined a list, but a $ when I looked up a value from the list. This is a kind of funny feature of Perl; you put a sign in front of a variable to explain how to interpret the result in the current context.) Running this code will show the following:

The third datatype is associative arrays (also called hashes). An associative array lets you keep a list of stuff, with a name associated with each item. Here’s an example:

	%AVG = ("Suzuki"   => .372,
	        "Bonds"    => .362,
	        "Helton"   => .347,
	        "Mora"     => .340,
	        "Guerrero" => .337);
	print "Melvin Mora's batting average was ", $AVG{"Mora"}, "
";

Notice the percent sign (%) in front of the variable name when I define the variable, but the $ when I look up a value. Oh, and notice the way I used printin this example. You can print a set of different things, separated by commas. Running this code produces the following:

The last datatype we use in this book is file handles, which we use to reference files. Traditionally, you write file handles in uppercase. Also, they don’t have any symbol in front of them. See the next section for an example of using a file handle.

I hate using that term (it seems so technical), but I can’t think of a better one. Sometimes you want to tell Perl to do one thing if something is true and something else if it’s false. You can use the if {} else {} structure to do this. I’ll build on the previous example here:

	if($AVG{"Bonds"} > .350) {
	  print "Whoah!
";
	} else {
	  print "Eh.
";
	}

Of course, this code will print the following:

You can also use loops to repeat things in Perl. There are many different types of loops, but here is a simple example of one:

	$i = 0;
	while ($i < scalar(@positions)) {
	  print $positions[$i], " ";
	  $i = $i + 1;
	}
	print "
";

Running this program produces the following output:

You can put comments in Perl programs that Perl ignores. They start with a pound sign (#). It is good practice to write comments in your programs. Sometimes a piece of code is complicated and difficult to read. It is often hard to remember what a piece of code does and how it works. To avoid confusing yourself and other people later, you can include comments that explain what the code does.

When trying to understand files from the Internet, we want to match a lot of patterns. For example, consider the play-by-play calls “Roger Clemens intentionally walks Barry Bonds,” “Keith Foulke intentionally walks Rafael Palmeiro,” and “Jake Westbrook intentionally walks Doug Mientkiewicz.” You probably noticed that each expression fits a pattern: the name of a pitcher followed by the expression “intentionally walks” followed by a batter’s name. A regular expression gives you a concise way to express this relationship.

Let’s start with an example that uses this pattern:

	$playbyplay = "Jake Westbrook intentionally walks Doug Mientkiewicz.";
	if($playbyplay =~ /w+sw+ intentionally walks w+sw+/) {
	  print "found an intentional walk
";
	}

If you run this code fragment, Perl will print the words “found an intentional walk.” Here is how this works. The expression =~ means “if the variable on the left matches the pattern on the right.” The expression between the slashes—/w+sw+ intentionally walks w+sw+/—is the pattern. You can interpret this pattern as “a bunch of characters, then a space, then some more characters, another space, the words ‘intentionally walks,’ another space, some characters, another space, and some more characters.” More specifically, the wmeans “any word character,” the s means “any space character,” and the +means “at least one of the things to the left.”

See “Use Regular Expressions to Identify Events” [Hack #23] for an overview of regular expressions.

One feature needs an explanation. If you place parentheses around part of an expression, Perl will set a variable to the thing that matched inside the parentheses. These variables are named $1, $2, $3, etc.

This can be useful for extracting things from patterns. Let’s use this technique to extract the name of the pitcher and batter in the earlier example:

	$playbyplay = "Jake Westbrook intentionally walks Doug Mientkiewicz.";
	if($playbyplay =~ /(w+sw+) intentionally walks (w+sw+)/) {
	  print "pitcher: $1, batter: $2
";
	}

If you run this code fragment, Perl will print:

Often, you will want to repeat the same Perl code inside a script. Instead of writing the same few lines over again, you can place them in a subroutine and give the subroutine a name. Here’s a simple example of a subroutine that prints the name of a pitcher and batter when given a play-by-play expression matching the “intentional walk” pattern:

	sub intentional_walk_message($) {
	  # takes one argument: play by play string
	  my ($playbyplay) = (@_);
	  if ($playbyplay =~ /(w+sw+) intentionally walks (w+sw+)/) {
	    print "pitcher: $1, batter: $2
";
	  }
	}

In this subroutine, the ($) is called a prototype—it tells Perl that this expression takes one argument. The arguments are contained in the list (@_). Finally, the my qualifier tells the script “set the variable $playbyplay only inside this subroutine” so that if another part of the script uses this value and the subroutine changes it, there will be no surprises.

Perl supports a system called packages for grouping together data structures, functions, and variables that are often used together. A module is just a package defined in a file of the same name; I use these terms interchangeably in this book. Modules are a method of grouping together commonly used datatypes and subroutines into a single package. (This is an example of object-oriented programming.) The datatypes are called objects and the subroutines are called methods.

You tell Perl that you want to use an object through the use command. You access a method (subroutine) associated with an object through an expression such as $object->method(). Here is a specific example that opens a file for output using the FileHandle package:

	use FileHandle;
	$fh = new FileHandle;
	$fh->open(">file");

The first line loads the package. The second new returns a new FileHandle object. The third line opens a file for output, associating the file with the FileHandle object. (You can use the FileHandle object in Perl to refer to the file.)

In this book, we use Perl packages for parsing web pages and reading baseball data. For more information on packages, see the Perl documentation.