PerlReference StandardModules

From PostgreSQL 中文维基, PostgreSQL 中文站, PostgreSQL 中国社区, PostgreSQL Chinese community

Chapter 32. Standard Modules Contents: Listings by Type Benchmark Carp CGI CGI::Carp Class::Struct Config CPAN Cwd Data::Dumper DB_File Dumpvalue English Errno Exporter Fatal Fcntl File::Basename File::Compare File::Copy File::Find File::Glob File::Spec File::stat File::Temp FileHandle Getopt::Long Getopt::Std IO::Socket IPC::Open2 IPC::Open3 Math::BigInt Math::Complex Math::Trig Net::hostent POSIX Safe Socket Symbol Sys::Hostname Sys::Syslog Term::Cap Text::Wrap Time::Local Time::localtime User::grent User::pwent

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