Consider the following Perl code:
use strict;
use warnings;
use feature qw(say);
package A;
our $x = 1;
package B;
our $x = 2;
package A;
say $x;
package B;
say $x;
The output is:
2
2
However, I would have expected:
1
2
Why does $x after package A refer to $B::x instead of $A::x?
Basically it's a scope thing.
From the documentation on our:
An our declaration declares an alias for a package variable that will be visible across its entire lexical scope, even across package boundaries. The package in which the variable is entered is determined at the point of the declaration, not at the point of use.
The first our creates makes $x an alias for $A::x. The second one reassigns $x to be an alias for $B::x, shadowing/replacing the previous one so that further uses of an unqualified $x in the same lexical scope (the file in this case since it's outside a block) refers to the B package variable no matter what the current package is.
This duplication of names is explicitly allowed per the docs:
Multiple our declarations with the same name in the same lexical scope are allowed if they are in different packages.
our creates lexically-scoped variable that is mapped to the similarly-named variable in the package in which the declaration is found.
package A;
our $x;
is equivalent to
package A;
use experimental qw( refalising declared_refs );
my \$x = \$A::x;
Subsequently changing the package has no effect.
Related
I have working code, but I am trying to understand why it works. I am also trying to learn more about the internals of Perl 5 (perlbrew, perl-5.26.1, Cygwin x64).
I know from perlvar and strict that use strict 'vars' works by setting flags in $^H. Perl then tests accesses to non-:: variables based on those flags. Somehow, both our and use vars mark variables so that they will pass the test. How do they do so?
For example:
perl -E 'package Foo;
use strict "vars";
use vars qw($foo);
say $foo;'
runs fine (although it produces no output). Based on the source for use vars, I tried this, which I thought would have the same effect:
perl -E 'package Foo;
use strict "vars";
my $sym = "Foo::foo"; # <-- These two lines pulled straight
*$sym = \$$sym; # <-- from the source for the vars pragma
say $foo;'
However, it gave me an error: Global symbol "$foo" requires explicit package name. I also tried $sym = "::Foo:foo" in the above, with the same result.
I checked, and $Foo::foo is in the symbol table:
$ perl -E 'package Foo;
use Data::Dumper;
use strict "vars";
my $sym = "Foo::foo";
*$sym = \$$sym;
say Dumper(\%{"Foo::"});' # <-- Foo's symbol table
Output:
$VAR1 = {
'BEGIN' => *Foo::BEGIN,
'Dumper' => *Foo::Dumper,
'foo' => *Foo::foo # <-- yep, it's there
};
What else is use vars doing that I'm missing? Does our do the same, or something different?
Update
Here's an A/B based on melpomene's answer:
Fails Succeeds
------------------------- ----------------------------------
package Foo; package Foo;
use strict "vars"; use strict "vars";
BEGIN {
package Bar;
my $sym="Foo::foo"; my $sym = "Foo::foo";
*$sym = \$$sym; *$sym = \$$sym;
}
say $foo; say $foo;
use strict 'vars' works by setting flags in $^H.
Yes, but that's an implementation detail. $^H exposes some internal interpreter state bits, but you're not supposed to touch it in normal code.
Somehow, both our and use vars mark variables so that they will pass the test. How do they do so?
This is also considered an implementation detail.
However, we can peek a bit under the hood. strict "vars" complains about undeclared variables (at compile time).
There is a hardcoded list of variables that are exempt from this check; it includes all punctuation variables (e.g. $/, $_, etc. along with $a and $b (used by sort)).
All lexically (i.e. locally) declared variables also pass strict; this is how my, our, and state work. (For our purposes local is not a declaration and does not create local variables; local temporarily changes the value of an existing variable.)
The third exception is variables exported from modules. Using global variables as part of your module interface is generally considered to be a bad idea, but some older modules still do it. English also exports variables because that's its whole point, so we'll use it as an example:
use strict;
use English qw($INPUT_RECORD_SEPARATOR);
$INPUT_RECORD_SEPARATOR = ""; # <--
my $paragraph = readline STDIN;
The line marked <-- does not throw an error because Perl remembers which variables were imported from a module.
What does "exporting" actually mean? It just means aliasing a symbol across package boundaries:
*main::foo = \$Some::Module::foo; # now $main::foo is an alias for $Some::Module::foo
The curious thing is that as far as the Perl internals are concerned, a variable is "imported" if it has been aliased in some other package. It does not matter what it was aliased to; all that matters is where the aliasing happened. use vars (ab-)uses this detail to bypass strict "vars" by exporting your own variables back at you:
package Some::Package;
use vars qw($foo);
works like
package Some::Package;
BEGIN {
package vars;
*Some::Package::foo = \$Some::Package::foo;
}
# now $foo is an alias to ... itself
The other piece of the puzzle is that use happens at compile time, like BEGIN blocks. Your example fails because your aliasing attempt only happens at runtime, which is too late for strict, and because it doesn't switch to a different package to do the aliasing.
In the end vars is just a module, written in plain Perl. our is different: It is a real keyword and part of the language. It also has different behavior: It effectively creates an alias (to a package variable), but that alias lives in a local scope, not the symbol table.
Consider e.g. the following:
my $foo = 2;
{
our $foo = "hello";
print "foo = $foo; main::foo = $main::foo\n";
}
print "foo = $foo; main::foo = $main::foo\n";
This outputs
foo = hello; main::foo = hello
foo = 2; main::foo = hello
because the inner our $foo declaration shadows the outer $foo in the inner block. Within the block both $foo and $main::foo refer to the same variable; outside $foo refers to the lexical my $foo, which is untouched.
Another difference to use vars:
use strict;
package Foo;
our $x = "hello";
package Bar;
print "$x\n"; # hello
This code works fine because package declarations don't create a new scope. There is only one unit of scoping here (the whole file), and so our $x makes $x refer to $Foo::x for the rest of the file, no matter which package you switch into.
On the other hand:
use strict;
package Foo;
use vars qw($x);
$x = "hello";
package Bar;
print "$x\n";
This code doesn't even compile. The reference to $x in the last line can't be resolved: Perl checks the local scope first, but there are no locally declared $x's. It then checks the current package (Bar) and finds nothing either, and without strict "vars" it would have automatically created $Bar::x for you, but with strict "vars" enabled this is simply an error. $Foo::x is irrelevant and never checked.
I have below Perl code.
use warnings;
use strict;
my $x = "global\n";
sub a {
print $x;
}
sub b {
local $x = "local\n";
a();
}
a();
b();
a();
Even if $x has scope inside b() subroutine why Perl doesn't allows to localize it ?
You cannot mix the lexical scope used by my with the namespaced global scope of package variables (the keyword local may only be used on the latter). Perl will treat $x in the source as the lexically-scoped variable once you have defined it as such. You can still access the package variable (using $::x) - although that would just mean you had two entirely separate variables in use, and would not allow you to refer to either at the same time as $x.
You can achieve something very similar to what you appear to be trying to do by using our instead of my:
our $x = "global\n";
The our keyword creates a lexically-scoped alias to a package variable.
Output is then:
global
local
global
I just wanted to know what is the motivation behind this constraints.
my is thought of as a creator of statically scoped variables.
local is thought of as a creator of dynamically scoped variables.
So you have two similarly-named variables in your program. Given the whole point of my was to replace local, of course my takes precedence over local and not the other way around. You would lose the benefits of my if it was the other way around.
I can't find anywhere what the :: is for in Perl. Example:
$someVariable::QUERY{'someString'};
Thanks!
These are package separators. I suspect the actual code is more like $SomePackage::SomeHash{'SomeKey'}. This syntax allows accessing a "package variable", in this case a hash, from some other package, or by its fully qualified name. You are probably more accustomed to seeing something like:
package SomePackage;
our %SomeHash;
$SomeHash{'SomeKey'} # do something with $SomePackage::SomeHash{'SomeKey'} here
A use case is setting up some module, like say Data::Dumper, which uses these package variables to control output:
use Data::Dumper;
local $Data::Dumper::Sortkeys = 1;
print Dumper { c => 3, a => 1, b => 2 };
... though this type of usage is typically avoided by using Object Oriented style.
See also: the famous "Coping with Scoping" article by MJD: http://perl.plover.com/FAQs/Namespaces.html
It's covered in Perlmod.
The :: is really a namespace identifier. In early Perl before this idea of namespace took hold, you could have variable name collisions happening in your program:
Here's my program:
#! /usr/bin/env perl
#use strict;
use warnings;
use feature qw(say);
require "test2.pl";
$foo = "bar";
futz_with_foo();
say $foo;
I set $foo to bar and never touched it. Should print out bar However, when I run my program, I get:
$ ./test.pl
WOO WOO! I MESSED WITH FOO!
In test2.pl, I have:
sub futz_with_foo {
$foo = "WOO WOO! I MESSED WITH FOO!"
}
1;
What happened is that both programs are using the same variable $foo. To get around this issue Perl gives modules the ability to have their own namespace. The original syntax was the single quote, but changed to :: in Perl 4 (if I remember correctly). You can still use the single quote. You declare your namespace with the package.
The best way to understand this is to see it in action. Try the following:
#! /usr/bin/env perl
use strict;
use warnings;
use feature qw(say);
our $foo = 'This is the value of $foo';
say '$foo: ' . $foo;
say '$main::foo: ' . $main::foo;
say "\$main'foo: " . $main'foo;;
say "\nSwitching to package Bar";
package Bar;
our $foo = 'This is in package Bar';
say '$foo: ' . $foo;
say '$Bar::foo: ' . $Bar::foo;
say "\nSwitching to package main again";
package main;
say '$foo: ' . $foo;
Running this, I get:
$foo: This is the value of $foo
$main::foo: This is the value of $foo
$main'foo: This is the value of $foo
Switching to package Bar
$foo: This is in package Bar
$Bar::foo: This is in package Bar
Switching to package main again
$foo: This is in package Bar
By default, your program starts out in the main namespace. By the way, you'll notice that I declared our $foo and not my $foo. That's because our puts the variable in the Perl symbol table where package variables are stored. The my is a lexically scoped declaration, and is now preferred. A variable declared with my only exists in its declared scope and that can't be outside of the file its in.
Maybe this will shed some light on the error message you get when you forget to declare a variable with my:
Global symbol "$foo" requires explicit package name at ...
By default, all Perl variables are Package variables (that is, they're in Perl's symbol table). The use strict pragma forces you to either declare package variables with our or forces you to use the full package name of the variable. By declaring a variable with my (like we do 99 40/100% of the time) and by using strict, we force you to declare your variables when using Perl.
Hope this helps.
The double-colon operator :: is the separator used to prefix a member of a package, module, or class with the package, module, or class that the member is form (to distinguish between similarly named methods in different containers). You can visit this page for more information.
It's not anything on its own. SomePackage::SomeHash as a whole is an identifier. $someVariable::QUERY{'someString'} refers to hash element someString of the hash %someVariable::QUERY. Hash %someVariable::QUERY is the full name of the hash %QUERY in the package someVariable.
So lets say I have a main.pl script and in that script I need to declare some variables (any kind of variable constant or normal) and those variables need to be available through all scripts and modules that I'll include from that main.pl script automatically.
What I mean if I have a variable $myVar in main.pl and from main.pl I require script1.pl, script2.pl or script3.pm, and from anyone of those scripts I need to access $myVar as you would access any var defined in that specific script or module.
I've searched on the net, but I've only found examples where you can access variables from the scripts you include or extract variables from modules; but that's not what I want.
Isn't there a keyword like in PHP where you would use global $var1, $var2 etc. to use variable from the parent script?
Any example, documentation or article is acceptable - basically anything that could help me accomplish that would be helpful.
You can declare global variables with the our keyword:
our $var = 42;
Each global variable has a fully qualified name which can be used to access it from anywhere. The full name is the package name plus the variable name. If you haven't yet declared a package at that point, you are in package main, which can be shortened to a leading ::. So the above variable has the names
$var # inside package main
$main::var # This is most obvious
$::var # This may be a good compromise
If we had used another package, the prefix would change, e.g.
package Foo;
our $bar = "baz";
# $Foo::bar from anywhere,
# or even $::Foo::bar or $main::Foo::bar
If we want to use a variable without the prefix, but under other packages, we have to export it. This is usually done by subclassing Exporter, see #Davids answer. However, this can only provide variables from packages that are being used, not the other way round. E.g.
Foo.pm:
package Foo;
use strict; use warnings;
use parent 'Exporter'; # imports and subclasses Exporter
our $var = 42;
our $not_exported = "don't look at me";
our #EXPORT = qw($var); # put stuff here you want to export
# put vars into #EXPORT_OK that will be exported on request
1;
script.pl:
#!/usr/bin/perl
# this is implicitly package main
use Foo; # imports $var
print "var = $var\n"; # access the variable without prefix
print "$Foo::not_exported\n"; # access non-exported var with full name
Lexical variables (declared with my) don't have globally unique names and can't be accessed outside their static scope. They also can't be used with Exporter.
The easiest way to do this, would be to create your own module. So, for example, if I want global access to variables $foo and $bar, then I could create a module, as follows:
# file: MyVars.pm
package MyVars;
$foo = 12;
$bar = 117.8;
1;
Then I can access these variables using any perl script that uses the MyVars module:
# file: printvars.pl
use MyVars;
print "foo = $MyVars::foo\nbar = $MyVars::bar\n";
Output:
foo = 12
bar = 117.8
I know what my is in Perl. It defines a variable that exists only in the scope of the block in which it is defined. What does our do?
How does our differ from my?
How does our differ from my and what does our do?
In Summary:
Available since Perl 5, my is a way to declare non-package variables, that are:
private
new
non-global
separate from any package, so that the variable cannot be accessed in the form of $package_name::variable.
On the other hand, our variables are package variables, and thus automatically:
global variables
definitely not private
not necessarily new
can be accessed outside the package (or lexical scope) with the
qualified namespace, as $package_name::variable.
Declaring a variable with our allows you to predeclare variables in order to use them under use strict without getting typo warnings or compile-time errors. Since Perl 5.6, it has replaced the obsolete use vars, which was only file-scoped, and not lexically scoped as is our.
For example, the formal, qualified name for variable $x inside package main is $main::x. Declaring our $x allows you to use the bare $x variable without penalty (i.e., without a resulting error), in the scope of the declaration, when the script uses use strict or use strict "vars". The scope might be one, or two, or more packages, or one small block.
The PerlMonks and PerlDoc links from cartman and Olafur are a great reference - below is my crack at a summary:
my variables are lexically scoped within a single block defined by {} or within the same file if not in {}s. They are not accessible from packages/subroutines defined outside of the same lexical scope / block.
our variables are scoped within a package/file and accessible from any code that use or require that package/file - name conflicts are resolved between packages by prepending the appropriate namespace.
Just to round it out, local variables are "dynamically" scoped, differing from my variables in that they are also accessible from subroutines called within the same block.
An example:
use strict;
for (1 .. 2){
# Both variables are lexically scoped to the block.
our ($o); # Belongs to 'main' package.
my ($m); # Does not belong to a package.
# The variables differ with respect to newness.
$o ++;
$m ++;
print __PACKAGE__, " >> o=$o m=$m\n"; # $m is always 1.
# The package has changed, but we still have direct,
# unqualified access to both variables, because the
# lexical scope has not changed.
package Fubb;
print __PACKAGE__, " >> o=$o m=$m\n";
}
# The our() and my() variables differ with respect to privacy.
# We can still access the variable declared with our(), provided
# that we fully qualify its name, but the variable declared
# with my() is unavailable.
print __PACKAGE__, " >> main::o=$main::o\n"; # 2
print __PACKAGE__, " >> main::m=$main::m\n"; # Undefined.
# Attempts to access the variables directly won't compile.
# print __PACKAGE__, " >> o=$o\n";
# print __PACKAGE__, " >> m=$m\n";
# Variables declared with use vars() are like those declared
# with our(): belong to a package; not private; and not new.
# However, their scoping is package-based rather than lexical.
for (1 .. 9){
use vars qw($uv);
$uv ++;
}
# Even though we are outside the lexical scope where the
# use vars() variable was declared, we have direct access
# because the package has not changed.
print __PACKAGE__, " >> uv=$uv\n";
# And we can access it from another package.
package Bubb;
print __PACKAGE__, " >> main::uv=$main::uv\n";
Coping with Scoping is a good overview of Perl scoping rules. It's old enough that our is not discussed in the body of the text. It is addressed in the Notes section at the end.
The article talks about package variables and dynamic scope and how that differs from lexical variables and lexical scope.
The perldoc has a good definition of our.
Unlike my, which both allocates storage for a variable and associates a simple name with that storage for use within the current scope, our associates a simple name with a package variable in the current package, for use within the current scope. In other words, our has the same scoping rules as my, but does not necessarily create a variable.
my is used for local variables, whereas our is used for global variables.
More reading over at Variable Scoping in Perl: the basics.
I ever met some pitfalls about lexical declarations in Perl that messed me up, which are also related to this question, so I just add my summary here:
1. Definition or declaration?
local $var = 42;
print "var: $var\n";
The output is var: 42. However we couldn't tell if local $var = 42; is a definition or declaration. But how about this:
use strict;
use warnings;
local $var = 42;
print "var: $var\n";
The second program will throw an error:
Global symbol "$var" requires explicit package name.
$var is not defined, which means local $var; is just a declaration! Before using local to declare a variable, make sure that it is defined as a global variable previously.
But why this won't fail?
use strict;
use warnings;
local $a = 42;
print "var: $a\n";
The output is: var: 42.
That's because $a, as well as $b, is a global variable pre-defined in Perl. Remember the sort function?
2. Lexical or global?
I was a C programmer before starting using Perl, so the concept of lexical and global variables seems straightforward to me: it just corresponds to auto and external variables in C. But there're small differences:
In C, an external variable is a variable defined outside any function block. On the other hand, an automatic variable is a variable defined inside a function block. Like this:
int global;
int main(void) {
int local;
}
While in Perl, things are subtle:
sub main {
$var = 42;
}
&main;
print "var: $var\n";
The output is var: 42. $var is a global variable even if it's defined in a function block! Actually in Perl, any variable is declared as global by default.
The lesson is to always add use strict; use warnings; at the beginning of a Perl program, which will force the programmer to declare the lexical variable explicitly, so that we don't get messed up by some mistakes taken for granted.
This is only somewhat related to the question, but I've just discovered a (to me) obscure bit of perl syntax that you can use with "our" (package) variables that you can't use with "my" (local) variables.
#!/usr/bin/perl
our $foo = "BAR";
print $foo . "\n";
${"foo"} = "BAZ";
print $foo . "\n";
Output:
BAR
BAZ
This won't work if you change 'our' to 'my'.
print "package is: " . __PACKAGE__ . "\n";
our $test = 1;
print "trying to print global var from main package: $test\n";
package Changed;
{
my $test = 10;
my $test1 = 11;
print "trying to print local vars from a closed block: $test, $test1\n";
}
&Check_global;
sub Check_global {
print "trying to print global var from a function: $test\n";
}
print "package is: " . __PACKAGE__ . "\n";
print "trying to print global var outside the func and from \"Changed\" package: $test\n";
print "trying to print local var outside the block $test1\n";
Will Output this:
package is: main
trying to print global var from main package: 1
trying to print local vars from a closed block: 10, 11
trying to print global var from a function: 1
package is: Changed
trying to print global var outside the func and from "Changed" package: 1
trying to print local var outside the block
In case using "use strict" will get this failure while attempting to run the script:
Global symbol "$test1" requires explicit package name at ./check_global.pl line 24.
Execution of ./check_global.pl aborted due to compilation errors.
Just try to use the following program :
#!/usr/local/bin/perl
use feature ':5.10';
#use warnings;
package a;
{
my $b = 100;
our $a = 10;
print "$a \n";
print "$b \n";
}
package b;
#my $b = 200;
#our $a = 20 ;
print "in package b value of my b $a::b \n";
print "in package b value of our a $a::a \n";
Let us think what an interpreter actually is: it's a piece of code that stores values in memory and lets the instructions in a program that it interprets access those values by their names, which are specified inside these instructions. So, the big job of an interpreter is to shape the rules of how we should use the names in those instructions to access the values that the interpreter stores.
On encountering "my", the interpreter creates a lexical variable: a named value that the interpreter can access only while it executes a block, and only from within that syntactic block. On encountering "our", the interpreter makes a lexical alias of a package variable: it binds a name, which the interpreter is supposed from then on to process as a lexical variable's name, until the block is finished, to the value of the package variable with the same name.
The effect is that you can then pretend that you're using a lexical variable and bypass the rules of 'use strict' on full qualification of package variables. Since the interpreter automatically creates package variables when they are first used, the side effect of using "our" may also be that the interpreter creates a package variable as well. In this case, two things are created: a package variable, which the interpreter can access from everywhere, provided it's properly designated as requested by 'use strict' (prepended with the name of its package and two colons), and its lexical alias.
Sources:
http://perldoc.perl.org/functions/our.html
http://perldoc.perl.org/perlsub.html#Private-Variables-via-my()
#!/usr/bin/perl -l
use strict;
# if string below commented out, prints 'lol' , if the string enabled, prints 'eeeeeeeee'
#my $lol = 'eeeeeeeeeee' ;
# no errors or warnings at any case, despite of 'strict'
our $lol = eval {$lol} || 'lol' ;
print $lol;