为什么 "asdf".replace(/.*/g, "x") == "xx"？

Question

我偶然发现了一个（对我来说）令人惊讶的事实。

console.log("asdf".replace(/.*/g, "x"));

为什么要两个替换？似乎任何没有换行符的非空字符串都会为此模式产生两个替换。使用替换函数，我可以看到第一个替换是针对整个字符串，第二个是针对空字符串。

Answer 1

根据ECMA-262 标准，String.prototype.replace 调用RegExp.prototype[@@replace]，它表示：

11. Repeat, while done is false
  a. Let result be ? RegExpExec(rx, S).
  b. If result is null, set done to true.
  c. Else result is not null,
    i. Append result to the end of results.
    ii. If global is false, set done to true.
    iii. Else,
      1. Let matchStr be ? ToString(? Get(result, "0")).
      2. If matchStr is the empty String, then
        a. Let thisIndex be ? ToLength(? Get(rx, "lastIndex")).
        b. Let nextIndex be AdvanceStringIndex(S, thisIndex, fullUnicode).
        c. Perform ? Set(rx, "lastIndex", nextIndex, true).

其中rx 是/.*/g，S 是'asdf'。

参见 11.c.iii.2.b：

b.让 nextIndex 为 AdvanceStringIndex(S, thisIndex, fullUnicode)。

因此在'asdf'.replace(/.*/g, 'x')实际上是：

1. 结果（未定义），结果 = []，lastIndex = 0
2. 结果 = 'asdf'，结果 = [ 'asdf' ]，lastIndex = 4
3. result = '', results = [ 'asdf', '' ], lastIndex = 4, AdvanceStringIndex, 将 lastIndex 设置为 5
4. 结果 = null，结果 = [ 'asdf', '' ]，返回

因此有 2 个匹配项。

Answer 2

在与yawkat 的离线聊天中，我们发现了一种直观的方式，可以了解"abcd".replace(/.*/g, "x") 为何恰好产生两个匹配项。请注意，我们尚未检查它是否完全等同于 ECMAScript 标准强加的语义，因此仅将其作为经验法则。

经验法则

• 将匹配视为元组(matchStr, matchIndex) 的列表 指示输入字符串的哪些字符串部分和索引已被吃掉的时间顺序。
• 此列表从正则表达式的输入字符串的左侧开始不断构建。
• 已经吃光的部分不能再匹配了
• 在matchIndex 给出的索引处进行替换，覆盖该位置的子字符串matchStr。如果matchStr = ""，那么“替换”实际上就是插入。

在形式上，匹配和替换的行为被描述为一个循环，如 in the other answer 所示。

简单示例

1. "abcd".replace(/.*/g, "x") 输出"xx"：

   • 匹配列表是[("abcd", 0), ("", 4)]

     值得注意的是，它确实不包括以下人们可能想到的匹配，原因如下：

     • ("a", 0), ("ab", 0): 量词 * 是贪婪的
     • ("b", 1)，("bc", 1)：由于之前的匹配("abcd", 0)，字符串"b"和"bc"已经被吃掉了
     • ("", 4), ("", 4)（即两次）：索引位置 4 已经被第一个明显的匹配吃掉了

   • 因此，替换字符串 "x" 会在这些位置准确替换找到的匹配字符串：在位置 0 替换字符串 "abcd"，在位置 4 替换 ""。

     在这里您可以看到替换可以作为前一个字符串的真正替换，也可以作为新字符串的插入。

2. "abcd".replace(/.*?/g, "x") 与 lazy quantifier *? 输出 "xaxbxcxdx"

   • 匹配列表是[("", 0), ("", 1), ("", 2), ("", 3), ("", 4)]

     与前面的示例相比，这里没有包括 ("a", 0)、("ab", 0)、("abc", 0) 甚至 ("abcd", 0)，因为量词的惰性会严格限制它找到可能的最短匹配项。

   • 由于所有匹配字符串均为空，因此不会发生实际替换，而是在位置 0、1、2、3 和 4 处插入 x。

3. "abcd".replace(/.+?/g, "x") 与 lazy quantifier +? 输出 "xxxx"

   • 匹配列表为[("a", 0), ("b", 1), ("c", 2), ("d", 3)]

4. "abcd".replace(/.{2,}?/g, "x") 与 lazy quantifier [2,}? 输出 "xx"

   • 匹配列表为[("ab", 0), ("cd", 2)]

5. "abcd".replace(/.{0}/g, "x") 输出 "xaxbxcxdx" 的逻辑与示例 2 相同。

更难的例子

如果我们总是匹配一个空字符串并控制这种匹配发生的位置，我们可以始终如一地利用插入而不是替换的想法。例如，我们可以在每个偶数位置创建匹配空字符串的正则表达式，以便在其中插入一个字符：

1. "abcdefgh".replace(/(?<=^(..)*)/g, "_")) 和 positive lookbehind (?<=...) 输出 "_ab_cd_ef_gh_"（目前仅在 Chrome 中支持）

   • 匹配列表为[("", 0), ("", 2), ("", 4), ("", 6), ("", 8)]

2. "abcdefgh".replace(/(?=(..)*$)/g, "_")) 与 positive lookahead (?=...) 输出 "_ab_cd_ef_gh_"

   • 匹配列表为[("", 0), ("", 2), ("", 4), ("", 6), ("", 8)]

Answer 3

第一个匹配显然是"asdf"（位置[0,4]）。因为设置了全局标志 (g)，所以它会继续搜索。此时（位置 4），它找到了第二个匹配项，一个空字符串（位置 [4,4]）。

请记住，* 匹配零个或多个元素。

Answer 4

简单地说，第一个x是用来替换匹配的asdf。

第二个x 表示asdf 之后的空字符串。搜索在空时终止。