flex/as 版 eval 字符串　四则混合　运算　

最新推荐文章于 2022-12-11 18:08:36 发布

deeplyloving

最新推荐文章于 2022-12-11 18:08:36 发布

阅读量131

点赞数

本文链接：https://blog.csdn.net/deeplyloving/article/details/84187189

版权

1.传入一个带四则运算的字符串。（如：var a:String = "2*(4-3.001)+3.5";）.

2.返回值为被解析后四则运算出来的结果值。

    package com.zzz  
    {  
        public class MathExpress  
        {  
            public function MathExpress()  
            {  
            }  
            public static function MathExpressByStr(str:String):String{  
                str = "(" + str.replace(/[^\d.+-*\/()]+/g,"") + ")";  
                while (/\([^()]*\)/.test(str)){  
                    str = str.replace(/\(([^()]*)\)/g,function(s, b){  
                        while (/[*\/]/.test(b)){  
                            b = b.replace(/([\d.]+)([*\/])([\d.]+)/g,function(c, m, l, n){  
                                var i:Number = parseFloat(m);  
                                var j:Number = parseFloat(n);  
                                return l=="*" ? i*j : i/j;  
                            })  
                        }  
                        while (/[+-]/.test(b)){  
                            b = b.replace(/([\d.]+)([+-])([\d.]+)/g,function(c, m, l, n){  
                                var i:Number = parseFloat(m);  
                                var j:Number = parseFloat(n);  
                                return l=="+" ? i+j : i-j;  
                            })  
                        }  
                        return b;  
                    })  
                }  
                return str;  
            }     
        }  
    }

3.得最后结果：7.498

转至:http://blog.csdn.net/zzz_robinson/article/details/7239829

private function evalString(infix:String):String{  
                var opArray:Array = new Array();  
                  
                //栈底标记  
                opArray[0] = '@';  
                var op:Number = 1;  
                var postfix:Array = new Array();  
                var post:Number = 0;  
                  
                //保存计算结果  
                var res:Number = 0;  
                  
                var i, j;  
                var tempString:String = new String();  
                  
                //计算两个数  
                function Caculate(opSign:String) {  
                    if (opSign == '+') {  
                        res = postfix[post-2]+postfix[post-1];  
                    } else if (opSign == '-') {  
                        res = postfix[post-2]-postfix[post-1];  
                    } else if (opSign == '*') {  
                        res = postfix[post-2]*postfix[post-1];  
                    } else if (opSign == '/') {  
                        if (!postfix[post-1]) {  
                            trace("Expression Error!");  
                        } else {  
                            res = postfix[post-2]/postfix[post-1];  
                        }  
                    }  
                    postfix[post-1] = 0;  
                    postfix[post-2] = res;  
                    post--;  
                }  
                  
                //扫描中缀表达式  
                for (i=0; i<infix.length; i++) {  
                    switch (infix.charAt(i)) {  
                        //左括号就直接入栈  
                        case '(' :  
                            opArray[op] = infix.charAt(i);  
                            op++;  
                            break;  
                        //右括号则退栈计算，直到遇见一个左括号  
                        case ')' :  
                            for (j=op-1; j>0; j--) {  
                                if (opArray[j] != '(') {  
                                    Caculate(opArray[j]);  
                                    opArray[j] = '#';  
                                } else {  
                                    opArray[j] = '#';  
                                    break;  
                                }  
                            }  
                            op = j;  
                            break;  
                        case '*' :  
                        case '/' :  
                            //如果栈顶的运算符为*或/，则先退栈，再入栈，否则直接入栈   
                            if (opArray[op-1] == '*') {  
                                op--;  
                                Caculate(opArray[op]);  
                                opArray[op] = '#';  
                            } else if (opArray[op-1] == '/') {  
                                op--;  
                                Caculate(opArray[op]);  
                                opArray[op] = '#';  
                            }  
                            opArray[op] = infix.charAt(i);  
                            op++;  
                            break;  
                        case '+' :  
                        case '-' :  
                            //如果栈顶的运算符不是左括号也不是栈底，则先退栈计算，再入栈   
                            if (opArray[op-1] != '(' && opArray[op-1] != '@') {  
                                op--;  
                                Caculate(opArray[op]);  
                                opArray[op] = '#';  
                            }  
                            opArray[op] = infix.charAt(i);  
                            op++;  
                            break;  
                        default :  
                            //如果是数字字符或者小数点则转化为数字存入数组  
                            //如果下一个字符是运算符则把当前数字存入数组  
                            tempString += infix.charAt(i);  
                            var temp:String = new String();  
                            temp = infix.charAt(i+1);  
                            if (temp != '.' && (temp>'9' || temp<'0')) {  
                                postfix[post] = parseFloat(tempString);  
                                post++;  
                                tempString = "";  
                            }  
                            //trace(postfix);     
                    }  
                }  
                  
                //扫描完成，全部退栈  
                for (j=op-1; j>0; j--) {  
                    if (opArray[j] != '@') {  
                        Caculate(opArray[j]);  
                        opArray[j] = '#';  
                    } else {  
                        break;  
                    }  
                }  
                //返回结果  
                return postfix[0];  
            }

转至：http://blog.csdn.net/zzz_robinson/article/details/7311629