如何根据另一个哈希的键/值删除[子]哈希？

Question

假设我有两个哈希值。其中一个包含一组数据，只需要保留另一个哈希中显示的内容。

例如，

my %hash1 = ( 
        test1 => { inner1 => { more => "alpha", evenmore => "beta" } },
        test2 => { inner2 => { more => "charlie", somethingelse => "delta" } },
        test3 => { inner9999 => { ohlookmore => "golf", somethingelse => "foxtrot" } }
    );

my %hash2 = (
        major=> { test2 => "inner2",
              test3 => "inner3" }  );

我想做的是，如果 hash1 中的整个子哈希不作为 hash2{major} 中的键/值存在，则删除它，最好没有模块。 “innerX”中包含的信息并不重要，它只是必须保留（除非要删除子哈希，然后它就会消失）。

在上面的示例中，执行此操作后，hash1 将如下所示：

my %hash1 = ( 
        test2 => { inner2 => { more => "charlie", somethingelse => "delta" } },
        );

它删除 hash1{test1} 和 hash1{test3}，因为它们与 hash2 中的任何内容都不匹配。

这是我目前尝试过的方法，但它不起作用。这也可能不是最安全的做法，因为我在尝试删除哈希值时循环遍历哈希值。不过我正在删除每个应该没问题的吗？

这是我尝试这样做，但是 perl 抱怨：

Can't use string ("inner1") as a HASH ref while "strict refs" in use at

while(my ($test, $inner) = each %hash1)
{
    if(exists $hash2{major}{$test}{$inner})
    {
        print "$test($inner) is in exists.\n";
    }
    else
    {
        print "Looks like $test($inner) does not exist, REMOVING.\n";
       #not to sure if $inner is needed to remove the whole entry
         delete ($hash1{$test}{$inner});
    } 
}

Answer 1

你很接近。请记住，$hash2{major}{$test} 是标量，而不是哈希引用。

#! /usr/bin/perl

use strict;
use warnings;

my %hash1 = ( 
  test1 => { inner1 => { more => "alpha", evenmore => "beta" } },
  test2 => { inner2 => { more => "charlie", somethingelse => "delta" } },
  test3 => { inner9999 => { ohlookmore => "golf", somethingelse => "foxtrot" } }
);

my %hash2 = (
  major => { test2 => "inner2",
             test3 => "inner3" }
);

foreach my $k (keys %hash1) {
  my $delete = 1;
  foreach my $inner (keys %{ $hash1{$k} }) {
    $delete = 0, last if exists $hash2{major}{$k} &&
                                $hash2{major}{$k} eq $inner;
  }
  delete $hash1{$k} if $delete;
}

use Data::Dumper;
$Data::Dumper::Indent = 1;
print Dumper \%hash1;

以 $delete = 0, ... 开头的行有点可爱。相当于 $delete = 0; last; 在另一个条件中，但它已经嵌套了两次。不想建造一个 matryoshka 娃娃，我使用了一个 语句修饰符，但顾名思义，它修改单个语句。

这就是 Perl 的逗号运算符 发挥作用的地方：

二进制, 是逗号运算符。在标量上下文中，它评估其左侧参数，丢弃该值，然后评估其右侧参数并返回该值。这就像 C 的逗号运算符。

在本例中，左侧参数是表达式 $delete = 0，右侧参数是 last。

该条件可能看起来不必要的繁琐，但

... if $hash2{major}{$k} eq $inner;

在探测 %hash2 中未提及的测试（例如 test1/inner1）时会产生未定义值警告。 使用

.. if $hash2{major}{$k} && $hash2{major}{$k} eq $inner;

如果 %hash2 中提到的测试的“内部名称”是一个错误值（例如字符串 “0”），则 会错误地删除该测试。是的，在这里使用 exists 可能会不必要地繁琐，但由于不知道你的实际哈希键，我选择了保守的路线。

输出：

$VAR1 = {
  'test2' => {
    'inner2' => {
      'somethingelse' => 'delta',
      'more' => 'charlie'
    }
  }
};

尽管您没有违反它，但请注意以下与使用 相关的警告每个：

如果在迭代哈希时添加或删除哈希元素，则可能会跳过或重复条目，所以不要这样做。例外：删除 each 最近返回的项目始终是安全的，这意味着以下代码将起作用：

 while (($key, $value) = every %hash) {
      打印 $key, "\n";
      删除 $hash{$key}; # 这是安全的
    }

更新：像数组一样搜索哈希（印象深刻你的 CS 书呆子朋友说“……线性而不是对数”）是一个危险信号，上面的代码就是这样做的。一种更好的方法与 Penfold 的答案类似，

%hash1 = map +($_ => $hash1{$_}),
         grep exists $hash2{major}{$_} &&
              exists $hash1{$_}{ $hash2{major}{$_} },
         keys %hash1;

它以良好的声明式风格描述了 %hash1 所需的内容，即

1. %hash1 的一级键> 应该在 $hash2{major} 中提及，并且
2. $hash2{major} 中每个一级键对应的值本身应该是该键的子键%hash1 中

（哇，令人眼花缭乱。我们需要多个英语占位符变量！）

+($_ => $hash1{$_}) 中的一元加号消除了歧义对于糟糕的解析器来说，它知道我们希望将表达式视为“对”。有关其他信息，请参阅 关于 map 的 perlfunc 文档的末尾可能需要这样做的情况。

Answer 2

您可以将其作为单行代码来完成，因为delete() 将采用一组键。这并不像我最初想象的那么容易，但现在我已经正确地阅读了这个问题......

delete @hash1{ 
        grep(
            !(
              exists($hash2{major}->{$_}) 
                && 
              exists( $hash1{$_}->{ $hash2{major}->{$_} } )
            ),
            keys %hash1
        )
    };

Answer 3

# This is the actual hash we want to iterate over.
my $keepers = $hash2{major};

%hash1 = map { $_ => $hash1{$_} }  # existing key and hash contents in %hash1
             grep { exists $keepers->{$_} and               # key there?
                    exists $hash1{$_}->{ $keepers->{$_} } } # key in hash there?
             (keys %hash1);        # All the keys we might care about

这是有效的，因为我们本质上是在三个独立的阶段中列出我们想要/不想要的东西的列表：

1. keys 调用一步获取 hash1 中的所有键。
2. grep 生成（作为一步）符合我们的标准的键列表。
3. 映射（作为一个步骤）生成一组我们想要的键和值。

这样，在我们准备好之前，我们永远不会更改主哈希。如果 %hash1 包含许多键，我们将使用大量内存。如果您担心这一点，您可以这样做：

# Initialization as before ...

use File::Temp qw(tempfile);

my ($fh, $file) = tempfile();
my $keepers = $hash2{major};

print $fh "$_\n" for (keys %hash1);
close $fh;
open $fh, "<", $file or die "can't reopen tempfile $file: $!\n";
while ( defined ($_ = <$fh>) ) {
  chomp;
  delete $hash1{$_} 
    unless exists $keepers->{$_} and 
           exists $hash1{$_}->{ $keepers->{$_} }; 
}

这个之所以有效，是因为我们不是在散列上迭代，而是在其密钥的存储副本上迭代。

Answer 4

这就是我会这样做的方式：（第三次尝试就是魅力）

foreach ( map { [ $_ => $hash2{major}{$_} ] } keys %hash1 ) { 
    my ( $key, $value ) = @$_;
    if ( defined $value and my $new_value = $hash1{$key}{$value} ) { 
        $hash1{$key} = $new_value;
    }
    else { 
        delete $hash1{$key};
    }
}