book

Minimal Perl

by Tim Maher

October 2006

Beginner

504 pages

12h 58m

English

Manning Publications

Read now

Unlock full access

Dedication
The History of Minimal PerlThe Genesis of the BookA little help from my friendAn auspicious weather non-event
Audience and OrganizationPart 1: Perl for UNIX and Linux usersPart 2: Perl for UNIX and Linux Shell programmersReference materialsAuthor’s ApproachReference valueForewarned is forearmedEntertainment valueEssential TerminologyTypographical ConventionsItalicsMarkup for highlighting and cross-referencingSpecial charactersShell and Perl commentsDisplays of Commands or Code With OutputShell command-with-output displaysPerl code-with-output displaysEllipsis marksCoding ConventionsShell programsPerl programsDownloading the Source CodeDefault Invocation Options for Perl ExamplesDepiction of Optional MaterialErrataAuthor OnlineAbout the Authors
Chapter 1Chapter 2Chapter 3Chapter 4Chapter 5Chapter 6Chapter 7Chapter 8Chapter 9Chapter 10Chapter 11Chapter 12
1.1. A visit to Perlistan1.1.1. Sometimes you need a professional guide1.2. Perl can be simple1.3. About Minimal Perl1.3.1. What Minimal Perl isn’tIs Minimal Perl a dumbed-down version of Perl?Is Minimal Perl a less capable Perl?Will learning Minimal Perl restrict my future options?1.3.2. What Minimal Perl isHow does Minimal Perl relate to Unix and standard Perl?1.4. Laziness is a virtue1.5. A minimal dose of syntax1.5.1. Terminating statements with semicolons1.6. Writing one-line programs1.6.1. Balancing simplicity and readability1.6.2. Implementing simple filters1.7. Summary
2.1. Perl’s invocation options2.1.1. One-line programming: -e2.1.2. Enabling warnings: -w2.1.3. Processing input: -n2.1.4. Processing input with automatic printing: -p2.1.5. Processing line-endings: -l2.1.6. Printing without newlines: printfTip on using printf for prompting2.1.7. Changing the input record separator: -0digits2.2. Using variables2.2.1. Using special variables2.2.2. Using the data variable: $_2.2.3. Using the record-number variable: $.2.2.4. Employing user-defined variablesTips on employing user-defined variables2.3. Loading modules: -M2.4. Writing simple scripts2.4.1. Quoting techniquesTypical uses of quotesSingle quotesDouble quotesBackslashes2.4.2. True and False values2.4.3. Handling switches: -sA switch-driven line-numbering script: show_files2.4.4. Using warn and dieUsing $0 with warn and die2.4.5. Using logical and, logical orTips on using logical and, logical or2.4.6. Programming with BEGIN and END blocksTesting and setting variables in the BEGIN block2.4.7. Loading modules with use2.5. Additional special variables2.5.1. Employing I/O variables2.5.2. Exploiting formatting variablesTip on using formatting variablesCongratulations!2.6. Standard option clusters2.6.1. Using aliases for common types of Perl commandsAliases for Perl commands: Line modeAliases for Perl commands: Paragraph mode2.7. Constructing programs2.7.1. Constructing an output-only one-liner2.7.2. Constructing an input/output script2.8. SummaryDirections for further study

3.1. A brief history of grep3.2. Shortcomings of grep3.2.1. Uncertain support for metacharactersDealing with conflicting regex dialects3.2.2. Lack of string escapes for control characters3.2.3. Comparing capabilities of greppers and PerlComparing regex dialectsContrasting match-related capabilitiesAppreciating additional enhancements3.3. Working with the matching operator3.3.1. The one-line Perl grepperAutomatic skipping of directory filesNesting single quotes3.4. Understanding Perl’s regex notation3.5. Perl as a better fgrep3.6. Displaying the match only, using $&3.7. Displaying unmatched records (like grep -v)3.7.1. Validating data3.7.2. Minimizing typing with shortcut metacharacters3.8. Displaying filenames only (like grep -l)3.9. Using matching modifiers3.9.1. Ignoring case (like grep -i)3.10. Perl as a better egrep3.10.1. Working with cascading filtersSwitching from alternation metacharacters to pipesSwitching from egrep to Perl to gain efficiency3.11. Matching in context3.11.1. Paragraph modeSenator Quimby needs a Perl expert3.11.2. File mode3.12. Spanning lines with regexes3.12.1. Matching across lines3.12.2. Using lwp-request3.12.3. Filtering lwp-request output3.13. Additional examples3.13.1. Log-file analysisDisqualifying undesirable matches3.13.2. A scripted grepper3.13.3. Fuzzy matching3.13.4. Web scraping3.14. SummaryDirections for further study
4.1. A brief history of sed4.2. Shortcomings of sed4.3. Performing substitutions4.3.1. Performing line-specific substitutions: sed4.3.2. Performing line-specific substitutions: Perl4.3.3. Performing record-specific substitutions: Perl4.3.4. Using backreferences and numbered variables in substitutions4.4. Printing lines by number4.4.1. Printing lines by number: sed4.4.2. Printing lines by number: Perl4.4.3. Printing records by number: Perl4.5. Modifying templates4.6. Converting special characters4.7. Editing files4.7.1. Editing with commands4.7.2. Editing with scriptsThe insert_contact_info scriptAdding commentary to a regex4.7.3. Safeguarding in-place editingClobber-proofing backup files in commands: $SECONDSClobber-proofing backup files in scripts: $$4.8. Converting to lowercase or uppercase4.8.1. Quieting spam4.9. Substitutions with computed replacements4.9.1. Converting miles to kilometers4.9.2. Substitutions using function results4.10. The sed to Perl translator4.11. SummaryDirections for further study
5.1. A brief history of AWK5.2. Comparing basic features of awk and Perl5.2.1. Pattern-matching capabilitiesStingy matchingRecord-separator matching5.2.2. Special variables5.2.3. Perl’s variable interpolation5.2.4. Other advantages of Perl over AWK5.2.5. Summary of differences in basic featuresWays in which Perl is superior to AWKWays in which AWK is superior to Perl5.3. Processing fields5.3.1. Accessing fields5.3.2. Printing fieldsA rock-star biodata system (AWK)A rock-star biodata system (Perl)5.3.3. Differences in syntax for print5.3.4. Using custom field separators in PerlEnhancing the rock-star biodata system5.4. Programming with Patterns and Actions5.4.1. Combining pattern matching with field processing5.4.2. Extracting data from tablesComparing cities for “mean annual precipitation”5.4.3. Accessing cell data using array indexingComparing cities for “days of significant rain”Comparing cities for “sogginess”5.5. Matching ranges of records5.5.1. Operators for single- and multi-record ranges5.5.2. Matching a range of dates5.5.3. Matching multiple ranges5.6. Using relational and arithmetic operators5.6.1. Relational operators5.6.2. Arithmetic operators5.7. Using built-in functions5.7.1. One-liners that use functions5.7.2. The legend of nexprBorn in a barroom wager: nexprThe nexpr_p script (Perl)5.7.3. How the nexpr* programs work5.8. Additional examples5.8.1. Computing compound interest: compound_interest5.8.2. Conditionally pluralizing nouns: compound_interest25.8.3. Analyzing log files: scan4oopsConstructing a regex to match “Oops” reportsThe enhanced scan4oops2 script5.9. Using the AWK-to-Perl translator: a2p5.9.1. Tips on using a2p5.10. SummaryDirections for further study
6.1. Introducing hybrid find/perl programs6.2. File testing capabilities of find vs. Perl6.2.1. Augmenting find with Perl6.3. Finding files6.3.1. Finding files by name matchingFinding multi-word filenames6.3.2. Finding files by pathname matching6.4. Processing filename arguments6.4.1. Defending against grep’s messesA screen-safe grepper: text_grep6.4.2. Recursive grepping6.4.3. Perl as a generalized argument pre-processor6.5. Using find|xargs vs. Perl alternatives6.5.1. Using Perl for reliable timestamp sorting6.5.2. Dealing with multi-word filenames6.6. find as an argument pre-processor for Perl6.7. A Unix-like, OS-portable find command6.7.1. Making the most of find2perl6.7.2. Helping non-Unix friends with find2perl6.8. SummaryDirections for further study
7.1. Understanding and managing evaluation context7.1.1. Determinants and effects of evaluation context7.1.2. Making use of evaluation contextConverting data types7.2. Programming with functions that generate or process scalars7.2.1. Using splitTips on using split7.2.2. Using localtimeTips on using localtime7.2.3. Using statEmulating the Shell’s –nt operatorEmulating ls with the listfile scriptTips on using stat7.2.4. Using chompTips on using chomp7.2.5. Using rand7.3. Programming with functions that process lists7.3.1. Comparing Unix pipelines and Perl functions7.3.2. Using sortSorting randomlyTips on using sort7.3.3. Using grep7.3.4. Using joinMatching against list variablesDeveloping HTML documents with join: The fields2lists script7.3.5. Using mapConverting Celsius to Fahrenheit: The c2f scriptTips on using map7.4. Globbing for filenames7.4.1. Tips on globbingEmploying regex notation for filtering filenames7.5. Managing files with functions7.5.1. Handling multi-valued return codesTips on file-management functions7.6. Parenthesizing function arguments7.6.1. Controlling argument-gobbling functions7.7. SummaryDirections for further study
8.1. Exploiting script-oriented functions8.1.1. Defining definedUsing defined for keyboard inputTips on using defined8.1.2. Exiting with exit8.1.3. Shifting with shift8.2. Pre-processing arguments8.2.1. Accommodating non-filename arguments with implicit loops8.2.2. Filtering arguments8.2.3. Generating arguments8.3. Executing code conditionally with if/else8.3.1. Employing if/else vs. and/or8.3.2. Mixing branching techniques: The cd_report script8.3.3. Tips on using if/else8.4. Wrangling strings with concatenation and repetition operators8.4.1. Enhancing the most_recent_file script8.4.2. Using concatenation and repetition operators together8.4.3. Tips on using the concatenation operator8.5. Interpolating command output into source code8.5.1. Using the tput commandHighlighting trailing whitespaces with tput8.5.2. Grepping recursively: The rgrep script8.5.3. Tips on using command interpolation8.6. Executing OS commands using system8.6.1. Generating reports8.6.2. Tips on using system8.7. Evaluating code using eval8.7.1. Using a Perl shell: The psh script8.7.2. Appreciating a multi-faceted Perl grepper: The preg scriptTips on using preg8.8. SummaryDirections for further study
9.1. Using array variables9.1.1. Initializing arrays with piecemeal assignments and push9.1.2. Understanding advanced array indexing9.1.3. Extracting fields in a friendlier fashion9.1.4. Telling fortunes: The fcookie scriptfcookie2: The sequel9.1.5. Tips on using arrays9.2. Using hash variables9.2.1. Initializing hashesTips on initializing hashes9.2.2. Understanding advanced hash indexing9.2.3. Understanding the built-in %ENV hash9.2.4. Printing hashes9.2.5. Using %ENV in place of switches9.2.6. Obtaining uniqueness with hashesRendering arguments uniqueRendering inputs unique9.2.7. Employing a hash as a simple database: The user_lookup script9.2.8. Counting word frequencies in web pages: The count_words script9.3. Comparing list generators in the Shell and Perl9.3.1. Filename generation/globbing9.3.2. Command substitution/interpolation9.3.3. Variable substitution/interpolationConclusion9.4. SummaryDirections for further study
10.1. Looping facilities in the Shell and Perl10.2. Looping with while/until10.2.1. Totaling numeric argumentsTips on using while for list processing10.2.2. Reducing the size of an image10.2.3. Printing key/value pairs from a hash using each10.2.4. Understanding the implicit loop10.3. Looping with do while/until10.3.1. Prompting for input10.4. Looping with foreach10.4.1. Unlinking files: the rm_files script10.4.2. Reading a line at a time10.4.3. Printing a hash10.4.4. Demystifying acronyms: The expand_acronyms script10.4.5. Reducing image sizes: The compress_image2 script10.5. Looping with for10.5.1. Exploiting for’s support for indexing: the raffle script10.6. Using loop-control directives10.6.1. Nesting loops within loops10.6.2. Enabling loop-control directives in bottom-tested loops10.6.3. Prompting for input10.6.4. Enhancing loops with continue blocks: the confirmation script10.7. The CPAN’s select loop for Perl10.7.1. Avoiding the re-invention of the “choose-from-a-menu” wheel10.7.2. Monitoring user activity: the show_user script10.7.3. Browsing man pages: the perlman script10.8. SummaryDirections for further study
11.1. Compartmentalizing code with subroutines11.1.1. Defining and using subroutines11.1.2. Understanding use strictStrictifying a script11.2. Common problems with variables11.2.1. Clobbering variables: The phone_home script11.2.2. Masking variables: The 4letter_word script11.2.3. Tips on avoiding problems with variables11.3. Controlling variable scoping11.3.1. Declaring variables with my11.3.2. Declaring variables with our11.3.3. Declaring variables with local11.3.4. Introducing the Variable Scoping GuidelinesGuidelines for simple programs11.4. Variable Scoping Guidelines for complex programs11.4.1. Enable use strict11.4.2. Declare user-defined variables and define their scopesUse the my declaration on non-switch variablesDon’t let variables leak into subroutinesUse the our declaration on switch variables and variables exported by modules11.4.3. Pass data to subroutines using arguments11.4.4. Localize temporary changes to built-in variables with local11.4.5. Employ user-defined loop variables11.4.6. Applying the Guidelines: the phone_home2 scriptTips on using Variable Scoping Guidelines11.5. Reusing a subroutine11.6. SummaryDirections for further study
12.1. Creating modules12.1.1. Using the Simple Module TemplateStarting the new moduleSpecifying exported componentsDefining subroutinesConcluding the module with a “happy ending”12.1.2. Creating a module: Center.pmUsing carp in production, warn during developmentSetting imported variables rather than passing arguments12.1.3. Testing a new moduleTesting Center with the center3 scriptSpecifying the module’s location: The PERL5LIB variable12.2. Managing modules12.2.1. Identifying the modules that you wantSearching for a module that calculates UPS shipping charges12.2.2. Determining whether you have a certain module12.2.3. Installing modules from the CPANConfiguring CPANInstalling modules as the root userInstalling modules as a non-root user12.3. Using modules12.3.1. Business::UPS—the ups_shipping_price script12.3.2. LWP::Simple—the check_links script12.3.3. Shell::POSIX::Select—the menu_ls script12.3.4. File::Find—the check_symlinks script12.3.5. CGI—the survey.cgi scriptGeneral comments on survey.cgiUsing CGI functions in survey.cgiUnderstanding the operational modes of survey.cgiConstructing the HTML documentsOutput from survey.cgiThe CGI cheatsheets12.3.6. Tips on using Object-Oriented modules12.4. SummaryDirections for further study
Welcome to Perlistan!

Content preview from Minimal Perl

Chapter 8. Scripting techniques

8.1	Exploiting script-oriented functions	248
8.2	Pre-processing arguments	256
8.3	Executing code conditionally with `if/else`	259
8.4	Wrangling strings with concatenation and repetition operators	265
8.5	Interpolating command output into source code	269
8.6	Executing OS commands using `system`	275
8.7	Evaluating code using `eval`	283
8.8	Summary	292

Those nifty one-line commands you saw in part 1 are easy to type, and they’re adequate for an impressively wide variety of common tasks. And gosh darn it, you might even say they’re cute, if not downright elegant.

But sooner or later, you’ll need to write programs that can validate their arguments, handle arguments that aren’t filenames, capture and manipulate outputs from Unix commands, process inputs ...