no-useless-backreference

禁用正则表达式中无用的反向引用

在 JavaScript 正则表达式中，定义对模式的另一个备选部分中的组的反向引用、对出现在反向引用之后的组的反向引用、对包含该反向引用的组的反向引用或对负向先行断言内的组的反向引用在语法上是有效的。但是，根据规范，在任何这些情况下，无论反向引用和组出现在什么上下文中，反向引用总是最终只匹配零长度（空字符串）。

总是成功匹配零长度并且不能匹配任何其他内容的反向引用是无用的。它们基本上被忽略，并且可以被移除而不会改变正则表达式的行为。

const regex = /^(?:(a)|\1b)$/;

regex.test("a"); // true
regex.test("b"); // true!
regex.test("ab"); // false

const equivalentRegex = /^(?:(a)|b)$/;

equivalentRegex.test("a"); // true
equivalentRegex.test("b"); // true
equivalentRegex.test("ab"); // false
1
2
3
4
5
6
7
8
9
10
11

无用的反向引用可能是代码中的错误。它通常表明正则表达式没有按预期工作。

规则详情

此规则旨在检测并禁止正则表达式中的以下反向引用

• 对另一个备选项中的组的反向引用，例如 /(a)|\1b/。在这种构造的正则表达式中，反向引用预计匹配在当时未参与的组中捕获的内容。
• 对模式中稍后出现的组的反向引用，例如 /\1(a)/。该组尚未捕获任何内容，并且 ECMAScript 不支持前向引用。在向后匹配的后行断言内部，情况相反，此规则禁止对同一后行断言中之前出现的组的反向引用，例如 /(?<=(a)\1)b/。
• 从同一组内对组的反向引用，例如 /(\1)/。与前面类似，该组尚未捕获任何内容，并且 ECMAScript 不支持嵌套引用。
• 对负向先行断言中的组的反向引用，如果反向引用不在同一个负向先行断言中，例如 /a(?!(b)).\1/。负向先行断言（先行或后行）只有在其模式无法匹配时才成功，这意味着该组已失败。

根据 ECMAScript 规范，上面列出的所有反向引用都是有效的，总是成功匹配零长度，并且不能匹配任何其他内容。因此，它们不会产生解析或运行时错误，但也不会影响其正则表达式的行为。它们在语法上是有效的，但无用。

对于来自其他语言的开发者来说，这可能会令人惊讶，在其他语言中，其中一些反向引用可以以有意义的方式使用。

// in some other languages, this pattern would successfully match "aab"

/^(?:(a)(?=a)|\1b)+$/.test("aab"); // false
1
2
3

此规则的错误代码示例

/*eslint no-useless-backreference: "error"*/

/^(?:(a)|\1b)$/; // reference to (a) into another alternative

/^(?:(a)|b(?:c|\1))$/; // reference to (a) into another alternative

/^(?:a|b(?:(c)|\1))$/; // reference to (c) into another alternative

/\1(a)/; // forward reference to (a)

RegExp('(a)\\2(b)'); // forward reference to (b)

/(?:a)(b)\2(c)/; // forward reference to (c)

/\k<foo>(?<foo>a)/; // forward reference to (?<foo>a)

/(?<=(a)\1)b/; // backward reference to (a) from within the same lookbehind

/(?<!(a)\1)b/; // backward reference to (a) from within the same lookbehind

new RegExp('(\\1)'); // nested reference to (\1)

/^((a)\1)$/; // nested reference to ((a)\1)

/a(?<foo>(.)b\1)/; // nested reference to (?<foo>(.)b\1)

/a(?!(b)).\1/; // reference to (b) into a negative lookahead

/(?<!(a))b\1/; // reference to (a) into a negative lookbehind
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

此规则的正确代码示例

/*eslint no-useless-backreference: "error"*/

/^(?:(a)|(b)\2)$/; // reference to (b)

/(a)\1/; // reference to (a)

RegExp('(a)\\1(b)'); // reference to (a)

/(a)(b)\2(c)/; // reference to (b)

/(?<foo>a)\k<foo>/; // reference to (?<foo>a)

/(?<=\1(a))b/; // reference to (a), correctly before the group as they're in the same lookbehind

/(?<=(a))b\1/; // reference to (a), correctly after the group as the backreference isn't in the lookbehind

new RegExp('(.)\\1'); // reference to (.)

/^(?:(a)\1)$/; // reference to (a)

/^((a)\2)$/; // reference to (a)

/a(?<foo>(.)b\2)/; // reference to (.)

/a(?!(b|c)\1)./; // reference to (b|c), correct as it's from within the same negative lookahead

/(?<!\1(a))b/; // reference to (a), correct as it's from within the same negative lookbehind
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

请注意，此规则并非旨在检测和禁止在正则表达式中潜在的错误使用反向引用语法，例如在字符类中使用或尝试引用不存在的组。根据上下文，不是语法上有效的反向引用的 \1…\9 序列可能会产生语法错误，或者被解析为其他内容（例如，作为旧式八进制转义序列）。

此规则的附加正确代码示例

/*eslint no-useless-backreference: "error"*/

// comments describe behavior in a browser

/^[\1](a)$/.test("\x01a"); // true. In a character class, \1 is treated as an octal escape sequence.
/^\1$/.test("\x01"); // true. Since the group 1 doesn't exist, \1 is treated as an octal escape sequence.
/^(a)\1\2$/.test("aa\x02"); // true. In this case, \1 is a backreference, \2 is an octal escape sequence.
1
2
3
4
5
6
7

相关规则

• no-control-regex
• no-empty-character-class
• no-invalid-regexp

版本

此规则在 ESLint v7.0.0-alpha.0 中引入。

深入阅读

正则表达式 - JavaScript | MDN
developer.mozilla.org

资源

• 规则来源
• 测试来源