Intermediate Perl

book cover
Intermediate Perl
By brian d foy, Tom Phoenix, Randal L. Schwartz
Publisher: O'Reilly
Pub Date: March 2006
Print ISBN-10: 0-596-10206-2
Print ISBN-13: 978-0-59-610206-7
Pages: 278

Table of Contents  | Index

Perl is a versatile, powerful programming language used in a variety of disciplines, ranging from system administration to web programming to database manipulation. One slogan of Perl is that it makes easy things easy and hard things possible. Intermediate Perl is about making the leap from the easy things to the hard ones.

Originally released in 2003 as Learning Perl Objects, References, and Modules and revised and updated for Perl 5.8, this book offers a gentle but thorough introduction to intermediate programming in Perl. Written by the authors of the best-selling Learning Perl, it picks up where that book left off. Topics include:

  • Packages and namespaces

  • References and scoping

  • Manipulating complex data structures

  • Object-oriented programming

  • Writing and using modules

  • Testing Perl code

  • Contributing to CPAN

Following the successful format of Learning Perl, we designed each chapter in the book to be small enough to be read in just an hour or two, ending with a series of exercises to help you practice what you've learned. To use the book, you just need to be familiar with the material in Learning Perl and have ambition to go further.

Perl is a different language to different people. It is a quick scripting tool for some, and a fully-featured object-oriented language for others. It is used for everything from performing quick global replacements on text files, to crunching huge, complex sets of scientific data that take weeks to process. Perl is what you make of it. But regardless of what you use Perl for, this book helps you do it more effectively, efficiently, and elegantly.

Intermediate Perl is about learning to use Perl as a programming language, and not just a scripting language. This is the book that turns the Perl dabbler into the Perl programmer.

book cover
Intermediate Perl
By brian d foy, Tom Phoenix, Randal L. Schwartz
Publisher: O'Reilly
Pub Date: March 2006
Print ISBN-10: 0-596-10206-2
Print ISBN-13: 978-0-59-610206-7
Pages: 278

Table of Contents  | Index

   Intermediate Perl
      Structure of This Book
      Conventions Used in This Book
      Using Code Examples
      Comments and Questions
      Safari® Enabled
        Chapter 1.  Introduction
      Section 1.1.  What Should You Know Already?
      Section 1.2.  What About All Those Footnotes?
      Section 1.3.  What's with the Exercises?
      Section 1.4.  What If I'm a Perl Course Instructor?
        Chapter 2.  Intermediate Foundations
      Section 2.1.  List Operators
      Section 2.2.  Trapping Errors with eval
      Section 2.3.  Dynamic Code with eval
      Section 2.4.  Exercises
        Chapter 3.  Using Modules
      Section 3.1.  The Standard Distribution
      Section 3.2.  Using Modules
      Section 3.3.  Functional Interfaces
      Section 3.4.  Selecting What to Import
      Section 3.5.  Object-Oriented Interfaces
      Section 3.6.  A More Typical Object-Oriented Module: Math::BigInt
      Section 3.7.  The Comprehensive Perl Archive Network
      Section 3.8.  Installing Modules from CPAN
      Section 3.9.  Setting the Path at the Right Time
      Section 3.10.  Exercises
        Chapter 4.  Introduction to References
      Section 4.1.  Performing the Same Task on Many Arrays
      Section 4.2.  Taking a Reference to an Array
      Section 4.3.  Dereferencing the Array Reference
      Section 4.4.  Getting Our Braces Off
      Section 4.5.  Modifying the Array
      Section 4.6.  Nested Data Structures
      Section 4.7.  Simplifying Nested Element References with Arrows
      Section 4.8.  References to Hashes
      Section 4.9.  Exercises
        Chapter 5.  References and Scoping
      Section 5.1.  More Than One Reference to Data
      Section 5.2.  What If That Was the Name?
      Section 5.3.  Reference Counting and Nested Data Structures
      Section 5.4.  When Reference Counting Goes Bad
      Section 5.5.  Creating an Anonymous Array Directly
      Section 5.6.  Creating an Anonymous Hash
      Section 5.7.  Autovivification
      Section 5.8.  Autovivification and Hashes
      Section 5.9.  Exercises
        Chapter 6.  Manipulating Complex Data Structures
      Section 6.1.  Using the Debugger to View Complex Data
      Section 6.2.  Viewing Complex Data with Data::Dumper
      Section 6.3.  YAML
      Section 6.4.  Storing Complex Data with Storable
      Section 6.5.  Using the map and grep Operators
      Section 6.6.  Applying a Bit of Indirection
      Section 6.7.  Selecting and Altering Complex Data
      Section 6.8.  Exercises
        Chapter 7.  Subroutine References
      Section 7.1.  Referencing a Named Subroutine
      Section 7.2.  Anonymous Subroutines
      Section 7.3.  Callbacks
      Section 7.4.  Closures
      Section 7.5.  Returning a Subroutine from a Subroutine
      Section 7.6.  Closure Variables as Inputs
      Section 7.7.  Closure Variables as Static Local Variables
      Section 7.8.  Exercise
        Chapter 8.  Filehandle References
      Section 8.1.  The Old Way
      Section 8.2.  The Improved Way
      Section 8.3.  The Even Better Way
      Section 8.4.  IO::Handle
      Section 8.5.  Directory Handle References
      Section 8.6.  Exercises
        Chapter 9.  Practical Reference Tricks
      Section 9.1.  Review of Sorting
      Section 9.2.  Sorting with Indices
      Section 9.3.  Sorting Efficiently
      Section 9.4.  The Schwartzian Transform
      Section 9.5.  Multi-Level Sort with the Schwartzian Transform
      Section 9.6.  Recursively Defined Data
      Section 9.7.  Building Recursively Defined Data
      Section 9.8.  Displaying Recursively Defined Data
      Section 9.9.  Exercises
        Chapter 10.  Building Larger Programs
      Section 10.1.  The Cure for the Common Code
      Section 10.2.  Inserting Code with eval
      Section 10.3.  Using do
      Section 10.4.  Using require
      Section 10.5.  require and @INC
      Section 10.6.  The Problem of Namespace Collisions
      Section 10.7.  Packages as Namespace Separators
      Section 10.8.  Scope of a Package Directive
      Section 10.9.  Packages and Lexicals
      Section 10.10.  Exercises
        Chapter 11.  Introduction to Objects
      Section 11.1.  If We Could Talk to the Animals...
      Section 11.2.  Introducing the Method Invocation Arrow
      Section 11.3.  The Extra Parameter of Method Invocation
      Section 11.4.  Calling a Second Method to Simplify Things
      Section 11.5.  A Few Notes About @ISA
      Section 11.6.  Overriding the Methods
      Section 11.7.  Starting the Search from a Different Place
      Section 11.8.  The SUPER Way of Doing Things
      Section 11.9.  What to Do with @_
      Section 11.10.  Where We Are So Far...
      Section 11.11.  Exercises
        Chapter 12.  Objects with Data
      Section 12.1.  A Horse Is a Horse, of Course of Courseor Is It?
      Section 12.2.  Invoking an Instance Method
      Section 12.3.  Accessing the Instance Data
      Section 12.4.  How to Build a Horse
      Section 12.5.  Inheriting the Constructor
      Section 12.6.  Making a Method Work with Either Classes or Instances
      Section 12.7.  Adding Parameters to a Method
      Section 12.8.  More Interesting Instances
      Section 12.9.  A Horse of a Different Color
      Section 12.10.  Getting Our Deposit Back
      Section 12.11.  Don't Look Inside the Box
      Section 12.12.  Faster Getters and Setters
      Section 12.13.  Getters That Double as Setters
      Section 12.14.  Restricting a Method to Class-Only or Instance-Only
      Section 12.15.  Exercise
        Chapter 13.  Object Destruction
      Section 13.1.  Cleaning Up After Yourself
      Section 13.2.  Nested Object Destruction
      Section 13.3.  Beating a Dead Horse
      Section 13.4.  Indirect Object Notation
      Section 13.5.  Additional Instance Variables in Subclasses
      Section 13.6.  Using Class Variables
      Section 13.7.  Weakening the Argument
      Section 13.8.  Exercise
        Chapter 14.  Some Advanced Object Topics
      Section 14.1.  UNIVERSAL Methods
      Section 14.2.  Testing Our Objects for Good Behavior
      Section 14.3.  AUTOLOAD as a Last Resort
      Section 14.4.  Using AUTOLOAD for Accessors
      Section 14.5.  Creating Getters and Setters More Easily
      Section 14.6.  Multiple Inheritance
      Section 14.7.  Exercises
        Chapter 15.  Exporter
      Section 15.1.  What use Is Doing
      Section 15.2.  Importing with Exporter
      Section 15.3.  @EXPORT and @EXPORT_OK
      Section 15.4.  %EXPORT_TAGS
      Section 15.5.  Exporting in a Primarily OO Module
      Section 15.6.  Custom Import Routines
      Section 15.7.  Exercises
        Chapter 16.  Writing a Distribution
      Section 16.1.  There's More Than One Way To Do It
      Section 16.2.  Using h2xs
      Section 16.3.  Embedded Documentation
      Section 16.4.  Controlling the Distribution with Makefile.PL
      Section 16.5.  Alternate Installation Locations (PREFIX=...)
      Section 16.6.  Trivial make test
      Section 16.7.  Trivial make install
      Section 16.8.  Trivial make dist
      Section 16.9.  Using the Alternate Library Location
      Section 16.10.  Exercise
        Chapter 17.  Essential Testing
      Section 17.1.  More Tests Mean Better Code
      Section 17.2.  A Simple Test Script
      Section 17.3.  The Art of Testing
      Section 17.4.  The Test Harness
      Section 17.5.  Writing Tests with Test::More
      Section 17.6.  Testing Object-Oriented Features
      Section 17.7.  A Testing To-Do List
      Section 17.8.  Skipping Tests
      Section 17.9.  More Complex Tests (Multiple Test Scripts)
      Section 17.10.  Exercise
        Chapter 18.  Advanced Testing
      Section 18.1.  Testing Large Strings
      Section 18.2.  Testing Files
      Section 18.3.  Testing STDOUT or STDERR
      Section 18.4.  Using Mock Objects
      Section 18.5.  Testing POD
      Section 18.6.  Coverage Testing
      Section 18.7.  Writing Your Own Test::* Modules
      Section 18.8.  Exercises
        Chapter 19.  Contributing to CPAN
      Section 19.1.  The Comprehensive Perl Archive Network
      Section 19.2.  Getting Prepared
      Section 19.3.  Preparing Your Distribution
      Section 19.4.  Uploading Your Distribution
      Section 19.5.  Announcing the Module
      Section 19.6.  Testing on Multiple Platforms
      Section 19.7.  Consider Writing an Article or Giving a Talk
      Section 19.8.  Exercise
        Appendix A.  Answers to Exercises
      Section A.1.  Answers for Chapter 2
      Section A.2.  Answers for Chapter 3
      Section A.3.  Answers for Chapter 4
      Section A.4.  Answers for Chapter 5
      Section A.5.  Answers for Chapter 6
      Section A.6.  Answer for Chapter 7
      Section A.7.  Answers for Chapter 8
      Section A.8.  Answers for Chapter 9
      Section A.9.  Answers for Chapter 10
      Section A.10.  Answers for Chapter 11
      Section A.11.  Answer for Chapter 12
      Section A.12.  Answer for Chapter 13
      Section A.13.  Answers for Chapter 14
      Section A.14.  Answers for Chapter 15
      Section A.15.  Answer for Chapter 16
      Section A.16.  Answer for Chapter 17
      Section A.17.  Answers for Chapter 18
      Section A.18.  Answer for Chapter 19
   About the Author