在 Perl 中访问字符串中的单个字符时，是 substr 还是拆分为数组更快？

Question

我正在编写一个 Perl 脚本，我需要在其中循环遍历字符串的每个字符。有很多字符串，每个都有 100 个字符长（它们是很短的 DNA 序列，如果你想知道的话）。

那么，使用substr 一次提取每个字符是否更快，还是使用split 将字符串放入数组然后遍历数组更快？

在等待答案的同时，我想我会阅读有关如何在 Perl 中进行基准测试的内容。

Answer 1

这实际上取决于您对数据的处理方式——但是，嘿，您的最后一个问题是正确的！不要猜测，基准测试。

Perl 为这种事情提供了Benchmark 模块，使用它真的非常简单。下面是一个小示例代码，可以开始使用：

#!/usr/bin/perl
use strict;
use warnings;
use Benchmark qw(cmpthese);

my $dna;
$dna .= [qw(G A T C)]->[rand 4] for 1 .. 100;

sub frequency_substr {
  my $length = length $dna;
  my %hist;

  for my $pos (0 .. $length) {
    $hist{$pos}{substr $dna, $pos, 1} ++;
  }

  \%hist;
}

sub frequency_split {
  my %hist;
  my $pos = 0;
  for my $char (split //, $dna) {
    $hist{$pos ++}{$char} ++;
  }

  \%hist;
}

sub frequency_regmatch {
  my %hist;

  while ($dna =~ /(.)/g) {
    $hist{pos($dna)}{$1} ++;
  }

  \%hist;
}


cmpthese(-5, # Run each for at least 5 seconds
  { 
    substr => \&frequency_substr,
    split => \&frequency_split,
    regex => \&frequency_regmatch
  }
);

还有一个示例结果：

         Rate  regex  split substr
regex  6254/s     --   -26%   -32%
split  8421/s    35%     --    -9%
substr 9240/s    48%    10%     --

事实证明 substr 速度惊人。 :)

Answer 2

这是我要做的，而不是首先尝试在 substr 和 split 之间进行选择：

#!/usr/bin/perl

use strict; use warnings;

my %dist;
while ( my $s = <> ) {
    while ( $s =~ /(.)/g ) {
        ++ $dist{ pos($s) }{ $1 };
    }
}

更新：

我的好奇心占了上风。这是一个基准：

#!/usr/bin/perl

use strict; use warnings;
use Benchmark qw( cmpthese );

my @chars = qw(A C G T);
my @to_split = my @to_substr = my @to_match = map {
    join '', map $chars[rand @chars], 1 .. 100
} 1 .. 1_000;

cmpthese -1, {
    'split'  => \&bench_split,
    'substr' => \&bench_substr,
    'match'  => \&bench_match,
};

sub bench_split {
    my %dist;
    for my $s ( @to_split ) {
        my @s = split //, $s;
        for my $i ( 0 .. $#s ) {
            ++ $dist{ $i }{ $s[$i] };
        }
    }
}

sub bench_substr {
    my %dist;
    for my $s ( @to_substr ) {
        my $u = length($s) - 1;
        for my $i (0 .. $u) {
            ++ $dist{ $i }{ substr($s, $i, 1) };
        }
    }
}

sub bench_match {
    my %dist;
    for my $s ( @to_match ) {
        while ( $s =~ /(.)/g ) {
            ++ $dist{ pos($s) }{ $1 };
        }
    }
}

输出：

 速率拆分匹配 substr
分裂 4.93/s -- -31% -65%
匹配 7.11/s 44% -- -49%
substr 14.0/s 184% 97% --

Answer 3

我在 Mastering Perl 中有一个例子来处理这个问题。您是否想创建一堆单独的标量，每个标量都带有 Perl 标量的内存开销，或者将所有内容存储在单个字符串中以减少内存但可能做更多的工作。你说你有很多这样的东西，所以如果你担心记忆，把它们保留为单个字符串可能会更好。

精通 Perl 还有几章涉及基准测试和分析，如果您对此感到好奇的话。

Ether 说先让它工作，然后再担心其余的事情。其中一部分是将操作隐藏在面向任务的界面后面。一个不错的面向对象模块可以为您做到这一点。如果你不喜欢这个实现，你就改变它。但是，更高级别的程序不必更改，因为界面保持不变。