Programming Perl, 3rd Edition

Programming Perl, 3rd Edition

by Larry Wall, Tom Christiansen, Jon Orwant
Released July 2000
Publisher(s): O'Reilly Media, Inc.
ISBN: 9780596000271

Read it now on the O’Reilly learning platform with a 10-day free trial.

O’Reilly members get unlimited access to books, live events, courses curated by job role, and more from O’Reilly and nearly 200 top publishers.

Buy on Amazon
Start your free trial

Book description

Perl is a powerful programming language that has grown in popularity since it first appeared in 1988. The first edition of this book, Programming Perl, hit the shelves in 1990, and was quickly adopted as the undisputed bible of the language. Since then, Perl has grown with the times, and so has this book. Programming Perl is not just a book about Perl. It is also a unique introduction to the language and its culture, as one might expect only from its authors. Larry Wall is the inventor of Perl, and provides a unique perspective on the evolution of Perl and its future direction. Tom Christiansen was one of the first champions of the language, and lives and breathes the complexities of Perl internals as few other mortals do. Jon Orwant is the editor of The Perl Journal, which has brought together the Perl community as a common forum for new developments in Perl. Any Perl book can show the syntax of Perl's functions, but only this one is a comprehensive guide to all the nooks and crannies of the language. Any Perl book can explain typeglobs, pseudohashes, and closures, but only this one shows how they really work. Any Perl book can say that my is faster than local, but only this one explains why. Any Perl book can have a title, but only this book is affectionately known by all Perl programmers as "The Camel." This third edition of Programming Perl has been expanded to cover version 5.6 of this maturing language. New topics include threading, the compiler, Unicode, and other new features that have been added since the previous edition.

Table of contents

  1. Programming Perl, 3rd Edition
    1. A Note Regarding Supplemental Files
    2. Preface
      1. The Pursuit of Happiness
      2. What's New in This Edition
      3. The Standard Distribution
      4. Online Documentation
        1. Navigating the Standard Manpages
        2. Searching the Manpages
        3. Non-Perl Manpages
      5. Offline Documentation
      6. Additional Resources
        1. Perl on the Web
        2. Usenet Newsgroups
        3. Bug Reports
      7. Conventions Used in This Book
      8. Acknowledgments
      9. We'd Like to Hear from You
    3. I. Overview
      1. 1. An Overview of Perl
        1. 1.1. Getting Started
        2. 1.2. Natural and Artificial Languages
          1. 1.2.1. Variable Syntax
            1. 1.2.1.1. Singularities
            2. 1.2.1.2. Pluralities
              1. 1.2.1.2.1. Arrays.
              2. 1.2.1.2.2. Hashes.
            3. 1.2.1.3. Complexities
            4. 1.2.1.4. Simplicities
          2. 1.2.2. Verbs
        3. 1.3. An Average Example
          1. 1.3.1. How to Do It
        4. 1.4. Filehandles
        5. 1.5. Operators
          1. 1.5.1. Some Binary Arithmetic Operators
          2. 1.5.2. String Operators
          3. 1.5.3. Assignment Operators
          4. 1.5.4. Unary Arithmetic Operators
          5. 1.5.5. Logical Operators
          6. 1.5.6. Some Numeric and String Comparison Operators
          7. 1.5.7. Some File Test Operators
        6. 1.6. Control Structures
          1. 1.6.1. What Is Truth?
            1. 1.6.1.1. The if and unless statements
          2. 1.6.2. Iterative (Looping) Constructs
            1. 1.6.2.1. The while and until statements
            2. 1.6.2.2. The for statement
            3. 1.6.2.3. The foreach statement
            4. 1.6.2.4. Breaking out: next and last
        7. 1.7. Regular Expressions
          1. 1.7.1. Quantifiers
          2. 1.7.2. Minimal Matching
          3. 1.7.3. Nailing Things Down
          4. 1.7.4. Backreferences
        8. 1.8. List Processing
        9. 1.9. What You Don't Know Won't Hurt You (Much)
    4. II. The Gory Details
      1. 2. Bits and Pieces
        1. 2.1. Atoms
        2. 2.2. Molecules
        3. 2.3. Built-in Data Types
        4. 2.4. Variables
        5. 2.5. Names
          1. 2.5.1. Name Lookups
        6. 2.6. Scalar Values
          1. 2.6.1. Numeric Literals
          2. 2.6.2. String Literals
          3. 2.6.3. Pick Your Own Quotes
          4. 2.6.4. Or Leave the Quotes Out Entirely
          5. 2.6.5. Interpolating Array Values
          6. 2.6.6. "Here" Documents
          7. 2.6.7. V-String Literals
          8. 2.6.8. Other Literal Tokens
        7. 2.7. Context
          1. 2.7.1. Scalar and List Context
          2. 2.7.2. Boolean Context
          3. 2.7.3. Void Context
          4. 2.7.4. Interpolative Context
        8. 2.8. List Values and Arrays
          1. 2.8.1. List Assignment
          2. 2.8.2. Array Length
        9. 2.9. Hashes
        10. 2.10. Typeglobs and Filehandles
        11. 2.11. Input Operators
          1. 2.11.1. Command Input (Backtick) Operator
          2. 2.11.2. Line Input (Angle) Operator
          3. 2.11.3. Filename Globbing Operator
      2. 3. Unary and Binary Operators
        1. 3.1. Terms and List Operators (Leftward)
        2. 3.2. The Arrow Operator
        3. 3.3. Autoincrement and Autodecrement
        4. 3.4. Exponentiation
        5. 3.5. Ideographic Unary Operators
        6. 3.6. Binding Operators
        7. 3.7. Multiplicative Operators
        8. 3.8. Additive Operators
        9. 3.9. Shift Operators
        10. 3.10. Named Unary and File Test Operators
        11. 3.11. Relational Operators
        12. 3.12. Equality Operators
        13. 3.13. Bitwise Operators
        14. 3.14. C-Style Logical (Short-Circuit) Operators
        15. 3.15. Range Operator
        16. 3.16. Conditional Operator
        17. 3.17. Assignment Operators
        18. 3.18. Comma Operators
        19. 3.19. List Operators (Rightward)
        20. 3.20. Logical and, or, not, and xor
        21. 3.21. C Operators Missing from Perl
      3. 4. Statements and Declarations
        1. 4.1. Simple Statements
        2. 4.2. Compound Statements
        3. 4.3. if and unless Statements
        4. 4.4. Loop Statements
          1. 4.4.1. while and until Statements
          2. 4.4.2. for Loops
          3. 4.4.3. foreach Loops
          4. 4.4.4. Loop Control
        5. 4.5. Bare Blocks
          1. 4.5.1. Case Structures
        6. 4.6. goto
        7. 4.7. Global Declarations
        8. 4.8. Scoped Declarations
          1. 4.8.1. Scoped Variable Declarations
          2. 4.8.2. Lexically Scoped Variables: my
          3. 4.8.3. Lexically Scoped Global Declarations: our
          4. 4.8.4. Dynamically Scoped Variables: local
        9. 4.9. Pragmas
          1. 4.9.1. Controlling Warnings
          2. 4.9.2. Controlling the Use of Globals
      4. 5. Pattern Matching
        1. 5.1. The Regular Expression Bestiary
        2. 5.2. Pattern-Matching Operators
          1. 5.2.1. Pattern Modifiers
          2. 5.2.2. The m// Operator (Matching)
          3. 5.2.3. The s/// Operator (Substitution)
            1. 5.2.3.1. Modifying strings en passant
            2. 5.2.3.2. When a global substitution just isn't global enough
          4. 5.2.4. The tr/// Operator (Transliteration)
        3. 5.3. Metacharacters and Metasymbols
          1. 5.3.1. Metasymbol Tables
          2. 5.3.2. Specific Characters
          3. 5.3.3. Wildcard Metasymbols
        4. 5.4. Character Classes
          1. 5.4.1. Custom Character Classes
          2. 5.4.2. Classic Perl Character Class Shortcuts
          3. 5.4.3. Unicode Properties
            1. 5.4.3.1. Perl's Unicode properties
            2. 5.4.3.2. Standard Unicode properties
            3. 5.4.3.3. Unicode block properties
            4. 5.4.3.4. Defining your own character properties
          4. 5.4.4. POSIX-Style Character Classes
        5. 5.5. Quantifiers
        6. 5.6. Positions
          1. 5.6.1. Beginnings: The \A and ^ Assertions
          2. 5.6.2. Endings: The \z, \Z, and $ Assertions
          3. 5.6.3. Boundaries: The \b and \B Assertions
          4. 5.6.4. Progressive Matching
          5. 5.6.5. Where You Left Off: The \G Assertion
        7. 5.7. Capturing and Clustering
          1. 5.7.1. Capturing
          2. 5.7.2. Clustering
          3. 5.7.3. Cloistered Pattern Modifiers
        8. 5.8. Alternation
        9. 5.9. Staying in Control
          1. 5.9.1. Letting Perl Do the Work
          2. 5.9.2. Variable Interpolation
            1. 5.9.2.1. When backslashes happen
            2. 5.9.2.2. The qr// quote regex operator
          3. 5.9.3. The Regex Compiler
          4. 5.9.4. The Little Engine That /Could(n't)?/
        10. 5.10. Fancy Patterns
          1. 5.10.1. Lookaround Assertions
          2. 5.10.2. Nonbacktracking Subpatterns
          3. 5.10.3. Programmatic Patterns
            1. 5.10.3.1. Generated patterns
            2. 5.10.3.2. Substitution evaluations
            3. 5.10.3.3. Match-time code evaluation
            4. 5.10.3.4. Match-time pattern interpolation
            5. 5.10.3.5. Conditional interpolation
          4. 5.10.4. Defining Your Own Assertions
      5. 6. Subroutines
        1. 6.1. Syntax
        2. 6.2. Semantics
          1. 6.2.1. Tricks with Parameter Lists
          2. 6.2.2. Error Indications
          3. 6.2.3. Scoping Issues
        3. 6.3. Passing References
        4. 6.4. Prototypes
          1. 6.4.1. Inlining Constant Functions
          2. 6.4.2. Care with Prototypes
        5. 6.5. Subroutine Attributes
          1. 6.5.1. The locked and method Attributes
          2. 6.5.2. The lvalue Attribute
      6. 7. Formats
        1. 7.1. Format Variables
        2. 7.2. Footers
          1. 7.2.1. Accessing Formatting Internals
      7. 8. References
        1. 8.1. What Is a Reference?
        2. 8.2. Creating References
          1. 8.2.1. The Backslash Operator
          2. 8.2.2. Anonymous Data
            1. 8.2.2.1. The anonymous array composer
            2. 8.2.2.2. The anonymous hash composer
            3. 8.2.2.3. The anonymous subroutine composer
          3. 8.2.3. Object Constructors
          4. 8.2.4. Handle References
          5. 8.2.5. Symbol Table References
          6. 8.2.6. Implicit Creation of References
        3. 8.3. Using Hard References
          1. 8.3.1. Using a Variable as a Variable Name
          2. 8.3.2. Using a BLOCK as a Variable Name
          3. 8.3.3. Using the Arrow Operator
          4. 8.3.4. Using Object Methods
          5. 8.3.5. Pseudohashes
          6. 8.3.6. Other Tricks You Can Do with Hard References
          7. 8.3.7. Closures
            1. 8.3.7.1. Closures as function templates
            2. 8.3.7.2. Nested subroutines
        4. 8.4. Symbolic References
        5. 8.5. Braces, Brackets, and Quoting
          1. 8.5.1. References Don't Work as Hash Keys
          2. 8.5.2. Garbage Collection, Circular References, and Weak References
      8. 9. Data Structures
        1. 9.1. Arrays of Arrays
          1. 9.1.1. Creating and Accessing a Two-Dimensional Array
          2. 9.1.2. Growing Your Own
          3. 9.1.3. Access and Printing
          4. 9.1.4. Slices
          5. 9.1.5. Common Mistakes
        2. 9.2. Hashes of Arrays
          1. 9.2.1. Composition of a Hash of Arrays
          2. 9.2.2. Generation of a Hash of Arrays
          3. 9.2.3. Access and Printing of a Hash of Arrays
        3. 9.3. Arrays of Hashes
          1. 9.3.1. Composition of an Array of Hashes
          2. 9.3.2. Generation of an Array of Hashes
          3. 9.3.3. Access and Printing of an Array of Hashes
        4. 9.4. Hashes of Hashes
          1. 9.4.1. Composition of a Hash of Hashes
          2. 9.4.2. Generation of a Hash of Hashes
          3. 9.4.3. Access and Printing of a Hash of Hashes
        5. 9.5. Hashes of Functions
        6. 9.6. More Elaborate Records
          1. 9.6.1. Composition, Access, and Printing of More Elaborate Records
          2. 9.6.2. Composition, Access, and Printing of Even More Elaborate Records
          3. 9.6.3. Generation of a Hash of Complex Records
        7. 9.7. Saving Data Structures
      9. 10. Packages
        1. 10.1. Symbol Tables
        2. 10.2. Autoloading
      10. 11. Modules
        1. 11.1. Using Modules
        2. 11.2. Creating Modules
          1. 11.2.1. Module Privacy and the Exporter
            1. 11.2.1.1. Exporting without using Exporter's import method
            2. 11.2.1.2. Version checking
            3. 11.2.1.3. Managing unknown symbols
            4. 11.2.1.4. Tag-handling utility functions
        3. 11.3. Overriding Built-in Functions
      11. 12. Objects
        1. 12.1. Brief Refresher on Object-Oriented Lingo
        2. 12.2. Perl's Object System
        3. 12.3. Method Invocation
          1. 12.3.1. Method Invocation Using the Arrow Operator
          2. 12.3.2. Method Invocation Using Indirect Objects
          3. 12.3.3. Syntactic Snafus with Indirect Objects
          4. 12.3.4. Package-Quoted Classes
        4. 12.4. Object Construction
          1. 12.4.1. Inheritable Constructors
          2. 12.4.2. Initializers
        5. 12.5. Class Inheritance
          1. 12.5.1. Inheritance Through @ISA
          2. 12.5.2. Accessing Overridden Methods
          3. 12.5.3. UNIVERSAL: The Ultimate Ancestor Class
          4. 12.5.4. Method Autoloading
          5. 12.5.5. Private Methods
        6. 12.6. Instance Destructors
          1. 12.6.1. Garbage Collection with DESTROY Methods
        7. 12.7. Managing Instance Data
          1. 12.7.1. Field Declarations with use fields
          2. 12.7.2. Generating Classes with Class::Struct
          3. 12.7.3. Generating Accessors with Autoloading
          4. 12.7.4. Generating Accessors with Closures
          5. 12.7.5. Using Closures for Private Objects
          6. 12.7.6. New Tricks
        8. 12.8. Managing Class Data
        9. 12.9. Summary
      12. 13. Overloading
        1. 13.1. The overload Pragma
        2. 13.2. Overload Handlers
        3. 13.3. Overloadable Operators
        4. 13.4. The Copy Constructor (=)
        5. 13.5. When an Overload Handler Is Missing (nomethod and fallback)
        6. 13.6. Overloading Constants
        7. 13.7. Public Overload Functions
        8. 13.8. Inheritance and Overloading
        9. 13.9. Run-Time Overloading
        10. 13.10. Overloading Diagnostics
      13. 14. Tied Variables
        1. 14.1. Tying Scalars
          1. 14.1.1. Scalar-Tying Methods
          2. 14.1.2. Magical Counter Variables
          3. 14.1.3. Magically Banishing $_
        2. 14.2. Tying Arrays
          1. 14.2.1. Array-Tying Methods
          2. 14.2.2. Notational Convenience
        3. 14.3. Tying Hashes
          1. 14.3.1. Hash-Tying Methods
        4. 14.4. Tying Filehandles
          1. 14.4.1. Filehandle-Tying Methods
          2. 14.4.2. Creative Filehandles
        5. 14.5. A Subtle Untying Trap
        6. 14.6. Tie Modules on CPAN
    5. III. Perl as Technology
      1. 15. Unicode
        1. 15.1. Building Character
        2. 15.2. Effects of Character Semantics
        3. 15.3. Caveats
      2. 16. Interprocess Communication
        1. 16.1. Signals
          1. 16.1.1. Signaling Process Groups
          2. 16.1.2. Reaping Zombies
          3. 16.1.3. Timing Out Slow Operations
          4. 16.1.4. Blocking Signals
        2. 16.2. Files
          1. 16.2.1. File Locking
          2. 16.2.2. Passing Filehandles
        3. 16.3. Pipes
          1. 16.3.1. Anonymous Pipes
          2. 16.3.2. Talking to Yourself
          3. 16.3.3. Bidirectional Communication
          4. 16.3.4. Named Pipes
        4. 16.4. System V IPC
        5. 16.5. Sockets
          1. 16.5.1. Networking Clients
          2. 16.5.2. Networking Servers
          3. 16.5.3. Message Passing
      3. 17. Threads
        1. 17.1. The Process Model
        2. 17.2. The Thread Model
          1. 17.2.1. The Thread Module
            1. 17.2.1.1. Thread creation
            2. 17.2.1.2. Thread destruction
            3. 17.2.1.3. Catching exceptions from join
            4. 17.2.1.4. The detach method
            5. 17.2.1.5. Identifying threads
            6. 17.2.1.6. Listing current threads
            7. 17.2.1.7. Yielding the processor
          2. 17.2.2. Data Access
            1. 17.2.2.1. Synchronizing access with lock
            2. 17.2.2.2. Deadlock
            3. 17.2.2.3. Locking subroutines
            4. 17.2.2.4. The locked attribute
            5. 17.2.2.5. Locking methods
            6. 17.2.2.6. Condition variables
          3. 17.2.3. Other Thread Modules
            1. 17.2.3.1. Queues
            2. 17.2.3.2. Semaphores
            3. 17.2.3.3. Other standard threading modules
      4. 18. Compiling
        1. 18.1. The Life Cycle of a Perl Program
        2. 18.2. Compiling Your Code
        3. 18.3. Executing Your Code
        4. 18.4. Compiler Backends
        5. 18.5. Code Generators
          1. 18.5.1. The Bytecode Generator
          2. 18.5.2. The C Code Generators
        6. 18.6. Code Development Tools
        7. 18.7. Avant-Garde Compiler, Retro Interpreter
      5. 19. The Command-Line Interface
        1. 19.1. Command Processing
          1. 19.1.1. #! and Quoting on Non-Unix Systems
          2. 19.1.2. Location of Perl
          3. 19.1.3. Switches
        2. 19.2. Environment Variables
      6. 20. The Perl Debugger
        1. 20.1. Using the Debugger
        2. 20.2. Debugger Commands
          1. 20.2.1. Stepping and Running
          2. 20.2.2. Breakpoints
          3. 20.2.3. Tracing
          4. 20.2.4. Display
          5. 20.2.5. Locating Code
          6. 20.2.6. Actions and Command Execution
          7. 20.2.7. Miscellaneous Commands
        3. 20.3. Debugger Customization
          1. 20.3.1. Editor Support for Debugging
          2. 20.3.2. Customizing with Init Files
          3. 20.3.3. Debugger Options
        4. 20.4. Unattended Execution
        5. 20.5. Debugger Support
          1. 20.5.1. Writing Your Own Debugger
        6. 20.6. The Perl Profiler
      7. 21. Internals and Externals
        1. 21.1. How Perl Works
        2. 21.2. Internal Data Types
        3. 21.3. Extending Perl (Using C from Perl)
          1. 21.3.1. XS and XSUBs
          2. 21.3.2. Creating Extensions
          3. 21.3.3. XSUB Input and Output
          4. 21.3.4. Using Functions from an External C Library
        4. 21.4. Embedding Perl (Using Perl from C)
          1. 21.4.1. Compiling Embedded Programs
          2. 21.4.2. Adding a Perl Interpreter to Your C Program
          3. 21.4.3. Calling a Perl Subroutine from C
          4. 21.4.4. Evaluating a Perl Statement from C
          5. 21.4.5. Fiddling with the Perl Stack from C
        5. 21.5. The Moral of the Story
    6. IV. Perl as Culture
      1. 22. CPAN
        1. 22.1. The CPAN modules Directory
        2. 22.2. Using CPAN Modules
          1. 22.2.1. Decompressing and Unpacking CPAN Modules
          2. 22.2.2. Building CPAN Modules
          3. 22.2.3. Installing CPAN Modules into the Perl Library
        3. 22.3. Creating CPAN Modules
          1. 22.3.1. Internal Testing
          2. 22.3.2. External Testing
      2. 23. Security
        1. 23.1. Handling Insecure Data
          1. 23.1.1. Detecting and Laundering Tainted Data
          2. 23.1.2. Cleaning Up Your Environment
          3. 23.1.3. Accessing Commands and Files Under Reduced Privileges
        2. 23.2. Handling Timing Glitches
          1. 23.2.1. Unix Kernel Security Bugs
          2. 23.2.2. Handling Race Conditions
          3. 23.2.3. Temporary Files
        3. 23.3. Handling Insecure Code
          1. 23.3.1. Safe Compartments
            1. 23.3.1.1. Restricting namespace access
            2. 23.3.1.2. Restricting operator access
            3. 23.3.1.3. Safe examples
          2. 23.3.2. Code Masquerading as Data
      3. 24. Common Practices
        1. 24.1. Common Goofs for Novices
          1. 24.1.1. Universal Blunders
          2. 24.1.2. Frequently Ignored Advice
          3. 24.1.3. C Traps
          4. 24.1.4. Shell Traps
          5. 24.1.5. Previous Perl Traps
        2. 24.2. Efficiency
          1. 24.2.1. Time Efficiency
          2. 24.2.2. Space Efficiency
          3. 24.2.3. Programmer Efficiency
          4. 24.2.4. Maintainer Efficiency
          5. 24.2.5. Porter Efficiency
          6. 24.2.6. User Efficiency
        3. 24.3. Programming with Style
        4. 24.4. Fluent Perl
        5. 24.5. Program Generation
          1. 24.5.1. Generating Other Languages in Perl
          2. 24.5.2. Generating Perl in Other Languages
          3. 24.5.3. Source Filters
      4. 25. Portable Perl
        1. 25.1. Newlines
        2. 25.2. Endianness and Number Width
        3. 25.3. Files and Filesystems
        4. 25.4. System Interaction
        5. 25.5. Interprocess Communication (IPC)
        6. 25.6. External Subroutines (XS)
        7. 25.7. Standard Modules
        8. 25.8. Dates and Times
        9. 25.9. Internationalization
        10. 25.10. Style
      5. 26. Plain Old Documentation
        1. 26.1. Pod in a Nutshell
          1. 26.1.1. Verbatim Paragraphs
          2. 26.1.2. Pod Directives
          3. 26.1.3. Pod Sequences
        2. 26.2. Pod Translators and Modules
        3. 26.3. Writing Your Own Pod Tools
        4. 26.4. Pod Pitfalls
        5. 26.5. Documenting Your Perl Programs
      6. 27. Perl Culture
        1. 27.1. History Made Practical
        2. 27.2. Perl Poetry
    7. V. Reference Material
      1. 28. Special Names
        1. 28.1. Special Names Grouped by Type
          1. 28.1.1. Regular Expression Special Variables
          2. 28.1.2. Per-Filehandle Variables
          3. 28.1.3. Per-Package Special Variables
          4. 28.1.4. Program-wide Special Variables
          5. 28.1.5. Per-Package Special Filehandles
          6. 28.1.6. Per-Package Special Functions
        2. 28.2. Special Variables in Alphabetical Order
      2. 29. Functions
        1. 29.1. Perl Functions by Category
        2. 29.2. Perl Functions in Alphabetical Order
          1. 29.2.1. abs
          2. 29.2.2. accept
          3. 29.2.3. alarm
          4. 29.2.4. atan2
          5. 29.2.5. bind
          6. 29.2.6. binmode
          7. 29.2.7. bless
          8. 29.2.8. caller
          9. 29.2.9. chdir
          10. 29.2.10. chmod
          11. 29.2.11. chomp
          12. 29.2.12. chop
          13. 29.2.13. chown
          14. 29.2.14. chr
          15. 29.2.15. chroot
          16. 29.2.16. close
          17. 29.2.17. closedir
          18. 29.2.18. connect
          19. 29.2.19. cos
          20. 29.2.20. crypt
          21. 29.2.21. dbmclose
          22. 29.2.22. dbmopen
          23. 29.2.23. defined
          24. 29.2.24. delete
          25. 29.2.25. die
          26. 29.2.26. do (block)
          27. 29.2.27. do (file)
          28. 29.2.28. do (subroutine)
          29. 29.2.29. dump
          30. 29.2.30. each
          31. 29.2.31. eof
          32. 29.2.32. eval
          33. 29.2.33. exec
          34. 29.2.34. exists
          35. 29.2.35. exit
          36. 29.2.36. exp
          37. 29.2.37. fcntl
          38. 29.2.38. fileno
          39. 29.2.39. flock
          40. 29.2.40. fork
          41. 29.2.41. format
          42. 29.2.42. formline
          43. 29.2.43. getc
          44. 29.2.44. getgrent
          45. 29.2.45. getgrgid
          46. 29.2.46. getgrnam
          47. 29.2.47. gethostbyaddr
          48. 29.2.48. gethostbyname
          49. 29.2.49. gethostent
          50. 29.2.50. getlogin
          51. 29.2.51. getnetbyaddr
          52. 29.2.52. getnetbyname
          53. 29.2.53. getnetent
          54. 29.2.54. getpeername
          55. 29.2.55. getpgrp
          56. 29.2.56. getppid
          57. 29.2.57. getpriority
          58. 29.2.58. getprotobyname
          59. 29.2.59. getprotobynumber
          60. 29.2.60. getprotoent
          61. 29.2.61. getpwent
          62. 29.2.62. getpwnam
          63. 29.2.63. getpwuid
          64. 29.2.64. getservbyname
          65. 29.2.65. getservbyport
          66. 29.2.66. getservent
          67. 29.2.67. getsockname
          68. 29.2.68. getsockopt
          69. 29.2.69. glob
          70. 29.2.70. gmtime
          71. 29.2.71. goto
          72. 29.2.72. grep
          73. 29.2.73. hex
          74. 29.2.74. import
          75. 29.2.75. index
          76. 29.2.76. int
          77. 29.2.77. ioctl
          78. 29.2.78. join
          79. 29.2.79. keys
          80. 29.2.80. kill
          81. 29.2.81. last
          82. 29.2.82. lc
          83. 29.2.83. lcfirst
          84. 29.2.84. length
          85. 29.2.85. link
          86. 29.2.86. listen
          87. 29.2.87. local
          88. 29.2.88. localtime
          89. 29.2.89. lock
          90. 29.2.90. log
          91. 29.2.91. lstat
          92. 29.2.92. m//
          93. 29.2.93. map
          94. 29.2.94. mkdir
          95. 29.2.95. msgctl
          96. 29.2.96. msgget
          97. 29.2.97. msgrcv
          98. 29.2.98. msgsnd
          99. 29.2.99. my
          100. 29.2.100. new
          101. 29.2.101. next
          102. 29.2.102. no
          103. 29.2.103. oct
          104. 29.2.104. open
          105. 29.2.105. opendir
          106. 29.2.106. ord
          107. 29.2.107. our
          108. 29.2.108. pack
          109. 29.2.109. package
          110. 29.2.110. pipe
          111. 29.2.111. pop
          112. 29.2.112. pos
          113. 29.2.113. print
          114. 29.2.114. printf
          115. 29.2.115. prototype
          116. 29.2.116. push
          117. 29.2.117. q/STRING/
          118. 29.2.118. quotemeta
          119. 29.2.119. rand
          120. 29.2.120. read
          121. 29.2.121. readdir
          122. 29.2.122. readline
          123. 29.2.123. readlink
          124. 29.2.124. readpipe
          125. 29.2.125. recv
          126. 29.2.126. redo
          127. 29.2.127. ref
          128. 29.2.128. rename
          129. 29.2.129. require
          130. 29.2.130. reset
          131. 29.2.131. return
          132. 29.2.132. reverse
          133. 29.2.133. rewinddir
          134. 29.2.134. rindex
          135. 29.2.135. rmdir
          136. 29.2.136. s///
          137. 29.2.137. scalar
          138. 29.2.138. seek
          139. 29.2.139. seekdir
          140. 29.2.140. select (output filehandle)
          141. 29.2.141. select (ready file descriptors)
          142. 29.2.142. semctl
          143. 29.2.143. semget
          144. 29.2.144. semop
          145. 29.2.145. send
          146. 29.2.146. setpgrp
          147. 29.2.147. setpriority
          148. 29.2.148. setsockopt
          149. 29.2.149. shift
          150. 29.2.150. shmctl
          151. 29.2.151. shmget
          152. 29.2.152. shmread
          153. 29.2.153. shmwrite
          154. 29.2.154. shutdown
          155. 29.2.155. sin
          156. 29.2.156. sleep
          157. 29.2.157. socket
          158. 29.2.158. socketpair
          159. 29.2.159. sort
          160. 29.2.160. splice
          161. 29.2.161. split
          162. 29.2.162. sprintf
          163. 29.2.163. sqrt
          164. 29.2.164. srand
          165. 29.2.165. stat
          166. 29.2.166. study
          167. 29.2.167. sub
          168. 29.2.168. substr
          169. 29.2.169. symlink
          170. 29.2.170. syscall
          171. 29.2.171. sysopen
          172. 29.2.172. sysread
          173. 29.2.173. sysseek
          174. 29.2.174. system
          175. 29.2.175. syswrite
          176. 29.2.176. tell
          177. 29.2.177. telldir
          178. 29.2.178. tie
          179. 29.2.179. tied
          180. 29.2.180. time
          181. 29.2.181. times
          182. 29.2.182. tr///
          183. 29.2.183. truncate
          184. 29.2.184. uc
          185. 29.2.185. ucfirst
          186. 29.2.186. umask
          187. 29.2.187. undef
          188. 29.2.188. unlink
          189. 29.2.189. unpack
          190. 29.2.190. unshift
          191. 29.2.191. untie
          192. 29.2.192. use
          193. 29.2.193. utime
          194. 29.2.194. values
          195. 29.2.195. vec
          196. 29.2.196. wait
          197. 29.2.197. waitpid
          198. 29.2.198. wantarray
          199. 29.2.199. warn
          200. 29.2.200. write
          201. 29.2.201. //
      3. 30. The Standard Perl Library
        1. 30.1. Library Science
        2. 30.2. A Tour of the Perl Library
      4. 31. Pragmatic Modules
        1. 31.1. use attributes
        2. 31.2. use autouse
        3. 31.3. use base
        4. 31.4. use blib
        5. 31.5. use bytes
        6. 31.6. use charnames
        7. 31.7. use constant
          1. 31.7.1. Restrictions on use constant
        8. 31.8. use diagnostics
        9. 31.9. use fields
        10. 31.10. use filetest
          1. 31.10.1. use filetest 'access'
        11. 31.11. use integer
        12. 31.12. use less
        13. 31.13. use lib
        14. 31.14. use locale
        15. 31.15. use open
        16. 31.16. use overload
        17. 31.17. use re
        18. 31.18. use sigtrap
          1. 31.18.1. Signal Handlers
          2. 31.18.2. Predefined Signal Lists
          3. 31.18.3. Other Arguments to sigtrap
          4. 31.18.4. Examples of sigtrap
        19. 31.19. use strict
          1. 31.19.1. strict 'refs'
          2. 31.19.2. strict 'vars'
          3. 31.19.3. strict 'subs'
        20. 31.20. use subs
        21. 31.21. use vars
        22. 31.22. use warnings
      5. 32. Standard Modules
        1. 32.1. Listings by Type
          1. 32.1.1. Data Types
          2. 32.1.2. String Processing, Language Text Processing, Parsing, and Searching
          3. 32.1.3. Option, Argument, Parameter, and Configuration File Processing
          4. 32.1.4. Filenames, Filesystems, and File Locking
          5. 32.1.5. Filehandle, Directory Handle, and Stream I/O Utilities
          6. 32.1.6. Internationalization and Locale
          7. 32.1.7. Operating System Interfaces
          8. 32.1.8. Networking and Interprocess Communication
          9. 32.1.9. World Wide Web
          10. 32.1.10. DBM Interfaces
          11. 32.1.11. User Interfaces
          12. 32.1.12. Authentication, Security, and Encryption
          13. 32.1.13. Perl Language Extensions and Internals
          14. 32.1.14. Convenient Classes
          15. 32.1.15. Warnings and Exceptions
          16. 32.1.16. Documentation Support
          17. 32.1.17. Module Installation Support
          18. 32.1.18. Development Support
          19. 32.1.19. Perl Compiler and Code Generator
          20. 32.1.20. Microsoft-Related Modules
        2. 32.2. Benchmark
        3. 32.3. Carp
        4. 32.4. CGI
        5. 32.5. CGI::Carp
        6. 32.6. Class::Struct
        7. 32.7. Config
        8. 32.8. CPAN
        9. 32.9. Cwd
        10. 32.10. Data::Dumper
        11. 32.11. DB_File
        12. 32.12. Dumpvalue
        13. 32.13. English
        14. 32.14. Errno
        15. 32.15. Exporter
        16. 32.16. Fatal
        17. 32.17. Fcntl
        18. 32.18. File::Basename
        19. 32.19. File::Compare
        20. 32.20. File::Copy
        21. 32.21. File::Find
        22. 32.22. File::Glob
        23. 32.23. File::Spec
        24. 32.24. File::stat
        25. 32.25. File::Temp
        26. 32.26. FileHandle
        27. 32.27. Getopt::Long
        28. 32.28. Getopt::Std
        29. 32.29. IO::Socket
        30. 32.30. IPC::Open2
        31. 32.31. IPC::Open3
        32. 32.32. Math::BigInt
        33. 32.33. Math::Complex
        34. 32.34. Math::Trig
        35. 32.35. Net::hostent
        36. 32.36. POSIX
        37. 32.37. Safe
        38. 32.38. Socket
        39. 32.39. Symbol
        40. 32.40. Sys::Hostname
        41. 32.41. Sys::Syslog
        42. 32.42. Term::Cap
        43. 32.43. Text::Wrap
        44. 32.44. Time::Local
        45. 32.45. Time::localtime
        46. 32.46. User::grent
        47. 32.47. User::pwent
      6. 33. Diagnostic Messages
      7. Glossary
    8. Index
    9. About the Authors
    10. Colophon

Product information

  • Title: Programming Perl, 3rd Edition
  • Author(s): Larry Wall, Tom Christiansen, Jon Orwant
  • Release date: July 2000
  • Publisher(s): O'Reilly Media, Inc.
  • ISBN: 9780596000271