时间戳

首页 > 解决方案 > 如何在 Perl 中正确替换散列数组中的值？

arrays - 如何在 Perl 中正确替换散列数组中的值？

问题描述

如下所示，我有一个 foreach 循环，其中一个哈希数组中的值被另一个哈希数组中的值替换。

第二个 foreach 循环只是打印并测试是否正确分配了值。

foreach my $row (0 .. $#row_buff) {
    $row_buff[$row]{'offset'} = $vars[$row]{'expression'};
    print $row_buff[$row]{'offset'},"\n";
}

foreach (0 .. $#row_buff) {
    print $row_buff[$_]{'offset'},"\n";
}

这里@row_buff 和@vars 是两个哈希数组。它们预先填充了所有使用的键的值。

哈希被推入数组中，如下所示：

推@row_buff，\%hash；

问题：假设第一个 foreach 打印中的打印语句如下所示：

string_a
string_b
string_c
string_d

然后第二个 foreach 循环中的 print 语句如下所示：

string_d
string_d
string_d
string_d

这让我感到困惑。两个打印语句都应该以完全相同的方式打印，对吗？但是第二个打印语句打印的值只是以重复方式单独打印的最后一个值。有人可以指出我这里可能出了什么问题吗？非常感谢任何提示。这是我第一次提出问题，如果我错过了什么，请原谅我。

更新

有一点我可以补充的信息，对不起大家。在 foreach 之前还有一行，就像这样：

@row_buff = (@row_buff) x $itercnt;
foreach my $row (0 .. $#row_buff) {
    $row_buff[$row]{'offset'} = $vars[$row]{'expression'};
    print $row_buff[$row]{'offset'},"\n";
}

foreach (0 .. $#row_buff) {
    print $row_buff[$_]{'offset'},"\n";
}

$itrcnt 是一个整数。我用它多次复制@row_buff。

标签： arraysperlhash

解决方案

这显然与在数组上存储引用有关，而不是与独立数据有关。由于未提供详细信息，因此尚不清楚这是如何发生的，但以下讨论应该会有所帮助。

考虑这两个基本示例。

首先，在数组上放置一个哈希（引用），每次先改变一个值

use warnings;
use strict;
use feature 'say';
use Data::Dump qw(dd);
# use Storable qw(dclone);

my %h = ( a => 1, b => 2 );

my @ary_w_refs;

for my $i (1..3) {
    $h{a} = $i; 
    push @ary_w_refs, \%h;           # almost certainly WRONG

    # push @ary_w_refs, { %h };      # *copy* data
    # push @ary_w_refs, dclone \%h;  # may be necessary, or just safer
}

dd $_ for @ary_w_refs;

我使用Data::Dump来显示复杂的数据结构，因为它的简单性和默认的紧凑输出。为此目的还有其他模块，Data::Dumper位于核心（已安装）中。

以上印刷品

{ a => 3, b => 2 }
{ a => 3, b => 2 }
{ a => 3, b => 2 }

看看a我们每次在散列中更改的 key 的值，因此应该为每个数组元素设置不同的值（1, 2, 3） - 最后是相同的，并且等于我们最后分配的值? （问题中似乎就是这种情况。）

这是因为我们为每个元素分配了对哈希的引用%h，所以即使每次通过循环时，我们首先更改该键的哈希值，最后它只是每个元素对相同哈希的引用. *</sup>

因此，当在循环之后查询数组时，我们只能得到散列中的内容（键a是最后分配的数字，3）。该数组没有自己的数据，只有一个指向哈希数据的指针。†</sup> （因此哈希的数据也可以通过写入数组来更改，如下例所示。）

大多数时候，我们想要一个单独的、独立的副本。解决方案？复制数据。

天真地，而不是

push @ary_w_refs, \%h;

我们可以做的

push @ary_w_refs, { %h };

这{}是一个匿名哈希的构造函数，‡</sup> 所以%h里面被复制了。所以实际数据进入数组并且一切都很好？在这种情况下，是的，其中哈希值是纯字符串/数字。

但是当哈希值本身是引用时呢？然后这些引用被复制，并且@ary_w_refs再次没有自己的数据！我们会遇到完全相同的问题。（尝试上面的哈希为( a => [1..10] )）

如果我们有一个复杂的数据结构，带有值的引用，我们需要一个深拷贝。做到这一点的一个好方法是使用库，并且Storable非常dclone好

use Storable qw(dclone);
...

    push @ary_w_refs, dclone \%h;

现在数组元素有自己的数据，与 . 无关（但在复制时）%h。

这对于一个简单的哈希/数组也是一件好事，为了避免未来的变化，哈希被改变但我们忘记了它被复制的地方（或者哈希和它的副本甚至不知道彼此）。

另一个例子。让我们用 hashref 填充一个数组，然后将它复制到另一个数组

use warnings;
use strict;
use feature 'say';    
use Data::Dump qw(dd pp);

my %h = ( a => 1, b => 2 );

my @ary_src = \%h;
say "Source array: ", pp \@ary_src;

my @ary_tgt = $ary_src[0];
say "Target array: ", pp \@ary_tgt;

$h{a} = 10;
say "Target array: ", pp(\@ary_tgt), " (after hash change)";

$ary_src[0]{b} = 20;
say "Target array: ", pp(\@ary_tgt), " (after hash change)";

$ary_tgt[0]{a} = 100;
dd \%h;

（为简单起见，我使用只有一个元素的数组。）

这打印

源数组：[{ a => 1, b => 2 }]
目标数组：[{ a => 1, b => 2 }]
目标数组：[{ a => 10, b => 2 }]（哈希更改后）
目标数组：[{ a => 10, b => 20 }]（哈希更改后）
{ a => 100, b => 20 }

那个“目标”数组，据说只是从源数组中复制出来的，当远处的哈希发生变化时会发生变化！当它的源数组发生变化时。同样，这是因为对哈希的引用被复制，首先复制到一个数组，然后复制到另一个数组。

为了获得独立的数据副本，再次复制数据，每次。我再次建议保持安全并使用Storable::dclone（或当然是等效的库），即使使用简单的哈希和数组也是如此。

最后，请注意最后一个有点险恶的情况——写入该数组会更改散列！这个（第二次复制的）数组可能远离散列，在散列甚至不知道的函数（在另一个模块中）中。这种错误可能是真正隐藏的错误的来源。

现在，如果您澄清引用被复制的位置，更完整（简单）地表示您的问题，我们可以提供更具体的补救措施。

∗</sup> 使用正确且经常使用的引用的一种重要方式是，每次通过

for my $elem (@data) { 
    my %h = ...
    ... 
    push @results, \%h;  # all good
}

%h每次都会重新引入该词法，因此保留在数组上引用的数据，因为数组在循环之外持续存在，对于每个元素都是独立的。

这样做也更有效率，因为 in 中的数据%h没有被复制，就像它一样{ %h }，但只是“重新调整用途”，也就是说，从在%h迭代结束时被破坏的词法到引用在数组中。

如果要复制的结构自然存在于循环之外，这当然可能并不总是合适的。然后使用它的深层副本。

同一种机制在函数调用中起作用

sub some_func {
    ...
    my %h = ...
    ...
    return \%h;  # good
}

my $hashref = some_func();

同样，词法%h在函数返回时超出范围并且不再存在，但它携带的数据和对它的引用被保留，因为它被返回并分配，所以它的引用计数是非零的。（至少返回给调用者，也就是说；它可能已经在子执行期间被传递到其他地方，所以我们可能仍然会对使用相同引用的多个参与者造成混乱。）所以$hashref有对已创建数据的引用在潜艇。

回想一下，如果一个函数被传递了一个引用，当它被调用或在其执行期间（通过调用返回引用的其他子程序），更改并返回它，那么我们再次在某个调用者中更改了数据，可能远离这部分的程序流程。

当然，这通常会使用更大的数据池，而这些数据池不能一直被复制，但是需要小心并组织代码（尽可能模块化），以尽量减少出错的机会.

†</sup> 对于引用的作用，这是对“指针”一词的松散使用，但如果要引用 C，我会说它有点像“修饰过的”C 指针

‡</sup> 在不同的上下文中，它可以是一个块

推荐阅读