ruby - 为什么此正则表达式在 sed 中的运行方式与在 Perl/Ruby 中的运行方式不同？

Question

我有一个正则表达式，它在 sed 中给出一个结果，在 Perl(和 Ruby)中给出另一个结果。

我有字符串 one;two;;three，我想突出显示由 ; 分隔的子字符串。所以我在 Perl 中执行以下操作:

$a = "one;two;;three";
$a =~ s/([^;]*)/[\1]/g;
print $a;

(或者，在 Ruby 中:print "one;two;;three".gsub(/([^;]*)/, "[\\1]")。)

结果是:

[one][];[two][];[];[three][]

(我知道虚假空子串的原因。)

奇怪的是，当我在 sed 中运行相同的正则表达式时，我得到了不同的结果。我跑:

echo "one;two;;three" | sed -e 's/[^;]*/[\0]/g'

我得到:

[one];[two];[];[three]

造成这种不同结果的原因是什么？

编辑:

有人回答“因为 sed 不是 perl”。我知道。我问这个问题的原因是因为我不明白 sed 如何很好地处理零长度匹配。

Answer 1

这是一个有趣且令人惊讶的边缘案例。

您的 [^;]* 模式可能匹配空字符串，所以它变成了一个哲学问题，即。，有多少个空字符串字符串介于两个字符之间:零个、一个还是多个？

种子

sed 匹配明显遵循 “Zero–Length Regex Matches.” 的“在零长度正则表达式匹配后推进”部分中描述的理念。

Now the regex engine is in a tricky situation. We’re asking it to go through the entire string to find all non–overlapping regex matches. The first match ended at the start of the string, where the first match attempt began. The regex engine needs a way to avoid getting stuck in an infinite loop that forever finds the same zero-length match at the start of the string.

The simplest solution, which is used by most regex engines, is to start the next match attempt one character after the end of the previous match, if the previous match was zero–length.

也就是说，字符之间有零个空字符串。

上面这段话不是权威标准，引用这样的文档反而会更好。

检查 source of GNU sed , 我们看到

/* Start after the match.  last_end is the real end of the matched
   substring, excluding characters that were skipped in case the RE
   matched the empty string.  */
start = offset + matched;
last_end = regs.end[0];

Perl 和 Ruby

Perl 与 s/// 的理念，Ruby 似乎共享这一点——所以下面的文档和示例使用 Perl 来表示两者——每个字符后只有一个空字符串。

“Regexp Quote–Like Operators” section of the perlop文档读取

The /g modifier specifies global pattern matching—that is, matching as many times as possible within the string.

s/([^;]*)/[\1]/g 的跟踪执行给出

1. 开始。 “匹配位置”由 ^ 表示，位于目标字符串的开头。

    o n e ; t w o ; ; t h r e e
   ^
   

2. 尝试匹配[^;]*。

    o n e ; t w o ; ; t h r e e
         ^
   

   注意$1中捕获的结果是one。

3. 尝试匹配[^;]*。

    o n e ; t w o ; ; t h r e e
         ^
   

   重要教训:* 正则表达式量词总是成功，因为它表示“零个或多个”。在这种情况下，$1 中的子字符串是空字符串。

剩下的比赛如上进行。

作为一个敏锐的读者，您现在问自己，“自己，如果 * 总是成功，匹配如何在目标字符串的末尾终止，或者就此而言，它是如何得到的甚至超过了第一个零长度匹配？”

我们在 “Repeated Patterns Matching a Zero–length Substring” section of the perlre 中找到了这个尖锐问题的答案。文档。

However, long experience has shown that many programming tasks may be significantly simplified by using repeated subexpressions that may match zero–length substrings. Here’s a simple example being:

@chars = split //, $string; # // is not magic in split
($whitewashed = $string) =~ s/()/ /g; # parens avoid magic s// /

Thus Perl allows such constructs, by forcefully breaking the infinite loop. The rules for this are different for lower–level loops given by the greedy quantifiers *+{}, and for higher-level ones like the /g modifier or split operator.

…

The higher–level loops preserve an additional state between iterations: whether the last match was zero–length. To break the loop, the following match after a zero–length match is prohibited to have a length of zero. This prohibition interacts with backtracking … and so the second best match is chosen if the best match is of zero length.

其他 Perl 方法

通过添加否定的回顾断言，您可以过滤虚假的空匹配。

  $ perl -le '$a = "one;two;;three";
              $a =~ s/(?<![^;])([^;]*)/[\1]/g;
              print $a;'
  [one];[two];[];[three]

应用 Mark Dominus 称为 Randal’s Rule 的内容，“当您知道要保留什么时，请使用捕获。当您知道要丢弃什么时，请使用 split。”你想扔掉分号，这样你的代码就变得更直接了

$ perl -le '$a = "one;two;;three";
            $a = join ";", map "[$_]", split /;/, $a;
            print $a;'
[one];[two];[];[three]