在javascript中使用数学方程拆分变量

实际上我有两个问题。 我想做的是首先检查用户输入的值是否是正确的数学公式。例如，如果用户输入

x+y（z

，则应将其检测为无效公式，并将

x+y（z）

检测为正确公式

我想做的第二件事是从

+-*/（）

符号中分割公式，这样上面的公式将作为

x，y，z

返回

我所做的就是吼叫

var arr = [];

var s = 'x + y ( z )';

arr = s.split("(?<=[-+*/])|(?=[-+*/])");

console.log(arr);

var arr=[]；
var s='x+y（z）'；
arr=s.split（“（？对于第二部分：


var s='x+y（z）'；
var arr=s.match（/（\w）/g）；
控制台日志（arr）；
document.write（JSON.stringify（arr））；
第二部分：


var s='x+y（z）'；
var arr=s.match（/（\w）/g）；
控制台日志（arr）；
document.write（JSON.stringify（arr））；
警告之词
前面的方法非常非常危险

我之所以发布这篇文章，是因为这是一个有效的答案，但你必须非常小心，因为用户可能会完全搞乱你的网站。

不要让一个用户输入用于另一个用户的评估！！！永远！！！

实际答案
您可以使用浏览器的内置java脚本编译器，并使用
eval（）


正如我之前提到的！极度小心！
警告之词
前面的方法非常非常危险

我之所以发布这篇文章，是因为这是一个有效的答案，但你必须非常小心，因为用户可能会完全搞乱你的网站。

不要让一个用户输入用于另一个用户的评估！！！永远！！！

实际答案
您可以使用浏览器的内置java脚本编译器，并使用
eval（）


正如我之前提到的！非常小心！
使用@ShanShan和@Tomer W答案，我编写了一个公式验证器。代码如下。在这个验证器中，我检查是否有开始和结束括号、额外的/*-+符号、不需要的符号等

如果用户希望创建并验证具有x、y、z的公式
变量，用户必须将变量添加到数组并将其传递给
此验证器具有编写的公式，因此验证器接受
不是数字的变量

我还使用了本文中提到的自定义集

重要提示：此java脚本函数无法验证包含sin、cos、tan、log等的非常复杂的公式。脚本将它们标识为字母，并返回false。

function StringSet() {
    var setObj = {}, val = {};

    this.add = function(str) {
        setObj[str] = val;
    };

    this.contains = function(str) {
        return setObj[str] === val;
    };

    this.remove = function(str) {
        delete setObj[str];
    };

    this.values = function() {
        var values = [];
        for ( var i in setObj) {
            if (setObj[i] === val) {
                values.push(i);
            }
        }
        return values;
    };
}

/**
 * 
 * @param _formulaInputs
 *            Array of use entered inputs to be use in formula
 * @param _formula
 *            User entered formula
 * @returns {Boolean}
 */
function validateFormula(_formulaInputs, _formula) {

    var formula = _formula;

    var bracketStack = new Array();

    var formulaDescArray = [];

    var formulaDescInForm = new StringSet();

    for (var i = 0; i < _formulaInputs.length; i++) {

        formulaDescInForm.add(_formulaInputs[i]);
    }

    /* Regex to check for unwanted symbols(! @ # $ etc.) */
    if (/[^\w\d\(\)\+\*\/\-\s]/.exec(formula) != null) {
        return false;
    }

   for (var i = 0; i < _formula.length; i++) {
            if ((_formula.charAt(i) == '/' || _formula.charAt(i) == '*'
                    || _formula.charAt(i) == '-' || _formula.charAt(i) ==   '+')
                    && (_formula.charAt(i + 1) == '/'
                            || _formula.charAt(i + 1) == '*'
                            || _formula.charAt(i + 1) == '-' || _formula
                            .charAt(i + 1) == '+')) {
                return false;
            }
    }

    var lastChar = formula.charAt(formula.length - 1);

    if (lastChar == '/' || lastChar == '*' || lastChar == '-'
            || lastChar == '+') {
        return false;
    }

    formulaDescArray = formula.split(/[\/\*\-\+\()]/g);

    /* Remove unwanted "" */
    for (var i = 0; i < formulaDescArray.length; i++) {
        if (formulaDescArray[i].trim().length == 0) {
            formulaDescArray.splice(i, 1);
            i--;
        }
    }

    /* Remove unwanted numbers */
    for (var i = 0; i < formulaDescArray.length; i++) {

        if (!isNaN(formulaDescArray[i])) {
            formulaDescArray.splice(i, 1);
            i--;
        }
    }

    for (var i = 0; i < formulaDescArray.length; i++) {
        if (!formulaDescInForm.contains(formulaDescArray[i].trim())) {
            return false;
        }
    }

    for (var i = 0; i < formula.length; i++) {
        if (formula.charAt(i) == '(') {
            bracketStack.push(formula.charAt(i));
        } else if (formula.charAt(i) == ')') {
            bracketStack.pop();
        }
    }

    if (bracketStack.length != 0) {
        return false;
    }

    return true;

}

函数StringSet（）{
var setObj={}，val={}；
this.add=函数（str）{
setObj[str]=val；
};
this.contains=函数（str）{
返回setObj[str]==val；
};
this.remove=函数（str）{
删除setObj[str]；
};
this.values=函数（）{
var值=[]；
用于（setObj中的var i）{
if（setObj[i]==val）{
价值观。推动（i）；
}
}
返回值；
};
}
/**
* 
*@param\u公式输入
*要在公式中使用的使用输入的数组
*@param\u公式
*用户输入的公式
*@returns{Boolean}
*/
函数validateFormula（_formulaInputs，_formula）{
var公式=_公式；
var bracketStack=新数组（）；
var formulaDescArray=[]；
var formulaDescInForm=新StringSet（）；
对于（var i=0；i<\u formulaInputs.length；i++）{
添加（_formulaInputs[i]）；
}
/*正则表达式检查不需要的符号（！@#$等）*/
如果（/[^\w\d\（\）\+\*\/\-\s]/.exec（公式）！=null）{
返回false；
}
对于（变量i=0；i<\u公式长度；i++）{
如果（_formula.charAt（i）='/'| | | u formula.charAt（i）='*'
||| | | | u公式.字符（i）='-'| | u公式.字符（i）='+'）
&&（_公式.字符（i+1）=='/'
||_公式.字符（i+1）='*'
|||公式.字符（i+1）='-'| | |公式
.charAt（i+1）='+'））{
返回false；
}
}
var lastChar=formula.charAt（formula.length-1）；
如果（lastChar='/'| | lastChar='*'| | lastChar=='-'
||lastChar=='+'）{
返回false；
}
formulaDescArray=formula.split（/[\/\*\-\+\（）]/g）；
/*删除不需要的“”*/
对于（var i=0；i
使用@ShanShan和@Tomer W答案，我编写了一个公式验证器。代码如下。在这个验证器中，我检查是否有开始和结束括号、额外的/*-+符号、不需要的符号等

如果用户希望创建并验证具有x、y、z的公式
变量，用户必须将变量添加到数组并将其传递给
此验证器具有编写的公式，因此验证器接受
不是数字的变量

我还使用了本文中提到的自定义集

重要提示：此java脚本函数无法验证包含sin、cos、tan、log等的非常复杂的公式。脚本将它们标识为字母，并返回false。

function StringSet() {
    var setObj = {}, val = {};

    this.add = function(str) {
        setObj[str] = val;
    };

    this.contains = function(str) {
        return setObj[str] === val;
    };

    this.remove = function(str) {
        delete setObj[str];
    };

    this.values = function() {
        var values = [];
        for ( var i in setObj) {
            if (setObj[i] === val) {
                values.push(i);
            }
        }
        return values;
    };
}

/**
 * 
 * @param _formulaInputs
 *            Array of use entered inputs to be use in formula
 * @param _formula
 *            User entered formula
 * @returns {Boolean}
 */
function validateFormula(_formulaInputs, _formula) {

    var formula = _formula;

    var bracketStack = new Array();

    var formulaDescArray = [];

    var formulaDescInForm = new StringSet();

    for (var i = 0; i < _formulaInputs.length; i++) {

        formulaDescInForm.add(_formulaInputs[i]);
    }

    /* Regex to check for unwanted symbols(! @ # $ etc.) */
    if (/[^\w\d\(\)\+\*\/\-\s]/.exec(formula) != null) {
        return false;
    }

   for (var i = 0; i < _formula.length; i++) {
            if ((_formula.charAt(i) == '/' || _formula.charAt(i) == '*'
                    || _formula.charAt(i) == '-' || _formula.charAt(i) ==   '+')
                    && (_formula.charAt(i + 1) == '/'
                            || _formula.charAt(i + 1) == '*'
                            || _formula.charAt(i + 1) == '-' || _formula
                            .charAt(i + 1) == '+')) {
                return false;
            }
    }

    var lastChar = formula.charAt(formula.length - 1);

    if (lastChar == '/' || lastChar == '*' || lastChar == '-'
            || lastChar == '+') {
        return false;
    }

    formulaDescArray = formula.split(/[\/\*\-\+\()]/g);

    /* Remove unwanted "" */
    for (var i = 0; i < formulaDescArray.length; i++) {
        if (formulaDescArray[i].trim().length == 0) {
            formulaDescArray.splice(i, 1);
            i--;
        }
    }

    /* Remove unwanted numbers */
    for (var i = 0; i < formulaDescArray.length; i++) {

        if (!isNaN(formulaDescArray[i])) {
            formulaDescArray.splice(i, 1);
            i--;
        }
    }

    for (var i = 0; i < formulaDescArray.length; i++) {
        if (!formulaDescInForm.contains(formulaDescArray[i].trim())) {
            return false;
        }
    }

    for (var i = 0; i < formula.length; i++) {
        if (formula.charAt(i) == '(') {
            bracketStack.push(formula.charAt(i));
        } else if (formula.charAt(i) == ')') {
            bracketStack.pop();
        }
    }

    if (bracketStack.length != 0) {
        return false;
    }

    return true;

}

函数