例如，这些是有效的数学表达式：
a * b + c
-a * (b / 1.50)
(apple + (-0.5)) * (boy - 1)
这些是无效的数学表达式：
--a *+ b @ 1.5.0 // two consecutive signs, two consecutive operators, invalid operator, invalid number
-a * b + 1) // unmatched parentheses
a) * (b + c) / (d // unmatched parentheses
匹配浮点数没有问题，但是括号匹配有困难。任何的想法？如果有比正则表达更好的解决方案，我也会接受。但正则表达式是首选。
======
编辑：
我想对我对“已接受的答案”的选择做一些评论，希望那些有相同问题并找到这个帖子的人不会被误导。
我认为有几个答案“被接受”，但我不知道哪一个是最好的。所以我随机选择了接受的答案（差不多）。除了接受的答案，我建议阅读Guillaume Malartre的答案。他们都为我的问题提供了实用的解决方案。有关严谨/理论上的答案，请在接受的答案下阅读David Thornley的评论。正如他所提到的，Perl对正则表达式的扩展（源于常规语言）使其“不规则”。 （我在我的问题中没有提到任何语言，所以大多数答复者都假设正则表达式的Perl实现 - 可能是最流行的实现。我在发布问题时也是如此。）
如果我上面说错了，请纠正我。
答案 0 :(得分：8)
正则表达式只能用于识别常规语言。数学表达的语言不规律;你需要实现一个真正的解析器（例如LR）才能做到这一点。
答案 1 :(得分：8)
使用下推自动机匹配paranthesis http://en.wikipedia.org/wiki/Pushdown_automaton（或只是一个堆栈;-)）
堆栈解决方案的详细信息：
while (chr available)
if chr == '(' then
push '('
else
if chr == ')' then
if stack.elements == 0 then
print('too many or misplaced )')
exit
else
pop //from stack
end while
if (stack.elements != 0)
print('too many or misplaced(')
即使很简单：只需保留一个计数器而不是堆栈。
答案 2 :(得分：5)
我相信你会更好地实现一个真正的解析器来完成你所追求的目标。
简单数学表达式的解析器是“解析101”，有几个例子可以在网上找到。
一些例子包括：
请注意，验证表达式所需的语法比上面的示例更简单，因为这些示例还实现了对表达式的求值。
答案 3 :(得分：4)
匹配parens与正则表达式很有可能。
这是一个Perl脚本，可以解析任意深度匹配的parens。虽然它会抛弃外面的不匹配的parens，但我没有专门设计它来验证parens。只要它们是平衡的，它就会解析任意深的parens。这会让你开始。
关键是正则表达式和使用它的递归。玩它，我相信你可以得到它也标记不匹配的prens。我想如果你捕获这个正则表达式抛弃并计算parens（即在非匹配文本中测试奇数parens），你就会得到无效的，不平衡的parens。
#!/usr/bin/perl
$re = qr /
( # start capture buffer 1
\( # match an opening paren
( # capture buffer 2
(?: # match one of:
(?> # don't backtrack over the inside of this group
[^()]+ # one or more
) # end non backtracking group
| # ... or ...
(?1) # recurse to opening 1 and try it again
)* # 0 or more times.
) # end of buffer 2
\) # match a closing paren
) # end capture buffer one
/x;
sub strip {
my ($str) = @_;
while ($str=~/$re/g) {
$match=$1; $striped=$2;
print "$match\n";
strip($striped) if $striped=~/\(/;
return $striped;
}
}
while(<DATA>) {
print "start pattern: $_";
while (/$re/g) {
strip($1) ;
}
}
__DATA__
"(apple + (-0.5)) * (boy - 1)"
"((((one)two)three)four)x(one(two(three(four))))"
"a) * (b + c) / (d"
"-a * (b / 1.50)"
输出：
start pattern: "(apple + (-0.5)) * (boy - 1)"
(apple + (-0.5))
(-0.5)
(boy - 1)
start pattern: "((((one)two)three)four)x(one(two(three(four))))"
((((one)two)three)four)
(((one)two)three)
((one)two)
(one)
(one(two(three(four))))
(two(three(four)))
(three(four))
(four)
start pattern: "a) * (b + c) / (d"
(b + c)
start pattern: "-a * (b / 1.50)"
(b / 1.50)
答案 4 :(得分：3)
你不能使用正则表达式来做平衡括号之类的事情。
答案 5 :(得分：3)
使用单个正则表达式这很棘手，但使用混合正则表达式/过程方法非常容易。我们的想法是为简单表达式构造一个正则表达式（不带括号），然后用一些原子字符串（例如标识符）重复替换( simple-expression )。如果最终的简化表达式匹配相同的“简单”模式，则原始表达式被认为是有效的。
插图（在php中）。
function check_syntax($str) {
// define the grammar
$number = "\d+(\.\d+)?";
$ident = "[a-z]\w*";
$atom = "[+-]?($number|$ident)";
$op = "[+*/-]";
$sexpr = "$atom($op$atom)*"; // simple expression
// step1. remove whitespace
$str = preg_replace('~\s+~', '', $str);
// step2. repeatedly replace parenthetic expressions with 'x'
$par = "~\($sexpr\)~";
while(preg_match($par, $str))
$str = preg_replace($par, 'x', $str);
// step3. no more parens, the string must be simple expression
return preg_match("~^$sexpr$~", $str);
}
$tests = array(
"a * b + c",
"-a * (b / 1.50)",
"(apple + (-0.5)) * (boy - 1)",
"--a *+ b @ 1.5.0",
"-a * b + 1)",
"a) * (b + c) / (d",
);
foreach($tests as $t)
echo $t, "=", check_syntax($t) ? "ok" : "nope", "\n";
以上只验证语法，但也可以使用相同的技术构建真正的解析器。
答案 6 :(得分：1)
对于括号匹配和实现其他表达式验证规则，编写自己的小解析器可能最简单。在这种情况下，正则表达式并不好。
答案 7 :(得分：1)
好的，这是我在ActionScript3中的括号查找版本，使用这种方法可以在括号内，括号内和父母之后分析部分给予很大的牵引力，如果某些括号保留在最后，则可以发出警告或拒绝发送到最终的评估函数。
package {
import flash.display.Sprite;
import mx.utils.StringUtil;
public class Stackoverflow_As3RegexpExample extends Sprite
{
private var tokenChain:String = "2+(3-4*(4/6))-9(82+-21)"
//Constructor
public function Stackoverflow_As3RegexpExample() {
// remove the "\" that just escape the following "\" if you want to test outside of flash compiler.
var getGroup:RegExp = new RegExp("((?:[^\\(\\)]+)?) (?:\\() ( (?:[^\\(\\)]+)? ) (?:\\)) ((?:[^\\(\\)]+)?)", "ix") //removed g flag
while (true) {
tokenChain = replace(tokenChain,getGroup)
if (tokenChain.search(getGroup) == -1) break;
}
trace("cummulativeEvaluable="+cummulativeEvaluable)
}
private var cummulativeEvaluable:Array = new Array()
protected function analyseGrammar(matchedSubstring:String, capturedMatch1:String, capturedMatch2:String, capturedMatch3:String, index:int, str:String):String {
trace("\nanalyseGrammar str:\t\t\t\t'"+str+"'")
trace("analyseGrammar matchedSubstring:'"+matchedSubstring+"'")
trace("analyseGrammar capturedMatchs:\t'"+capturedMatch1+"' '("+capturedMatch2+")' '"+capturedMatch3+"'")
trace("analyseGrammar index:\t\t\t'"+index+"'")
var blank:String = buildBlank(matchedSubstring.length)
cummulativeEvaluable.push(StringUtil.trim(matchedSubstring))
// I could do soo much rigth here!
return str.substr(0,index)+blank+str.substr(index+matchedSubstring.length,str.length-1)
}
private function replace(str:String,regExp:RegExp):String {
var result:Object = regExp.exec(str)
if (result)
return analyseGrammar.apply(null,objectToArray(result))
return str
}
private function objectToArray(value:Object):Array {
var array:Array = new Array()
var i:int = 0
while (true) {
if (value.hasOwnProperty(i.toString())) {
array.push(value[i])
} else {
break;
}
i++
}
array.push(value.index)
array.push(value.input)
return array
}
protected function buildBlank(length:uint):String {
var blank:String = ""
while (blank.length != length)
blank = blank+" "
return blank
}
}
}
它应该追踪这个：
analyseGrammar str: '2+(3-4*(4/6))-9(82+-21)'
analyseGrammar matchedSubstring:'3-4*(4/6)'
analyseGrammar capturedMatchs: '3-4*' '(4/6)' ''
analyseGrammar index: '3'
analyseGrammar str: '2+( )-9(82+-21)'
analyseGrammar matchedSubstring:'2+( )-9'
analyseGrammar capturedMatchs: '2+' '( )' '-9'
analyseGrammar index: '0'
analyseGrammar str: ' (82+-21)'
analyseGrammar matchedSubstring:' (82+-21)'
analyseGrammar capturedMatchs: ' ' '(82+-21)' ''
analyseGrammar index: '0'
cummulativeEvaluable=3-4*(4/6),2+( )-9,(82+-21)