4.4 Symbolic References

What happens if you try to dereference a value that is not a hard reference? The value is then treated as a symbolic reference. That is, the reference (which still has a scalar value) is interpreted as a string. That string is taken to be the name of a variable, rather than a direct link to a (possibly anonymous) thingy.

Here is how it works:

$name = "bam";
$$name = 1;                # Sets $bam
${$name} = 2;              # Sets $bam
${$name x 2} = 3;          # Sets $bambam
$name->[0] = 4;            # Sets $bam[0]
@$name = ();               # Clears @bam
&$name();                  # Calls &bam() (as in prior versions of Perl)
$pkg = "THAT";             #  (Don't use "package" or "pack"!)
${"${$pkg}::$name"} = 5;   # Sets $THAT::bam without eval

This is very powerful, and slightly dangerous, in that it's possible to intend (with the utmost sincerity) to use a hard reference, and accidentally use a symbolic reference instead. To protect against that, you can say:

use strict 'refs';

and then only hard references will be allowed for the rest of the enclosing block. An inner block may countermand that decree with:

no strict 'refs';

It is important to note the difference between the following two lines of code:

${identifier};    # same as $identifier
${"identifier"};  # also $identifier, but treated as symbolic reference

Because the second form is treated as a symbolic reference, it will generate an error under use strict 'refs'.

Only package variables are visible to symbolic references. Lexical variables (declared with my) aren't in a package symbol table, and thus are invisible to this mechanism. For example:

local $value  = "10";
{
    my $value = "20";
    print ${"value"};
}

This will print "10", not "20". Remember that local affects package variables, which are all global to the package.