3.1.1 Lexical Variables

Lexical variables (those tagged with my) aren't listed in the symbol table at all. Every block and subroutine gets a list of one or more arrays of variables called scratchpads (typically one, but more if the subroutine recurses). Each lexical variable is assigned one slot from a scratchpad; in fact, different types of variables with the same name - $spud and %spud, say - occupy different slots. Since a subroutine's lexical variables are independent of any other's, we get truly local variables. We will have more to say on this subject in Chapter 20, Perl Internals.

3.1.2 Lexical Versus Dynamic Scoping

There are two ways of getting private values inside a subroutine or block. One is to use the local operator, which operates on global variables only; it saves their values and arranges to have them restored at the end of the block. The other option is to use my, which not only creates a new variable, it marks it as private to the block.

On the surface, both local and my behave identically:

$a = 20;                       # global variable
{
     local ($a);               # save $a's old value; 
                               # new value is undef
     my (@b);                  # Lexical variable
     $a = 10;                  # Modify $a's new value
     @b = ("wallace", "grommit");
     print $a;                 # prints "10"
     print "@b";               # prints "wallace grommit"
} 
# Block ended. Back to global scope where only $a is valid
print $a;                      # prints "20", the old value
print @b;                      # prints a warning, because no global @b

A global variable created because of a local statement gets deallocated at the end of the block.

While their usage is identical, there's one important difference between local and my. The my declaration creates truly local variables, such as auto variables in C. This is called lexical binding. The variable is private to the block in which it is declared and is available only to that block (what you can see lexically defines the bounds). It is not available to subroutines that are called from the block.

In contrast, the local operator does not create new variable. When applied to global variables, it squirrels their values away and restores them at the end of the block. Because the variables themselves are global, their new value is available not only to the block in which the local operator is used, but also to all called subroutines. Consider

$x = 10;
first();

sub first {
    local ($x) = "zen";      # $x is still global, and has a new value
    second();
}
sub second {
    print $x;   # Prints "zen", the current value of the global $x
}

From global scope, we call first, which localizes the global $x, sets it to a new value (the string "zen"), and calls second. second sees the last value of $x, as set by first. This process is called dynamic scoping, because the value of $x seen by second depends on the particular call stack. This feature can be quite confusing in practice, because if you wrote another subroutine that declared a local $x and called second, it would pick up that version of $x.

In other words, local makes a global variable's new value temporary; it does not change the essential nature of the variable itself (it still remains global). my creates a truly local variable. Which is why you can say

local $x{foo}; # Squirrel away $x{foo}'s value.

but not

my $x{foo};    # Error. $x{foo} is not a variable

It is recommended that you use my wherever possible, because you almost always want lexical scoping. In addition, as we shall see in Chapter 20, lexically scoped variables are faster than dynamically scoped variables.

{ # Start of a new block
    local(@ARGV) = ("/home/alone", "/vassily/kandinski");
    while (<>) {
        # Iterate through each file and process each line
        print;  # print, for example
    }
} # Block ends. The original @ARGV restored after this.

{
    local $/ = undef; # Saves previous value of $/, and substitutes 
                      # it with undef
    $a = <STDIN>;     # Slurp all of STDIN into $a
}