search for books and compare prices
Tables of Contents for Effective Perl Programming
Chapter/Section Title
Page #
Page Count
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