Perl Quick Reference

Files and Directories s/cat/dogs/ search "cat" substitute "dogs"

s/cat/dogs/g search every "cat" on a line, sub "dogs"
chdir ("/etc") change to directory /etc s/cAT/dogs/I ignore case for search
Variable and Arrays
@a = </etc/*>; @a gets list of files in /etc [glob] [Aa] match big or little A
@a = </etc/h*>; @a gets a list of h* files in /etc [glob] $var = "contents" initialize a scalar variable
[^A] anything but A $v = 45 value of $v is 45
while ($v= <bin/*> { [0-9] every single digit
@a = ~s/.*\/// remove path (before last slash -- greedy) ($a,$b,$c) = (2,4,6) $a is 2, $b is 4, $c is 6
[a-zA-Z0-9] any single letter or digit (1..5) same as (1,2,3,4,5)
[\d] digits; every digit; same as [0-0] ($a,$b) = ($b,$a) swap $a and $b
opendir (ETC,"/etc") || die "Cannot open dir /etc"; [\D] anything not \d; same as [^0-9]
@a=readdir(ETC); ($d, @list) = ($a,$b,$c) $d gets value of $a, array @list
[\w] words; same as [a-zA-Z0-9] gets value of $b and $c
close (ETC); [dir handle see man readdir] [\W] same as [^a-zA-Z0-9]; any nonword char
[\s] white space; same as [ \r\t\n\f] @var = ("xx", "yy", "zz") initialize an array variable
unlink ("file6"); remove file6 (like unix rm file6)
[\S] sane as [^\r\t\n\f] $var[0] recalls "xx"
unlink ("*.c"); like rm *.c (also takes lists and variables)
$var[1] recalls "yy"
rename (("top","bot") || die "Cannot rename top to bot."; [a+] one or more a's in sequence (aaaaaa) $#var index of last item (2 for @var)
rename ("f","bin/f"); mv, but must repeat file name in destination [a?] zero or one a
[a*] zero or more a's in sequence @v = (1,2,3) initialize @v (for following examples)
link ("hat","cap"); Unix ln hat cap @w = (0,@v,4,five @w is now (0,1,2,3,4,five)
symlink ("hat","cap"); Unix ln -s hat cap $_ = "a bbbbb c"; @w = (six, @w) @w is now (six,0,1,2,3,4,five)
$x=readlink ("file"); returns name of symlink or undef (zero) s/b*/cat/; replaces bbbbb with cat "a cat c" $b = $w[1] $b is now 0
s/b{4}/cat/; replaced 4 b's with cat: "a catb c" $b = ++$w[1] $b and $w [1] are now 1
mkdir ("bin",0777) || die "cannot make dir bin" [x=1 w=2 r=4]; s/b {3.7}/cat/; replaces 3 to 7 b's: "a cat c" (greedy) $b = $w[1]++ $b is still 1 and $w[1] is now 2
rmdir ("bin") || die "cannot remove dir bin"; @c = @w[0,1,6] @c is now (six,2,five)
chmod (0666,"f1","f2") Change permissions for files f1 and f2 s/ant(.)/bug\1/ \1 gets paren value (\2 gets second paren) @w[0,1] = (no,no) @w is now (no,no,1,2,3,4,five)
if ants then bugs; if anto then bugo $w[$#w] returns "five" (the last element)
System Processing (second parens referenced with \2) print "@w[0..$#w]" prints entire array
/read|writ/ing/ alternative match (*reading or writing)
system ("who"); executes the shell process "who" \b word boundary push(@v,$b) adds new element $b to (right) end of @v
system ("who >file") && die "cannot create file right now"; return /cat\b/ "cat" but not "catalog" pop(@v) removes last (rightmost) element of @v
of true (nonzero) is an error -- opposite /\bcat/ "catalog" but not "concatenate" chop(@v) removes last char from each element
of Perl therefore && instead of || /\bcat\b/ "cat" as a word, but not in a word
/^a/ matches a iff a is first char in string unshift(@v,$b) adds new element $b to front of @v
while (system ("grep aa fl")) } executes the shell process "grep" /a$/ matches a iff a is last char in string shift(@v) removes first element of @v
push (@a, $_) } puts found lines in array @a /a|b+/ match one a or any number of b's reverse(@v) returns order of elements reversed
/(a|b)+/ match any number of a's or b's sort(@v) returns elements sorted (string sort)
while (system ("grep", "aa", "fl")){same except list saves one shell @v= sort{$a<=>$b}@v uses a numeric sort
push (@a, $_) } process; therefore faster $a ="real food";
$x=$a=~/(.)\1/; $x is 1 (true): matches oo in "food" @v = (0,1,2,) initialize @v (for following examples)
$v = `grep aa fl`; `backtics` execute the shell process "grep" $a =~s/oo/ee/ oo changed to ee; $a is now "real feed"; push(@v,6) @v is now (0,1,2,6)
$b = pop(@v) @v is now (0,1,2,); $b is 6
foreach (`grep aa fl`) { puts found line in array @a $1,$2,$3 \1\2 \3 etc can be accessed as $1 $2 $3 … unshift(@v,$b) @v is now 6,0,1,2)
push (@a, $_);} $b = shift(@v) @v is now (0,1,2,) $b gets 6 again
$_ = " they cannot write at all"; @x = reverse(@v) @x is (2,1,0); @v is still (0,1,2)
Regular Expressions /w..te/; matches "write" @v = (2,3,1,11) initialize @v
print $'; $' prints "they cannot" @v = sort(@v) @v is now (1,11,2,3,) (string sort!)
if (/abc/) { search for string "abc"; print $&; $& prints "write" @v = (aa,bb,cc) initialize @v
print "$_"; print line which "abc" occurs; $_ is the print $'; $' prints "at all" chop(@v) @v is now (a,b,c,) [array context]
} default variable
srand initialize random number split(/separator/list) change string into array at separators;
which (<>) { diamond operator: this routine is like grep $n=rand(35) Sets $n to real number 0-34 $a = "crazy-cool-cats";
if (/abc/) { $x=@v[rand (35)] $x gets a random element 0-34 of @v @c = split (/-/,$a); @c becomes ("crazy", "cool", "cats")
print "$_";} search for "abc" from a file or files $_ = "big blue bugs"
} @bugs = split $_ and whitespace defaults
/ca*t/ matches "ca" any number of "a's" and "t" Copyright © Forty Below Net Works 2000
. matches any character but \n [email protected] join(separator, array) change array into string with separators
/c.*?t/ the ? suppresses greedy: cat but not cattt www.40-below.com $b = join("::", @c) $b becomes ("crazy::cool::cats"); any or no
.* any char from present to end of the line chars as separators, but no reg expressions
 Hashes (Associative Arrays) Control Operators File Operators
%map = ("pete", "xx", "jo", "yy", "ida", "zz") sub do_it { creates subroutine with local vars $v and open (FL, "fl"); open input file fl with filehandle FL
create associative array (pairs of values) local ($v,@a); @a while (<FL>){} puts next line from file fl into $_
$map{pete} recalls xx with key "pete" [note curly brackets] $v =1} subroutine returns last expression evaluated close (FL) closes file fl
$map{jo} recalls yy with key "jo" local($v,$w) = @_; special char @_ assigns locals from parameters,
$map {me} = "aa" creates key "me" with value "aa" elements $_[0], $_[1], $_[2], etc. open (OUT,">fl"); open file for output with filehandle OUT
$var{date} = 94 creates "date" with value of 94 open (AP,">>fl"); open file fl for append, filehandle AP
&do_it cats 5 do_it invoked with arguments (cats and 5)
@x = %map @x gets ("pete", "xx", "jo", "yy", open (MAIL, " | mail [email protected]");
"ida", "zz", "me", "aa") if (expr) { if expr is true then list1 executed | Piping runs command -- here the mail cmd
%w = @x creates assoc. array from @x statement list1 [put piping at end to grab cmd output | ]
keys (%map) lists keys of %map (e.g. use with foreach) } elsif (expr2) { else if expr2 is true then list2 executed
in a scalar context returns no. of keys statement list2 (can continue with more elsifs) dbmopen (%var, "fl", 0666); keeps array %var in file fl
} else { $var ($name} = time; appends time to array in fl
each (%map) lists all current values of %map statement list3 else -- when all the aboves fail execute this dbmclose(%var); 0666 sets octal file permissions
delete $map{jo} deletes key and value; returns the value } list3 rename ($fl, "$fl.ex") renames file to file.ex
foreach (keys(%map)) {print ("$map{$_}\n");}
expr2 if expr; if statement with order reversed <STDIN> waits for keyboard input -- adds \n
String Functions (same for unless, while, and until) <STDOUT>
chop($str) discards any last char of $str <STDERR>
this && that; logic and; equals: if (this) {that} $v = <STDIN> $v gets single line input on Enter
chomp($str) discards \n if last char of $str
this || that; logic or; equals: unless (this) {that} @v = <STDIN> @v several lines; ^D to end (array context)
$v = chop($str) puts last char in $v
str eq str compares two strings (true if equal) if (/a/ && /e/ && /i/ && /o/ && /u/) {print "all vowels used";}
$var eq "this" compare contents of var with str "this" while (<STDIN>) { reads each line to $_
all conditions must be true for true; print "$_"; } $_ is the default variable
ne, lt, gt, le, ge, cmp (returns -1, 0, or 1) logical "and"
these are the other string operators while (<>) { diamond operator reads @ARGV from the
unless (expr) { executes unless expr is true print $_; } cmd line (here it prints all lines of arg files)
$str="ab" x 4; $str is now "abababab" statement list } takes elsif and else (like if)
. concatenate two strings File Test (list is not exhaustive)
.= concatenation assignment strings while (expr) { while expr is true repeat execution of
($var =~ /reg. ex./) returns true if regular expressions found statement list } statement list $fl = "filename" assigns a filename to a variable
($var =~ /^Pe/i) regular expression starts "pe", any case if(-r $fl && -w _) Underline "_" reports on a -w without
until (expr) { like while, but stops when expr is true {print "use $fl";} a new stat system call
$var -~s/ab/cd/; substitute -- all ab to cd (like sed) statement list }
$var =~tr/A-Z/a-z/; translate -- all $var to lowercase; like Unix tr -r readable (file or dir)
$count = tr/a-z//; no change but counts no. of lowercase letters for (ini, test, incr) { initialize a variable, test to run list, -w writable
$var = tr/a-z/ /c c complement: changes any but a-z to space statement list } then increment the variable -x executable
$var = tr/a-z/ABC/d delete: deletes any match of a-z that is not abc -o owned by user
for ($a=1; $a<=10; $a++) { print "$a";} Prints 1 through 10 -e exists
$v = index($str,$x) find index no of beginning string $x in $str for ($a=1; $a<=$#var,$a++) {print "$a";} 1 through length @var -1 -z zero size (file exists)
$v =("abc", "bc") $v gets 1; position of "a" is 0 (zero) -s nonzero size
foreach $v (@list){ Repeats cmd list for each $v produced -f file
$v - rindex($str,$x)) index starts from right, but numbers from left statement list by @list; NOTE: If you change any particular -d directory
$v = ("cabc", "c") $v gets 3; position of first c from right } $v, the element changes in the array @list -l symlink
@w = (1..9); -T text file
$v = substr($str, $start, $length) $v gets substring if found foreach $v(@w) { prints 1 through 9 on separate lines -B binary file
$start is index of string; $length is no of char print $v\n;} -M modification age in days
$v = substr("cabc",1,3)returns "abc"; 3 ($length) could be omitted here -A access age in days
$v = substr("cabc", -3,3) returns "abc"; negative counts back from right @w = (1..9); Omits the $v; Perl assumes the default stat() remaining info on files
foreach (@w) { variable $_
$str = "big boat"; initialize $str; print $_;} String Escapes for Double Quotes
substr($str,-4) = "payments"; $str becomes "big payments"
\n newline
last ends loops: while, for, etc. \t tab
Print
next skips to next item in loop -- while, for, etc. \007 octal value (007 = bell)
$v = sprintf("%10s \n", $str); $v gets print string; like printf redo jumps to top of loop; unlike next it doesn't \x7f hex value (7f = delete)
print "hello\n" Prints "hello" to standard out get new item; use with last to break loop \$ literal dollar sign
printf ("%20s %4d %6.2f\n", $s, $i, $r); LABEL7: label statements for next and last jumps \l lowercase the next letter
Same as "C" printf; %20s for string, 4d for for jumping out of nested loop to outer loop \L lowercase letters until \E
decimal integer, %6.2f for floating point last LABEL7 end nested labeled LABEL7 \u uppercase next letter
die "no such file"; ends program; prints message to stdout \U uppercase letters until \E