BASIC INFORMATION ABOUT PERL

If the information below is not enough, consult man perl and look at the
message produced by the command perl -v.

Two ways to run a perl script:

perl -w <script name>

<script name>

In the latter case, the first line of the script must be

#!/usr/bin/perl -w

(The -w option means to warn the user of questionable syntax.)

No type declarations.  Scalar values are numbers or strings.
'<string>' string is taken literally.
"<string>" string is evaluated (variables and special symbols are replaced
by their values).

Example Hello World script:

#!/usr/bin/perl -w
print "hello world\n";

Syntax similar to C with some additions.

$<variable name> holds a scalar value.
@<variable name> holds an array of items, usually numbers or strings.

example: @y = (1, 2, 'three');
         print "$y[2]\n";

prints the word three.

%<variable name> holds an associative array (list of pairs: key,value,key,value,
etc).

example:
%z = ('name','programming languages','department','CISC','course number', 670);
$key = 'course number';
print "$z{$key}\n";
print "$z{'course number'}\n";  # both of these work

prints
670
670

Assignment statements. Like C but,

@x = @y;   assigns a copy of array y to x
$x = @y;   assigns the length of @y to x

$y[3] = 'new value';   works.

Compound statements:

  if (...) {...}       #no 'then'
    elsif (...) {...}  #not 'elseif'
    ...
    else {...};

  while (...) {...}
  until (...) {...}

  In a loop, the command next means continue, last means break.

  for(...;...;...) {...}  as in C.

  foreach $v (@s) {...}  assigns $v to each item in @s in order.
  foreach $v (keys %s) {...} assigns $v to each key in %s.

  Actually, keys is a function that returns an array of the keys in
  the assocative array that it is applied to.

  foreach $v (values %s) {...} assigns $v to each value in %s.

  Values is a function like keys.

  User-defined functions:

  sub <function name>  { ... }  defines function.

  &<function name> (<args>)  a function call.

  In definition of function, the formal parameters are $_[0], $_[1], etc.
  (Parameter values are passed in an array called @_.)
  For local variables, use my($<variable name>) in place of $<variable name>
  the first time the variable is mentioned.

  Comments begin with #, go to end of line

  Operators

  Most C operators work for Perl, including !, &&, ||.
  Additional operators: not, and, or, xor
  x string repeat, e.g., print 'q'x10 prints qqqqqqqqqq.
  string comparisons: lt gt le ge eq ne cmp (cmp returns -1, 0 or 1)
  <=> three-way compare for numbers
  binding operators =~ and !~ (x!~y is like not x=~y)
  <string> =~ m/<regular expr>/<modifier>  tests whether a substring matches
   the regular expr
   (other delimiters besides / can be used)
   (the m is optional if / is the delmiter)
  regular expressions are standard UNIX style
   . (match single char)
   ^ (first char)
   $ (last char)
   $<stringname> (matches the specified string)
   x* (0 or more occurrences of x)
   x+ (1 or more ...)
   x? (x is optional)
   x{n} (x matches n times)
   x{n,} (x matches at least n times)
   x{n,m} (x matches n to m times)
   [xyz] (match x,y or z)
   [^xyz] (match any char except x, y or z)
   [a-z] (match a or b or ... or z)
   x|y (match x or y)

   (subexpressions can have parentheses placed around them; the matching
   subsrings get bound to variables $1 through $9)
   Use \ in front of a special char(like *,+,?,|,$, etc.) if you want to
   match them as ordinary chars.

   some abbreviations:
   \d = [0-9]
   \w = [a-zA-Z_0-9]
   \s = [ \t\n\r\f] whitespace
   \D = [^0-9]
   \W = [^a-zA-Z_0-9]
   \S = [^ \t\n\r\f]

  Option <modifier>
    g = global (allows many matches)
    i = ignore case
    m = allows multiple lines in string
    s = treat string as single line

   example:
    $test = 'nesting';
    $i=0;
    while ($test =~ /n./g) $i++;
      $i = number of matches

   <string > =~ s/<reg. expr>/<replacement>/<modifier> 

  Special variable $_ = the string just read
   /<pattern>/ can be used to mean $_ =~ /<pattern>/

   example: open(INFILE,$theFile);
            while (<INFILE>) {
              if (/magic/) {   # if current line contains the word 'magic'
                $theLine = $_;  # save the line
                chomp($theLine); # get rid of \n char
              ...} ...}

   Some built-in functions:

   push(<arrayname>,<list>) adds <list> of items to end of <arrayname>
     e.g., @x = ();
           push(@x,1,2,'three');
           print @x;
           push(@x,@x);
           print @x;
   pop(<arrayname>)
   unshift(<arrayname>,<list>) adds <list> of items to front of <arrayname>
   shift(<arrayname>)
   chomp(<stringname>), chomp(<arrayname>)  removes line ending char(s) from
     (each) line, returns # of chars deleted
   open(<filehandle>,<<direction> filename>)  returns true if file is opened
    <direction> = < (means read), > (means write), >> (means append)
    e.g., open(OUTFILE,'>generated.txt');
   close(<filehandle>)
   < <filehandle> > evaluates to the next line in file, e.g., <STDIN>
   die(<text>) prints <text> to STDERR and terminats program
   eof(<filehandle>)
   exit(<number>)
   keys(<arrayname>) returns array of keys or number of keys in assoc. array
   length(<string>)
   my(<variables>) makes one or more variables local
   print(<list>)
   print(<filehandle> <list>)  no comma between filehandle and list
     e.g.,

open(IN,'<ptest') or die 'no such file';
open(OUT,'>pcopy');
while (<IN>) {
  print OUT $_;  #copies file
}
close(IN);
close(OUT);

   return(<list>) returns the list or just the first element of the list
   reverse(<list>) returns copy of <list> in reverse order
   split(/<regular expr>/,<string>,<limit>) returns list of substrings
     separated by the substrings matching <regular expr> upto <limit>
     substrings (only <limit>-1 matches to <regular expr> are made);
     if <regular expr> contains subexprs in parentheses, the substrings
     matching these subexprs are included in the list. <limit> argument
     is optional.
    e.g.,

$x='1a23b4';
@y = split(/[a-z]/,$x,2);
print "$y[0]\n"; #prints 1
print "$y[1]\n"; #prints 23b4
print @y;        #prints 123b4
print "\n";
print "@y\n";    #prints 1 23b4
@y = split(/([a-z])/,$x,2);
print @y;        #prints 1a23b4
print "\n";
print "@y\n";    #prints 1 a 23b4

    pos(<variable>) position in string just after where last m//g ended
    substr(<string>,<offset>,<length>) returns the substring containing up to
      <length> chars, starting from position <offset> in <string>. <length>
      is optional.  If <offset> is negative, offset is from end of <string>

    If substr is used on lhs of =, the string will be changed by whatever is
    to the right of the =.

    values(<array>) returns a list of the values in the associative array
    system(<string>) causes the command <string> to be executed by the
      operating system.  Perl waits until the command has finished executing.

    The parentheses around the arguments in a function call and the
    commas separating the arguments can often be omitted; not recommended
    practice except for print and die statements.

    Command line arguments can be accessed through the array variable @ARGV.