Beginning Perl Web Development - From Novice To Professional (2006)

310A P P E N D I X ■ P E R L B A S I C S

$a = "A9"; print ++$a, "\ n"; $a = "bz"; print ++$a, "\ n"; $a = "Zz"; print ++$a, "\ n"; $a = "z9"; print ++$a, "\ n"; $a = "9z"; print ++$a, "\ n";

should produce

$ perl auto2.pl B0

ca AAa aa0 10

$

This shows that a 9 turns into a 0 and increments the next digit left. A z turns into an a and increments the next digit left, and if there are no more digits to the left, either an a or an A is created depending on the case of the current leftmost digit.

Multiple Assignments

We’ve said that = is an operator, but does that mean it returns a value? Well, actually it does, it returns whatever was assigned. This allows us to set several variables up at once. Here’s a simple example of this (read it from right to left):

$d = $c = $b = $a = 1;

First we set $a to 1, and the result of this is 1. $b is set with that, the result of which is 1. And so it goes on.

Scoping

All the variables we’ve seen so far in our programs have been global variables. That is, they can be seen and changed from anywhere in the program. For the moment, that’s not too much of a problem, since our programs are very small, and we can easily understand where things get assigned and used. However, when we start writing larger programs, this becomes a problem.

Why is this? Well, suppose one part of your program uses a variable, $counter. If another part of your program wants a counter, it can’t call it $counter as well for fear of clobbering the old value. This becomes more of an issue when we get into subroutines, which are little sections of code we can temporarily call upon to accomplish something for us before returning to what we were previously doing. Currently, we’d have to make sure all the variables in our program had different names, and with a large program that’s not desirable. It would be easier to restrict the life of a variable to a certain area of the program.

To achieve this, Perl provides another type of variable: lexical variables. These are constrained to the enclosing block and all blocks inside it. If they’re not currently inside a block, they are constrained to the current file. To tell Perl that a variable is lexical, we say my_$variable;. This creates a brand-new lexical variable for the current block, and sets it to the undefined value. Here’s an example:

#!/usr/bin/perl -w

# scope1.pl

$record = 4;

print "We're at record ", $record, "\ n";

{

my $record; $record = 7;

print "Inside the block, we're at record ", $record, "\ n";

}

print "Outside, we're still at record ", $record, "\ n";

This should tell you

$ perl scope1.pl We're at record 4

Inside the block, we're at record 7 Outside we're still at record 4

$

Let’s look at how this program works. First, we set our global variable $record to 4.

$record = 4;

print "We're at record ", $record, "\ n";

Now we enter a new block and create a new lexical variable. Important! This is completely and utterly unrelated to the global variable $record as my() creates a new lexical variable. This exists for the duration of the block only, and has the undefined value.

{

my $record;

Next, the lexical variable is set to 7, and printed out. The global $record is unchanged.

$record = 7;

print "Inside the block, we're at record ", $record, "\ n";

Finally, the block ends, and the lexical copy ends with it. We say that it has gone out of scope. The global remains, however, and so $record has the value 4.

}

print "Outside, we're still at record ", $record, "\ n";

In order to make us think clearly about our programming, we will ask Perl to be strict about our variable use. The statement use strict; checks that, among other things, we’ve declared all our variables. We declare lexicals with the my() function. Here’s what happens if we change our program to use strict format:

312 A P P E N D I X ■ P E R L B A S I C S

#!/usr/bin/perl -w

# scope2.pl

use strict;

$record = 4;

print "We're at record ", $record, "\ n";

{

my $record; $record = 7;

print "Inside the block, we're at record ", $record, "\ n";

}

print "Outside, we're still at record ", $record, "\ n";

Now, the global $record is not declared. So sure enough, Perl complains about it, generating this output:

$ perl scope2.pl

Global symbol "$record" requires explicit package name at scope2.pl line 6. Global symbol "$record" requires explicit package name at scope2.pl line 7. Global symbol "$record" requires explicit package name at scope2.pl line 15. Execution of scope2.pl aborted due to compilation errors.

$

We’ll see exactly what this means in later chapters (in Beginning Perl, Second Edition), but for now it suffices to declare $record as a my() variable:

#!/usr/bin/perl -w

# scope3.pl

use strict;

my $record; $record = 4;

print "We're at record ", $record, "\ n";

{

my $record; $record = 7;

print "Inside the block, we're at record ", $record, "\ n";

}

print "Outside, we're still at record ", $record, "\ n";

Now Perl is happy, and we get the same output as before. You should almost always start your programs with a use strict. Of course, nobody’s going to force you to do so, but it will help you avoid a lot of mistakes, and it will certainly give other people who have to look at

314 A P P E N D I X ■ P E R L B A S I C S

my $name = "fred";

print 'My name is $name\ n';

Here we get

$ perl varint2.pl My name is $name\ n$

Notice that the system prompt is printed at the end of that line because \ n is not a newline character within the single quotes. This doesn’t just happen in things we print, it happens every time we construct a string:

#!/usr/bin/perl -w

# varint3.pl

use strict;

my $name = "fred";

my $salutation = "Dear $name,"; print $salutation, "\ n";

This gives us

$ perl varint3.pl Dear fred,

$

This has exactly the same effect as

my $salutation = "Dear " . $name . ",";

but is more concise and easier to understand.

If you need to place text immediately after the variable, you can use curly braces to delimit the name of the variable. Take this example:

#!/usr/bin/perl -w

# varint4.pl

use strict;

my $times = 8;

print "This is the $timesth time.\ n";

This is syntactically incorrect, because Perl looks for a variable $timesth, which hasn’t been declared. In this case, we have to change the last line by wrapping the variable name in curly braces to this:

print "This is the ${ times} th time.\ n";

Now we get the right result:

$ perl varint4.pl This is the 8th time.

$

The if Statement

In programming, we often need to test a condition, and if that condition is true, take some action. This can be performed using an if statement, which has the general syntax

if ( condition ) { statements

}

Don’t type this in and try to make it run—it is meant to be a general structure of the construct. An important note: those curly braces around the body (the statements) are required. You

must use them, even if the body is one line of code.

For instance, let’s say we want to divide by a number unless that number is 0. We can first check to see if the number is not 0, and if it is not, perform the division.

if ($number != 0) {

$result = 100 / $number;

}

Let’s create a program to use the if statement. It will prompt the user to enter a number. If the number is not 0, then 100 is divided by that number and the result is stored in $result. If the number is 0, the result will remain the default value of 0:

#!/usr/bin/perl -w

# if.pl

use strict;

print "please enter a number: "; chomp(my $number = <STDIN>);

my $result = 0;

if ($number != 0) {

$result = 100 / $number;

}

print "the result is: $result\ n";

Recall that the statement

chomp(my $number = <STDIN>);

316A P P E N D I X ■ P E R L B A S I C S

is shorthand for the two statements that read from standard input and then remove the newline:

my $number = <STDIN>; chomp $number;

Now let’s execute the program, once with a nonzero value and once with zero:

$ perl if.pl

please enter a number: 8 the result is: 12.5

$ perl if.pl

please enter a number: 0 the result is: 0

$

Operators Revisited

The if statement and all the other control structures we’re going to visit in this section test to see if a condition is true or false. They do this using the Boolean logic mentioned earlier, together with Perl’s ideas of true and false. To remind you of these:

•An empty string, "", is false.

•The number 0 and the string "0" are both false.

•An empty list, (), is false.

•The undefined value is false.

•Everything else is true.

However, you need to be careful for a few traps here. A string containing invisible characters, like spaces or newlines, is true. A string that isn’t "0" is true, even if its numerical value is 0, so "0.0" for instance, is true.

Larry Wall has said that programming Perl is an empirical science—you learn things about it by trying them out. Is (()) a true value? You can look it up in books and the online documentation, or you can spend a few seconds writing a program like this:

#!/usr/bin/perl –w

# emptylist.pl

use strict;

if ( (()) ) {

print "Yes, it is.\ n";

}

This way you get the answer straight away, with the minimum of fuss. (If you’re interested, it isn’t a true value.) We’ve also seen that conditional operators can test things out, returning 1 if the test was successful and an empty string if it was not. Let’s see more of the things we can test.

Here’s a very simple way of testing if a user knows a password. (Note: don’t use a good password in this program since the user can just read the source code to find it!)

#!/usr/bin/perl -w

# password.pl

use strict;

my $password = "foxtrot"; print "Enter the password: "; my $guess = <STDIN>;

chomp $guess;

if ($password eq $guess) { print "Pass, friend.\ n";

}

if ($password ne $guess) {

die "Go away, imposter!\ n";

}

Here’s our security system in action:

$ perl password.pl

Enter the password: abracadabra Go away, imposter!

$ perl password.pl

Enter the password: foxtrot Pass, friend.

$

This program starts by asking the user for input:

my $guess = <STDIN>;

Just a warning: this is a horrendously bad way of asking for a password, since it’s echoed to the screen, and everyone looking at the user’s computer would be able to read it. Even though you won’t be using a program like this, if you ever do need to get a password from the user, the Perl FAQ provides a better method in perlfaq8. Type perldoc -q password to find it.

chomp $guess;

This statement chomps the newline off of $guess. We must never forget to remove the newline from the end of the user’s data. We didn’t need to do this for numeric comparison, because Perl would remove that for us anyway during conversion to a number. Otherwise, even if the user had entered the right password, Perl would have tried to compare "foxtrot" with "foxtrot\ n" and it could never be the same.

if ($password ne $guess) {

die "Go away, imposter!\ n";

}

Then if the password we have isn’t the same as the user’s input, we send out a rude mes-