使用 Perl 替换运算符保留捕获

Question

有人可以解释为什么下面的代码...

#!/opt/local/bin/perl
use strict;
use warnings;

my $string;

$string = "\t\t\tEntry";
print "String: >$string<\n";

$string =~ s/^(\t*)//gi;

print "\$1: >$1<\n";
print "String: >$string<\n";
print "\n";

$string = "\t\t\tEntry";

$string =~ s/^(\t*)([^\t]+)/$2/gi;

print "\$1: >$1<\n";
print "String: >$string<\n";
print "\n";

exit 0;

...产生以下输出...

String: >           Entry<
Use of uninitialized value in concatenation (.) or string at ~/sandbox.pl line 12.
$1: ><
String: >Entry<

$1: >           <
String: >Entry<

...或者更直接：为什么第一个替换中的匹配值没有保留在 $1 中？

Answer 1

我在 Perl 5.12 的两个实现上尝试过这一点，但没有遇到问题。 5.8 做到了。

因为您有 g 选项，perl 会尝试匹配该模式，直到失败。请参阅下面的调试输出。

所以它在 Perl 5.8 中不起作用，但 this 可以：

my $c1;
$string =~ s/^(\t*)/$c1=$1;''/ge;

因此每次匹配时，它都会将其保存到 $c1 中。

这就是 use re 'debug' 告诉我的：

Compiling REx `^(\t*)'
size 9 Got 76 bytes for offset annotations.
first at 2
   1: BOL(2)
   2: OPEN1(4)
   4:   STAR(7)
   5:     EXACT <\t>(0)
   7: CLOSE1(9)
   9: END(0)
anchored(BOL) minlen 0
Offsets: [9]
        1[1] 2[1] 0[0] 5[1] 3[1] 0[0] 6[1] 0[0] 7[0]
Compiling REx `^(\t*)([^\t]+)'
size 25 Got 204 bytes for offset annotations.
first at 2
   1: BOL(2)
   2: OPEN1(4)
   4:   STAR(7)
   5:     EXACTF <\t>(0)
   7: CLOSE1(9)
   9: OPEN2(11)
  11:   PLUS(23)
  12:     ANYOF[\0-\10\12-\377{unicode_all}](0)
  23: CLOSE2(25)
  25: END(0)
anchored(BOL) minlen 1
Offsets: [25]
        1[1] 2[1] 0[0] 5[1] 3[1] 0[0] 6[1] 0[0] 7[1] 0[0] 13[1] 8[5] 0[0] 0[0] 0[0] 0[0] 0[0] 0[0] 0[0] 0[0] 0[0] 0[0] 14[1] 0[0] 15[0]
String: >                       Entry<
Matching REx `^(\t*)' against `                 Entry'
  Setting an EVAL scope, savestack=5
   0 <> <                       Entry>        |  1:  BOL
   0 <> <                       Entry>        |  2:  OPEN1
   0 <> <                       Entry>        |  4:  STAR
                           EXACT <\t> can match 3 times out of 2147483647...
  Setting an EVAL scope, savestack=5
   3 <                  > <Entry>        |  7:    CLOSE1
   3 <                  > <Entry>        |  9:    END
Match successful!
match pos=0
Use of uninitialized value in substitution iterator at - line 11.
Matching REx `^(\t*)' against `Entry'
  Setting an EVAL scope, savestack=5
   3 <                  > <Entry>        |  1:  BOL
                            failed...
Match failed
Freeing REx: `"^(\\t*)"'
Freeing REx: `"^(\\t*)([^\\t]+)"'

因为您试图匹配行开头的空格，所以您既不需要 g 也不需要 i。因此，这可能是您正在尝试做其他事情的情况。

Answer 2

我认为 5.10 及更高版本，如果存在匹配，它只会影响捕获缓冲区。
您的示例中有趣的事情是 $string =~ s/^(\t*)([^\t]+)/$2/gi;
它没有重置捕获缓冲区。这似乎是因为序言中估计了
如果应该尝试匹配。在本例中，([^\t]+) 消耗了第一个
中的整个字符串
匹配，因此出现字符串太短并且缓冲区从未重置。

我无法测试它，但 $string =~ s/^(\t*)([^\t])//gi 应该给出相同的警告。
if ( s///g ) {} 并且在这种情况下捕获缓冲区的测试不一定包含
任何事物。 5.8版本就是这种情况。即使在更高版本中，它实际上也只是一个调试功能。

编辑 @theracoon - 关于您的评论：“我相当确定 ([^\t]+) 实际上并未消耗整个字符串。输出绝对没有反映这一点。”

这是您的正则表达式在第一个匹配（第 1 轮）中消耗了整个字符串的证明。
第二遍就没有什么可匹配的了。这就是 /g 修饰符的工作方式。
它尝试在字符串中最后一次匹配结束的位置再次匹配整个正则表达式。

use re 'debug';
$string = "\t\t\tEntry";
$string =~ s/^(\t*)([^\t]+)/$2/gi;
print "'$string'\n";

通过 1 ..
将 REx "^(\t*)([^\t]+)" 与 "%t%t%tEntry"
8 <%t%t%tEntry> <>
匹配成功！

通过 2 ..
将 REx "^(\t*)([^\t]+)" 与 "" 进行匹配
（不，没有什么可以匹配的）
字符串太短 [regexec_flags]...
匹配失败
'入口'