Perl 5 - 迭代器

Question

我在 perl 中实现了一个简单的迭代器。我通常使用 C#，并且经常使用迭代器和函数式编程。所以我认为在 Perl 中获得一些基础知识会很简单。

问题是，我的性能很差，我不希望比 for 或 foreach 更快，但我认为有人可以给我一些关于如何加快速度。

这是我的包的核心内容：

package Iterator;
use strict;

#Constructor for Iterator type
sub new {
  my $type = $_[0];
  my $this = {};

  #set default values
  $this->{Array} = @_[1];
  $this->{Index} = 0;
 $this->{Sub} = sub { 
   my @array = @{$this->{Array}};
   return $#array >= $this->{Index} ? $array[$this->{Index}++] : undef;
  };

  #return self
  bless($this, $type);
  return $this;
}

#Iterates next
sub Next {
 return $_[0]->{Sub}->();
}

允许您执行此操作：

my $iterator = Iterator->new(\@array);
while (defined(my $current = $iterator->Next())) {
  print $current, "\n";
}

还不华丽......。

还启用一些像这样的功能代码：

my $sum = 0;
Iterator
  ->new(\@array)
  ->Where(sub { $_[0] % 2 == 0 })
  ->ForEach(sub { $sum += $_[0] });

它将总结数组的所有偶数值。

我的瓶颈是迭代代码：

$this->{Sub} = sub { 
   my @array = @{$this->{Array}};
   return $#array >= $this->{Index} ? $array[$this->{Index}++] : undef;
  };

有什么可以加快速度的指针吗？

Answer 1

这里的游戏有点晚了，但由于您关心性能，迭代器类型代码中最大的瓶颈之一是基于哈希的对象的字段需要在每次访问时取消引用。解决这个问题的一种方法是使用闭包，其中字段在变量上封闭，避免不必要的取消引用。

在我的模块 List::Gen 中，其中包含惰性列表的相当高性能的实现，我编写了实用函数 curse ，它使基于闭包的对象的行为与普通 Perl 对象一样。

下面是一个用 curse 编写的迭代器类的简短示例。在对 1000 个数字求和的简单基准测试中，即使在修复了其他答案中指出的所有低效率问题之后，此方法的速度还是您的方法的两倍。

{package Iterator;
    use List::Gen 'curse';
    sub new {
        my ($class, $array) = @_;
        my $index = 0;
        curse {
            next  => sub {$array[$index++]},
            index => sub :lvalue {$index},
        } => $class
    }
    sub reset {shift->index = 0}
} 

如果您确实想要提高速度，由于 next 方法不需要传递任何内容，您甚至可以这样写：

my $next = $iterator->can('next');

while (defined (my $x = $next->()) {...}

与普通方法调用相比，这将使您的速度提高 30% 到 40% 。

您可以阅读 List::Gen 的源代码以了解 curse 的更高级用法

Answer 2

您可能会发现阅读一些高阶 Perl 很有用。

Answer 3

这一行：

my @array = @{$this->{Array}};

将数组复制到@array中，我认为你不想这样做。只需执行 $#{$this->{Array}} 即可找到数组的端点。

Answer 4

一个更有效的版本：

package Iterator;
use strict;

#Constructor for Iterator type
sub new {
  my $type = shift;
  my $array = shift;
  my $this = {};
  $this->{array} = $array;
  $this->{index} = 0;
  bless($this, $type);
  return $this;
}

#Iterates next
sub Next {
  my $this = shift;
  return $this->{array}->[$this->{index}++];
}

Answer 5

使用 grep 和 List 可以更轻松地对偶数求和： :Util：

use List::Util 'sum';
say sum grep { not $_ % 2 } (1 .. 10); // 30

在我看来，你的问题建议的代码很可能是过度设计的。除非你能想出一个使用传统 Perl 原语无法轻松解决的像样的例子。

Answer 6

看看 List::Util 和 List::MoreUtils 可以帮助您解决此问题。
您甚至可以使用 perl5i 获得更现代的语法。

例子：

use perl5i::2;

my @nums = (0..100);
my $sumEven = @nums->grep(sub { $_ % 2 == 0 })->reduce(sub { $a+$b });

say $sumEven;

Answer 7

已经有一个 数组迭代器 CPAN，所以如果你还没有做过的话可以看看它的方法。

顺便说一句，在您的代码中：

#set default values
$this->{Array} = @_[1];

我假设您想说 $_[1]。使用 @_[1] 您正在请求一个元素的数组切片。最后的结果是相同的，但语义不同。奇怪的是，如果我执行 @_[1] 或出现错误，我期望得到一个包含一个元素的数组，但在调试器中进行了测试，并且您获得了标量（至少在 perl 5.10 中）。无论如何，Perl 6 都会采用这种行为，并且不会更改用于访问数组或散列中的元素的印记，因此您正在编写“高级”Perl ;-)

Answer 8

不要卸载存储的数组。当您执行以下操作时，您会将数组的每个元素从 $this->{Array} 指向的位置复制到本地列表 @array：

my @array = @{$this->{Array}};

另外如果您知道当您点击 undef 时您将停止，那么您甚至不必检查边界。

$this->{Sub} = sub { return $this->{Array}[++$this->{Index}]; }

这就是您所需要的。当{Index}超出范围时，将返回undef。

此外，您可以用 Perl 编写表达式，如下所示：

$sum += $_ foreach grep { $_ % 2 == 0 } @array;

Answer 9

一个更简单的 Perl 迭代器：

my @array = (1, 2, 3, 4);
while (my $i = shift @array)
{
    print $i . "\n";
}