Enhanced descriptions from Syndetics:

Originally created as a powerful text processing tool, Perl has since evolved into a multi-purpose, multi-platform language capable of implementing a variety of tasks such as system administration, CGI and network programming, XML processing, and more. Beginning Perl, Second Edition provides valuable insight into Perl's role in all of these tasks and more.

Commencing with a comprehensive overview of language basics, you'll learn all about important concepts such as Perl's data types and control flow constructs. This material sets the stage for a discussion of more complex topics, such as writing custom functions, using regular expressions, and file input and output. Next, we move on to the advanced topics of object oriented programming, modules, CGI programming, and database administration with Perl's powerful database interface module, DBI. The examples and code provided offer you all of the information you need to start writing your own powerful scripts to solve the problems listed above, and many more.

Whether you are a complete novice or an experienced programmer, Beginning Perl, Second Edition offers an ideal guide to learning Perl.

Table of contents provided by Syndetics

• About the Author (p. xv)
• Acknowledgments (p. xvii)
• Introduction (p. xix)
• Chapter 1 First Steps in Perl (p. 1)
• Programming Languages (p. 1)
• Our First Perl Program (p. 2)
• Program Structure (p. 5)
• Escape Sequences (p. 8)
• Whitespace (p. 8)
• Number Systems (p. 8)
• The Perl Debugger (p. 10)
• Summary (p. 10)
• Exercises (p. 11)
• Chapter 2 Scalars (p. 13)
• Types of Data (p. 13)
• Numbers (p. 14)
• Strings (p. 17)
• Here-Documents (p. 20)
• Converting Between Numbers and Strings (p. 20)
• Operators (p. 21)
• Numeric Operators (p. 22)
• String Operators (p. 31)
• Operators to Be Seen Later (p. 35)
• Operator Precedence (p. 36)
• Variables (p. 37)
• Scoping (p. 41)
• Variable Names (p. 44)
• Variable Interpolation (p. 44)
• Currency Converter (p. 46)
• Two Miscellaneous Functions (p. 48)
• The exit() Function (p. 48)
• The die() Function (p. 49)
• Summary (p. 50)
• Exercises (p. 50)
• Chapter 3 Control Flow Constructs (p. 51)
• The if Statement (p. 52)
• Operators Revisited (p. 53)
• Multiple Choice: if ... else (p. 58)
• The unless Statement (p. 61)
• Expression Modifiers (p. 62)
• Using Short-Circuited Evaluation (p. 63)
• Looping Constructs (p. 63)
• The while Loop (p. 63)
• while ([left angle bracket]STDIN[right angle bracket]) (p. 65)
• Infinite Loops (p. 66)
• Looping Until (p. 67)
• The for Loop (p. 68)
• The foreach Loop (p. 68)
• do .. while and do .. until (p. 69)
• Loop Control Constructs (p. 71)
• Breaking Out (p. 71)
• Going On to the Next (p. 72)
• Reexecuting the Loop (p. 73)
• Loop Labels (p. 74)
• goto (p. 76)
• Summary (p. 76)
• Exercises (p. 76)
• Chapter 4 Lists and Arrays (p. 77)
• Lists (p. 77)
• Simple Lists (p. 77)
• Less Simple Lists (p. 78)
• Creating Lists Easily with qw// (p. 80)
• Accessing List Values (p. 83)
• Arrays (p. 87)
• Assigning Arrays (p. 87)
• Scalar vs. List Context (p. 90)
• Adding to an Array (p. 91)
• Accessing an Array (p. 91)
• Summary (p. 109)
• Exercises (p. 110)
• Chapter 5 Hashes (p. 111)
• Creating a Hash (p. 111)
• Working with Hash Values (p. 113)
• Hash in List Context (p. 115)
• Hash in Scalar Context (p. 116)
• Hash Functions (p. 117)
• The keys() Function (p. 117)
• The values() Function (p. 118)
• The each() Function (p. 119)
• The delete() Function (p. 120)
• The exists() Function (p. 120)
• Hash Examples (p. 121)
• Creating Readable Variables (p. 121)
• "Reversing" Information (p. 121)
• Counting Things (p. 122)
• Summary (p. 125)
• Exercises (p. 125)
• Chapter 6 Subroutines/Functions (p. 127)
• Understanding Subroutines (p. 128)
• Defining a Subroutine (p. 128)
• Invoking a Subroutine (p. 129)
• Order of Declaration and Invoking Functions (p. 130)
• Passing Arguments into Functions (p. 133)
• Return Values (p. 134)
• Understanding Scope (p. 137)
• Global Variables (p. 137)
• Introduction to Packages (p. 138)
• Lexical Variables (aka Local Variables) (p. 140)
• Some Important Notes on Passing Arguments (p. 141)
• Function Arguments Passed by Reference (p. 141)
• Lists Are One Dimensional (p. 143)
• Default Argument Values (p. 145)
• Named Parameters (p. 145)
• Summary (p. 147)
• Exercises (p. 147)
• Chapter 7 Regular Expressions (p. 149)
• What Are They? (p. 150)
• Patterns (p. 150)
• Working with Regexes (p. 168)
• Substitution (p. 168)
• Changing Delimiters (p. 170)
• Modifiers (p. 171)
• The split() Function (p. 172)
• The join() Function (p. 173)
• Common Blunders (p. 174)
• Summary (p. 175)
• Exercises (p. 175)
• Chapter 8 Files and Data (p. 177)
• Filehandles (p. 177)
• The open() Function (p. 177)
• The close() Function (p. 178)
• Three Ways to Open a File (p. 180)
• Reading in Scalar Context (p. 181)
• Reading with the Diamond (p. 183)
• @ARGV: The Command Line Arguments (p. 186)
• @ARGV and [left angle bracket right angle bracket] (p. 187)
• $ARGV (p. 188)
• Reading in List Context (p. 188)
• Writing to Files (p. 190)
• Buffering (p. 193)
• Opening Pipes (p. 194)
• Piping In from a Process (p. 194)
• Piping Out to Processes (p. 196)
• Bidirectional Pipes (p. 198)
• File Tests (p. 199)
• Summary (p. 204)
• Exercises (p. 204)
• Chapter 9 String Processing (p. 205)
• Character Position (p. 205)
• String Functions (p. 206)
• The length() Function (p. 206)
• The index() Function (p. 206)
• The rindex() Function (p. 208)
• The substr() Function (p. 208)
• Transliteration (p. 210)
• Summary (p. 211)
• Exercises (p. 211)
• Chapter 10 Interfacing to the Operating System (p. 213)
• The %ENV Hash (p. 213)
• Working with Files and Directories (p. 215)
• File Globbing (p. 215)
• Reading Directories (p. 218)
• Functions to Work with Files and Directories (p. 219)
• Executing External Programs (p. 223)
• The system() Function (p. 223)
• Backquotes (p. 225)
• There's More (p. 226)
• Summary (p. 227)
• Exercises (p. 227)
• Chapter 11 References (p. 229)
• What Is a Reference? (p. 229)
• Anonymity (p. 230)
• The Life Cycle of a Reference (p. 230)
• Reference Creation (p. 230)
• Reference Modification (p. 237)
• Reference Counting and Destruction (p. 241)
• Using References for Complex Data Structures (p. 242)
• Matrices (p. 242)
• Autovivification (p. 243)
• Trees (p. 247)
• Summary (p. 250)
• Exercises (p. 251)
• Chapter 12 Object-Oriented Perl (p. 253)
• Improving Your Vocabulary (p. 253)
• Objects (p. 253)
• Attributes (p. 254)
• Methods (p. 254)
• Classes (p. 255)
• Polymorphism (p. 256)
• Encapsulation (p. 256)
• Inheritance (p. 256)
• Constructors (p. 257)
• Destructors (p. 258)
• An Example (p. 258)
• Including Other Files with use (p. 261)
• do (p. 261)
• require (p. 262)
• use (p. 263)
• Changing @INC (p. 263)
• Rolling Your Own Classes (p. 264)
• Bless You, My Reference (p. 265)
• Storing Attributes (p. 267)
• The Constructor (p. 268)
• Creating Methods (p. 271)
• Do You Need OO? (p. 283)
• Are Your Subroutines Tasks? (p. 283)
• Do You Need Persistence? (p. 284)
• Do You Need Sessions? (p. 284)
• Do You Need Speed? (p. 284)
• Do You Want the User to Be Unaware of the Object? (p. 284)
• Are You Still Unsure? (p. 284)
• Summary (p. 284)
• Exercises (p. 285)
• Chapter 13 Modules (p. 287)
• Why Do We Need Them? (p. 287)
• Package Hierarchies (p. 288)
• Exporters (p. 288)
• Online Documentation (p. 290)
• Creating a Non-OO Module (p. 290)
• The Perl Standard Modules (p. 295)
• Data::Dumper (p. 295)
• File::Find (p. 297)
• Getopt::Std (p. 298)
• Getopt::Long (p. 300)
• File::Spec (p. 301)
• Benchmark (p. 302)
• Win32 (p. 304)
• CPAN (p. 305)
• Installing Modules with PPM (p. 307)
• Installing a Module Manually (p. 308)
• The CPAN Module (p. 308)
• Bundles (p. 311)
• Submitting Your Own Module to CPAN (p. 312)
• Summary (p. 313)
• Chapter 14 Introduction to CGI (p. 315)
• We Need a Webserver (p. 316)
• Creating a CGI Directory (p. 316)
• Writing CGI Programs (p. 316)
• "hello, world!" in CGI (p. 317)
• The CGI Environment (p. 319)
• Generating HTML (p. 320)
• Introducing CGI.pm (p. 322)
• Conventional Style of Calling Methods (p. 328)
• CGI.pm Methods (p. 329)
• Methods That Generate More Than One Tag (p. 329)
• Methods That Generate One Tag (p. 330)
• Processing Form Data (p. 330)
• The param() Method (p. 332)
• Dynamic CGI Program (p. 333)
• Let's Play Chess! (p. 335)
• Improvements We Can Make (p. 344)
• What We Did Not Talk About (p. 344)
• Summary (p. 345)
• Exercises (p. 346)
• Chapter 15 Perl and DBI (p. 347)
• Introduction to Relational Databases (p. 347)
• The Relational of Relational Database (p. 348)
• We Need an SQL Server--MySQL (p. 350)
• Installing MySQL (p. 350)
• Testing the MySQL Server (p. 351)
• Creating a Database (p. 352)
• Creating a Non-root User with the GRANT Command (p. 354)
• The INSERT Command (p. 355)
• The SELECT Command (p. 358)
• Table Joins (p. 364)
• Introduction to DBI (p. 365)
• Installing DBI and the DBD::mysql (p. 365)
• Connecting to the MySQL Database (p. 366)
• Executing an SQL Query with DBI (p. 367)
• A More Complex Example (p. 369)
• Use Placeholders (p. 372)
• DBI and Table Joins (p. 374)
• Perl + DBI + CGI = Fun! (p. 375)
• What We Didn't Talk About (p. 382)
• Summary (p. 383)
• Exercises (p. 383)
• Appendix Exercise Solutions (p. 385)
• Index (p. 407)