You really want to use a Hash of Arrays (HoA in the common parlance):

my %use;

$use{'valpt'} = [];
$use{'valpt'}[0] = 'whatever';
[download]

Update: For a vigourous explanation of why the OP doesn't want to do what he think he does see Why it's stupid to `use a variable as a variable name'.

/J\

Yes, but you probably don't want to do it:

no strict 'refs';
my $point1 = 'valpt';
@$point1 = (1,2,3);
# symbolic reference
print @valpt;
[download]

Or (your specific request):

no strict 'refs';
my $point1 = 'valpt';
eval "\@use_$point1 = (1,2,3)";
print @use_valpt;
[download]

For several security and bug-hunting reasons, this is a very bad idea. What you probably want is a hash instead...

my $point1 = 'valpt';
my @array = (1,2,3);
$foo{ "use_$point1" } = \@array;
# hard reference to array stored in hash %foo
print @{ $foo{ 'use_valpt' } };
# dereference arrayref stored in %foo under 'use_valpt' key
[download]

You can then access your data by the name chosen in $point1 without worrying about creating global variables all over the place. Have a look at perlref.

Why the eval???

no strict 'refs';
my $point1 = 'valpt';
eval "\@use_$point1 = (1,2,3)";
print @use_valpt;
[download]

can be written as:

no strict 'refs';
my $point1 = 'valpt';
@{"use_$point1"} = (1,2,3);
print @use_valpt;
[download]

Because I am being particularly dim today. You're quite right: using eval is unnecessary, and may well be like handing a box of matches to a kid whose already playing with petrol. I shouldn't have mentioned it :)

You can still use them, if you really know what you're doing. But doing so amounts to mangling with a special hash, namely the symbol table. Use a "real" hash, instead and you're fine.

Use a "real" hash, instead and you're fine.

I beg to differ. Using a 'real' hash subjects you to some of the same problems you face when using symbolic references. Biggest problem: making typos.

    use warnings;
    no strict 'refs';
    my $point1 = 'valpt';
    @{"use_$point1"} = ("foo", "bar");
    ...
    my $var = 'valpt';  # Oops, typo.
    push @{"use_$var"}, "baz";  # Silently does the wrong thing.

    use strict 'refs';
    my $point1 = 'valpt';
    my %use;
    @{$use{$point1}} = ("foo", "bar");
    ...
    my $var = 'valpt';  # Oops, typo.
    push @{$use{$var}}, "baz";  # Silently does the wrong thing.
[download]

Using hash keys as variable names is only marginally better than using symbolic references. (The advantage mainly being you won't accidentely overwrite important package variables - which in this case, given there are no non-user variables starting with 'use', isn't a serious risk). You still got to be careful to be "fine".

Howdy!

Beg all you want. You won't get any... :)

Using hash keys with variable names is so much safer than using symbolic references. The biggest problem with symbolic references is polluting the package namespace.

If you have a data structure with elements whose name is only going to be known at runtime, you have little choice but to use a hash. It's the "right" data structure to use. You have to be responsible for the integrity of the way you manage your keys.

yours,
Michael

In fact they're almost the same, since under the hood, the creation of a symref populates the symbol table, which is 'only' a clever global hash anyway. It'd be interesting to know what the OP wanted to use the code for, since there may well be a nicer solution: the variable names look like they might be something to do with a multidimensional array, which could probably be handled in a tidier way.