Perl中如何针对哈希嵌套哈希的相同值合并键

当然可以实现这个需求！我来一步步拆解怎么操作，先从示例场景入手，再给出代码实现和注意事项。

示例场景 #

假设你有这样的原始嵌套哈希：

my %original_hash = (
    key1 => {
        '2023-10-01' => 'valueA',
        '2023-10-02' => 'valueB',
        '2023-10-03' => 'valueA',
    },
    key2 => {
        '2023-09-01' => 'valueC',
        '2023-09-02' => 'valueC',
    },
);

你期望的合并结果是把相同值对应的timestamp收集到数组里，变成这样：

my %merged_hash = (
    key1 => {
        'valueA' => ['2023-10-01', '2023-10-03'],
        'valueB' => ['2023-10-02'],
    },
    key2 => {
        'valueC' => ['2023-09-01', '2023-09-02'],
    },
);

实现步骤与代码 #

核心思路就是反转内部哈希的键值关系：以原内部哈希的值作为新键，把对应的timestamp收集到数组中。具体代码如下：

use strict;
use warnings;
use Data::Dumper; # 用于打印哈希结构，方便调试

# 原始嵌套哈希
my %original_hash = (
    key1 => {
        '2023-10-01' => 'valueA',
        '2023-10-02' => 'valueB',
        '2023-10-03' => 'valueA',
    },
    key2 => {
        '2023-09-01' => 'valueC',
        '2023-09-02' => 'valueC',
    },
);

# 初始化合并后的哈希
my %merged_hash;

# 遍历外层哈希的每个键和对应的内部哈希
foreach my $outer_key (keys %original_hash) {
    my $inner_hash_ref = $original_hash{$outer_key};
    # 为当前外层键创建空哈希，用于存储合并后的结果
    $merged_hash{$outer_key} = {};
    
    # 遍历内部哈希的每个timestamp（原键）和对应的值
    foreach my $timestamp (keys %$inner_hash_ref) {
        my $value = $inner_hash_ref->{$timestamp};
        # 把timestamp追加到对应值的数组中
        push @{ $merged_hash{$outer_key}->{$value} }, $timestamp;
    }
    
    # 可选操作：对每个值对应的timestamp数组进行排序（按需启用）
    foreach my $val (keys %{ $merged_hash{$outer_key} }) {
        @{ $merged_hash{$outer_key}->{$val} } = sort @{ $merged_hash{$outer_key}->{$val} };
    }
}

# 打印合并后的结果，验证效果
print Dumper(\%merged_hash);

特殊情况处理 #

如果你的内部哈希的值不是简单字符串/数字，而是嵌套哈希或数组，直接比较值会因为引用地址不同而无法判断是否相等。这时候可以用Data::Compare模块来深度比较值的内容，或者把值序列化为字符串作为唯一标识：

use strict;
use warnings;
use Data::Dumper;
use Data::Compare;

# 原始哈希：内部值是嵌套哈希
my %original_hash = (
    key1 => {
        '2023-10-01' => { name => 'Alice', age => 30 },
        '2023-10-02' => { name => 'Bob', age => 25 },
        '2023-10-03' => { name => 'Alice', age => 30 },
    },
);

my %merged_hash;

foreach my $outer_key (keys %original_hash) {
    my $inner_hash_ref = $original_hash{$outer_key};
    $merged_hash{$outer_key} = []; # 用数组存储{ value => ..., timestamps => ... }结构
    
    my %processed_values; # 记录已处理过的值及其对应的timestamp数组
    
    foreach my $timestamp (keys %$inner_hash_ref) {
        my $current_value = $inner_hash_ref->{$timestamp};
        my $matched = 0;
        
        # 遍历已处理的值，检查是否有内容相同的
        foreach my $entry (@{ $merged_hash{$outer_key} }) {
            if (Compare($current_value, $entry->{value})) {
                push @{ $entry->{timestamps} }, $timestamp;
                $matched = 1;
                last;
            }
        }
        
        # 如果没有匹配到，新增一个条目
        if (!$matched) {
            push @{ $merged_hash{$outer_key} }, {
                value => $current_value,
                timestamps => [$timestamp]
            };
        }
    }
}

print Dumper(\%merged_hash);

注意事项 #

• 务必开启use strict和use warnings，这能帮你避免很多低级错误。
• 如果timestamp是时间戳数字，排序逻辑直接可用；如果是自定义日期格式，可能需要用Time::Piece等模块解析后再排序。
• 当值是复杂结构时，序列化或深度比较会带来一定性能开销，数据量大的话需要权衡。

内容的提问来源于stack exchange，提问作者ran1n