Perl Syntax

[Basic Script]
[Data Types]
[Conditionals]
[Loops and Iterations]
[Functions]
[Regular Expressions]
[Special Variables]
[Standard IO]
[Useful Functions and Keywords]
other languages..

Basic Script
#############################################################################
#
# name: main
# purpose: entry point of the script
#############################################################################
#

# @ARGV holds all script command line arguments (pos 0 is not prog-name)
# $0 holds script filename
print "hello world\n";

Data Types
#############################################################################
#
# name: main
# purpose: show the basic datatypes
#############################################################################
#

### scalars (ints, floats, strings)

$float = 3.14; # can hold real / whole numbers
$false = 0; # 0 counts as FALSE, non-zero is TRUE
$str = "hello"; # can hold strings
$false2 = ""; # en empty string is FALSE of course
$false3 = '0'; # "0" also counts as FALSE, all other strings are TRUE
undef $num; # similar to NULL, counts as FALSE
$line = "hello\n"; # $line holds 'hello' and then a new-line (LF) - 6
chars
$firm = 'hello\n'; # $firm holds the text 'hello\n' - 7 chars
$ten_a = 'a' x 10; # $ten_a holds 'aaaaaaaaaa'
$long1 = <<"END1"; # long text with a few lines - as a "" string
This is long text,
With $float lines.
END1
$long2 = <<'END2'; # long text with a few lines - as a '' string
This can hold \n.
END2

# scalar operations
$num = $num*2 + 3 - $float; # $num is 23.86
$num = 2**4 % 5; # $num is 1 - exp then modulus
$num++; # $num is 2 - inc after eval
$ms = (1<< 3)&0xff|0x03^0x01; # $ms is 0x0a
print ++($foo = '99'); # prints '100' - inc before eval
$new = $str." world"; # $new is "hello world"

### arrays (lists of scalars)

@nums = (1,2,3);
@strings = ("one",$str); # @strings is ("one","hello")
@mixed = ("three",3.13); # any scalar can be placed in a list
@empty = (); # empty list counts as FALSE, non-empty is TRUE
($one,$two) = (1,2); # $one is 1, $two is 2
@to_ten = (1,2,3..10); # 3..10 is a list of all nums from 3 to 10

# array operations
$first = $nums[0]; # $first is 1
$strings[1] = "neo"; # @strings is ("one","neo")
$mixed[2] = 37; # @mixed is ("three",3.13,37) - grows automatically
@joined = (@mixed,8); # @joined is ("three",3.13,37,8)
@sl = @nums[0,-1,1]; # @sl is (1,3,2) - array slice (specific indices)
@sl = @nums[0..2]; # @sl is (1,2,3) - array slice (span)
$len = scalar(@nums); # an array in scalar context is the list length (3)
$last_index = $#nums; # $last_index is 2 (the last index in the list)
$#nums = -1; # @nums is () - empty

### hashes (maps of keys and values)

%ages = ("jim"=>18,"ted"=>21); # the key "jim" has a value of 18
%same = ("jim",18,"ted",21); # => is exactly like ,
%mix_hash = (1=>"bla","hi"=>22.1); # any scalar can be a key or value
%empty_hash = (); # empty hash counts as FALSE, full is
TRUE

# hash operations
$jims_age = $ages{"jim"}; # $jims_age is 18
$ages{"jim"}++; # key "jim" has value of 19 in %ages
$ages{"ron"} = 24; # key "ron" with value 24 added to %ages
@sl = @ages{"ted","ron"}; # @sl is (21,24) - hash slice
$stats = scalar(%ages); # string eg. "1/16" - 1 used bucket out of 16
alloced

### references (scalar that holds a pointer to another type)

$scalarref = \$num;
$arrayref = \@mixed;
$hashref = \%ages;

# reference operations
$num_copy = $$scalarref; # dereference using {type}$reference
@mixed_copy = @$arrayref;
$value = $$hashref{"jim"};
$value = $arrayref->[0]; # or dereference using $reference->
$value = $hashref->{"jim"};

Conditionals
#############################################################################
#
# name: main
# purpose: show the basic conditionals
#############################################################################
#

# regular c style if statement, must use blocks

if (defined($value) && ($value == 1)) # defined() tests for
undef
{
print "value equals 1\n";
}

# if-else, must use blocks

if (($job eq "millionaire") || ($state ne "dead")) # eq,ne are used for
strings
{
print "a suitable husband found\n";
}
else
{
print "not suitable\n";
}

# unless is the opposite of if, must use blocks

unless (($age >= 18) and ($age < 80)) # and,or,not are also ok
{
print "too old\n";
}

# short forms (no blocks needed if a single statement comes before)

print "ok" if $ok;
print "ok" unless not $ok;

# and the true perl way

open(FILE) or die "cant open file";

Loops and Iterations

#############################################################################
#
# name: main
# purpose: show the flow blocks
#############################################################################
#

# for (regular c style), must use a block

for ($i=0; $i<10; $i++)
{
print "iteration number $i\n";
}

# foreach (iterate on lists), must use blocks

foreach $num (@numbers) # $num hold a member in each iteration
{
print "$num";
}
foreach (@numbers) # if excluded, the member is stored in $_
{
print; # by default, $_ is printed
}
for (1..10) { print "a"; } # 'foreach' is actually a synonym for
'for'

# while / until statements, must use blocks

$i = 0;
while ($i < 10) # enter block if condition is TRUE
{
print "iteration number $i\n";
$i++;
}
until ($i == 0) # enter block if condition is FALSE
{
$i--;
print "back to $i\n";
}

# do while / until just like in c, must use blocks

$i = 0;
do
{
print "this will print\n"; # enter block once before evaluating
} while ($i != 0);
do
{
print "this too\n";
} until ($i == 0);

# short forms (no blocks needed if a single statement comes before)

print "a" for (1..10);
read_next_line() while not end_of_file();
read_next_line() until end_of_file();

# next and last statements are similar to c continue and break

for ($i=0; $i<10; $i++)
{
next if ($i == 3); # skip printing 3 (go to next iteration)
last if ($i == 5); # exit the loop before printing 5
print $i; # will print 0124
}
Functions
#############################################################################
#
# name: main
# purpose: show function and subroutine syntax
#############################################################################
#

# return values
sub seventeen1 # return keyword indicated return value
{
return 17;
}
sub seventeen2 # if no return exists, retval is the last
expression
{
17;
}
$num = seventeen1() + seventeen2() + 53;
sub retlist # all datatypes can be returned
{
return (1,2,3);
}
($one,$two,$thr) = retlist; # () are optional (even when we have args)

# arguments
sub has_args
{
@func_arguments = @_; # all arguments are members of the list @_
$first_arg = $_[0]; # returns undef if no arg given
($arg1,$arg2,$arg3) = @_; # the common perl way to handle function
arguments
}
has_args($num,@l1,22,@l2); # all arguments are flattened into one list
sub takes_two_lists # to pass several lists / hashes, use references
{
($l1ref,$l2ref) = @_;
@list1 = @$l1ref;
}
takes_two_lists(\@a,\@b);

# prototypes (limited compile-time argument checking)

sub two_scalars($$) { }; # two_scalars(12,"hello");
sub scalar_n_list($@) { }; # scalar_n_list("scalar",1,2,3);
sub array_ref(\@) { }; # array_ref(@array);

Regular Expressions
#############################################################################
#
# name: main
# purpose: show regular expression usage
#############################################################################
#

# matching
$call911 = 'Someone, call 911.'; # the string we want to match upon
$found = ($call911 =~ /call/); # $found is TRUE, matched 'call'
@res = ($call911 =~ /Some(...)/); # @res is ('one'), matched 'Someone'
$entire_res = $&; # $entire_res is 'Someone'
$brack1_res = $1; # $brack1_res is 'one', $+ for last
brackets
($entire_pos,$brack1_pos) = @-; # $entire_pos is 0, $brack1_pos is 4
($entire_end,$brack1_end) = @+; # $entire_end is 7, $brack1_end is 7
# global matching (get all found)
$call911 =~ /(.o.)/g; # g is global-match, $1 is 'Som', $2 is
'eon'
@res = ($call911 =~ /(.o.)/g); # @res is ('Som','eon'), $& is 'eon'

# substituting
$greeting = "hello world"; # the string we want to replace in
$greeting =~ s/hello/goodbye/; # $greeting is 'goodbye world'

# splitting
@l = split(/\W+/,$call911); # @l is ('Someone','call','911')
@l = split(/(\W+)/,$call911); # @l is ('Someone',', ','call','
','911','.')

# pattern syntax
$call911 =~ /c.ll/; # . is anything but \n, $& is 'call'
$call911 =~ /c.ll/s; # s is singe-line, . will include \n, $& is 'call'
$call911 =~ /911\./; # \ escapes metachars {}[]()^$.|*+?\, $& is '911.'
$call911 =~ /o../; # matches earliest, $& is 'ome'
$call911 =~ /g?one/; # ? is 0 or 1 times, $& is 'one'
$call911 =~ /cal+/; # + is 1 or more times, $& is 'call', * for 0 or
more
$call911 =~ /cal{2}/; # {2} is exactly 2 times, $& is 'call'
$call911 =~ /cal{0,3}/; # {0,3} is 0 to 3 times, $& is 'call', {2,} for >=
2
$call911 =~ /S.*o/; # matches are greedy, $& is 'Someo'
$call911 =~ /S.*?o/; # ? makes match non-greedy, $& is 'So'
$call911 =~ /^.o/; # ^ must match beginning of line, $& is 'So'
$call911 =~ /....$/; # $ must match end of line, $& is '911.'
$call911 =~ /9[012-9a-z]/;# one of the letters in [...], $& is '91'
$call911 =~ /.o[^m]/; # none of the letters in [^...], $& is 'eon'
$call911 =~ /\d*/; # \d is digit, $& is '911'
$call911 =~ /S\w*/; # \w is word [a-zA-Z0-9_], $& is 'Someone'
$call911 =~ /..e\b/; # \b is word boundry, $& is 'one', \B for non-
boundry
$call911 =~ / \D.../; # \D is non-digit, $& is ' call', \W for non-word
$call911 =~ /\s.*\s/; # \s is whitespace char [\t\n ], $& is ' call '
$call911 =~ /\x39\x31+/; # \x is hex byte, $& is '911'
$call911 =~ /Some(.*),/; # (...) extracts, $1 is 'one', $& is 'Someone,'
$call911 =~ /e(one|two)/; # | means or, $& is 'eone'
$call911 =~ /e(?:one|tw)/;# (?:...) does not extract, $& is 'eone', $1 is
undef
$call911 =~ /(.)..\1/; # \1 is memory of first brackets, $& is 'omeo'
$call911 =~ /some/i; # i is case-insensitive, $& is 'Some'
$call911 =~ /^Some/m; # m is multi-line, ^ will match start of entire
text
$call911 =~ m!call!; # use ! instead of /, no need for \/, $& is 'call'

Special Variables
#############################################################################
#
# name: main
# purpose: show some special internal variables
#############################################################################
#

# $_ - default input
print for (1..10); # in many places, no var will cause work on $_
print $_ for $_ (1..10); # same as above

# $. - current line in last file handle

while (!(<IN> =~ /error/i)) {};
print "first error on line $.\n";

# $/ - input record separator (default is "\n")

undef $/;
$entire = <IN>; # read entire file all at once
$/ = "512";
$chunk = <IN>; # read a chunk of 512 bytes

# $\ - output record separator (default is undef)

$\ = "\n"; # auto \n after print
print 'no need for LF';

# $! - errno / a string description of error

open(FILE) or die "error: $!";

# $@ - errors from last eval

eval $cmd;
print "eval successful" if not $@;

Standard IO
#############################################################################
#
# name: main
# purpose: show some basic IO and file handling
#############################################################################
#

# open a file a la shell

open(IN, "< input.txt") or die "cant open input file: $!";
open(OUT, ">> output.txt") or die "cant open output file: $!";
# binmode(IN) to change IN from txt mode to binary mode
# read records from a file (according to $/)
while ($line = <IN>) # <IN> returns next line, or FALSE if none left
{
# write data to a file
print OUT $line;
}

# cleanup
close(IN);
close(OUT);

# check if file exists

print "$filename exists" if (-e $filename);

# check the file size

print "$filename file size is ".(stat $filename)[7];

# get all the txt files in current directory

@txtfiles = <*.txt>; # perl globbing
@txtfiles = `dir /b *.txt`; # or use the shell (slower), needs chomping

Useful Functions and Keywords

#############################################################################
#
# name: main
# purpose: show some basic functions and keywords of perl
#############################################################################
#

# scalar / string functions

foreach (`dir /b`) { chomp; print; } # chomp removes \n tail (according to
$/)
$ext = chop($file).$ext for (1..3); # chop removes last char and returns it
print 'a is '.chr(ord('a')); # ord converts chr to num, chr is
opposite
print lc("Hello"), uc(" World"); # prints 'hello WORLD'
print length("hello"); # prints '5'
$three_a = sprintf("%08x",58); # just like regular c sprintf
print($type) if ($type = ref $ref); # prints 'SCALAR'/'ARRAY'/'HASH'/'REF'

# regexps and pattern matching functions

print quotemeta('[.]'); # prints '\[\.\]'
@words = split(/W+/,$sentence); # splits a string according to a regexp

# array / list functions

@three_two_one = reverse(1,2,3); # returns a list in reverse
print pop(push(@arr,'at end')); # prints 'at end', no change to @arr
print shift(unshift(@arr,'at start'); # prints 'at start', no change to @arr
@after = grep(!/^\s*#/, @before); # weed out full comment lines
$sentence = join(' ',@words); # turns lists into strings with a delim
print sort <*.*>; # sort string lists in alphabetical
order
delete @arr[3..5]; # deletes the 3rd,4th,5th elements in
@arr
print "length is ".scalar @arr; # scalar evaluates expressions as
scalars

# hash related functions

delete @hash{"key1","key2"}; # deletes these keys from the hash
print $hash{$_} foreach (keys %hash); # prints all hash values by checking
keys
print values(%hash); # same but different

# misc functions and keywords

sleep(10); # causes the script to sleep for 10
secs
exit(0) if $should_quit; # exits the script with a return value
use warnings; use strict; # imports new external modules
no warnings; no strict; # un-imports imported external modules
my $var; # declare a local variable (strict)
undef($null) if defined($null); # check if a variable is defined
eval '$pn = $0;'; print $pn; # interpret new perl code in runtime
system("del $filename"); # run commands in the shell (blocking)
system("start calc.exe"); # run commands in the shell
(nonblocking)
@files = `dir /b`; # run & get output of shell commands
("")

Powered by Notepad.