Re^2: Best practices - if any?

[AriSoft]

Ok. I was already wondering what is the the practical difference with "my" and "our" variable declarations in the main level. I knew that "our" goes to symbol table but I did not realize what it means until now. I can declare the same variable in many files and they all points to the same symbol as far as the module is the same one. Right?

[BrowserUk]

I can declare the same variable in many files and they all points to the same symbol as far as the module is the same one. Right?

With the above correction, yes.

The only unfortunate exception is when you use threads. Then each thread inherits a cloned, non-shared copy of those globals already in existance in the thread from which it is cloned. If you want a shared global, you must post-fix it with :shared everywhere it is declared. Use it some places and omit it other and things get really messy.

[shmem]

Variables declared with our create a package variable and a lexically scoped variable which is an alias to that package variable, visible through the entire scope (file or block) even spanning packages:

# file foo.pl
use strict;
our $foo; # that's $main::foo

{
    package Foo;
    our $foo = "foo"; # package variable $Foo::foo created
    print __FILE__,' ',__LINE__,' ',__PACKAGE__,":: \$foo is '$foo'\n"
+;

    package Bar;
    print __FILE__,' ',__LINE__,' ',__PACKAGE__,":: \$foo is '$foo'\n"
+;
}
print __FILE__,' ',__LINE__,' ',__PACKAGE__,":: \$foo is '$foo'\n";
print __FILE__,' ',__LINE__,' ',__PACKAGE__,":: \$Foo::foo is '$Foo::f
+oo'\n";

# file bar.pl
use strict;

{
    package Bar;
    our $foo; # package variable $Bar::foo created
    print __FILE__,' ',__LINE__,' ',__PACKAGE__,":: \$foo is '$foo'\n"
+;
} # end of scope

package Foo;
our $foo; # package variable $Foo::foo initialized in 'foo.pl'
print __FILE__,' ',__LINE__,' ',__PACKAGE__,":: \$foo is '$foo'\n";

package Bar;
print __FILE__,' ',__LINE__,' ',__PACKAGE__,":: \$foo is '$foo'\n";

#!/usr/bin/perl

use strict;
our $foo = 'bar'; # package variale main::foo
require 'foo.pl';
require 'bar.pl';

print __FILE__,' ',__LINE__,' ',__PACKAGE__,":: \$foo is '$foo'\n";

Running main.pl yields

foo.pl 8 Foo:: $foo is 'foo'
foo.pl 11 Bar:: $foo is 'foo'
foo.pl 13 main:: $foo is 'bar'
foo.pl 14 main:: $Foo::foo is 'foo'
bar.pl 7 Bar:: $foo is ''
bar.pl 12 Foo:: $foo is 'foo'
bar.pl 15 Bar:: $foo is 'foo'
main.pl 8 main:: $foo is 'bar'

updated as per JavaFan's comment below. Of course there's only one variable and it's alias in the current scope.

[JavaFan]

Variables declared with our create a package variable and a lexically scoped variable

That suggests any use of our creates two variables. It doesn't. It creates an alias (another name) for the variable - the alias is lexically scoped. And no matter how many times you use our, it doesn't create new variables over and over again - unlike my.

my $foo++;  say $foo;
my $foo++;  say $foo;
our $bar++; say $bar;
our $bar++; say $bar;
__END__
1
1
1
2

It does warn. But even if you put all the lines in different scopes (no warnings then), it's still the same variable when using our:

{my $foo++;  say $foo;}
{my $foo++;  say $foo;}
{our $bar++; say $bar;}
{our $bar++; say $bar;}
__END__
1
1
1
2

[shmem]

But even if you put all the lines in different scopes (no warnings then), it's still the same variable when using our:

...as long as the alias refers to the same package variable. An our in an inner scope creates a new alias:

our $foo;
{
  our $foo = 'foo'; say $foo;
}
{
  package Foo;
  our $foo = 'bar'; say $foo;
}
package main; say $foo;
package Foo; say $foo;
{
  package Foo;
  our $foo; say $foo;
  {
    package Bar;
    our $foo = 'quux'; say $foo;
  }
  say $foo;
}
{
  package Foo;
  say $foo;
}
__END__
foo
bar
foo
foo
bar
quux
bar
foo