JavaScript中使用全局查找重叠的回顾后发表达式

Question

在Javascript中，对于后顾正则表达式有几种（有时很棘手的）解决方案。但是，如果我需要一个具有全局搜索、可能重叠且具有零宽度的后顾表达式，哪种方法最简单呢？例如，使用/(?<=[01])\d/g，我们可以执行以下操作：

let a = "--1--01001--1087---";
let result = a.replace(/(?<=[01])\d/g, "#");
// This should print "--1--0####--1##7---" if lookbehind would be supported
console.log(result);

另一个例子：我们如何创建一个仅适用于字母（[a-zA-Z]）的类似于\b的表达式。 （前瞻没有问题，只是JS不支持后顾）。

- FERcsI

Answer 1

“逆序回溯”的方法似乎是最简单的。对于像这样的短数字模式，这种方法效果最佳。”

function revStr(str) {
    return str.split('').reverse().join('');
}

var s = "--1--01001--1087---";
var rxp = /\d(?=[01])/g;

var result = revStr(revStr(s).replace(rxp, "#"));
document.write(result);

逻辑：

• \d(?=[01]) 是反向正则表达式 (?<=[01])\d
• 我们使用 revStr(s) 函数翻转输入字符串
• 再次翻转替换结果以获取最终结果。

注意：

如果您需要在 JavaScript 中同时使用可变宽度的后向查找和前向查找，我可以推荐阅读 Steven Levithan 的 JavaScript Regex Lookbehind Redux 文章，在其中您可以找到一个示例函数，显示如何使用 XRegExp 实现该行为。以下是这些函数：

// Simulating infinite-length leading lookbehind in JavaScript. Uses XRegExp.
// Captures within lookbehind are not included in match results. Lazy
// repetition in lookbehind may lead to unexpected results.

(function (XRegExp) {

    function prepareLb(lb) {
        // Allow mode modifier before lookbehind
        var parts = /^((?:\(\?[\w$]+\))?)\(\?<([=!])([\s\S]*)\)$/.exec(lb);
        return {
            // $(?!\s) allows use of (?m) in lookbehind
            lb: XRegExp(parts ? parts[1] + "(?:" + parts[3] + ")$(?!\\s)" : lb),
            // Positive or negative lookbehind. Use positive if no lookbehind group
            type: parts ? parts[2] === "=" : !parts
        };
    }

    XRegExp.execLb = function (str, lb, regex) {
        var pos = 0, match, leftContext;
        lb = prepareLb(lb);
        while (match = XRegExp.exec(str, regex, pos)) {
            leftContext = str.slice(0, match.index);
            if (lb.type === lb.lb.test(leftContext)) {
                return match;
            }
            pos = match.index + 1;
        }
        return null;
    };

    XRegExp.testLb = function (str, lb, regex) {
        return !!XRegExp.execLb(str, lb, regex);
    };

    XRegExp.searchLb = function (str, lb, regex) {
        var match = XRegExp.execLb(str, lb, regex);
        return match ? match.index : -1;
    };

    XRegExp.matchAllLb = function (str, lb, regex) {
        var matches = [], pos = 0, match, leftContext;
        lb = prepareLb(lb);
        while (match = XRegExp.exec(str, regex, pos)) {
            leftContext = str.slice(0, match.index);
            if (lb.type === lb.lb.test(leftContext)) {
                matches.push(match[0]);
                pos = match.index + (match[0].length || 1);
            } else {
                pos = match.index + 1;
            }
        }
        return matches;
    };

    XRegExp.replaceLb = function (str, lb, regex, replacement) {
        var output = "", pos = 0, lastEnd = 0, match, leftContext;
        lb = prepareLb(lb);
        while (match = XRegExp.exec(str, regex, pos)) {
            leftContext = str.slice(0, match.index);
            if (lb.type === lb.lb.test(leftContext)) {
                // Doesn't work correctly if lookahead in regex looks outside of the match
                output += str.slice(lastEnd, match.index) + XRegExp.replace(match[0], regex, replacement);
                lastEnd = match.index + match[0].length;
                if (!regex.global) {
                    break;
                }
                pos = match.index + (match[0].length || 1);
            } else {
                pos = match.index + 1;
            }
        }
        return output + str.slice(lastEnd);
    };

}(XRegExp));

每个函数都需要三个参数：要搜索的字符串，作为字符串的回顾模式（可以使用XRegExp语法扩展），以及主正则表达式。 XRegExp.replaceLb 需要第四个参数作为替换值，可以是字符串或函数。

以下是使用示例：

XRegExp.execLb("Fluffy cat", "(?i)(?<=fluffy\\W+)", XRegExp("(?i)(?<first>c)at"));
// -> ["cat", "c"]
// Result has named backref: result.first -> "c"

XRegExp.execLb("Fluffy cat", "(?i)(?<!fluffy\\W+)", /cat/i);
// -> null

XRegExp.testLb("Fluffy cat", "(?i)(?<=fluffy\\W+)", /cat/i);
// -> true

XRegExp.testLb("Fluffy cat", "(?i)(?<!fluffy\\W+)", /cat/i);
// -> false

XRegExp.searchLb("Catwoman's fluffy cat", "(?i)(?<=fluffy\\W+)", /cat/i);
// -> 18

XRegExp.searchLb("Catwoman's fluffy cat", "(?i)(?<!fluffy\\W+)", /cat/i);
// -> 0

XRegExp.matchAllLb("Catwoman's cats are fluffy cats", "(?i)(?<=fluffy\\W+)", /cat\w*/i);
// -> ["cats"]

XRegExp.matchAllLb("Catwoman's cats are fluffy cats", "(?i)(?<!fluffy\\W+)", /cat\w*/i);
// -> ["Catwoman", "cats"]

XRegExp.replaceLb("Catwoman's fluffy cat is a cat", "(?i)(?<=fluffy\\W+)", /cat/ig, "dog");
// -> "Catwoman's fluffy dog is a cat"

XRegExp.replaceLb("Catwoman's fluffy cat is a cat", "(?i)(?<!fluffy\\W+)", /cat/ig, "dog");
// -> "dogwoman's fluffy cat is a dog"

XRegExp.replaceLb("Catwoman's fluffy cat is a cat", "(?i)(?<!fluffy\\W+)", /cat/ig, function ($0) {
    var first = $0.charAt(0);
    return first === first.toUpperCase() ? "Dog" : "dog";
});
// -> "Dogwoman's fluffy cat is a dog"

- Wiktor Stribiżew

---

除非您需要使用可变宽度的后顾和前瞻，否则这种反转方法似乎最适合重叠匹配。而且代码量并不是很大。此外，正则表达式模式也不难反转。 - Wiktor Stribiżew

我发现这样说，但看起来没有其他选择。实际上，有时我们也需要同时使用前向和后向查找（并不常见：我想在我16年的Perl编程经验中只用过大约5次，但依然有需求）。 - FERcsI

如果你需要在JavaScript中同时使用可变宽度的look-behind和look-ahead，我可以推荐阅读Steven Levithan的JavaScript Regex Lookbehind Redux文章，其中提供了一个示例函数，展示如何使用XRegExp实现这种行为。 - Wiktor Stribiżew