是否可以编写一个匹配出现次数未知的嵌套模式的正则表达式？例如，当外部大括号中嵌套了未知数量的打开/关闭大括号时，正则表达式是否可以匹配左大括号和右大括号？
例如：
public MyMethod()
{
if (test)
{
// More { }
}
// More { }
} // End
应该匹配：
{
if (test)
{
// More { }
}
// More { }
}
【问题讨论】：
标签： regex nested finite-automata
...假设有一些您愿意停下来的最大嵌套数。
让我解释一下。
@torsten-marek 是正确的，正则表达式无法检查这样的嵌套模式，但是可以定义一个嵌套的正则表达式模式，它可以让您捕获像这样的嵌套结构达到某个最大深度。我创建了一个来捕获EBNF-style cmets (try it out here)，比如：
(* This is a comment (* this is nested inside (* another level! *) hey *) yo *)
正则表达式（用于单深度 cmets）如下：
m{1} = \(+\*+(?:[^*(]|(?:\*+[^)*])|(?:\(+[^*(]))*\*+\)+
这可以通过将\(+\*+ 和\*+\)+ 替换为{ 和} 并将其间的所有内容替换为简单的[^{}] 来轻松适应您的目的：
p{1} = \{(?:[^{}])*\}
（Here's the link 尝试一下。）
要嵌套，只需在块本身内允许此模式：
p{2} = \{(?:(?:p{1})|(?:[^{}]))*\}
...or...
p{2} = \{(?:(?:\{(?:[^{}])*\})|(?:[^{}]))*\}
要查找三重嵌套块，请使用：
p{3} = \{(?:(?:p{2})|(?:[^{}]))*\}
...or...
p{3} = \{(?:(?:\{(?:(?:\{(?:[^{}])*\})|(?:[^{}]))*\})|(?:[^{}]))*\}
一个清晰的模式已经出现。要查找嵌套到 N 深度的 cmets，只需使用正则表达式：
p{N} = \{(?:(?:p{N-1})|(?:[^{}]))*\}
where N > 1 and
p{1} = \{(?:[^{}])*\}
可以编写一个脚本来递归地生成这些正则表达式，但这超出了我需要的范围。 （这留给读者作为练习。?）
【讨论】：
String getNestedBraceRegex(int n) {if(n == 1) return "\\{(?:[^{}])*\\}"; else return "\\{(?:(?:" + getNestedBraceRegex(n-1) + ")|(?:[^{}]))*\\}";} 完美，谢谢。 PCRE/2 更优雅：(\{((?>[^{}]+|(?1))*)\}) 但这不起作用，例如在 Java 中。
不，那时你正在进入Context Free Grammars 的领域。
【讨论】：
是的，如果它是 .NET RegEx 引擎。 .Net 引擎支持由外部堆栈提供的有限状态机。见details
【讨论】：
如果字符串在一行上，可能是有效的 Perl 解决方案：
my $NesteD ;
$NesteD = qr/ \{( [^{}] | (??{ $NesteD }) )* \} /x ;
if ( $Stringy =~ m/\b( \w+$NesteD )/x ) {
print "Found: $1\n" ;
}
HTH
编辑：检查：
Torsten Marek 的另一件事（他正确指出，它不再是正则表达式）：
【讨论】：
在 PHP 正则表达式引擎中使用递归匹配比括号的过程匹配要快得多。尤其是较长的字符串。
http://php.net/manual/en/regexp.reference.recursive.php
例如
$patt = '!\( (?: (?: (?>[^()]+) | (?R) )* ) \)!x';
preg_match_all( $patt, $str, $m );
对比
matchBrackets( $str );
function matchBrackets ( $str, $offset = 0 ) {
$matches = array();
list( $opener, $closer ) = array( '(', ')' );
// Return early if there's no match
if ( false === ( $first_offset = strpos( $str, $opener, $offset ) ) ) {
return $matches;
}
// Step through the string one character at a time storing offsets
$paren_score = -1;
$inside_paren = false;
$match_start = 0;
$offsets = array();
for ( $index = $first_offset; $index < strlen( $str ); $index++ ) {
$char = $str[ $index ];
if ( $opener === $char ) {
if ( ! $inside_paren ) {
$paren_score = 1;
$match_start = $index;
}
else {
$paren_score++;
}
$inside_paren = true;
}
elseif ( $closer === $char ) {
$paren_score--;
}
if ( 0 === $paren_score ) {
$inside_paren = false;
$paren_score = -1;
$offsets[] = array( $match_start, $index + 1 );
}
}
while ( $offset = array_shift( $offsets ) ) {
list( $start, $finish ) = $offset;
$match = substr( $str, $start, $finish - $start );
$matches[] = $match;
}
return $matches;
}
【讨论】：
使用正则表达式检查嵌套模式非常容易。
'/(\((?>[^()]+|(?1))*\))/'
【讨论】：
(?>...) 原子组语法（在 PHP 5.2 下）的一个问题是 ?> 部分被解释为：“脚本结束”！我会这样写：/\((?:[^()]++|(?R))*+\)/。这对于匹配和非匹配都更有效。以最小的形式，/\(([^()]|(?R))*\)/，它确实是一件美丽的事情！
(?1) 允许 cmets 位于其他文本中（我将其撕掉并从我的电子邮件地址正则表达式中简化了它）。并且使用了(?>，因为我相信它会使它更快地失败（如果需要）。这不正确吗？
'(a (b c)) (d e)'，使用简单的表达式'/\([^()]*\)/' 给我同样的结果。长表达有什么好处吗？
/^(\((?>[^()]+|(?1))*\))+$/ 和/^\([^()]*\)+$/ 来匹配(a (b c))(d e)。前者匹配，但后者不匹配。
这似乎有效：/(\{(?:\{.*\}|[^\{])*\})/m
【讨论】：
{{} 匹配
正如 zsolt 提到的，一些正则表达式引擎支持递归——当然，这些引擎通常使用回溯算法，因此它不会特别有效。例如：/(?>[^{}]*){(?>[^{}]*)(?R)*(?>[^{}]*)}/sm
【讨论】：
Pumping lemma for regular languages 是你不能这样做的原因。
生成的自动机将具有有限数量的状态，例如 k，因此一串 k+1 个左大括号必然会在某处重复一个状态（当自动机处理字符时）。同一状态之间的字符串部分可以无限重复，自动机不知道区别。
特别是，如果它接受 k+1 个左大括号，后跟 k+1 个右大括号（它应该接受），它还将接受泵送的左大括号数，然后是不变的 k+1 个右大括号（它不应该)。
【讨论】：
没有。就这么容易。有限自动机（它是正则表达式基础的数据结构）除了它所处的状态之外没有内存，如果你有任意深度的嵌套，你需要一个任意大的自动机，这与 的概念相冲突有限的自动机。
您可以将嵌套/配对元素匹配到固定深度，其中深度仅受您的记忆限制，因为自动机变得非常大。然而，在实践中，您应该使用下推自动机，即用于上下文无关文法的解析器，例如 LL（自上而下）或 LR（自下而上）。您必须考虑更糟糕的运行时行为：O(n^3) vs. O(n)，n = length(input)。
有许多可用的解析器生成器，例如用于 Java 的 ANTLR。为 Java（或 C）找到现有的语法也不难。
更多背景信息：Automata Theory 维基百科
【讨论】：