Question

我正在尝试使用匹配来自http://daringfireball.net/2010/07/improved_regex_for_matching_urls

的正则表达式的URL

(?xi)
\b
(                       # Capture 1: entire matched URL
  (?:
    https?://               # http or https protocol
    |                       #   or
    www\d{0,3}[.]           # "www.", "www1.", "www2." … "www999."
    |                           #   or
    [a-z0-9.\-]+[.][a-z]{2,4}/  # looks like domain name followed by a slash
  )
  (?:                       # One or more:
    [^\s()<>]+                  # Run of non-space, non-()<>
    |                           #   or
    \(([^\s()<>]+|(\([^\s()<>]+\)))*\)  # balanced parens, up to 2 levels
  )+
  (?:                       # End with:
    \(([^\s()<>]+|(\([^\s()<>]+\)))*\)  # balanced parens, up to 2 levels
    |                               #   or
    [^\s`!()\[\]{};:'".,<>?«»“”‘’]        # not a space or one of these punct chars
  )
)

根据another question的答案，似乎有些情况导致此正则表达式为backtrack catastrophically。例如：

var re = /\b((?:https?:\/\/|www\d{0,3}[.]|[a-z0-9.\-]+[.][a-z]{2,4}\/)(?:[^\s()<>]+|\(([^\s()<>]+|(\([^\s()<>]+\)))*\))+(?:\(([^\s()<>]+|(\([^\s()<>]+\)))*\)|[^\s`!()\[\]{};:'".,<>?«»“”‘’]))/i;
re.test("http://google.com/?q=(AAAAAAAAAAAAAAAAAAAAAAAAAAAAA)")

...可能需要很长时间才能执行（例如在Chrome中）

在我看来问题出在这部分代码中：

(?:                       # One or more:
    [^\s()<>]+                  # Run of non-space, non-()<>
    |                           #   or
    \(([^\s()<>]+|(\([^\s()<>]+\)))*\)  # balanced parens, up to 2 levels
  )+

...似乎大致相当于(.+|\((.+|(\(.+\)))*\))+，它看起来像包含(.+)+

我能做出哪些改变可以避免这种情况吗？

Answer 1

将其更改为以下内容可以防止灾难性的回溯：

(?xi)
\b
(                       # Capture 1: entire matched URL
  (?:
    https?://               # http or https protocol
    |                       #   or
    www\d{0,3}[.]           # "www.", "www1.", "www2." … "www999."
    |                           #   or
    [a-z0-9.\-]+[.][a-z]{2,4}/  # looks like domain name followed by a slash
  )
  (?:                       # One or more:
    [^\s()<>]+                  # Run of non-space, non-()<>
    |                           #   or
    \(([^\s()<>]|(\([^\s()<>]+\)))*\)  # balanced parens, up to 2 levels
  )+
  (?:                       # End with:
    \(([^\s()<>]|(\([^\s()<>]+\)))*\)  # balanced parens, up to 2 levels
    |                               #   or
    [^\s`!()\[\]{};:'".,<>?«»“”‘’]        # not a space or one of these punct chars
  )
)

唯一的变化是在每个＆＃34;平衡的parens＆＃34;中的第一个+之后移除[^\s()<>]。正则表达式的一部分。

以下是使用JS进行测试的单行版本：

var re = /\b((?:https?:\/\/|www\d{0,3}[.]|[a-z0-9.\-]+[.][a-z]{2,4}\/)(?:[^\s()<>]+|\(([^\s()<>]|(\([^\s()<>]+\)))*\))+(?:\(([^\s()<>]|(\([^\s()<>]+\)))*\)|[^\s`!()\[\]{};:'".,<>?«»“”‘’]))/i;
re.test("http://google.com/?q=(AAAAAAAAAAAAAAAAAAAAAAAAAAAAA")

原始正则表达式的问题部分是平衡括号部分，以简化回溯发生原因的解释我将完全删除它的嵌套括号部分，因为它在这里不相关：

\(([^\s()<>]+|(\([^\s()<>]+\)))*\)    # original
\(([^\s()<>]+)*\)                     # expanded below

\(                # literal '('
(                 # start group, repeat zero or more times
    [^\s()<>]+        # one or more non-special characters
)*                # end group
\)                # literal ')'

考虑一下字符串'(AAAAA'会发生什么，文字(会匹配，然后AAAAA将被群组使用，而)将无法匹配。此时，该群组将放弃一个A，暂时留下AAAA并尝试在此时继续比赛。由于该群组后面有*，因此该群组可以多次匹配，因此您现在可以([^\s()<>]+)*匹配AAAA，然后在第二次传递时匹配A。当此失败时，原始捕获将释放额外的A并由第二次捕获消耗。

这将持续很长时间，导致以下尝试匹配，其中每个逗号分隔的组指示组匹配的不同时间，以及实例匹配的字符数：

AAAAA
AAAA, A
AAA, AA
AAA, A, A
AA, AAA
AA, AA, A
AA, A, AA
AA, A, A, A
....

我可能错了，但在确定正则表达式无法匹配之前，我确定它最多可增加16个步骤。当您继续向字符串添加其他字符时，计算出来的步骤数呈指数级增长。

删除+并将其更改为\(([^\s()<>])*\)，您可以避免此回溯方案。

重新添加交替以检查嵌套括号并不会导致任何问题。

请注意，您可能希望在字符串末尾添加某种锚点，因为目前"http://google.com/?q=(AAAAAAAAAAAAAAAAAAAAAAAAAAAAA"将匹配(之前，因此re.test(...)将返回{ {1}}因为true匹配。

如何使这个正则表达式不会导致“灾难性的回溯”？

1 个答案: