Perl Versions

Perl is installed in Ubuntu by default. You can download the code from www.perl.com and build the newest version from source if you want to, although a stable and quality release of Perl is already installed by default in Ubuntu and most (perhaps all) Linux and UNIX-like distributions, including macOS. Updated versions might appear in the Ubuntu repositories, but they’re generally only security fixes that can be installed by updating your system. See Chapter 9, “Managing Software,” to see how to quickly get a list of available updates for Ubuntu.

You can determine what version of Perl you have installed by typing perl -v at a shell prompt. When you install the latest Ubuntu distribution, you should have the latest version of Perl that was available when the software for your Ubuntu release was gathered and finalized.

Note that there was a development effort underway to replace Perl 5. The new version was to be called Perl 6, but had diverged far enough away from Perl 5 that the decision was made to rename it to Raku. You can learn about Raku at www.raku.org.

A Simple Perl Program

This section introduces a very simple Perl program example to get you started using Perl. Although trivial for experienced Perl hackers, this short example is necessary for new users who want to learn more about Perl.

To introduce you to the absolute basics of Perl programming, Listing 42.1 illustrates a simple Perl program that prints a short message.

LISTING 42-1 A Simple Perl Program

#!/usr/bin/perl
print 'Look at all the camels!
';

Type in the program shown in the listing and save it to a file called trivial.pl. Then make the file executable by using the chmod command (see the following sidebar) and run it at the command prompt.

matthew@seymour:~$ chmod +x trivial.pl

matthew@seymour:~$ ./trivial.pl

matthew@seymour:~$ perl trivial.pl

The #! line is technically not part of the Perl code at all. The # character indicates that the rest of the screen line is a comment. The comment is a message to the shell, telling it where it should go to find the executable to run this program. The interpreter ignores the comment line. Comments are useful for documenting scripts, like this:

Click here to view code image

#!/usr/bin/perl
# a simple example to print a greeting
print "hello there
";

The # character can also be used in a quoted string and used as the delimiter in a regular expression.

A block of code such as what might appear inside a loop or a branch of a conditional statement is indicated with curly braces ({}). For example, here is an infinite loop:

Click here to view code image

#!/usr/bin/perl
# a block of code to print a greeting forever
while (1) {
        print "hello there
";
};

A Perl statement is terminated with a semicolon (;). A Perl statement can extend over several screen lines because Perl is not concerned about white space.

The second line of the simple program in Listing 42.1 prints the text enclosed in quotation marks. is the escape sequence for a newline character.

matthew@seymour:~$ perldoc

matthew@seymour:~$ perldoc perl

matthew@seymour:~$ man perl

matthew@seymour:~$ perldoc perltoc

Perl Variable Types

Perl has three variable types: scalars, arrays, and hashes. A different character is used to signify each variable type, so you can have the same name used with each type at the same time.

A scalar variable is indicated with the $ character, as in $penguin. Scalars can be numbers or strings, and they can change type as needed. If you treat a number like a string, it becomes a string. If you treat a string like a number, it is translated into a number if it makes sense to do so; otherwise, it usually evaluates to 0. For example, the string "76trombones" evaluates as the number 76 if used in a numeric calculation, but the string "polar bear" evaluates to 0.

A Perl array is indicated with the @ character, as in @fish. An array is a list of values referenced by index number, starting with the first element, numbered 0, just as in C and awk. Each element in the array is a scalar value. Because scalar values are indicated with the $ character, a single element in an array is also indicated with a $ character.

For example, $fish[2] refers to the third element in the @fish array. This tends to throw some people off but is similar to arrays in C, in which the first array element is 0.

A hash is indicated with the % character, as in %employee. A hash is a list of name/value pairs. Individual elements in a hash are referenced by name rather than by index (unlike in an array). Again, because the values are scalars, the $ character is used for individual elements.

For example, $employee{name} gives you one value from the hash. Two rather useful functions for dealing with hashes are keys and values. The keys function returns an array that contains all the keys of the hash, and values returns an array of the values of the hash. Using this approach, the Perl program in Listing 42.2 displays all the values in your environment, much like typing the bash shell’s env command.

LISTING 42-2 Displaying the Contents of the env Hash

#!/usr/bin/perl
foreach $key (keys %ENV)  {
  print "$key = $ENV{$key}
";
}

Special Variables

Perl has a variety of special variables, which usually look like punctuation—$_, $!, and $]—and are all extremely useful for shorthand code. $_ is the default variable, $! is the error message returned by the operating system, and $] is the Perl version number.

$_ is perhaps the most useful of these. You see this variable used often in this chapter. $_ is the Perl default variable, which is used when no argument is specified. For example, the following two statements are equivalent:

chomp;

chomp($_);

The following loops are equivalent:

for $cow (@cattle) {
        print "$cow says moo.
";
}

for (@cattle)        {
        print "$_ says moo.
";
}

For a complete list of the special variables, see the perlvar man page.

Comparison Operators

The comparison operators used by Perl are similar to those used by C, awk, and the csh shells, and they are used to specify and compare values (including strings). A comparison operator is most often used within an if statement or loop. Perl has comparison operators for numbers and strings. Table 42.1 shows the numeric comparison operators and their meanings.

Table 42.2 shows the string comparison operators and their meanings.

Compound Operators

Perl uses compound operators, similar to those used by C or awk, which can be used to combine other operations (such as comparisons or arithmetic) into more complex forms of logic. Table 42.3 shows the compound pattern operators and their meanings.

Arithmetic Operators

Perl supports a variety of math operations. Table 42.4 summarizes these operators.

You can also use comparison operators (such as == or <) and compound pattern operators (&&, ||, and !) in arithmetic statements. They evaluate to the value 0 for false and 1 for true.

Other Operators

Perl supports a number of operators that do not fit any of the prior categories. Table 42.5 summarizes these operators.

Except for the comma operator and conditional expression, you can also use these operators with the assignment operator, similar to the way addition (+) can be combined with assignment (=), giving +=.

Special String Constants

Perl supports string constants that have special meaning or cannot be entered from the keyboard.

Table 42.6 shows most of the constants supported by Perl.

if

The syntax of the Perl if/else structure is as follows:

if (condition) {
  statement or block of code
} elsif (condition) {
  statement or block of code
} else {
  statement or block of code
}

condition is a statement that returns a true or false value.

Truth is defined in Perl in a way that might be unfamiliar to you, so be careful. Everything in Perl is true except 0 (the digit zero), "0" (the string containing the number 0), "" (the empty string), and an undefined value. Note that even the string "00" is a true value because it is not one of the four false cases.

A statement or block of code section is executed if the test condition returns a true value.

For example, Listing 42.3 uses the if/else structure and shows conditional statements using the eq string comparison operator.

LISTING 42-3 if/elsif/else

if  ($favorite eq "chocolate") {
      print "I like chocolate too.
";
} elsif ($favorite eq "spinach") {
      print "Oh, I do not like spinach.
";
} else {
     print "Your favorite food is $favorite.
";
}

unless

unless works just like if only backward. unless performs a statement or block if a condition is false:

Click here to view code image

unless ($name eq "Rich")        {
  print "Go away, you're not allowed in here!
";
}

print "Go away!
" unless $name eq "Rich";

for

The for construct performs a statement (block of code) for a set of conditions defined as follows:

Click here to view code image

for (start condition; end condition; increment function) {
  statement(s)
}

The start condition is set at the beginning of the loop. Each time the loop is executed, the increment function is performed until the end condition is achieved. This looks much like the traditional for/next loop. The following code is an example of a for loop:

for ($i=1; $i<=10; $i++) {
      print "$i
"
}

foreach

The foreach construct performs a statement block for each element in a list or an array:

Click here to view code image

@names = ("alpha","bravo","Charlie");
foreach $name (@names) {
  print "$name sounding off!
";
}

The loop variable ($name in the example) is not merely set to the value of the array elements; it is aliased to that element. This means if you modify the loop variable, you’re actually modifying the array. If no loop array is specified, the Perl default variable $_ may be used, as shown here:

Click here to view code image

@names = ("alpha","bravo","Charlie");
foreach (@names) {
  print "$_ sounding off!
";

}

This syntax can be very convenient, but it can also lead to unreadable code. Give a thought to the poor person who’ll be maintaining your code. (It will probably be you.)

while

while performs a block of statements as long as a particular condition is true, as shown in this example:

while ($x<10) {
     print "$x
";
     $x++;
}

Remember that the condition can be anything that returns a true or false value. For example, it could be a function call, like this:

Click here to view code image

while ( InvalidPassword($user, $password) )        {
        print "You've entered an invalid password. Please try again.
";
        $password = GetPassword;
}

until

until is exactly the opposite of the while statement. It performs a block of statements as long as a particular condition is false (or, rather, until it becomes true). The following is an example:

Click here to view code image

until (ValidPassword($user, $password))  {
  print "YSdpgm_m
Sdpgm_m
You have entered an invalid password. Please try again.
";
Sdpgm_m
  $password = GetPassword;
}

last and next

You can force Perl to end a loop early by using a last statement. last is similar to the C break command; the loop is exited. If you decide you need to skip the remaining contents of a loop without ending the loop, you can use next, which is similar to the C continue command. Unfortunately, these statements do not work with do ... while. However, you can use redo to jump to a loop (marked by a label) or inside the loop where called:

$a = 100;
while (1) {
  print "start
";
  TEST: {
    if (($a = $a / 2) > 2) {
      print "$a
";
      if (—$a < 2) {
        exit;
      }
      redo TEST;
    }
  }
}

In this simple example, the variable $a is repeatedly manipulated and tested in a loop. The word start will be printed only once.

do ... while and do ... until

The while and until loops evaluate the conditional first. The behavior is changed by applying a do block before the conditional. With the do block, the condition is evaluated last, which results in the contents of the block always executing at least once (even if the condition is false). This is similar to the C language do ... while (conditional) statement.

Sending Mail

You can get Perl to send email in several ways. One method that you see frequently is opening a pipe to the sendmail command and sending data to it (as shown in Listing 42.5). Another method is using the Mail::Sendmail module (available through CPAN), which uses socket connections directly to send mail (as shown in Listing 42.6). The latter method is faster because it does not have to launch an external process. Note that sendmail must be installed on your system for the Perl program in Listing 42.5 to work.

LISTING 42-5 Sending Mail Using Sendmail

#!/usr/bin/perl
open (MAIL, "| /usr/sbin/sendmail -t"); # Use -t to protect from users
print MAIL <<EndMail;
To: you
From: me
Subject: A Sample Email
Sending email from Perl is easy!

.
EndMail
close MAIL;

dpitts<indexterm startref="iddle2799" class="endofrange" significance="normal"/>:}]

print <<EndText;
.....
EndText

LISTING 42-6 Sending Mail Using the Mail::Sendmail Module

#!/usr/bin/perl
use Mail::Sendmail;

%mail = ( To => "[email protected]",
  From => "[email protected]",
  Subject => "A Sample Email",
  Message => "This is a very short message"
  );

sendmail(%mail) or die $Mail::Sendmail::error;

print "OK. Log says:
", $Mail::Sendmail::log;

use Mail::Sendmail;

Perl ignores the comma after the last element in the hash. It is convenient to leave it there; then, if you want to add items to the hash, you do not need to add the comma. This is purely a style decision.

# perl -MCPAN -e shell

cpan>

cpan> install Bundle::CPAN

cpan> get Mail::Sendmail

cpan> install Mail::Sendmail

# perl -MCPAN   -e "install Mail::Sendmail

Note also that the @ sign in Listing 42.6 does not need to be escaped within single quotation marks (''). Perl does not interpolate (evaluate variables) within single quotation marks but does within double quotation marks and here strings (similar to << shell operations).

Purging Logs

Many programs maintain some variety of logs. Often, much of the information in the logs is redundant or just useless. The program shown in Listing 42.7 removes all lines from a file that contain a particular word or phrase, so lines that you know are not important can be purged. For example, you might want to remove all the lines in the Apache error log that originate with your test client machine because you know those error messages were produced during testing.

LISTING 42-7 Purging Log Files

#!/usr/bin/perl
# Be careful using this program!
# This will remove all lines that contain a given word
# Usage:  remove <word> <file>
$word=@ARGV[0];
$file=@ARGV[1];
if ($file)  {
  # Open file for reading
  open (FILE, "$file") or die "Could not open file: $!";
      @lines=<FILE>;
  close FILE;
  # Open file for writing
  open (FILE, ">$file") or die "Could not open file for writing: $!";
  for (@lines)  {
    print FILE unless /$word/;
  } # End for
  close FILE;
} else {
  print "Usage:  remove <word> <file>
";
}  #  End if...else

The code in Listing 42.7 includes a few idiomatic Perl expressions to keep it brief. It reads the file into an array by using the <FILE> notation; it then writes the lines back out to the file unless they match the pattern given on the command line.

The die function kills program operation and displays an error message if the open statements fail. $! in the error message, as mentioned earlier in this chapter, is the error message returned by the operating system. It is likely to be something like 'file not found' or 'permission denied'.

Posting to Usenet

If some portion of your job requires periodic postings to Usenet—an FAQ listing, for example—the following Perl program can automate the process for you. In Listing 42.8, the posted text is read in from a text file, but your input can come from anywhere.

The program shown in Listing 42.8 uses the Net::NNTP module, which is a standard part of the Perl distribution. You can find more documentation on the Net::NNTP module by entering 'perldoc Net::NNTP' at the command line.

LISTING 42-8 Posting an Article to Usenet

#!/usr/bin/perl
# load the post data into @post
open (POST, "post.file");
@post = <POST>;
close POST;
# import the NNTP module
use Net::NNTP;
$NNTPhost = 'news';
# attempt to connect to the remote host;
# print an error message on failure
$nntp = Net::NNTP->new($NNTPhost)
  or die "Cannot contact $NNTPhost: $!";
# $nntp->debug(1);
$nntp->post()
  or die "Could not post article: $!";
# send the header of the post
$nntp->datasend("Newsgroups: news.announce
");
$nntp->datasend("Subject: FAQ - Frequently Asked Questions
");
$nntp->datasend("From: ADMIN <root>
"
$nntp->datasend("

");
# for each line in the @post array, send it
for (@post)     {
  $nntp->datasend($_);
} #  End for
$nntp->quit;

One-Liners

Perl excels at the one-liner. Folks go to great lengths to reduce tasks to one line of Perl code. Perl has the rather undeserved reputation of being unreadable. The fact is that you can write unreadable code in any language. Perl allows for more than one way to do something, and this leads rather naturally to people trying to find the most arcane way to do things.

Named for Randal Schwartz, a Schwartzian transform is a way of sorting an array by something that is not obvious. The sort function sorts arrays alphabetically; that is pretty obvious. What if you want to sort an array of strings alphabetically by the third word? Perhaps you want something more useful, such as sorting a list of files by file size? A Schwartzian transform creates a new list that contains the information you want to sort by, referencing the first list. You then sort the new list and use it to figure out the order that the first list should be in. Here’s a simple example that sorts a list of strings by length:

Click here to view code image

@sorted_by_length =
  map { $_ => [0] }            # Extract original list
  sort { $a=>[1] <=> $b=>[1] } # Sort by the transformed value
  map { [$_, length($_)] }     # Map to a list of element lengths
  @list;

Because each operator acts on the thing immediately to the right of it, it helps to read this from right to left (or bottom to top, the way it is written here).

The first thing that acts on the list is the map operator. It transforms the list into a hash in which the keys are the list elements and the values are the lengths of each element. This is where you put in your code that does the transformation by which you want to sort.

The next operator is the sort function, which sorts the list by the values.

Finally, the hash is transformed back into an array by extracting its keys. The array is now in the desired order.

Command-Line Processing

Perl is great at parsing the output of various programs. This is a task for which many people use tools such as awk and sed. Perl gives you a larger vocabulary for performing these tasks. The following example is very simple but illustrates how you might use Perl to chop up some output and do something with it. In this example, Perl is used to list only files that are larger than 10KB:

Click here to view code image

matthew@seymour:~$ ls -la | perl -nae 'print "$F[8] is $F[4]
" if $F[4] >
10000;'

The -n switch indicates that the Perl code should run for each line of the output. The -a switch automatically splits the output into the @F array. The -e switch indicates that the Perl code is going to follow on the command line.