Update: Some relevant reading material.

And when you *do* start using strict, it won't let you use symbolic (soft) references anyway.

OK.. This is driving me crazy. In package x, I have @list = ('a','b','c'). In package y, (after requiring package x), I try: my($a,$b,$c)=(); $a = 'Here'; $b = 'Present': $c = 'Me too'; for(@x::list){ if ($$_) {print "$_ has a value"} } but this does not work using 'my'. I too have moved to stict to support mod_perl (what an excercise!). Why do I do this? I collect form variables (stored in $a,$b,$c) but if they are in @a::list (or better yet, a comma separated database column), they are user-required (and display an error to user if missing). Is this a bad use for symbolic references? What would you do?

Storing form variables in global variables feels like a very bad idea to me, for the same reason any unrestricted set of global variables is a bad idea.

Personally I prefer a hash to store the form variables in, CGI.pm does support it, though its a rather new feature, and it's rather well hidden. Look up the method Vars.

Use a hash and don't abuse globals just to pass arguments. to paraphrase your code:

#!/usr/bin/perl -w
use strict;
check(qw(a b c));


sub check {
  my %hash = (
   a => 'here',
   b => 'present',
   c => 'me too',
  );

  for (@_) {
    print "$hash{$_} has a value\n";
  }
}
[download]

"What should it profit a man, if he should win a flame war, yet lose his cool?"

In addition to what runig said, note that Perl has two places to store variables. The first is the lexical scope pad. That's where my variables go. Lexical scopes can be created and destroyed by a lot of things, but the most common is within blocks:

my $n = 1;
{
    my $n = 2;
    print $n; # Prints 2
}
print $n; # Prints 1
[download]

The second place is the symbol table. This is where variables declared our and local go (among other things). The symbol table can be accessed directly from Perl code (you need a C-based backend to play with the lexical pad directly).

Using lexicals is usually the Right Thing.

Lexical scopes can be created and destroyed by a lot of things

Out of interest, what else can destroy them?

A package statement. The end of a string eval. Probably a bunch of other stuff I can't remember ATM.

"There is no shame in being self-taught, only in not trying to learn in the first place." -- Atrus, Myst: The Book of D'ni.

Since it has been suggested that you use strict and avoid symbolic references, the inevitable question will be "then how do I do what I'm trying to do here?" The answer is almost always to use a hash. Here's a quick example of your code ported to use a lexically scoped hash:

my $n = 0;

my %nums;
foreach ( qw( zero one two three ) ) {
    $nums{$_} = $n++ || "zero";
}
my $msg = "";
foreach ( qw( zero one two three ) ) {
    $msg .= "$_ = '$nums{$_}'\n";
}
print $msg;

print qq(
zero = '$nums{zero}'
one = '$nums{one}'
two = '$nums{two}'
three = '$nums{three}'
);
[download]

You get the benefit of being able to dynamically create entries in the hash, without the side-effect of possibly clobbering unrelated variables.

thanks for everyone's reply. So my two main questions now are:

Just why are lexicals "the right thing?" Both clearly have their uses and their purposes (and scopes), but is it really that one is "the right thing?", or is it just the you have to use the appropriate method at the appropriate time?

The second question is, what is the advantage of using this form of hash:

my $hash;
$hash{foo} = bar;
[download]

vs. this form of hash:

my $hash = {};
$hash->{foo} = bar;
[download]

Just why are lexicals "the right thing?"

Unless you are very careful to use local, package variables (the kind you get when you don't use my) are always global. Even when you do use local, there are many surprises waiting in store. Package variables make action at a distance far too easy.

Lexical variables, on the other hand, are usually very safe. You know that when you scope a lexical variable to a specific block, nothing outside of that block can access it. You also know that you are not clobbering any other variables of the same name from other scopes. It's just the right way to go 99.95% of the time. The whole history of computer science has proved this out -- people are constantly thinking of new ways to keep pieces of code from inadvertantly interacting with and breaking other pieces of code.

The second question is, what is the advantage of using this form of hash . . . vs. this form of hash

The first one you showed was a hash, the second was a hash reference. References are very useful for a variety of reasons, but unless you actually need one, I advise sticking with a plain hash. I have no objective reasons, other than reducing the amount of unnecessary syntax (which, especially when writing Perl code, is always something to strive for).

my $hash;
$hash{foo} = bar;
[download]

Once again, you are not using strict (and you have two different variables named 'hash'). The first line above refers to the lexical scalar variable $hash (which in your second example you use as a hash reference, which is just another type of scalar); the second line, assuming there is nothing else in this program, is referring to the package variable %main::hash. If you wanted to make a lexical hash you would go:

my %hash;
$hash{foo} = 'bar';
[download]

You should use strict, as your second line also uses the bare word 'bar', which gets interpreted as a string, but is a dangerous thing to rely upon, and won't work under strict anyway (and assigining to the undeclared hash is also not allowed under strict). Maybe a look through perldata is in order.

Only lexicals have scope which is why they're "the right thing". You can learn all this and more by reading perldata. RTFM.

Well...

my $hash;
$hash{foo} = bar;
[download]

• Creates a lexical scalar named $hash
• Assigns 'bar' to the key 'foo' in the global variable %hash (or, more accurately, %main::hash)

  If you meant:

  my %hash;
  $hash{foo} = 'bar';
  
  #Versus
  
  my $hash = {};
  $hash->{foo} = 'bar';
  [download]

  Then there is still a difference. In the first, you create a lexical hash named %hash, then assign a value to one of it's keys. In the second you create a lexical scalar which contains an anonymous reference to a hash.

  To examine the difference, run this:

  #!/usr/bin/perl
  use strict;
  use warnings;
  use Data::Dumper;
  
  print "A lexical hash:\n";
  my %hash;
  $hash{foo} = 'bar';
  print Dumper(\%hash);
  
  print "A lexical hash *reference*:\n";
  my $hash = {};
  $hash->{foo} = 'bar';
  print Dumper(\$hash);
  [download]

  Note how the variable in the second case "points to" (is a reference to) the actual hash, while the first case is just the hash. I highly suggest reading up on references, and man perlvar -- the nuances are important and often incredibly useful. ;-)
  radiantmatrix
  require General::Disclaimer;
  "Users are evil. All users are evil. Do not trust them. Perl specifically offers the -T switch because it knows users are evil." - japhy

  $$_ = foo ;
[download]

$main::zero = foo ;
[download]

eval("\$$_ = foo") ;
[download]

my $zero ;
...
print "$zero" ;
[download]