9780201419757

There is an increasing need for more advanced information about how to write the most effective Perl scripts. This book shows in sixty concise and direct lessons how to tackle and solve common programming obstacles. Effective Perl Programming explains idiomatic Perl, covering the latest release (Version 5), and includes information and useful examples about the structure, functions, and latest capabilities of the language, such as self-documenting object-oriented modules. You can also learn from Hall's answers to real life questions and problems he receives from newsgroups and his Perl seminars.

Joseph N. Hall is a software designer with interests in object-oriented languages, compilers, and graphical user interfaces. He teaches Perl and World Wide Web classes in association with Stonehenge Consulting, a leading provider of Perl Instruction.

0201419750AB04062001

Foreword

ix

(2)

Preface

xi

(2)

Acknowledgements

xiii

Introduction

1

(8)

Basics

9

(14)

Item 1: Know your namespaces.

9

(2)

Item 2: Avoid using a slice when you want an element.

11

(4)

Item 3: Don't assign undef when you want an empty list.

15

(2)

Item 4: String and numeric comparisons are different.

17

(1)

Item 5: Remember that 0 and "" are false.

18

(1)

Item 6: Understand conversions between strings and numbers.

19

(4)

Idiomatic Perl

23

(28)

Item 7: Use $_ for elegance.

26

(1)

Item 8: Know the other default arguments: @_, @ARGV, STDIN.

27

(2)

Item 9: Know common shorthands and syntax quirks.

29

(5)

Item 10: Avoid excessive punctuation.

34

(1)

Item 11: Consider different ways of reading from a stream.

35

(2)

Item 12: Use foreach, map and grep as appropriate.

37

(4)

Item 13: Don't misquote.

41

(2)

Item 14: Learn the myriad ways of sorting.

43

(8)

Regular Expressions

51

(36)

Item 15: Know the precedence of regular expression operators.

51

(4)

Item 16: Use regular expression memory.

55

(9)

Item 17: Avoid greed when parsimony is best.

64

(4)

Item 18: Remember that whitespace is not a word boundary.

68

(3)

Item 19: Use split for clarity, unpack for efficiency.

71

(3)

Item 20: Avoid using regular expressions for simple string operations.

74

(3)

Item 21: Make regular expressions readable.

77

(3)

Item 22: Make regular expressions efficient.

80

(7)

Subroutines

87

(30)

Item 23: Understand the difference between my and local.

87

(8)

Item 24: Avoid using @_ directly--unless you have to.

95

(2)

Item 25: Use wantarray to write subroutines returning lists.

97

(2)

Item 26: Pass references instead of copies.

99

(5)

Item 27: Use hashes to pass named parameters.

104

(4)

Item 28: Use prototypes to get special argument parsing.

108

(2)

Item 29: Use subroutines to create other subroutines.

110

(7)

References

117

(20)

Item 30: Understand references and reference syntax.

117

(7)

Item 31: Create lists of lists with references.

124

(2)

Item 32: Don't confuse anonymous arrays with list literals.

126

(2)

Item 33: Build C-style structs with anonymous hashes.

128

(2)

Item 34: Be careful with circular data structures.

130

(3)

Item 35: Use map and grep to manipulate complex data structures.

133

(4)

Debugging

137

(26)

Item 36: Enable static and/or run-time checks.

138

(8)

Item 37: Use debugging and profiling modules.

146

(5)

Item 38: Learn to use a debugging version of Perl.

151

(4)

Item 39: Test things by using the debugger as a Perl "shell."

155

(3)

Item 40: Don't debug too much at once.

158

(5)

Using Packages and Modules

163

(14)

Item 41: Don't reinvent the wheel--use Perl modules.

163

(3)

Item 42: Understand packages and modules.

166

(4)

Item 43: Make sure Perl can find the modules you are using.

170

(3)

Item 44: Use perldoc to extract documentation for installed modules.

173

(4)

Writing Packages and Modules

177

(20)

Item 45: Use h2xs to generate module boilerplate.

177

(6)

Item 46: Embed your documentation with POD.

183

(4)

Item 47: Use XS for low-level interfaces and/or speed.

187

(6)

Item 48: Submit your useful modules to the CPAN.

193

(4)

Object-Oriented Programming

197

(22)

Item 49: Consider using Perl's object-oriented programming features.

199

(5)

Item 50: Understand method inheritance in Perl.

204

(6)

Item 51: Inherit data explicitly.

210

(2)

Item 52: Create invisible interfaces with tied variables.

212

(7)

Miscellany

219

(32)

Item 53: Use pack and unpack for data munging.

219

(4)

Item 54: Know how and when to use eval, require, and do.

223

(6)

Item 55: Know when, and when not, to write networking code.

229

(7)

Item 56: Don't forget the file test operators.

236

(1)

Item 57: Access the symbol table with typeglobs.

237

(2)

Item 58: Use @{[...]} or a tied hash to evaluate expressions inside strings.

239

(3)

Item 59: Initialize with BEGIN; finish with END.

242

(3)

Item 60: Some interesting Perl one-liners.

245

(6)

Appendix A: sprintf

251

(4)

Appendix B: Perl Resources

255

(2)

Index

257

What is included with this book?

The New copy of this book will include any supplemental materials advertised. Please check the title of the book to determine if it should include any access cards, study guides, lab manuals, CDs, etc.

The Used, Rental and eBook copies of this book are not guaranteed to include any supplemental materials. Typically, only the book itself is included. This is true even if the title states it includes any access cards, study guides, lab manuals, CDs, etc.

I used to write a lot of C and C++. My last major project before stepping into the world of Perl full time was an interpreted language that, among other things, drew diagrams, computed probabilities, and generated entire FrameMaker books. It comprised over 50,000 lines of platform-independent C++, and it had all kinds of interesting internal features. It was a fun project. It also took two years to write. It seems to me that most interesting projects in C and/or C++ take months or years to complete. But it also seems to me that a whole lot of ideas that start out being mundane and uninteresting become interesting three-month projects when they are expressed in an ordinary high-level language. This is one of the reasons why I originally became interested in Perl. I had heard that Perl was an excellent scripting language with powerful string handling, regular expression, and process control features. I learned Perl, and learned to like it, when I was thrown into a project in which most of my work involved slinging around text files. I quickly found myself spending hours writing Perl programs that would have taken me days or weeks to write in a different language. Who should read this book Effective Perl Programmingis a book of advice and examples. It derives from my experience as a Perl programmer and--especially--as a Perl instructor. The book is suitable for readers who have a basic understanding of Perl and a few months of practical experience programming in it. Because Effective Perl Programmingis a guidebook, not a manual, readers will need access to a comprehensive reference. I recommend either the Perl man pages (freely available in many forms, including Unix man and HTML) or Programming Perl. Although I use a lot of Unix-derived examples in this book, most of what appears here is not specific to Unix. I thought about including Win32 Perl and MacPerl examples but eventually decided that the book would have more integrity and consistency if it didn''t stray from Perl''s "native" operating system. I do encourage non-Unix developers to read Effective Perl Programming, or at least to give it a careful look. How and why I wrote this book I''ve always wanted to be a writer. In childhood I was obsessed with science fiction. I read constantly, sometimes three paperbacks a day, and every so often, wrote some (bad) stories myself. In 1985, I attended the Clarion Science Fiction Writers'' workshop in East Lansing, Michigan. Afterward, I spent a year or so occasionally working on short story manuscripts, but never published any fiction. (Not yet, anyway!) Later on, when I had settled down into a career in software, I met Randal Schwartz. I hired him as a contractor on an engineering project and worked with him for over a year. Eventually he left to pursue teaching Perl full time. After a while, so did I. In May 1996, I had a conversation with Keith Wollman at a developer''s conference in San Jose. When we drifted onto the topic of Perl, he asked me what I would think of a book called Effective Perl. I liked the idea. Scott Meyers''s Effective C++was one of my favorite books on C++, and extending the series to cover Perl would obviously be useful. I couldn''t get Keith''s idea out of my head. With some help from Randal, I worked out a proposal for the book, and Addison-Wesley accepted it. The rest--well, that was the fun part. I spent many 12-hour days and nights with FrameMaker in front of the computer screen, asked lots of annoying questions on the Perl 5 Porters list, posted many bug reports to the same list, looked through dozens of books and manuals, wrote many, many little snippets of Perl code, and drank many, many cans of Diet Coke and Diet Pepsi. I even had an occasional epiphany as I discovered very basic things about Perl I had never realized I was missing. After a while, a manuscript emerged. This book is my attempt to share with the rest of you some of the fun and stimulation I experienced while learning the power of Perl. I certainly appreciate you taking the time to read it, and I hope you will find it useful and enjoyable. Joseph N. Hall Chandler, Arizona 0201419750P04062001

Amazon no longer offers textbook rentals. We do!

Effective Perl Programming Writing Better Programs with Perl

Effective Perl Programming Writing Better Programs with Perl

0201419750

Summary

Author Biography

Table of Contents

Supplemental Materials

Excerpts