1. Chapter 11: Perl Scripting Off Larry’s Wall

2. In this chapter … Background Terminology Syntax Variables Control Structures File Manipulation Regular Expressions

3. Perl Practical Extraction and Report Language Developed by Larry Wall in 1987 Originally created for data processing and report generation Elements of C, AWK, sed, scripting Add-on modules and third party code make it a more general programming language

4. Features C-derived syntax Ambiguous variables & dynamic typing Singular and plural variables Informal, easy to use Many paradigms – procedural, functional, object-oriented Extensive third party modules

5. Features, con’t As elegant as you make it Do What I Mean intelligence Fast, easy, down and dirty coding Interpreted, not compiled perldoc – man pages for Perl modules

6. Terminology Module – one stand alone piece of code Distribution – set of modules Package – a namespace for one or more distributions Package variable – declared in package, accessible between modules Lexical variable – local variable (scope)

7. Terminology, con’t Scalar – variable that contains only one value (number, string, etc) Composite – variable made of one or more scalars List – series of one or more scalars – e.g. (2, 4, ‘Zach’) Array – composite variable containing a list

8. Invoking Perl perl –e ‘text of perl program’ perl perl_script Make perl script executable and you can execute the script itself –i.e../my_script.pl Common file extension.pl not required Like other scripts start with #! to specify execution program

9. Invoking Perl, con’t Use perl –w to display warnings –Will warn if using undeclared variables –Instead of –w, use warnings; in your script Same effect Usually you’ll find perl in /usr/bin/perl

10. Syntax Each perl statement ended by semicolon (;) Can have multiple statements per line Whitespace ignored largely –Except within quoted strings Double quotes allow interpretation of variables and special characters (like \n) Single quotes don’t (just like the shell)

11. Syntax, con’t Forward slash used to delimit regular expressions (e.g. /.*sh?/) Backslash used for escape characters –E.g. \n – newline, \t – tab Lines beginning with # are ignored as comments

12. Output Old way –print what_to_print; –Concatenate print item_1, item_2 –Want a newline? print what_to_print, “\n” New way –say what_to_print Automatically adds newline

13. Output, con’t what_to_print can be many things –Quoted string – “Here’s some text” –Variables - $myvar –Result of a function – toupper($myvar) –A combination print “Sub Tot: $total \n”, “Tax: $total*$tax \n” Want to display an error and exit? –die “Uh-oh!\n”;

14. Variables Perl variables can be singular or plural Data typing done dynamically at runtime Three types –Scalar (singular) –Array (plural) –Hash a.k.a. Associative Arrays (plural) Variable names are case sensitive Can contain letters, numbers, underscore

15. Variables, con’t Each type of variable starts with a different special character to mark type By default all variables are package in scope To make lexical, preface declaration with my keyword Lexical variables override package variables Include use strict; to not allow use of undeclared variables

16. Variables, con’t We’ve already covered use warnings; Undeclared variables, if referenced, have a default value of undef –Equates to 0 or null string –Can check by using defined() function $. is equal to the line number you’re on $_ is the default operand – ‘it’

17. Scalars Singular, holds one value, either string or number Must be preceded with $ i.e. $myvar Perl will automatically cast between strings and numbers Will treat as a number or string, whichever is appropriate in context

18. Arrays Plural, containing an ordered list of scalars Zero-based indexing Dynamic size and allocation Begin with @ e.g. @myarray @variable references entire array To reference a single element (which would be a scalar, right?) $variable[index]

19. Arrays, con’t $#array returns the index of the last element –Zero based – this means it’s one less than the size of the array @array[x..y] returns a ‘slice’ or sublist Printing arrays –Array enclosed in double quotes prints space delimited list –Not in quotes all entries concatenated

20. Arrays, con’t Arrays can be treated like FIFO queues –shift(@array) – pop first element off –push(@array, scalar) – push element on at end Use splice to combine arrays –splice(@array,offset,length,@otherarray)

21. Hashes Plural, contain an array of key-value pairs Prefix with % i.e. %myhash Keys are strings, act as indexes to array Each key must be unique, returns one value Unordered Optimized from random access Keys don’t need quotes unless there are spaces

22. Hashes, con’t Element access –$hashvar{index} = value e.g. $myvar{boat} =“tuna”; print $myvar{boat}; –%hashvar = ( key => value, …); e.g. %myvar = ( boat => “tuna”, 4 => “fish”); –Get array of keys or values keys(%hashvar) values(%hashvar)

23. Evaluating Expressions Most control structures use an expression to evaluate whether they are run Perl uses different comparison operators for strings and numbers Also uses the same file operators (existence, access, etc) that bash uses

24. Expressions Numeric operators –==, !=,, = – returns 0 if equal, 1 if >, -1 if < String Operators –eq, ne, lt, gt, le, ge –cmp same as

25. Control Structures if (expr) {…} unless (expr) {…} if (expr) {…} else {…} if (expr) {…} elsif (expr) {…} … else {…} while (expr) {…} until (expr) {…}

26. Control Structures, con’t for and foreach are interchangeble Syntax 1 –Similar to bash for…in structure –foreach [var] (list) {…} –If var not defined, $_ assumed –For each loop iteration, the next value from list is populated in var

27. Control Structures, con’t for/foreach Syntax 2 –Similar to C’s for loop –foreach (expr1; expr2; expr3) {…} –expr1 sets initial condition –expr2 is the terminal condition –expr3 is the incrementor

28. Control Structures, con’t Short-circuiting loops –Use last to break out of loop altogether Same as bash’s break –Use next to skip to the next iteration of the loop Same as bash’s continue

29. Handles A handle is essentially a variable linked to a file or process Perl automatically opens handles for the default streams –STDIN, STDOUT, STDERR You can open additional handles –To a file for input/output/appending –To a process for input/output

30. Handles, con’t Basic syntax –open(handle, [‘mode’], “ref”); –handle is a variable to reference the handle –mode can be many things Simple cases:, >>, | Input (<) implied if omitted –ref is what to open – file or process –mode and ref can be combined as one string

31. Handles, con’t Once open access via handle variable Output –print handle “what to print” Input –$var = gets one line of input –Use as a loop condition to read input one line at a time, populating $_

32. Handles, con’t <> - magic handle, pulls from STDIN or command line arguments to perl Line of input contains EOL character –Use chomp($var) to remove it –Use chop($var) to remove the last character When done close(handle); –Housekeeping, good coding practice –Perl actually closes all open handles for you

33. Handles, con’t Examples –open(my $INPUT, “/path/to/file”); –open(my $ERRLOG, “>>/var/log/errors”); –open(my $SORT, “| sort –n”); –open(my $ALIST, "grep \'^[Aa]\' /usr/share/dict/words|") –while( ) { print $ERRLOG $_; }

34. Regular Expressions Recall Appendix A Perl has a few unique features and caveats Regular Expressions (RE) delimited by forward slash Perl uses the =~ operator for RE matching –Ex. if ($myvar =~ /^T/) { …} # if myvar starts w/ T To negate RE matching use !~ operator

35. RE, con’t =~ operator can also be used to do replacement –Ex. $result =~s/old/new/; –‘old’ replaced with ‘new’ if matched Remember, RE (esp. in Perl) are greedy –Will match longest possible match Bracketed expressions don’t need to be escaped, just use parentheses