1. Overview

   1. Chapter 1 An Overview of Perl

      1. Getting Started
      2. Natural and Artificial Languages
      3. An Average Example
      4. Filehandles
      5. Operators
      6. Control Structures
      7. Regular Expressions
      8. List Processing
      9. What You Don't Know Won't Hurt You (Much)

2. The Gory Details

   1. Chapter 2 Bits and Pieces

      1. Atoms
      2. Molecules
      3. Built-in Data Types
      4. Variables
      5. Names
      6. Scalar Values
      7. Context
      8. List Values and Arrays
      9. Hashes
      10. Typeglobs and Filehandles
      11. Input Operators

   2. Chapter 3 Unary and Binary Operators

      1. Terms and List Operators (Leftward)
      2. The Arrow Operator
      3. Autoincrement and Autodecrement
      4. Exponentiation
      5. Ideographic Unary Operators
      6. Binding Operators
      7. Multiplicative Operators
      8. Additive Operators
      9. Shift Operators
      10. Named Unary and File Test Operators
      11. Relational Operators
      12. Equality Operators
      13. Bitwise Operators
      14. C-Style Logical (Short-Circuit) Operators
      15. Range Operator
      16. Conditional Operator
      17. Assignment Operators
      18. Comma Operators
      19. List Operators (Rightward)
      20. Logical and, or, not, and xor
      21. C Operators Missing from Perl

   3. Chapter 4 Statements and Declarations

      1. Simple Statements
      2. Compound Statements
      3. if and unless Statements
      4. Loop Statements
      5. Bare Blocks
      6. goto
      7. Global Declarations
      8. Scoped Declarations
      9. Pragmas

   4. Chapter 5 Pattern Matching

      1. The Regular Expression Bestiary
      2. Pattern-Matching Operators
      3. Metacharacters and Metasymbols
      4. Character Classes
      5. Quantifiers
      6. Positions
      7. Capturing and Clustering
      8. Alternation
      9. Staying in Control
      10. Fancy Patterns

   5. Chapter 6 Subroutines

      1. Syntax
      2. Semantics
      3. Passing References
      4. Prototypes
      5. Subroutine Attributes

   6. Chapter 7 Formats

      1. Format Variables
      2. Footers

   7. Chapter 8 References

      1. What Is a Reference?
      2. Creating References
      3. Using Hard References
      4. Symbolic References
      5. Braces, Brackets, and Quoting

   8. Chapter 9 Data Structures

      1. Arrays of Arrays
      2. Hashes of Arrays
      3. Arrays of Hashes
      4. Hashes of Hashes
      5. Hashes of Functions
      6. More Elaborate Records
      7. Saving Data Structures

   9. Chapter 10 Packages

      1. Symbol Tables
      2. Autoloading

   10. Chapter 11 Modules

       1. Using Modules
       2. Creating Modules
       3. Overriding Built-in Functions

   11. Chapter 12 Objects

       1. Brief Refresher on Object-Oriented Lingo
       2. Perl's Object System
       3. Method Invocation
       4. Object Construction
       5. Class Inheritance
       6. Instance Destructors
       7. Managing Instance Data
       8. Managing Class Data
       9. Summary

   12. Chapter 13 Overloading

       1. The overload Pragma
       2. Overload Handlers
       3. Overloadable Operators
       4. The Copy Constructor (=)
       5. When an Overload Handler Is Missing (nomethod and fallback)
       6. Overloading Constants
       7. Public Overload Functions
       8. Inheritance and Overloading
       9. Run-Time Overloading
       10. Overloading Diagnostics

   13. Chapter 14 Tied Variables

       1. Tying Scalars
       2. Tying Arrays
       3. Tying Hashes
       4. Tying Filehandles
       5. A Subtle Untying Trap
       6. Tie Modules on CPAN

3. Perl as Technology

   1. Chapter 15 Unicode

      1. Building Character
      2. Effects of Character Semantics
      3. Caveats

   2. Chapter 16 Interprocess Communication

      1. Signals
      2. Files
      3. Pipes
      4. System V IPC
      5. Sockets

   3. Chapter 17 Threads

      1. The Process Model
      2. The Thread Model

   4. Chapter 18 Compiling

      1. The Life Cycle of a Perl Program
      2. Compiling Your Code
      3. Executing Your Code
      4. Compiler Backends
      5. Code Generators
      6. Code Development Tools
      7. Avant-Garde Compiler, Retro Interpreter

   5. Chapter 19 The Command-Line Interface

      1. Command Processing
      2. Environment Variables

   6. Chapter 20 The Perl Debugger

      1. Using the Debugger
      2. Debugger Commands
      3. Debugger Customization
      4. Unattended Execution
      5. Debugger Support
      6. The Perl Profiler

   7. Chapter 21 Internals and Externals

      1. How Perl Works
      2. Internal Data Types
      3. Extending Perl (Using C from Perl)
      4. Embedding Perl (Using Perl from C)
      5. The Moral of the Story

4. Perl as Culture

   1. Chapter 22 CPAN

      1. The CPAN modules Directory
      2. Using CPAN Modules
      3. Creating CPAN Modules

   2. Chapter 23 Security

      1. Handling Insecure Data
      2. Handling Timing Glitches
      3. Handling Insecure Code

   3. Chapter 24 Common Practices

      1. Common Goofs for Novices
      2. Efficiency
      3. Programming with Style
      4. Fluent Perl
      5. Program Generation

   4. Chapter 25 Portable Perl

      1. Newlines
      2. Endianness and Number Width
      3. Files and Filesystems
      4. System Interaction
      5. Interprocess Communication (IPC)
      6. External Subroutines (XS)
      7. Standard Modules
      8. Dates and Times
      9. Internationalization
      10. Style

   5. Chapter 26 Plain Old Documentation

      1. Pod in a Nutshell
      2. Pod Translators and Modules
      3. Writing Your Own Pod Tools
      4. Pod Pitfalls
      5. Documenting Your Perl Programs

   6. Chapter 27 Perl Culture

      1. History Made Practical
      2. Perl Poetry

5. Reference Material

   1. Chapter 28 Special Names

      1. Special Names Grouped by Type
      2. Special Variables in Alphabetical Order

   2. Chapter 29 Functions

      1. Perl Functions by Category
      2. Perl Functions in Alphabetical Order

   3. Chapter 30 The Standard Perl Library

      1. Library Science
      2. A Tour of the Perl Library

   4. Chapter 31 Pragmatic Modules

      1. use attributes
      2. use autouse
      3. use base
      4. use blib
      5. use bytes
      6. use charnames
      7. use constant
      8. use diagnostics
      9. use fields
      10. use filetest
      11. use integer
      12. use less
      13. use lib
      14. use locale
      15. use open
      16. use overload
      17. use re
      18. use sigtrap
      19. use strict
      20. use subs
      21. use vars
      22. use warnings

   5. Chapter 32 Standard Modules

      1. Listings by Type
      2. Benchmark
      3. Carp
      4. CGI
      5. CGI::Carp
      6. Class::Struct
      7. Config
      8. CPAN
      9. Cwd
      10. Data::Dumper
      11. DB_File
      12. Dumpvalue
      13. English
      14. Errno
      15. Exporter
      16. Fatal
      17. Fcntl
      18. File::Basename
      19. File::Compare
      20. File::Copy
      21. File::Find
      22. File::Glob
      23. File::Spec
      24. File::stat
      25. File::Temp
      26. FileHandle
      27. Getopt::Long
      28. Getopt::Std
      29. IO::Socket
      30. IPC::Open2
      31. IPC::Open3
      32. Math::BigInt
      33. Math::Complex
      34. Math::Trig
      35. Net::hostent
      36. POSIX
      37. Safe
      38. Socket
      39. Symbol
      40. Sys::Hostname
      41. Sys::Syslog
      42. Term::Cap
      43. Text::Wrap
      44. Time::Local
      45. Time::localtime
      46. User::grent
      47. User::pwent

   6. Chapter 33 Diagnostic Messages

1. Colophon

Our look is the result of reader comments, our own experimentation, and feedback from distribution channels. Distinctive covers complement our distinctive approach to technical topics, breathing personality and life into potentially dry subjects. The animal on the cover of Programming Perl, Third Edition is a dromedary (one-hump camel). Camels are large ruminant mammals, weighing between 1,000 and 1,600 pounds and standing six to seven feet tall at the shoulders. They are well known for their use as draft and saddle animals in the desert regions, especially of Africa and Asia. Camels can go for days without water. If food is scarce, they will eat anything, even their owner's tent. Camels live up to 50 years. Melanie Wang was the production editor and copyeditor for Programming Perl, Third Edition. Colleen Gorman and Maureen Dempsey provided quality control. Maeve O'Meara, Mary Sheehan, Emily Quill, Jeffrey Holcomb, Ann Schirmer, Colleen Gorman, Darren Kelly, Madeleine Newell, and Betty Hugh provided production support. Ellen Troutman Zaig wrote the index.

Edie Freedman designed the cover of this book using a 19th-century engraving from the Dover Pictorial Archive. Emma Colby produced the cover layout with QuarkXPress 4.1 using Adobe's ITC Garamond font.

Alicia Cech and David Futato designed the interior layout based on a series design by Nancy Priest. The authors' text in POD was converted by Lenny Muellner into DocBook 3.1 SGML. The print version of this book was created by translating the SGML source into a set of gtroff macros using a Perl filter developed at O'Reilly & Associates by Norman Walsh. Steve Talbott designed and wrote the underlying macro set on the basis of the GNU gtroff -ms macros; Lenny Muellner adapted them to SGML and implemented the book design. The GNU groff text formatter version 1.11 was used to generate PostScript output. Mike Sierra provided crucial help with the Chinese and Japanese Unicode characters in Chapter 15. The text and heading fonts are ITC Garamond Light and Garamond Book. The illustrations that appear in the book were produced by Robert Romano and Rhon Porter using Macromedia FreeHand 8 and Adobe Photoshop 5.

Whenever possible, our books use RepKover&#153, a durable and flexible lay-flat binding. If the page count exceeds RepKover's limit, perfect binding is used.