First, change @{$ns_records{$k}}->[$d] to $ns_records{$k}->[$d], and your warning goes away. You are trying to use an array as an arrayref, as the warning states. You wouldn't normally say "@array[0]" (that would be a slice). You would say "$array[0]". Dealing with references doesn't change how sigils are applied.

And here's another (and to me, clearer) way to build the datastructure.

use strict;
use warnings;

use Data::Dumper;

    my @ns_list = ( 'server1.foo-domain.net',
                    'server2.noo-domain.net',
                    'server3.zoo-domain.net', );

  my @addr_list = ( '1.2.3.5',
                    '11.22.33.55',
                    '22.21.20.55', );

   my @ptr_list = ( '5.3.2.1.in-addr.arpa',
                    '55.33.22.11.in-addr.arpa',
                    '55.20.21.22.in-addr.arpa', );

my @uptime_list = ( '131 days',
                    '28 days',
                    '366 days', );

my %hash;

$hash{$ns_list[$_]} = [ $addr_list[$_], 
                        $ptr_list[$_], 
                        $uptime_list[$_]
                      ] for 0 .. $#ns_list;
                      
print Dumper \%hash;
[download]

That's definitely clearer - thanks Dave!

You can do that by working with the indexes, rather than shifting

my %ns_records = map {
    $ns_list[$_] => [
        $addr_list[$_],
        $ptr_list[$_],
        $uptime_list[$_]
    ]
} 0 .. $#ns_list;
[download]

A small point of style. The _list suffixes on your arrays don't add much to the readability of your code. I would drop them in favor of descriptive plurals like @addrs, @ptrs, @uptimes. Your hash would read better with a singular name, $ns_record{'foo.org'} pronounced "ns_record of foo.org".

The warning should have a line number associated with it. I think it is from line 33, @{$ns_records{$k}}->[$d], which should be $ns_records{$k}->[$d].

Your hash would read better with a singular name, $ns_record{'foo.org'} pronounced "ns_record of foo.org".

By that logic, arrays should be singular as well, because $addr[4] is pronounced "address number 4". Some consistency would be nice.

For hashes, I use plural when they're used as an array, and singular when they're used as a structure: %ns_records would be a list of records ($ns_records{$domain}), while %ns_record would be a record with named fields ($ns_record{'ptr'}).

Thanks for the tips - any errors are so glaring after you guys point them out!

...that is non-destructive of your original data.
That is very instructive!

    sub transpose {
        my $rows     = shift;
        my $max_col  = @{ $rows->[0] } - 1;
        [ map { my $c=$_; [ map {($_->[$c])} @$rows ] } 0..$max_col ]
    }
[download]

    #    [ [ 0, 1 ]     <== transpose ==>   [ [ 0, 2 ]
    #    , [ 2, 3 ] ]                       , [ 1, 3 ] ]
[download]

    my $data_by_rows = transpose(
        [ \@ns_list, \@addr_list, \@ptr_list, \@uptime_list ]
    ) ;
[download]

    $data_by_rows = [
      [
        'server1.foo-domain.net',
        '1.2.3.5',
        '5.3.2.1.in-addr.arpa',
        '131 days'
      ],
      [
        'server2.noo-domain.net',
        '11.22.33.55',
        '55.33.22.11.in-addr.arpa',
        '28 days'
      ],
      [
        'server3.zoo-domain.net',
        '22.21.20.55',
        '55.20.21.22.in-addr.arpa',
        '366 days'
      ]
    ];
[download]

All that's left to do is convert each row into hostname=>[data] format and load it into your hash:

    my %ns_records =
        map {( shift @$_, [ @$_ ] )} @$data_by_rows;
[download]

While munging the data manually isn't difficult, by factoring out the transposition part of the job, we made our solution easier to understand. We also created a handy helper function that we can reuse on other projects.

Cheers,
Tom

I have a local module, my own version of List::Util, with the utils I find I frequently want for lists. In it &zip and &group are defined. They come in real handy for tasks like this:

    use ihb::List::Util qw/ zip group /;

    my %ns_records;
    @ns_records{@ns_list} = group(3, zip(\(
        @addr_list,
        @ptr_list,
        @uptime_list
    )));
[download]

&zip(ARRAYS) takes a list of array references and zips them together into one list. zip([ 'a' .. 'd' ], [ 1 .. 4 ]) => qw/ a 1 b 2 c 3 d 4 /.

&group(LENGTH, LIST) groups elements in a list into a list of arrays with length LENGTH.

Update: If you don't like to parallelly have to keep the array count in sync, you may do

    use ihb::List::Util qw/ zip group /;

    my @arrays = \(
        @addr_list,
        @ptr_list,
        @uptime_list
    );

    my %ns_records;
    @ns_records{@ns_list} = group(scalar @arrays, zip(@arrays));
[download]

ihb

my %ns_records = map { $_ => [
                               shift @addr_list,
                               shift @ptr_list,
                               shift @uptime_list
                             ]
                     } @ns_list;
[download]

for (0..$#ns_list) {
    $ns_records{$ns_list[$_]} = [$addr_list[$_], $ptr_list[$_], $uptim
+e_list[$_]];
}
[download]

my %ns_records = map { $_ => [
                               pop @addr_list,
                               pop @ptr_list,
                               pop @uptime_list
                             ]
                     } reverse @ns_list;
[download]

Bottom line though, it doesn't really matter from an efficiency standpoint which way you go. Use whichever method is more readable :)

Could you post your benchmark? Does it deal with the fact that the arrays get destroyed on the first test?




Dave