Basically, when you save an array or hash as elements of a hash, you have to store the array ref or hash ref.

See the code and comments:

use strict; #for better practice
use warnings;#same as above

my @test = ( qw / bing bong bang / );
print '['.$test[2].'] ['.$test[1].'] ['.$test[0]."]\n";

my %bits;#explicitly declare your variables
$bits{'one'}= \@test;#assign the array ref, not the flattened array it
+self.
my @new =  @{$bits{'one'}};#now deref it, so you get the flattened arr
+ay back.
print '['.$new[2].'] ['.$new[1].'] ['.$new[0]."]\n";
[download]

A even better way, is to use the array ref directly, instead of falttening it and copying the entire array. When the array is big, that gives you bad performance.

use strict;
use warnings;

my @test = ( qw / bing bong bang / );
print '['.$test[2].'] ['.$test[1].'] ['.$test[0]."]\n";

my %bits;
$bits{'one'}= \@test;
my $new =  $bits{'one'}; #new holds the array ref, not a copy of the e
+ntire array
print '['.$new->[2].'] ['.$new->[1].'] ['.$new->[0]."]\n";#to get elem
+ents from array ref, use -> operator
[download]

my @test = qw / bing bong bang /;
print '['.$test[2].'] ['.$test[1].'] ['.$test[0]."]\n";

$bits{'one'}= \@test;        # hash entry from a reference to array
my @new =  @{$bits{'one'}};  # get back the array from the hash

print '['.$new[2].'] ['.$new[1].'] ['.$new[0]."]\n";
[download]

use Data::Dumper;

@test = qw / bing bong bang /;
print Dumper(\@test);

$bits{'one'}= \@test;

@new =  @{$bits{'one'}};
print Dumper(\@new);
[download]

$bits{'one'}=@test;
[download]

my @test = ( qw / bing bong bang / );
print '['.$test[2].'] ['.$test[1].'] ['.$test[0]."]\n";
$bits{'one'}= \@test;
my @new =  @{$bits{'one'}};
print '['.$new[2].'] ['.$new[1].'] ['.$new[0]."]\n";

OUTPUT:
[bang] [bong] [bing]
[bang] [bong] [bing]
[download]

Even though it isn't exactly the same as \@test, for your purposes it works the same.

It's doubtful that his real purposes are anything like the example he showed, so the differences between [ @test ] and \@test may actually be quite significant.

The first, [ @test ] actually creates a new array, a copy of @test, and returns a reference to it. The second, \@test returns a reference to @test itself.

If @test is big, making copies of it could hurt performance.

Also, because the data is copied, changing an element in the array referred to by [ @test ] won't have any affect on the contents of @test itself. Sometimes that's just what you want. Sometimes it isn't.

-sauoq
"My two cents aren't worth a dime.";

Ah.. now this is interesting..

In this instance I plan to read lines from a file and split them by their delimiter and store them as lists in a hash.

So @test in my example is infact one line read from a file, then @test becomes another line etc..

So what happens to the data if its references all the way down?

I suspect I should be using the @test method in this case.

 ___
/\__\ "What is the world coming to?"
\/__/ www.wolispace.com
[download]

And just because TI(always)MTOWTDI, just another twist on ways you can do it:

$bits->{'one'}    = \@test;          # use a reference
@{$bits->{'one'}} = @test;           # copy into $bits
$bits{'one'}      = [@test];         # copy into anon. list
$bits{'one'}      = \@{[@test]};     # um yeah, having fun
$bits{'one'}      = [@{[@test]}];    # you wouldn't REALLY do this
@{$bits{'one'}}   = @{[@{[@test]}]}; # ok, that's ridiculous
[download]

my @test = ( qw / bing bong bang / );
print '['.$test[2].'] ['.$test[1].'] ['.$test[0]."]\n";
$bits{'one'}= \@test;
my @new =  @{$bits{'one'}};
print '['.$new[2].'] ['.$new[1].'] ['.$new[0]."]\n";

__OUTPUT__
[bang] [bong] [bing]
[bang] [bong] [bing]
[download]

Please use perldoc to view the following documents on your local machine:

perldoc perlreftut
perldoc perlref
perldoc perllol
perldoc perldsc
[download]

PerlMonks Q&A comes tantilisingly close

Closer than that, I'd say. Did you look at nested data structures?