Chapter 32. Standard Modules
The previous edition of this book included comprehensive, definitive
coverage for all modules that were part of the standard Perl
distribution. But if we did that again now, you'd pay twice what
you're paying for this book, not to mention what you'd have to pay the
chiropractor after trying to carry the book home. Over the last few
years, more and more modules have come bundled standard; we're up to
around two hundred of them right now. Some of these, such as
CGI, have remarkably extensive documentation in
their own right. And if you're using ActiveState's distribution of
Perl, your standard library is even more luxed out.
So instead, we provide a complete listing of the standard modules,
sorted by type, along with a brief description of what each module
does. Then we cherry pick a few of our favorite modules by providing
examples of typical uses, followed by a short description of how they
work, just to give you a taste of using them. The descriptions are
suggestive rather than comprehensive, and virtually all the modules
have features beyond those shown. However, complete documentation for
all standard modules is included with every Perl distribution, so you
can just look up the details on your own system using the
perldoc program, your system's
man(1) command, or your favorite
browser. See the section "Online Documentation" in the Preface. Ask
your Local Expert if you can't find the docs, because they're almost
certainly installed somewhere on your system.
Even if they're not, you can always read the pod docs directly from
the modules themselves, because all module docs come embedded in their
corresponding module (.pm) files, and pod was
designed to be somewhat readable. (Unlike, say, HTML.)
32.1. Listings by Type
Normal module names begin with an uppercase letter. Lowercase names
indicate pragmas that you'll find documented in Chapter 31, "Pragmatic Modules", rather than in this chapter.
32.1.1. Data Types
These modules extend Perl's type system (or lack thereof) in various
ways.
Module |
Description |
Class::Struct |
Create struct-like Perl object classes
|
constant |
Declare constant scalars and lists
|
integer |
Force Perl to do arithmetic with integers instead of floating point
|
Math::BigFloat |
Calculate with arbitrary length floating-point math
|
Math::BigInt |
Calculate with arbitrary length integer math
|
Math::Complex |
Calculate with complex numbers and associated mathematical functions
|
Math::Trig |
Load many trigonometric and related functions
|
overload |
Overload Perl operators on objects
|
Symbol |
Manipulate Perl symbol tables and generate anonymous
typeglobs
|
Time::Local |
Efficiently compute epoch time given localtime or gmtime
|
32.1.2. String Processing, Language Text Processing, Parsing, and Searching
These modules do things with (or to) text.
Module |
Description |
Search::Dict |
Use a binary search for a string in a sorted text file
|
Text::Abbrev |
Create an abbreviation table from a list
|
Text::ParseWords |
Parse text into a list of tokens or an array of arrays
|
Text::Soundex |
Use Knuth's Soundex algorithm
|
Text::Tabs |
Expand or unexpand tabs like expand
(1) and unexpand
(1) |
Text::Wrap |
Wrap lines to form simple paragraphs
|
32.1.3. Option, Argument, Parameter, and Configuration
File Processing
These modules process your command line.
Module |
Description |
Getopt::Long
|
Process extended command-line options in long form (--xxx) |
Getopt::Std |
Process single-character switches with switch clustering (-xyz)
|
32.1.4. Filenames, Filesystems, and File Locking
These modules provide cross-platform methods of file access.
Module |
Description |
Cwd |
Get the pathname of the current working directory
|
File::Basename |
Portably parse a pathname into directory, basename, and extension components
|
File::CheckTree |
Run many file test checks on a set of directory trees
|
File::Compare |
Portably compare contents of filenames or filehandles
|
File::Copy |
Portably copy filenames or filehandles or move filenames
|
File::DosGlob |
Do Microsoft-style fileglobbing
|
File::Find |
Traverse a file tree like find(1)
|
File::Glob |
Use Unix-style fileglobbing
|
File::Path |
Portably create or remove a series of directories
|
File::Spec |
Use portable filename operations (object-oriented interface)
|
File::Spec::Functions |
Use portable filename operations (functional interface)
|
File::Spec::Mac |
Use filename operations for Mac OS files
|
File::Spec::OS2 |
Use filename operations for OS/2 files
|
File::Spec::Unix |
Use filename operations for Unix files
|
File::Spec::VMS |
Use filename operations for VMS files
|
File::Spec::Win32 |
Use filename operations for Microsoft files
|
File::stat |
Override built-in stat and lstat functions with a method interface
|
32.1.5. Filehandle, Directory Handle, and
Stream I/O Utilities
These modules provide object-oriented file, directory, and IPC access.
Module |
Description |
DirHandle |
Use object methods for directory handles
|
FileCache |
Keep more files concurrently open for output than your system permits
|
FileHandle |
Use object methods for filehandles
|
IO |
Provide a frontend to load all of IO::Dir, IO::File, IO::Handle,
IO::Pipe, IO::Seekable, and IO::Socket
|
IO::Dir |
Use object methods for directory handles
|
IO::File |
Use file-related object methods for filehandles
|
IO::Handle |
Use generic object methods for filehandles
|
IO::Pipe |
Use object methods for pipes
|
IO::Poll |
Provide an object interface to poll(2) syscall
|
IO::Seekable |
Use object methods for seekable I/O objects
|
IO::Select |
Use a convenient OO interface to the select(2) syscall
|
SelectSaver |
Save and restore selected filehandle
|
32.1.6. Internationalization and Locale
These modules help you perform Un-American Activities.
Module |
Description |
bytes |
Enforce old byte-oriented semantics
|
charnames |
Define character names used in \N{name} escapes in string literals
|
I18N::Collate |
Compare 8-bit scalar data according to current locale
(deprecated)
|
locale |
Use or avoid POSIX locales for built-in operations
|
utf8 |
Turn on UTF-8 and Unicode support explicitly
|
32.1.7. Operating System Interfaces
These modules tweak your interface to the operating system.
Module |
Description |
Fcntl |
Load the C library's fcntl.h definitions as Perl constants
|
filetest |
Control the file test operators (-r, -w, etc.) for
nontraditional filesystems
|
open |
Set default disciplines for open function calls
|
POSIX |
Use the Perl interface to POSIX 1003.1
|
Shell |
Run shell commands transparently within Perl
|
sigtrap |
Enable simple signal handling
|
Sys::Hostname |
Portably try every conceivable way to determine the current hostname
|
Sys::Syslog |
Use the C library's syslog(3) functions
|
Time::gmtime |
Override the built-in gmtime function with a method interface
|
Time::localtime |
Override the built-in localtime function with a method interface
|
Time::tm |
Provide the internal object used by Time::gmtime and Time::localtime
|
User::grent |
Override built-in getgr* functions with a method interface
|
User::pwent |
Override built-in getpw* functions with a method interface
|
32.1.8. Networking and Interprocess Communication
These modules provide abstract interfaces around the basic
interfaces we wrote about in Chapter 16, "Interprocess Communication".
Module |
Description |
IO::Socket |
Use a generic object interface to socket communications
|
IO::Socket::INET |
Use an object interface for Internet-domain sockets
|
IO::Socket::UNIX |
Use an object interface for Unix-domain (local) sockets
|
IPC::Msg |
Use object methods for working with System V messages
(SysV Msg IPC object class)
|
IPC::Open2 |
Open a process for simultaneous reading and writing
|
IPC::Open3 |
Open a process for reading, writing, and error handling
|
IPC::Semaphore |
Use object methods for System V semaphores
|
IPC::SysV |
Define constants for all System V IPC mechanisms
|
Net::hostent |
Override built-in gethost* functions
with a method interface
|
Net::netent |
Override built-in getnet* functions
with a method interface
|
Net::Ping |
Check a remote host for reachability
|
Net::protoent |
Override built-in getproto* functions
with a method interface
|
Net::servent |
Override built-in getserv* functions
with a method interface
|
Socket |
Load the C library socket.h definitions and structure manipulators
|
32.1.9. World Wide Web
These modules interface to the WWW. You may have heard of it.
Module |
Description |
CGI |
Access CGI forms and powerful automated HTML generation
|
CGI::Apache |
Make your CGI script work under the Perl-Apache API
|
CGI::Carp |
Write to the httpd(8) (or other) CGI error log
|
CGI::Cookie |
Set and get HTTP cookies
|
CGI::Fast |
Use the Fast CGI protocol
|
CGI::Pretty |
Produce nicely formatted HTML code
|
CGI::Push |
Do server-push CGI scripting
|
32.1.10. DBM Interfaces
These modules load various database management libraries.
Module |
Description |
AnyDBM_File |
Provide a framework for multiple DBM libraries
|
DB_File |
Provide tied access to the db(3) library (version 1.x Berkeley DB)
|
GDBM_File |
Provide tied access to the gdbm(3) library
|
NDBM_File |
Provide tied access to the ndbm(3) library
|
SDBM_File |
Provide tied access to SDBM (simple DBM) files
|
32.1.11. User Interfaces
These modules provide a decent OS CLI I/O API, ASAP.
Module |
Description |
Term::Cap |
Use the termcap(3) library
|
Term::Complete |
Do programmable command completion on word lists
|
Term::ReadLine |
Use any of several readline packages
|
32.1.12. Authentication, Security, and Encryption
These modules work with sandboxes.
Module |
Description |
Opcode |
Enable or disable named opcodes when compiling Perl code
for use with the Safe module
|
ops |
Restrict unsafe operations when compiling
|
Safe |
Compile and execute code in restricted compartments
|
32.1.13. Perl Language Extensions and Internals
(Not to be confused with Intentions and Externals.)
Module |
Description |
attributes |
Get or set subroutine or variable attributes
|
attrs |
Get or set subroutine or variable attributes (obsolete)
|
base |
Establish inheritance of base class at compile time
|
Data::Dumper |
Serialize Perl data structures
|
DB |
Access the Perl debugger's experimental API
|
Devel::DProf |
Profile a Perl program's execution
|
Devel::Peek |
Load data debugging tools for XS programmers
|
diagnostics |
Force verbose warnings and suppress duplicates
|
Dumpvalue |
Provide screen dump of data
|
English |
Use longer variable names for built-in punctuation variables
|
Env |
Access environment variables in %ENV as regular scalars
|
Errno |
Load the C library's errno.h definitions and tie the %! variable
|
Fatal |
Replace built-ins with versions that raise exceptions on failure
|
fields |
Declare compile-time verified access to a class's data attributes
|
less |
Request less of something from Perl (unimplemented)
|
re |
Alter default regular expression behavior
|
strict |
Restrict sloppy constructs
|
subs |
Predeclare the subroutine names in current the package
|
vars |
Predeclare global variables (obsolete--see our in Chapter 29, "Functions")
|
32.1.14. Convenient Classes
These modules provide base classes and other conveniences.
Module |
Description |
Tie::Array |
Provide a base class for tied arrays
|
Tie::Handle |
Provide base class definitions for tied handles
|
Tie::Hash |
Provide base class definitions for tied hashes
|
Tie::RefHash |
Provide references as hash keys
|
Tie::Scalar |
Provide base class definitions for tied scalars
|
Tie::SubstrHash |
Hash a fixed-size table with a fixed-length key
|
UNIVERSAL |
Provide a base class for all classes (blessed references)
|
32.1.15. Warnings and Exceptions
What to do when things go rwong.
Module |
Description |
Carp |
Provide routines that warn and die from the perspective of the caller
|
warnings |
Control warnings within the lexical scope
|
32.1.16. Documentation Support
And there's an awful lot of documentation to support.
Module |
Description |
Pod::Checker |
Check pod documents for syntax errors (used by podchecker(1))
|
Pod::Functions |
List built-in functions by type
|
Pod::Html |
Convert pod files to HTML (used by pod2html(1))
|
Pod::InputObjects |
Manage documentation support
|
Pod::Man |
Convert pod to troff(1) format for the man(1) system (used by pod2man(1))
|
Pod::Parser |
Provide a base class for creating pod filters and translators
|
Pod::Select |
Extract selected sections of pod from input (used by podselect(1))
|
Pod::Text |
Convert pod data to formatted ASCII text
(used by pod2text(1))
|
Pod::Text::Color |
Convert pod data to formatted ASCII text with ANSI color escapes
|
Pod::Text::Termcap |
Convert pod data to ASCII text with terminal-specific escapes
|
Pod::Usage |
Print a usage message derived from embedded pod documentation
|
32.1.17. Module Installation Support
These modules help other modules jump through various hoops.
Module |
Description |
AutoLoader |
Load subroutines only on demand
|
AutoSplit |
Split a package for autoloading
|
autouse |
Postpone module loading until a function is used from that module
|
blib |
Use the library from MakeMaker's uninstalled version of an extension
|
Config |
Access Perl configuration information
|
CPAN |
Query, download, and build Perl modules from CPAN sites
|
Devel::SelfStubber |
Generate stubs for a module using SelfLoader
|
DynaLoader |
Dynamically load C or C++ libraries as Perl extensions
|
Exporter |
Implement default import method for traditional modules
|
ExtUtils::Command |
Provide utilities to replace common external commands in Makefile
|
ExtUtils::Embed |
Provide utilities for embedding Perl in C or C++ programs
|
ExtUtils::Install |
Install files into the system's Perl library
|
ExtUtils::Installed |
Manage inventory of installed modules
|
ExtUtils::Liblist |
Determine which libraries to use and how to use them
|
ExtUtils::MakeMaker |
Create a Makefile for a Perl extension
|
ExtUtils::Manifest |
Load tools to write and check a MANIFEST file
|
ExtUtils::Miniperl |
Write the C code for perlmain.c
|
ExtUtils::Mkbootstrap |
Create a bootstrap file for use by DynaLoader
|
ExtUtils::Mksymlists |
Write linker options files for dynamic extension
|
ExtUtils::MM_Cygwin |
Override Unix behavior methods in ExtUtils::MakeMaker
|
ExtUtils::MM_OS2 |
Override Unix behavior methods in ExtUtils::MakeMaker
|
ExtUtils::MM_Unix |
Provide methods used by ExtUtils::MakeMaker
|
ExtUtils::MM_VMS |
Override Unix behavior methods in ExtUtils::MakeMaker
|
ExtUtils::MM_Win32 |
Override Unix behavior methods in ExtUtils::MakeMaker
|
ExtUtils::Packlist |
Manage .packlist files
|
ExtUtils::testlib |
Add blib/* directories to @INC
|
FindBin |
Locate installation directory of the Perl program that is running
|
lib |
Manipulate @INC at compile time
|
SelfLoader |
Load functions only on demand
|
XSLoader |
Dynamically load C or C++ libraries as Perl extensions
|
32.1.18. Development Support
These modules are for timing and testing, to see how much faster
and cleaner your code doesn't run anymore.
Module |
Description |
Benchmark |
Compare running times of alternate code versions
|
Test |
Use a simple framework for writing test scripts
|
Test::Harness |
Run standard test scripts with statistics
|
32.1.19. Perl Compiler and Code Generator
These modules support various backend code generators for Perl.
Module |
Description |
B |
Load Perl code generators (a.k.a. the "Perl compiler")
|
B::Asmdata |
Provide autogenerated data about Perl ops to produce bytecode
|
B::Assembler |
Assemble Perl bytecode
|
B::Bblock |
Walk basic blocks in the syntax tree
|
B::Bytecode |
Use the Perl compiler's bytecode backend
|
B::C |
Use the Perl compiler's C translation backend
|
B::CC |
Use the Perl compiler's optimized C translation backend
|
B::Debug |
Walk the Perl syntax tree, printing debug info about ops
|
B::Deparse |
Use the Perl compiler backend to reproduce Perl code
|
B::Disassembler |
Disassemble Perl bytecode
|
B::Lint |
Catch dubious constructs
|
B::Showlex |
Show lexical variables used in functions or files
|
B::Stash |
Show what stashes are loaded
|
B::Terse |
Walk the Perl syntax tree, printing terse info about ops
|
B::Xref |
Generate cross-reference reports for Perl programs
|
ByteLoader |
Load byte-compiled Perl code
|
O |
Provide a generic interface to Perl compiler backends
|
32.1.20. Microsoft-Related Modules
If you got the Perl distribution for Microsoft systems from
ActiveState, you already have the following Microsoft-only modules
included for you. If you just grabbed the standard source distribution
(maybe you want to build it under the Cygwin Unix-emulation environment) but you're running on Wintel, you can get all of these modules
from CPAN.
Module |
Description |
Win32::ChangeNotify |
Monitor events related to files and directories
|
Win32::Console |
Use Win32 console and character mode functions
|
Win32::Event |
Use Win32 event objects from Perl
|
Win32::EventLog |
Process Win32 event logs from Perl
|
Win32::File |
Manage file attributes in Perl
|
Win32::FileSecurity |
Manage FileSecurity Discretionary Access Control Lists in Perl
|
Win32::IPC |
Load the base class for Win32 synchronization objects
|
Win32::Internet |
Access WININET.DLL functions
|
Win32::Mutex |
Use Win32 mutex objects from Perl
|
Win32::NetAdmin |
Manage network groups and users in Perl
|
Win32::NetResource |
Manage network resources in Perl
|
Win32::ODBC |
Use ODBC Extension for Win32
|
Win32::OLE |
Use OLE automation extensions
|
Win32::OLE::Const |
Extract constant definitions from TypeLib
|
Win32::OLE::Enum |
Use OLE Automation Collection Objects
|
Win32::OLE::NLS |
Use OLE National Language Support
|
Win32::OLE::Variant |
Create and modify OLE VARIANT variables
|
Win32::PerfLib |
Access the Windows NT Performance Counter
|
Win32::Process |
Create and manipulate processes
|
Win32::Semaphore |
Use Win32 semaphore objects
|
Win32::Service |
Manage system services
|
Win32::Sound |
Play with Windows sounds
|
Win32::TieRegistry |
Mung the registry
|
Win32API::File |
Access low-level Win32 system API calls for files and directories
|
Win32API::Net |
Manage Windows NT LanManager accounts
|
Win32API::Registry |
Access low-level Win32 system API calls from WINREG.H
|
| | |
31.22. use warnings | | 32.2. Benchmark |
Copyright © 2001 O'Reilly & Associates. All rights reserved.