| Foreword |
|
ix | (2) |
| Preface |
|
xi | (2) |
| Acknowledgements |
|
xiii | |
| Introduction |
|
1 | (8) |
|
|
|
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) |
|
|
|
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) |
|
|
|
41 | (2) |
|
Item 14: Learn the myriad ways of sorting. |
|
|
43 | (8) |
|
|
|
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) |
|
|
|
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) |
|
|
|
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) |
|
|
|
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) |
|
|
|
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 | |