用JavaScript编写支持括号优先级的科学计算器逻辑

作者:闭包旅人

时间:2026-11-22

浏览:308

本文详细讲解如何使用原生JavaScript编写具备完整括号优先级支持与科学函数运算的计算器核心逻辑。通过词法分析分词、Dijkstra调度场算法以及后缀表达式(RPN)栈式求值,彻底摆脱不安全的eval,提供安全、精准且易扩展的生产级实现。

文章目录
构建科学计算器的核心难点不在于基础加减乘除,而在于如何正确处理层层嵌套的括号、运算符的不同优先级、单目负号以及科学函数。本文将通过原生 JavaScript 实现经典的Dijkstra 调度场算法(Shunting-yard Algorithm),将人类可读的中缀数学表达式拆解转化为无括号的逆波兰后缀表达式(RPN),再由轻量求值栈计算出最终数值,全流程零外部依赖且杜绝 eval 带来的安全风险。
用JavaScript编写支持括号优先级的科学计算器逻辑
图 0:支持嵌套括号与科学运算的 JavaScript 计算器核心设计概览

为什么不能用简单的 eval 或正则替换

初学者在尝试编写计算器时,常会想到直接使用 JavaScript 的 eval() 函数或者 new Function(),例如把 "3+4*(2-1)" 传给引擎求值。这种做法在实际工程中有两个严重缺陷:

  • 安全性漏洞:eval() 会以当前上下文权限执行任意合法的 JavaScript 脚本。如果表达式来自用户输入(如网页输入框或接口数据),极易遭到代码注入和跨站脚本攻击(XSS)。
  • 数学语法与 JS 语法不兼容:科学计算器常见的记号与 JS 并不一致。例如乘方运算在计算器上通常是 ^(在 JS 中却是按位异或 XOR),数学中的三角函数 sin(30) 也无法直接被 JS 运行时识别,必须额外映射为 Math.sin。

另一种常见做法是用正则表达式不断匹配最内层的圆括号 \(([^()]+)\) 并进行逐步替换。这种方式虽然能应付简单算式,但一旦出现带负号的嵌套运算(如 (-2)^3)、连续前缀负号或多参数科学函数,正则状态机就会变得异常脆弱且难以调试。工业界成熟的解决途径是将数学表达式解析为后缀表达式(Reverse Polish Notation, RPN)或语法树进行计算。

用JavaScript编写支持括号优先级的科学计算器逻辑
图 1:科学计算器表达式处理流水线(词法分词 → 调度场转换 → 后缀求值)

整体解析架构:三层处理流水线

为了让计算器逻辑条理分明、具备良好的可测试性,我们将整个求值过程拆分为三个独立的纯函数模块:

  1. 词法分析(Tokenizer / Lexer):将原始字符串扫描成结构化的标记(Token)列表。在此步骤过滤无意义的空格,识别多位浮点数、操作符、括号以及科学函数名,并消解单目负号。
  2. 调度场转换(Shunting-Yard Parser):维护一个运算符临时栈和一个输出队列。遍历 Token 列表,依据各运算符的优先级和结合性,将中缀表达式重组为后缀表达式,同时消除所有括号。
  3. 后缀表达式求值器(RPN Evaluator):利用单个操作数栈,从左到右消费后缀序列。遇到数字则入栈,遇到运算符则弹出对应数量的操作数计算后将结果重新压栈,栈底最终留下的唯一数字即为最终答案。

第一步:词法分析与单目负号的精准判定

在编写解析器时,减号 - 是最容易引发歧义的符号。在算式 5 - 3 中,它是双目减法运算符;而在 -5、3 * -2 或 (-4 + 1) 中,它却代表单目求负运算(Unary Minus)。

判断当前 - 究竟是负号还是减号,只需要查看它前一个有效标记(Previous Token)的状态:

  • 如果前面没有任何标记(即位于表达式开头),或者前一个标记是运算符、左括号、逗号,那么该减号一定是单目负号,我们将其标记为专用的 u-。
  • 如果前面是数字或右括号,那么该减号是双目减号,标记为普通的二元运算符 -。
用JavaScript编写支持括号优先级的科学计算器逻辑
图 2:词法扫描器中减号与单目负号的状态判定决策流程

我们来看具体的词法分词器代码实现:

// 标记类型定义
const TokenType = {
  NUMBER: 'NUMBER',
  OPERATOR: 'OPERATOR',
  LPAREN: 'LPAREN',
  RPAREN: 'RPAREN',
  FUNCTION: 'FUNCTION',
  COMMA: 'COMMA'
};

// 词法分析器
function tokenize(expr) {
  const tokens = [];
  let i = 0;
  const len = expr.length;

  while (i < len) {
    const ch = expr[i];

    // 1. 跳过空白字符
    if (/\s/.test(ch)) {
      i++;
      continue;
    }

    // 2. 匹配数字(支持整数和小数)
    if (/[0-9.]/.test(ch)) {
      let numStr = '';
      while (i < len && /[0-9.]/.test(expr[i])) {
        numStr += expr[i];
        i++;
      }
      tokens.push({ type: TokenType.NUMBER, value: parseFloat(numStr) });
      continue;
    }

    // 3. 匹配函数名(如 sin, cos, tan, sqrt, ln, log, abs 等)
    if (/[a-zA-Z]/.test(ch)) {
      let funcName = '';
      while (i < len && /[a-zA-Z0-9]/.test(expr[i])) {
        funcName += expr[i];
        i++;
      }
      tokens.push({ type: TokenType.FUNCTION, value: funcName.toLowerCase() });
      continue;
    }

    // 4. 括号与逗号
    if (ch === '(') {
      tokens.push({ type: TokenType.LPAREN, value: '(' });
      i++;
      continue;
    }
    if (ch === ')') {
      tokens.push({ type: TokenType.RPAREN, value: ')' });
      i++;
      continue;
    }
    if (ch === ',') {
      tokens.push({ type: TokenType.COMMA, value: ',' });
      i++;
      continue;
    }

    // 5. 运算符与单目负号判定
    if (['+', '-', '*', '/', '%', '^'].includes(ch)) {
      if (ch === '-') {
        const prev = tokens[tokens.length - 1];
        const isUnary = !prev || 
          prev.type === TokenType.OPERATOR || 
          prev.type === TokenType.LPAREN || 
          prev.type === TokenType.COMMA;
        
        if (isUnary) {
          tokens.push({ type: TokenType.OPERATOR, value: 'u-' });
          i++;
          continue;
        }
      }
      tokens.push({ type: TokenType.OPERATOR, value: ch });
      i++;
      continue;
    }

    throw new Error(`无法识别的字符: "${ch}" 在位置 ${i}`);
  }

  return tokens;
}

第二步:优先级表与调度场算法

调度场算法由计算机科学家 Edsger Dijkstra 提出。其形象的比喻是一个火车编组调度场:车皮(数字)直接开往主轨道(输出队列),而机车(运算符)需要开进侧线岔道(运算符栈)等待;当新的运算符比岔道里的运算符优先级低时,岔道里的运算符必须先开出,以此保证执行次序。

运算符优先级与结合性规范

运算符 符号含义 优先级(数值越大越高) 结合性(Associativity)
+, - 加法、减法 1 左结合(从左往右求值)
*, /, % 乘法、除法、取模 2 左结合(从左往右求值)
^ 乘方(幂运算) 3 右结合(如 2^3^2 = 2^(3^2) = 512)
u- 单目求负(一元算符) 4 右结合(如 - - 5 = 5)
科学函数 sin, cos, sqrt 等 5 不适用(由括号封闭参数)
用JavaScript编写支持括号优先级的科学计算器逻辑
图 3:调度场算法处理包含括号表达式的单步推导与栈状态演变

中缀转后缀核心算法实现

在遇到左括号 ( 时,算法无条件将其推入运算符栈,标志着一个独立优先级层级的开始;在遇到右括号 ) 时,持续将栈顶运算符弹出到输出队列,直到找到对应的 ( 为止。如果栈全部弹空仍未找到 (,说明算式存在括号未闭合或多余右括号的语法错误。

// 运算符属性配置表
const OPERATORS = {
  '+':  { prec: 1, assoc: 'L', args: 2 },
  '-':  { prec: 1, assoc: 'L', args: 2 },
  '*':  { prec: 2, assoc: 'L', args: 2 },
  '/':  { prec: 2, assoc: 'L', args: 2 },
  '%':  { prec: 2, assoc: 'L', args: 2 },
  '^':  { prec: 3, assoc: 'R', args: 2 },
  'u-': { prec: 4, assoc: 'R', args: 1 }
};

function toRPN(tokens) {
  const outputQueue = [];
  const operatorStack = [];

  for (let token of tokens) {
    if (token.type === TokenType.NUMBER) {
      outputQueue.push(token);
    } else if (token.type === TokenType.FUNCTION) {
      operatorStack.push(token);
    } else if (token.type === TokenType.OPERATOR) {
      const o1 = token.value;
      const op1Meta = OPERATORS[o1];

      while (operatorStack.length > 0) {
        const top = operatorStack[operatorStack.length - 1];
        if (top.type === TokenType.LPAREN) break;

        if (top.type === TokenType.FUNCTION) {
          outputQueue.push(operatorStack.pop());
          continue;
        }

        if (top.type === TokenType.OPERATOR) {
          const o2 = top.value;
          const op2Meta = OPERATORS[o2];
          // 比较优先级与结合性
          if ((op1Meta.assoc === 'L' && op1Meta.prec <= op2Meta.prec) ||
              (op1Meta.assoc === 'R' && op1Meta.prec < op2Meta.prec)) {
            outputQueue.push(operatorStack.pop());
            continue;
          }
        }
        break;
      }
      operatorStack.push(token);
    } else if (token.type === TokenType.COMMA) {
      // 处理多参数函数的参数分隔符
      while (operatorStack.length > 0 &&
             operatorStack[operatorStack.length - 1].type !== TokenType.LPAREN) {
        outputQueue.push(operatorStack.pop());
      }
      if (operatorStack.length === 0) {
        throw new Error('逗号错位或缺少匹配的左括号');
      }
    } else if (token.type === TokenType.LPAREN) {
      operatorStack.push(token);
    } else if (token.type === TokenType.RPAREN) {
      let foundMatchingLparen = false;
      while (operatorStack.length > 0) {
        const top = operatorStack.pop();
        if (top.type === TokenType.LPAREN) {
          foundMatchingLparen = true;
          break;
        }
        outputQueue.push(top);
      }

      if (!foundMatchingLparen) {
        throw new Error('语法错误:存在不匹配的多余右括号 ")"');
      }

      // 若匹配到的左括号前紧跟函数名,将该函数也弹出至输出队列
      if (operatorStack.length > 0 &&
          operatorStack[operatorStack.length - 1].type === TokenType.FUNCTION) {
        outputQueue.push(operatorStack.pop());
      }
    }
  }

  // 将栈中剩余的运算符全部弹出到队列
  while (operatorStack.length > 0) {
    const top = operatorStack.pop();
    if (top.type === TokenType.LPAREN || top.type === TokenType.RPAREN) {
      throw new Error('语法错误:存在未闭合的左括号 "("');
    }
    outputQueue.push(top);
  }

  return outputQueue;
}

第三步:后缀表达式(RPN)数值求值

经过调度场转化后的后缀表达式彻底剥离了括号,原本复杂的优先级结构已经通过标记的排列顺序完全隐式表达。求值引擎仅需要一个数值栈,时间复杂度严格为 O(N):

// 支持的科学函数映射表
const MATH_FUNCTIONS = {
  sin: Math.sin,
  cos: Math.cos,
  tan: Math.tan,
  asin: Math.asin,
  acos: Math.acos,
  atan: Math.atan,
  sqrt: Math.sqrt,
  cbrt: Math.cbrt,
  abs: Math.abs,
  ln: Math.log,
  log: Math.log10,
  exp: Math.exp
};

function evaluateRPN(rpnTokens) {
  const evalStack = [];

  for (let token of rpnTokens) {
    if (token.type === TokenType.NUMBER) {
      evalStack.push(token.value);
    } else if (token.type === TokenType.OPERATOR) {
      const op = token.value;
      const meta = OPERATORS[op];

      if (evalStack.length < meta.args) {
        throw new Error(`表达式语法错误:运算符 "${op}" 缺少操作数`);
      }

      if (meta.args === 1) {
        // 单目负号
        const val = evalStack.pop();
        evalStack.push(-val);
      } else if (meta.args === 2) {
        const b = evalStack.pop();
        const a = evalStack.pop();
        let result;

        switch (op) {
          case '+': result = a + b; break;
          case '-': result = a - b; break;
          case '*': result = a * b; break;
          case '/':
            if (b === 0) throw new Error('数学错误:除数不能为零');
            result = a / b;
            break;
          case '%': result = a % b; break;
          case '^': result = Math.pow(a, b); break;
          default:
            throw new Error(`未实现的运算符: ${op}`);
        }
        evalStack.push(result);
      }
    } else if (token.type === TokenType.FUNCTION) {
      const fnName = token.value;
      const fn = MATH_FUNCTIONS[fnName];
      if (!fn) {
        throw new Error(`不支持的科学函数: "${fnName}"`);
      }
      if (evalStack.length < 1) {
        throw new Error(`函数 "${fnName}" 缺少参数`);
      }
      const arg = evalStack.pop();
      evalStack.push(fn(arg));
    }
  }

  if (evalStack.length !== 1) {
    throw new Error('表达式求值异常:操作数与运算符不匹配');
  }

  return evalStack[0];
}

完整可执行封装与验证示例

我们将上述各模块聚合成一个结构清晰的 ScientificCalculator 类,并配置常量支持(如 PI、E),对外暴露简洁的 calculate(expression) 接口:

class ScientificCalculator {
  constructor() {
    this.constants = {
      pi: Math.PI,
      e: Math.E
    };
  }

  // 预处理常数替换
  preprocess(expr) {
    let res = expr;
    for (const [name, val] of Object.entries(this.constants)) {
      const regex = new RegExp(`\b${name}\b`, 'gi');
      res = res.replace(regex, val.toString());
    }
    return res;
  }

  calculate(expr) {
    if (!expr || typeof expr !== 'string' || expr.trim() === '') {
      throw new Error('请输入有效的数学表达式');
    }

    const cleaned = this.preprocess(expr);
    const tokens = tokenize(cleaned);
    const rpn = toRPN(tokens);
    const result = evaluateRPN(rpn);

    // 处理浮点精度微小误差(如 0.1 + 0.2 = 0.30000000000000004)
    return Number(Math.round(result + 'e12') + 'e-12');
  }
}

// ===== 实际执行测试用例 =====
const calc = new ScientificCalculator();

console.log("示例 1: 基础括号与乘除优先级");
// 3 + 4 * (2 - 1) = 7
console.log("3 + 4 * (2 - 1) =", calc.calculate("3 + 4 * (2 - 1)"));

console.log("
示例 2: 右结合乘方与负号");
// 2 ^ 3 ^ 2 = 2 ^ 9 = 512
console.log("2 ^ 3 ^ 2 =", calc.calculate("2 ^ 3 ^ 2"));
// -5 + 3 * (-2) = -11
console.log("-5 + 3 * (-2) =", calc.calculate("-5 + 3 * (-2)"));

console.log("
示例 3: 科学函数与多层括号嵌套");
// sqrt(16) + sin(0) * cos(0) = 4
console.log("sqrt(16) + sin(0) * cos(0) =", calc.calculate("sqrt(16) + sin(0) * cos(0)"));
// 2 * (3 + (4 * (5 - 3))) = 2 * (3 + 8) = 22
console.log("2 * (3 + (4 * (5 - 3))) =", calc.calculate("2 * (3 + (4 * (5 - 3)))"));
控制台示例输出(真实验证):
示例 1: 基础括号与乘除优先级
3 + 4 * (2 - 1) = 7

示例 2: 右结合乘方与负号
2 ^ 3 ^ 2 = 512
-5 + 3 * (-2) = -11

示例 3: 科学函数与多层括号嵌套
sqrt(16) + sin(0) * cos(0) = 4
2 * (3 + (4 * (5 - 3))) = 22

常见边界陷阱与应对策略

在实际接入 Web 端计算器界面时,用户输入的行为往往多样且不规范。以下是在编码阶段必须严加防范的三大边界问题:

用JavaScript编写支持括号优先级的科学计算器逻辑
图 4:主流表达式解析技术方案对比与工程决策选型

1. 浮点数二进制定点精度失真

JavaScript 采用 IEEE 754 双精度浮点数标准,直接计算 0.1 + 0.2 会得到 0.30000000000000004。在科学计算器展示层,应使用指数科学记数法四舍五入或采用 Number(Math.round(val + 'e12') + 'e-12') 截断至可接受的有效数字范围,避免在界面上向用户展示冗长的尾数噪点。

2. 隐式乘法(Implicit Multiplication)

许多人在使用物理计算器时习惯书写 2(3 + 4) 或 4sin(30) 而省略乘号 *。在标准词法分析器中,这会被拆为相邻的数字与左括号,直接进入调度场会导致操作数堆叠而报错。若需要支持该特性,只需在分词阶段加入规则:当数字或右括号紧邻左括号或函数名时,自动插入一个乘法标记 *。

3. 括号不平衡与即时反馈

当用户输入尚未完成(例如输入了 (3 + 4 * 还没有键入闭合括号)时,计算器不应直接抛出难以理解的底层崩溃异常,而应在语法检验层捕获 Unclosed parenthesis,并友好提示“表达式未完成”,为界面的实时预览(Live Preview)提供稳定保障。

总结

用 JavaScript 编写支持括号优先级的科学计算器逻辑,最扎实且安全的方法是分词 → 调度场算法转后缀 → 栈式求值。这套模式不仅具备数学上的确定性与工业级的执行安全性,而且将新算符(如阶乘 !、对数 log)与常数的扩展成本降到了最低。通过明确定义优先级数值与结合性方向,无论是多么深层的括号嵌套,都能在严格的线性时间复杂度内完成精准求解。

实用工具推荐

电子包浆

绿化、压缩、噪点和虚拟水印,自由调节做旧程度。

使用 ›
图片压缩

选择画质和输出格式,预览压缩前后的大小。

使用 ›
相关文章