Chapter 17

Using Command-Line Options

• How Are the Options Specified?
• What Are the Options?
  • Example: Using the -0 Option
  • Example: Using the -n and -p Options
  • Example: Using the -i Option
  • Example: Using the -s Option
• Summary
• Review Questions
• Review Exercises

Perl has a wide range of command-line options or switches that you can use. The options are also called switches because they can turn on or turn off different behaviors. A thorough knowledge of the command line switches will enable you to create short one-time programs to perform odd little tasks. For example, the -e option lets you specify a line of code directly on the command line instead of creating a script file. You use the -l option to change the line endings in a text file.

How Are the Options Specified?

The most frequent way to specify command-line options is on the command line. All of Perl's options are specified using a dash and then a single character followed by arguments, if needed. For example,

 perl -I/usr/~john/include script.pl

You can combine options with no arguments with the following switch. The following two command lines are equivalent.

perl -cI/usr/~john/include script.pl

perl -c -I/usr/~john/include script.pl

You can also specify command-line options inside your script file using the #! line. Just place them following the directory or executable name. If you are working on a UNIX system, you are probably familiar with using the #! notation to tell the system where to find the Perl executable. The various UNIX systems and Windows can interpret the #! line in different ways. Therefore, Perl starts parsing the #! switches immediately after the first instance of perl on the line. For example, if you started your script with this line:

#!/bin/perl -w

Then Perl will run with the -w option in effect.

What Are the Options?

Table 17.1 provides a short description of each command-line option used with Perl. After the table, examples of several options will be shown.

As you can see, Perl has quite a few command-line options. Most of them are designed so that you can do useful things without needing to create a text file to hold the script. If you are a system administrator then these options will make you more productive. You'll be able to manipulate files and data quickly and accurately. If you're looking to create applications or more complicated programs, you won't need these options-except for -w and -d.

The rest of the chapter is devoted to demonstrating the -0, -n, -p, -i, and -s options.

Example: Using the -0 Option

The -0 option will let you change the record separator. This is useful if your records are separated by something other than a newline. Let's use the example of input records separated by a dash instead of a newline. First, you need to find out the octal value of the dash character. The easy way to do this is to covert from the decimal value, which will be displayed if you run the following command line.

perl -e "print ord('-');"

This program will display 45. Converting 4510 into octal results in 558.

Next, you'll need an input file to practice with. Listing 17.1 shows a sample input file.

Listing 17.1  17LST01.DAT-Test Input File for the -0 Option

Veterinarian-Orthopedist-Dentist-

Listing 17.2 holds a program that reads the above data file using the diamond operators. The program will use the dash character as an end-of-line indicator.

Set the record separator to be a dash using the #! switch setting method.
Open a file for input.
Read all of the records into the @lines array. One element in @lines will be one record.
Close the file.
Iterate over the @lines array and print each element.

Listing 17.2  17LST02.PL-Using the -0 Option to Change the Record Separator

#!perl -0055



open(FILE, "<test.dat");

@lines = <FILE>;

close(FILE);



foreach (@lines) {

    print("$_\n");

}

This program will display:

Veterinarian-

Orthopedist-

Dentist-

Notice that the end-of-line indicator is left as part of the record. This behavior also happens when the newline is used as the end-of-line indicator. You can use chop() or chomp() to remove the dash, if needed.

Example: Using the -n and -p Options

The -n and -p options wrap your script inside loops. Before looking at specific examples, let's see what the loops look like and how they are changed by the -a and -F options.

The -n option causes Perl to execute your script inside the following loop:

while (<>) {

    # your script

}

The -p option uses the same loop, but adds a continue block so that $_ will be printed every time through the loop. If both -n and -p are specified on the command line, the -p option will take precedence. The loop looks like this:

while (<>) {

    # your script

} continue {

    print;

}

The -a option adds a split() function call to the beginning of each iteration of the loop so that the loop looks like this:

while (<>) {

    @F = split(/ /);

    # your script

}

The -F option lets you split on something besides the space character. If you used -F/i+/ on the command line, the loop would look like this:

while (<>) {

    @F = split(/i+/);

    # your script

}

You can use BEGIN and END blocks if you need to specify some initialization or cleanup code. The initialization section might be used to create objects or to open log files. The cleanup section can be used to display statistics or close files. For example,

BEGIN {

    # initialization section

    $count = 0;

}



while (<>) {

    # your script

}



END {

    # cleanup section

    print("The count was $count.\n");

}

Next, you'll see some examples of these options in action. Let's start with a command line that simply displays each line of the input file-like the type command in DOS and UNIX.

perl -p -e "1;" test.dat

This command line is equivalent to:

while (<>) {

    1;

} continue {

    print;

}

And will display:

David Veterinarian

John Orthopedist

Jeff Dentist

How about just printing the first word of each line? You could use this com-
mand line:

perl -p -e "s/\s*(\w+).*/$1/;" test.dat

which is equivalent to:

while (<>) {

    s/\s*(\w+).*/$1/;

} continue {

    print;

}

And will display:

David

John

Jeff

If you have data files that store information in columns, you can pull out the second column of information like this:

perl -p -e "s/\s*.+\s(.+)\s*/$1\n/;" test.dat

which will display:

Veterinarian

Orthopedist

Dentist

You can use the -a option to get access to information stored in columns. For example, you could also display the second column like this:

perl -p -a -e "$_ = \"$F[1]\n\";" test.dat

which is equivalent to

 while (<>) {

    @F = split(/ /);

    $_ = \"$F[1]\n\";

} continue {

    print;

}

Notice that you need to escape the double-quotes in the above command line. If you don't do this you will get an error message.

Example: Using the -i Option

The -i option lets you modify files in-place. This means that Perl will automatically rename the input file and open the output file using the original name. You can force Perl to create a backup file by specifying a file extension for the backup file immediately after the -i. For example, -i.bak. If no extension is specified, no backup file will be kept.

One of the more popular uses for the -i option is to change sequences of characters. This kind of change normally requires 10 or more lines of code. However, using command-line options you can do it like this:

perl -p -i.bak -e "s/harry/tom/g;" test.dat

This command-line will change all occurrences of "harry" to "tom" in the test.dat file.

Example: Using the -s Option

The -s option lets you create your own custom switches. Custom switches are placed after the script name but before any filename arguments. Any custom switches are removed from the @ARGV array. Then a scalar variable is named after the switch is created and initialized to 1. For example, let's say that you want to use a switch called -useTR in a script like the one in Listing 17.3.

Listing 17.3  17LST03.PL-Checking for the useTR Switch

if ($useTR) {

    # do TR processing.

    print "useTR=$useTR\n";

}

You might execute this program using this following command line:

perl -s -w 17lst03.pl -useTR

and it would display:

useTR=1

Summary

This chapter covered the different command-line options that you can use with Perl. The options can also be referred to as switches because they turn different behaviors on and off.

The switches can be specified on the command line or using the #! line inside your script. If you use the #! line, try to place the options after the 32nd position to avoid inconsistent handling by different versions of UNIX.

The -n option is used to place your script inside of an input loop. The -p option uses the same loop, but also prints the $_ variable after each pass through the loop. The -a and -F options are used when you want the input lines to be split into the @F array.

Another very useful option is -i, which lets you edit files in-place. This option is good when you are doing a lot of text file manipulation.

The next chapter, "Using Internet Protocols," introduces you to some of the different standards used on the Internet. These standards let you do activities like read mail, send mail, and transfer files.

Review Questions

Answers to Review Questions are in Appendix A.

1. What is a command-line option?
2. What are the two places that the switches can be specified?
3. What switch should always be used?
4. Which switch lets you read records that end with the ~ character instead of the newline?
5. What two options can be used with the -n option?
6. How can you execute a script that someone sent you via e-mail?
7. What happens if you specify both the -v and the -c options?

Review Exercises

1. Use the -v option to see the patchlevel of your version of Perl.
2. Use the chomp or chop function to remove the dash from the end of the records printed by the program in Listing 17.2.
3. Write a program that uses the -p option to display the third column.
4. Modify the program written in Exercise 3 to use a BEGIN block to ask the user which column to display.
5. Create a sample e-mail message that contains a Perl script. Use the -x option to execute it.
6. Modify the e-mail message written for Exercise 5 to display any text that appears after the __END__ token. Hint: Use the DATA file handle.