Perl - 哪些范围/闭包/环境产生这种行为？

Question

给定一个根目录，我希望识别任何 .svn 目录和 pom.xml 的最浅父目录。

为了实现这一点，我定义了以下函数

use File::Find;
sub firstDirWithFileUnder {
    $needle=@_[0];
    my $result = 0;
    sub wanted {
        print "\twanted->result is '$result'\n";
        my $dir = "${File::Find::dir}";

        if ($_ eq $needle and ((not $result) or length($dir) < length($result))) {
            $result=$dir;
            print "Setting result: '$result'\n";
        }
    }
    find(\&wanted, @_[1]);
    print "Result: '$result'\n";
    return $result;
}

..并这样调用它：

    $svnDir = firstDirWithFileUnder(".svn",$projPath);
    print "\tIdentified svn dir:\n\t'$svnDir'\n";
    $pomDir = firstDirWithFileUnder("pom.xml",$projPath);
    print "\tIdentified pom.xml dir:\n\t'$pomDir'\n";

有两种情况出现，我无法解释：

1. 当 .svn 搜索成功时，内部感知到的 $result 值嵌套子例程 wanted 持续到下一次调用 firstDirWithFileUnder 时。因此，当 pom 搜索开始时，尽管 my $result = 0; 行仍然存在，但 wanted 子例程将其值视为最后一个 firstDirWithFileUnder 的返回值调用。
2. 如果 my $result = 0; 行被注释掉，则该函数仍然可以正确执行。这意味着 a) 外部作用域 (firstDirWithFileUnder) 仍然可以看到 $result 变量以便能够返回它，并且 b) print 显示wanted 仍然看到上次的 $result 值，即它似乎已经形成了一个闭包，该闭包在第一次调用 firstDirWithFileUnder 后仍然持续存在。

有人可以解释发生了什么，并建议我如何在进入外部范围时正确地将 $result 的值重置为零？

Answer 1

使用警告然后使用诊断会产生这些有用的信息，包括解决方案：

变量“$needle”不会在 ----- 第 12 行 (#1) 保持共享

(W 闭包) 内部（嵌套）命名子例程引用
在外部命名子例程中定义的词法变量。

当调用内部子程序时，它会看到
外部子例程的变量在 first 之前和期间
调用外部子程序；在这种情况下，在第一次调用之后
外部子程序完成后，内部和外部子程序将不再存在
不再共享变量的共同值。换句话说，
变量将不再被共享。

这个问题通常可以通过制作内部子程序来解决
匿名，使用 sub {} 语法。 当内部匿名 subs 时
创建外部子程序中的引用变量，它们
会自动反弹到此类变量的当前值。

---

$result 是词法范围的，这意味着每次调用 &firstDirWithFileUnder 时都会分配一个全新的变量。
sub Want { ... } 是一个编译时子例程声明，这意味着它由 Perl 解释器编译一次并存储在包的符号表中。由于它包含对词法作用域 $result 变量的引用，因此 Perl 保存的子例程定义将仅引用 $result 的第一个实例。第二次调用 &firstDirWithFileUnder 并声明一个新的 $result 变量时，这将是与 $result 内的 $result 完全不同的变量代码>&想要。

您需要将 sub Wanted { ... } 声明更改为词法作用域的匿名 sub:

my $wanted = sub {
    print "\twanted->result is '$result'\n";
    ...
};

并调用 File::Find::find 如下所示

find($wanted, $_[1])

，< code>$wanted 是子例程的运行时声明，并且在每次单独调用时都会使用对 $result 的当前引用重新定义&firstDirWithFileUnder。

---

更新：此代码片段可能具有指导意义：

sub foo {
    my $foo = 0;  # lexical variable
    $bar = 0;     # global variable
    sub compiletime {
        print "compile foo is ", ++$foo, " ", \$foo, "\n";
        print "compile bar is ", ++$bar, " ", \$bar, "\n";
    }
    my $runtime = sub {
        print "runtime foo is ", ++$foo, " ", \$foo, "\n";
        print "runtime bar is ", ++$bar, " ", \$bar, "\n";
    };
    &compiletime;
    &$runtime;
    print "----------------\n";
    push @baz, \$foo;  # explained below
}
&foo for 1..3;

典型输出：

compile foo is 1 SCALAR(0xac18c0)
compile bar is 1 SCALAR(0xac1938)
runtime foo is 2 SCALAR(0xac18c0)
runtime bar is 2 SCALAR(0xac1938)
----------------
compile foo is 3 SCALAR(0xac18c0)
compile bar is 1 SCALAR(0xac1938)
runtime foo is 1 SCALAR(0xa63d18)
runtime bar is 2 SCALAR(0xac1938)
----------------
compile foo is 4 SCALAR(0xac18c0)
compile bar is 1 SCALAR(0xac1938)
runtime foo is 1 SCALAR(0xac1db8)
runtime bar is 2 SCALAR(0xac1938)
----------------

请注意，编译时 $foo 始终引用相同的变量 SCALAR(0xac18c0) ，并且这也是函数第一次运行的运行时 $foo 。

本示例中包含最后一行 &foo, push @baz,\$foo ，这样 $foo 就不会产生垃圾在 &foo 末尾收集。否则，第二个和第三个运行时 $foo 可能会指向相同的地址，即使它们引用不同的变量（每次声明变量时都会重新分配内存）。