book

Intermediate Perl

by Randal L. Schwartz, brian d foy, Tom Phoenix

March 2006

Intermediate to advanced

278 pages

6h 49m

English

O'Reilly Media, Inc.

Read now

Unlock full access

Structure of This BookConventions Used in This BookUsing Code ExamplesComments and QuestionsSafari® EnabledAcknowledgments
1.1. What Should You Know Already?1.2. What About All Those Footnotes?1.3. What’s with the Exercises?1.4. What If I’m a Perl Course Instructor?
2.1. List Operators2.1.1. List Filtering with grep2.1.2. Transforming Lists with map2.2. Trapping Errors with eval2.3. Dynamic Code with eval2.4. Exercises2.4.1. Exercise 1 [15 min]2.4.2. Exercise 2 [25 min]
3.1. The Standard Distribution3.2. Using Modules3.3. Functional Interfaces3.4. Selecting What to Import3.5. Object-Oriented Interfaces3.6. A More Typical Object-Oriented Module: Math::BigInt3.7. The Comprehensive Perl Archive Network3.8. Installing Modules from CPAN3.9. Setting the Path at the Right Time3.9.1. Handling Module Dependencies3.10. Exercises3.10.1. Exercise 1 [25 min]3.10.2. Exercise 2 [35 min]
4.1. Performing the Same Task on Many Arrays4.2. Taking a Reference to an Array4.3. Dereferencing the Array Reference4.4. Getting Our Braces Off4.5. Modifying the Array4.6. Nested Data Structures4.7. Simplifying Nested Element References with Arrows4.8. References to Hashes4.9. Exercises4.9.1. Exercise 1 [5 min]4.9.2. Exercise 2 [30 min]
5.1. More Than One Reference to Data5.2. What If That Was the Name?5.3. Reference Counting and Nested Data Structures5.4. When Reference Counting Goes Bad5.5. Creating an Anonymous Array Directly5.6. Creating an Anonymous Hash5.7. Autovivification5.8. Autovivification and Hashes5.9. Exercises5.9.1. Exercise 1 [5 min]5.9.2. Exercise 2 [40 min]
6.1. Using the Debugger to View Complex Data6.2. Viewing Complex Data with Data::Dumper6.3. YAML6.4. Storing Complex Data with Storable6.5. Using the map and grep Operators6.6. Applying a Bit of Indirection6.7. Selecting and Altering Complex Data6.8. Exercises6.8.1. Exercise 1 [20 min]6.8.2. Exercise 2 [5 min]
7.1. Referencing a Named Subroutine7.2. Anonymous Subroutines7.3. Callbacks7.4. Closures7.5. Returning a Subroutine from a Subroutine7.6. Closure Variables as Inputs7.7. Closure Variables as Static Local Variables7.8. Exercise7.8.1. Exercise [50 min]

8.1. The Old Way8.2. The Improved Way8.3. The Even Better Way8.4. IO::Handle8.4.1. IO::File8.4.2. Anonymous IO::File Objects8.4.3. IO::Scalar8.4.4. IO::Tee8.5. Directory Handle References8.5.1. IO::Dir8.6. Exercises8.6.1. Exercise 1 [20 min]8.6.2. Exercise 2 [30 min]8.6.3. Exercise 3 [15 min]
9.1. Review of Sorting9.2. Sorting with Indices9.3. Sorting Efficiently9.4. The Schwartzian Transform9.5. Multi-Level Sort with the Schwartzian Transform9.6. Recursively Defined Data9.7. Building Recursively Defined Data9.8. Displaying Recursively Defined Data9.9. Exercises9.9.1. Exercise 1 [15 min]9.9.2. Exercise 2 [15 min]9.9.3. Exercise 3 [10 min]9.9.4. Exercise 4 [20 min]
10.1. The Cure for the Common Code10.2. Inserting Code with eval10.3. Using do10.4. Using require10.5. require and @INC10.5.1. Extending @INC10.5.2. Extending @INC with PERL5LIB10.5.3. Extending @INC with -I10.6. The Problem of Namespace Collisions10.7. Packages as Namespace Separators10.8. Scope of a Package Directive10.9. Packages and Lexicals10.10. Exercises10.10.1. Exercise 1 [25 min]10.10.2. Exercise 2 [15 min]
11.1. If We Could Talk to the Animals...11.2. Introducing the Method Invocation Arrow11.3. The Extra Parameter of Method Invocation11.4. Calling a Second Method to Simplify Things11.5. A Few Notes About @ISA11.6. Overriding the Methods11.7. Starting the Search from a Different Place11.8. The SUPER Way of Doing Things11.9. What to Do with @_11.10. Where We Are So Far...11.11. Exercises11.11.1. Exercise 1 [20 min]11.11.2. Exercise 2 [40 min]
12.1. A Horse Is a Horse, of Course of Course—or Is It?12.2. Invoking an Instance Method12.3. Accessing the Instance Data12.4. How to Build a Horse12.5. Inheriting the Constructor12.6. Making a Method Work with Either Classes or Instances12.7. Adding Parameters to a Method12.8. More Interesting Instances12.9. A Horse of a Different Color12.10. Getting Our Deposit Back12.11. Don’t Look Inside the Box12.12. Faster Getters and Setters12.13. Getters That Double as Setters12.14. Restricting a Method to Class-Only or Instance-Only12.15. Exercise12.15.1. Exercise [45 min]
13.1. Cleaning Up After Yourself13.2. Nested Object Destruction13.3. Beating a Dead Horse13.4. Indirect Object Notation13.5. Additional Instance Variables in Subclasses13.6. Using Class Variables13.7. Weakening the Argument13.8. Exercise13.8.1. Exercise [45 min]
14.1. UNIVERSAL Methods14.2. Testing Our Objects for Good Behavior14.3. AUTOLOAD as a Last Resort14.4. Using AUTOLOAD for Accessors14.5. Creating Getters and Setters More Easily14.6. Multiple Inheritance14.7. Exercises14.7.1. Exercise 1 [20 min]14.7.2. Exercise 2 [40 min]
15.1. What use Is Doing15.2. Importing with Exporter15.3. @EXPORT and @EXPORT_OK15.4. %EXPORT_TAGS15.5. Exporting in a Primarily OO Module15.6. Custom Import Routines15.7. Exercises15.7.1. Exercise 1 [15 min]15.7.2. Exercise 2 [15 min]
16.1. There’s More Than One Way To Do It16.2. Using h2xs16.2.1. MANIFEST16.2.2. README16.2.3. Changes16.2.4. META.yml16.2.5. The Prototype Module Itself16.3. Embedded Documentation16.4. Controlling the Distribution with Makefile.PL16.5. Alternate Installation Locations (PREFIX=...)16.6. Trivial make test16.7. Trivial make install16.8. Trivial make dist16.9. Using the Alternate Library Location16.10. Exercise16.10.1. Exercise [30 min]
17.1. More Tests Mean Better Code17.2. A Simple Test Script17.3. The Art of Testing17.4. The Test Harness17.5. Writing Tests with Test::More17.6. Testing Object-Oriented Features17.7. A Testing To-Do List17.8. Skipping Tests17.9. More Complex Tests (Multiple Test Scripts)17.10. Exercise17.10.1. Exercise [60 min]
18.1. Testing Large Strings18.2. Testing Files18.3. Testing STDOUT or STDERR18.4. Using Mock Objects18.5. Testing POD18.6. Coverage Testing18.7. Writing Your Own Test::* Modules18.8. Exercises18.8.1. Exercise 1 [20 min]18.8.2. Exercise 2 [20 min]
19.1. The Comprehensive Perl Archive Network19.2. Getting Prepared19.3. Preparing Your Distribution19.4. Uploading Your Distribution19.5. Announcing the Module19.6. Testing on Multiple Platforms19.7. Consider Writing an Article or Giving a Talk19.8. Exercise19.8.1. Exercise [Infinite min]
A.1. Answers for Chapter 2A.1.1. Exercise 1A.1.2. Exercise 2A.2. Answers for Chapter 3A.2.1. Exercise 1A.2.2. Exercise 2A.3. Answers for Chapter 4A.3.1. Exercise 1A.3.2. Exercise 2A.4. Answers for Chapter 5A.4.1. Exercise 1A.4.2. Exercise 2A.5. Answers for Chapter 6A.5.1. Exercise 1A.5.2. Exercise 2A.6. Answer for Chapter 7A.6.1. ExerciseA.7. Answers for Chapter 8A.7.1. Exercise 1A.7.2. Exercise 2A.7.3. Exercise 3A.8. Answers for Chapter 9A.8.1. Exercise 1A.8.2. Exercise 2A.8.3. Exercise 3A.8.4. Exercise 4A.9. Answers for Chapter 10A.9.1. Exercise 1A.9.2. Exercise 2A.10. Answers for Chapter 11A.10.1. Exercise 1A.10.2. Exercise 2A.11. Answer for Chapter 12A.11.1. ExerciseA.12. Answer for Chapter 13A.12.1. ExerciseA.13. Answers for Chapter 14A.13.1. Exercise 1A.13.2. Exercise 2A.14. Answers for Chapter 15A.14.1. Exercise 1A.14.2. Exercise 2A.15. Answer for Chapter 16A.15.1. ExerciseA.16. Answer for Chapter 17A.16.1. ExerciseA.17. Answers for Chapter 18A.17.1. Exercise 1A.17.2. Exercise 2A.18. Answer for Chapter 19A.18.1. Exercise

Overview

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.