my $arraycnt = 0;
$$_ = $values[$arraycnt++] for @names;
[download]

Update: Also, please read Why it's stupid to `use a variable as a variable name'

Another warning - there is no guarantee that the name you are attempting to create from the content of @names is a valid perl variable-identifier. You may get strange run-time errors.

Sure i can, i'm just trying to create a set of variables that match the database field names filled with the relevant data (a good 800 or so fields).

As i said i understand it could be better to use hashes and so on, but in this case the variables built from @names aren't variables at all, because they are fieldnames from a database that don't change..

Which allows me to use the one reference in all the applications that access this particular database.. And the above worked perfectly.. Thanks..

And how exactly is using the fieldnames from a database to dynamically create scalar variable names an improvement over using a hash to hold the fieldnames and their respective values? I'm really curious. With the hash method, you get one hash, easily transportable by hard reference, and easily manipulated. With the symbolic ref method, you get variable names that are created in the global symbol table hash, which you must continue to use via soft reference throughout the remainder of the script unless your script both dynamically creates the variable names and hard codes them. ...if it's the latter, and you're hard coding the names at later points in the script, may as well hard code them from the beginning instead of creating them on the fly.

The fact is that there are few good uses of symbolic references. An exception is the exporting of global variables between packages... but even this should be handled with care and often via the well-proven Exporter module. Many languages don't even allow the use of soft references, and yet they still get along just fine without them.




Dave

Forgetting about symbolic references ( variables dynamically named ) and forgetting the above snippet, could you please explain what exactly you're trying to accomplish? It almost looks like you're trying to associate a bunch of field names with a bunch of values, and maybe trying to create variables named after those fieldnames, though the code above isn't quite doing that. With a little more explanation and clarification someone's going to come along and help you find the proper way to accomplish what you really need, instead of what you're currently asking for.

If you want to just create a bunch of variables named after the contents of @names, you would probably do it this way:

    no strict qw/refs/;
    @::{@names} = \( @values );
[download]

But that's a surefire way to cause yourself all sorts of headaches that you really don't want to suffer through. You know, the global symbol table, that you're trying to muck around with, is just a glorified hash. If it's good enough for Perl, it's probably good enough for you too: use a hash.

UpdatedUsed a symbol-table slice instead of original foreach loop, just for fun and reckless disregard for the safety of mankind.

use strict;

$db->FetchRow();
my @names = $db->FieldNames();
my @values = $db->Data();
no strict "refs";
${$names[$_]} = $values[$_] for 0..$#names;
use strict;
[download]

By the way, while ($names[$arraycnt] ne '') is an infinite loop. Uninitialized entries in an array are undef, not ''.

undef is converted to the empty string when comparing it to a string. Give it a try:

print "ne" while(undef eq '');
[download]

hth

re: By the way, while ($names$arraycnt ne '') is an infinite loop. Uninitialized entries in an array are undef, not ''.

just tried something after you said this, i.e. got the loop to count and print the number every time it loops and it only counts to the exact number of the fields in the db, so it must have read the undef to equal ''?