By: Boris Mordkovich

March 15th, 2001

Reader Rating: 8

Perl is short for Practical Extraction and Report Language. It's a language that is available free over the Web, and it's used for a variety of things, from writing CGI scripts to assisting administrators in maintaining their systems. Perl was created, and is still maintained, by Larry Wall. It's slower than C, but faster than a normal interpreted language. Instead, it's compiled when executed and then interpreted. A Perl compiler does exist but it's still under development. For more information on compiled Perl go to the Perl Home Page [1].

As I mentioned earlier, one of the nice things about Perl is that it's free. It's distributed under the GNU license, and the source is available from the Perl Home Page. This, along with the fact that it's flexible and has very few constraints, helps make Perl a popular language. It's also highly platform-independent, and has been ported to many different platforms including Unix, Windows, and even DOS. Code modifications can be minor or major depending on any system specific functions that are used.

Perl's popularity has also been encouraged by the fact that you can find support in a variety of places. At the top of the list is the comp.lang.perl/#nlt#/Perl Newsgroup [2], which is moderated by a number of Perl experts.

Perl and CGI

This is a brief explanation of Perl and CGI. If you have, or want to, put up your own web site, you'll have heard of HTML, Javascript, Java, and CGI. CGI stands for the Common Gateway Interface. CGI is unlike Javascript, HTML, and Client Side Java. CGI provides a standard method for programs written in any language to run on the server side, and to communicate with the Web server software in response to requests for Web pages. In other words, CGI is the part of your web site that communicates with the other programs running on your server.

The main purpose of writing CGI programs or scripts is to afford more interactivity on your web site. Many web sites are static, and don't allow much user interaction. Others have guestbooks, image counters, and allow you to place orders, access databases, and other useful applications.

This is where CGI comes in. In order to implement these types of interactivity, you must have an application running on the server that, for example, knows how to process certain types of user input. As I mentioned, CGI scripts can be written in any language, but the most common are Perl and C. Perl is the preferred language for writing CGI scripts because of its strength in string manipulation. And now other programming languages such as Java and PHP are also gaining popularity, as they provide interactivity without the use of CGI.

CGI programming is nothing more than programming with some special types of input, and a few very strict rules for program output. When a user fills out a FORM (a collection of HTML tags that allow them to submit input) the server sends the form input to the specified CGI program, which in turn parses the entered data and uses it in a specified manner, and returns HTML with an answer to the user's request.

When you're choosing a language in which to write CGI scripts, ensure that the language you select:

• Makes text manipulation easy
• Is able to interface with other software utilities and libraries
• Is able to access your operating system's environment variables

Perl satisfies all the above requirements, making it a very good language for CGI programming. If you want to write your own CGI scripts, I'd suggest that you use Perl -- you'll find that it will make your life a lot easier. If you want to get more detail on CGI and how it works, try the CGI specification on the NCSA site [3] (be aware, this is a pretty technical description aimed at experienced programmers).

Running a Perl Program

Note: This will not teach you everything about Perl but it should give you a good idea of how the language works, and how to program in Perl.

Running a Perl program is relatively simple. Once you have a program written out, all you have to do is to invoke the Perl interpreter, along with the filename.

perl filename.pl

If you are running on a unix system, you can make the file executable using the chmod +rx function call. In order to do this, you must have the following line as the first line in your Perl program.

#! /usr/local/bin/perl

Where "/usr/local/bin/perl" is the path of your Perl interpreter. In order to find this path on UNIX just type:

which perl

on the command line.

Let's practice writing a small program at our console. Using any editor type the following code:

#! /usr/local/bin/perl

print "Hello World!\\n\";

Now save your program with a .pl extension. Let's call it hello.pl. From the command line then type:

perl hello.pl

You should then see the following output:

Hello World!

You have just written your first Perl program. Congratulations!

Literals

Perl literals are values that are represented as-is. The value is considered to be hard-coded into the program. Perl supports literals of the following two types:

• Numbers
• Strings

Numeric literals represent numbers. Strings literals are used to identify names, text, or messages that are displayed in the program. String literals are usually enclosed in single quotes, which means that any variable names (more on variables below) appearing in them are not interpolated. Double quoted string literals are also supported, and they support what is called variable interpolation, meaning that variable names are substituted for their real values. Single backquoted string literals are also supported. These normally allow you to run command line options and return the output to your program.

Perl also supports comments in your code. A perl comment is signified by a # sign. When you see a # sign, it means that everything after that is a comment up to the end of the line.

Variables

All programming languages support variables. Variables are like string literals, except that they hold a specific value or values. Perl supports three sets of variables:

• Scalars The scalar variables hold only one value, which may be a numeric literal, or a string literal. Scalar variable names always begin with a $ sign.
• Arrays An array variable can hold a list, or an array of values. The values can be numbers or strings. A key or subscript value is automatically assigned, and the values are kept in the order entered. Array variable names start with an @ sign.
• Associative Arrays Associative arrays or hashes as they're also known, are similar to arrays. But the major difference is that you, the programmer, assign the key and value to the hash, while an array automatically assigns a key. Hashes do not keep the entered items in the same order as they were entered. Hash variables always start with the % sign.

As mentioned above, scalar values are used to track a single pieces of information. Perl's most commonly used variable is $_. This special variable name is called the default variable for Perl's many functions, so become very familiar with it.

We can see a value being assigned to a scalar value in the following example along with interpolation.

$var="my Scalar Variable";

print "This is $var";

The output of the above code would be: This is my Scalar Variable

Arrays hold a list of variables and are handled in a variety of different ways. You can give the values to the array during initialization:

@array=('one','two','three');

The above array assigns three values into the array. The values are separated by commas. The first subscript of an array is always 0, unless you change it with special variable $[. This is generally not good practice, because you can confuse people reading your code. In order to read the value, you would refer to the array name and the subscript that you want. For example, if we wanted the value 'two' we would say:

print $array[1];

We say $array because we are referring to only one value, followed by an open bracket, the subscript that we want, and then the close bracket. This would return the second value in your array.

Hashes can be initialized in a similar manner to arrays.

%hash=('key1','value1','key2','value2','key3','value3');

The major difference is that you have to place the values in a key-value order. So the first value you type would be the first key; the second, the associated value; the third, the second key; and the fourth, the value associated with that key. The process of retrieving the value from a hash, is similar to an array, except that instead of using [ ] (square brackets) we would use { } (braces), and instead of the subscript number, we would use the key. If we wanted to retrieve 'value2', we would use the following:

print $hash{'key2'};

Be aware that Perl variables are case-sensitive, so $me, $Me, $mE and $ME are four separate variables. Similarly, if you had a scalar variable called $me, an array called @me, and a hash called %me, they would be interpreted as three separate variables, not the same one.

Operators

Perl supports the same set of operators as most other computer languages. Operators allow a computer language to perform actions on operands. As in every computer language, Perl operators also have a certain precedence.

We've already encountered the assignment operator (=). This operator assigns a value from one variable to another:

$string1 = $string2;

The above code assigns the value of $string2 to $string1. We will now consider binary and unary arithmatic operators.

• op1 + op2 The addition operator will add two numbers.
• op1 - op2 The subtraction operator will subtract two numbers.
• op1 * op2 The multiplication operator will multiply two numbers.
• op1 / op2 The division operator will divide two numbers.
• op1 % op2 The modulus operator will return the remainder of the division of two integer operands.
• op1 xx op2 The exponentiation operator will raise op1 to the power of op2.
• ++op1 The pre-increpment operator will increase the value of op1 first, then assign it.
• op1++ The post-increment operator will increase the value of op1 after it is assigned.
• --op1 The pre-decrement operator will decrease the value of op1 before it is assigned.
• op1-- The post-decrement operator will decrease the value of op1 after it is assigned.

The logical operators are used mainly to control the flow of the program. Some of the logical operators that Perl supports include:

• && The AND operator takes two values, and will return true only if both values are true.
• || The OR operator takes two values, and will return true only if at least one value is true.
• ! The NOT operator will negate a value.
• op1 == op2 The equals operator checks for the equality of two numerical values.
• op1 != op2 This not-equals operator checks for the inequality of two numerical values.
• op1 < op2 This numerical operator will return true if op1 is less than op2.
• op1 > op2 This numerical operator will return true if op1 is greater than op2.
• op1 <= op2 This numerical operator will return true if op1 is less than or equal to op2.
• op1 >= op2 This numerical operator will return true if op1 is greater than or equal to op2
• op1 <=> op2 This numerical operator will return -1 if op1 is less than op2, it will return 0 if they are equal, and it will return 1 if op2 is greater than op1.
• op1 eq op2 This string operator will return true if the two strings are equal.
• op1 ne op2 This string operator will return true if both strings are not equal.
• op1 lt op2 This string operator will return true if op1 is less than op2.
• op1 le op2 This string operator will return true if op1 is less than or equal to op2.
• op1 gt op2 This string operator will return true if op1 is greater than op2.
• op1 ge op2 This string operator will return true if op1 is greater than or equal to op2.
• op1 cmp op2 This string operator functions in the same manner as the numerical <=> operator described above.

There are other operators which can also be used in Perl. We have the concatenation operator for strings (.):

$string1 . $string2

The above code will concatenate $string1 with $string2 to form a new string.

We also have the repetition operator (x), this operator will repeat a string a certain number of times specified:

$string1 x 2;

The above code will repeat $string1 twice.

The range operator allows us to use ranges, in arrays or patters:

@array = (1..50);

The above code will assign 50 elements to the array.

As we have already seen, we have a wide variety of operators that work with scalar values, but if we wanted to work with arrays we could do what is called "array splicing". Let's say we have an array with 10 values. If we want to assign values 5 and 6 to two scalar values we could do the following:

($one,$two) = @array[4,5]; #remember that arrays start at subscript 0.

In the above code we just spliced two values from the array. When we do array splicing we use the @ sign, followed by the array name, followed by brackets and the subscripts that you want separated by commas. So instead of having two lines for the above code we have one. We need to enclose the two scalar values in parentheses in order to group them.

Functions

Functions are used to organize your code into small pieces which can be reused. Perl declares functions using the sub keyword followed by the { sign to start the function and the } to end it:

sub function1 {    
   
 CODE HERE    
   
}

In order to call a Perl function it's suggested that you call it using the & sign followed by the function name. If you have parameters, they can be also passed, so it's suggested that you enclose them in parentheses:

&function1;

In Perl, functions can serve as procedures which do not return a value (in reality they do, but that will be discussed later), or functions which do return a value. The above example is of a function that acts as a procedure. Below is an example of a function that acts as a function, because it returns a value (we are also passing values to the function):

$answer = &add(1,2);

You aren't limited to passing only scalar values to a function. You can also pass it arrays, but it will be easier to pass them at the end.

Perl functions receive their values in an array: @_

This array holds all the values of the parameters passed to the function. So in the above example, where we had 2 values passed, we would retrieve them in the following manner:

sub function1 {    
   
 ($val1, $val2) = @_;    
   
}

or we could do it in this manner:

sub function1 {    
   
 $val1=$_[0];    
   
 $val2=$_[1];    
   
}

The parameters are being passed by value, meaning that you will be working with copies of the original parameters and not the actual parameters themselves. If you wish to pass them by reference, then you would have to work directly with the variable ($_[subscript]).

Perl's scope of variables is different than most other languages. You don't have to declare your variables at the beginning of the program, or in the functions: you just use them. The scope of the variables is always global. If you use a variable in a function, it is global to the rest of the program. If you want the variable to be seen only by code within that particular function (and any other functions it may call), then you must declare it as a local variable:

sub function1 {    
   
 local($myvar)    
   
}

The above code will declare $myvar as local, so it can't be seen by the rest of the program.

Functions can also be nested within each other, and you can create recursive functions that call themselves.

Control Statements

Perl has a variety of control statements, which allow you to control how your program runs, and what statements control each step.

The first statement that we'll cover is the if statement. The if statement allows you to set a condition. The syntax is:

if (condition) {    
   
 STATEMENTS    
   
}

The logic is as follows: if the condition returns a true value, then execute the statements in the block, otherwise do not execute anything. The if statement goes beyond that, allowing you to have an else statement:

if (condition) {    
   
 STATEMENTS    
   
} else {    
   
 STATEMENTS    
   
}

The else part of the above if statement will be executed only if the condition in our initial if statement is false. We can also improve this, and add more flexibility, by having multiple if statements:

if (condition){    
   
 STATEMENTS    
   
} elsif (condition){    
   
 STATEMENTS    
   
} else {    
   
 STATEMENTS    
   
}

Now we can run multiple tests, and choose from a variety of options as to what to execute.

Another type of control statement that Perl offers are loop statements, which allow us to execute blocks of instructions a certain number of times. Let's take a look at some of these statements:

While loops can be used in a couple of ways. We can test for our condition at the beginning or end of the loop. The syntax for testing the condition at the beginning of the loop is:

while (condition) {    
   
 STATEMENTS    
   
}

The condition will be tested first. If it is true then the statements will be executed, otherwise, they will be skipped. If the statements are executed, then the condition is tested again to see if they should be executed again. This continues until the condition is false.

The syntax for testing the condition at the end is:

do {    
   
 STATEMENTS    
   
} while (condition);

If you decide test at the end of the loop, the statements will execute at least once.

Another type of loop is the until loop. Unlike the while loop, the until loop is used to execute certain statements while some condition is false. But, just like the while loop, we can test the condition at the beginning and at the end of the loop:

until (condition) {    
   
 STATEMENTS    
   
}

If we want to test the condition of the loop at end:

do {    
   
 STATEMENTS    
   
} until (condition);

Another very powerful loop is the for loop. Unlike the while and until loops, where we don't know how many times we'll reiterate the statements, the for loop is normally used to iterate through a specific number of loops. The syntax is:

for (INITIALIZATION; CONDITION; INCREMENT/DECREMENT) {    
   
 STATEMENTS    
   
}

The initialization expression is executed first. It can be used to initialize the variables inside the loop. The condition expression is used as the test that will tell us whether we should exit the loop or not, and the increment/decrement operator is used to increase our initial value or any other value we choose.

The last type of loop that we'll discuss is the foreach loop. Since one of the most powerful things in Perl is the manipulation of arrays, we must, of course, have a loop that allows us to cycle through an array or hash. The syntax for the foreach loop is:

foreach LOOP_VAR (ARRAY) {    
   
 STATEMENTS    
   
}

The LOOP_VAR variable is optional. If none is indicated, then the default variable $_ is used. ARRAY is the name of our array. If we're using a hash, we'll need to be able to retrieve a scalar value, so we'd have to use the function "keys" or "values" along with the hash, in order to be able to retrieve a scalar value. The value retrieved is stored in LOOP_VAR (or $_), which we can then manipulate in our statements.

There are also certain keywords that we can use within loops: