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 inLearning 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. 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 Foreword Preface Structure of This Book Conventions Used in This Book Using Code Examples Comments and Questions Safari® Enabled Acknowledgments 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.