perl - Perl 对数组结构哈希的尊重

Question

我有一个数组和哈希的哈希，如下所示：

$VAR1 = \{
           'abc' => {
                       'def' => 'WorkSet',
                       'products' => [
                                       {
                                         'prodtype' => 'Dell',
                                         'product' => 'Powerconnect-5600'
                                       },
                                       {
                                         'prodtype' => 'Dell',
                                         'product' => 'R-720'
                                       },
                                       {
                                         'prodtype' => 'Dell',
                                         'product' => 'R-920'
                                       }
                                     ]
                     },
        '123' => {
                        '456' => 'WorkSet',
                        'products' => [
                                        {
                                          'prodtype' => 'Dell',
                                          'product' => '210'
                                        },
                                        {
                                          'prodtype' => 'Dell',
                                          'product' => 'TZ-200'
                                        },
                                        {
                                          'prodtype' => 'Dell',
                                          'product' => 'TZ-200'
                                        },
                                       ]
          }
 }

我想要这样：

  Branch: Workset
  Build Number: abc
  product : Dell producttype : PowerConnect-5600
  product : Dell producttypr : R-720
  product : Dell producttype : R-920

哈希值 123 也应该相同。

我知道单独遵守上述哈希值，但发现很难在循环中完成。

请给我你的指导。

仅供参考，我已经使用 Data:Dumper perl 模块列出了上述哈希值。

        This is what I thought and tried but not getting the required answer in loops:

  my @unique = uniq @version;
  foreach $version(@ unique){
  my $i=0;
  print "$list->{$version}{branch}\n";
  print "$list->{$version}->{products}->[$i]->{product}\n";
  $i=$i+1;
  } where @unique = qw (abc,123)

score 1 · Accepted Answer

这将取消引用您的结构（假设每个内部版本号只有 2 个元素 - 分支和数组或产品）。您在哈希中将“产品”作为“产品类型”（例如prodtype => Dell），将“产品类型”作为“产品” - 名称相反。您应该考虑按照Jason Gray的建议改进您的数据结构。

#!/usr/bin/perl
use strict;
use warnings;

my $hash = {
           'abc' => {
                       'def' => 'WorkSet',
                       'products' => [
                                       {
                                         'prodtype' => 'Dell',
                                         'product' => 'Powerconnect-5600'
                                       },
                                       {
                                         'prodtype' => 'Dell',
                                         'product' => 'R-720'
                                       },
                                       {
                                         'prodtype' => 'Dell',
                                         'product' => 'R-920'
                                       }
                                     ]
                     },
        '123' => {
                        '456' => 'WorkSet',
                        'products' => [
                                        {
                                          'prodtype' => 'Dell',
                                          'product' => '210'
                                        },
                                        {
                                          'prodtype' => 'Dell',
                                          'product' => 'TZ-200'
                                        },
                                        {
                                          'prodtype' => 'Dell',
                                          'product' => 'TZ-200'
                                        },
                                       ]
          }
};

while (my ($build_num, $href) = each %$hash) {
    my ($branch, $aref);
    for my $key (keys %$href) {
        if (ref($href->{$key}) eq 'ARRAY') {
            $aref = $href->{$key};  
        }
        else {
            $branch = $href->{$key};    
        }
    }
    print "Branch: $branch\n";
    print "Build Number: $build_num\n";

    for my $href (@$aref) {
        print "product: $href->{prodtype} prodtype: $href->{product}\n";
    }
    print "\n";
}

这将输出打印为：

Branch: WorkSet
Build Number: 123
product: Dell prodtype: 210
product: Dell prodtype: TZ-200
product: Dell prodtype: TZ-200

Branch: WorkSet
Build Number: abc
product: Dell prodtype: Powerconnect-5600
product: Dell prodtype: R-720
product: Dell prodtype: R-920

score 1 · Accepted Answer

但是，我意识到这不完全是您的数据结构。我提供了一个示例，说明您可以稍微采用不同的方法。

use strict;
use warnings;
use feature 'say';

my $h = {
      abc => {
          Workset => { 
                       Dell => [ 
                                 'Powerconnect-5600', 
                                 'R-270', 
                                 'R-920', 
                               ],
                     },
             },
      123 => {
          Workset => {
                       Dell => [
                                 '210',
                                 'TZ-200',
                               ],
                     },
             },
};

for my $k ( keys %$h ) {
   for my $j ( keys %$h->{$k} ) {
      for my $prod ( keys %$h->{$k}{$j} ) {
         say "Branch: $j";
         say "Build Number: $k";
         say "product : $prod producttype : " . $_ for @{ $h->{$k}{$j}{$prod} };
      }
   }
}

输出：

Branch: Workset
Build Number: 123
product : Dell producttype : 210
product : Dell producttype : TZ-200

Branch: Workset
Build Number: abc
product : Dell producttype : Powerconnect-5600
product : Dell producttype : R-270
product : Dell producttype : R-920

score 1 · Accepted Answer

这个问题已经被回答并接受了，但无论如何我必须打开我的陷阱......

首先，我认为你的结构是关闭的。它应该如下所示：

$VAR1 = {
          '123' => bless( {
                            'ARRAY' => [
                                         bless( {
                                                  'PRODUCT' => 'Dell',
                                                  'TYPE' => '210'
                                                }, 'Product' ),
                                         bless( {
                                                  'PRODUCT' => 'Dell',
                                                  'TYPE' => 'TZ-200'
                                                }, 'Product' ),
                                         bless( {
                                                  'PRODUCT' => 'Dell',
                                                  'TYPE' => 'TZ-200'
                                                }, 'Product' )
                                       ]
                          }, 'Build' ),
          'abc' => bless( {
                            'ARRAY' => [
                                         bless( {
                                                  'PRODUCT' => 'Dell',
                                                  'TYPE' => 'Powerconnect-5600'
                                                }, 'Product' ),
                                         bless( {
                                                  'PRODUCT' => 'Dell',
                                                  'TYPE' => 'R-720'
                                                }, 'Product' ),
                                         bless( {
                                                  'PRODUCT' => 'Dell',
                                                  'TYPE' => 'R-920'
                                                }, 'Product' )
                                       ]
                          }, 'Build' )
        };

我基于你想要的输出。看起来您有包含产品列表的构建。产品由产品类型和产品描述组成。在您的原始结构中，您有：

 `456` => Workset`

但是这部分结构没有意义，你不要使用它。也许您的意思是这是Branch Type？很难说。让其他我不明白的，我忽略了它。

现在，你应该如何解析这个结构？您应该使用Perl Object Oriented Programming。这使您不必担心数据结构。你的类定义会处理这个问题。如果这是一个哈希数组，或者一个或多个哈希数组，或者可能是一个或多个哈希数组，您不必担心。

这是整个主程序。两个循环：在第一个循环中，我读入数据（由三个选项卡分隔的项目组成：内部版本号、产品类型和产品）。它清晰、简短且易于理解。只需六行代码即可解析整个数据结构：

use strict;
use warnings;
use feature qw(say);

my %workset;
my $prev_build;

#
# Read in the Data
#
while ( my $line = <DATA> ) {
    chomp $line;
    my ($build_num, $prodtype, $description) = split /\t/, $line;
    my $product = Product->new( $prodtype, $description );
    if ( not $prev_build or $prev_build ne $build_num ) {
        $workset{$build_num} = Build->new;
        $prev_build = $build_num;
    }
    $workset{$build_num}->Push($product);
}

#
# Parse the structure and Print it out
#
for my $workset ( sort keys %workset ) {
    say "Build Number: " . $workset;
    while (  my $product = $workset{$workset}->Pop ) {
        say "Product: " . $product->Product . " Prodtype: " . $product->Type;
    }
}

这是输出：

Build Number: 123
Product: Dell Prodtype: TZ-200
Product: Dell Prodtype: TZ-200
Product: Dell Prodtype: 210
Build Number: abc
Product: Dell Prodtype: R-920
Product: Dell Prodtype: R-720
Product: Dell Prodtype: Powerconnect-5600

就像你想要的那样。

我的程序的其余部分是类定义。大多数时候，我只是将定义附加到我的主程序的末尾，因为我再也不会使用它们了。尽管如此，使用面向对象的代码可以使编程更快、更容易。

这是我的程序的其余部分：

package Product;

sub new {
    my $class   = shift;
    my $product = shift;
    my $type        = shift;

    my $self = {};
    bless $self, $class;

    $self->Product($product);
    $self->Type($type);

    return $self;
}

sub Product {
    my $self        = shift;
    my $product = shift;

    if ( defined $product ) {
        $self->{PRODUCT} = $product;
    }
    return $self->{PRODUCT};
}

sub Type {
    my $self = shift;
    my $type = shift;

    if ( defined $type ) {
        $self->{TYPE} = $type;
    }
    return $self->{TYPE};
}

package Build;
use Carp;

sub new {
    my $class = shift;

    my $self = {};
    bless $self, $class;

    return $self;
}

# PRIVATE -- No peeking
sub _Array_ref {
    my $self = shift;

    if ( not exists $self->{ARRAY} ) {
        $self->{ARRAY} = [];
    }
    return $self->{ARRAY};
}

sub Index {
    my $self  = shift;
    my $index = shift;

    if ( not defined $self->{INDEX} ) {
        $self->{INDEX} = 0;
    }

    if ( defined $index ) {
        $self->{INDEX} = $index;
    }

    if ( $self->{INDEX} < 0 or $self->{INDEX} > $self->Size ) {
        croak qq(Index out of range: Set to "$index");
    }

    return $self->{INDEX};
}

sub Array {
    my $self = shift;
    my @array = @{ $self->_Array_ref };

    return wantarray ? @array : \@array;
}

sub Size {
    my $self = shift;

    my $array_ref = $self->_Array_ref;
    return $#{ $array_ref };
}

sub Push {
    my $self    = shift;
    my $product = shift;

    if ( not defined $product or not $product->isa("Product") )  {
        croak qq(Push Method for requires a Product Class to push);
    }

    my $array_ref = $self->_Array_ref;
    push @{ $array_ref }, $product;

    return $#{ $array_ref };
}

sub Pop {
    my $self = shift;

    my $array_ref = $self->_Array_ref;
    return pop @{ $array_ref };
}

sub Next {
    my $self = shift;

    my $index = $self->Index;
    my $array_ref = $self->_Array_ref;
    $index += 1;
    $self->Index($index);

    return ${ $array_ref }[$index];
}

sub Prev {
    my $self = shift;

    my $index = $self->Index;
    my $array_ref = $self->_Array_ref;
    $index -= 1;
    $self->Index($index);

    return ${ $array_ref }[$index];
}

package main;

__DATA__
abc Dell    Powerconnect-5600
abc Dell    R-720
abc Dell    R-920
123 Dell    210
123 Dell    TZ-200
123 Dell    TZ-200

score 0 · Accepted Answer

这也有效：

    while (my ($build_num, $href) = each %$list) {
    my ($branch, $aref, $username);
    $aref = $href->{'products'};
    $branch = $href->{branch};
    $username = $href->{user};

    for my $href (@$aref) {
     print "product: $href->{prodtype}     prodtype: $href->{product}       qbs_id:$href->{qbs_id}\n";
   }

刚刚编辑了@Chris 的答案，做了一些简单的修改，没有使用 ref..谢谢

perl - Perl 对数组结构哈希的尊重

4 回答 4

Related

Reference