perl will use standard input by default and look there for statements it should execute. Thus, to execute Perl statements, you could start up the perl program just by typing in its name^[18]:

    $ perl

The perl interpreter starts up, and silently waits for input. It is possible to type in a number of Perl statements next. Every command in Perl should end in a semicolon; to forget one is a common error, both for experienced and novice users. Thus, a Perl program could look like this:

    print "hello world\n";
    exit 0;

To make perl interpret these statements, terminate the input by typing Ctrl+D on the next line. Now perl will check the statements you typed, check for errors and execute them. If all went well, you will see the following on your screen:

    hello world

Most of the time, you will want to execute a program that consists of statements in a file. It is possible to start up perl, and tell it to execute statements from within a file:

All script files (shell, Perl) are handled the same way: statements are contained in files which have the execution bit set (chmod +x). If the first line of an script contains a hash and an exclamation mark -- #! -- as its first two characters, this denotes that the location of an interpreter follows. The shell will start that interpreter and feed the script to it. For example:

Everything after the first line is Perl speak. Lines beginning with a hash (#) are comments. Remember that statements in Perl should end in a semicolon. Thus, a Perl script could look something like this:

 
    #!/usr/bin/perl

    statement1;
    # a comment line
    statement2;
    statement3;  # end of line comment

Perl statements can also be put in a block. A block consists of a opening curly brace, some statements and a closing curly brace. For instance:

 
    if ($x > 5)
    {
        statement5;
        statement6;
    }

The block is used in several places: each if, for example, must be followed by a block and statements in a subroutine definition will be contained in a block.

Once you have written a Perl program this way, and have set the execution bit on it, you can simply run it by typing the name of the file. Again, perl will check your code first and generate error messages if it finds mistakes.

In many of our examples, we will use the built-in print function. print takes a list containing one or more arguments and prints them. If a file handle (file handles) is placed between the print keyword and the arguments, the arguments are sent to the corresponding file. By default, standard output will be used. The print function does not add newlines or other formatting.

Formatting can be added by including escape characters, or you can use the printf function. C programmers will feel at ease with this function right away. The first string argument to printf is a format string, which is a mixture of normal characters and format directives. Normal characters are simply output as is. Format directives begin with a “%” and are instructions on how to output the next argument from the list of arguments following the format string. Format directives may contain width and precision specification, instructions for left or right justification, and type of data. Please see the Perl documentation (start with perldoc perl. An example:

$v = 10;
$h = 33.6;
printf( "The area of a %f x %f rectangle is %10.3f\n", $v, $h, $v * $h );
    

will print:

The area of a 10 x 33.6 rectangle is    336.000
    

You can store all types of data in variables. An example:

#!/usr/bin/perl

$x = 1;
$y = 2;
$z = 3;

print "$x + $y = $z\n";
   

Any variables in quotes will be evaluated before the print prints out the results. So, running this program results in the following output:

1 + 2 = 3
   

    {
        my($x, $y); # private variables for this block

    }

    use strict;

    #!/usr/bin/perl -w

    use strict;

    $verse = "Some text";

In Perl, the first character of a variable name or variable reference denotes what kind of value the variable may hold. Here are the most common kinds of variables:

The above table names three different variables. In other words, variable $x is a different variable than @x.

12354
-179
0x32    # hexadecimal
027     # octal

12.3
-6.23E27
3E7
.1

    "The world\n"

    'no expansions'

    print 'Some $verse here \n';

    Some $verse here \n

    my $verse = 'hallo there';
    print "Some $verse here\n";

    Some hallo there here

$x = '$t'

$x = "$t"

"Hello World!"
'A bit longer but still a nonsensical string'
''
""

$length = 12.3;
$width = 17;
$area = $length * $width;       # $area should be 209.1

$colour = "blue";
$shade = "dark";
$description = $shade . " " . $colour

()                    # the empty list, or array
(1,2,3)               # an array of three integers
(1,'fred',27.1,3*5)

@one = (1, 2, 3);
@two = (4, 5, 6);
@both = (@one, @two);
      

@vec = (3,4,5);
$sum = $vec[0] + $vec[2];
$vec[1] = $sum;
      

@vec = (5,10,15);

    my $size = @somearray;
    my $size = scalar @somearray;

0 - - 3 - - - - - - a
      |     c
      |    /
      |  (X)  $c[4]
      |  /    $b[7]->[4]
      | /     $a[3]->[7]->[4] 
      |/ 
      7
      |
      |
      b
      

    %box = ("len", 100, "height", 40, "width", 20, "colour", "blue");

    %box = ("len" => 100, "height" => 40, "width", 20, "colour" => "blue");

    print "height is ", $box{'height'};

    height is 40

    $box{'volume'} = $box{'width'} * $box{'length'} * $box{'height'};

Operators allow a combination of constants and variables. There are many common operators, however we will only discuss the most important ones. The precedence of the operations are largely intuitive. Precedence of operations can be overridden by the use of parentheses. When in doubt, use parentheses to prevent ambiguity as a last resort. Check the Perl syntax first.

Numerical operators.  Numerical operators expect numbers as arguments and return numbers as results. The basic numeric operators are: + - * / **, (the last one means exponentiation). Additionally, these operators may be combined with the “=” equal sign, to form C-style operators such as += -= *= **=:

$n   = 8;
$n **= 3;  # same as: $n = $n ** 3;
print $n;  # 512 (8 * 8 * 8).. 

Among the built-in numeric functions are: cos, sin, exp, log and sqrt. Additionally, the increment-by-one (++) and decrement-by-one (--) operators are used in Perl in the same way as they are used in C. As in the C language, their placement is of importance:

$m = 1;
 
print $m++ . " ";   # print value first, than increment..
print $m   . " ";   # print incremented value ..
print ++$m . " ";   # increment first, then print new value.. 
print $m   . " \n"; # print value;
    

This would result in the printing of the range: 1 2 3 3

String concatenation operator.  To add strings, use the string concatenation operator: . (a dot). It denotes string concatenation:

    $i = 'hi';
    $o = 'ho';
    $song = $i . $o;

Variable $song will now contain hiho.

Boolean operators.  There is no special data type that signifies Boolean values. There are just values that mean false: the zero or null values. More specifically, they are:

    ""      null string
    "0"     string
    0       integer
    0.0     float
    ()      empty array or list

A variable can be set to undef, meaning that it is completely undefined. Everything that is not zero, null, empty or undef will mean true. There are a number of operators that explicitly produce Boolean results: these always produce 0 to indicate false and 1 to indicate true. The most common are:

    ||  or
    &&  and
    !   not

The first two are short-circuit operators; the right operand is not evaluated if the answer can be determinded solely from the left operand. The “not” operator ! reverses the value of its only operand: true will become false, vice versa.

Numeric Comparisons.  For comparing numbers, you can use:

 
    <   less
    <=  less or equal
    ==  equals
    !=  not equal
    >=  bigger or equal 
    >   bigger

String Comparisons.  The commonly used ones:

    lt  lesser than
    le  lesser or equal
    eq  equals (identical)
    ne  not equal
    ge  greater or equal
    gt  greater than

The operators eq and ne are used for direct string comparisons. The others are used mainly in sorting. To perform more sophisticated string comparisons in Perl, use pattern matching. Perl permits the use of powerful pattern-matching operators: =~ and !~ for does match and does not match respectively.

Regular Expressions are probably the most important feature of Perl. Regular Expressions in general are described in the section called “Regular Expressions”. Be sure to read the part about Perl Regular Expression extensions (see the section called “Perl Regular Expressions”). This section shows how to apply Regular Expressions in Perl.

To match a Regular Expression against a variable, a statement must be created consisting of

A comparison statement can look as follows:

    $some =~ /^[A-Z]/

This is not complete: the result of the comparison must be handled as well. In the following example the Boolean result of the above statement is evaluated (with an if statement). The result is either true or false. If true (if the contents of $some starts with an uppercase letter), the block is entered:

    if ($some =~ /^[A-Z]/)
    {
        # match: do something
    }

If both variable and binding operator are omitted, the comparison is done against the contents of the so-called default variable $_:

    if (/^[A-Z]/)
    {
        # RE matches on $_: do something
    }

Of course, if the Regular Expression matches, pseudo variables like $&, $1, etc. can be inspected, as described in the section called “Perl Regular Expressions”.

There is also the reverse of the binding operator: the !~. Its result is true if the Regular Expression does not match the contents of the variable. In the example below, the block is entered when the contents of $some does not start with an uppercase letter:

    if ($some !~ /^[A-Z]/)
    {
        # if no match: do something
    }

When matching against $_ the not operator ! can be used instead:

    if (!/^[A-Z]/)
    {
        # RE does not match on $_
    }

Another way to check if a variable matches is to inspect the results of the match. This will only work if grouping (see the section called “Perl Regular Expressions”) is used. The following is an example:

    my @results = $input =~ /^([A-Z])([a-z]+)/;

    if (@results)
    {
        # RE matched!
        print "1st part: $results[0], 2nd part $results[1]\n";
    }

Perl programs may need to refer to specific input or output streams or files. The variables that name them are, by convention, always rendered in uppercase. Output files can be explicitly created by the open function. For example, to open a file named prog.dat you would use:

    open(OUT, ">prog.dat") || die "$0: open prog.dat for writing failed: $!";

This associates the file handle OUT with the file. The leading “>” signifies that the file will be emptied (if it did exist) or created. Use “>>” to instead append to the file.

Now, you can use the file handle to write something to the file:

    print OUT ("A test");

This will open and empty the file and will write “A test” to it. There is no comma between the file handle and the first string argument.

Standard input is opened automatically and can be referenced via the predefined handle called “STDOUT”. STDOUT will be used by printf and print if no file handle was specified. Another automatically opened handle is STDERR (standard error).

A file can be closed using the close keyword:

    close(OUT);

File handles can also be used when reading from a file.

    my $file = 'listOfNames';
    open(IN, "<$file") || die "$0: unable to open $file for reading";

The initial < can be omitted.

To read from the file, use the file handle surrounded by < and >. There is, however, something to watch out for: scalar versus array context. If the handle is read in scalar context, exactly one line is read:

    my $line = <IN>;

When this is used again, the next line is read and so on. In array context however, all lines will be read at once. The following, for example, will do exactly that:

    my @allLines = <IN>;

The method of reading input line-by-line is often used in combination with a while keyword:

    while (<IN>)
    {
        # most recent line read in $_
        print $_;
    }

This example reads each line and prints it, until no more lines can be read.

Don't forget to close the handles again:

    close(IN);

A predefined file handle is STDIN for standard input. It is opened for reading. It can be used like any other handle.

A commonly used construction is <>. It operates as follows:

In applications it might be used like this:

    while (<>)
    {
        ...statement(s)...
    }

This will read either from named files (given as arguments) or from standard input. While inside the while loop, a special predefined variable $ARGV contains the name of the file that is being read (standard input is indicated by a dash (-)).

A very powerful Perl facility is the process handle. It works exactly like a file handle but refers to a process instead. Process handles can be opened for reading or for writing.

The following code will open a WHO handle that is associated with a running who program.

    open (WHO, "who|") || die "cannot start who: $!";

    my @whoLines = <WHO>;

    close (WHO);

    print "There are currently ", scalar @whoLines, " users logged in\n";

The | symbol indicates that this is a process to be opened. By placing the | at the end, we tell Perl that we want to read from the process.

Of course, there are also writable process handles. A typical application might be writing a message (collected earlier) to a mail program:

    open (MAIL, "|mutt -s \"log report\" $mailto") || 
        die "cannot start mutt: $!";

    print MAIL @messageLines;

    close (MAIL);

This time the | is at the beginning, indicating that the handle should be open for writing. The message is sent after the close statement has been processed.

Perl supports a number of loop constructs. Let's study the following example, in which we also recapitulate a number of the other things we've learned so far. The numbers in the left margin are for reference purposes only and do not belong to the code.

  /----------------------------------------------------------------
  |
1 |   open ( PW, "</etc/passwd") || die "Eh..? Can't read /etc/passwd?";
2 |   while ( @a = split (':', <PW>) ) {
3 |      foreach $x ( @a ) { print $x . " "; }
4 |      print "\n";
5 |   }
6 |   close( PW );
  |
    

In line 1, the main logic functionality is determined by a boolean expression: the || ('or' operator) with two operands. The operands are functions in this case, but that is all perfectly legal in the Perl language. Remember that booleans act as short-circuit operators: the right operand is not evaluated if the answer can be determined solely from the left operand. Therefore, if the open succeeds, the die function will never be called. When open fails, the first part of the boolean expression is false and, therefore, the second part of the expression should be parsed (the die function will be called) and the script will terminate. For now, let's assume that the function opened the password file successfully. The file handle PW is now associated with it.

Line 2 contains a “while” loop. A “while” statement uses a test expression as its argument and executes its block every time the expression evaluates to true. A test expression is evaluated before every iteration, so the block may get executed 0 times. The core of the test expression is the split function. The split will take a string (its second argument) and split it into chunks, delimited by one of the characters as specified in the first argument (in our case, a colon). In our example, split fetches the input string directly from the file using the file handle “PW”. The test expression evaluates to true as long as the array “@a” is filled by the split, which is the case as long as split is able to read from the file.

Line 3 gives an example of the foreach loop. The foreach loop provides a handy way to cycle through all elements of an array in order. It takes 2 arguments: the variable where an element of the array should be put in and the name of the array within parentheses. The loop cycles through all values in the array (effectively: all fields in the line from the password file) and stashes each field in $x, one field per iteration. The value is printed next.

Line 4 just prints a newline after each line that was read and parsed from the password file.

Line 5 terminates the “while” loop and

Line 6 closes the file associated with the file handle “PW”.

Another example further clarifies the use of the foreach loop and introduces the range operator (three dots in a row) and the concept of lists:

@a = ("a"..."z","A"..."Z");
foreach $n (@a) {
    print $n;
}
    

In the first line, the array @a is filled with the elements of a list. A list is simply a listing of values. In this case, the list is formed by specifying two ranges, namely the range of all letters from "a" to "z" and the second range of all letters from "A" to "Z". The array @a will contain 52 elements. The foreach loops through all values in the array, one per iteration, and prints the resulting value to standard output (since we did not specify a file handle).

abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ
    

The for loop is the third type of loop. It is identical to the C “for” construct. The general structure is:

A for statement can easily be rewritten using while:

    my $i;                            my $i = 0;
    for($i = 0; $i < 20; $i++)        while ($i < 20)
    {                                 {
        print "\$i: $i\n";                print "\$i: $i\n";
                                          $i++;
    }                                 }

The test is performed before every iteration, so the block may be executed 0 times. Here, for example, is a way to print a table of squares, using the printf function:

    for($n = 1; $n <= 10; ++$n) 
    {
        printf("%d squared is %d\n", $n, $n * $n);
    }

Perl supports the if statement:

    if( $le < 10.0 ) 
    {
        print("Length $le is too small\n");
    }

Each test expression must be followed by a statement block. Blocks do not have to end with a semicolon. The following is functionally equivalent to our example above:

    print( "Length $le is too small!\n" ) if ($le < 10.0);

There are “else” and “elsif” keywords too:

    if( $le < 10.0 ) 
    {
        print( "Length $le is too small!\n" );
    }
    elsif( $le > 100.0 ) 
    {
        print( "Length $le is too big!\n" );
    }
    else
    {
        print( "Length is just right!\n" );
    }
    

Note that if, elsif and else must be followed by a block, even for one statement.

You can even use short-circuit boolean operators, as in:

    $l < 10.0 && print("Length $le is too small!\n");

This kind of expression is particularly useful when you have to take an exceptional action after something (such as opening an input file) fails:

    open(IN,"<foo.dat") || die("Unable to open foo.dat: $!");

written equivalently, but less readably, as:

    die("Unable to open foo.dat: $!") if !open(IN,"<foo.dat");