- Packages
- Modules
- Exporting symbols
- Some example modules
- Documenting modules with POD
- Conclusion
This chapter is from the book
This chapter is from the book
This chapter is from the book
6.4 Some example modules
The Perl distribution comes with many modules, and CPAN (see Section 1.6) offers thousands of others. This section describes a few of these modules and how to use them.
6.4.1 Math::Trig
The Math::Trig module, which was written by Jarkko Hietaniemi and Raphael Manfredi, defines subroutines that fill in some of Perl's missing trigonometric functions. All of its subroutines are exported by default to the caller's package.
Among the subroutines defined by Math::Trig are tan, which returns the tangent of an angle in radians, and deg2rad, which converts degrees to radians. Here is an example of how to use this module:
#!/usr/bin/perl use strict; use warnings; use Math::Trig; my $angle_degrees = 30; my $angle_radians = deg2rad $angle_degrees; my $tangent = tan $angle_radians; print "Tangent of $angle_degrees degrees is $tangent.\n";
6.4.2 File::Compare
File::Compare, written by Nick Ing-Simmons, compares two files. It returns 0 if the files are equal, 1 if the files are different, or -1 if there was an error.
By default, File::Compare exports the compare subroutine to the caller's package. The following program uses File::Compare to compare two files:
#!/usr/bin/perl
# filename: compare-files.pl
use strict;
use warnings;
use File::Compare;
# What files should we compare?
my $file1 = "/home/reuven/.bashrc";
my $file2 = "/home/reuven/.bash_profile";
# Compare the files, and get a result
my $result = compare($file1, $file2);
if ($result == 0)
{
print "'$file1' and '$file2' are identical.\n";
}
elsif ($result == 1)
{
print "'$file1' and '$file2' are different.\n";
}
elsif ($result == -1)
{
die "Problem running File::Compare::compare: $! ";
}
else
{
die "Error! Result of '$result' from File::Compare: $! ";
}
6.4.3 Getopt::Long
Getopt::Long, written by Johan Vromans and available on CPAN (see Section 1.6), makes it easy for Perl programs to accept command-line arguments. Unix programs often allow an option to be invoked with a single-letter argument or an equivalent, one-word argument. For example, GNU cat sees the -n and –number options as equivalent.
Command-line arguments often take values. For example:
program --number=5
Getopt::Long automatically exports the subroutine GetOptions. takes a hash as an argument, in which the keys describe the data types and the values are references to variables that should be assigned the argument's value. For instance, a program can automatically place the integer argument to the –number flag in the $number variable with:
GetOpt("number=i" => \$number);
To make –number and -n aliases for one another, separate the possibilities with a vertical bar (|). The following program demonstrates how to integrate this feature into a program:
#!/usr/bin/perl
# filename: test-getopt.pl
use strict;
use warnings;
use Getopt::Long;
# Declare the variable, giving a default value
my $number = 0;
# Get the options
my $success = GetOptions("number|n=i" => \$number);
# Use the variable
print "Option was $number\n" if $success;
If this program is invoked without –number or -n, GetOptions does not modify $number. GetOptions also tests the type of data passed in –number, exiting with a fatal error if the user passes a string or float.
The manual for Getopt::Long, available after installation with perldoc Getopt::Long, describes the module's type checking in detail.
6.4.4 Data::Dumper
Data::Dumper, written by Gurusamy Sarathy and available from CPAN (see Section 1.6), makes it possible to store, pass, and retrieve complex data structures. By default, Data::Dumper exports its Dumper subroutine.
The following program demonstrates how Data::Dumper stores an array of arrays:
#!/usr/bin/perl # filename: demo-dumper.pl use strict; use warnings; use Data::Dumper; # Translate 0-1-2-3 (English, Spanish, Hebrew) my @array0 = qw(zero cero efes); my @array1 = qw(one uno achat); my @array2 = qw(two dos shtayim); my @array3 = qw(three tres shalosh); # Create a reference to our array of arrays my $numbers_ref = [\@array0, \@array1, \@array2, \@array3]; print Dumper($numbers_ref), "\n";
The output from demo-dumper.pl looks like this:
$VAR1 = [
[
'zero',
'cero',
'efes'
],
[
'one',
'uno',
'achat'
],
[
'two',
'dos',
'shtayim'
],
[
'three',
'tres',
'shalosh'
]
];
Data::Dumper is particularly useful for saving data structures to disk and then reading them back again. The following program reads this structure from the file /tmp/output-file, retrieves it into a lexical with eval, and then displays its contents:
#!/usr/bin/perl
# filename: read-dumped-data.pl
use strict;
use warnings;
my $VAR1;
# What file is it?
my $file = "/tmp/output-file";
# Open a filehandle
open FILE, $file or die "Cannot read '$file': $! ";
# Grab the whole file at once
undef $/;
# Read the contents
my $contents = (<FILE>);
# Close the filehandle
close FILE;
# Evaluate the contents into a new array ref
eval $contents;
foreach my $number (@$VAR1)
{
print "English: $number->[0]\n";
print "Spanish: $number->[1]\n";
print "Hebrew: $number->[2]\n";
print "\n";
}