linux crash course chapter 11 3

Chapter 11:
Perl Scripting
Off Larry’s Wall


In this chapter …
•
•
•
•
•
•
•

Background
Terminology
Syntax
Variables
Control Structures
File Manipulation
Regular Expressions


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

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


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

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)


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


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


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


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)


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


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


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”;

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


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


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’


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


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]

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


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)


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


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)


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


Expressions
• Numeric operators
– ==, !=, <, >, <=, >=
– <=> returns 0 if equal, 1 if >, -1 if <

• String Operators
– eq, ne, lt, gt, le, ge
– cmp same as <=>


Control Structures
•
•
•
•
•
•

if (expr) {…}
unless (expr) {…}
if (expr) {…} else {…}
if (expr) {…} elsif (expr) {…} … else {…}
while (expr) {…}
until (expr) {…}