Perl Goatse 是“秘密操作员”吗？高效的？

Question

Perl 中的“goatse 运算符”或 =()= 习惯用法导致在列表上下文中计算表达式。

一个例子是：

my $str = "5 and 4 and a 3 and 2 1 BLAST OFF!!!";
my $count =()= $str =~ /\d/g; # 5 matches...
print "There are $count numbers in your countdown...\n\n";

当我解释使用时，会发生这样的情况：

1. $str =~ /\d/g 匹配所有数字。 g 开关和列表上下文生成这些匹配项的列表。让这成为“List Producer”的例子，在 Perl 中这可能有很多东西。
2. =()= 会导致对空列表进行赋值，因此所有实际匹配项都会复制到空列表中。
3. 在标量上下文中对 2. 中生成的列表的 $count 进行赋值给出了列表的计数或 5. 的结果。
4. 空列表 =()= 的引用计数在标量分配。然后 Perl 删除列表元素的副本。

关于效率的问题是：

1. 我解析这个的方式错了吗？
2. 如果您有一些列表生成器并且您感兴趣的只是计数，是否有更有效的方法来做到这一点？

它对于这个简单的列表效果很好，但是如果列表有数十万个匹配项怎么办？通过这种方法，您可以生成每场比赛的完整副本，然后将其删除以进行计数。

Answer 1

Perl 5 在复制列表方面很聪明。它仅复制左侧的项目数量。它之所以有效，是因为标量上下文中的列表分配会产生右侧的项目数。因此，正则表达式将创建 n 个项目，但它们不会被复制和丢弃，而只是被丢弃。您可以在下面的基准测试中看到额外副本在简单情况下产生的差异。

至于效率，迭代解决方案通常在内存和 CPU 使用方面更容易，但这必须权衡山羊秘密运算符的简洁性。以下是对各种解决方案进行基准测试的结果：

naive: 10
iterative: 10
goatse: 10

for 0 items:
               Rate iterative    goatse     naive
iterative 4365983/s        --       -7%      -12%
goatse    4711803/s        8%        --       -5%
naive     4962920/s       14%        5%        --

for 1 items:
               Rate     naive    goatse iterative
naive      749594/s        --      -32%      -69%
goatse    1103081/s       47%        --      -55%
iterative 2457599/s      228%      123%        --

for 10 items:
              Rate     naive    goatse iterative
naive      85418/s        --      -33%      -82%
goatse    127999/s       50%        --      -74%
iterative 486652/s      470%      280%        --

for 100 items:
             Rate     naive    goatse iterative
naive      9309/s        --      -31%      -83%
goatse    13524/s       45%        --      -76%
iterative 55854/s      500%      313%        --

for 1000 items:
            Rate     naive    goatse iterative
naive     1018/s        --      -31%      -82%
goatse    1478/s       45%        --      -75%
iterative 5802/s      470%      293%        --

for 10000 items:
           Rate     naive    goatse iterative
naive     101/s        --      -31%      -82%
goatse    146/s       45%        --      -75%
iterative 575/s      470%      293%        --

这是生成它的代码：

#!/usr/bin/perl

use strict;
use warnings;

use Benchmark;

my $s = "a" x 10;

my %subs = (
    naive => sub {
        my @matches = $s =~ /a/g;
        return scalar @matches;
    },
    goatse => sub {
        my $count =()= $s =~ /a/g;
        return $count;
    },
    iterative => sub {
        my $count = 0;
        $count++ while $s =~ /a/g;
        return $count;
    },
);

for my $sub (keys %subs) {
    print "$sub: @{[$subs{$sub}()]}\n";
}

for my $n (0, 1, 10, 100, 1_000, 10_000) {
    $s = "a" x $n;
    print "\nfor $n items:\n";
    Benchmark::cmpthese -1, \%subs;
}

Answer 2

在您的特定示例中，基准测试很有用：

my $str = "5 and 4 and a 3 and 2 1 BLAST OFF!!!";

use Benchmark 'cmpthese';

cmpthese -2 => {
    goatse => sub {
        my $count =()= $str =~ /\d/g;
        $count == 5 or die
    },
    while => sub {
        my $count; 
        $count++ while $str =~ /\d/g;
        $count == 5 or die
    },
};

它返回：

           Rate goatse  while
goatse 285288/s     --   -57%
while  661659/s   132%     --

列表上下文中的 $str =~ /\d/g 正在捕获匹配的子字符串，即使不需要它。 while 示例在标量（布尔）上下文中包含正则表达式，因此正则表达式引擎只需返回 true 或 false，而不是实际的匹配项。

一般来说，如果您有一个列表生成函数并且只关心项目的数量，那么编写一个短的 count 函数会更快：

sub make_list {map {$_**2} 0 .. 1000}

sub count {scalar @_}

use Benchmark 'cmpthese';

cmpthese -2 => {
    goatse => sub {my $count =()= make_list; $count == 1001 or die},
    count  => sub {my $count = count make_list; $count == 1001 or die},
};

这给出了：

         Rate goatse  count
goatse 3889/s     --   -26%
count  5276/s    36%     --

我猜测为什么 sub 更快是因为 subroutine调用经过优化，可以传递列表而不复制它们（作为别名传递）。

Answer 3

如果您需要在列表上下文中运行某些内容，则必须在列表上下文中运行它。在某些情况下，就像您所介绍的那样，您可能可以使用另一种技术来解决它，但在大多数情况下您不会。

然而，在进行基准测试之前，最重要的问题是“这重要吗？”。在进行基准测试之前进行分析，只有当您没有真正的问题需要解决时才担心这些事情。 :)

如果您正在寻找终极的效率，Perl 的水平有点太高了。 :)