自动调用作为子例程引用的哈希值

#!/usr/bin/perl

my %hash = (
    key1 => "value1",
    key2 => sub {
        return "value2"; # In the real code, this value can differ
    },
);

foreach my $key (sort keys %hash) {
    print $hash{$key} . "\n";
}

perl ./test.pl
value1
value2

perl ./test.pl
value1
CODE(0x7fb30282cfe0)

#1 楼

有一个称为“魔术”的功能，该功能允许在访问变量时调用代码。

在变量中添加魔术极大地减慢了对该变量的访问，但是某些变量比其他变量更昂贵。 >

无需访问散列的每个元素都具有魔术性，只需访问一些值即可。

tie是一种更昂贵的魔术形式，在这里不需要。

因此，最有效的解决方案如下：

use Time::HiRes     qw( time );
use Variable::Magic qw( cast wizard );

{
   my $wiz = wizard(
      data => sub { my $code = $_[1]; $code },
      get => sub { ${ $_[0] } = $_[1]->(); },
   );

   sub make_evaluator { cast($_[0], $wiz, $_[1]) }
}

my %hash;
$hash{key1} = 'value1';
make_evaluator($hash{key2}, sub { 'value2@'.time });

print("$hash{$_}\n") for qw( key1 key2 key2 );

输出：

value1
value2@1462548850.76715
value2@1462548850.76721

其他示例：

my %hash; make_evaluator($hash{key}, sub { ... });
my $hash; make_evaluator($hash->{$key}, sub { ... });

my $x; make_evaluator($x, sub { ... });
make_evaluator(my $x, sub { ... });

make_evaluator(..., sub { ... });
make_evaluator(..., \&some_sub);

您还可以“修复”现有哈希。在您的哈希哈希方案中，

my $hoh = {
   { 
      key1 => 'value1',
      key2 => sub { ... },
      ...
   },
   ...
);

for my $h (values(%$hoh)) {
   for my $v (values(%$h)) {
      if (ref($v) eq 'CODE') {
         make_evaluator($v, $v);
      }
   }
}

#2 楼

正如Oleg所指出的，可以使用或多或少的各种奥秘技巧来做到这一点，例如tie，重载或魔术变量。但是，这既不必要，也将变得毫无意义。绝妙的技巧是，至少在99％的时间里在真实代码中使用它们都是错误的。

在实践中，最简单，最简洁的解决方案可能是编写一个使用以下代码的帮助程序子程序：标量，如果它是代码引用，则执行它并返回结果：

sub evaluate {
    my $val = shift;
    return $val->() if ref($val) eq 'CODE';
    return $val;  # otherwise
}

并像这样使用它：

foreach my $key (sort keys %hash) {
    print evaluate($hash{$key}) . "\n";
}

#3 楼

我不认为其他人在不赞成tie机制的情况下写的话是正确的。没有一个作者似乎正确地理解了它的工作原理以及可用的核心库备份

这是一个基于tie的Tie::StdHash示例，如果您将哈希值绑定到Tie::StdHash类，那么它就可以像普通哈希一样工作这意味着除了您可能要覆盖的方法之外，没有什么可写的了。在这种情况下，我已经覆盖了TIEHASH，以便可以在与tie命令相同的语句中指定初始化列表，并且FETCH，它将调用超类的FETCH，然后在它恰好是子例程引用时对其进行调用

您绑定的哈希将正常运行，除了您要求的更改。我希望很明显，如果您已经将子例程引用存储为哈希值，则不再有直接的方法来检索它。这样的值将始终被不带任何参数的调用结果替换。

SpecialHash.pm

package SpecialHash;

use Tie::Hash;
use base 'Tie::StdHash';

sub TIEHASH {
    my $class = shift;
    bless { @_ }, $class;
}

sub FETCH {
    my $self = shift;
    my $val = $self->SUPER::FETCH(@_);
    ref $val eq 'CODE' ? $val->() : $val;
}

1;

main.pl

use strict;
use warnings 'all';

use SpecialHash;

tie my %hash, SpecialHash => (
    key1 => "value1",
    key2 => sub {
        return "value2"; # In the real code, this value can differ
    },
);

print "$hash{$_}\n" for sort keys %hash;

输出

value1
value2

更新

听起来您的实际情况是存在一个看起来像这样的现有哈希值

my %hash = (
    a => {
        key_a1 => 'value_a1',
        key_a2 => sub { 'value_a2' },
    },
    b => {
        key_b1 => sub { 'value_b1' },
        key_b2 => 'value_b2',
    },
);

在已填充的变量上使用tie并不像绑定那样整洁然后在声明时，然后插入值，因为必须将数据复制到绑定对象。但是，我在TIEHASH类中编写SpecialHash方法的方式使在tie语句中做到这一点变得很简单。并将其与主要哈希值

该程序将恰好是哈希值引用的tie的每个值联系在一起。其核心是语句

tie %$val, SpecialHash => ( %$val )

，其功能与
相同
在先前的代码中

tie my %hash, SpecialHash => ( ... )

，但取消引用%hash以使语法有效，并且还使用哈希的当前内容作为绑定哈希的初始化数据。这就是复制数据的方式

之后，只有几个嵌套循环将整个$val转储以验证关系是否正常

use strict;
use warnings 'all';
use SpecialHash;

my %hash = (
    a => {
        key_a1 => 'value_a1',
        key_a2 => sub { 'value_a2' },
    },
    b => {
        key_b1 => sub { 'value_b1' },
        key_b2 => 'value_b2',
    },
);

# Tie all the secondary hashes that are hash references
#
for my $val ( values %hash ) {
    tie %$val, SpecialHash => ( %$val ) if ref $val eq 'HASH';
}

# Dump all the elements of the second-level hashes
#
for my $k ( sort keys %hash ) {

    my $v = $hash{$k};
    next unless ref $v eq 'HASH';

    print "$k =>\n";

    for my $kk ( sort keys %$v ) {
        my $vv = $v->{$kk};
        print "    $kk => $v->{$kk}\n" 
    }
}

输出

a =>
    key_a1 => value_a1
    key_a2 => value_a2
b =>
    key_b1 => value_b1
    key_b2 => value_b2

#4 楼

是的你可以。您可以tie哈希到将代码引用解析为其返回值的实现，也可以将带祝福的标量与overload ed方法一起使用，以进行字符串化，数字化以及您要自动解析的任何其他上下文。

#5 楼

对于这种用例，perl的特殊功能之一就是tie。这使您可以将面向对象的样式方法附加到标量或哈希。

应该谨慎使用它，因为这可能意味着您的代码以意想不到的方式在做真正奇怪的事情。

但例如：

#!/usr/bin/env perl

package RandomScalar;

my $random_range = 10;

sub TIESCALAR {
    my ( $class, $range ) = @_;
    my $value = 0;
    bless $value, $class;
}

sub FETCH {
    my ($self) = @_;
    return rand($random_range);
}

sub STORE {
    my ( $self, $range ) = @_;
    $random_range = $range;
}

package main;

use strict;
use warnings;

tie my $random_var, 'RandomScalar', 5;

for ( 1 .. 10 ) {
    print $random_var, "\n";
}

$random_var = 100;
for ( 1 .. 10 ) {
    print $random_var, "\n";
}

如您所见-这使您可以采用“普通”标量，并通过它。您可以对hash使用非常类似的机制-例如，可能要进行数据库查找。

但是，您也需要非常谨慎-因为这样做是在远距离创建动作的。未来的维护程序员可能不会希望$random_var每次运行时都实际更改，并且值分配未实际“设置”。

它对于例如测试，这就是为什么我给出一个例子。

在您的示例中-您可能会“绑定”哈希：

#!/usr/bin/env perl

package MagicHash;

sub TIEHASH {
    my ($class) = @_;
    my $self = {};
    return bless $self, $class;
}

sub FETCH {
    my ( $self, $key ) = @_;
    if ( ref( $self->{$key} ) eq 'CODE' ) {
        return $self->{$key}->();
    }
    else {
        return $self->{$key};
    }
}

sub STORE {
    my ( $self, $key, $value ) = @_;
    $self->{$key} = $value;
}

sub CLEAR {
    my ($self) = @_;
    $self = {};
}

sub FIRSTKEY {
    my ($self) = @_;
    my $null = keys %$self;    #reset iterator
    return each %$self;
}

sub NEXTKEY {
    my ($self) = @_;
    return each %$self;
}

package main;

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

tie my %magic_hash, 'MagicHash';
%magic_hash = (
    key1 => 2,
    key2 => sub { return "beefcake" },
);

$magic_hash{random} = sub { return rand 10 };

foreach my $key ( keys %magic_hash ) {
    print "$key => $magic_hash{$key}\n";
}
foreach my $key ( keys %magic_hash ) {
    print "$key => $magic_hash{$key}\n";
}
foreach my $key ( keys %magic_hash ) {
    print "$key => $magic_hash{$key}\n";
}

此它的邪恶程度要小一些，因为将来的维护程序员可以正常使用您的“哈希”。但是动态评估可以使您的脚步放松，因此-仍然请谨慎。

另外一种选择是将其“面向对象”进行操作-创建一个“存储对象”，其基本原理如下：上面-仅创建对象，而不使用tie。对于长期使用，这应该更加清楚，因为您不会得到意想不到的行为。 （这是一个在做魔术的对象，这很正常，而不是“有趣的哈希”）。

#6 楼

您需要确定何时存在代码引用，然后将其作为实际调用执行：
真正的调度表），而不是有一些返回非代码引用，而有一些返回非引用。

但是，如果您这样定义哈希，那么在涉及哈希时就不必做任何特殊的欺骗了是时候使用哈希了。查找键时，它将调用sub并直接返回值。

foreach my $key (sort keys %hash) {
    if (ref $hash{$key} eq 'CODE'){
        print $hash{$key}->() . "\n";
    }
    else {
        print "$hash{$key}\n";
    }
}

#7 楼

不，不是没有一些辅助代码。您要求一个简单的标量值和一个代码引用以相同的方式运行。可以做到这一点的代码远非简单，而且还会在哈希及其使用之间注入复杂性。您可能会发现以下方法更简单，更干净。

您可以使所有值都成为代码引用，使哈希成为调度表，以进行统一调用

my %hash = (
    key1 => sub { return "value1" },
    key2 => sub {
        # carry on some processing ...
        return "value2"; # In the real code, this value can differ
    },
);

print $hash{$_}->() . "\n" for sort keys %hash;

但当然，这种方法的开销很小。