my @data = ({}) x ($rows-1); # need an extra for the header
[download]

No, that wasn't it, but you put me on the right path! You're correct that I had the wrong number of hashrefs, but changing the above line to my @data;, the output is correct. Thank you :)

Temp: '333 aaa' added to row 0  at test.pl line 39.
Temp: '444 bbb' added to row 1  at test.pl line 39.
Temp: '555 ccc' added to row 2  at test.pl line 39.
$VAR1 = {
          'data' => [
                      {
                        'foo' => '333',
                        'bar' => 'aaa'
                      },
                      {
                        'foo' => '444',
                        'bar' => 'bbb'
                      },
                      {
                        'foo' => '555',
                        'bar' => 'ccc'
                      }
                    ],
          'headers' => [
                         'foo',
                         'bar'
                       ]
        };
[download]

Now, does anyone care to tell my po' self why this worked? I feel unusually dense today.

Update: Apparently, using the 'x' operator to populate an array with references will populate it with the same reference for every element, which apparently is the problem. My intent in populating the array with hashrefs was to ensure strong type checking:

my @foo = ([]);
@{$foo[0]}{'one'}='uno'
[download]

The above code fails because you can't coerce an array into a hash.

Cheers,
Ovid

Join the Perlmonks Setiathome Group or just click on the the link and check out our stats.

Yes, using the x operator with references employs the same reference each time. Why? Because that's the most efficient way of doing it, I'd gather, regardless of whether you're using references or not!

As proof, run these in the Perl debugger. (The first x is the 'display this data' instruction to the debugger.) You could also check the source code (pp.c) where the repeatcpy() C function or macro is employed.

x map \$_, ("japhy") x 5;
x ([]) x 5;
[download]

_____________________________________________________
Jeff[japhy]Pinyan: Perl, regex, and perl hacker, who'd like a job (NYC-area)
s++=END;++y(;-P)}y js++=;shajsj<++y(p-q)}?print:??;

use strict;
use Text::CSV;
use Data::Dumper;

my (%report,@headers);
my $csv = Text::CSV->new();

while(<DATA>) {
   die unless $csv->parse($_);
   if ($. == 1) {
      @headers = $csv->fields();
      $report{headers} = \@headers;
   }
   else {
      my @row = $csv->fields();
      push @{$report{data}}, {map{$headers[$_]=>$row[$_]} (0..$#row)};
   }
}

print Dumper \%report;

__DATA__
foo,bar
333,aaa
444,bbb
555,ccc
[download]

Update:
"This fails because, as I mentioned, I don't have direct access to the CSV data and thus cannot use Text::CSV"

I probably chose the words 'unit test' poorly. When i find myself in this situation i try to back away and try another route. I only used Text::CSV to abstract that portion of the problem, as the data structure was what was giving you the trouble.

This fails because I don't have direct access to the CSV data and thus cannot use Text::CSV (though I'd like to). Thanks for the suggestion, though.

Cheers,
Ovid

Join the Perlmonks Setiathome Group or just click on the the link and check out our stats.

my @data = ({}) x (3);
print Dumper \@data;
[download]

$VAR1 = [
          {},
          $VAR1->[0],
          $VAR1->[0]
        ];
[download]

$VAR1 = [
          {},
          {},
          {},
        ];
[download]

for (0..2) {
    print $report->{data}->[$_]->{foo}," => ", $report->{data}->[$_]->
+{bar},"\n";
}
[download]

C:\s\pldir>perl -MData::Dumper -e "@a=({}) x 2;print Dumper @a;"
$VAR1 = {};
$VAR2 = $VAR1;
[download]

When the array is initialized, you end up with the first element being a hash reference, the second element is a reference to the first! I haven't figured out why, yet.

I ran the test without the array initialization (my @data = ({}) x ($rows-1); # need an extra for the header) and Dumper printed the data structure as expected. Is there a reason you need to setup @data in advance? Maybe
push @data, {} for (1 .. $rows-1); would work better if you do?

This appears to be a perl bug. You can see in this very stripped down example that the correct hashes are made but they are not pushed into the array(ref or plain) as expected.

use Data::Dumper;
my (@data, @col_names, %tmp, $record);
@data = <DATA>;
chomp @data;
@col_names = split ',', shift @data;
while(my $line = shift @data) {
    last unless $line;
    @tmp{@col_names} = split ',', $line;
    print 'Inside ', Dumper \%tmp;
    push @{$record}, \%tmp;
}
push @{$record}, { 'what ', 'the £$%^& ?' };
print 'Outside ', Dumper $record;
print 'Record 0 ', %{$record->[0]}, "\n";
print 'Record 1 ', %{$record->[1]}, "\n";
print 'Record 2 ', %{$record->[2]}, "\n";
print 'Record 3 ', %{$record->[3]}, "\n";

__DATA__
foo,bar
333,aaa
444,bbb
555,ccc

__END__
Inside $VAR1 = {
          'foo' => '333',
          'bar' => 'aaa'
        };
Inside $VAR1 = {
          'foo' => '444',
          'bar' => 'bbb'
        };
Inside $VAR1 = {
          'foo' => '555',
          'bar' => 'ccc'
        };
Outside $VAR1 = [
          {
            'foo' => '555',
            'bar' => 'ccc'
          },
          $VAR1->[0],
          $VAR1->[0],
          {
            'what ' => 'the £$%^& ?'
          }
        ];
Record 0 foo555barccc
Record 1 foo555barccc
Record 2 foo555barccc
Record 3 what the £$%^& ?
[download]

cheers

tachyon

s&&rsenoyhcatreve&&&s&n.+t&"$'$`$\"$\&"&ee&&y&srve&&d&&print

That isn't a bug. Your %tmp hash is declared prior to the loop. You are pushing a reference to the same hash each time through the loop (your $record array ref holds a bunch of pointers to the same thing).

I understand your desire to avoid autovivification. I wish there was a Perl pragma to disable it so I could detect certain types of programming mistakes. Since we lack such, my next suggestion is of little practical value.

However, you can initialize a list of reference like so:     my @data= map( {}, 1..$rows ); (Just a tiny tidbit.)