Re: What is the scope of $_?

[tobyink]

There is more than one $_. All your examples use the global $_. This is global in scope (as are all the "punctuation variables", except @_ which is just weird).

However, certain constructs implicitly localize variables. for loops do this.

Also (from Perl 5.10) you can create a new variable called $_ using my $_ or given (though the behaviour of given will change in 5.18 - it will not implicitly create a lexical $_). These have the same scope as any other lexical variables - the remainder of the block they're defined in, where the file itself counts as a block.

If you want to access your caller's lexical $_, then the official way is to use a sub prototype. I've also written lexical::underscore which allows you to delve multiple levels down the call stack.

[kennethk]

<tangent> How is @_ not global in scope? I mean, it gets implicitly localized on any subroutine call, but it's present by default and package independent:

use strict;
use warnings;

@_ = @ARGV;

package Foo;

print for @_;
@_ = qw(1 2 3 4 5);
{
    local @_ = reverse @_;
    print for @_;
}

package main;

print for @_;

</tangent>

[tobyink]

You are correct. I was under the impression that a reference to @_ behaved differently than a reference to another localized array, once the localization went out of scope.

But the following example appears to show they behave the same...

use strict;
use Data::Dumper;

our @X;
my ($underscore, $scissors);

@_ = (1..3);
@X = (1..3);

sub foo {
    local @X = (4..6);
    $underscore = \@_;
    $scissors   = \@X;
}

foo(4..6);
print Dumper($underscore, $scissors);

So (like $_) @_ is just a global array that gets localized by certain control structures. (In particular, sub.)

[Lotus1]

If all the OP's examples use the global $_ then printing it at the end would show the last value assigned. What actually happens is a warning for 'Use of uninitialized value $_ ...' The subroutine uses whatever $_ that is in scope when it is called.

use warnings;
use strict;

sub abc()
{
  $_ = 'x';
}

foreach(1..2)
{
    my $loopvar = 'in the loop';
  print "Before:$_\n";
  abc();
  print "After:$_\n";
}

print "\$_ = $_\n";  # warning for uninitialized value $_ (global scop
+e)

abc();
print "\$_ = $_\n";  # prints $_ = x

[tobyink]

As I said, all the OP's examples use the global $_ but some Perl control structures localize that variable.

The same effect is illustrated here using global $::x...

use warnings;
use strict;

sub abc()
{
    $::x = 'x';
}

foreach $::x (1..2)
{
    print "Before:$::x\n";
    abc();
    print "After:$::x\n";
}

print "\$::x = $::x\n";  # warning for uninitialized value $x (global 
+scope)

abc();
print "\$::x = $::x\n";  # prints $x = x

[Lotus1]

So when the foreach loop finishes it restores the undef value to $_. Thanks.