帮助遍历/排序复杂的Perl数据结构(HoH with AoH fun)

我已经纠结了好几个小时了

我有一个数据结构，看起来像这样(从"data::Dumper"输出)。这是我自己的错，我正在创建数据结构，因为我正在解析一些输入。

print Dumper $data;
___OUTPUT___
$VAR = { 'NAME' => {
                    'id' => '1234',
                    'total' => 192,
                    'results' =>  { 
                                     'APPLE'   => 48 ,
                                     'KUMQUAT' => 61 ,
                                     'ORANGE'  => 33 ,
                                  }
                   }
       }

有上千个"NAME"键
只有一个"id"和一个"total"。
在"结果"散列中可能有一个或多个键/值对。

我想打印出一个逗号分隔的列表，首先按"total"排序，然后按"results"数组中每个散列的值排序。

下面的代码用于从已经存储的数据结构中打印出CSV。

use strict;
use warnings;
# [...lots of other stuff...]
open (my $fh, >out.csv);
print $fh "Name, ID, Label, Count, Totaln";
foreach ( sort { $data->{$b}->{total} <=> $data->{$a}->{total} }
    keys %{$data} )
{
    my $name = $_;
    foreach (
        sort {
            $data->{$name}->{results}->{$a} <=> $data->{$name}->{results}
              ->{$b}
        } values %{ $data->{$name}->{results} }
      )
    {
        print $fh $name . ","
          . $data->{$name}->{id} . "," . "'"
          . $_ . ","
          . $data->{$name}->{results}->{$_} . "," . "n";
    }
    print $fh $name . ","
      . $data->{$name}->{id} . "," . "," . ","
      . $data->{$name}->{total} . "n";
}
close($fh);

这很好，工作得很好(除了提醒我为什么不再使用Perl)。

示例输出如下:

Name, ID,  Label,   Count, Total
foo, 1234, ORANGE,    33,
foo, 1234, APPLE,     48,
foo, 1234, KUMQUAT,   61,
foo, 1234,     ,        ,  142
bar, 1101, BIKE,      20,
bar  1101,     ,        ,  20

然而

!我注意到我正在获得键碰撞(在"结果"哈希)，因为我需要保持和报告所有数据，我决定尝试将"结果"更改为哈希数组…

print Dumper $data;
___OUTPUT___
$VAR = { 'NAME' => {
                    'id' => '1234',
                    'total' => 192,
                    'results' => [
                                   { 'APPLE'   => 48 },
                                   { 'KUMQUAT' => 61 },
                                   { 'ORANGE'  => 33 },
                                   { 'APPLE'   => 50 },
                                 ]
                   }
       }

有上千个"NAME"键
只有一个"id"和一个"total"。
"结果"数组中可能有一个或多个哈希值。
"results"数组中的每个哈希值只能有一个名称/值对。

不管有没有人读过这篇文章，我不得不说把它写下来是相当有治疗作用的，所以我会继续…: -)

对于新的数据结构，我在排序/打印代码方面遇到了问题。

use strict;
use warnings;
# [...lots of other stuff...]
open (my $fh, >out.csv);
print $fh "Name, ID, Label, Count, Totaln";
foreach ( sort { $data->{$b}->{total} <=> $data->{$a}->{total} }
    keys %{$data} )
{
    my $name = $_;
    foreach (
        sort {
            $data->{$name}->{results}->{$a} <=> $data->{$name}->{results}
              ->{$b}
        } values %{ $data->{$name}->{results} }
      )
    {
    # .... HELP ME FOR THE LOVE OF ALL THAT IS GOOD IN THE WORLD! ....
    # I'm at the point now where my brain is starting to slowly dribble from my
    # ears...
    }
    print $fh $name . "," 
      . $data->{$name}->{id} . "," . "," . ","
      . $data->{$name}->{total} . "n";
}
close($fh);

如果你读到这里我向你致敬。如果你能帮忙，我为你鼓掌。

如果有人对数据结构的替代格式有建议，请告诉我!(如果你感兴趣的话……我使用"flip-flop"操作符来捕获源文件的块，然后逐行使用这些块来创建数据结构。我还调用外部程序来计算某些东西(没有Perl等价物)并存储结果。

谢谢

好了，我只说一次:当你有复杂的结构时总是使用对象

正如你所发现的，你的大脑在试图跟踪哈希数组的哈希数组的数组时会爆炸。这是创建对象结构的完美理由。如果您永远不会重用它，那也没关系。它使你的编程任务，更容易。

下面的包花了我大约30分钟来编写和调试。如果你使用它，你就会省去很多麻烦和调试。

作为一个额外的好处，当您发现您的错误假设(嘿，每个人都这样做!)，您的RESULT数组中有多个具有相同键的项时，您只需要修改几行易于定位的代码，而不是遍历整个程序，试图将所有内容保持在一起。

我使用你的数据结构，除了我使结果数组包含两个项目的数组(标签和金额)，而不是哈希。我本可以使用散列，但这样，我可以返回一个包含两个元素的数组。现在，我想起来了，真的没有理由这样做。

#! /usr/bin/env perl
use warnings;
use strict;
use feature qw(say);
use Data::Dumper;

my %hash;
my $obj;
$obj = structure->new();
$obj->Name("foo");
$obj->Total("foo", 142);
$obj->Id("foo", 1234);
$obj->Push(qw(foo  ORANGE  33));
$obj->Push(qw(foo  APPLE   48));
$obj->Push(qw(foo  APPLE   50));
$obj->Push(qw(foo  KUMQUAT 61));
$obj->SortResults("foo");
$obj->Name("bar");
$obj->Total("bar", 20);
$obj->Id("bar", 1100);
$obj->Push(qw(bar BIKE    20));
$obj->SortResults("bar");
say Dumper($obj);
exit 0;
########################################################################
package structure;
use Data::Dumper;
#
# New Structure containing all data
# 
sub new {
    my $class = shift;
    my $self = {};
    bless $self, $class;
    return $self;
}
#
# Either adds a new name object or returns name object;
#
sub Name {
    my $self = shift;
    my $name = shift;
    if (not defined $self->{$name}) {
        $self->{$name}->{ID} = undef;
        $self->{$name}->{TOTAL} = undef;
        $self->{$name}->{RESULTS} = [];
    }
    return $self->{$name};
}
#
# Returns a list of Names
#
sub NameList {
    my $self = shift;
    return keys %{$self};
}
#
# Either returns the id or sets $name's id
#
sub Id {
    my $self = shift;
    my $name = shift;
    my $id = shift;
    my $nameObj = $self->Name($name);
    if (defined $id) {
        $nameObj->{ID} = $id;
    }
    return $nameObj->{ID};
}
#
# Either returns the total for $name or sets $name's total
#
sub Total {
    my $self = shift;
    my $name = shift;
    my $total = shift;
    my $nameObj = $self->Name($name);
    if (defined $total) {
        $nameObj->{TOTAL} = $total;
    }
    return $nameObj->{TOTAL};
}
#
# Pushes new product and amount on $name's result list
#
sub Push {
    my $self = shift;
    my $name = shift;
    my $product = shift;
    my $amount = shift;
    my $nameObj = $self->Name($name);
    my @array = ("$name", "$amount");
    push @{$nameObj->{RESULTS}}, @array;
    return @array;
}
#
# Pops product and amount on $name's result list
#
sub Pop {
    my $self = shift;
    my $name = shift;
    my $nameObj = $self->Name($name);
    my $arrayRef = pop @{$nameObj->{RESULTS}};
    return @{$arrayRef};
}
sub SortResults {
    my $self = shift;
    my $name = shift;
    my $nameObj = $self->Name($name);
    my @results = @{$nameObj->{RESULTS}};
my @sortedResults = sort {$a->[1] <=> $b->[1]} @results;
my $nameObj->{RESULTS} = @sortedResults;
    return @sortedResults;
}

$obj->SortResults将对结果进行排序，但是您可以使用它来检索作为排序列表的结果。要按总数对项目进行排序，您可以使用:

my @sortedItems = sort {$obj->Total($a) <=> $obj->Total($b)} $obj->NameList();

简而言之，你可以节省自己的时间和清洁女工清理的烂摊子。(爆炸的大脑很难从墙壁和天花板上擦去)。

我从经验中学到，当你开始谈论包含指向其他哈希的数组的哈希时，是时候创建一个对象来处理混乱了。为这些一次性作业创建对象似乎要花更长的时间，但根据我的经验，您通常可以在30分钟内制作出所需的对象并进行测试，从而节省了随后数小时的挫败感。

use strict;
use warnings;
# [...lots of other stuff...]
open (my $fh, '>', 'out.csv');
print $fh "Name, ID, Label, Count, Totaln";
my $data = {
    'NAME' => {
        'id' => '1234',
        'total' => 192,
        'results' => [
            { 'APPLE'   => 48 },
            { 'KUMQUAT' => 61 },
            { 'ORANGE'  => 33 },
            { 'APPLE'   => 50 },
        ]
    }
};
# sort names by total, descending
for my $name ( sort { $data->{$b}{total} <=> $data->{$a}{total} } keys %{$data} )
{
    # sort results by count, ascending; is this what you want?
    for my $result ( sort { (%$a)[1] <=> (%$b)[1] } @{ $data->{$name}{results} } ) {
        my ($label, $count) = %$result;
        print $fh join(',', $name, $data->{$name}{id}, $label, $count, ''), "n";
    }
    print $fh join(',', $name, $data->{$name}{id}, '', '', $data->{$name}{total}), "n";
}
close($fh);

您可以使用这样的数据结构来减少复杂性:

$VAR = [
         {
           'name' => 'foo',
           'id' => '1234',
           'total' => 192,
           'results' => [
                          { 'label' => 'APPLE', 'score' => 48 },
                          { 'label' => 'KUMQUAT', 'score' => 61 },
                          { 'label' => 'ORANGE', 'score' => 33 },
                          { 'label' => 'APPLE', 'score' => 50 },
                        ]
         },
       ];

所以，如果我没记错的话，你看到的应该是这样的:

foreach my $row ( sort( $a->{'total'} <=> $b->{'total'} ) @data ) {
    foreach my $result ( sort( $a->{'score'} <=> $b->{'score'} ) @{$row->{'results'}} ) {
    }
}

相关内容

最新更新

热门标签：