Tải bản đầy đủ

linux crash course chapter 11 3

Chapter 11:
Perl Scripting
Off Larry’s Wall

In this chapter …

Control Structures
File Manipulation
Regular Expressions

• 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


C-derived syntax
Ambiguous variables & dynamic typing
Singular and plural variables
Informal, easy to use
Many paradigms – procedural, functional,
• 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

• Module – one stand alone piece of code
• Distribution – set of modules
• Package – a namespace for one or more
• 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
• 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

• 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

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

• 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
• 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’

• Singular, holds one value, either string or
• 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


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)


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
Optimized from random access
Keys don’t need quotes unless there are

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

• 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) {…}

Tài liệu bạn tìm kiếm đã sẵn sàng tải về

Tải bản đầy đủ ngay