Register your product to gain access to bonus material or receive a coupon.
Effective Perl Programming: Ways to Write Better, More Idiomatic Perl,, 2nd Edition
- By Joseph N. Hall, Joshua A. McAdams, Brian D. Foy
- Published Apr 19, 2010 by Addison-Wesley Professional.
eBook
- Your Price: $38.39
- List Price: $47.99
- Includes EPUB and PDF
- About eBook Formats
This eBook includes the following formats, accessible from your Account page after purchase:
EPUB
The open industry format known for its reflowable content and usability on supported mobile devices.
PDF
The popular standard, used most often with the free Acrobat® Reader® software.
This eBook requires no passwords or activation to read. We customize your eBook by discreetly watermarking it with your name, making it uniquely yours.
Description
- Copyright 2010
- Pages: 504
- Edition: 2nd
- eBook
- ISBN-10: 0-321-77067-6
- ISBN-13: 978-0-321-77067-7
The Classic Guide to Solving Real-World Problems with Perl–Now Fully Updated for Today’s Best Idioms!
For years, experienced programmers have relied on Effective Perl Programming to discover better ways to solve problems with Perl. Now, in this long-awaited second edition, three renowned Perl programmers bring together today’s best idioms, techniques, and examples: everything you need to write more powerful, fluent, expressive, and succinct code with Perl.
Nearly twice the size of the first edition, Effective Perl Programming, Second Edition, offers everything from rules of thumb to avoid common pitfalls to the latest wisdom for using Perl modules. You won’t just learn the right ways to use Perl: You’ll learn why these approaches work so well.
New coverage in this edition includes
- Reorganized and expanded material spanning twelve years of Perl evolution
- Eight new chapters on CPAN, databases, distributions, files and filehandles, production Perl, testing, Unicode, and warnings
- Updates for Perl 5.12, the latest version of Perl
- Systematically updated examples reflecting today’s best idioms
You’ll learn how to work with strings, numbers, lists, arrays, strictures, namespaces, regular expressions, subroutines, references, distributions, inline code, warnings, Perl::Tidy, data munging, Perl one-liners, and a whole lot more. Every technique is organized in the same Items format that helped make the first edition so convenient and popular.
Sample Content
Table of Contents
Foreword xi
Preface xiii
Acknowledgments xvii
About the Authors xix
Introduction 1
Chapter 1: The Basics of Perl 9
Item 1. Find the documentation for Perl and its modules. 9
Item 2. Enable new Perl features when you need them. 12
Item 3. Enable strictures to promote better coding. 14
Item 4. Understand what sigils are telling you. 17
Item 5. Know your variable namespaces. 19
Item 6. Know the difference between string and numeric comparisons. 21
Item 7. Know which values are false and test them accordingly. 23
Item 8. Understand conversions between strings and numbers. 27
Item 9. Know the difference between lists and arrays. 31
Item 10. Don’t assign undef when you want an empty array. 34
Item 11. Avoid a slice when you want an element. 37
Item 12. Understand context and how it affects operations. 41
Item 13. Use arrays or hashes to group data. 45
Item 14. Handle big numbers with bignum. 47
Chapter 2: Idiomatic Perl 51
Item 15. Use $_ for elegance and brevity. 53
Item 16. Know Perl’s other default arguments. 56
Item 17. Know common shorthand and syntax quirks. 60
Item 18. Avoid excessive punctuation. 66
Item 19. Format lists for easy maintenance. 68
Item 20. Use foreach, map, and grep as appropriate. 70
Item 21. Know the different ways to quote strings. 73
Item 22. Learn the myriad ways of sorting. 77
Item 23. Make work easier with smart matching. 84
Item 24. Use given-when to make a switch statement. 86
Item 25. Use do {} to create inline subroutines. 90
Item 26. Use List::Util and List::MoreUtils for easy list manipulation. 92
Item 27. Use autodie to simplify error handling. 96
Chapter 3: Regular Expressions 99
Item 28. Know the precedence of regular expression operators. 99
Item 29. Use regular expression captures. 103
Item 30. Use more precise whitespace character classes. 110
Item 31. Use named captures to label matches. 114
Item 32. Use noncapturing parentheses when you need only grouping. 116
Item 33. Watch out for the match variables. 117
Item 34. Avoid greed when parsimony is best. 119
Item 35. Use zero-width assertions to match positions in a string. 121
Item 36. Avoid using regular expressions for simple string operations. 125
Item 37. Make regular expressions readable. 129
Item 38. Avoid unnecessary backtracking. 132
Item 39. Compile regexes only once. 137
Item 40. Pre-compile regular expressions. 138
Item 41. Benchmark your regular expressions. 139
Item 42. Don’t reinvent the regex. 142
Chapter 4: Subroutines 145
Item 43. Understand the difference between my and local. 145
Item 44. Avoid using @_ directly unless you have to. 154
Item 45. Use wantarray to write subroutines returning lists. 157
Item 46. Pass references instead of copies. 160
Item 47. Use hashes to pass named parameters. 164
Item 48. Use prototypes to get special argument parsing. 168
Item 49. Create closures to lock in data. 171
Item 50. Create new subroutines with subroutines. 176
Chapter 5: Files and Filehandles 179
Item 51. Don’t ignore the file test operators. 179
Item 52. Always use the three-argument open. 182
Item 53. Consider different ways of reading from a stream. 183
Item 54. Open filehandles to and from strings. 186
Item 55. Make flexible output. 189
Item 56. Use File::Spec or Path::Class to work with paths. 192
Item 57. Leave most of the data on disk to save memory. 195
Chapter 6: References 201
Item 58. Understand references and reference syntax. 201
Item 59. Compare reference types to prototypes. 209
Item 60. Create arrays of arrays with references. 211
Item 61. Don’t confuse anonymous arrays with list literals. 214
Item 62. Build C-style structs with anonymous hashes. 216
Item 63. Be careful with circular data structures. 218
Item 64. Use map and grep to manipulate complex data structures. 221
Chapter 7: CPAN 227
Item 65. Install CPAN modules without admin privileges. 228
Item 66. Carry a CPAN with you. 231
Item 67. Mitigate the risk of public code. 235
Item 68. Research modules before you install them. 239
Item 69. Ensure that Perl can find your modules. 242
Item 70. Contribute to CPAN. 246
Item 71. Know the commonly used modules. 250
Chapter 8: Unicode 253
Item 72. Use Unicode in your source code. 254
Item 73. Tell Perl which encoding to use. 257
Item 74. Specify Unicode characters by code point or name. 258
Item 75. Convert octet strings to character strings. 261
Item 76. Match Unicode characters and properties. 265
Item 77. Work with graphemes instead of characters. 269
Item 78. Be careful with Unicode in your databases. 272
Chapter 9: Distributions 275
Item 79. Use Module::Build as your distribution builder. 275
Item 80. Don’t start distributions by hand. 278
Item 81. Choose a good module name. 283
Item 82. Embed your documentation with Pod. 287
Item 83. Limit your distributions to the right platforms. 292
Item 84. Check your Pod. 295
Item 85. Inline code for other languages. 298
Item 86. Use XS for low-level interfaces and speed. 301
Chapter 10: Testing 307
Item 87. Use prove for flexible test runs. 308
Item 88. Run tests only when they make sense. 311
Item 89. Use dependency injection to avoid special test logic. 314
Item 90. Don’t require more than you need to use in your methods. 317
Item 91. Write programs as modulinos for easy testing. 320
Item 92. Mock objects and interfaces to focus tests. 324
Item 93. Use SQLite to create test databases. 330
Item 94. Use Test::Class for more structured testing. 332
Item 95. Start testing at the beginning of your project. 335
Item 96. Measure your test coverage. 342
Item 97. Use CPAN Testers as your QA team. 346
Item 98. Set up a continuous build system. 348
Chapter 11: Warnings 357
Item 99. Enable warnings to let Perl spot suspicious code. 358
Item 100. Use lexical warnings to selectively turn on or off complaints. 361
Item 101. Use die to generate exceptions. 364
Item 102. Use Carp to get stack traces. 366
Item 103. Handle exceptions properly. 370
Item 104. Track dangerous data with taint checking. 372
Item 105. Start with taint warnings for legacy code. 375
Chapter 12: Databases 377
Item 106. Prepare your SQL statements to reuse work and save time. 377
Item 107. Use SQL placeholders for automatic value quoting. 382
Item 108. Bind return columns for faster access to data. 384
Item 109. Reuse database connections. 386
Chapter 13: Miscellany 391
Item 110. Compile and install your own perls. 391
Item 111. Use Perl::Tidy to beautify code. 394
Item 112. Use Perl Critic. 398
Item 113. Use Log::Log4perl to record your program’s state. 403
Item 114. Know when arrays are modified in a loop. 410
Item 115. Don’t use regular expressions for comma-separated values. 412
Item 116. Use unpack to process columnar data. 414
Item 117. Use pack and unpack for data munging. 416
Item 118. Access the symbol table with typeglobs. 423
Item 119. Initialize with BEGIN; finish with END. 425
Item 120. Use Perl one-liners to create mini programs. 428
Appendix A: Perl Resources 435
Appendix B: Map from First to Second Edition 439
Books 435
Websites 436
Blogs and Podcasts 437
Getting Help 437
Index 445
More Information
Other Things You Might Like
- Online Video $239.99