Robert's Perl Tutorial

The location of this document=20 is http://www.sthomas.net/roberts-perl-tutorial.htm mirrored=20 from http://www.netcat.co.uk/rob/perl/win32perltut.html · wit= h=20 permission.

while =
(<DATFILE>) {
	printf "%2s : $_",$.;
}

print =
"My first Perl script\n";     
print "My first Perl =
script";
#!c:/perl/perl.exe

print "I'm a cool Perl hacker\n";

$string=3D"perl";
$num1=3D20;
$num2=3D10.75;
print "The string is $string, number 1 is $num1 and number 2 is =
$num2\n";

$string=3D"perl";
$num1=3D20;
$num2=3D10.75;
print "The string is $string, number 1 is $num1 and number 2 is =
$num2\n";

$string=3D"perl";
$num=3D20;
print "Doubles: The string is $string and the number is $num\n";
print 'Singles: The string is $string and the number is $num\n';

$num=3D10;
print "\$num is $num\n";

$num++;
print "\$num is $num\n";

$num--;
print "\$num is $num\n";

$num+=3D3;
print "\$num is $num\n";

print "the MS-DOS =
path is c:\\scripts\\";

$string=3D"perl";
$num=3D20;
$mx=3D3;

print "The string is $string and the number is $num\n";

$num*=3D$mx;
$string++;
print "The string is $string and the number is $num\n";

Note the easy shortcut *=3D meaning 'multiply $num by $mx' =
or, $num=3D$num*$mx .
Of course Perl supports the usual + - * / ** =
% operators. The last two are
exponentiation (to the power of) and modulus (remainder of x divided by =
y).
Also note the way you can increment a string ! Is this language flexible =
or what ?=20

print "a =
doublequoted string ", $var, 'that was a variable called var', $num," =
and a newline \n";

Of course, you just put all the above inside a single=20
doublequoted string: 
print "a =
doublequoted string $var that was a variable called var $num and a =
newline \n";

to achieve the same effect. The advantage of using the =
print function in list context
is that expressions are evaluated before being printed. For example, try =
this: 
$var=3D"Perl";
$num=3D10;
print "Two \$nums are $num * 2 and adding one to \$var makes $var++\n";
print "Two \$nums are ", $num * 2," and adding one to \$var makes ", =
$var++,"\n";

$num=3D10;		# =
sets $num to 10
&print_results;		# prints variable $num

$num++;
&print_results;

$num*=3D3;
&print_results;

$num/=3D3;
&print_results;

sub print_results {
        print "\$num is $num\n";
}

if ($day eq "sunday") {
	&lie_in_bed;
}

$day=3D"sunday";

if ($day eq "sunday") {
        print "Zzzzz....\n";
}

Note the syntax. The if =
statement requires something to test for Truth. This =
expression must
be in (parens), then you have the braces to form a block.=20

&isit;                   # $test1 is at this =
moment undefined

$test1=3D"hello";         # a string, not equal to "" or "0"
&isit;

$test1=3D0.0;             # $test1 is now a number, effectively 0
&isit;

$test1=3D"0.0";           # $test1 is a string, but NOT effectively 0 !
&isit;

sub isit {
        if ($test1) {                           # tests $test1 for truth =
or not
                print "$test1 is true\n";
        } else {                                # else statement if it =
is not true
                print "$test1 is false\n";
        }
}

The first test fails because $test1 =
is undefined. This means it has not been created by=20
assigning a value to it. So according to Rule 3 it is false. The last =
two tests are
interesting. Of course, 0.0 is the same as 0 in a numeric =
context. But it is not the
same as 0 in a string context, so in that case it is true.    
$x=3D5;
$y=3D5;

if ($x - $y) {
        print '$x - $y is ',$x-$y," which is true\n";
} else {
        print '$x - $y is ',$x-$y," which is false\n";
}

$lucky=3D15;
$drawnum=3D15;

if ($lucky =3D=3D $drawnum) {
        print "Congratulations!\n";
} else {
        print "Guess who hasn't won!\n";
}

$name	 =3D 'Mark';

$goodguy =3D 'Tony';

if ($name =3D=3D $goodguy) {
        print "Hello, Sir.\n";
} else {
        print "Begone, evil peon!\n";
}

$foo=3D291;
$bar=3D30;

if ($foo < $bar) {=20
        print "$foo is less than $bar (numeric)\n";=20
}

if ($foo lt $bar) {=20
        print "$foo is less than $bar (string)\n";=20
}

$age=3D25;
$max=3D30;

if ($age > $max) {
        print "Too old !\n";
} else {
        print "Young person !\n";
}

It is easy to see what else does. If the expression is =
false then whatever is in=20
the else block is evaluated =
(or carried out, executed, whatever term you choose to use).
Simple. But what if you want another test ? Perl can do that too.=20

$age=3D25;
$max=3D30;
$min=3D18;

if ($age > $max) {
        print "Too old !\n";
} elsif ($age < $min) {=20
        print "Too young !\n";=20
} else {=20
        print "Just right !\n";=20
}

If the first test fails, the second is evaluated. This =
carries on until there are no=20
more elsif statements, or an =
else statement is reached. An =
else statement is optional,
and no elsif statements should =
come after it. Logical, really.    
if ($age > $max) {
        print "Too old !\n";
}=20

if ($age < $min) {
        print "Too young !\n";
}

print "Too old\n" if     $age > $max;
print "Too old\n" unless $age < $max;

print "Please tell me =
your name: ";
$name=3D<STDIN>;
print "Thanks for making me happy, $name !\n";

New things to learn here. Firstly, <STDIN> . STDIN is a =
filehandle. Filehandles are what=20
you use to interact with things such as files, console input, socket =
connections and more. 
print "Please tell me your =
name: ";
$name=3D<STDIN>;
chop $name
print "Thanks for making me happy, $name !\n"

and that fails with a syntax error. Can you spot why? Look at the error =
code, look at the=20
line number and see where the syntax is wrong. The answer is a missing =
semicolon=20
( ; ) on the end of the last two lines. 
print =
"Please tell me your name: ";
chop ($name=3D<STDIN>);
print "Thanks for making me happy, $name !";

print "Please tell me your name: ";
chop ($name=3D<STDIN>);

print "Please tell me your nationality: ";
chop ($nation=3D<STDIN>);

if ($nation eq "British" or $nation eq "New Zealand") {
	print "Hallo $name, pleased to meet you!\n";

} elsif ($nation eq "Dutch" or $nation eq "Flemish") {
	print "Hoi $name, hoe gaat het met u vandaag?!\n";

} else {
	print "HELLO!!!  SPEAKEEE ENGLIEESH???\n";
}

chomp ($name=3D<STDIN>);

@names=3D("Muriel","Gavin","Susanne","Sarah","Anna");

print "The elements of \@names are @names\n";
print "The first element is $names[0] \n";
print "The third element is $names[2] \n";
print 'There are ',scalar(@names)," elements in the array\n";

@names=3D("Muriel","Gavin","Susanne","Sarah","Anna","Paul","Trish","Simon=
");

print @names;
print "\n";
print "@names";

When a list is placed inside doublequotes, it is space =
delimited when interpolated. Useful.    
$myvar=3D"scalar variable";
@myvar=3D("one","element","of","an","array","called","myvar");

print $myvar;        # refers to the contents of a scalar variable =
called myvar
print $myvar[1];     # refers to the second element of the array myvar
print @myvar;        # refers to all the elements of array myvar

print "Enter a number :";
chomp ($x=3D<STDIN>);

@names=3D("Muriel","Gavin","Susanne","Sarah","Anna");

print "You requested element $x who is $names[$x]\n";

print "The index number of the last element is $#names \n";

This is useful. Notice the last line of the example. It returns =
the index number of=20
the last element. Of course you could always just do this $last=3Dscalar(@names)-1; but=20
this is more efficient. It is an easy way to get the last element, as =
follows: 
print "Enter the number of the =
element you wish to view :";
chomp ($x=3D<STDIN>);

@names=3D("Muriel","Gavin","Susanne","Sarah","Anna","Paul","Trish","Simon=
");

print "The first two elements are @names[0,1]\n";
print "The first three elements are @names[0..2]\n";
print "You requested element $x who is $names[$x-1]\n";		# starts at 0
print "The elements before and after are : @names[$x-2,$x]\n";
print "The first, second, third and fifth elements are =
@names[0..2,4]\n";

print "a) The last element is $names[$#names]\n";	# one way
print "b) The last element is @names[-1]\n";		# different way=20

It looks complex, but it is not. Really. Notice you can have =
multiple values separated=20
by a comma. As many as you like, in whatever order. The range operator =
.. gives you
everything between and including the values. And finally look at how we =
print the last=20
element - remember $#names =
gives us a number ? Simply enclose it inside square =
brackets
and you have the last element.    
@names=3D("Muriel","Gavin","Susanne","Sarah","Anna",=
"Paul","Trish","Simon");

for ($x=3D0; $x <=3D $#names; $x++) {
        print "$names[$x]\n";=20
}

which sets $x to 0, runs the =
loop once, then adds one to $x =
, checks it is less than=20
$#names , if so carries on. By =
the way, that was your introduction to for =
loops. Just=20
to go into a little detail there, the for =
loop has three parts to it:    
for $x =
(0 .. $#names) {
        print "$names[$x]\n";
}

which takes advantage of the range operator .. (two dots together). This simply =
gives $x the=20
value of 0, then increments $x =
by 1 until it is equal to $#names .=20

foreach $person =
(@names) {
        print "$person";
}

This goes through each element ('iterates', another good    technical =
word to use)=20
of @names , and assigns each =
element in turn to the variable $person =
. Then you can do=20
what you like with the variable. Much easier. You can use 
for $person (@names) {
        print "$person";
}

if you want. Makes no difference at all, aside from a little  clarity.=20

foreach =
(@names) {
        print "$_";
}

If you don't specify a variable to put each element into, $_ is used instead as it is=20
the default for this operation, and many, many others in Perl. Including =
the print function : =

foreach (@names) {
        print ;
}

As we haven't supplied any arguments to print , $_ is printed as default. You'll be =
seeing=20
a lot of $_ in Perl. Actually, =
that statement is not exactly true. You will be seeing lot
of places where $_ is used, =
but quite often when it is used, it is not actually written.=20
In the above example, you don't actually see $_ but you know it is there.=20

while (1) {
	$x++;
        print "$x:  Did you know you can press CTRL-C to interrupt a =
perl program?\n";
}

Another way to exit a loop is a simple foreach over the elements, as we =
have seen. But if we=20
don't know when we want to exit a loop? For example, suppose we want to =
print out a list of=20
names but stop when we find one with a particular title? You are =
throwing a huge party,=20
someone is allergic to vodka, and this person has drunk from the punch =
bowl despite being=20
assured by someone holding two empty bottles of Absolut that he was just =
using the bottles=20
to convey yet more orange juice into said punch bowl. So you need a =
doctor, and so you write
a Perl script to find one from the list of attendees, wanting the =
doctor's name to be the last=20
item printed: 
@names=3D('Mrs Smith','Mr =
Jones','Ms Samuel','Dr Jansen','Sir Philip');

foreach $person (@names) {
	print "$person\n";
	last if $person=3D~/Dr /;
}

The last operator is our =
friend. Don't worry about the /Dr / business -- that is a =
regular=20
expression which we cover next. All you need to know is that it returns =
true if the name begins=20
with 'Dr '. When it does return true, last =
is operated and the loop ends early.    
@names  =3D('Mrs =
Smith','Mr Jones','Ms Samuel','Dr Jansen','Sir Philip');
@medics =3D('Dr Black','Dr Waymour','Dr Jansen','Dr Pettle');

foreach $person (@names) {
	print "$person\n";
	if ($person=3D~/Dr /) {
		foreach $doc (@medics) {
			print "\t$doc\n";
			last if $doc eq $person;
		}
	}
}

Aside from showing one way to indent your code, this also demonstrates a =
nested loop. A nested=20
loop is a loop within a loop. What happens is that the =
@names array is searched for a 'Dr ',=20
and if it is found then the @medics array is searched to =
make sure the doctor is a human-fixing=20
doctor not a professor of physics or something. The regular expression =
has been shifted into=20
an if statement, where it =
works nicely as it only returns true or false.    
@names  =3D('Mrs Smith','Mr Jones','Ms =
Samuel','Dr Jansen','Sir Philip');
@medics =3D('Dr Black','Dr Waymour','Dr Jansen','Dr Pettle');

LBL: foreach $person (@names) {
	print "$person\n";
	if ($person=3D~/Dr /) {
		foreach $doc (@medics) {
			print "\t$doc\n";
			last LBL if $doc eq $person;
		}
	}
}

Only two changes here. We have defined a label, namely LBL. =
Instead of breaking out from=20
the current loop, which is the default, we specify a label to break out =
to, which is in=20
the outer loop. This works with as many nested loops as your brain can =
handle. You don't have=20
to use uppercase names but for namespace reasons it is recommended, and =
you can call your=20
labels whatever you please. I was just being unimaginative with the name =
of LBL, feel free=20
to invent labels called DORIS or MATILDA if that's what floats your =
personal boat. 
print "Enter a =
name :";
chomp ($x=3D<STDIN>);

@names=3D("Muriel","Gavin","Susanne","Sarah");

print "@names\n";

push (@names, $x);

print "@names\n";

Fairly self explanatory. The push =
function just adds a value on to the end of the array.=20
Of course, Perl being Perl, it doesn't have to be just the one value: =

print "Enter a name :";
chop ($x=3D<STDIN>);

@names=3D("Muriel","Gavin","Susanne","Sarah");
@cities=3D("Brussels","Hamburg","London","Breda");

print "@names\n";

push (@names, $x, 10, @cities[2..4]);

print "@names\n";

This is worth looking at in more detail. It appears there is no fifth =
element of=20
@cities , as referred to by =
@cities[2..4] .    
print "There are ",scalar(@names)," =
elements in \@names\n";

There appear to be 8 elements in @names =
. However, we have just proved there are in fact 9.=20
The reason there are 9 is that we referred to non-existent elements of =
@cities , and Perl=20
has quite happily extended @names =
to suit. The array @cities =
remains unchanged. Try poping=20
the array if you don't believe me.    
@names=3D("Muriel","Gavin","Susanne","Sarah");
@cities=3D("Brussels","Hamburg","London","Breda");

&look;

$last=3Dpop(@names);
unshift (@cities, $last);

&look;

sub look {
        print "Names : @names\n";
        print "Cities: @cities\n";
}

Now we have two arrays. The pop =
function removes the last element of an array and returns =
it,
which means you can do something like assign the returned value to a =
variable.   =20
The unshift function adds a =
value to the beginning of the array. Hope you didn't forget that=20
&subroutinename calls a =
subroutine. Presented below are the functions you can use to work with =
arrays:=20

@names=3D("Muriel","Sarah","Susanne","Gavin");

&look;

@middle=3Dsplice (@names, 1, 2);

&look;

sub look {
        print "Names : @names\n";
        print "The Splice Girls are: @middle\n";
}

The first argument for splice =
is an array. Then second is the offset. The offset is the =
index   =20
number of the list element to begin splicing at. In this case it is 1. =
Then   =20
comes the number of elements to remove, which is sensibly 1 or more in =
this   =20
case. You can set it to 0 and perl, in true perl style, won't complain.  =
 =20
Setting to 0 is handy because splice =
can add elements to the middle of an array, and if you =
don't   =20
want any deleted 0 is the number to use. Like so: 
@names=3D("Muriel","Gavin","Susanne","Sarah");
@cities=3D("Brussels","Hamburg","London","Breda");

&look;

splice (@names, 1, 0, @cities[1..3]);

&look;

sub look {
        print "Names : @names\n";
        print "Cities: @cities\n";
}

Notice how the assignment to @middle    =

has gone -- it is no longer relevant.    
@names=3D("Muriel","Sarah","Susanne","Gavin");

&look;

$middle=3Dsplice (@names, 1, 2);

&look;

sub look {
        print "Names : @names\n";
        print "The Splice Girls are: $middle\n";
}

then the scalar is assigned the last element removed, or undef if   =20
it doesn't work at all.    
@cities=3D("Brussels","Hamburg","London","Breda");

&look;

$cities[1]=3D"";

&look;

sub look {
	print "Cities: ",scalar(@cities), ": @cities\n";
}

splice =
(@cities, 1, 1);

$car =3D"Porsche 911";
$aircraft=3D"G-BBNX";

&look;

$car=3D"";

&look;

sub look {
	print "Car :$car: Aircraft:$aircraft:\n";
	print "Aircraft exists !\n" if $aircraft;
	print "Car exists !\n" if $car;
}

print "Car is defined !\n" =
if defined $car;

$car 	 =3D"Porsche 911";
$aircraft=3D"G-BBNX";

&look;

undef $car; # this undefines $car

&look;

sub look {
	print "Car :$car: Aircraft:$aircraft:\n";
	print "Aircraft exists !\n"  if $aircraft;
	print "Car exists !\n" 	     if defined $car;
}

dir *.txt 
.txt.
$name=3D~/piper/

print "What do you read before joining any Perl =
discussion ? ";
chomp ($_=3D<STDIN>);

print "Your answer was : $_\n";

if ($_=3D~/the faq/) {
        print "Right !  Join up !\n";
} else {
        print "Begone, vile creature !\n";
}

So here $_ is searched   =20
for 'the faq'. Guess what we don't need ! The =3D~ .
This works just as well: 
if (/the faq/) =
{

because if you don't specify a variable, then perl searches $_ by default.=20
In this particular case, it would be better to use 
 if ($_ eq "the faq") { as we are testing =
for exact matches.   =20

if =
(/the faq/i) {

with the /i switch, which   =20
specifies case-insensitivity. Now it works for all variations, such as =
"the   =20
Faq" and "the FAQ".    
$_=3D"perl =
for Win32";                            # sets the string to be searched

if ($_=3D~/perl/) { print "Found perl\n" };       # is 'perl' inside $_ =
?  $_ is "perl for Win32".
if (/perl/)     { print "Found perl\n" };       # same as the regex =
above.  Don't need the =3D~ as we are testing $_
if (/PeRl/)     { print "Found PeRl\n" };       # this will fail because =
of case sensitivity
if (/er/)       { print "Found er\n" };         # this will work, =
because there is an 'er' in 'perl'
if (/n3/)       { print "Found n3\n" };         # this will work, =
because there is an 'n3' in 'Win32'
if (/win32/)    { print "Found win32\n" };      # this will fail because =
of case sensitivity
if (/win32/i)   { print "Found win32 (i)\n" };  # this will *work* =
because of case insensitivity (note the /i)

print "Found!\n"  if      / /;                  # another way of doing =
it, this time looking for a space

print "Found!!\n" unless $_!~/ /;		# both these are the same, but =
reversing the logic with unless and !
print "Found!!\n" unless    !/ /;		# don't do this, it will always never =
not confuse nobody :-)
						# the ~ stays the same, but =3D is changed to ! (negation)

$find=3D32;                                       # Create some =
variables to search for
$find2=3D" for ";                                 # some spaces in the =
variable too

if (/$find/)  { print "Found '$find'\n" };      # you can search for =
variables like numbers
if (/$find2/) { print "Found '$find2'\n" };     # and of course strings =
!

print "Found $find2\n" if /$find2/;           # different way to do the =
above

As you can see from the last example, you can embed a variable in   =20
the regex too. Regular expressions could fill entire books (and they =
have   =20
done, see the book critiques at http://www.perl.com/) but here are some =
useful   =20
tricks:=20

@names=3Dqw(Karlson Carleon Karla Carla Karin =
Carina Needanotherword);

foreach (@names) {                      # sets each element of @names to =
$_ in turn
        if (/[KC]arl/) {                # this line will be changed a =
few times in the examples below
                print "Match !  $_\n";
        } else {
                print "Sorry.   $_\n";
        }
}

This time @names is   =20
initialised using whitespace as a delimiter instead of a comma. qw refers to=20
'quote words', which means split the list by words. A word ends with =
whitespace=20
(like tabs, spaces, newlines etc).    
if =
(/[KCZ]arl[sa]/) {

if (/[KCZ]arl[^sa]/) =
{
which returns things beginning with K, =
C or    Z, then arl, and then anything EXCEPT =
s or a. The    caret ^ =
has to be the first character,    otherwise it doesn't =
work as the negation. Having said [ ] =
defines single characters only, I should    mention than =
these two are the same : 
/[abcdeZ]arl/;
/[a-eZ]arl/;

if you use a hyphen then you get the list of characters including   =20
the start and finish characters. And if you want to match a special =
character   =20
(metacharacter), you must escape it: 
/[\-K]arl/;

if (/a$/) {

if (/n/i)  {
if (/^n/i) {

The first one is true if the word contains an 'n' anywhere in it.   =20
The second specifies that the 'n' must be at the beginning of the string =
to be   =20
matched. Use this anchor where you can, because it makes the whole regex =
  =20
faster, and safer if you know what the first character must be.=20

if ($_ !~/[KC]arl/) {

Of course, as we are testing $_    =

this works too: 
if (!/[KC]arl/) {

$_=3D'My email address is =
<Robert@NetCat.co.uk>.';

/(<robert\@netcat.co.uk>)/i;

print "Found it ! $1\n";

Firstly, note the single quotes when $_    =

is assigned. If there were double quotes, we'd need \@ instead of @ .
Remember, double quotes "" =
allow variable interpolation, so Perl looks for an=20
array called @NetCat which =
does not exist. 
/<(robert)\@netcat.co.uk>/i;

You can put the parens anywhere. More or less. Now, run this :    =

$_=3D'My email address is =
<Robert@NetCat.co.uk>.';

/<(robert)\@(netcat.co.uk)>/i;

print "Found it ! $1 at $2\n";

See, you can have more than one ! Look at the above regex. Looks   =20
easy now, don't you think ? What about five minutes ago ? It would have =
looked   =20
like a typing mistake ! Well, there are some hairier regex to come, but =
you'll   =20
have a good barber.=20

$_=3D'My email address is =
<webslave@work.com>.';

print "Found it ! :$1:" if /(<.*>)/i;

When you see an if 
statement like this, read it right to left. The print statement is only executed if =
code on =20
the right of the expression is true. 
$_=3D'My email address is =
<webslave@work.com>.';

print "Found it ! :$1:" if /(<*>)/i;

What's happening here ?    
$_=3D'My =
email address is <webslave@work.com>.';
print "Match 1 worked :$1:" if /(<*)/i;

$_=3D'<My email address is <webslave@work.com>.';
print "Match 2 worked :$1:" if /(<*)/i;

$_=3D'My email address is <webslave@work.com<<<<>.';
print "Match 3 worked :$1:" if /(<*>)/i;

Match 1 is true. It doesn't return anything, but it is true =20
because there are 0 < at =
the very =20
start of the string. 
$_=3D'HTML munging time !.';

/<I>(.*)<\/I>/i;

print "Found it ! $1\n";

Pretty much the same as the above, except the parens are moved so =20
we return what's only inside the tags, not including the tags =
themselves. Also =20
note how / is escaped like so; =
\/ otherwise Perl thinks =
that's the end of =20
the regex. 
$_=3D'HTML munging =
time is here again !.';

and run it again. Interesting effect, eh ? This is known as =20
Greedy Matching. What happens is that when Perl finds the initial match, =
that =20
is it jumps right to =
the end =20
of the string and works back from there to find a match, so the longest =
string =20
matches. This is fine unless you want the shortest string. And there is =
a =20
solution: 
/(.*?)<\/I>/i;

Just add a question mark and Perl does stingy =
matching. No   =20
nationalistic jokes. I have Dutch and Scottish friends I don't want to =
offend.     
$_=3D'The number is 2200 and the day is Monday';

($star)=3D/([0-9]*)/;

($plus)=3D/([0-9]+)/;

print "Star is '$star' and Plus is '$plus'\n";

You'll note that $star has no value. The match was =20
successful though. It managed to match 0 or more characters from 0 to 9 =
at the =20
very start of the regex. 
$_=3D'My email =
address is <robert@netcat.co.uk> !.';

/<([^>]+)/i;

print "Found it ! $1\n";

This regex matches <. Then the =
capturing parens =20
start. They have no effect on this regex other than to capture the =
match. =20
After that, there is a character class, containing one character. As =
^ 
is the first character is the class, it negates the class. That's why =

we are using a character class with only one character in it, because it =
can =20
be negated. 
$_=3D'HTML munging time is here =
again !.';
/<(.*?)>(.*?)<\/\1>/i;

print "Found it ! $2\n";

If you want to know how to return all the matches above, read on.   =20
But before that:=20
   =

/http:\/\/language\.perl\.com\/faq\//;

which should make the awful metaphor above clearer, if not   =20
funnier. The slash, / , is not =
  =20
normally a metacharacter but as it is being used for the regular =
expression   =20
delimiters, it needs to be escaped. We already know that . is special.    
m#http://language\.perl\.com/faq/#;=20

Which is a huge improvement, as we change / to # =
.
We can go further with readability by quoting everything:    
m#\Qhttp://language.perl.com/faq/\E#;

The \Q =
escapes everything   =20
up until \E or the regex =
delimiter (so   =20
we don't really need the \E above). In this case #    
will not be escaped, as it delimits the regex.    
$_=3D'Us ? The bus usually =
waits for us, unless the driver forgets us.';

print "$_\n";

s/Us/them/;   # operates on $_, otherwise you need $foo=3D~s/Us/them/;

print "$_\n";

What happens here is that the string 'Us' is searched for, and   =20
when a match is found it is replaced with the right side of the =
expression, in   =20
this case 'them'. Simple.    
s/Us/them/g;

which fails. This is because regexes are not, by default,   =20
case-sensitive. So: 
s/us/them/ig;

would be a better bet. Now, everything is changed. A little too   =
=20
much, but one problem at a time. Everything you have learn about regex =
so far   =20
can be used with s/// , like =
parens,   =20
character classes [ ] , greedy =
and   =20
stingy matching and much more. Deleting things is easy too. Just specify =
  =20
nothing as the replacement character, like so s/Us//; .    
s/ us/them/g;

An small improvement. The first 'Us' is now no longer changed,    =

but one problem at a time ! We'll first consider the problem of the =
regex   =20
changing 'usually' and other words with 'us' in them.    
s/ us[. ,]/them/g;

Another tiny step. Unfortunately, that step wasn't really in the  =
 =20
right direction, more on the slippery slope to Poor Programming =
Practice. Why?=20
Because we are limiting ourselves. Suppose someone wrote ' send it to =
us;   =20
when we get it'.    
s/ us[^a-z]/ them/g;

the caret ^ negates the =
  =20
character class, and a-z =
represents   =20
every alphabet from a to z inclusive. A space has been added to the   =20
substitution part - as the original space was matched, it should be =
replaced   =20
to maintain readability.    
s/ us[^\w]/ them/g;

The \w construct =
actually   =20
means 'word' - equivalent to a-zA-Z_0-9 =
.
So we'll use that instead.    
s/ us[\W]/ them/g;

and of course we don't need the negating caret now. In fact, we   =
=20
don't even need the character class ! 
s/ us\W/ them/g;

So far, so good. Matching the first 'us' is going to be difficult =
  =20
though. Fortunately, there is an easy solution. We've seen Perl's =
definition   =20
of a word - \w . Between each =
word is   =20
a boundary. You can match this with \b    =
. 
s/\bus\W/ them/g;

that's \b followed by =
'us', not 'bus' :-)
Now, we require a word boundary before 'us'. As there   =20
is a 'nothing' at the start of the string, we have a match. There is a =
space   =20
after the first 'Us', so the match is successful. You might notice an =
extra   =20
space has crept in - that's the space we added earlier. The match =
doesn't   =20
include the space any more - it matches on the word boundary, that is =
just=20
before the word begins. The space doesn't count.    
s/\bus(\W)/them\1/g;

We start with capturing whatever the \W    
matches, using parens. Then, we add it to the replacement   =20
string. The capture is of course in $1 =
,
but as it is in a regex we refer to it as \1 =
.    
#         =
Solution to the us/them problem...
#
#   The program works through the text assigning the=20
#   variable $1 to 'U' or 'u' for any words where this=20
#   letter is followed by 's' and then by non 'word'=20
#   characters.   The latter is assigned to variable $2.
#
#   For each such matching occurrence, $1 is replaced by=20
#   the letter that precedes it in the alphabet using=20
#   operations 'ord' and 'chr' that return the ASCII value=20
#   of a character and the character corresponding to a=20
#   given natural number.  After this 'hem' is tacked on=20
#   followed by $2, to retain the shape of the original=20
#   sentence.  The '/e' switch is used for evaluation.
#
#   NOTES
#   1. This solution will not replace US (short for=20
#   United States) with Them or them.
#
#   2. If a 'magical' decrement operator '--' existed for=20
#   strings then the solution could be simplified for we=20
#   wouldn't need to use the 'chr' and 'ord' operators.

$_=3D'Us ? The bus usually waits for =
us, unless the driver forgets us.';

print "$_\n";

s/\b([Uu])s(\W)/chr(ord($1)-1).hem.$2/eg;

print "$_\n";

print "Enter a number :";
chop ($input=3D<STDIN>);

if ($input=3D~/\D/) {
        print "Not a number !!!!\n";
} else {
        print 'Your answer is ',$input x 3,"\n";

}

this checks that there are no non-number characters in $x . It's not perfect because=20
it'll choke on   =20
decimal points, but it's just an example. Writing your own =
number-checker is   =20
actually quite difficult, but it is an interesting exercise. Try it, and =
see   =20
how accurate yours is.    
unless ($input=3D~/\d/) {
        print 'Your answer is ',$input x 3,"\n";
} else {
        print "Not a number !!!!\n";
}

which reverses the logic with an unless    =
statement.=20

$_=3D'HTML =
<I>munging</I> time is here <I>again</I> !.';

and we want to find all the italic words. We know that /g will match globally, so=20
surely this will work : 
$_=3D'HTML =
munging time is here again ! What =
fun !';

$match=3D/<i>(.*?)<\/i>/ig;

print "$match\n";

except it returns 1, and there were definitely two matches. The   =20
match operator returns true or false, not the number of matches. So you =
can   =20
test it for truth with functions like if, =
while,   =20
unless Incidentally, the s///  =

operator does return the number of substitutions. 
($match) =3D /(.*?)<\/i>/i;

which handily puts all the first match into $match . Note that an =3D =
is used =20
(for assignment), as opposed to =3D~ (to point the regex at =
a variable other than $_. 
$_=3D'HTML munging time is =
here again ! What fun !';

($word1, $word2) =3D /<i>(.*?)<\/i>/ig;

print "Word 1 is $word1 and Word 2 is $word2\n";

In the example above notice /g    =

has been added so a global replacement is done - this =20
means perl carries on matching even after it finds the first match. Of =
course, =20
you might not know how many matches there will be, so you can just use =
an =20
array, or any other type of list: 
$_=3D'HTML munging time is here =
again ! What fun !';

@words =3D /<i>(.*?)<\/i>/ig;

foreach $word (@words) {
        print "Found $word\n";
}

and @words will be grown =20
to the appropriate size for the matches. You really can supply what you =
like =20
to be assigned to: 
($word1, =
@words[2..3], $last) =3D /(.*?)<\/i>/ig;
you'll need more italics for that last one to work. It was only a =
 demonstration. 
$_=3D'HTML munging time is here =
again ! What fun !';

while (/<(.*?)>(.*?)<\/\1>/g) {
        print "Found the HTML tag $1 which has $2 inside\n";
}

So the while operator runs the regex, and if it is true, carries =20
out the statements inside the block. 
$_=3D'HTML munging time is =
here again ! What fun !';

$found++ while /<i>.*?<\/i>/ig;

print "Found $found matches\n";

You don't need braces in this case as nothing apart from the   =20
expression to be evaluated follows the while =
   function.=20

$_=3D'One word sentences ? =
Eliminate. Avoid clich=E9s like the plague.  They are old hat.';

while (/o(rd|ne|ld)/gi) {
        print "Matched $1\n";
}

Firstly, notice the subtle introduction of the or operator, in this case | ,=20
the pipe. What I really want to explain =20
however, is that this regex matches o followed by rd, ne or ld. Without =
the =20
parens it would be /ord|ne|ld/ =
which =20
is definitely not what we want. That matches just plain ord, or ne or =
ld. 
print "Give me a name :";
chop($_=3D<STDIN>);

print "Good name\n" if /Pe(tra|ter|nny)/;

The code above functions correctly. If you were wondering what a =20
good name is, Petra, Peter and Penny qualify. The regex is not as =
efficient as =20
it could be though. Think about what Perl is doing with the regex, that =
you =20
are just ignoring. Simply throwing away casually. Without consideration =
as to =20
the effort that has gone into creating it for you. The resources =
squandered. =20
The little bytes of memory whose sole function in life is to store this =
 =20
information, which will never be used. 
print =
"Give me a name :";
chop($_=3D<STDIN>);

print "Good name\n" if /Pe(?:tra|ter|nny)/;

print "The match is :$1:\n";

The second print statement demonstrates that nothing is captured   =20
this time. You get the benefits of the paren's precedence-changing   =20
capabilities, but without the overhead of the capturing. This benefit is =
  =20
especially worthwhile if you are writing CGI programs which use parens =
in   =20
regex -- with CGI, every little of bit efficiency counts.    
$_=3D'I am sleepy....zzzz....DING ! Wake Up!';

if (/(z{5})/) {
        print "Matched $1\n";
} else {
        print "Match failed\n";
}

The braces { } specify =20
how many of the preceding character to match. So z{2} matches exactly two 'z's and so =
on. =20
Change z{5} to z{4} and see how it works. And =
there's more... 
print "How many letters do you =
want to match ? ";
chomp($num=3D<STDIN>);

# we assign and print in one smooth move
print $_=3D"The lowest form of wit is indeed sarcasm, I don't think.\n";

print "Matched \\w{$num,} : $1 \n"  if /(\w{$num,})/;

print "Matched \\w{$num,?}: $1 \n"  if /(\w{$num,}?)/;

print "\nMatched \\w{$num,} :";
print "$1 " while /(\w{$num,})/g;

print "\nMatched \\w{$num,?} :";
print "$1 " while /(\w{$num,}?)/g;

$_=3D'I am =
sleepy....snore....DING ! Wake Up!';

/snore/;	# look, no parens !

print "Postmatch: $'\n";
print "Prematch: $`\n";
print "Match: $&\n";

If you are wondering what the difference between match and using  =
 =20
parens is you should remember than you can move the parens around, but =
you   =20
can't vary what $& and its =
ilk   =20
return. Also, using any of the above three operators does slow your =
entire   =20
program, whereas using parens will just slow the particular regex you =
use them   =20
for. However, once you've used one of the three matches you might as =
well use   =20
them all over the place as you've paid the speed penalty. Use parens =
where   =20
possible.=20

<FONT SIZE=3D2> <FONT SIZE=3D4> <FONT =
SIZE=3D6>

$data=3D"<FONT =
SIZE=3D2> <FONT SIZE=3D4> <FONT SIZE=3D6>";

print "$data\n";

$data=3D~s/(size=3D)(\d)/\1\2 * 2/ig;

print "$data\n";

which doesn't really work out. What this does is match   =20
size=3Dx, where x is any digit. The first =
match,   =20
size=3D, goes into $1 =
and   =20
the second match, whatever the digit is, goes into $2 . The second part of the regex =
simply   =20
prints $1 and $2 (referred to as \1 and \2    ), and attempts to multiply =
$2    
by 2. Remember /i means   =20
case insensitive matching.    
$data=3D~s/(size=3D)(\d)/$1.($2 * =
2)/eig;

A little explanation....the LHS is the same as before. We add   =20
/e so Perl evaluates the RHS =
as an   =20
expression. So we need to change \1    =

into $1 and so on. The   =20
parens are there to ensure that $2 * 2    =

is evaluated, then joined to $1 . And that's it ! 
$data=3D'The function is <5funcA>';

$funcA=3D'*2+4';

print "$data\n";

$data=3D~s/<(\d)(\w+)>/($1+2).${$2}/;	# first time
# $data=3D~s/<(\d)(\w+)>/($1+2).${$2}/e;	# second time
# $data=3D~s/<(\d)(\w+)>/($1+2).${$2}/ee;	# third time

print "$data\n";

To properly appreciate this you need to run it three times, each  =
 =20
time commenting out a different line. Only one regex line should be   =20
uncommented when the program is run.    
@dates=3D(
'01/22/95',
'05/15/87',
'8-13-96',
'5.27.78',
'6/16/1993'
);

@dates=3D(
'01/22/95',
'5/15/87',
'8-13-96',
'5.27.78',
'6/16/1993'
);

foreach (@dates) {
	print;
	s#(\d\d)/(\d\d)#$2/$1#;
	print " $_\n";
}

Hmm. This hasn't worked for the dates delimited with - . ,=20
and the last date hasn't worked either. The first problem is pretty   =20
easy; we are just matching / , nothing else. The second =
problem   =20
arises because we are matching two digits. Therefore, 5/15/87 is matched =
on   =20
the 15 and 87, not the 5 and 15. The date 6/16/1993 is matched on the 16 =
and   =20
the 19 of 1993.    
foreach (@dates) {
	print;
	s#(\d\d?)[/-.](\d\d?)#$2/$1#;
	print " $_\n";
}

which fails. Examine the error statement carefully. The key word   =20
is 'range'. What range? Well, the range between / and . because =
-   =20
is the range operator within a character class. That means it is a =
special   =20
character, or a metacharacter. And to negate the special meaning of   =20
metacharacters we have to use a backslash.    
foreach (@dates) {
	print;
	s#(\d\d?)[/\-.](\d\d?)#$2/$1#;
	print " $_\n";
}

Nearly there. However, we are always replacing the delimiter with   =20
/ which is messy. That's an easy fix: 
foreach (@dates) {
	print;
	s#(\d\d?)([/\-.])(\d\d?)#$3$2$1#;
	print " $_\n";
}

so that fixes that. In case you were wondering, the .    
dot does not act as '1 of anything' inside a character class. It would   =
=20
defeat the object of the character class if it did. So it doesn't need   =
=20
escaping. There is a further improvement you can make to this regex: =

$m=3D'/.-';

foreach (@dates) {
	print;
	s#(\d\d?)([$m])(\d\d?)#$3$2$1#;
	print " $_\n";
}

which is good practice because you are bound to want to change   =20
your delimiters at some point, and putting them inside the regex is   =20
hardcording, and we all know that ends in tears. You can also re-use the =
  =20
$m variable elsewhere, which is good pratice.    
    /\-.
$m=3D'/.-';

$m=3D'/-.';

@dates=3D(
'01/22/95',
'5/15/87',
'8-13-96',
'5.27.78',
'/16/1993',
'8/1/993',
);

$m=3D'/.-';

foreach (@dates) {
	print;
	s#(\d\d?)([$m])(\d\d?)#$3$2$1# or print "Invalid date! ";
	print " $_\n";
}

The two invalid dates at the end are let through. If you wanted   =20
to check the validity of every possible date since the start of the =
modern   =20
calendar then you might be better off with a database rather than a =
regex, but   =20
we can do some basic checking. The important point is that we know the   =
=20
limitations of what we are doing.    
$m=3D'/.-';

foreach (@dates) {
	print;
	s#(\d\d?)([$m])(\d\d?)[$m](\d\d|\d{4})#$3$2$1$2# or print "Invalid =
date! ";
	print " $_\n";
}

which doesn't really work out. The problem is it lets 993   =20
through. This is because \d\d will match on the front of 993. =
Furthermore, we   =20
aren't fixing the year back on to the end result.    
foreach (@dates) {
	print;
	s#(\d\d?)([$m])(\d\d?)\2(\d\d|\d{4})$#$3$2$1$2$4# or print "Invalid!";
	print " $_\n";
}

This is now looking like a serious regex. Changes:    
@dates=3D(
'01/22/95',
'5/15/87',
'8-13-96',
'5.27.78',
'/16/1993',
'8/1/993',
'3/29/1854',
'! 4/23/1972 !',
);

$m=3D'/.-';

foreach (@dates) {
	print;
	s#(\d\d?)([$m])(\d\d?)\2(\d\d|(?:19|20)\d{2})(?:$|\D)#$3$2$1$2$4# or =
print "Invalid!";
	print " $_\n";
}

We have now got a nested OR, and the inner OR is non-capturing   =20
for reasons of efficiency and readability. At the end we alternate =
between   =20
letting the regex match either an end of line or any non-digit, =
symbolised   =20
with \D.    
$_=3D'Piper:PA-28:Archer:OO-ROB:Antwerp';

@details=3Dsplit /:/, $_;

foreach (@details) {
        print "$_\n";
}

Here we give split is   =20
given two arguments. The first one is a regex specifying what to split =
on. The   =20
next is what to split. Actually, I could leave $_    
out because as usual it is the default if nothing is specified.    =

$_=3D'Piper:PA-28:Archer:OO-ROB:Antwerp';

($maker,$model,$name,$reg,$location) =3D split /:/, $_;
(@aircraft[0..1],$aname,@regdetails) =3D split /:/, $_;

$number=3Dsplit /:/ ;             # not bothering with the $_ at the =
end, as it is the default

print "Using the first 'split'\n";
print "$reg is a $maker $model $name based in $location\n";
print "There are $number details available on this aircraft\n\n";

print "Using the second 'split'\n";
print "You can find $regdetails[0], an $aircraft[1], $regdetails[1]\n";

This demonstrates that a list can be a list of scalar variables   =
=20
(which is basically what an array is anyway), and that you can easily =
see how   =20
many elements the expression can be split into.    
$_=3D'Piper:PA-28:Archer:OO-ROB:Antwerp';

@details=3Dsplit /:/, $_, 3;

foreach (@details) {
        print "$_\n";
}

In the example below we split    =

on whitespace. Whitespace, in perl terms, is a space,   =20
tab, newline, formfeed or carriage return. Instead of writing \t\n\f\r for each=20
of the above, you can simply use \s =
, or the negated version   =20
\S which means anything =
except   =20
whitespace. Think of whitespace as anything you know is there, but you =
can't   =20
see.    
$_=3D'Piper       PA-28  Archer         =
  OO-ROB
Antwerp';

@details=3Dsplit /\s+/, $_;

foreach (@details) {
        print "$_\n";
}

@chars=3Dsplit //, $details[0];

foreach $char (@chars) {
        print "$char !\n";
}

"My data =
is delimited by |, for example:
name|age|sex|height|
Why doesn't
@array=3Dsplit /|/, $line;
work ?"

$line=3D'name|age|sex|height';

@array=3Dsplit /|/,$line;

foreach (@array) { print "$_\n" }

The effect is to split    
each character. The | is   =20
returned. As it is the delimiter, |    =

should be ignored, not returned.    
$line=3D'name|age|sex|height';

@array=3Dsplit /\|/,$line;

foreach (@array) { print "$_\n" }

$w1=3D"Mission critical ?";
$w2=3D"Internet ready modems !";
$w3=3D"J(insert your cool phrase here)";	# anything prefixed by 'J' is =
now cool ;-)
$w4=3D"y2k compatible.";
$w5=3D"We know the Web.";
$w6=3D"...the leading product in an emerging market.";

$cool=3Djoin ' ', $w1,$w2,$w3,$w4,$w5,$w6;

print $cool;

Join takes a 'glue' operator, which is not a regular   =20
expression. It can be a scalar variable however. In this case it is a =
space.   =20
Then it takes a list, which can either be a list of scalar variables, an =
array   =20
or whatever as long as its a list. And you can see what the result is. =
You   =20
could assign it to an array, but you'd end up with everything in the =
first   =20
element of the array.    
$w1=3D"Mission critical ?";
$w2=3D"Internet ready modems !";
$w3=3D"J(insert your cool phrase here)"; 	# anything prefixed by 'J' is =
now cool ;-)
$w4=3D"y2k approved, tested and safe !";
$w5=3D"We know the Web.";
$w6=3D"...the leading product in an emerging market.";
@morecool=3D("networkable","compatible");

$sep=3D" ";

$cool=3Djoin $sep, $w1,$w2,$w3,@morecool,$w4,$w5,$w6;

print $cool;

@cool=3D(
"networkable directory services",
"legacy systems compatible",
"Mission critical, Business Ready",
"Internet ready modems !",
"J(insert your cool phrase here)",
"y2k approved, tested and safe !",
"We know the Web. Yeah.",
"...the leading product in an emerging market."
);

srand;

print "How many phrases would you like (max ",scalar(@cool),") ?";
while (1) {
        chop ($input=3D<STDIN>);
        if ($input <=3D scalar(@cool) and $input > 0) {
                last;
        }
        print 'Sorry, invalid input, try again :';
}

for (1..$input) {
        $index=3Dint(rand $#cool);
        print "$cool[$index] ";
        splice @cool, $index, 1;
}

A few things to explain. Firstly, while (1) =
{ .
We want an everlasting loop, and this one way to do it.   =20
1 is always true, so round it goes. We could test $input directly, but that wouldn't =
allow
last to be demonstrated.    =

$x=3D"Hello";
$y=3D" World";
$z=3D"\n";

print "$x\n";           # print $x and a newline

$prt=3D$x.$y.$z;          # make a new var $prt out of $x, $y and $z

print $prt;

$x.=3D$y." again ".$z;    # add stuff to $x

print $x;

The Main Perl =
Newsgroup:comp.lang.perl.misc
The Perl FAQ:http://www.perl.com/faq/
Where to download perl:http://www.activestate.com/

Now, to open and do things with this file. First, we must open =20
the file and assign it to a filehandle. All operations will be =
done on =20
the file via the filehandle. Earlier, we used <STDIN> as a filehandle - we =
read from =20
it. 
$stuff=3D"c:\scripts\stuff.txt";

open STUFF, $stuff;

while (<STUFF>) {
        print "Line number $. is : $_";
}

What this script does is fail. What is should do is open   =20
the file defined in $stuff , =
assign it   =20
to the filehandle STUFF and =
then,   =20
while there are still lines left in the file, print the line number =
$. and the current line.    =

open =
STUFF, $stuff or die "Cannot open $stuff for read :$!";

If the open operation   =20
fails, the or means that the =
code on   =20
the RHS (right hand side) is evaluated. Perl dies. This means it exits =
the   =20
script, performs a post-mortem which it writes up into $! and tells=20
you the line number at which it died. Just because $! contains useful   =20
information doesn't mean to say it is automagically printed, in true =
perl   =20
fashion. Usually you will wish to avail yourself of the information =
inside as   =20
it is of great help when working out why something is not going =
according to   =20
plan. The moral of the chapter is:    
$stuff=3D"c:/scripts/stuff.txt";

open STUFF, $stuff or die "Cannot open $stuff for read :$!";

while (<STUFF>) {
        print "Line $. is : $_";
}

A little more detail on what is happening here. The file is   =20
opened for read. You can append and write too. You don't have to =
use a   =20
variable, but I always do because it is then easy to change and easy to =
insert   =20
into the or die section, and =
it is   =20
easy to change later on. Hardcoding things is not the best way to write =
a   =20
maintainable and flexible program. Just ask the Year 2000 people about =
code   =20
that lived a little longer than the authors imagined :-). 
open STUFF, "c:/scripts/stuff.txt" or die "Cannot =
open stuff.txt for read :$!";

is just as good but more work if you want to change anything.    
$STUFF=3D"c:/scripts/stuff.txt";

open STUFF or die "Cannot open $STUFF for read :$!";

while (<STUFF>) {
        print "Line $. is : $_";
}

This saves a little bit of typing, but does tie your filehandle   =20
to the variable name. In fact, that entire program could be compressed   =
=20
further, but that's for later.    
$STUFF=3D"c:/scripts/stuff.txt";

open STUFF or die "Cannot open $STUFF for read :$!";

print "Line $. is : $_" while (<STUFF>);
       =20

$out=3D"c:/scripts/out.txt";

open OUT, ">$out" or die "Cannot open $out for write :$!";

for $i (1..10) {
        print OUT "$i : The time is now : ",scalar(localtime),"\n";
}

Note the addition of >    
to the filename. This opens it for writing. If we want to print   =20
to the file we now just specify the filehandle name. You print to the    =

filehandle, which is a gateway to the file.    
$out=3D"c:/scripts/out.txt";

&printfile;

open OUT, ">>$out" or die "Cannot open $out for append :$!";

print OUT 'The time is now : ',scalar(localtime),"\n";

close OUT;

&printfile;

sub printfile {
        open IN, $out or die "Cannot open $out for read :$!";
        while (<IN>) {
                print;
        }
        close IN;
}

This script demonstrates subroutines again, and how to append to   =20
a file, that is write additional data at the end. The close function is introduced here. =
This,   =20
well, closes a filehandle. You don't have to close a filehandle - just =
leave   =20
it open until the script finishes, or the next open command to the same  =
 =20
filehandle will close it for you.=20

perl myscript.pl hello world how are you

foreach (@ARGV) {
        print "$_\n";
}

Another useful way to get parameters into a program -- this time   =20
without user input. The relevance to filehandles is as follows. Run the  =
 =20
following perl script as: 
perl =
myscript.pl stuff.txt out.txt

while (<>) {
        print;
}

Short and sweet ? If you don't specify anything in the angle   =20
brackets, whatever is in @ARGV =
is used   =20
instead. And after it finishes with the first file, it will carry on =
with the   =20
next and so on. You'll need to remove non-file elements from @ARGV before you use this.    
perl =
myscript.pl stuff.txt out.txt

print while <>;

Read it right to left. It is possible to shorten it even further    ! =

perl myscript.pl stuff.txt out.txt

print <>;

This takes a little explanation. As you know, many things in   =20
Perl, including filehandles, can be evaluated in list or scalar context. =
The   =20
result that is returned depends on the context.    
@ARGV=3D"c:/scripts/out.txt";

$^I=3D".bk";              # let the magic begin

while (<>) {
        tr/A-Z/a-z/;    # another new function sneaked in
        print;          # this goes to the temp filehandle, ARGVOUT,=20
			# not STDOUT as usual, so don't mess with it !
}

So, what's happening? First, we load up @ARGV with   =20
the name of a file. It doesn't matter how @ARGV is loaded. =
We   =20
could have shifted the code =
from the   =20
command line.    
Beer
Wine
Pizza
Catfood

shorts
t-shirt
blouse

pizza
beer
wine
catfood

Viz
Private Eye
The Independent
Byte

toothpaste
soap
towel

$SHOP=3D"shop.txt";
$x=3D0;

open SHOP or die "Can't open $SHOP for read: $!\n";

while (<SHOP>) {
        if (/^\n/) {            # does line begin with newline ?
                $x++;           # if so, increment $x.  Rest of if =
statement not executed.
        } else {
                $list[$x].=3D$_;  # glue $_ on the end of whatever is in =
$list[$x], using a .
        }              =20
}

foreach (@list) {
        print "Items are:\n$_\n\n";
}

which works, but there is a much easier way to do it. You knew I   =20
was going to say that. 
$SHOP=3D"shop.txt";
$/=3D"\n\n";

open SHOP or die "Can't open $SHOP for read: $!\n";

while (<SHOP>) {
        push (@list, $_);
}

foreach (@list) {
        print "Items are:\n$_\n\n";
}

The $/ variable is a   =20
special variable (it even looks special). It is the Default Input =
Record   =20
Separator. Remember the operation of the angle brackets being to =
read a   =20
file in up until the next newline ? Time to come clean. What the angle =
bracket   =20
actually do is read up until whatever $/    =

is set to. It is set to a newline by default.    
Tea:Beer:Wine:Pizza:Catfood:Coffee:Chicken:Salmon:Icecream
$SHOP=3D"shop.txt";
$/=3D"\n\n";

open SHOP or die "Can't open $SHOP for read: $!\n";

$clothes=3D<SHOP>;        # everything up until the first =
occurrence of $/ into $clothes

$food=3D<SHOP>;   # everything from first occurrence of $/ to the =
second into $food

print "We need...\n",$clothes,"...and\n",$food;

And now we know that, there is a even quicker way to achieve the   =20
aim of the original program : 
$SHOP=3D"shop.txt";
$/=3D"\n\n";

open SHOP or die "Can't open $SHOP for read: $!\n";

@list=3D<SHOP>; # dumps *all* of $SHOP into @list, not just one =
line.

foreach (@list) {
        print "Items are:\n$_\n\n";
}

and you don't need to grab it all : 
@list[0..2]=3D<SHOP>=20

. We haven't mentioned list context for a while. Whether the line =20
input operator <> =
returns a =20
single value or a list depends on the context you use it in. When you =
supply =20
@xxxxx then this must be a =
list. If =20
you supply $xxxxx then that's =
a scalar =20
variable. You can force it into list context by using parens. 
($first, $second) =3D =
<SHOP>;
$first, $second =3D <SHOP>;

print "This is a long =
line of text which might be too long to fit on just one line\n";
print "and I was right, it was too long to fit on one line.  In fact, it =
looks like it\n";
print "might very well take up to FOUR, yes FOUR lines to print.  That's =
four print\n";
print "statements, which takes up even more room.  But wait! I'm wrong!  =
It will take\n";
print "FIVE lines to print this statement!  Or is that six lines? I'm =
not sure....\n";
The solution: 
$var=3D'variable =
interpolated';

print <<PRT;
This is a long line of text which might be too long to fit on just one =
line
and I was right, it was too long to fit on one line. In fact, it looks =
like
it might very well take up to FOUR, yes FOUR lines to print. =20

That's four print statements, which takes up even more room.  But wait! =
I'm=20
wrong!  It will take FIVE lines to print this statement!  Or maybe six =
lines?=20
I'm not sure....but anyway, just to prove this can be $var.
PRT
That's called a 'here' document and you don't need to use    =
PRT, you can use whatever you like within reason. You don't =
need    to put in explicit newlines, although if you do they perform as =
usual. Now you    know about here docs you can stop wearing the print    function out by calling it =
every couple of lines. You don't have    to use here docs to print to =
files, just anywhere you'd normally put a more    than one print statement.=20

$dir=3Dshift;	# shifts @ARGV, the command line =
arguments after the script name

chdir $dir or die "Can't chdir to $dir:$!\n" if $dir;

while (<*>) {
	print "Found a file: $_\n" if -T;
}

$dir =
=3Dshift;
$type=3D'txt';

chdir $dir or die "Can't chdir to $dir:$!\n" if $dir;

while (<*.$type>) {
	print "Found a file: $_\n";
}
like so. But, there is a better way to read from directories. The =
   method above is rather slow and inflexible.=20

$dir=3D shift || '.';

opendir DIR, $dir or die "Can't open directory $dir: $!\n";

while ($file=3D readdir DIR) {
	print "Found a file: $file\n";
}
The first difference is the first line, which essentially says if =
   shift is false, then =
$dir =3D    ., which is of course the current directory. =
Then, the directory is    opened and we have the chance to trap the =
error. It is assigned a filehandle.    The readdir function reads each file    =
into $file. There is no while   =
 (<WDIR>) { construct.    
$dir=3D shift || =
'.';

opendir DIR, $dir or die "Can't open directory $dir: $!\n";

while ($file=3D readdir DIR) {
	print "Found a file: $file\n" if -T $file ;
}
Firstly, because the filename is now not in $_ we    =
have to explicitly apply the -T =
test    to it with -T $file.    
        print =
"Found a file: $dir/$file\n" if -T "$dir/$file" ;

where we now specify the pathname, both in the printout and in    =
the file test itself. The "" are used because otherwise perl tries to =
divide    $file by $dir.    
$dir=3D shift || '.';

opendir DIR, $dir or die "Can't open directory $dir: $!\n";

while ($file=3D readdir DIR) {
	print "Found a file: '$file'\n";
}
Notice that two files are found which have interesting names,    =
namely . and .. . These two files are the =
current,    and lower directory respectively. Nothing new, they have =
always been there --    run the DOS command dir if you =
don't believe me. You don't    usually want to know about them, so: =

while ($file=3D readdir DIR) {
	next if $file=3D~/^\./;
	print "Found a file: '$file'\n";
}
is the usual workaround. You can use scalar context to dump    =
everything to a list of some description: 
$dir=3D shift || '.';

opendir DIR, $dir or die "Can't open directory $dir: $!\n";

@files=3Dreaddir(DIR);

print "@files";
but that includes the . files, so it is best to    =
ensure they aren't included: 
@files=3Dgrep !/^\./, readdir(DIR);
We haven't met -T yet,  =
  but for the moment just remember it searches a list and if it returns =
true,    lets the variable pass. In this case, if it doesn't begin with =
. then that's    true so it goes into @files.    
print "$myarray[1]";
print "$myhash{'BE'}";
Notice that the $ =
prefix    is used, because it is a scalar variable. =
Despite the fact it is part of a    list, it is still a scalar variable. =
The hash syntax is simply to use braces    { =
} instead of square brackets.    
@countries=3D('NL,The =
Netherlands','BE,Belgium','DE,Germany','MC,Monaco','ES,Spain');

print "Enter the country code:";
chop ($find=3D<STDIN>);

foreach (@countries) {
        ($code,$name)=3Dsplit /,/;
        if ($find=3D~/$code/i) {
                print "$name has the code $code\n";
        }
}
Complex and slow. We could also store a reference to another    =
array in each element of @countries =
,    but that is not efficient. Whatever way we choose, =
you still need to search    the whole thing. And what if @countries    is a big array ? See =
how much easier a hash is:=20

%countries=3D('NL','The =
Netherlands','BE','Belgium','DE','Germany','MC','Monaco','ES','Spain');

print "Enter the country code:";
chop ($find=3D<STDIN>);

$find=3D~tr/a-z/A-Z/;
print "$countries{$find} has the code $find\n";
Very easy. All we need to do is make sure everything is in    =
uppercase with tr and we are =
there.    Notice the way %countries =
is defined -    exactly the same as a normal array, except =
that the values are put into the    hash in key/value pairs.    
foreach (keys %countries) {
        print "The key $_ contains $countries{$_}\n";
}
which is useful. Note how any list can be fed to foreach , and off it goes. As usual, =
there    is another way to do the above: 
while (($code,$name)=3Deach %countries) {
        print "The key $code contains $name\n";
}
The each function =
returns    each key/value pair of the hash, and is slightly faster. In =
this example we    assign them to a list (you spotted the parens ?) and =
away we go. Eventually    there are no more pairs, which returns false =
to the while loop and it =
stops.    
print "The key $code contains =
$name\n" while ($code,$name)=3Deach %countries;

print "The key $_ contains $countries{$_}\n" foreach keys %countries;

foreach (sort keys %countries) =
{
        print "The key $_ contains $countries{$_}\n";
}
Spot the difference. Yes, sort    =
crept in there. If you want the list sorted backwards, =
some    cunning is called for. This is suitably foxy: 
foreach (reverse sort keys %countries) {
        print "The key $_ contains $countries{$_}\n";
}
Perl is just so difficult at times, don't you think ? This works  =
  because:    
print "Enter string to be reversed: ";
$input=3D<STDIN>;

@letters=3Dsplit //,$input;	# splits on the 'nothings' in between each =
character of $input

print join ":", @letters;	# joins all elements of @letters with \n, =
prints it
print reverse @letters;	# prints all of @letters, but sdrawkcab )-:
Perl's list operators can just feed directly to each other, =
saving many lines of code but also decreasing readability to those that =
aren't Perl-literate: 
print "Enter string to be reversed: ";
print join ":",reverse split //,$_=3D<STDIN>;
This section is about sorting, so enough of reverse . Time to go forwards instead. 
%countries=3D('976','Mongolia','52','Mexico','212','=
Morocco','64','New Zealand','33','France');

foreach (sort keys %countries) {
        print "The key $_ contains $countries{$_}\n";
}
You might want to sort numerically. In that case, you need to    =
understand how Perl's sort function works.  =

%countries=3D('976','Mongolia','52','Mexico','212','=
Morocco','64','New Zealand','33','France');

foreach (sort supersort keys %countries) {
        print "$_ $countries{$_}\n";
}

sub supersort {
        if ($a > $b) {
                return 1;
        } elsif ($a < $b) {=20
		return -1;
	} else {=20
		return 0;=20
	}
}
then it works correctly. Of course, there is an easier way. The   =
 'spaceship' operator <=3D> =
. It    does exactly what the supersort subroutine does, =
namely return 1, -1 or 0    depending on the comparison of two given =
values.    
%countries=3D('976','Mongolia','52','Mexico','212','=
Morocco','64','New Zealand','33','France');

foreach (sort { $a <=3D> $b } keys %countries) {
        print "$_ $countries{$_}\n";
}
Notice the { } braces, which define the contents as the    =
subroutine sort must use. Pretty short subroutine. There is a companion  =
  operator to <=3D> , =
namely cmp which does exactly =
the same thing but of    course compares the values as strings, not =
numbers.Remember, if you are    comparing numbers, your comparison =
operator should contain non-alphas, if you    are comparing strings the =
operator should contains alphas only. And don't talk    to =
strangers.    
foreach (sort values %countries) {
But Pointy Hair wants the keys too. And if you have a value you   =
 can't find the key.    
%countries=3D('976','Mongolia','52','Mexico','212','=
Morocco','64','New Zealand','33','France');

foreach (sort { $countries{$a} cmp $countries{$b} } keys %countries) {
        print "$_ $countries{$_}\n";
}
beautifully simple. If you want a reverse sort transpose $a and $b    .    
%countries=3D('976','Mongolia','52','Mexico','212','=
Morocco','64','New Zealand','33','France');
@nations=3Dqw(China Hungary Japan Canada Fiji);

@sorted=3D sort values %countries, @nations;

foreach (@nations, values %countries) {
        print "$_\n";
}

print "#----\n";

foreach (@sorted) {
        print "$_\n";
}
This sorts @nations and =
   the values from %countries =
into a new    array.    
@stuff=3Dqw(flying gliding skiing dancing parties =
racing);	# quote-worded list

@new =3D grep /ing/, @stuff;	# Creates @new, which contains elements of =
@stuff=20
				# matching with 'ing' in them.

print join ":",@stuff,"\n";	# first makes one string out of the elements =
of @stuff, joined
				# with ':' , then prints it, then prints \n

print join ":",@new,"\n";
Remember qw means =
'quote    words', so word boundaries are used as delimiters instead. The =
grep function must be fed a =
list on the    right hand side. On the left side, you may assign the =
results to a list or a    scalar variable. Assigning to a list gives you =
each actual element, and to a    scalar gives you the number of matches =
found: 
@stuff=3Dqw(flying gliding skiing dancing parties =
racing);

$new =3D grep /ing/, @stuff;

print join ":",@stuff,"\n";

print "Found $new elements of \@stuff which matched\n";
If you decide to modify the elements on their way through grep , you actually modify the =
original    list. Be careful out there. 
@stuff=3Dqw(flying gliding skiing dancing parties =
racing);

@new =3D grep s/ing//, @stuff;

print join ":",@stuff,"\n";
print join ":",@new,"\n";
To determine what actually matches you can either use an    =
expression or a block. Up to now we've been using expressions, but when =
things    become more complicated use a block: 
@stuff=3Dqw(flying gliding skiing dancing parties =
racing);

@new =3D grep { s/ing// if /^[gsp]/ } @stuff;

print join ":",@stuff,"\n";
print join ":",@new,"\n";
Try removing the braces and you'll get an error. Notice that the  =
  comma before the list has gone. It is now obvious where the expression =
ends,    as it is inside a block delimited with { } . The regex says if =
the element    begins with g, s or p, then remove ing. The result is =
only assigned to @new if the =
expression is completely true -    'parties' does begin with p, so that =
works, but s/ing// fails so =
the overall result is    false, and the value is not assigned to @new    .=20

@stuff=3Dqw(flying gliding skiing dancing parties =
racing);

print "There are ",scalar(@stuff)," elements in \@stuff\n";
print join ":",@stuff,"\n";

@mapped  =3D map  /ing/, @stuff;
@grepped =3D grep /ing/, @stuff;

print "There are ",scalar(@stuff)," elements in \@stuff\n";
print join ":",@stuff,"\n";

print "There are ",scalar(@mapped)," elements in \@mapped\n";
print join ":",@mapped,"\n";

print "There are ",scalar(@grepped)," elements in \@grepped\n";
print join ":",@grepped,"\n";
You can see that @mapped    =
is just a list of 1's. Notice that there are 5 ones =
   whereas there are six elements in the original array,    =
@stuff. This is because @mapped contains the =
true    results of map =
-- in every case    the expression /ing/ is successful,    except for =
'parties'.    
@letters=3D(a,b,c,d,e);

@ords=3Dmap ord, @letters;
print join ":",@ords,"\n";

@chrs=3Dmap chr, @ords;  =20
print join ":",@chrs,"\n";
This uses the ord    =
function to change each letter into its ASCII equivalent, =
then    the chr function =
convert ASCII numbers    to characters. If you change map to    grep in the example above, you can =
see    that nothing appears to happen. What is happening is that grep is trying the expression on =
each    element, and if it succeeds (is true) it returns the element, =
not the result.    The expression succeeds for each element, so each =
element is returned in turn.    Another example: 
@stuff=3Dqw(flying gliding skiing dancing parties =
racing);

print join ":",@stuff,"\n";

@mapped  =3D map  { s/(^[gsp])/$1 x 2/e } @stuff;
@grepped =3D grep { s/(^[gsp])/$1 x 2/e } @stuff;

print join ":",@stuff,"\n";
print join ":",@mapped,"\n";
print join ":",@grepped,"\n";
Recapping on regex, what that does is match any element beginning =
   with g, s or p, and replace it with the same element twice. The caret =
^ forces a match at the =
beginning of the    string, the [square brackets] denote a character =
class, and /e forces Perl to =
evaluate the RHS as an    expression.    
@mapped  =3D map  { chop } @stuff;
@grepped =3D grep { chop } @stuff;
The chop function =
removes    the last character from a string, and returns it. So that's =
what you get back    from ^ , =
the result of the    expression. The grep function gives    you the =
mangled remains of the original value.=20

@stuff=3Dqw(flying gliding skiing dancing parties =
racing);

print join ":",@stuff,"\n";

@mapped  =3D map  { &isit } @stuff;
@grepped =3D grep { &isit } @stuff;

print join ":",@mapped,"\n";
print join ":",@grepped,"\n";

sub isit {
        ($word)=3D/(^.*)ing/;

        if (length $word =3D=3D 3) {
                return "ok";
        } else {
                return 0;
        }
}
The subroutine isit =
first    grabs everything up until 'ing', puts it into =
$word    , then returns 'ok' =
if the there are three characters in $word =
. If not, it returns the false value    0. You can make =
these subroutines (think of them as functions) as complex as    you =
like.    
@grepstuff=3D@mapstuff=3Dqw(flying gliding skiing =
dancing parties racing);

print join " ",map  { s/(^[gsp])/$1 x 2/e } @mapstuff;
print "\n";
print join " ",grep { s/(^[gsp])/$1 x 2/e } @grepstuff;
Now, make sure $_ is =
the    last thing evaluated: 
@grepstuff=3D@mapstuff=3Dqw(flying gliding skiing =
dancing parties racing);

print join " ",map  { s/(^[gsp])/$1 x 2/e;$_} @mapstuff;
print "\n";
print join " ",grep { s/(^[gsp])/$1 x 2/e } @grepstuff;
and there you have it. Now you understand that you can go and    =
impress your friends, but please don't count on success.=20

system("vole");

print "\n\nResult: $?\n\n";

system("vol");

print "\n\nResult: $?\n\n";
As you can see, a successful system call returns 0. An    =
unsuccessful one returns a value which you need to divide by 256 to get =
the    real return value. Also notice you can see the output. And =
because system returns, the =
code after the first    system =
call is executed. Not so with    exec, which will terminate your perl =
   script if it is successful. Perl's usual use of single and double =
quotes    applies as per variable interpolation.=20

$volume=3D`vol`;

print "The contents of the variable \$volume are:\n\n";

print $volume;

print "\nWe shall regexise this variable thus :\n\n";

$volume=3D~m#Volume in drive \w is (.*)#;

print "$1\n";
As you can see here, the Win32 vol command is executed. We just   =
 print it out, escaping the $ =
in the    variable name. Then a simple regex, using # as a =
delimiter just in case you'd    forgotten delimiters don't have to be / =
.=20

open TRIN, "tree =
c:\\ /a |" or die "Can't see the tree :$!";

while (<TRIN>) {
	print "$. $_";
}
Note the | which =
denotes    that data is to be piped from the specified process. =
You can also pipe    data to a process by using | as    the first character.    =

open TRIN, =
"tree c:\\ /a |" or die "Can't see the tree :$!";

while (<TRIN>) {
	printf "%3s $_", $.;
	last if $. =3D=3D 10;
}
As soon as $. hits 10 =
we    shut the process off by exiting the loop. Easy.    
open TRIN, "tree c:\\ /a =
|" or die "Can't see the tree :$!";

while (<TRIN>) {
	printf "%3s $_", $.;
	last if $. >=3D 10;
}
exit your loops in a paranoid manner, unless you really    =
mean only to exit when at line ten. For maximum safety, maybe you should =
   create your own counter variable because $. is a global =
variable.    I'm not necessarily advocating doing any of the above, but =
I am suggested    these things are considered.    
$windir=3D$ENV{'WINDIR'};		# yes, you =
can access the environment variables !

$x=3D0;

opendir WDIR, "$windir" or die "Can't open $windir !!! Panic : $!";

while ($file=3D readdir WDIR) {
	next if $file=3D~/^\./;		# try commenting this line to see why it is =
there

	$age=3D -M "$windir/$file";	# -M returns the age in days
	$age=3D~s/(\d*\.\d{3}).*/$1/;	# hmmmmm

	#### %4.4d - must take up 4 columns, and pad with 0s to make up space
	####         and minimum width is also 4
	#### %10s  - must take up 10 columns, pad with spaces
	# printf "%4.4d %10s %45s \n", $x, $age, $file;

	#### %-10s - left justify
	# printf "%4.4d %-10s %-45s \n", $x, $age, $file;

	####  %10.3 - use 10 columns, pad with 0s if less than 3 columns used
	# printf "%4.4d %10.3d %45s \n", $x, $age, $file;

	$x++;

	last if $x=3D=3D15;			# we don't want to go through all the files :-)
}
There are some intentionally new functions there. When you start  =
  hacking Perl (actually, you already started if you have worked through =
this    far) you'll see a lot of example code. Try and understand the =
above, then read    the explanation below.    
open TRIN, "tree c:\\ /a |" or die "Can't see the =
tree :$!";

while (<TRIN>) {
	$line=3D sprintf "%3s $_", $.;
	print $line;
	last if $. =3D=3D 10;
}

@opts=3Dqw(w on ad oe =
b);

for (@opts) {
	$result=3Dqx(dir /$_);
	print "dir /$_ resulted in:\n$result",'-' x 79;
	sleep 1;
}
Anything within qx( ) =
is    executed, and duly variable interpolated. This =
sample also demonstrated qw =
which is 'quote words', so the elements    of =
@opts are delimited by word boundaries, not the usual =
commas.    You can also use for =
instead of foreach =
if you want to save typing four    character for the sake =
of legibility.    
perl -e"for (55..75) { print chr($_) }"

perl -e"while (<>) {print if /^[bv]/i}" =
shop.txt

perl -ne"print if /^[bv]/i" shop.txt

perl -ne"printf \"$ARGV : %3s : $_\",$. if =
/^[bv]/i" shop.txt
which demonstrates that doublequotes must be escaped.    
perl -i.bk -ne"printf \"%4s : $_\",$." shop2.txt

>> this is what was said
>> blah blah
> blaaaaahhh

The new text

perl -i.bk -pe"s/^>+ ?//" email.txt

perl -e"print 50/200+2"
perl -e"for (50..90) { print chr($_) }"

perl -e"for $i (50..90) { print chr($i),\" is =
$i\n\" }"

perl -e"for $i (50..90) { print chr($i),qq| is $i\n| }

($height,$angle)=3D@ARGV;		# @ARGV =
is the command line parameters

$distance=3D$height*$angle;	# an easy calculation

print "With a glide ratio of $angle:1 you can fly $distance from =
$height\n";

perl yourscript.pl 5000 24

($height,$angle)=3D@ARGV;

$distance=3D$height*$angle;
print "With a glide ratio of $angle:1 you can fly $distance from =
$height\n";

$angle++;			# add 1 to $angle
$distance=3D$height*$angle;
print "With a glide ratio of $angle:1 you can fly $distance from =
$height\n";

$angle-=3D2;			# subtract 2 from $angle so it is 1 less than the =
original
$distance=3D$height*$angle;
print "With a glide ratio of $angle:1 you can fly $distance from =
$height\n";

($height,$angle)=3D@ARGV;

&howfar;
print "With a glide ratio of $angle:1 you can fly $distance from =
$height\n";

$angle++;
&howfar;
print "With a glide ratio of $angle:1 you can fly $distance from =
$height\n";

$angle-=3D2;
&howfar;
print "With a glide ratio of $angle:1 you can fly $distance from =
$height\n";

sub howfar {				# sub subroutinename
	$distance=3D$height*$angle;
}

($height,$angle)=3D@ARGV;

$height/=3D3.2;			# divide feet by 3.2 to get metres

&howfar;
print "With a glide ratio of $angle:1 you can fly $distance from =
$height\n";

$angle++;
&howfar;
print "With a glide ratio of $angle:1 you can fly $distance from =
$height\n";

$angle-=3D2;
&howfar;
print "With a glide ratio of $angle:1 you can fly $distance from =
$height\n";

sub howfar {
	$distance=3D$height*$angle;
}

($height,$ratio)=3D@ARGV;
$cnv1=3D3.2;			# now it is a variable.  Could easily be a cmd line=20
				# parameter too.  We have the flexibility.
$height  =3Dint($height/$cnv1);	# divide feet by 3.2 to get metres

&howfar;
print "With a glide ratio of $ratio:1 you can fly $distance from =
$height\n";

$ratio++;
&howfar;
print "With a glide ratio of $ratio:1 you can fly $distance from =
$height\n";

$ratio-=3D2;
&howfar;
print "With a glide ratio of $ratio:1 you can fly $distance from =
$height\n";

sub howfar {
	$distance=3Dint($height*$ratio);
}

($height,$ratio)=3D@ARGV;
$cnv1=3D3.2;		=09

&howfar($height,$ratio);
print "With a glide ratio of $ratio:1 you can fly $distance from =
$height\n";

&howfar($height,$ratio+1);
print "With a glide ratio of ",$ratio+1,":1 you can fly $distance from =
$height\n";

&howfar($height,$ratio-1);
print "With a glide ratio of ",$ratio-1,":1 you can fly $distance from =
$height\n";

sub howfar {
	print "The parameters passed to this subroutine are @_\n";
	($ht,$rt)=3D@_;
	$ht  =3Dint($ht/$cnv1);
	$distance=3Dint($ht*$rt);
}

$name=3D'Rover';
$pet =3D'dog';
$age =3D3;

print "$name the $pet is aged $age\n";

{
	my $age =3D4;	  # run this again, but comment this line out
	my $name=3D'Spot';  # and this one
	$pet    =3D'cat';

	print "$name the $pet is aged $age\n";
}

print "$name the $pet is aged $age\n";
This is pretty straightforward until we get to the { . This marks the start of a =
block.    One feature of a block is that it can have its own =
namespace. Variables    declared, in other words initialised, within =
that block are just normal    variables, unless they are declared with =
my    .    
($height,$ratio)=3D@ARGV;
$cnv1=3D3.2;		=09

&howfar($height,$ratio);
print "With a glide ratio of $ratio:1 you can fly $distance from =
$height\n";

&howfar($height,$ratio+1);
print "With a glide ratio of ",$ratio+1,":1 you can fly $distance from =
$height\n";

&howfar($height,$ratio-1);
print "With a glide ratio of ",$ratio-1,":1 you can fly $distance from =
$height\n";

sub howfar {
	my ($height,$ratio)=3D@_;
	$height  =3Dint($height/$cnv1);
	$distance=3Dint($height*$ratio);
}

($height,$ratio)=3D@ARGV;
$cnv1=3D3.2;		=09

$distance=3D&howfar($height,$ratio);  # run this again and delete =
'$distance=3D'
print "With a glide ratio of $ratio:1 you can fly $distance from =
$height\n";

$distance=3D&howfar($height,$ratio+1);
print "With a glide ratio of ",$ratio+1,":1 you can fly $distance from =
$height\n";

$distance=3D&howfar($height,$ratio-1);
print "With a glide ratio of ",$ratio-1,":1 you can fly $distance from =
$height\n";

sub howfar {
	my ($height,$ratio)=3D@_;
	my $distance;
	$height  =3Dint($height/$cnv1);
	$distance=3Dint($height*$ratio/1000); 	# output result in kilometres =
not metres
}

($height,$ratio,$airspeed)=3D@ARGV;
$cnv1=3D3.2;		=09
$cnv2=3D1.8;

($distance,$time)=3D&howfar($height,$ratio,$airspeed);
print "Glide ratio $ratio:1, $distance from $height taking $time\n";

($distance,$time)=3D&howfar($height,$ratio+1,$airspeed);
print "Glide ratio ",$ratio+1,":1, $distance from $height taking =
$time\n";

($distance,$time)=3D&howfar($height,$ratio-1,$airspeed);
print "Glide ratio ",$ratio-1,":1, $distance from $height taking =
$time\n";

sub howfar {
	my ($height,$ratio,$airspeed)=3D@_;
	my ($distance,$time);			    # how to 'my' multiple variables
	$airspeed*=3D$cnv2;		 	    # convert knots to kmph
	$height  =3Dint($height/$cnv1);
	$distance=3Dint($height*$ratio/1000);
	$time	 =3Dint($distance/($airspeed/60));    # simple time conversion
	# print "Time:$time, Distance:$distance\n"; # uncomment this later
}

($height,$ratio,$airspeed)=3D@ARGV;
$cnv1=3D3.2;		=09
$cnv2=3D1.8;

($distance,$time)=3D&howfar($height,$ratio,$airspeed);
print "Glide ratio $ratio:1, $distance from $height taking $time\n";

($distance,$time)=3D&howfar($height,$ratio+1,$airspeed);
print "Glide ratio ",$ratio+1,":1, $distance from $height taking =
$time\n";

($distance,$time)=3D&howfar($height,$ratio-1,$airspeed);
print "Glide ratio ",$ratio-1,":1, $distance from $height taking =
$time\n";

sub howfar {
	my ($height,$ratio,$airspeed)=3D@_;
	my ($distance,$time);			 # how lexically scope multiple variables
	$airspeed*=3D$cnv2;			 # convert knots to kmph
	$height  =3Dint($height/$cnv1);
	$distance=3Dint($height*$ratio/1000); 	 # output result in kilometres =
not metres
	$time	 =3Dint($distance/($airspeed/60)); # simple time conversion
	return ($distance,$time);		 # explicit return
}

($height,$ratio,$airspeed)=3D@ARGV;
$cnv1=3D3.2;		=09
$cnv2=3D1.8;

($distance,$time)=3D&howfar($height,$ratio,$airspeed);
print "Glide ratio $ratio:1, $distance from $height taking $time\n";

($distance,$time)=3D&howfar($height,$ratio+1,$airspeed);
print "Glide ratio ",$ratio+1,":1, $distance from $height taking =
$time\n";

$distance=3D&howfar($height,$ratio-1);	# old way of calling it
print "With a glide ratio of ",$ratio-1,":1 you can fly $distance from =
$height\n";

sub howfar {
	my ($height,$ratio,$airspeed)=3D@_;
	my ($distance,$time);			=20
	$airspeed*=3D$cnv2;			=20
	$height  =3Dint($height/$cnv1);
	$distance=3Dint($height*$ratio/1000); 	=20
	$time	 =3Dint($distance/($airspeed/60));=20
	return ($distance,$time);
}

($height,$ratio,$airspeed)=3D@ARGV;
$cnv1=3D3.2;		=09
$cnv2=3D1.8;

($distance,$time)=3D&howfar($height,$ratio,$airspeed);
print "Glide ratio $ratio:1, $distance from $height taking $time\n";

($distance,$time)=3D&howfar($height,$ratio+1,$airspeed);
print "Glide ratio ",$ratio+1,":1, $distance from $height taking =
$time\n";

$distance=3D&howfar($height,$ratio-1);
print "With a glide ratio of ",$ratio-1,":1 you can fly $distance from =
$height\n";

print "Direct print: ",join ",",&howfar(5000,55,60)," not bad for no =
engine!\n";

sub howfar {
	my ($height,$ratio,$airspeed)=3D@_;
	my ($distance,$time);			 # how to 'my' multiple variables
	$airspeed*=3D$cnv2;			 # convert knots to kmph
	$height  =3Dint($height/$cnv1);
	$distance=3Dint($height*$ratio/1000); 	 # output result in kilometres =
not metres
	if ($airspeed > 0) {
		$time	 =3Dint($distance/($airspeed/60));
		return ($distance,$time);
	} else {
		return $distance;
	}
}

sub howfar {
	my ($height,$ratio,$airspeed)=3D@_;
	my ($distance,$time);			 # how to 'my' multiple variables
	$airspeed*=3D$cnv2;			 # convert knots to kmph
	$height  =3Dint($height/$cnv1);
	$distance=3Dint($height*$ratio/1000); 	 # output result in kilometres =
not metres
	$time	 =3Dint($distance/($airspeed/60)) if $airspeed > 0;
	return ($distance,$time);
}

$distance=3D&howfar($height,$ratio-1);

$word=3D&wordfunc("Greetings");
print "The word is $word\n";

(@words)=3D&wordfunc("Bonjour");
print "The words are @words\n";

sub wordfunc {
my $word=3Dshift;		# when in a subroutine, shifts @_ if no target =
specified
	my @words;				# how to my an array
	@words=3Dsplit //,$word;			# splits on the nothings between each letter
	($first,$last)=3D($words[0],$words[$#words]);  # see section on Arrays =
if required
	return ($first,$last);			# Returns just the first and last
}

($word)=3D&wordfunc("Greetings");

@words=3D@ARGV;

print "Output Field Separator is :$,:\n";
print '1. Words:', @words, "\n";

&change;

$,=3D'_';

print "\nOutput Field Separator is :$,:\n";
print '2. Words:', @words, "\n";

&change;

sub change {
	print '   Words:', @words, "\n";
}which should be executed something like this: 
perl test.pl sarcasm is the lowest form of wit
The special variable $,    =
defines what Perl should print in between lists it is =
given. By    default, it is nothing. So the first two prints should have =
no spaces between    the words. Then we assign '_' to $, so    the next prints have =
underscores between the words.    
@words=3D@ARGV;

print "Output Field Separator is :$,:\n";
print '1. Words:', @words, "\n";

&change;

$,=3D"_";

print "\nOutput Field Separator is :$,:\n";
print '2. Words:', @words, "\n";

&change;

sub change {
	$save=3D$,;
	$,=3D'*';
	print '   Words:', @words, "\n";
	$,=3D$save;
}
That works, but it is messy. Perl has a special function for    =
occasions of this nature, called local    =
. An example of local =
in    action: 
@words=3D@ARGV;

print "Output Field Separator is :$,:\n";
print '1. Words:', @words, "\n";

&change;

$,=3D"_";

print "\nOutput Field Separator is :$,:\n";
print '2. Words:', @words, "\n";

&change;

sub change {
        local $,=3D"!-!";
	print '   Words:', @words, "\n";
}
You can try it with my    =
instead but it won't work. I'm sure you'll try it anyway, =
I know    you learn things the hard way otherwise you a) wouldn't be =
programming    computers and b) wouldn't be using this tutorial to do =
it.    
($w1,$w2)=3D&wordfunc("Hello World");	# =
Assign the array references to scalars

print "@$w1 and @$w2\n";		# deference, ie access, the arrays referred to
#print "$w1 and $w2\n";			# uncomment this next time round

sub wordfunc {
        my $phrase=3Dshift;
	my (@words,@word1,@word2);	# declare three variables lexically
	@words=3Dsplit /\s+/,$phrase;	# split the phrase on whitespace
	@word1=3Dsplit //,$words[0];	# create array of letters from the first =
word
	@word2=3Dsplit //,$words[1];	# and the second
	return (\@word1,\@word2);	# return references to the two arrays -- =
scalars
}

use File::Find;

$dir1=3D'/some/dir/with/lots/of/files';
$dir2=3D'/another/directory/';

find(\&wanted, $dir1,$dir2);

sub wanted {
	print "Found it $File::Find::dir/$_\n" if /^[a-d]/i;

}

use Win32::ChangeNotify;

$Path=3D'/downloads';
$WatchSubTree=3D0;
$Events=3D'FILE_NAME';
$browser=3D'E:/progs/netscape/Communicator/program/netscape.exe';
$changes=3D0;

$notify =3D Win32::ChangeNotify->new($Path,$WatchSubTree,$Events);

while (1) {
	print "- ",scalar(localtime)," $changes so far to $Path.\n";
	$notify->wait;
	++$changes;
	print "- ",scalar(localtime), " Launching $browser...\n";
	system("$browser $Path");
	$notify->reset;
}

$name=3Dshift;

print &logname($name);

sub logname {
	my $name=3Dshift;
	my @namebits;
	my ($logon,$inital);
	@namebits=3Dsplit /\s+/,$name;
	($inital)=3D$name=3D~/(\w)/;
	$logon=3D$inital.$namebits[$#namebits];
	$logon=3Dlc $logon;
	return $logon;
}

sub logname {
        my $name=3Dshift;
        my @namebits;
        my ($logon,$inital);
        @namebits=3Dsplit /\s+/,$name;
        ($inital)=3D$name=3D~/(\w)/;
        $logon=3D$inital.$namebits[$#namebits];
        $logon=3Dlc $logon;
        return $logon;
}

1;

use RMP::logon;

$name=3Dshift;

print logname($name);

@input=3D@ARGV;

$outfile=3D'outfile.txt';
open OUT, ">$outfile" or die "Can't open $outfile for write:$!\n";

$input2++;
$delay=3D2 if $input[0] eq 'sleep';

sleep $delay;

print "The first element of \@input is $input[0]\n";
print OUY "Slept $delay!\n";

perl -w script.pl hello
Perl finds quite a few errors. The -w =
   switch finds, among other heinous sins:    
perl =
script.pl hello
to execute this: 
#!perl -w

@input=3D@ARGV;

$outfile=3D'outfile.txt';
open OUT, ">$outfile" or die "Can't open $outfile for write:$!\n";

$input2++;
$delay=3D2 if $input[0] eq 'sleep';

sleep $delay;

print "The first element of \@input is $input[0]\n";
print OUY "Slept $delay!\n";

perl -w =
script.pl hello
It may be more convenient for you to put the flag inside the    =
script. It doesn't have to be just -w    =
, it can be any argument Perl supports. Run 
perl -hfor a full list.    
perl script.pl "Alain James Smith";
where the "" enclose the string as a single parameter as opposed  =
  to three separate space-delimited parameters. 
#use strict;			# uncomment after running a couple =
of times

$name=3Dshift;			# shifts @ARGV if no arguments supplied

print "The name is $name\n";
$inis=3D&initials($name);

$luck=3Dint(rand(10)) if $inis=3D~/^(?:[a-d]|[n-p]|[x-z])/i;

print "The initials are $inis, lucky number: $luck\n";

sub initials {
        my $name=3Dshift;
        $initials.=3D$1 while $name=3D~/(\w)\w+\s?/g;
        return $initials;
}

Global symbol "$name" requires explicit package name at n1.pl =
line 3.
Global symbol "$inis" requires explicit package name at n1.pl line 6.
Global symbol "$luck" requires explicit package name at n1.pl line 8.
Global symbol "$initials" requires explicit package name at n1.pl line =
14.
Execution of n1.pl aborted due to compilation errors.

use strict;

$MAIN::name=3Dshift;			# shifts @ARGV if no arguments supplied

print "The name is ",$MAIN::name,"\n";
my $inis=3D'';
my $luck=3D'';

$inis=3D&initials($MAIN::name);

$luck=3Dint(rand(10)) if $inis=3D~/^(?:[a-d]|[n-p]|[x-z])/i;

print "The initials are $inis, lucky number: $luck\n";

sub initials {
        my $name=3Dshift;
	my $initials;
        $initials.=3D$1 while $name=3D~/(\w)\w+\s?/g;
        return $initials;
}

$name=3Dshift;

print "Logon name creation program\n:Converting '$name'\n";

print &logname($name),"\n\n";

print "Program ended at", scalar(localtime),"\n";

sub logname {
        my $name=3Dshift;
        my @namebits;
        my ($logon,$inital);
        @namebits=3Dsplit /\s+/,$name;
        ($inital)=3D$name=3D~/(\w)/;
        $logon=3D$inital.$namebits[$#namebits];
        $logon=3Dlc $logon;
        return $logon;
}

perl -d script.pl "Peter Dakin";
and you are into the debugger, which should look something like   =
 this: 
c:\scripts\db.pl>perl -d db.pl "Peter Dakin"

Loading DB routines from perl5db.pl version 1.0401
Emacs support available.

Enter h or `h h' for help.

main::(db.pl:1):        $name=3Dshift;
  DB<1>

main::(db.pl:1): =
       $name=3Dshift;
  DB<1> s
main::(db.pl:3):        print "Logon name creation program\n:Converting =
'$name'\n";
  DB<1> $name=3D~s/\s//g;

  DB<2> print $name
MarkGray
  DB<3>

open STUFF, $stuff or die "Cannot open =
$stuff for read :$!";

$_=3Dshift;

/^R/ or print "Doesn't start with R\n";

perl -e"print 2+8

perl -e"print 2+8/2

perl -e"print ((2+8)/2)

@list=3Dqw(a b c);

$name1 =3D  $list[4] or "1-Unknown";

$name2 =3D  $list[4] || "2-Unknown";

print "Name1 is $name1, Name2 is $name2\n";

print "Name1 exists\n" if defined $name1;
print "Name2 exists\n" if defined $name2;

@list=3Dqw(a b c);

$ele1 =3D $list[4] or print "1 Failed\n";
$ele2 =3D $list[4] || print "2 Failed\n";

print <<PRT;
ele1 :$ele1:

ele2 :$ele2:

PRT

$file=3D'not-there.txt';

open FILE, $file   || print "1: Can't open file:$!\n";

open FILE, $file   or print "2: Can't open file:$!\n";

$file=3D'not-there.txt';

open FILE, $file   || print "1: Can't open file:$!\n";

open FILE, $file   or print "2: Can't open file:$!\n";

open (FILE, $file) || print "3: Can't open file:$!\n";

@list=3Dqw(a b c);

$name1 =3D  $list[4]   or "1-Unknown";

($name2 =3D  $list[4]) || "2-Unknown";

print "Name1 is $name1, Name2 is $name2\n";

print "Name1 exists\n" if defined $name1;
print "Name2 exists\n" if defined $name2;

@list=3Dqw(a b c);

print "List is:@list\n";

if ($list[0] eq 'x' && $list[2]++ eq 'd') {
	print "True\n";
	} else {
	print "False\n";
}

print "List is:@list\n";

@list=3Dqw(a b c);

print "List is:@list\n";

if ($list[0] eq 'x' & $list[2]++ eq 'd') {
	print "True\n";
	} else {
	print "False\n";
}

print "List is:@list\n";

$x =
!~/match/;

if ($t !=3D 5) {

($name1,$name2)=3D@ARGV;

if ($name1 eq 'Jane' xor $name2 eq 'Sonia') {
	print "OK, allowed\n";
} else {
	print "Sorry, not allowed\n";
}

perl script.pl Jane Karen (one true, one =
false)

perl script.pl Jim Sonia (one =
true, one false)

perl script.pl Jane Sonia (both =
true)

perl script.pl Jim Sam (both =
false)

$_=3Dshift;

print "OK\n" unless not(!/r/i || /o/i & /p/ or /q/);

--
Robert

/z{3}/	3 z only
/z{3,}/	At least 3 z
/z{1,3}/	1 to 3 z
/z{4,8}/	4 to 8 z

All the keys	`print keys = %countries;`=20
All the values	`print values = %countries;`=20
A Slice of Hash :-)	`print = @countries{'NL','BE'};`=20
How many elements ?	`print scalar(keys=20 %countries);`
Does the key exist ?	`print "It's there !\n" if exists=20 $countries{'NL'};`

db.pl	Name of script being executed
1	Line number of script that is just about to be = executed.
$name=3Dshift;	The code that is just about to be = executed.

`n`	Executes main program, but skips subroutine calls. The = subroutine is=20 executed, but you aren't stepped through it. Try using `n=20`instead of `s` .
`/xx/`	Searches through program for xx
`p`	Prints, for example `p @namebits`, `p = $name`=20
`Enter`	Pressing the Enter key (inputting a carriage return) repeats = the=20 last `n` or `s` command.
`perlcode`	You can type any perl code in and it will be evaluated, and = have a=20 effect on your program. In the example below I remove spaces = from=20 `$name`. Inputs in bold: main::(db.pl:1): = $name=3Dshift; DB<1> s main::(db.pl:3): print "Logon name creation program\n:Converting = '$name'\n"; DB<1> $name=3D~s/\s//g; DB<2> print $name MarkGray DB<3>

Comparison	Numeric	String
Equal	=3D=3D	eq
Not equal	!=3D	ne
Greater than	>	gt
Less than	<	lt
Greater than or equal to	>=3D	ge
Less than or equal to	<=3D	le

push	Adds value to the end of the array
pop	Removes and returns value from end of array
shift	Removes and returns value from beginning of array
unshift	Adds value to the beginning of array =

Assigning	`$countries{PT}=3D'Portugal';`
Deleting	`delete=20 $countries{NL};`

Robert's Perl Tutorial

Introduction

This tutorial is...

This tutorial is not...

The Table of Contents

What you need to know

What you need to have

How to use this tutorial...

Conventions used in this Tutorial

Use of this document

Personal Printouts

Intranet usage

Mirroring

Translations

A Short Introduction To Perl

What is Perl?

What is ActivePerl? Are the other Perls inactive?

Can I run Perl on my computer?

What can I do with Perl ?

The Internet

Systems Administration

What can't I do with Perl ?

Support

Setup

1. Getting the Software

2. Installation

3. Testing - Your First Perl Script

The Tutorial: The Journey Begins

Your First Time

What if it doesn't...?

Assuming it's now all right...

Shebang

Variables

Scalars

$ % @ are Good Things

Typing

Variable Interpolation

Changing Variables

Auto(de|in)crements

Escaping

Context: About Perl and @^$%&~`/?

Strings and Increments

Print: A List Operator

Subroutines -- A First Look

Comments

Comparisons

An iffy start

The Truth According to Perl

Equality and Perl

All Equality is Not Equal: Numeric versus String

An interlude -- The Perl Motto

The Comparison Operators Listed

The Golden Rule of Comparisons

More About If: Multiples

elsif

User Input

STDIN and other filehandles

Chop

Safe Chopping with Chomp

Arrays

Lists, herds -- what are arrays?

Basic Array Work

Elements of Arrays

How to refer to elements of an array

More ways to access arrays

For Loops

A for Loop demonstrated

For loops with .. , the range operator

foreach

The infamous $_

A Premature End to your loop

A little more control over the premature ending: Labels

Changing the Elements of an Array

Jiggerypokery with Arrays

A table of array hacking functions

Splice

Deleting Variables

False values versus Existence: It is, therefore...

Basic Regular Expressions

An introduction