Table of content


   
  Table of Contents
  Index
Effective Perl Programming: Writing Better Programs with Perl
By Joseph  N.  Hall, Randal  L.  Schwartz
   
Publisher : Addison Wesley
Pub Date : December 30, 1997
ISBN : 0-201-41975-0
Pages : 288
Copyright
      Foreword
      Preface
        Who should read this book
        How and why I wrote this book
     
      Acknowledgements
      Introduction
        The world of Perl
        Terminology
        Notation
        Perl style
        Organization
        How to contact us
     
      Chapter 1.   Basics
        Item 1: Know your namespaces.
        Item 2: Avoid using a slice when you want an element.
        Item 3: Don't assign undef when you want an empty list.
        Item 4: String and numeric comparisons are different.
        Item 5: Remember that and "" are false.
        Item 6: Understand conversions between strings and numbers .
     
      Chapter 2.   Idiomatic Perl
        Item 7: Use $_ for elegance .
        Item 8: Know the other default arguments: @_ , @ARGV , STDIN .
        Item 9: Know common shorthands and syntax quirks .
        Item 10: Avoid excessive punctuation.
        Item 11: Consider different ways of reading from a stream.
        Item 12: Use foreach , map and grep as appropriate.
        Item 13: Don't misquote.
        Item 14: Learn the myriad ways of sorting.
     
      Chapter 3.   Regular Expressions
        Item 15: Know the precedence of regular expression operators.
        Item 16: Use regular expression memory.
        Item 17: Avoid greed when parsimony is best.
        Item 18: Remember that whitespace is not a word boundary.
        Item 19: Use split for clarity, unpack for efficiency.
        Item 20: Avoid using regular expressions for simple string operations.
        Item 21: Make regular expressions readable.
        Item 22: Make regular expressions efficient.
     
      Chapter 4.   Subroutines
        Item 23: Understand the difference between my and local .
        Item 24: Avoid using @_ directlyunless you have to.
        Item 25: Use wantarray to write subroutines returning lists.
        Item 26: Pass references instead of copies.
        Item 27: Use hashes to pass named parameters.
        Item 28: Use prototypes to get special argument parsing.
        Item 29: Use subroutines to create other subroutines.
     
      Chapter 5.   References
        Item 30: Understand references and reference syntax.
        Item 31: Create lists of lists with references.
        Item 32: Don't confuse anonymous arrays with list literals.
        Item 33: Build C-style structs with anonymous hashes.
        Item 34: Be careful with circular data structures.
        Item 35: Use map and grep to manipulate complex data structures.
     
      Chapter 6.   Debugging
        Item 36: Enable static and/or run-time checks.
        Item 37: Use debugging and profiling modules.
        Item 38: Learn to use a debugging version of Perl.
        Item 39: Test things by using the debugger as a Perl "shell."
        Item 40: Don't debug too much at once.
     
      Chapter 7.   Using Packages and Modules
        Item 41: Don't reinvent the wheeluse Perl modules.
        Item 42: Understand packages and modules.
        Item 43: Make sure Perl can find the modules you are using.
        Item 44: Use perldoc to extract documentation for installed modules.
     
      Chapter 8.   Writing Packages and Modules
        Item 45: Use h2xs to generate module boilerplate .
        Item 46: Embed your documentation with POD.
        Item 47: Use XS for low-level interfaces and/or speed.
        Item 48: Submit your useful modules to the CPAN.
     
      Chapter 9.   Object-Oriented Programming
        Item 49: Consider using Perl's object-oriented programming features.
        Item 50: Understand method inheritance in Perl.
        Item 51: Inherit data explicitly.
        Item 52: Create invisible interfaces with tied variables .
     
      Chapter 10.   Miscellany
        Item 53: Use pack and unpack for data munging .
        Item 54: Know how and when to use eval , require , and do .
        Item 55: Know when, and when not, to write networking code.
        Item 56: Don't forget the file test operators.
        Item 57: Access the symbol table with typeglobs.
        Item 58: Use @{[ ]} or a tied hash to evaluate expressions inside strings.
        Item 59: Initialize with BEGIN ; finish with END .
        Item 60: Some interesting Perl one-liners.
     
      Appendix A.   sprintf
        Conversion Specifiers for sprintf
     
      Appendix B.   Perl Resources
      Index


Effective Perl Programming. Writing Better Programs with Perl
Effective Perl Programming: Writing Better Programs with Perl
ISBN: 0201419750
EAN: 2147483647
Year: 1996
Pages: 116

Similar book on Amazon

flylib.com © 2008-2017.
If you may any questions please contact us: flylib@qtcs.net