将数学表达式与正则表达式匹配？

Question

例如，这些是有效的数学表达式：

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

匹配浮点数没有问题，但括号匹配有困难。任何的想法？如果有比正则表达式更好的解决方案，我也会接受。但首选正则表达式。

========

编辑：

我想对我对“已接受的答案”的选择做一些cmet，希望有相同问题并找到这个帖子的人不会被误导。

有几个我认为“接受”的答案，但我不知道哪个是最好的。所以我（几乎）随机选择了接受的答案。除了公认的答案外，我还建议阅读 Guillaume Malartre 的答案。他们都为我的问题提供了切实可行的解决方案。对于有些严格/理论的答案，请阅读 David Thornley 在接受的答案下的 cmets。正如他所提到的，Perl 对正则表达式的扩展（源自正则语言）使其“不规则”。 （我在我的问题中没有提到任何语言，所以大多数回答者都假设正则表达式的 Perl 实现——可能是最流行的实现。当我发布我的问题时我也是如此。）

如果我在上面说错了，请纠正我。

Answer 1

使用下推自动机匹配括号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(')

甚至很简单：只保留一个计数器而不是堆栈。

Answer 2

正则表达式只能用于识别正则语言。数学表达式的语言不规则；您需要实现一个实际的解析器（例如 LR）才能执行此操作。

Answer 3

用正则表达式匹配括号是很有可能的。

这是一个 Perl 脚本，它将解析任意深度匹配括号。虽然它会抛出不匹配的括号，但我并没有专门设计它来验证括号。只要它们是平衡的，它就会解析任意深度的括号。但是，这将帮助您入门。

关键在于正则表达式及其使用中的递归。玩它，我相信你也可以用它来标记不匹配的 prens。我认为，如果您捕获此正则表达式丢弃的内容并计算括号（即测试不匹配文本中的奇数括号），您将获得无效、不平衡的括号。

#!/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)

Answer 4

我相信你最好实现一个真正的解析器来完成你所追求的。

简单数学表达式的解析器是“Parsing 101”，网上有几个例子可以找到。

一些例子包括：

• ANTLR: Expression Evaluator Sample（ANTLR 语法可以针对多种语言）
• pyparsing:http://pyparsing.wikispaces.com/file/view/fourFn.py（pyparsing 是一个 Python 库）
• Lex 和 Yacc：http://epaperpress.com/lexandyacc/（包含 PDF 教程和计算器示例代码）

请注意，验证表达式所需的语法比上面的示例更简单，因为这些示例还实现了表达式的求值。

Answer 5

你不能使用正则表达式来做平衡括号之类的事情。

Answer 6

这对于单个正则表达式很棘手，但使用混合正则表达式/过程方法很容易。这个想法是为简单表达式（不带括号）构造一个正则表达式，然后用一些原子字符串（例如标识符）重复替换( 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";

上面只验证语法，但同样的技术也可以用来构造一个真正的解析器。

Answer 7

对于括号匹配和实现其他表达式验证规则，编写自己的小解析器可能是最简单的。正则表达式在这种情况下不好用。

Answer 8

好的，这是我在 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)