Upon startup,
perl
looks for your script in one of the following places:
After locating your script, perl compiles it to an internal form. If the script is syntactically correct, it is executed.
A single-character option may be combined with the following option, if any. This is particularly useful when invoking a script using the #! construct which only allows one argument. Example:
#!/bin/perl -spi.bak # same as -s -p -i.bak
...
Options include:
#!/bin/perl -pi.bak
s/foo/bar/;
which is equivalent to
#!/bin/perl
while (<>) {
if ($ARGV ne $oldargv) {
rename($ARGV,$ARGV . '.bak');
open(ARGVOUT,">$ARGV");
select(ARGVOUT);
$oldargv = $ARGV;
}
s/foo/bar/;
}
continue {
print; # this prints to original filename
}
select(stdout);
except that the -i form doesn't need to compare $ARGV to $oldargv to know when
the filename has changed.
It does, however, use ARGVOUT for the selected filehandle.
Note that stdout is restored as the default output filehandle after the loop.
while (<>) {
... # your script goes here
}
Note that the lines are not printed by default.
See
-p
to have lines printed.
while (<>) {
... # your script goes here
} continue {
print;
}
Note that the lines are printed automatically.
To suppress printing use the
-n
switch.
A
-p
overrides a
-n
switch.
#!/bin/perl -s
if ($xyz) { print "true\n"; }
Perl has about two and a half data types: strings, arrays of strings, and associative arrays. Strings and arrays of strings are first class objects, for the most part, in the sense that they can be used as a whole as values in an expression. Associative arrays can only be accessed on an association by association basis; they don't have a value as a whole (at least not yet).
Strings are interpreted numerically as appropriate. A string is interpreted as TRUE in the boolean sense if it is not the null string or 0. Booleans returned by operators are 1 for true and '0' or '' (the null string) for false.
References to string variables always begin with `$', even when referring to a string that is part of an array. Thus:
$days # a simple string variable
$days[28] # 29th element of array @days
$days{'Feb'}# one value from an associative array
but entire arrays are denoted by `@':
@days # ($days[0], $days[1],... $days[n])
Any of these four constructs may be assigned to (in compiler lingo, may serve as an lvalue). (Additionally, you may find the length of array @days by evaluating ``$#days'', as in csh. [Actually, it's not the length of the array, it's the subscript of the last element, since there is (ordinarily) a 0th element.])
Every data type has its own namespace. You can, without fear of conflict, use the same name for a string variable, an array, an associative array, a filehandle, a subroutine name, and/or a label. Since variable and array references always start with `$' or `@', the ``reserved'' words aren't in fact reserved with respect to variable names. (They ARE reserved with respect to labels and filehandles, however, which don't have an initial special character.) Case IS significant---``FOO'', ``Foo'' and ``foo'' are all different names. Names which start with a letter may also contain digits and underscores. Names which do not start with a letter are limited to one character, e.g. ``$%'' or ``$$''. (Many one character names have a predefined significance to perl. More later.)
String literals are delimited by either single or double quotes. They work much like shell quotes: double-quoted string literals are subject to backslash and variable substitution; single-quoted strings are not. The usual backslash rules apply for making characters such as newline, tab, etc.You can also embed newlines directly in your strings, i.e. they can end on a different line than they begin. This is nice, but if you forget your trailing quote, the error will not be reported until perl finds another line containing the quote character, which may be much further on in the script. Variable substitution inside strings is limited (currently) to simple string variables. The following code segment prints out ``The price is $100.''
$Price = '$100';# not interpreted
print "The price is $Price.\n";# interpreted
Note that you can put curly brackets around the identifier to delimit it
from following alphanumerics.
Array literals are denoted by separating individual values by commas, and enclosing the list in parentheses. In a context not requiring an array value, the value of the array literal is the value of the final element, as in the C comma operator. For example,
@foo = ('cc', '-E', $bar);
assigns the entire array value to array foo, but
$foo = ('cc', '-E', $bar);
assigns the value of variable bar to variable foo.
Array lists may be assigned to if and only if each element of the list
is an lvalue:
($a, $b, $c) = (1, 2, 3);
($map{'red'}, $map{'blue'}, $map{'green'}) = (0x00f, 0x0f0, 0xf00);
Numeric literals are specified in any of the usual floating point or integer formats.
There are several other pseudo-literals that you should know about. If a string is enclosed by backticks (grave accents), it is interpreted as a command, and the output of that command is the value of the pseudo-literal, just like in any of the standard shells. The command is executed each time the pseudo-literal is evaluated. Unlike in csh, no interpretation is done on the data---newlines remain newlines. The status value of the command is returned in $?.
Evaluating a filehandle in angle brackets yields the next line from that file (newline included, so it's never false until EOF). Ordinarily you must assign that value to a variable, but there is one situation where in which an automatic assignment happens. If (and only if) the input symbol is the only thing inside the conditional of a while loop, the value is automatically assigned to the variable ``$_''. (This may seem like an odd thing to you, but you'll use the construct in almost every perl script you write.) Anyway, the following lines are equivalent to each other:
while ($_ = <stdin>) {
while (<stdin>) {
for (;<stdin>;) {
The filehandles
stdin,
stdout
and
stderr
are predefined.
Additional filehandles may be created with the
open
function.
The null filehandle <> is special and can be used to emulate the behavior of sed and awk. Input from <> comes either from standard input, or from each file listed on the command line. Here's how it works: the first time <> is evaluated, the ARGV array is checked, and if it is null, $ARGV[0] is set to '-', which when opened gives you standard input. The ARGV array is then processed as a list of filenames. The loop
while (<>) {
... # code for each line
}
is equivalent to
unshift(@ARGV, '-') if $#ARGV < $[;
while ($ARGV = shift) {
open(ARGV, $ARGV);
while (<ARGV>) {
... # code for each line
}
}
except that it isn't as cumbersome to say.
It really does shift array ARGV and put the current filename into
variable ARGV.
It also uses filehandle ARGV internally.
You can modify @ARGV before the first <> as long as you leave the first
filename at the beginning of the array.
Line numbers ($.) continue as if the input was one big happy file.
If you want to set @ARGV to your own list of files, go right ahead. If you want to pass switches into your script, you can put a loop on the front like this:
while ($_ = $ARGV[0], /^-/) {
shift;
last if /^--$/;
/^-D(.*)/ && ($debug = $1);
/^-v/ && $verbose++;
... # other switches
}
while (<>) {
... # code for each line
}
The <> symbol will return FALSE only once.
If you call it again after this it will assume you are processing another
@ARGV list, and if you haven't set @ARGV, will input from stdin.
A perl script consists of a sequence of declarations and commands. The only things that need to be declared in perl are report formats and subroutines. See the sections below for more information on those declarations. All objects are assumed to start with a null or 0 value. The sequence of commands is executed just once, unlike in sed and awk scripts, where the sequence of commands is executed for each input line. While this means that you must explicitly loop over the lines of your input file(or files), it also means you have much more control over which files and which lines you look at. (Actually, I'm lying---it is possible to do an implicit loop with either the -n or -p switch.)
A declaration can be put anywhere a command can, but has no effect on the execution of the primary sequence of commands. Typically all the declarations are put at the beginning or the end of the script.
Perl is, for the most part, a free-form language. (The only exception to this is format declarations, for fairly obvious reasons.)Comments are indicated by the # character, and extend to the end of the line. If you attempt to use /* */ C comments, it will be interpreted either as division or pattern matching, depending on the context. So don't do that.
The following compound commands may be used to control flow:
if (EXPR) BLOCK
if (EXPR) BLOCK else BLOCK
if (EXPR) BLOCK elsif (EXPR) BLOCK ... else BLOCK
LABEL while (EXPR) BLOCK
LABEL while (EXPR) BLOCK continue BLOCK
LABEL for (EXPR; EXPR; EXPR) BLOCK
LABEL BLOCK continue BLOCK
Note that, unlike C and Pascal, these are defined in terms of BLOCKs, not
statements.
This means that the curly brackets are required---no dangling statements allowed.
If you want to write conditionals without curly brackets there are several
other ways to do it.
The following all do the same thing:
if (!open(foo)) { die "Can't open $foo"; }
die "Can't open $foo" unless open(foo);
open(foo) || die "Can't open $foo"; # foo or bust!
open(foo) ? die "Can't open $foo" : 'hi mom';
# a bit exotic, that last one
The if statement is straightforward. Since BLOCKs are always bounded by curly brackets, there is never any ambiguity about which if an else goes with. If you use unless in place of if, the sense of the test is reversed.
The while statement executes the block as long as the expression is true (does not evaluate to the null string or 0). The LABEL is optional, and if present, consists of an identifier followed by a colon. The LABEL identifies the loop for the loop control statements next, last and redo (see below). If there is a continue BLOCK, it is always executed just before the conditional is about to be evaluated again, similarly to the third part of a for loop in C. Thus it can be used to increment a loop variable, even when the loop has been continued via the next statement (similar to the C ``continue'' statement).
If the word while is replaced by the word until, the sense of the test is reversed, but the conditional is still tested before the first iteration.
In either the if or the while statement, you may replace ``(EXPR)'' with a BLOCK, and the conditional is true if the value of the last command in that block is true.
The for loop works exactly like the corresponding while loop:
for ($i = 1; $i < 10; $i++) {
...
}
is the same as
$i = 1;
while ($i < 10) {
...
} continue {
$i++;
}
The BLOCK by itself (labeled or not) is equivalent to a loop that executes once. Thus you can use any of the loop control statements in it to leave or restart the block. The continue block is optional. This construct is particularly nice for doing case structures.
foo: {
if (/abc/) { $abc = 1; last foo; }
if (/def/) { $def = 1; last foo; }
if (/xyz/) { $xyz = 1; last foo; }
$nothing = 1;
}
Any simple statement may optionally be followed by a single modifier, just before the terminating semicolon. The possible modifiers are:
if EXPR
unless EXPR
while EXPR
until EXPR
The
if
and
unless
modifiers have the expected semantics.
The
while
and
unless
modifiers also have the expected semantics (conditional evaluated first),
except when applied to a do-BLOCK command,
in which case the block executes once before the conditional is evaluated.
This is so that you can write loops like:
do {
$_ = <stdin>;
...
} until $_ eq ".\n";
(See the
do
operator below. Note also that the loop control commands described later will
NOT work in this construct, since modifiers don't take loop labels.
Sorry.)
Here's what
perl
has that C doesn't:
print '-' x 80; # print row of dashes
print '-' x80; # illegal, x80 is identifier
print "\t" x ($tab/8), ' ' x ($tab%8); # tab over
if (101 .. 200) { print; } # print 2nd hundred lines
next line if (1 .. /^$/); # skip header lines
s/^/> / if (/^$/ .. eof()); # quote body
-r File is readable by effective uid.
-w File is writeable by effective uid.
-x File is executable by effective uid.
-o File is owned by effective uid.
-R File is readable by real uid.
-W File is writeable by real uid.
-X File is executable by real uid.
-O File is owned by real uid.
-e File exists.
-z File has zero size.
-s File has non-zero size.
-f File is a plain file.
-d File is a directory.
-l File is a symbolic link.
Example:
while (<>) {
chop;
next unless -f $_; # ignore specials
...
}
Note that -s/a/b/ does not do a negated substitution.
Here is what C has that
perl
doesn't:
Like C, perl does a certain amount of expression evaluation at compile time, whenever it determines that all of the arguments to an operator are static and have no side effects. In particular, string concatenation happens at compile time between literals that don't do variable substitution. Backslash interpretation also happens at compile time. You can say
'Now is the time for all' . "\n" .
'good men to come to.'
and this all reduces to one string internally.
Along with the literals and variables mentioned earlier,
the following operations can serve as terms in an expression:
If you prepend an `m' you can use any pair of characters as delimiters. This is particularly useful for matching Unix path names that contain `/'. If the final delimiter is followed by the optional letter `i', the matching is done in a case-insensitive manner.
Examples:
open(tty, '/dev/tty');
<tty> =~ /^y/i && do foo(); # do foo if desired
if (/Version: *([0-9.]*)/) { $version = $1; }
next if m#^/usr/spool/uucp#;
$cnt = (chmod 0755,'foo','bar');
while (<>) {
chop; # avoid \n on last field
@array = split(/:/);
...
}
$cnt = (chown $uid,$gid,'foo');Here's an example of looking up non-numeric uids:
print "User: ";
$user = <stdin>;
chop($user);
open(pass,'/etc/passwd') || die "Can't open passwd";
while (<pass>) {
($login,$pass,$uid,$gid) = split(/:/);
$uid{$login} = $uid;
$gid{$login} = $gid;
}
@ary = ('foo','bar','bie','doll');
if ($uid{$user} eq '') {
die "$user not in passwd file";
}
else {
unshift(@ary,$uid{$user},$gid{$user});
chown @ary;
}
open(output,'|sort >foo'); # pipe to sort
... # print stuff to output
close(output); # wait for sort to finish
open(input,'foo'); # get sort's results
die "Can't cd to spool." unless chdir '/usr/spool/news';
(chdir '/usr/spool/news') || die "Can't cd to spool."
Note that the parens are necessary above due to precedence.
See also
exit.
while (($key,$value) = each(ENV)) {
print "$key=$value\n";
}
See also keys() and values().
# insert dashes just before last line
while (<>) {
if (eof()) {
print "--------------\n";
}
print;
}
$ans = <stdin>;
exit 0 if $ans =~ /^[Xx]/;
See also
die.
($sec,$min,$hour,$mday,$mon,$year,$wday,$yday,$isdst)
= gmtime(time);
All array elements are numeric.
$_ = join(':', $login,$passwd,$uid,$gid,$gcos,$home,$shell);
See
split.
@keys = keys(ENV);
@values = values(ENV);
while ($#keys >= 0) {
print pop(keys),'=',pop(values),"\n";
}
$cnt = (kill 9,$child1,$child2);If the signal is negative, kills process groups instead of processes. (On System V, a negative process number will also kill process groups, but that's not portable.)
line: while (<stdin>) {
last line if /^$/; # exit when done with header
...
}
($sec,$min,$hour,$mday,$mon,$year,$wday,$yday,$isdst)
= localtime(time);
All array elements are numeric.
line: while (<stdin>) {
next line if /^#/; # discard comments
...
}
Note that if there were a
continue
block on the above, it would get executed even on discarded lines.
If the LABEL is omitted, the command refers to the innermost enclosing loop.
$val = oct($val) if $val =~ /^0/;
$article = 100;
open article || die "Can't find article $article";
while (<article>) {...
open(log, '>>/usr/spool/news/twitlog');
open(article, "caeser <$article |"); # decrypt article
open(extract, "|sort >/tmp/Tmp$$"); # $$ is our process#
$ARRAY[$#ARRAY+1] = EXPR;but is more efficient.
# a simpleminded Pascal comment stripper
# (warning: assumes no { or } in strings)
line: while (<stdin>) {
while (s|({.*}.*){.*}|$1 |) {}
s|{.*}| |;
if (s|{.*| |) {
$front = $_;
while (<stdin>) {
if (/}/) { # end of comment?
s|^|$front{|;
redo line;
}
}
}
print;
}
reset 'X'; # reset all X variables
reset 'a-z';# reset lower case variables
reset; # just reset ?? searches
s/\bgreen\b/mauve/g; # don't change wintergreen
$path =~ s|/usr/bin|/usr/local/bin|;
s/Login: $foo/Login: $bar/; # run-time pattern
s/([^ ]*) *([^ ]*)/$2 $1/; # reverse 1st two fields
(Note the use of $ instead of \ in the last example. See section
on regular expressions.)
select(report1);
$^ = 'report1_top';
select(report2);
$^ = 'report2_top';
Select happens to return TRUE if the file is currently open and FALSE otherwise,but this has no effect on its operation.
print join(':',split(/ */,'hi there'));
produces the output 'h:i:t:h:e:r:e'.
The pattern /PATTERN/ may be replaced with an expression to specify patterns
that vary at runtime.
As a special case, specifying a space (' ') will split on white space
just as split with no arguments does, but leading white space does NOT
produce a null first field.
Thus, split(' ') can be used to emulate awk's default behavior, whereas
split(/ /) will give you as many null initial fields as there are
leading spaces.
Example:
open(passwd, '/etc/passwd');
while (<passwd>) {
($login, $passwd, $uid, $gid, $gcos, $home, $shell)
= split(/:/);
...
}
(Note that $shell above will still have a newline on it. See chop().)
See also
join.
($dev,$ino,$mode,$nlink,$uid,$gid,$rdev,$size,
$atime,$mtime,$ctime,$blksize,$blocks)
= stat($filename);
($user,$system,$cuser,$csystem) = times;
$ARGV[1] =~ y/A-Z/a-z/; # canonicalize to lower case
$cnt = tr/*/*/; # count the stars in $_
$cnt = (unlink 'a','b','c');
unshift(ARGV,'-e') unless $ARGV[0] =~ /^-/;
Top of form processing is handled automatically: if there is insufficient room on the current page for the formatted record, the page is advanced, a special top-of-page format is used to format the new page header, and then the record is written. By default the top-of-page format is ``top'', but it may be set to the format of your choice by assigning the name to the $^ variable.
If FILEHANDLE is unspecified, output goes to the current default output channel,which starts out as stdout but may be changed by the select operator. If the FILEHANDLE is an EXPR, then the expression is evaluated and the resulting string is used to look up the name of the FILEHANDLE at run time. For more on formats, see the section on formats later on.
sub NAME BLOCK
Any arguments passed to the routine come in as array @_, that is ($_[0], $_[1], ...). The return value of the subroutine is the value of the last expression evaluated. There are no local variables---everything is a global variable.
A subroutine is called using the do operator. (CAVEAT: For efficiency reasons recursive subroutine calls are not currently supported. This restriction may go away in the future. Then again, it may not.)
Example:
sub MAX {
$max = pop(@_);
while ($foo = pop(@_)) {
$max = $foo if $max < $foo;
}
$max;
}
...
$bestday = do MAX($mon,$tue,$wed,$thu,$fri);
Example:
# get a line, combining continuation lines
# that start with whitespace
sub get_line {
$thisline = $lookahead;
line: while ($lookahead = <stdin>) {
if ($lookahead =~ /^[ \t]/) {
$thisline .= $lookahead;
}
else {
last line;
}
}
$thisline;
}
$lookahead = <stdin>; # get first line
while ($_ = get_line()) {
...
}
Use array assignment to name your formal arguments:
sub maybeset {
($key,$value) = @_;
$foo{$key} = $value unless $foo{$key};
}
s/^([^ ]*) *([^ ]*)/$2 $1/; # swap first two words
if (/Time: (..):(..):(..)/) {
$hours = $1;
$minutes = $2;
$seconds = $3;
}
By default, the ^ character matches only the beginning of the string, and
perl
does certain optimizations with the assumption that the string contains
only one line.
You may, however, wish to treat a string as a multi-line buffer, such that
the ^ will match after any newline within the string.
At the cost of a little more overhead, you can do this by setting the variable
$* to 1.
Setting it back to 0 makes
perl
revert to its old behavior.
format NAME =
FORMLIST
.
If name is omitted, format ``stdout'' is defined.
FORMLIST consists of a sequence of lines, each of which may be of one of three
types:
Picture lines are printed exactly as they look, except for certain fields that substitute values into the line. Each picture field starts with either @ or ^. The @ field (not to be confused with the array marker @) is the normal case; ^ fields are used to do rudimentary multi-line text block filling. The length of the field is supplied by padding out the field with multiple <, >, or | characters to specify, respectively, left justfication,right justification, or centering. If any of the values supplied for these fields contains a newline, only the text up to the newline is printed. The special field @* can be used for printing multi-line values. It should appear by itself on a line.
The values are specified on the following line, in the same order as the picture fields. They must currently be either string variable names or string literals (or pseudo-literals). Currently you can separate values with spaces, but commas may be placed between values to prepare for possible future versions in which full expressionsare allowed as values.
Picture fields that begin with ^ rather than @ are treated specially. The value supplied must be a string variable name which contains a text string. Perl puts as much text as it can into the field, and then chops off the front of the string so that the next time the string variable is referenced, more of the text can be printed. Normally you would use a sequence of fields in a vertical stack to print out a block of text. If you like, you can end the final field with ..., which will appear in the output if the text was too long to appear in its entirety.
Since use of ^ fields can produce variable length records if the text to be formatted is short, you can suppress blank lines by putting the tilde (~) character anywhere in the line. (Normally you should put it in the front if possible.) The tilde will be translated to a space upon output.
Examples:
# a report on the /etc/passwd file
format top =
Passwd File
Name Login Office Uid Gid Home
------------------------------------------------------------------
.
format stdout =
@<<<<<<<<<<<<<<<<<< @||||||| @<<<<<<@>>>> @>>>> @<<<<<<<<<<<<<<<<<
$name $login $office $uid $gid $home
.
# a report from a bug report form
format top =
Bug Reports
@<<<<<<<<<<<<<<<<<<<<<<< @||| @>>>>>>>>>>>>>>>>>>>>>>>
$system; $%; $date
------------------------------------------------------------------
.
format stdout =
Subject: @<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
$subject
Index: @<<<<<<<<<<<<<<<<<<<<<<<<<<<< ^<<<<<<<<<<<<<<<<<<<<<<<<<<<<
$index $description
Priority: @<<<<<<<<<< Date: @<<<<<<< ^<<<<<<<<<<<<<<<<<<<<<<<<<<<<
$priority $date $description
From: @<<<<<<<<<<<<<<<<<<<<<<<<<<<<< ^<<<<<<<<<<<<<<<<<<<<<<<<<<<<
$from $description
Assigned to: @<<<<<<<<<<<<<<<<<<<<<< ^<<<<<<<<<<<<<<<<<<<<<<<<<<<<
$programmer $description
~ ^<<<<<<<<<<<<<<<<<<<<<<<<<<<<
$description
~ ^<<<<<<<<<<<<<<<<<<<<<<<<<<<<
$description
~ ^<<<<<<<<<<<<<<<<<<<<<<<<<<<<
$description
~ ^<<<<<<<<<<<<<<<<<<<<<<<<<<<<
$description
~ ^<<<<<<<<<<<<<<<<<<<<<<<...
$description
.
It is possible to intermix prints with writes on the same output channel,
but you'll have to handle $- (lines left on the page) yourself.
If you are printing lots of fields that are usually blank, you should consider using the reset operator between records. Not only is it more efficient, but it can prevent the bug of adding another field and forgetting to zero it.
while (<>) {... # only equivalent in while!
while ($_ = <>) {...
/^Subject:/
$_ =~ /^Subject:/
y/a-z/A-Z/
$_ =~ y/a-z/A-Z/
chop
chop($_)
(Mnemonic: underline is understood in certain operations.)
/Version: (.*)|Revision: (.*)/ && ($rev = $+);(Mnemonic: be positive and forward looking.)
sub handler { # 1st argument is signal name
($sig) = @_;
print "Caught a SIG$sig--shutting down;
close(log);
exit(0);
}
$SIG{'INT'} = 'handler';
$SIG{'QUIT'} = 'handler';
...
$SIG{'INT'} = 'DEFAULT'; # restore default action
$SIG{'QUIT'} = 'IGNORE'; # ignore SIGQUIT
$ENV{'PATH'} = '/bin:/usr/bin'; # or whatever you need
$ENV{'SHELL'} = '/bin/sh' if $ENV{'SHELL'};
$ENV{'IFS'} = '' if $ENV{'IFS'};
Cerebral C programmers should take note of the following:
Seasoned sed programmers should take note of the following:
You can't currently dereference array elements inside a double-quoted string. You must assign them to a temporary and interpolate that.
Associative arrays really ought to be first class objects.
Recursive subroutines are not currently supported, due to the way temporary values are stored in the syntax tree.
Arrays ought to be passable to subroutines just as strings are.
The array literal consisting of one element is currently misinterpreted, i.e.
@array = (123);doesn't work right.
Perl actually stands for Pathologically Eclectic Rubbish Lister, but don't tell anyone I said that.