javascript - 函数有效，现在 RangeError

Question

为什么我收到RangeError:超出最大调用堆栈错误？我正在尝试解析文本以找到数学并解决它。它一直有效，直到我开始实现括号'。我试图找出错误，但就是无法弄清楚。

我的代码:

var alg = {
        calc: function(eq, solveFor) {
            var out;
            var sideOne = eq.substring(0, eq.indexOf('='))
            var sideTwo = eq.substring(eq.indexOf('=') + 1)
            if (sideOne === solveFor) {
                alg.simplify(sideTwo);
            }
            if (sideTwo === solveFor) {
                alg.simplify(sideOne);
            }
        },
        simplify: function(eq) {
            str = $.trim(eq);
            if (str == undefined) {
                console.error('Error: null string')
            } else {
                var charMatch = /^[\d\*\/\+\-\^\(\) ]+$/
                if (charMatch.exec(str) === null) {
                    console.error('Error: Invalid char/expression')
                } else {
                    alg.parMath('not');
                    alg.expRoot(solve);
                    alg.multDiv(solve);
                    alg.addSubtr(solve);
                }
            }
        },
        fromPar: function(par) {
            alg.parMath(par);
            alg.expRoot(solve);
            alg.multDiv(solve);
            alg.addSubtr(solve);
        },
        parMath: function(source) {
            var reP = /\(([\d\*\/\+\-\^\(\) ]+)\)/
            var exP = reP.exec(str)
            if (source === 'par') {
                str = str.replace(exP[0], solve)
            }
            if (exP !== null) {
                use = 'par'
                solve = exP[1]
            } else {
                use = 'not'
                solve = str;
            }
        },
        expRoot: function() {
            var fracCon = /(\d+)\/(\d+)/
            var reER = /(\d+)(\^)(\d+(\/\d)?)(?!\/)/
            var exER = reER.exec(solve)
            if (exER !== null) {
                var exFC = fracCon.exec(exER[3])
                if (exFC !== null) {
                    var rep = Math.pow(parseFloat(exER[1]),(parseFloat(exFC[1]) / parseFloat(exFC[2])))
                } else {
                    var rep = Math.pow(parseFloat(exER[1]),parseFloat(exER[3]))
                }
                solve = solve.replace(exER[0], rep)
                if (reER.exec(solve) !== null) {
                    alg.expRoot();
                }
            }
        },
        multDiv: function() {
            var reMD = /(\d+(?:\.\d+)?) *([\*|\/]) *(\d+(?:\.\d+)?)/
            var exMD = reMD.exec(solve);
            if (exMD !== null) {
                if (exMD[2] === "*") {
                    var rep = parseFloat(exMD[1]) * parseFloat(exMD[3]);
                    var rep = Math.round(rep * 1000000) / 1000000;
                } else {
                    var rep = parseFloat(exMD[1]) / parseFloat(exMD[3]);
                    var rep = Math.round(rep * 1000000) / 1000000;
                }
                if (use !== 'par') {
                    solve = solve.replace(exMD[0], rep);
                }
                if (reMD.exec(solve) !== null) {
                    alg.multDiv();
                }
            }
        },
        addSubtr: function() {
            var reAS = /(\d+(?:\.\d+)?) *([\+|\-]) *(\d+(?:\.\d+)?)/
            var exAS = reAS.exec(solve); //Getting RangeError here
            if (exAS !== null) {
                if (exAS[2] === "+") {
                    var rep = parseFloat(exAS[1]) + parseFloat(exAS[3])
                    var rep = Math.round(rep * 1000000) / 1000000
                } else {
                    var rep = parseFloat(exAS[1]) - parseFloat(exAS[3])
                    var rep = Math.round(rep * 1000000) / 1000000
                }
                if (use !== 'par') {
                    str = str.replace(exAS[0], rep)
                }
                if (exAS !== null) {
                    alg.addSubtr(solve);
                } else {
                    if (use == 'not') {
                        out = solve;
                    } else {
                        alg.fromPar('par')
                    }
                }
            } else {
                if (use == 'not') {
                    out = solve;
                } else {
                    alg.fromPar('par')
                }
            }
        }
    
    };
    
    console.log(alg.calc('x=(1+1)', "x"));

<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script>

我在 addSubtr 函数开始时收到错误(由注释标记)。谁能帮我找到如何修复该错误？

Answer 1

问题是您的代码进入无限循环。这是逻辑的相关部分

addSubtr: function() {
    /* ommitted */
    var exAS = reAS.exec(solve); //Getting RangeError here
    if (exAS !== null) {
        /* ommitted - logic here*/
        if (exAS !== null) {
          alg.addSubtr(solve);
          /* ommitted */
        }
    }
}

1. 您可以通过正则表达式解析 solve 来获取 exAS 的值。
2. 如果返回非空值，则表示您获得了匹配
3. 有了这只母鸡，您可以进入 if 条件并执行一些逻辑
4. 仍然在那里，还有另一个 if 语句，用于检查正则表达式是否匹配任何内容。现在，根据定义，这是正确的 - 通过删除大量代码可以很容易地看出 - 相同的条件被检查两次。没有什么可以改变两个 if 之间的结果。
5. 由于条件检查通过，您可以使用相同的输入再次递归调用相同的函数。

由于输入相同，逻辑将相同，因此会再次执行步骤 1-5 并再次调用该函数。

这会导致无限递归。事实上，JavaScript 的堆栈大小是有限制的，这就是您收到错误的原因。这有点误导，因为它是在调用堆栈大小上运行的正则表达式，而不是对 addSubtr 的递归调用，否则会更清楚发生了什么。

对于如何修复它 - 您需要重新构建逻辑，这样就不会陷入无限循环。我不确定最适合您的情况的方法是什么，但我建议您自己解决 - 无论如何，这将是一个有用的练习。这里有一些提示

在我提出的第4. 点中，我提到有一项本质上无用的检查。我认为它应该是有用的。 - 您可能希望内部 if 位于外部的外部。就目前而言，两者是等效的，因此可以删除内部 if。
- 也许内部 if 的条件不正确 - 可能您只是有时想要执行递归调用，而不是每次都执行。 - 也许应该有一些东西可以改变 exAS 或 solve 或两者。因此，要么条件在第二次检查时(可能)产生不同的结果，要么函数在递归调用时产生不同的结果(这将使递归调用有用)，或者两者兼而有之。