在 Perl 中打印数组哈希的有效方法

Question

我正在编写一个脚本，该脚本涉及打印数组散列的散列内容。

ex（伪代码）：

my %hash = ();
$hash{key1}{key2} = ['value1', 'value2', 'value3', . . .];

或

$hash{key1}{key2} = @array_of_values;

基本上，我希望能够对任意数量的键组合执行此操作，并且能够遍历所有可能的键/值对（或者更正确地表述为键、键/数组对，因为每个值实际上都是一个值数组，每个数组有 2 个与之关联的键）并以以下格式打印输出：

"key1, key2, value1, value2, value3, ...\n"

例如：

#!/usr/bin/perl

use strict;
use warnings;

# initialize hash
my %hash = ();
my $string1 = "string1";
my $string2 = "string2";

# push strings onto arrays stored in hash
push @{$hash{a}{b}}, $string1;
push @{$hash{a}{b}}, $string2;
push @{$hash{c}{d}}, $string2;
push @{$hash{c}{d}}, $string1;

# print elements of hash
# (want to do this as a loop for all possible key/value pairs)
local $, = ',';
print "a, b, ";
print @{$hash{a}{b}};
print "\n";
print "c, d, ";
print @{$hash{c}{d}};
print "\n";

system ('pause');

这段代码的输出如下所示：

a, b, string1,string2
c, d, string2,string1
Press any key to continue . . .

我正在考虑使用 each 运算符，但它似乎只适用于一维散列。 （each只返回一个键值对，涉及2个键时不能正常工作）

如何简化此代码以循环遍历哈希并打印所需的输出，而不管我的哈希有多大？

Answer 1

我一直在考虑并想出了一种可能的解决方案。如果有人有更优雅的解决方案，我很乐意看到它。谢谢！

这是我想出的解决方案：

#!/usr/bin/perl

use strict;
use warnings;

# initialize hash
my %hash = ();
my $string1 = "string1";
my $string2 = "string2";

# push strings onto arrays stored in hash
push @{$hash{a}{b}}, $string1;
push @{$hash{a}{b}}, $string2;
push @{$hash{c}{d}}, $string2;
push @{$hash{c}{d}}, $string1;

# prints hash of hash of arrays in a loop :)
my @keys1 = keys %hash;
for my $key1 (@keys1) {
    my @keys2 = keys $hash{$key1};
    for my $key2 (@keys2) {
        local $" = ', ';
        print "$key1, $key2, @{$hash{$key1}{$key2}}";
        print "\n";
    }
}

system ('pause');

虽然此解决方案不关心键的顺序，但它会以随机顺序打印。

输出：

c, d, string2, string1
a, b, string1, string2
Press any key to continue . . .

Answer 2

即使对于多级散列，使用each 也能正常工作，您只需要确保参数是散列即可。这是一个如何做到这一点的例子。我还展示了如何初始化你的哈希值。

use strict;
use warnings;
use v5.14;

my $string1 = "string1";
my $string2 = "string2";
my %hash = (
    a => { 
        b => [ $string1, $string2 ],
    },
    c => {
        d => [ $string2, $string1 ],
    }
);

for my $key (keys %hash) {
    while (my ($k, $v) = each %{ $hash{$key} }) {
        say join ", ", $key, $k, @$v;
    }
}

输出：

c, d, string2, string1
a, b, string1, string2

请注意使用@$v 来访问最内层数组的简单性，而不是使用有些繁琐的替代@{ $hash{$key}{$k} }。

Answer 3

要打印数组哈希的哈希值，您可以使用foreach 或for my 遍历数据结构：

# keys of the outer hash
foreach my $oh (keys %hash) {
    # keys of the inner hash
    foreach my $ih (keys %{$hash{$oh}}) {
        # $hash{$oh}{$ih} is the array, so it can be printed thus:
        print join(", ", $oh, $ih, @{$hash{$oh}{$ih}}) . "\n";

        # or you can iterate through the items like this:
        # foreach my $arr (@{$hash{$oh}{$ih}})
        # {   doSomethingTo($arr); }

    }
}

对于所有制图迷，这里有一个map 版本：

map { my $oh = $_; 
    map { say join( ", ", $oh, $_, @{$hash{$oh}{$_}} )  } keys %{$hash{$_}}
} keys %hash;

Answer 4

这是最简洁的递归子例程，因为它只会递归几次，所以不是一种浪费的解决方案。

use strict;
use warnings;

my %hash;
my ($string1, $string2) = qw/ string1 string2 /;

push @{$hash{a}{b}}, $string1;
push @{$hash{a}{b}}, $string2;
push @{$hash{c}{d}}, $string2;
push @{$hash{c}{d}}, $string1;

print_data(\%hash);

sub print_data {
    my ($ref, $prefix) = (@_, '');

   if (ref $ref eq 'ARRAY') {
      print $prefix, join(', ', @$ref), "\n";
   }
   else {
      print_data($ref->{$_}, "$prefix$_, ") for sort keys %$ref;
   }
}

输出

a, b, string1, string2
c, d, string2, string1

Answer 5

听起来你需要一个嵌套循环......可能有一种方法可以使用map 来做到这一点，这种方法更难记住，可读性也更差；-)（当然只对我自己说 - 我期待看到@ 987654326@解决方案出现在这里！）：

#!perl -l
my %hash = ();
$hash{key1}{key2} = ['value1', 'value2', 'value3',];

for my $outer (keys %hash) { 
    for my $inner (keys $hash{$outer}) { 
       print join(', ', $outer, $inner, @{ $hash{$outer}{$inner} } )
    } 
}

输出：

key1, key2, value1, value2, value3

如果事情真的很复杂，还有Data::Printer、Data::Seek、Data::Dive 和其他几个便利模块。有些需要使用哈希引用，但这可能会使更简单的解决方案复杂化，或者更容易解决更大、更困难的问题......

干杯，

编辑：将“嵌套地图”移动到单独的答案中。

Answer 6

您还没有说明为什么要打印 HoHoA 的内容（数组散列的散列）。如果出于调试目的，我会使用 Data::Dumper（核心）或 Data::Dump（在 CPAN 上）。

use Data::Dumper qw(Dumper);
print Dumper \%hash;

或

use Data::Dump qw(pp);
pp \%hash;

假设您希望根据样本格式化输出是有原因的（并且它始终只是一个 HoHoA）我会使用嵌套循环：

while (my ($ok, $ov) = each %hash) {
    while (my ($ik, $iv) = each %$ov) {
        say join ',', @$iv;
    }
}

我不建议使用map。它最适合用于列表转换而不是流控制，并且使用嵌套的map 块跟踪外部和内部键很尴尬，两者都使用$_ 处理不同的事情。不过，因为您和 G. Cito 表示有兴趣看到一个，所以这里是：

say foreach map {
    my $o = $_;
    map {
        my $i = $_;
        join ',', $o, $i, @{$hash{$o}{$i}}
    } keys %{$hash{$o}};
} keys %hash;

Answer 7

我要了它:-( ...“嵌套地图”(??)。

#!perl -l
my %hash = ();
$hash{key1}{key2} = ['value1', 'value2', 'value3',];
map{ &{ sub{
   map{ print for @{$hash{$_[0]}{$_}}} keys $hash{$_} }}($_)} keys %hash;

输出：

value1
value2
value3

注意：我认为从技术上讲（在幕后）它仍然是一个循环并且没有效率。似乎如果您“嵌套”对map 的调用并用匿名sub（{& sub { .. 位）包装内部map{}，那么您可以通过@_ 引用外部map 主题值（ ie 在$_[0] 中，因为它们进入内部map ...但前提是它们在列表上下文中($_) ... errm (?!?) 好的，我只是抓住这里。

无论如何，它可以工作，但看起来比它应该的更混乱 - 可能是因为它是一个“anti-pattern”。一个好处是它使“嵌套的for 循环”看起来不那么凌乱并且更易于阅读。