本文详细讲解如何使用原生JavaScript编写具备完整括号优先级支持与科学函数运算的计算器核心逻辑。通过词法分析分词、Dijkstra调度场算法以及后缀表达式(RPN)栈式求值,彻底摆脱不安全的eval,提供安全、精准且易扩展的生产级实现。
用JavaScript编写支持括号优先级的科学计算器逻辑
时间:2026-11-22
浏览:308
文章目录
eval 带来的安全风险。
为什么不能用简单的 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)或语法树进行计算。
整体解析架构:三层处理流水线
为了让计算器逻辑条理分明、具备良好的可测试性,我们将整个求值过程拆分为三个独立的纯函数模块:
- 词法分析(Tokenizer / Lexer):将原始字符串扫描成结构化的标记(Token)列表。在此步骤过滤无意义的空格,识别多位浮点数、操作符、括号以及科学函数名,并消解单目负号。
- 调度场转换(Shunting-Yard Parser):维护一个运算符临时栈和一个输出队列。遍历 Token 列表,依据各运算符的优先级和结合性,将中缀表达式重组为后缀表达式,同时消除所有括号。
- 后缀表达式求值器(RPN Evaluator):利用单个操作数栈,从左到右消费后缀序列。遇到数字则入栈,遇到运算符则弹出对应数量的操作数计算后将结果重新压栈,栈底最终留下的唯一数字即为最终答案。
第一步:词法分析与单目负号的精准判定
在编写解析器时,减号 - 是最容易引发歧义的符号。在算式 5 - 3 中,它是双目减法运算符;而在 -5、3 * -2 或 (-4 + 1) 中,它却代表单目求负运算(Unary Minus)。
判断当前 - 究竟是负号还是减号,只需要查看它前一个有效标记(Previous Token)的状态:
- 如果前面没有任何标记(即位于表达式开头),或者前一个标记是运算符、左括号、逗号,那么该减号一定是单目负号,我们将其标记为专用的
u-。 - 如果前面是数字或右括号,那么该减号是双目减号,标记为普通的二元运算符
-。
我们来看具体的词法分词器代码实现:
// 标记类型定义
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 | 不适用(由括号封闭参数) |
中缀转后缀核心算法实现
在遇到左括号 ( 时,算法无条件将其推入运算符栈,标志着一个独立优先级层级的开始;在遇到右括号 ) 时,持续将栈顶运算符弹出到输出队列,直到找到对应的 ( 为止。如果栈全部弹空仍未找到 (,说明算式存在括号未闭合或多余右括号的语法错误。
// 运算符属性配置表
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 端计算器界面时,用户输入的行为往往多样且不规范。以下是在编码阶段必须严加防范的三大边界问题:
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)与常数的扩展成本降到了最低。通过明确定义优先级数值与结合性方向,无论是多么深层的括号嵌套,都能在严格的线性时间复杂度内完成精准求解。
实用工具推荐
绿化、压缩、噪点和虚拟水印,自由调节做旧程度。
选择画质和输出格式,预览压缩前后的大小。