How do I use symbolic references in Perl?

Several points:

• You aren't talking about typeglobs, you are talking about symbolic references.
• Don't use symbolic references -- they lead to hard to track down bugs.
• In almost any case where symbolic references seem like a good idea, using a data structure based on a hash is the best approach.
• Consider using Hash::Util to lock your hashes when you don't want to alter them.
• Symbolic references don't work on lexical variables.
• Typeglobs don't work on lexical variables.
• Use lexical variables.
• Don't use symbolic references.

See perlreftut for more on references (symbolic and otherwise). See perldsc for help using data structures. See perlmod for more on typeglobs. See perlsub for more on lexical variables.

Here's an example of using locked hashes to control access to data based on the content of a variable:

use strict;
use warnings;
use Hash::Util qw( lock_hash unlock_hash );

my %data;
lock_hash( %data );
#Altering %data is a fatal exception.

unlock_hash( %data );

%data = (
    'bob' => [ 'jerk', 'genius' ],
);
lock_hash( %data );


for my $name (qw/ bob  margaret /) {
    my $info = $data{$name}; # Fatal error when accessing data for margaret.
    print "$name is a\n";
    print map "\t$_\n", @$info;
}

All warnings aside, the syntax to use symbolic references should you need to use it (but you won't) is:

use strict;
use warnings;

my $name = 'bob';

our @bob = qw/jerk genius/;

my $qualities;

{   no strict 'refs';
    print "$name: ", @$name, "\n";
    $qualities = \@$name;
}

print "$name is a @$qualities\n";  

Note that the array @bob is declared with our. Symbolic references only work with values in the symbol table. In other words, lexical variables do not work with symbolic references.

Just in case I haven't emphasized this enough, don't use symbolic references.

This is very bad practice. If you ever need to do it, it means you should refactor your code. Perhaps a hash with named keys would be better:

my %data = (
    'bob' => [ 'jerk', 'perlfan' ],
);
my $name = 'bob';

print $data{ $name }->[0], "\n";
print $data{ $name }->[1], "\n";

my $stringified = join ' and ', @{ $data{ $name } };
print $stringified, "\n";

See perldoc -q "variable name":

Beginners often think they want to have a variable contain the name of a variable. ...

Short answer: Don't. Long answer: Read the FAQ entry (which is also available on your computer). Longer answer: Read MJD's Why it's stupid to "use a variable as a variable name" (Part 2, Part 3).

You really shouldn't have to do this, see depesz's answer for the alternative, but...

{
    no strict 'refs';
    print join(q{, }, @$name);
}

Yes, you can use a string scalar as a variable reference, and it looks up the variable by name.

You can also do this with typeglobs, see the Symbol module for an easy way.

Usually when you think you need to use symbolic references, you will be better served by using a hash (associative array).

use strict;
use warnings;

my %user = (
  'bob' => [qw' jerk perlfan '],
  'mary' => 'had a little lamb',
);

{
  for my $name (qw'bob mary susan'){
    if( exists $user{$name} ){

      if( ref($user{$name}) eq 'ARRAY' ){
        print join( ' ', @{$user{$name}} ), "\n";

      }else{
        print $name, ' ', $user{$name}, "\n";
      }

    }else{
      print "$name not found\n";
    }
  }
}

Results in:

jerk perlfan
mary had a little lamb
susan not found

If you think you really need to use symbolic references, this is a safer way to do that.

use strict;
use warnings;

# can't use my
our @bob = ("jerk", "perlfan");
our $mary = 'had a little lamb';

{
  for my $name (qw'bob mary susan'){
    if( exists $::{$name} ){
      my $ref = $::{$name};

      if( *{$ref}{ARRAY} ){
        print join(' ',@$ref), "\n";

      }elsif( *{$ref}{SCALAR} ){
        print "# $name is not an array, it's a scalar\n";
        print $name, ' ', $$ref, "\n";
      }

    }else{
      print "$name not found\n"
    }
  }
}

Which returns:

jerk perlfan
# mary is not an array, it's a scalar
mary had a little lamb
susan not found

You should notice that it is harder to symbolic references safely, which is why you shouldn't use them.

_{Unless of course you are an expert doing something advanced.}