封闭中的本地变量可见性与本地`

Question

Perl 5.18.2似乎接受“本地子例程”。

示例：

sub outer()
{
    my $x = 'x';   # just to make a simple example

    sub inner($)
    {
        print "${x}$_[0]\n";
    }

    inner('foo');
}

如果没有“本地子例程”，我会写的：

#...
    my $inner = sub ($) {
        print "${x}$_[0]\n";
    }

    $inner->('foo');
#...

最重要的是，我认为两者都是等效的。

但是，第一个变体无法正常运行，因为Perl抱怨：

变量$ x在...

上不可用

... 中描述该行 $ x 在“本地子例程”中引用的线路。

谁能解释这一点？ Perl的本地子例程与Pascal的本地子例程根本不同吗？

Answer 1

问题中的术语“ local subroutine ”似乎是指。这些是私人子例程，仅在定义之后定义的范围（块）内可见；就像私人变量一样。

或 state 定义（或预定的）

但是它们是用我的 > sub subname {...} 在另一个内部的内部没有使其“本地”（在任何版本的perl中），但是将其编译成与其他子例程一起编写的，并将其放置在他们的软件包的符号表（ main :: 例如）。

---

问题提到 cloture> cloture 在标题中，这里是评论

a perl中的关闭是程序中的结构，通常是标量变量，引用子，并在其（运行时）创建其范围中带有环境（变量）。另请参阅a perlfaq7条目。凌乱解释。例如：

sub gen { 
    my $args = "@_"; 

    my $cr = sub { say "Closed over: |$args|. Args for this sub: @_" }
    return $cr;
}

my $f = gen( qw(args for gen) );

$f->("hi closed");
# Prints:
# Closed over: |args for gen|. Args for this sub: hi closed

匿名子“关闭”范围中定义的变量，从某种意义上说，当它的生成函数返回其引用并删除范围并远离这些变量，这些变量仍然存在，因为该引用的存在。
由于在运行时创建了匿名subs，因此每次调用其生成函数时，它都会重新制作词汇，因此Anon Sub也是如此，因此它始终可以访问当前值。
因此，返回的对Anon-Sub的引用使用词汇数据，否则这些数据将消失。一小部分魔术。^†

回到“本地”潜艇的问题。如果我们想引入实际关闭问题，我们需要从 offer subroutine返回代码参考，例如

sub outer {
    my $x = 'x' . "@_";
    return sub { say "$x @_" }
}
my $f = outer("args");
$f->( qw(code ref) );   # prints:  xargs code ref

或根据主要问题，如 v5.18.0 v5.26.0 ，我们可以使用一个命名的词汇（真正嵌套了（真正嵌套） ！）

sub outer {
    my $x = 'x' . "@_";
    
    my sub inner { say "$x @_" };

    return \&inner;
}

在这两种情况下，子例程我的$ f = ofter（...）; 的代码参考从 ofert 返回，该参考正确使用了本地词汇变量（ $ $ X ），其最新值。

但是我们不能使用外部闭合的平原sub in

sub outer {
    ...

    sub inner { ... }  # misleading, likely misguided and buggy

    return \&inner;    # won't work correctly
}

在编译时进行是全局的，因此它使用 ofter 从 ofter 首次称为时，将其值烘烤。因此， Inner 只有在 exter 下次称为 ofter 中的词汇环境时，才能正确才是正确的/代码>不。例如，我可以很容易地找到这篇文章，然后参见条目

---

^†，在我看来，在某种程度上，一个贫穷的对象，因为它具有功能性和数据，在另一个时间在其他地方制作，并且可以与传递给它的数据一起使用（并且都可以更新）

Answer 2

如果您需要“本地”潜艇，则可以根据所需的向后兼容性级别使用以下内容：

• 5.26+：

   我的子内{...}
   

• 5.18+：

   使用实验QW（lexical_subs）; ＃安全：在5.26中接受。
  
  我的子内部{...}
   

• “任何”版本：

    local *inner = sub {...};
   

但是，您不应该使用 sub Inner {...} 。

---

sub f { ... }

相同

BEGIN { *f = sub { ... } }

基本上与

sub outer {
   ...

   sub inner { ... }

   ...
}

您基本上

BEGIN {
   *outer = sub {
      ...

      BEGIN {
         *inner = sub { ... };
      }

      ...
   };
}

，即使在 外部之外也可以看到内部，因此它根本不是“本地”。

如您所见，对*内部的分配是在编译时完成的，这引入了另一个主要问题。

use strict;
use warnings;
use feature qw( say );

sub outer {
   my $arg = shift;

   sub inner {
      say $arg;
   }

   inner();
}

outer( 123 );
outer( 456 );

Variable "$arg" will not stay shared at a.pl line 9.
123
123

5.18确实引入了词汇（“本地”）子例程。

use strict;
use warnings;
use feature qw( say );
use experimental qw( lexical_subs );  # Safe: Accepted in 5.26.

sub outer {
   my $arg = shift;

   my sub inner {
      say $arg;
   };

   inner();
}

outer( 123 );
outer( 456 );

123
456

如果您需要支持旧版本的Perl，则可以使用以下内容：

use strict;
use warnings;
use feature qw( say );

sub outer {
   my $arg = shift;

   local *inner = sub {
      say $arg;
   };

   inner();
}

outer( 123 );
outer( 456 );

123
456

Answer 3

我从 Man Perldiag 中找到了一个很好的解释：

       Variable "%s" is not available
           (W closure) During compilation, an inner named subroutine or eval
           is attempting to capture an outer lexical that is not currently
           available.  This can happen for one of two reasons.  First, the
           outer lexical may be declared in an outer anonymous subroutine
           that has not yet been created.  (Remember that named subs are
           created at compile time, while anonymous subs are created at run-
           time.)  For example,

               sub { my $a; sub f { $a } }

           At the time that f is created, it can't capture the current value
           of $a, since the anonymous subroutine hasn't been created yet.

因此，这是一个可能的解决方法：

sub outer()
{
    my $x = 'x';   # just to make a simple example

    eval 'sub inner($)
    {
        print "${x}$_[0]\n";
    }';

    inner('foo');;
}

...虽然不会：

sub outer()
{
    my $x = 'x';   # just to make a simple example

    eval {
        sub inner($)
        {
            print "${x}$_[0]\n";
        }
    };

    inner('foo');;
}