Advanced Perl Programming

William "Bo" Rothwell's Advanced Perl Programming continues where his previous book left off, more or less, as it guides you through advanced techniques of the Perl programming language starting with command-line options, references, and arrays and hashes from advanced data types. Next, you'll learn about typeglobs for symbolic entries.

Additionally, you'll see advanced subroutine handling, then packages and namespaces. Furthermore, you'll build advanced modules and install CPAN modules. Unlike Java and C++, modules have been around in Perl for a long time now. Along the way, you'll learn and use POD mark up language for Perl documentation.

Moreover, you'll get a survey of the many advanced features and data structures of the current Perl programming language. You'll also get a survey of the new features of the latest Perl 5.x release. After reading and using this book, you'll have the tools, techniques, and source code to be an expert Perl programmer.

WHAT YOU WILL LEARN

* Carry out command-line parsing and extract scripts
* Create references; return values from a reference; work with the ref Function and strict refs
* Work with advanced Perl data types using arrays, hashes, and hash of hashes
* Use Typeglobs for symbol table entries
* Build modules and install CPAN modules


* Write documentation for Perl using POD
* Work with the newest features in Perl, including the smartmatch operator, yada yada, automated regex modifiers, the CORE namespace and more



WHO THIS BOOK IS FOR

Those with experience with Perl or who have read Rothwell's prior books, Beginning Perl Programming and Pro Perl Programming. At the impressionable age of 14, William "Bo" Rothwell crossed paths with a TRS-80 Micro Computer System (affectionately known as a “Trash 80”). Soon after the adults responsible for Bo made the mistake of leaving him alone with the TSR-80. He immediately dismantled it and held his first computer class, showing his friends what made this “computer thing” work. Since this experience, Bo’s passion for understanding how computers work and sharing this knowledge with others has resulting in a rewarding career in IT training. His experience includes Linux, Unix, DevOps tools, and programming languages such as Perl, Python, Tcl, and BASH.

Chapter One Command Line Options

1.1 Introducing Command Line Options

1.2 Changing Input Record Separator

1.3 Create a Loop Around Your Script

1.4 Editing in Place

1.5 Syntax Checking

1.6 Pre-appending to @INC

1.7 Including Modules

1.8 Command Line Parsing

1.9 Displaying Configuration Information

1.10 Extracting Scripts from Messages1.11 Additional Resources

1.12 Lab Exercises

Chapter Two References

2.1 What are References?

2.2 Creating References

2.3 Returning the Value from a Reference

2.4 The ref Function

2.5 Making Anonymous References

2.6 References to Functions

2.7 use strict ‘refs’

2.8 Additional Resources

2.9 Lab Exercises

Chapter Three Advanced Data Types: Arrays

3.1 Review: What You Should Already Know About Arrays

3.2 What You Might Know About Arrays

3.3 Arrays of Arrays

3.4 Creating Arrays of Arrays

3.5 Accessing Values in an Array of Arrays

3.6 Adding a Sub Array (Row)

3.7 Adding a column

3.8 Printing an Array of Arrays

3.9 Additional Resources

3.10 Lab Exercises

Chapter Four Advanced Data Types: Hashes

4.1 Review: What You Should Already Know About Hashes

4.2 What You Might Know About Hashes

4.3 Hashes of Hashes

4.4 Creating Hashes of Hashes

4.5 Accessing Values in a Hash of Hashes

4.6 Other Data Structures

4.7 Additional Resources

4.8 Lab Exercises

Chapter Five Typeglobs

5.1 Symbolic Tables

5.2 Typeglobs

5.3 Using typeglobs

5.4 References vs. Typeglobs

5.5 Avoiding Aliases to Entire Identifier

5.6 Making constants

5.7 Passing Filehandles into Functions5.8 Redefining a Function

5.9 Temporarily Redefining a Function

5.10 Additional Resources

5.11 Lab Exercises

Chapter Six Advanced Subroutine Handling

6.1 Review: What You Should Already Know About Functions

6.2 What You Might Know About Functions

6.3 Making Persistent Function Variables

6.4 Using the caller Function

6.5 Passing Arguments by Reference

6.6 Determining Functions Return Data

6.7 Returning Multiple Values

6.8 Exception Handling

6.9 Constant Functions

6.10 Prototypes

6.11 Additional Resources

6.12 Lab Exercises

Chapter Seven Packages and Namespaces

7.1 Scope

7.2 Creating Namespaces with the package Command

7.3 Fully Qualified Package Names

7.4 Nested Packages

7.5 use strict 'vars'

7.6 Identifiers Not Affected by Packages

7.7 Determine the Current Package

7.8 Packages vs. my Variables7.9 Additional Resources

7.10 Lab Exercises

Chapter Eight Building Modules

8.1 Introduction to Perl Modules

8.2 Creating a Module8.3 BEGIN and END Blocks

8.4 Symbol Tables in Modules

8.5 Exporting Identifiers from Modules

8.6 Private Identifiers

8.7 Oking Symbols to Export from Modules

8.8 Module Version Numbers

8.9 use vs. require

8.10 A Note About Library Files

8.11 Additional Resources

8.12 Lab Exercises

Chapter Nine Installing CPAN Modules

9.1 What is CPAN?

9.2 Accessing CPAN

9.3 CPAN Organization

9.4 Installing a CPAN Module Manually

9.5 Installing CPAN Modules Using the CPAN Module9.6 Using the Perl Package Manager to Install CPAN Modules

9.7 Listing What Modules are Currently Installed

9.8 Additional Resources

9.9 Lab Exercises

Chapter Ten POD

10.1 Overview of POD

10.2 POD Commands

10.3 POD Text

10.4 POD Verbatim

10.5 POD Examples

10.6 Common POD Problems

10.7 POD Utilities

10.8 Additional Resources

10.9 Lab Exercises

Chapter Eleven Advanced Features

11.1 Perl development environments11.2 The power of the do statement

11.3 autodie

11.4 String variables as files

11.5 File::Spec

11.6 Proper use of soft references

11.7 Install modules from CPAN without admin privileges

11.8 Basic testing

11.9 Advanced testing

11.10 Using prove

11.11 Benchmarking

Chapter Twelve Advanced Data Structures

12.1 Introduction to Benchmarking

12.2 Use the Readonly module to create constants

12.3 Make large numbers more readable

12.4 Make use of Scalar::Util

12.5 Make use of List::Util

12.6 Make use of List::MoreUtils

12.7 List formatting

12.8 Understand slices

12.9 Make use of Hash::Util

12.10 Make use of Hash::MoreUtils

12.11 Smart use of subscripts

12.12 Understand the advantages and disadvantages of for, foreach, grep and map

12.13 Know different sort techniques

12.14 Avoid using memory to store large data

Chapter Thirteen New Features

12.1 Perl versions

12.2 The latest/greatest?

12.3 Changes by version

12.4 The feature pragma

12.5 Make use of the Smartmatch Operator

12.6 The // operator

12.7 The UNITCHECK block

12.8 Yada yada

12.9 The autodie pragma

12.10 Using each, keys, values with arrays 12.11 New Regular Expression modifiers

12.12 Non-destructive substation

12.13 Automating Regular Expression modifiers

12.14 New feature for given

12.15 Change in use feature

12.16 The CORE namespace

12.17 Overriding Perl keywords