Scopes can be confusing. Perl 5 introduced lexical, or my, variables that are only visible in the scope in which you define them. To properly scope your variables, you need to know what can define a scope and what doesn’t.
You commonly see lexical variables for subroutine arguments, for instance:
sub foo {
my( $self, @args ) = @_;
...;
}
The variables $self and @args don’t exist outside of that subroutine (ignoring black magic with things such as PadWalker). Lexicals variables have limited effect and no action at a distance, making them invaluable for robust programming. Not only that, but since the lexical variable names only matter in their scope, you don’t have to know about all of the variables that you have already defined to choose variable names in your scope.
Before Perl 5, all variables were package variables (so, global). Perl 5 couldn’t just ignore all of the existing Perl 4 programs, so it ended up supporting both the global package variables and lexical variables. That can make things confusing if you don’t understand the difference.
First, you need to know what makes a scope. Most people can give you at least one answer: a block creates a scope. Blocks show up in the syntax of many of Perl’s commonly used features:
# a subroutine definition block, perhaps anonymous
sub foo { ... }
my $foo = sub { ... };
# blocks for control stuctures
foreach ( @array ) { ... }
while( $condition ) { ... }
if( $condition ) { ... }
# blocks related to functions:
my $result = do { ... };
my @transformed = map { ... } @input;
my @filtered = grep { ... } @input;
# blocks in regular expressions
m/(?{...})/
Sometimes you can create the lexical variable outside of the block even though it’s scoped to the block. You can declare the lexical variable in the the test for while or
foreach my $index ( 0 .. 5 ) {
print "index: $index\n";
}
while( my $line = <DATA> ) {
print "line: $line";
}
if( my $foo = 'abc' ) {
print "foo is $foo\n";
}
You don’t need a control structure or operator to use a block to define the scope. You can use a bare block to create a scope:
# bare blocks
{
my $cat = 'Buster';
...;
}
Most Perler’s could identify blocks as scope definers, but there’s another scope definer that many people miss. File this away for your job interview trivia: a file is a scope too. You can’t see lexical variables outside of the file in which you define them, even if you don’t explicitly create the scope with a block. It’s as if there is a virtual block around the entire file.
You can use the file scope to create private class variables. The methods you define in the same file can see the private variables, but code in other files, such as subclasses, can’t mess with them:
package Some::Class;
my $private = 0; # only visible in this file
sub some_method {
...; # can see $private
}
If you want other parts of the program to get or set the value in this private variable despite its scope, you can provide accessor methods. This gives you a chance to head off any shenanigans before you allow someone to change the value:
package Some::Class;
my $private = 0;
sub get_private { $private }
sub set_private { $private = $_[1] }
Some people extend the idea of private class variables too far because they think that a package creates a scope. It doesn’t. A package merely defines the default package unless you explicitly specify one. Since lexical variables aren’t connected to packages, they don’t care want the current package is. If you change the package, even if it’s in another block:
package Some::Class;
my $n = 'Can you see me?';
{
package main;
# $n still visible here
}
package Some::Class::Subclass;
# $n still visible
There are some more tricks with scopes and what constitutes a scoped variable, but that’s a matter for a future Item.
Things to remember
- Lexical variables are only visible in their scope.
- A block defines a scope.
- A file defines a scope.
- A package does not define a scope.