• my creates a lexical variable that only exists and is only accessible within its immediate enclosing lexical scope. It is not accessible anywhere else and does not exist in the package symbol table (so trying to qualify a lexical variable name with a package name will *not* get you the lexical variable).
• package globals are always accessible from anywhere using their fully qualified package names. Package variables never need to be declared. However, package variables must be qualified with their package names when 'use strict' is in effect except under the following situations:
• our declares 'unqualified access' to a package variable such that unqualified access is only allowed within the immediate enclosing lexical scope of the declaration (even if that lexical scope crosses package boundaries). It is the scope of unqualified access that is lexical, not the variable.
• use vars declares unqualified access to a package variable such that unqualified access is granted anywhere within the package to which it belongs (even if that package scope crosses a lexical boundary such as a file boundary).

So, can there be any *effective* difference between declaring a variable with our() or my() at the top of a single, single self contained script? Well, although it certainly isn't good programming style to reuse the same variable names, one difference is that you can never fully mask out a package variable:

#!/usr/bin/perl -w
use strict;
my $foo  = 42;
our $bar = 21;
print "$foo, $bar, $main::bar\n";

{
    print "$foo, $bar, $main::bar\n";
    my $foo = 7;
    my $bar = 9;
    print "$foo, $bar, $main::bar\n";
}
[download]

Inside the inner block a new lexical $foo is created completely masking out access to the outer lexical $foo (for the remainder of the inner block). A new lexical $bar is also created but only masks *unqualified* access to the package variable $bar, the package $bar is still (is always) accessible via its package name. But that is a contrived example.

Is it better to use my() or our() in single scripts? That is a matter of style and opinion. My rule is to only use package variables when a package variable is necessary. Thus the question isn't "should I use my() or our()?" ... that answer is dictated by whether I need a package variable or not, and then, if I *do* need a package variable, the question really is :should I use our() or 'use vars'?". I guess that depends, but sometimes our() variables won't cut it because their unqualified access is lexically scoped rather than package scoped. For example, if you use the Getopt::Declare module and wish to include a variable within an action-block the docs state that:

Actions are executed (as `do' blocks) in the package in which the Getopt::Declare object containing them was created. Hence they have access to all variables and functions in that scope. (ed. emphasis added)

This is accomplished inside the Getopt::Declare module by taking the action block (as a string), wrapping it in a do block with the caller's package declaration added and eval()'ing it. This means that if the action uses unqualified access to a package global it must be declared with 'use vars' and not our() because the unqualified access of our() is lexically scoped and won't be in effect inside Getopt::Declare's evaluation of the code. For a concrete example:

#!/usr/bin/perl -w
use strict;
use Getopt::Declare;

# use vars '$foo';    # this will work
our $foo;             # this won't work

$foo = "Hello World\n";

my $spec = <<'EOS';
    -greet     print a greeting
                 {print $foo}
EOS

my $opts = Getopt::Declare->new($spec);
__END__
[download]

The above (using our()) will generate an error, but if you use the commented out 'use vars' declaration instead, it will work fine. (aside note: the '-greet' above is followed by a hard tab, not spaces).

My first hard and fast rule is that there are no hard and fast rules. My second hard and fast rule (subject to qualification via the first rule) is to always use lexical variables except when a package variable is required and then 'use vars' is generally still my first choice. In the few instances where I want a package variable, I do not see that our() gives me any additional benefits over 'use vars', and occassionally (as in the Getopt::Declare situation) our() doesn't satisfy the access needs.