Perl Goatse'Secret Operator'是否高效？

Question

Perl中的「goatse operator」或=()=成語會導致在列表上下文中評估表達式。

一個例子是：

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"; 

正如我interprete使用，這是發生了什麼：

1. $str =~ /\d/g所有的數字相匹配。 g開關和列表上下文產生這些匹配的列表。讓它成爲「List Producer」示例，在Perl中，這可能是很多事情。
2. =()=導致對空列表的分配，因此所有實際匹配都被複制到空列表中。
3. 在標量上下文中2生成的列表$數分配給該列表的計數或5
4. 空列表的引用計數=()=標轉讓後變爲零的結果。列表元素的副本然後由Perl刪除。

對效率的問題是：

1. 我錯在我是怎麼解析呢？
2. 如果您有一些List Producer，並且您感興趣的是count，是否有更高效的方法來執行此操作？

它可以很好地處理這個簡單的列表，但是如果列表成千上萬的匹配呢？使用這種方法，您將生成每場比賽的完整副本，然後刪除它以便對它們進行計數。

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示例在標量（boolean）上下文中具有正則表達式，因此正則表達式引擎只需返回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%  -- 

我猜測爲什麼子速度更快是因爲子程序調用被優化爲傳遞列表而不復制它們（作爲別名傳遞）。

Answer 3

如果你需要在列表上下文中運行某些東西，你必須在列表上下文中運行它。在某些情況下，如您所介紹的那種，您可以使用其他技術解決此問題，但在大多數情況下您不會。

然而，在您進行基準測試之前，最重要的問題是「它甚至重要嗎？」。在您進行基準測試之前進行配置文件分析，只有在您遇到實際問題需要解決時才擔心這些事情。 :)

如果你正在尋找最終的效率，但Perl的水平有點高。 :)