3

我有一个正则表达式，仅当字符串在 A 之前的某处包含模式B时才捕获模式A。

假设，为了简单起见，A是\b\d{3}\b（即三个数字），B是单词“foo”。

因此我拥有的正则表达式是(?<=\b(?:foo)\b.*?)(?<A>\b\d{3}\b).

(?<=               # look-behind
    \b(?:foo)\b    # pattern B
    .*?            # variable length
)
(?<A>\b\d{3}\b)    # pattern A

例如，对于字符串

"foo text 111, 222 and not bar something 333 but foo 444 and better 555"

它捕获

(111, 222, 333, 444, 555)

我有一个新要求，现在我必须排除模式C前面的捕获，假设C是单词“bar”。我想要构建的是一个表达的正则表达式

(?<=               # look-behind
    \b(?:foo)\b    # pattern B
    ???????????    # anything that does not contains pattern C
)
(?<A>\b\d{3}\b)    # pattern A

所以，在示例字符串中，我将不得不捕获

(111, 222, 444, 555)

当然像(?<=\b(?:foo)\b.*?)(?<!\b(?:bar)\b.*?)(?<A>\b\d{3}\b)

(?<=               # look-behind
    \b(?:foo)\b    # pattern B
    .*?
)
(?<!               # negative look-behind
    \b(?:bar)\b    # pattern C
    .*?
)
(?<A>\b\d{3}\b)    # pattern A

将不起作用，因为它会在“bar”第一次出现后排除所有内容，并且捕获将是

(111, 222)

正则表达式(?<=\b(?:foo)\b(?!.*?(?:\bbar\b)).*?)(?<A>\b\d{3}\b)

(?<=                     # look-behind
    \b(?:foo)\b          # pattern B
    (?!                  # negative lookahead
        .*?              # variable lenght
        (?:\bbar\b)      # pattern C
    )
    .*?                  # variable lenght
)
(?<A>\b\d{3}\b)          # pattern A

也不起作用，因为对于我的测试字符串中的第一个“foo”，它总是会找到“bar”作为后缀，它只会捕获

(444, 55)

到目前为止，使用表达式的条件匹配并且（现在）知道在后视中，.net 从右到左匹配和捕获，我能够创建以下正则表达式(?<=(?(C)(?!)| (?:\bfoo\b))(?:(?<!\bbar)\s|(?<C>\bbar\s)|[^\s])*)(?<A>\b\d{3}\b)

(?<=                     # look-behind
    (?(C)                # if capture group C is not empty
        (?!)             # fail (pattern C was found)
        |                # else
        (?:\bfoo\b)      # pattern B
    )
    (?:
        (?<!\bbar)\s     # space not preceeded by pattern C (consume the space)
        |
        (?<C>\bbar\s)    # pattern C followed by space (capture in capture group C)
        |
        [^\s]            # anything but space (just consume)
    )*                   # repeat as needed
)
(?<A>\b\d{3}\b)          # pattern A

这可行，但太复杂了，因为模式A、B和C比我在此处发布的示例复杂得多。

是否可以简化此正则表达式？也许使用平衡组？

4

3 回答 3

3

您可以使用基于\G匹配上一次匹配后位置的锚点的模式：

(?:\G(?!\A)|\bfoo\b)(?:(?!\b(?:bar|\d{3})\b).)*(\d{3})

演示

细节：

(?:
    \G(?!\A) # contiguous to a previous match and not at the start of the string
  |        # OR
    \bfoo\b  # foo: the condition for the first match
)
(?:(?!\b(?:bar|\d{3})\b).)* # all that is not "bar" or a 3 digit number (*)
(\d{3})

(*)请注意，如果您可以针对您的实际情况使用更好的子模式（即不使用包含交替的前瞻测试每个字符），请不要犹豫更改它。（例如，基于字符类的东西[^b\d]*(?>(?:\B[b\d]+|b(?!ar\b)|\d(?!\d\d\b))[^b\d]*)*：）

另一种方式：由于 .net 正则表达式引擎能够存储重复捕获，您也可以这样写：

\bfoo\b(?:(?:(?!\b(?:bar|\d{3})\b).)*(\d{3}))+

但是这一次，您需要遍历每次出现的 foo 以提取第 1 组中的结果。它不太方便，但模式更快，因为它不是以交替开始的。

请注意，如果"bar"and"\d{3}"以单词字符开头和结尾，您可以以更有效的方式编写模式：

\bfoo(?:\W+(?>(?!bar\b)\w+\W+)*?(\d{3}))+\b

其他方式：将字符串拆分为“foo”和“bar”（保留分隔符），遍历每个部分。当部件为“foo”时，将标志设置为真，当部件为“bar”时，将其设置为假，当部件不是“foo”或“bar”时，如果标志为真，则提取数字。

于 2016-01-15T15:06:13.710 回答
2

一个简单的选项与 Casimir et Hippolyte 的第二种模式非常相似：

foo(?>(?<A>\b\d{3}\b)|(?!bar).)+
  • 从...开始foo
  • (?>…<code>|(?!bar).)+ - 如果您看到 . 则停止匹配bar。
  • (?<A>\b\d{3}\b)并捕获沿途看到的所有 A。
  • 在这种情况下不需要原子组(?>)，无论哪种方式回溯都不会搞砸。

工作示例

同样，它可以转换为lookbehind：

(?<=foo(?:(?!bar).)*?)(?<A>\b\d{3}\b)

这样做的好处是只匹配数字。后视断言foo在 A 之前有一个，但没有一个bar.
工作示例

这两个都假设 B 和 C 有点简单。

于 2016-01-15T21:18:06.293 回答
2

既然你问过，平衡组是可能的，但可能不需要。

\A                    # Match from the start of the string
(?>                   # Atomic group. no backsies.
    (?<B>(?<-B>)?foo)            # If we see "foo", push it to stack B.
                                 # (?<-B>)? ensures B only has one item - if there are two,
                                 # one is popped.
    |(?<-B>bar)                  # When we see a bar, reset the foo.
    |(?(B)(?<A>\b\d{3}\b)|(?!))  # If foo is set, we are allowed to capture A.
    |.                           # Else, just advance by one character.
)+
\z                    # Match until the end of the string.

工作示例

如果我们想更加聪明（我们可能不这样做），我们可以将大多数分支组合到条件中：

\A
(?>
  (?(B)
    (?:(?<A>\b\d{3}\b)|(?<-B>bar))
    | # else
    (?<B>foo)
  )
  |.
)+
\z

工作示例

同样，这是可能的，但平衡组在这里不是最好的选择，主要是因为我们没有平衡任何东西，只是检查是否设置了标志。

于 2016-01-15T21:50:31.343 回答