The following points may seem obvious, but they're things which aren't often pointed out. If they're too dull for you to deal with, then by all means skip down.

• You can read it (r) i.e. look at the file's contents
• You can write it (w) i.e modify the file's contents
• If it's a program, you can execute it (x) i.e. run the program

Odd name, isn't it? That's Unix for ya.

This following are the things that every Perl programmer needs to become extremely well aquainted with. They're commands and concepts that you'll use every time you write a Perl script.

Print

print "Hello World!";

Commenting

# This simple script just prints Hello World! on the screen

print "Hello World!";

Input from the User

A Variable is probably a familiar concept to anyone who's ever done any programming, but for those of you who haven't, try this analogy on for size: Think of a small set of draws - the kind of thing your Dad might have in his shed for keeping washers and bolts and nails and other little bits and pieces in. Each of those draws has a lable on it, so you can tell what's inside it, right? And probably there's draws of different sizes, to accommodate different sized "things". Well, a variable is like one of those little draws. It's just a place to store something, and is labled so that we know what's in it. A variable (draw) can be almost any size you like, to hold one small nail or an entire elephant (though I imagine your Dad probably doesn't have any elephants in the draws in his shed!)

Creating a Scalar Variable is all very well if we want to store one person's name. But what if we want to store a list of names? Of course, we could define a whole load of variables, called $Name1, $Name2, $Name3 etc, but this would get confusing and use an awful lot of code to do something very simple.

A more economical and tidy way to achieve this would be to set up a List.

Just as the names of scalar variables always start with a dollar sign ($), the names of Lists always begin with an at symbol (@), for example, we might define a list called @Names.

We can define a list either as empty or with elements in it. To define a list as empty, we can just say:

@Names = ();

To define the same list, but put some elements into it, all we need to do is supply the list of what we want to put in our list, inside those brackets (parentheses, to the americans among my audience) quoting them and separating them with commas, like this:

@Names = ("Andy","Bill","Colin","Dave");

In Perl, there's actually another way to do this same thing. We can use the qw (Quote Word) construct, which does the same thing, but without the brackets (parentheses), quotes and commas. To achieve the same thing as above, but using qw, we would start and terminate the list of items with a forward slash (/) and separate each item in the list with a space, like this:

@Names = qw/Andy Bill Colin Dave/;

The disadvantage of using this method, is that there's no way to differentiate between two separate items in the list, and an item made up of two words.

This is all very well if we know the elements we want in our list when we're writing the code, of course, but what if we don't? Well, we can put elements in the list by using scalar variables. Let's assume that we've got a variable called $User, and at some point in our program, we're going to ask the user to enter their name and the program will store it in $User. We could put their name into our @Names list like this:

@Names = ($User);

Or if we wanted to put it at a specific place in that list, we could do this:

@Names[4] = ($User);

See the difference? The second example tells Perl where to put the item, that's what the [4] bit is doing. It's important to point out that Perl counts from 0, so position 4 actually holds the fifth item in the list (the first item in the list is at position 0)

If you wanted to get really funky, you could even initialise a list by using another list. It doesn't matter too much if you don't get that idea right now, but let's see if you can understand this example:

@WildAnimals = ("Tiger","Polar Bear","Duck-Billed Platipuss");
@Pets = ("Cat","Dog","Chinese Water Dragon");
@MoreAnimals = ("Fox",@WildAnimals,"Kangaroo",@Pets,"Donkey");

In this case, our @MoreAnimals list would end up looking like this:

Fox
Tiger
Polar Bear
Duck-Billed Platipuss
Kangaroo
Cat
Dog
Chinese Water Dragon
Donkey

Actually, to be pedantic, if we tried to print our @MoreAnimals list to screen by saying

Print @MoreAnimals;

We'd actually end up with this:

FoxTigerPolar BearDuck-Billed PlatipussKangarooCatDogChinese Water DragonDonkey

None too pretty, I think you'll agree. To tell Perl we want to have the list items separated by something, we can tell it what we want Perl to space the items out with by using the function join(). So if we said:

Print join(", ", @MoreAnimals);

The list would end up looking like this:

Fox, Tiger, Polar Bear, Duck-Billed Platipuss, Kangaroo, Cat, Dog, Chinese Water Dragon, Donkey

Print join("\n", @MoreAnimals);

To tell Perl to print out each list item on a new line as we did above

Note to the reader - I'm trying to sort the following out in my head at the moment (with regards to what the actual operators are etc). The principles I've outlined here about Concatenation are sound, but the syntax I use may not be, so please don't take the next bit as gospel.

Complicated word, but all it basically means is 'tagging one thing onto the end of another'. In Perl, the "Concatenation Operator" (that is, the symbol you use to tell Perl to string two strings of text together) is a Full Stop (or Period) also known to techie folk as "dot". For example, consider the following example:

$FirstName = "Joe";
$LastName = "Bloggs";
$FullName = $FirstName . " " . $LastName;

Those first two lines should be fairly easy to understand - they set up two variables, one called $FirstName, which contains the string "Joe" and the other called $LastName, which contains the string "Bloggs".

The last line of that little script, however, does several things in quick sucession. It sets up a variable called $FullName, then it puts the data from the variable $FirstName into the newly created variable $FullName, then it tags a space on the end of the current contents of our $FullName variable (hence the double quotes with a space between them), and finally it tags the contents of the variable $LastName onto the end of $FullName. So $FullName ends up containing the string "Joe Bloggs"

Easy when you know how, eh?

So, what do you think happens in this following script:

$WeeklyWage = "300";
$Raise = "90";
$NewEarnings = $WeeklyWage .= $Raise;

If you guessed that $WeeklyWage ends up as 390, I'm afraid you're wrong. We're dealing with text strings and concatenation, so we've actually made $WeeklyWage 30090. I don't know about you, but I'd be quite happy with a weekly wage of £30,090!

The Control Structure is one of the basic tenets of Programming, so the chances are that anyone who knows anything about programming will already know what control structures are and how they benefit the programmer. For those of you who aren't already au fait with the concept, however, here's the low down.

One of the most usful things about a computer program is that you can give it instructions like:

• Keep on doing what you're doing until I tell you to stop
• Carry on performing this task until you run out of things to perform it on
• If such-and-such a thing happens, do one thing, otherwise do something else

A major part of any programming language is it's operators. They're what you use to tell the computer what to do with all these nice bits of data. In Perl, the common operators are as follows:

Operator Function	Symbol(s) used	Description	Example
Arithmetic Operators
Multiplication	* (asterisk or "star")	Multiplies numbers	3 * 2 result 6
Addition	+	Adds numbers	3 + 2 result 5
Subtraction	-	Subtracts the second number from the first	3 - 2 result 1
Division	/ (forward slash)	Divides the first number by the second	3 / 2 result 1.5
Modulus	% (percent)	not sure	check back soon
Exponentiation	** (two asterisks or "stars" with no space separating them)	not sure	check back soon
String (i.e. Text) Operators
Concatenation	. (dot)	Adds one piece of text (e.g. the contents of a variable) onto another	$a="Hello,"; $b="World!"; print $a . $b; results in the text Hello, World! printed to the screen
Multiply (string)	x	Repeats a specified string a given number of times	print "Hello!\n" x 3; will print Hello! three times (on separate lines)
Assignment Operators
Assignment	=	read as "gets set to"	$Number = 5 puts the value 5 in the variable $Number
Increment	{any operator}=	Adds the current value of a string (or whatever) to whatever you want to add something to	$a="Hello,"; $b="World!"; $a .= $b; adds the contents of $b onto the end of the contents of $a, so that $a ends up as "Hello, World!" (while $b still contains "World!" Please note that incrementation works with almost any operator, for example: $a *= 3 means multiply the current value of $a by three and store the result in $a $counter += 1 means add 1 to the value of $counter and store the result in $counter $FirstBit .= $NextBit means add the contents of the variable $NextBit onto the end of the current contents of the variable $FirstBit and store the result in $FirstBit
Increment / Decrement by 1	++ or -- (respectively)	Can be placed before or after a variable and adds or subtracts exactly 1 to or from it	$Age++ makes $Age equal to $Age plus 1 This form of increment is special, because placing it before or after the variable effects what value is returned from an expression, so that: $cows=5; $sheep = ++ $cows; does the following: First, it assigns the value 5 to the variable $cows. Next, it adds 1 to the value of $cows and stores the value in $cows plus it assigns the (now incremented) value of $cows to $sheep, so both $cows and $sheep end up being 6. However, $cows=5; $sheep = $cows ++; would do this: First, it assigns the value 5 to the variable $cows. Next, it it assigns the value of $cows to $sheep then it increments $cows, so $sheep was assigned the value of $cows before $cows was incremented, so although $cows ends up being 6, $sheep is 5.
Logical (i.e. Boolean) Operators
Logical AND	&& (double ampersand)	The expression will evaluate to true if both sides are true	$a && $b For a variable to be considered true, it has to have been defined and not be equal to zero (whether it's a string or a number). So I think the following is how this expression would work: $a = 4; $b = 7 $a && $b Would return a value of true (because they've both been defined) however, $a = 4; $a && $b Would return a value of false (because only $a has been defined)
Logical OR	|| (double "pipe" or vertical bar character	The expression will evaluate to true if one of the sides is true)	Works similarly to the logical AND
Logical NOT	! (Exclaimation mark)	The expression will evaluate to true if the variable is false, and false if it's true	$a = 4; !a$ evaluates to false
Comparison Operators
I haven't got this far yet - check back soon