1. the vars pragma to declare package level variables
2. available in perl5.6+, our which declares a package level and also creates lexical variable aliased to the package variable
3. fully qualify the variables with their package name

Which you can implement like so

use vars '$config';

our $config;

$Your::Package::config;
[download]

_________
broquaint

File-scoped lexicals are globally-scoped to anything in that file. our is only really useful when dealing with application-globals - things that will be used in more than one file. (@ISA, @EXPORT_OK, and $VERSION come to mind.) That's the reason why my is singularly possessive and our is plurally possessive. I personally think that our is misused in 99% of its usage.

------
We are the carpenters and bricklayers of the Information Age.

The idea is a little like C++ templates, except not quite so brain-meltingly complicated. -- TheDamian, Exegesis 6

Please remember that I'm crufty and crochety. All opinions are purely mine and all code is untested, unless otherwise specified.

my $i = 10;
&print_i;

sub print_i{
    print "$i\n";
}
[download]

our $i = 10;
....
[download]

our $i;
...
sub print_i{
    print "$i\n";
}
[download]

- Tom

Others have told you to declare the shared variable at the top of the file. Here's why:

#!/usr/bin/perl
use warnings;
use strict;

x();                 # this will trigger a warning

my $shared  = 'abc';

sub x {
    print "\$shared is: <$shared>\n";
}

x();                 # this will work fine
[download]

Although $shared is within the same scope as the sub x, its value has not yet been initialized. Therefore, the first time you call the subroutine, you get a warning for using an uninitialized value. Once the program flow passes over the shared point, everything it's OK. That was why, if you need a shared value, it should be "at the top".

HTH

our $var = whatever;
[download]

my $var1 =5;
&func1($var1);

........somewhere else in code your func dec

sub func1 {
  #this will grab the variable $var1 you passed in
  my $private_var = shift;
}
[download]

Declare them as my at the top of the file. our will also work, but is generally the wrong thing to do (our is what your variables are declared as by default when you're not using strict).

If they're constants (and I certainly hope they are), you can use the constant progma instad:

use constant  FOO => 1;
use constant  BAR => 2;
[download]

Though this won't interpolate within a string.

----
I wanted to explore how Perl's closures can be manipulated, and ended up creating an object system by accident.
-- Schemer

Note: All code is untested, unless otherwise stated

It depends what package your subroutines are living in. Assuming they're living in the main:: package, you can declare package scoped variables there by using:

use vars qw($foo @bar %baz);
[download]

Take a look at arturo's tutorial on variable scoping for some more ideas./

cheers
ViceRaid

Or you could just put a no strict before the code that accesses the variable.

Abigail

Just declare them like this:

..
..
use strict;

my $globalvariable;

# your code continues here #
[download]

jdtoronto