为什么我要使用 Perl 匿名子例程而不是命名子例程？

Question

我只是好奇为什么人们会选择在 Perl 中使用匿名子例程而不是命名子例程。 谢谢。

Answer 1

• 您可以将匿名子存储在数组、散列和标量中。
• 您可以在运行时构建它们，
• 也可以将它们作为参数传递给其他函数。
• 您可以将变量保留在周围范围内。

最后一点可能是最重要的，因为它通常是 Perl 中命名子例程与匿名子例程最意想不到的方面。 示例：

sub outer
{
  my $a = 123;

  sub inner
  {
    print $a, "\n";
  }

  # At this point, $a is 123, so this call should always print 123, right?
  inner();

  $a = 456;
}

outer(); # prints 123
outer(); # prints 456! Surprise!

但是将“内部”从命名子例程更改为对匿名子例程的引用，它的工作方式就不那么令人惊讶了：（

sub outer
{
  my $a = 123;

  my $inner = sub
  {
    print $a, "\n";
  };

  # At this point, $a is 123, and since the anonymous subrotine 
  # whose reference is stored in $inner closes over $a in the 
  # "expected" way...
  $inner->();

  $a = 456;
}

# ...we see the "expected" results
outer(); # prints 123
outer(); # prints 123

当然，每个人的期望都不同，因此“预期”周围的“恐吓引号”。）

这是实际代码中的使用示例（尽管应该注意的是，File::Find 接口通常被认为是一个很差的接口，因为它使用了全局变量，而不是使用了匿名子例程） ：

sub find_files
{
  my @files;

  my $wanted = sub
  { 
    if($something)
    {
      push @files, $File::Find::name;
    }
  };

  # The find() function called here is imported from File::Find
  find({ wanted => $wanted }, $directory);

  return @files;
}

将命名子例程作为 wanted 参数的值传递将需要使用只能使用一次的例程污染命名空间，并在内定义命名子例程>find_files() 子例程将表现出前面演示的“意外”行为。

Answer 2

我想到了回调和生成器。 一个例子：

#!/usr/bin/perl

use strict;
use warnings;

sub generate_multiplier {
    my ($coef) = @_;

    return sub { 
        my ($val) = @_;
        $coef * $val;
    }
}

my $doubler = generate_multiplier(2);
my $tripler = generate_multiplier(3);

for my $i ( 1 .. 10 ) {
    printf "%4d%4d%4d\n", $i, $doubler->($i), $tripler->($i);
}

__END__

C:\Temp> v
    1   2   3
    2   4   6
    3   6   9
    4   8  12
    5  10  15
    6  12  18
    7  14  21
    8  16  24
    9  18  27
   10  20  30

Answer 3

“匿名”子例程与常规的命名子例程非常相似，只是它们不绑定到符号表中的名称。

sub Foo { stuff() }

BEGIN { *Foo = sub { stuff() } }  # essentially equivalent

在第二种情况下，创建“匿名”子例程，然后将其绑定到当前命名空间中的名称“Foo”。 BEGIN 块使其在编译时发生，就像处理命名子例程一样。 （这有点复杂，因为第一种情况给它一个将显示在堆栈跟踪中的名称。）

每当您想在运行时创建函数时，匿名子例程都很有用。 这对于“闭包”特别有用——“记住”其词法上下文的函数。 例如，将列表转换为迭代器：

use 5.010;
use strict;
use warnings;

sub make_iterator {
  my @list = @_;
  return sub { shift @list }; # new sub that 'remembers' @list
}

my $iter1 = make_iterator( 0 .. 10 ); 
my $iter2 = make_iterator( 'a' .. 'z' );

say $iter1->();  # '0'
say $iter1->();  # '1'
say $iter2->();  # 'a'

有关为什么匿名子例程有用的更多信息，我推荐这本书 Higher Order Perl 描述了 Perl 中函数式编程的各种技术和应用。

Answer 4

我在掌握 Perl 中讨论了匿名子例程以及为什么要使用它们。 简而言之，您开始将行为视为另一种形式的数据，就像您考虑字符串或数字一样。 当您对这个想法感到满意时，您可以做一些非常令人惊奇的事情，因为您可以将许多决策推迟到程序的最后阶段，并且您不必扭曲代码设计来提前处理每种情况可能会出现。

您可以在知道要运行子例程的情况下编写代码，只是您还不知道是哪个子例程。 您相信前面的步骤可以为您解决这个问题。 一旦你能做到这一点，你就进入了编程的另一个层次，感觉就像你正在编写代码来为你创建程序一样。 通过这种方式，一些编程问题变得更容易解决。

而且，与其他所有功能一样，您可能会过度使用它或使用不当。

Answer 5

匿名子例程的规范答案通常是数组的数字排序：

my @sorted_array = sort { $a <=> $b } @array;

{ $a <=>; $b } 代表匿名子例程。

Answer 6

第一：子事物就是子事物。 my $thing=sub... 是存储在变量中的子引用。

第二：有一个微妙的用法差异：

use strict;
use warnings;

sub xx {
  my $zz=1;

   sub yy {
      print $zz;
   }
}


perl tmp.pl
Variable "$zz" will not stay shared at tmp.pl line 8.

将 [sub yy...] 更改为 [my $yy = sub {...] 或 [local *yy = sub{...] 并且投诉消失了。

另外，说实话，对 subs 的引用更容易处理，就像 @x=(1,2,3) 与 $x=[1, 2, 3] 一样。

Answer 7

这是我的 重写的示例Nasm's version.pl

# jump table to subroutines / variables
my %jump = (
  id     => 'id',
  xid    => 'xid',
  hex_id => 'xid',

  h      => \&h,
  mac    => \&mac,
  sed    => \&sed,
  make   => \&make,
  nsis   => \&nsis,

  perl   => \&perl,
  dump   => \&perl,
  yaml   => \&yaml,
  yml    => \&yaml,
  json   => \&json,
  js     => \&json,

  help   => \&help,
  usage  => sub{
    require Pod::Usage;

    Pod::Usage::pod2usage(
      "run perldoc $0 or pod2text $0 for more information"
    );
  }
);

基本上我能想到的唯一原因是为了回调，或者为了跳转表。