用JavaScript实现支持科学计算的数学公式运算类

其实就是之前写的Java版翻译成js的，用法和之前的一样。

传送门

通过对现有的后序表达式计算方法，经过稍许改动实现支持科学计算

废话不多说，直接上代码

计算类代码如下：

import { cloneDeep } from "lodash";

var Calculation = function () {
  var PiChange = function(ss) {// π转换
    var aa2 = cloneDeep(ss);
    var ssLast = ss.lastIndexOf('π');
    if (ssLast >= 0) {
      if (ssLast != 0 && ss.charAt(ssLast - 1) >= '0' && ss.charAt(ssLast - 1) <= '9') {// π不在首位并且前面一位是数字
        aa2 = changeStr(ss,ssLast,'*'+Math.PI);
      } else {
        aa2 = changeStr(ss,ssLast,''+Math.PI);
      }
      while (aa2.lastIndexOf('π') >= 0) {
        aa2 = PiChange(aa2);
      }
    }
    return aa2;
  };

  var EChange = function(ss) {// π转换
    var aa2 = cloneDeep(ss);
    var ssLast = ss.lastIndexOf('е');
    if (ssLast >= 0) {
      if (ssLast != 0 && ss.charAt(ssLast - 1) >= '0' && ss.charAt(ssLast - 1) <= '9') {// π不在首位并且前面一位是数字
        aa2 = changeStr(ss,ssLast,'*'+Math.E);
      } else {
        aa2 = changeStr(ss,ssLast,''+Math.E);
      }
      while (aa2.lastIndexOf('е') >= 0) {
        aa2 = EChange(aa2);
      }
    }
    return aa2;
  };

  var getOpLevel = function (op) {
    if (op === "+" || op === "-") {
      return 0;
    } else if (op === "*" || op === "/" || op === "%") {
      return 1;
    } else if (op === "g" || op === "L" || op === "G" || op === "S" || op === "C" || op === "T"
        || op === "i" || op === "c" || op === "t" || op === "o" || op === "e" || op === "s"
        || op === "!") {
      return 2;
    } else if (op === "√" || op === "°" || op === "^") {
      return 3;
    } else if (op === "f") {
      return 4;
    }
    return -1;
  }

  var getN = function(n) {// 计算阶乘的方法
    if (n == 0)
      return 1;
    var sum = 1.0;
    for (var s = 1; s <= n; s++) {
      sum *= s;
    }
    return sum;
  }

  var changeStr = function(str,index,changeStr){
    return str.substr(0, index) + changeStr+ str.substr(index + 1);
  };

  this.Parser = function(expression) {
    var list = [];// 用于存储表达式的链表
    expression = PiChange(expression);// 处理π
    expression = EChange(expression);// 处理e

    // 判断负数，并将-号转换为负数符号
    if (expression.charAt(0) === '-') {
      expression = 'f' + expression.slice(1);
    }
    // 将符号值转化为计算代号
    var newExperssion = expression.replace(new RegExp('lg','g'), 'G');
    newExperssion = newExperssion.replace(new RegExp('log','g'), 'g');
    newExperssion = newExperssion.replace(new RegExp('ln','g'), 'L');
    newExperssion = newExperssion.replace(new RegExp('sin','g'), 'S');
    newExperssion = newExperssion.replace(new RegExp('cos','g'), 'C');
    newExperssion = newExperssion.replace(new RegExp('tan','g'), 'T');
    newExperssion = newExperssion.replace(new RegExp('arcSin','g'), 'i');
    newExperssion = newExperssion.replace(new RegExp('arcCos','g'), 'c');
    newExperssion = newExperssion.replace(new RegExp('arcTan','g'), 't');
    newExperssion = newExperssion.replace(new RegExp('cot','g'), 'o');
    newExperssion = newExperssion.replace(new RegExp('sec','g'), 'e');
    newExperssion = newExperssion.replace(new RegExp('csc','g'), 's');
    newExperssion = newExperssion.replace(new RegExp('!','g'), '!1');
    newExperssion = newExperssion.replace(new RegExp('°','g'), '°1');
    newExperssion = newExperssion.replace(/\(-/g, '(f');
    // 取出表达式中的空格符号
    newExperssion = newExperssion.replace(/\s+/g,"");

    var str = '';
    for (var i = 0; i < newExperssion.length; i++) {
      var c = newExperssion.charAt(i);

      if ((c>= '0' && c<='9') || c == '.') {
        str += c;
      } else {
        if (str.length > 0) {// 此判断是因为有+(这种符号相连的情况
          list.push(str);
          str = '';
        }
        list.push(c);
      }
    }

    if (str.length > 0) {// 此判断是因为可能表达式不是以=结尾
      list.push(str);
      str = '';
    }
    return list;
  }

  this.Trans = function(list) {
    var stack = [];// 用于存储操作符的栈
    var postfixList = [];// 用于存储后序表达式的链表
    for (var i = 0; i<list.length;i++) {
      var str = list[i];
      // 这个分支是当前项是操作符号的情况
      if (str === "+" || str === "-" || str === "*" || str === "/" || str === "%" || str === "("
          || str === ")" || str === "g" || str === "L" || str === "G" || str === "S"
          || str === "C" || str === "T" || str === "i" || str === "c" || str === "t"
          || str === "o" || str === "e" || str === "s" || str === "!" || str === "f"
          || str === "√" || str === "°" || str === "^") {
        var opThis = cloneDeep(str);
        if (stack.length == 0) {
          // 如果栈为空，直接把操作符推入栈
          stack.push(opThis);
        } else if (str === "(") {
          // 如果操作符是左括号，直接推入栈
          stack.push(opThis);
        } else if (str === ")") {
          // 如果操作符是右括号，则往前找左括号，将左括号之后的操作符放到后续表达式列表中

          while (stack[stack.length-1] !== "(") { // stack.peek()是取栈顶元素而不弹出
            postfixList.push(stack.pop());
          }
          stack.pop();// 左括号丢弃，由此完成了去括号的过程
        } else {
          // 看栈顶元素，如果它优先级大于等于当前操作符的优先级，则弹出放到后续表达式列表中
          while (stack.length > 0 && (getOpLevel(stack[stack.length-1]) >= getOpLevel(opThis))) {
            postfixList.push(stack.pop());
          }
          stack.push(opThis);// 当前操作符入栈
        }
      } else {
        // 这个分支是当前项是操作数的情况
        postfixList.push(str);// 操作数直接入栈
      }
    }
    // 将栈中余下的操作符弹出放到后续表达式列表中
    while (stack.length > 0) {
      var opTop = cloneDeep(stack.pop());
      postfixList.push(opTop);
    }
    return postfixList;
  }

  this.Calculator = function (list) {
    var stack = [];
    for (var i = 0; i<list.length;i++) {// 遍历
      var str = list[i];
      // 这个分支是当前项是操作符号的情况
      if (str === "+" || str === "-" || str === "*" || str === "/" || str === "%" || str === "("
          || str === ")" || str === "g" || str === "L" || str === "G" || str === "S"
          || str === "C" || str === "T" || str === "i" || str === "c" || str === "t"
          || str === "o" || str === "e" || str === "s" || str === "!" || str === "f"
          || str === "√" || str === "°" || str === "^") {
        var result = 0;
        if (str === "+") {
          var op2 = Number(stack.pop());
          var op1 = Number(stack.pop());
          result = op1 + op2;
        } else if (str === "-") {
          var op2 = Number(stack.pop());
          var op1 = Number(stack.pop());
          result = op1 - op2;
        } else if (str === "*") {
          var op2 = Number(stack.pop());
          var op1 = Number(stack.pop());
          result = op1 * op2;
        } else if (str === "/") {
          var op2 = Number(stack.pop());
          var op1 = Number(stack.pop());
          result = op1 / op2;
        } else if (str === "%") {
          var op2 = Number(stack.pop());
          var op1 = Number(stack.pop());
          result = op1 % op2;
        } else if (str === "f") {// 负数符号
          var op = Number(stack.pop());
          result = -1 * op;
        } else if (str === "g") {// log
          var op2 = Number(stack.pop());
          var op1 = Number(stack.pop());
          if (op1 <= 0) {
            return "对数log的操作数须大于零";
          }
          if (op2 <= 0) {
            return "对数log的操作数须大于零";
          }
          result = Math.log(op2) / Math.log(op1);
        } else if (str === "L") {// ln
          var op = Number(stack.pop());
          if (op <= 0) {
            return "对数ln的操作数须大于零";
          }
          result = Math.log(op);
        } else if (str === "G") {// lg
          var op = Number(stack.pop());
          if (op <= 0) {
            return "对数lg的操作数须大于零";
          }
          result = Math.log10(op);
        } else if (str === "S") {// sin
          var op = Number(stack.pop());
          result = Math.sin(op);
        } else if (str === "C") {// cos
          var op = Number(stack.pop());
          result = Math.cos(op);
        } else if (str === "T") {// tan
          var op = Number(stack.pop());
          if (Math.abs(op % Math.PI * 2) == 1) {
            return "tan取值有错误";
          }
          result = Math.tan(op);
        } else if (str === "i") {// arcsin
          var op = Number(stack.pop());
          if (op > 1 || op < (-1)) {
            return "arcSin的取值有错误";
          } else {
            result = Math.asin(op);
          }
        } else if (str === "c") {// arccos
          var op = Number(stack.pop());
          if (op > 1 || op < (-1)) {
            return "arcCos的取值有错误";
          } else {
            result = Math.acos(op);
          }
        } else if (str === "t") {// arctan
          var op = Number(stack.pop());
          result = Math.atan(op);
        } else if (str === "o") {// cot
          var op = Number(stack.pop());
          // 角度
          var so = Math.sin(op);
          var co = Math.cos(op);
          result = co / so;
        } else if (str === "e") {// sec
          var op = Number(stack.pop());
          var ec = Math.cos(op);
          if (ec == 0) {
            return "sec取值有错误";
          } else {
            result = 1 / ec;
          }
        } else if (str === "s") {// csc
          var op = Number(stack.pop());
          var ss = Math.sin(op);
          if (ss == 0) {
            return "csc取值有错误";
          } else {
            result = 1 / ss;
          }
        } else if (str === "!") {// 阶乘
          stack.pop();
          var op1 = Number(stack.pop());
          if (op1 < 0) {
            return "阶乘数有误";
          }
          result = getN(op1);
        } else if (str === "√") {// 开方
          var op2 = Number(stack.pop());
          var op1 = Number(stack.pop());
          // 负值不能开偶次方
          if ((op2 < 0 && op1 % 2 == 0 || op1 == 0)) {
            return "负数不能开偶次方！";
          }
          if (op2 < 0) {
            result = -Math.pow(-op2, 1 / op1);
          } else {
            result = Math.pow(op2, 1 / op1);
          }
        } else if (str === "°") {// 角度制转弧度制
          stack.pop();
          var op1 = Number(stack.pop());
          result = (op1) * Math.PI / 180;
        } else if (str === "^") {// 幂
          var op2 = Number(stack.pop());
          var op1 = Number(stack.pop());
          if (op2 > 0 && op2 < 1) {// 幂次数大于零小于1，是开方操作
            if (op1 < 0 && ((1 / op2) % 2 == 0)) {
              return "负数不能开偶次方！";
            }
            if (op1 < 0) {
              result = -Math.pow(-op1, op2);
            }
          } else {
            result = Math.pow(op1, op2);
          }
        }

        stack.push(result.toString());
      } else {
        // 如果是操作数先直接入栈
        stack.push(str);
      }
    }
    // 取得结果
    return stack[stack.length-1];
  }
};
export default Calculation;

注意

该方法用到了lodash的cloneDeep拷贝方法