You’ll learn more detail about this later, but for now, assume that every code snippet begins like this:

use strict;
use warnings;
use diagnostics;

Those three statements will save you a lot of pain. They force you to properly declare most variables and subroutines, warn you when you’re doing silly things, and, if you include the use diagnostics line, actually give you an extended description of what you did wrong, along with suggestions on how to fix it. Experienced programmers generally omit diagnostics, but when you’re starting out, they’re invaluable.

Next, let’s look at a few variables.

my $nick_name = 'Ovid';
my @cats      = ( 'Valentin', 'Arthur' );
my $nick      = $nick_name;

print $nick;

That example assigns values to some variables. The statement in the third line copies the string ‘Ovid’ from the variable $nick_name to the variable $nick. The print statement will print the word Ovid to your console.

If you’re an experienced programmer, you already understand much of what’s going on here, and you can probably guess a lot more. But let’s now cover some common ground that will apply to most variables you work with in Perl.

Notice how each variable in the preceding code example is declared with the my function. This function in Perl is the most common way of declaring a variable, and it also makes the variable visible only to the current scope (which is covered later in this chapter) to hide it from other parts of your program. That’s important to ensure that a distant part of your program doesn’t silently change your data.

Note that there are other ways to declare variables and, in fact, the variable declaration is sometimes optional. You’ll learn more about that later, but for now, be sure to declare your variables with my, as shown here:

my $nick_name = 'Ovid';

This will protect this part of your program from being accidently changed by another part where you used the same variable name. That kind of self-inflicted bug is all too easy to create, and extremely difficult to find and fix. Use my and you’ll make your programming life easier.

Moving a bit further to the right in the sample code presented at the beginning of this discussion, you see punctuation before each variable name—in this case the dollar sign, $, as shown here:

my $nick_name = 'Ovid';

In Perl, this leading punctuation is called a sigil because, like the word “scalar.” it is a common word that has been “repurposed.” A sigil was originally a carved or painted symbol of great power. So, in Perl, a sigil is a punctuation symbol that tells you something about the variable you’re using.

Getting back to that dollar sign sigil, in Perl, when you see a variable beginning with a dollar sign, you know that you’re accessing a $calar value. The “S” shape of the dollar sign is a (theoretically) handy mnemonic for scalar. Or maybe it’s a handy mnemonic for $ingle value.

Note the phrase, “you’re accessing a $calar value.” That does not read, “contains a scalar value.” When you learn about arrays and hashes (or containers that can contain multiple values), the leading “$” will show you when you’re accessing a $ingle value of the array or hash, instead of multiple values. You’ll learn more that when you discover arrays and hashes.

Variables usually have names. In fact, many things in Perl have names, also called “identifiers.” These are things like subroutines (discussed in Chapter 7, Subroutines), filehandles (discussed in Chapter 9, Files and Directories), packages (discussed in Chapter 11, Packages and Modules), and a few others. In fact, just about anything you can pick a name for in Perl follows fairly simple naming rules.

Perl names must start with a leading (ASCII) letter or underscore. You can optionally follow that with one or more letters, numbers or underscores. The following are all valid variable names:

my $x;
my $foo;
my $_some_1;
my $DontMakeVariableNamesLikeThis;
my $make_names_like_this_instead;
my $item_3;
my $verily_I_say_unto_you_the_number_of_the_tr_tag_shall_be;

(The author used that last one in anger in a project several years ago, and somewhere out there is a maintenance programmer who wants to kill him.)

As a matter of style in Perl (yes, Perl has a style, as you can see at perldoc perlstyle), you don’t use camelCaseWords. Instead, we use words_separated_by_underscores. This is because the latter is easier to read, particularly for those who do not speak English as a first language. The practice of camelCase is merely a holdover from older programming languages that didn’t allow underscores in identifiers. Perl programmers are not really down with arbitrary limitations imposed by archaic programming conventions. They have enough arbitrary limitations already, thank you.

The following are not valid variable names:

my $answer-to-life;
my $~destructor;
my $3rd_times_the_charm;

As with all things in life and Perl, there are some caveats, the biggest of which is that Perl is allowed to violate the rules it sets for you. So, in Perl programs, you’ll sometimes see things the following:

my $host       = $1;
my $this_perl  = $^X;
my $taint_mode = ${^TAINT};

You can read about these and other special variables in perldoc perlvar. We’ll cover the most common ones in the book as they come up.

use utf8;
my $cédille = 'French letter';
print $cédille;

Assigning a string to a scalar is simple:

my $person = 'Leila';
my $wife   = "lovely";

Both of these lines of code are valid ways of assigning a string to a scalar. When using single quotes, what you see inside of the quotes is generally exactly what you get. However, when you use double quotes, you can use escape characters (“\n” for newline, “\t” for tab, and so on) and interpolate (embed) other variables in the string. Following is example that will print out “lovely Leila” with a newline at the end:

my $person = 'Leila';
my $wife   = "lovely $person";
print "$wife\n";

Sometimes you need to include quotes in your quotes. You can escape the quotes or use a different set of quotes, as shown here:

my $city = 'R\'lyeh';
my $city = "R'lyeh";
print $city;

my $reviewer = 'Adrian';
my $review   = "$reviewer wrote \"This book is awful\"";

my $reviewer = 'Adrian';
my $review   = qq{$reviewer wrote "This book is wonderful"};

my $review   = qq!$reviewer wrote "This book is awful"!;
my $review   = qq<$reviewer wrote "This book is awful">;
my $review   = qq[$reviewer wrote "This book is awful"];
my $review   = qq($reviewer wrote "This book is awful");
my $review   = qq@$reviewer wrote "This book is awful"@;

my $letter = qq{
Dear $editor,

I really liked the subtitle which you rejected and beg you to reconsider.
It was brilliant and perfectly conveyed the tone of this book. In case
you wish to reconsider, it's:

    "Get a job, hippy!"

Sincerely,
Ovid
};

my $letter = <<"END_APOLOGY";
Dear $editor,

I'm very sorry for mocking you in the last email. I promise it won't
happen again. Can I still get paid?

Sincerely,
Ovid
END_APOLOGY

my $get_customers_with_orders = <<'SQL;;
SELECT c.id
  FROM customers c
  JOIN orders o ON c.id = o.customer_id
SQL

Can't find string terminator "END_APOLOGY" anywhere before EOF.

print "I mean it!\nI'm really sorry for mocking you!";

I mean it!
I'm really sorry for mocking you!

print "\Ue.e. c\Eummings\n";

In the previous example, the print function takes a list of arguments. Consider the first print statement in the example:

print @stuff, "\n";

This tells Perl to dutifully print every item in the list, one after another, with the newline being printed last. Because no item in the list contains a space, they run together as they’re being printed.

The second version has the array being interpolated into a string.

print "@stuff\n";

When an array is interpolated into a string, the individual elements are, by default, separated with a single space, generating the “7 of 9” output.

You might also note that the array @stuff has two integers and one string. Because Perl is more focused on data structures than strict limitations on the kinds of data they contain, you can generally use whatever kinds of data you want.

Now, printing out an array is all fine and dandy, but often when you’re working with an array, you are trying to work with one element of the array or all elements. (Sometimes you work with a few elements called a “slice,” and you’ll learn more about that in a bit.)

You may remember earlier in this chapter the discussion said that, “in Perl. when you see a variable beginning with a dollar sign, you know that you’re accessing a $calar value.” It’s the same with arrays. Arrays are indexed by number, with the first element of the array being indexed by 0 (zero). Getting that first element looks like this:

my @words = ("and", "another", "thing");
print $words[0];

Remember that the sigil before the variable name indicates how you’re accessing it, not the type of variable. This is a frequent source of confusion for newer Perl programmers, so it’s important that you pay careful attention to this.

Also note on the right side of the variable name square brackets appear around the index. When you’re using square brackets in Perl, it usually means you’re dealing with an array (or possibly a reference to an array, but you’ll learn about that in Chapter 6, References).

Naturally, if you want to access all of the elements, you can do this:

my @words  = ( "and", "another", "thing" );
my $first  = $words[0];
my $second = $words[1];
my $third  = $words[2];

As you might expect, you can also assign to individual elements of the array this way:

$words[1] = "one more";
print "@array\n";

That prints and one more thing.

Again, note that when accessing an individual element of an array, you have a dollar sign on the left and square brackets on the right. This will be repeated quite a bit. It’s one of the classic stumbling blocks for new Perl programmers. If your eyes glaze over and you stop reading about the sigils and things like that, it’s your own darn fault when you get them wrong!

Sometimes you’ll find that you want some trailing elements of an array, but you’re not sure of the length. It’s easy to find out the length of the array, but there’s actually an interesting trick here. If you access an array with a negative number, you access array elements from the end of the list going backward, starting with −1 (because 0 would be the first element).

my @words  = ( "and", "another", "thing" );
my $last  = $words[-1];
print $last;

That will print thing. Of course, $words[-2] would be another and $words[-3] would be and.

use strict;
use warnings;
use diagnostics;
my @words;
my $word = $words[8];

my @words = ("this", "that");
my $no_such_word = $words[-17];

use strict;
use warnings;
use diagnostics;
my @words = ("this", "that");
$words[5] =  "bad idea";

'this', 'that', undef, undef, undef, 'bad idea'

use strict;
use warnings;
use diagnostics;
my @words = ("this", "that");
$words[-5] =  "bad idea";

Modification of non-creatable array value attempted, subscript −5
at bad.pl line 5 (#1)
(F) You tried to make an array value spring into existence, and the
subscript was probably negative, even counting from end of the array
backwards.
Uncaught exception from user code:
Modification of non-creatable array value attempted, subscript −5
at bad.pl line 5.

As a handy shortcut, so long as you’re assigning literals to the array and not variables, you can use the qw() operator (as in “q”uote “w”ords) like this:

my @odds = qw( 1 3 5 charlie );

The qw() operator takes a string and automatically separates it on whitespace, so this line of code is equivalent to the following:

my @odds = ( 1, 3, 5, 'charlie' );

Sometimes you’ll see something like this:

my @odds = qw( 1, 3, 5, 'charlie' );

That’s probably now what you want, and if you have warnings on, it will warn about a “Possible attempt to separate words with commas.” That’s because, since the string in the qw() operator is separated by whitespace, the commas will be included in the values and not be used as a list separator.

As with the qq() operator, qw() allows just about any pair of balanced delimiters. Some common ones include the following:

my @odds = qw! 1 3 5 charlie !;
my @odds = qw< 1 3 5 charlie >;
my @odds = qw{ 1 3 5 charlie };
my @odds = qw[ 1 3 5 charlie ];

Those are useful in case one of the words in the string might other contain a delimiter, as shown here:

my @punctuation = qw[ . ; ! ( ) { } ];

Naturally, you don’t want to always access array data by assigning the value of different elements to different variables. You often want to iterate over the elements and do something with them. Here’s one way to do this (but Chapter 5, Control flow goes into more detail during a discussion of control flow):

my @array = ( 'this', 'is', 'an', 'array' );
for my $element (@array) {
    print "$element\n";
}

That should print the following:

this
is
an
array

As you have already seen, accessing data in a hash is simple:

my %people = (
    "Alice",   1,
    "Bob",     2,
    "Ovid",    "idiot",
);

my $number = $people{'Bob'};
print "Bob = $number\n";
print "Bob = $people{'Bob'}\n";

You’ll immediately notice a few things here. First, you can see that to access an individual element of the hash, you have a dollar sign for the sigil (see a pattern?) and curly brackets (“curly braces,” “curlies,” “squiggly braces,” or whatever the heck you call ‘em) around the index.

As mentioned, the “keys” of the hash correspond to an array’s numeric indices. In fact, you could do that if you wanted to like this:

my %french_word_for = (
    1, 'un',
    2, 'deux',
    3, 'trois',
);
print "The French word for '3' is $french_word_for{3}\n";

That can be confusing, and you probably just want an array itself (though if you have a sparse array, a hash might be a good choice).

You’ll also note that you retrieved the hash value without quoting the key:

my $french_word = $silly_example{3};
my $other_data  = $another_example{some_key};

When accessing a single value, you are not required to quote the key, so long as it follows the rule of an identifier. So, this is wrong, and you must quote the key:

my $other_data  = $another_example{-some_key};

Iterating over a hash is fairly simple. One way to do this is to use the keys function. This returns the list of keys from the hash, as shown in the following example:

my %people = (
    "Alice", 1,
    "Bob",   2,
    "Ovid",  "idiot",
);
for my $name ( keys %people ) {
    print "$name is $people{$name}\n";
}

That might print something like this:

Ovid is idiot
Bob is 2
Alice is 1

Note that the order of the hash keys is effectively random, so there’s no guarantee that your version of Perl will print those lines in this order. It’s actually not random, but the reasons for that are beyond the scope of this book. Just remember that you should never rely on hash order. However, you’ll learn more about that in Chapter 10, Sort, map and grep during a discussion of sorting.

There is a corresponding values function that returns the values of the hash, again without any predictable order.

To add a new value to a hash, simply assign the new value to a key:

$people{Austen} = 'Jane';

That will add a new value to the hash, or overwrite the value for the key Austen if it exists.

You can add multiple key/value pairs by assigning the hash and a list:

%people = ( %people, Austen => 'Jane', Lincoln => 'Abraham' );

If any of the keys in the list match keys in the original hash, the original values will be replaced with the new ones.

my %people = (
      Alice => 1,
    Bob   => 2,
    Ovid  => "idiot",
);

my %people = (
    'Alice' => 1,
    'Bob'   => 2,
    'Ovid'  => "idiot",
);

my %people = (
      Alice => 1,
    2Bob  => 2,
    Ovid  => "idiot",
);

my %vegetables = ( 'celery' => 'yuck', 'spinach' => 'delicious' );
my %vegetables = ( 'celery', 'yuck', 'spinach', 'delicious' );

You’ve already learned that “the sigil that starts the variable indicates how you’re accessing it,” so as you might guess, to take several elements out of an array at once, you use the @ sign at the front. Following is an example:

my @names = ('Alice', 'Bill', 'Cathy', 'Doug');
my @men   = @names[ 1, 3 ]; # Bill and Doug
my @women = @names[ 0, 2 ]; # Alice and Cathy

It’s the square brackets ([]) that tell you what type of variable you’re indexing into (an array, in this case), not the leading sigil. Again, this is a concept you’ll need to get very used to because it’s core to understanding the Perl language. And, yes, this drum is being beaten repeatedly because everyone gets it wrong sooner or later.

Generally, it doesn’t make sense to take a single-element slice. So, if you do this, you get a warning (if you have warnings enabled, which you’ll learn more about in a bit).

use warnings;
my @stuff = ('bits', 'and', 'bobs');
my $item = @stuff[1];
print $item;

That will issue the following warning:

Scalar value @stuff[1] better written as $stuff[1] at stuff.pl line 3.

Make that recommended change and the warning will go away.

Naturally, you can take a slice of a hash. Because you use the leading sigil to indicate how you’re accessing the variable, you use the @ sign again, but with curly braces. Following is an example:

my %nationality_of = (
   'Ovid'          => 'Greek',
   'John Davidson' => 'Scottish',
   'Tennyson'      => 'English',
   'Poe'           => 'Tacky',    # Geek?
);

my @nationalities = @nationality_of{ 'Ovid', 'Tennyson' };
print "@nationalities";

That will print “Greek English,” despite the fact that Ovid was actually a Roman poet. Garbage in, garbage out.

Following is an example of scalar context:

my $number_of_things = @things_in_common;
my $number_of_things = scalar @things_in_common;
my $number_of_things = ( 'liars', 'fools', 'certain politicians' );
my $number_of_things = %hash_example;

When dealing with assigning values to variables, what you have on the left side of the = determines the “context” on which you’re evaluating the right side. So, if you have a scalar on the left, you have scalar context.

my @things_in_common = ( 'liars', 'fools', 'certain politicians' );
my $number_of_things = @things_in_common;

my @things_in_common = ( 'liars', 'fools', 'certain politicians' );
my $number_of_things = scalar @things_in_common;

my @things_in_common = ( 'liars', 'fools', 'certain politicians' );
my %count_for = ( useless_things => @things_in_common );
print $count_for{useless_things};

my @things_in_common = ( 'liars', 'fools', 'certain politicians' );
my %count_for = ( useless_things => scalar @things_in_common );
print $count_for{useless_things};

my $number_of_things = ( 'liars', 'fools', 'certain politicians' );
print $number_of_things;

my %hash = ( 1 => 2 );
print scalar %hash;

You have list context when the left-side value expects a list. Here’s how to copy an array to another array:

my @copy = @old_array;

Note that this is a “shallow” copy in that you’re only copying the top-level elements. Later, when you learn about references (Chapter 6, References), you’ll learn about this in more detail.

If you want, you can also assign a hash to an array, as shown here:

my %order_totals = (
    Charles     => 13.2,
    Valerie     => 17.9,
    'Billy Bob' => 0,
);
my @flattened = %order_totals;

That “flattens” the key/value pairs in the hash into a list. If you print the resulting array, you might get something like this:

Billy Bob 0 Charles 13.2 Valerie 17.9

Again, this is because a hash is not ordered. If you need to retrieve the elements of a hash in order, see Chapter 10, Sort, map and grep, which explores sorting.

One of the nice things about list context is that you can force it with parentheses. For example, if you want to assign the first element of an array to a scalar, just put parentheses around the scalar, as shown here:

my @swords = ( 'katana', 'wakizashi' );

my $number_of_swords = @swords;
my ($left_hand)      = @swords;

However, you aren’t limited to a single scalar. You can assign several scalars at the same time, as shown here:

my ( $left_hand, $right_hand ) = @swords;

This will come in extremely handy when you learn more about subroutines in Perl.

This has an interesting side effect. When you’re facing down Toshiro Mifune and you realize that your katana and wakizashi swords are in the wrong hands, you’re in trouble. Here’s how you might do that in C:

char *other_hand;
strcpy( other_hand, left_hand  );
strcpy( left_hand,  right_hand );
strcpy( right_hand, other_hand );

Too bad. You’re dead.

In Perl, because you can use list context with those scalars, you can just do this:

( $right_hand, $left_hand ) = ( $left_hand, $right_hand );

Pretty handy, eh?

You can mix scalars and other variables with this:

my ( $first, @extra ) = ( 1, 2, 3 4 );

$first will have the value of 1 and @extra will be 2, 3, and 4. However, the scalars must come first!

my ( @extra, $last ) = ( 1, 2, 3 4 );

That doesn’t do what you want because @extra slurped up all of the values and $last will be undefined.

Now it’s time for you to get some experience actually working with these variables yourself.

Try It Out Printing Scalars, Arrays, and Hashes

Example 3-1

This chapter has covered a lot of ground, so let’s get your hands a bit dirty and see how this really works.

1. Type the following program into your favorite editor and save it as example_3_1_variables.pl:

   use strict;
   use warnings;
   use diagnostics;
   
   my $hero = 'Ovid';
   my $fool = $hero;
   print "$hero isn't that much of a hero. $fool is a fool.\n";
   
   $hero = 'anybody else';
   print "$hero is probably more of a hero than $fool.\n";
   
   my %snacks = (
       stinky   => 'limburger',
       yummy    => 'brie',
       surprise => 'soap slices',
   );
   my @cheese_tray = values %snacks;
   print "Our cheese tray will have: ";
   for my $cheese (@cheese_tray) {
       print "'$cheese' ";
   }
   print "\n";

   Note

   example_3_1_varaibles.pl available for download at Wrox.com.

2. Now that you’ve saved it, run it with perl example_3_1_variables.pl. It will probably print something similar to the following:

   Ovid isn't that much of a hero. Ovid is a fool.
   anybody else is probably more of a hero than Ovid.
   Our cheese tray will have: 'havarti' 'soap slices' 'brie'

If it didn’t, the inclusion of strict, warnings, and diagnostics will provide clues to where you mistyped.

How it works

Let’s skip the strict, warnings and diagnostics since you’ll learn more about those later in this chapter. For now, just know that they make writing correct code much easier. Instead, let’s look at the first assignments.

my $hero = 'Ovid';
my $fool = $hero;
print "$hero isn't that much of a hero. $fool is a fool.\n";

$hero = 'anybody else';
print "$hero is probably more of a hero than $fool.\n";

That should be pretty clear by now, but with the second assignment to the $hero variable, you can see that it does not change the value of $fool. You’re copying the values of these variables, not the variables themselves.

For the rest, the only new thing here is the use of the values keyword. This was mentioned earlier, but this example shows it in action:

my @cheese_tray = values %snacks;
print "@cheese_tray\n";

That will print limburger brie soap slices and guarantee that you have a memorable (if unpopular) party.

Variables declared with my are referred to as “lexically scoped.” This means that they do not exist outside of the scope in which they are declared. This generally means file scoped or block scoped.

File scoped means that any my variable declared outside of a block is visible from that point on to the end of the file in which it is declared. This also means that if you have several packages in a file (which you’ll learn about in Chapter 11, Packages and Modules), the my variable in question will be visible to all packages in that file. You generally want to avoid that.

However, if they are declared inside of a block, they remain scoped to that block. In Perl, a block is simply one or more Perl statements delimited by curly braces. For example, here’s a bare block:

my $answer = 42;
{
    my $answer = 'forty-two';
    print "$answer\n";
}
print "$answer\n";

That will print the following:

forty-two
42

This is because the my declaration inside of the block “hides” the variable from the scope outside of the block.

my $_;

Example 3.1, “Variable scoping in blocks” provides a more real-world example with a block in a for loop.

use strict;
use warnings;
use diagnostics;

my @numbers = ( 1, 2, 3, 4, 5 );
for my $number (@numbers) {
    my $reciprocal = 1 / $number;
    print "The reciprocal of $number is $reciprocal\n";
}
print $number;
print $reciprocal;

The program in Example 3.1, “Variable scoping in blocks” will not run. Instead, you’ll get a bunch of errors similar to the following:

Global symbol "$number" requires explicit package name at numbers.pl line 11.
Global symbol "$reciprocal" requires explicit package name at numbers.pl line 12.
Execution of /var/tmp/eval_NAVl.pl aborted due to compilation errors (#1)

(F) You've said "use strict" or "use strict vars", which indicates
that all variables must either be lexically scoped (using "my" or "state"),
declared beforehand using "our", or explicitly qualified to say
which package the global variable is in (using "::").

Uncaught exception from user code:
Global symbol "$number" requires explicit package name at numbers.pl line 11.
Global symbol "$reciprocal" requires explicit package name at numbers.pl line 12.
Execution of $numbers.pl aborted due to compilation errors.

The @numbers variable does not appear in the error message because it’s file scoped and thus visible everywhere in this file. The error is because the $reciprocal and $number variables are declared with my inside of the block and are not available outside of it. Note that the $number variable is also lexically scoped to that block, even though it might appear to be outside of it. That’s just how for loops work.

To make the broken code run, simply delete the two print statements after the for loop.

But you may have noted the “requires explicit package name” error highlighted in the previous error message. What exactly does that mean?

In Perl, a package is just a “namespace” to keep variables, subroutines, and other things organized. By default, things live in the package main. You declare what package (namespace) you’re in with the package keyword. You’ll learn about this more in-depth in Chapter 11, Packages and Modules, but for now, when you’re writing simple programs, you only need to know the basics.

Generally you’ll find that package variables are globally scoped. A globally scoped variable is available anywhere in your program.

Consider the following code:

package main;
use strict;
use warnings;

Here, the package main; statement isn’t really required, because main is the default package. However, sometimes you’ll see code written like this:

package MyCompany::Stuff;

use strict;
use warnings;

%MyCompany::Stuff::department_number_for = (
    finance     => 13,
    programming => 2,
    janitorial  => 17,
    executive   => 0,
);

And later, other code can reference this with the following:

my $department_number = $MyCompany::Stuff::department_number_for{finance};

It doesn’t matter if that code is in the same package, or even a different file, so long as the MyCompany::Stuff package has been loaded. When addressing a package variable with the full package name included in it, this is known as a “fully qualified variable.” However, typing $MyCompany::Stuff::department_number_for{finance} can be very annoying. It’s also error-prone because the following is legal, but probably not what you intended (note the misspelling of “Sutff”):

my $department_number = $MyCompany::Sutff::department_number_for{finance};

Thus, you have several options to deal with this. One is to not use the strict pragma. (A pragma is a special module, the name of which is usually written in all lowercase letters, which alters the compile or runtime behavior of your program.) Any variable referenced without the my function is automatically a variable in the current package.

package main;
$answer = 42
print "$anwser\n";

That’s legal Perl, but you can see how easy it is to misspell variable names, so you shouldn’t do that because that way lies madness.

The vars Pragma

Moving along, prior to Perl 5.6.0, you had the vars pragma and it looked like Example 3.2, “The vars pragma”.

Example 3.2. The vars pragma

package MyCompany::Stuff;

use strict;
use warnings;

use vars (
    '%department_number_for',
    '$some_other_package_variable',
);

%department_number_for = (
    finance     => 13,
    programming => 2,
    janitorial  => 17,
    executive   => 0,
);
$some_other_package_variable = 42;
print $department_number_for{finance};

Note

listing_3_2_vars.pl available for download at Wrox.com.

Outside of the package, you would still have to refer to those variables by the fully qualified variable names, and, thus, run the risk of typos, but it saves typing inside of the package.

package MyCompany::Stuff;

use strict;
use warnings;

our %department_number_for;
our $some_other_package_variable;

%department_number_for = (
    finance     => 13,
    programming => 2,
    janitorial  => 17,
    executive   => 0,
);
$some_other_package_variable = 42;
print $department_number_for{finance};

our $answer = 42;
{
    local $answer = 57;
    print "$answer\n";
}
print "$answer\n";

57
42

local $MyCompany::Stuff;

our $answer = 42;
{
    local $answer = $answer;
    print "$answer\n";
    $answer = $answer + 2;
    print "$answer\n";
}
print "$answer\n";

42
44
42

For strict, you could actually write the following:

use strict 'vars';
use strict 'subs';
use strict 'refs';

However, you usually just want to write this (which means the same thing):

use strict;

Later in this book you’ll discover when you need to change this, but there is no point in teaching you how to use a gun until you’re old enough to decide for yourself if you really want to shoot yourself in the foot. (Actually, it’s just that it’s a bit too much right now.)

The vast majority of the time, strict means “predeclare your variables.” If you forget to do so, your program will not even run. For example, say that you try to do this:

my $name = 'Danny';
my $nick = $naem;

You will get a compile-time error because you misspelled $name (unless you created my $naem for some reason).

For warnings, things are a bit different. They’re generally just warning you about bad things your program is doing. But, in reality, these things might be okay. Your program will run, but warnings will be printed when your code thinks you’re doing something dodgy. You should look at the warnings closely to find out what they actually mean. For example, if you have warnings enabled, the following code will generate a warning about an uninitialized value in addition:

use warnings;
my $x;
my $y = $x + 2;

For versions of Perl prior to 5.6.0 (and sometimes after, for backward-compatibility), you’ll often see the -w switch (see perldoc perlrun) on the shebang line instead:

#!/usr/bin/perl -w
use strict;

This is because the warnings pragma was introduced in version 5.6.0. If you have the misfortune of working with an older version of Perl, be aware that 5.6.0 came out in 2000. In terms of technology, it’s ancient, and is no longer supported.

#!/usr/bin/perl
use strict;
my $x;
{
    use warnings;
    my $y;
    print $y;
}
print $x;

#!/usr/bin/perl
use strict;
use warnings;

my $x;
{
    my $y;
    print $y;
}
print $x;

If you’re relatively new to Perl, you should also use the diagnostics pragma, as shown in Example 3.4, “Using diagnostics”. This gives long-winded explanations of why you’ve been so naughty. The masochists will love it.

use strict;
use warnings;
use diagnostics;

my $x;
my $y = $x + 2;

The program shown in Example 3.4, “Using diagnostics” will print out a much longer diagnostic method to help you understand not only what went wrong, but why. Reading through these diagnostic messages is a great way to understand what Perl is doing and why. Following is an example:

Use of uninitialized value $x in addition (+) at diag.pl line 5 (#1)

(W uninitialized) An undefined value was used as if it were already
defined.  It was interpreted as a "" or a 0, but maybe it was a mistake.
To suppress this warning assign a defined value to your variables.

To help you figure out what was undefined, perl will try to tell you the
name of the variable (if any) that was undefined. In some cases it cannot
do this, so it also tells you what operation you used the undefined value
in.  Note, however, that perl optimizes your program and the operation
displayed in the warning may not necessarily appear literally in your
program.  For example, "that $foo" is usually optimized into "that "
. $foo, and the warning will refer to the concatenation (.) operator,
even though there is no . in your program.

As you can see, the diagnostic information is fairly good. If you (unlike the vast majority of programmers out there) actually read your errors and warnings carefully, you’ll have no problem understanding what happened.

You might think that strict and warnings aren’t that important, but consider the following example:

$disarm_nuclear_weapon = true;

Without strict, a bareword (a string literal without quotes) is just a string. That snippet might assign the string true to $disarm_nuclear_weapon. However, some terrorist programmer who has read Chapter 7, Subroutines on subroutines might add this above that line:

sub true { 0 }

And now you’ve assigned a false value (see Chapter 5, Control flow) to $disarm_nuclear_weapon and started World World III. Thanks a lot buddy! Just use strict and warnings, and keep the world safe from terrorism!

Now let’s get some hands-on experience with uninitialized variables.

Try It Out Understanding Uninitialized Variables

Example 3-2

This example is simple, but sometimes seeing the warnings in action will let you be more comfortable with them when you encounter “real world” code.

1. In your favorite text editor, enter the following code and save as example_3_2_diagnostics.pl:

   use strict;
   use warnings;
   use diagnostics;
   my $x;
   print 3 / $x;

   Note

   example_3_2_diagnostics.pl available for download at Wrox.com.

2. Now, type perl example_3_2_diagnostics.pl from the command line. You should see something similar to the following.

   Use of uninitialized value $x in division (/) at diag.pl line 5 (#1)
    (W uninitialized) An undefined value was used as if it were already
   defined.  It was interpreted as a "" or a 0, but maybe it was a mistake.
   To suppress this warning assign a defined value to your variables.
   
   To help you figure out what was undefined, perl will try to tell you the
   name of the variable (if any) that was undefined. In some cases it cannot
   do this, so it also tells you what operation you used the undefined value
   in.  Note, however, that perl optimizes your program and the operation
   displayed in the warning may not necessarily appear literally in your
   program.  For example, "that $foo" is usually optimized into "that "
   . $foo, and the warning will refer to the concatenation (.) operator,
   even though there is no . in your program.
   
   Illegal division by zero at diag.pl line 5 (#2)
    (F) You tried to divide a number by 0.  Either something was wrong in
   your logic, or you need to put a conditional in to guard against
   meaningless input.
   
   Uncaught exception from user code:
   Illegal division by zero at diag.pl line 5.

How it works

If you removed the three pragmas of strict, warnings, and diagnostics (actually, removing strict would not alter this), you’d just see the following output:

Illegal division by zero at diag.pl line 5.

An experienced programmer will immediately understand the problem and fix it. However, with warnings, you’d also get an additional error message:

Use of uninitialized value $x in division (/) at diag.pl line 5

This tells you not that $x is 0, but that you forgot to initialize it. When Perl does math, uninitialized values are treated as a zero and you’ll get a warning if you have warnings enabled.

However, as mentioned previously, the diagnostics pragma gives you much more information about what the problem is, and often gives you recommendations on how to resolve the problem, such as the following:

(F) You tried to divide a number by 0.  Either something was wrong in
   your logic, or you need to put a conditional in to guard against
   meaningless input.

The (F) means it’s a trappable, fatal error. “Trappable” means that you can “catch” the error, handle it, and try to continue running the program. You’ll learn more about error handling in Chapter 7, Subroutines.

The rest of the diagnostic information informs you that you have a logic error, or perhaps that value is expected, and you need to check for that value before trying to divide with it. You’ll learn how to do that in Chapter 5, Control flow.

Over time, you’ll get used to the various error messages that Perl outputs, and you’ll be able to stop using diagnostics. In fact, you should try deleting the use diagnostics line in the code and running it again to see the difference.

One of the most common special variables is the $_ variable, sometimes referred to as “dollar underscore.” This is the “default” variable and many functions automatically operate on this.

For example, when iterating over an array, you can do this:

for my $element (@array) {
    print $element;
}

Or, you can do this:

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

That’s because, when you use a for loop and you don’t create a variable to assign the elements to, the $_ variable is automatically populated with the value. In fact, the print function, by default, prints the $_ variable if it doesn’t have any arguments, as shown here:

for (@array) {
    print;
}

That will print all of the elements on a single line and you probably don’t want that. Instead, if you’re using Perl 5.10 or newer, you can use the feature pragma to import the say function. say is just like print, but it automatically adds a newline to whatever you print. Like print, it will automatically use the value of $_ as an argument if no arguments are provided.

use feature 'say';
for (@array) {
    say;
}

The global %ENV hash contains environment variables. These are variables generally set outside your program, but your program can read them to modify its behavior. For example, the $ENV{HOME} environment variable, on most operating systems, contains the home directory of the current user who is running the program.

Setting an environment variable in your program will not cause your operating system to see the new value, but all other parts of your program will see it. As this is a global variable, use with care.

Another useful built-in variable is @ARGV. This built-in array contains the arguments passed in on the command line. Example 3.5, “Rewriting “Hello, World!” with @ARGV” shows a way you can rewrite “Hello, World!”, but take the arguments from the command line:

use strict; # yes, I use these even for short programs
use warnings;

print "Hello, @ARGV";

Save that as hello.pl and type this on the command line:

perl hello.pl John Q. Public

That should print out Hello, John Q. Public.

There are plenty of other special variables in Perl, and you’ll learn about some of them as this book progresses. For now, you can read through perldoc perlvar and weep or laugh. Fortunately, you won’t encounter most of them.

As mentioned, Perl has many special variables built in to the language. Table 3.3, “Common Special Variables” lists a few of them. Don’t worry about their meaning for now, just be aware they exist. New ones will show up from time to time throughout the book.

The major differences between strict and warnings is that strict will prevent your program from running when it encounters some unsafe code, such as using an undeclared variable.

In constrast, warnings, will not prevent your program from running, but will instead emit “warnings” when your code exhibits behavior which may be problematic, such as when you attempt to use an unintialized variable or try to add a number to a string.

Following is an example of creating an array with the values “Andrew,” “Andy,” and “Kaufman” (without the quotes) and writing a program that will print: Andrew "Andy" Kaufman:

use strict;
use warnings;
use diagnostics;

my @name = qw(Andrew Andy Kaufman);
print qq{$name[0] "$name[1]" $name[2]\n};

Another way to accomplish this is the following:

use strict;
use warnings;
use diagnostics;

my @name = ('Andrew', 'Andy', 'Kaufman');
my ( $first, $nick, $last ) = @name;
print qq{$first "$nick" $last\n};

Following is an example of how to create a hash with the keys being names of fruits and the values being their normal color, and then printing every key/value pair as a separate line similar to bananas are yellow:

use strict;
use warnings;
use diagnostics;

my %color_for = (
    bananas => 'yellow',
    apples  => 'red',
    oranges => 'orange',
);
for my $fruit (keys %color_for) {
    my $color = $color_for{$fruit};
    print "$fruit are $color\n";
}