JavaScript计算器代码重构:怎么提升可维护性与模块化

作者:纸飞机

时间:2026-11-18

浏览:109

深入讲解如何对典型JavaScript计算器代码进行架构重构,通过将业务运算、状态流转与DOM渲染彻底解耦,提升系统可维护性与扩展性。

文章目录

一、混乱之源:典型计算器代码的痛点剖析

许多前端开发者在实现计算器组件时,习惯直觉式编码:在 HTML 按钮上绑定 onclick="handlePress('7')",然后在全局 JavaScript 中维护两个字符串变量,利用字符串拼接积累数字,甚至直接使用 eval() 执行整个表达式。

这种实现方式看似在十几分钟内完成了“加减乘除”,但其内部架构极为脆弱。我们来看一段高度还原的典型初版代码:

// 初版混乱代码示例(反例)
let currentInput = "";
let previousInput = "";
let operator = null;

function handlePress(value) {
  const display = document.getElementById("display");
  if (!isNaN(value) || value === ".") {
    currentInput += value;
    display.innerText = currentInput;
  } else if (value === "+" || value === "-" || value === "*" || value === "/") {
    operator = value;
    previousInput = currentInput;
    currentInput = "";
  } else if (value === "=") {
    // 隐藏隐患:使用 eval 或粗糙的 parseFloat 导致精度与语法崩溃
    currentInput = String(eval(`${previousInput} ${operator} ${currentInput}`));
    display.innerText = currentInput;
    operator = null;
  } else if (value === "C") {
    currentInput = "";
    previousInput = "";
    operator = null;
    display.innerText = "0";
  }
}

这段代码表面能运行,但在稍有规模的使用中会暴露出四个致命问题:

  • DOM 充当数据源与逻辑交织:函数的执行依赖外部真实的 DOM 元素。一旦在无 DOM 环境(如 Node.js 单元测试或自动化脚本)中运行,代码直接抛出异常。
  • 隐式状态不可预测:例如,连续按下两次加号、输入连续的小数点(如 3..2.1)、在除数为 0 之后继续按等号,或者在算出结果后立刻输入新数字,都会导致逻辑分叉失控。
  • 危险且难以测试的计算方式:依赖 eval 会引入安全风险,同时 JavaScript 浮点数算术(如 0.1 + 0.2 === 0.30000000000000004)会直接破坏屏幕显示。
  • 扩展成本极其高昂:如果要支持键盘快捷键、历史记录面板、百分比运算或退格键,必须不断向这个单一体积巨大的 handlePress 中填充 if-else 分支,可读性迅速归零。
JavaScript计算器代码重构:怎么提升可维护性与模块化
图 1:代码重构前后的内部职责与数据流动对比

二、模块化拆分的三大契约与职责定义

要实现一个高可维护的计算器,关键在于确立单一职责原则(Single Responsibility Principle)。我们把系统划分为三个完全独立的模块,每个模块只关心自身的输入与输出,杜绝越界调用。

1. 纯计算引擎(CalculatorEngine)

运算核心是一个纯函数库(Pure Functions),它不知道什么是 HTML,不依赖任何外部变量,给定相同的数字与操作符,必须恒定返回相同的计算结果。它的职责包含:

  • 执行基础二元运算(加、减、乘、除)与一元运算(正负反转、百分比)。
  • 处理浮点数运算精度(消除 IEEE 754 标准带来的 0.1 + 0.2 = 0.30000000000000004 现象)。
  • 定义异常边界(例如除数为 0 时返回特定错误标记,而非让程序抛出不受控异常)。

2. 状态机模型(CalculatorState)

计算器本质上是一个有限状态机。用户每次按下按键,都是向状态机发送一个动作(Action),状态机决定如何更新内部的数值缓冲。

状态机内部只保留四个基本字段:

  • currentOperand:当前屏幕正在输入的数值字符串。
  • previousOperand:暂存的前一个操作数。
  • operation:当前选定的运算符(+、-、*、/)。
  • overwriteOnNextInput:布尔标志,指示下一次输入数字时是追加字符还是覆盖重写(例如刚点击等号计算完毕后)。

3. 表现与交互层(CalculatorView)

视图层负责 DOM 元素的查询、按键事件的挂载,以及屏幕的重绘。它遵守被动渲染模式:只在收到新状态时才更新屏幕,绝不自行推算业务逻辑。

JavaScript计算器代码重构:怎么提升可维护性与模块化
图 2:三大模块边界及公开方法契约设计

三、分步重构落地实战

有了清晰的契约划分后,我们不再一次性推倒重写,而是按照“由内向外、逐步抽离”的重构路径,一步步替换旧逻辑。

步骤一:编写纯函数计算核心(Engine)

首先将计算逻辑从 DOM 中剥离。我们构建一个不可变(Immutable)概念的运算引擎,同时解决除零异常与经典的浮点数精度截断问题:

// modules/CalculatorEngine.js
export class CalculatorEngine {
  /**
   * 执行基础算术运算
   * @param {number} a 第一个操作数
   * @param {number} b 第二个操作数
   * @param {string} operator 运算符 '+', '-', '*', '/'
   * @returns {number} 计算结果
   */
  static compute(a, b, operator) {
    let result;
    switch (operator) {
      case "+":
        result = a + b;
        break;
      case "-":
        result = a - b;
        break;
      case "*":
        result = a * b;
        break;
      case "/":
        if (b === 0) {
          throw new Error("DivisionByZero");
        }
        result = a / b;
        break;
      default:
        return b;
    }
    return this.normalizePrecision(result);
  }

  /**
   * 修正浮点数运算产生的尾数误差,限制在 12 位有效数字以内
   */
  static normalizePrecision(num) {
    if (!isFinite(num)) return num;
    return parseFloat(num.toPrecision(12));
  }

  /**
   * 屏幕展示格式化(千分位与科学计数法支持)
   */
  static formatNumber(value) {
    if (value === "" || value == null) return "";
    if (value === "Error" || value === "-") return value;

    const [integerPart, decimalPart] = value.toString().split(".");
    const integerFormatted = Number(integerPart).toLocaleString("en-US");

    if (decimalPart != null) {
      return `${integerFormatted}.${decimalPart}`;
    }
    return integerFormatted;
  }
}

步骤二:构建有限状态机(State)

计算器在任何一个时刻,只能处于特定状态下。按键操作不是盲目追加字符,而是触发状态机的转移。我们梳理出完整的状态流转规则:

JavaScript计算器代码重构:怎么提升可维护性与模块化
图 3:计算器有限状态机流转与边界判定模型

状态机封装代码如下:

// modules/CalculatorState.js
import { CalculatorEngine } from "./CalculatorEngine.js";

export class CalculatorState {
  constructor() {
    this.clear();
  }

  clear() {
    this.currentOperand = "0";
    this.previousOperand = "";
    this.operation = null;
    this.overwriteOnNextInput = false;
    this.hasError = false;
  }

  delete() {
    if (this.hasError || this.overwriteOnNextInput) {
      this.clear();
      return;
    }
    if (this.currentOperand.length <= 1) {
      this.currentOperand = "0";
    } else {
      this.currentOperand = this.currentOperand.slice(0, -1);
    }
  }

  appendDigit(digit) {
    if (this.hasError) this.clear();

    // 覆盖输入模式(刚出计算结果后直接敲数字)
    if (this.overwriteOnNextInput) {
      this.currentOperand = digit === "." ? "0." : digit;
      this.overwriteOnNextInput = false;
      return;
    }

    // 严禁输入多个小数点
    if (digit === "." && this.currentOperand.includes(".")) return;

    // 处理以 0 开头的情形
    if (this.currentOperand === "0" && digit !== ".") {
      this.currentOperand = digit;
    } else {
      this.currentOperand += digit;
    }
  }

  chooseOperation(operator) {
    if (this.hasError) return;

    // 允许连续更换运算符(例如点错乘号后立刻改按除号)
    if (this.currentOperand === "" && this.previousOperand !== "") {
      this.operation = operator;
      return;
    }

    // 连续链式求值(如 2 + 3 + 4,先求出 5,再继续等待输入)
    if (this.previousOperand !== "") {
      this.evaluate();
    }

    this.operation = operator;
    this.previousOperand = this.currentOperand;
    this.currentOperand = "";
  }

  evaluate() {
    if (!this.operation || this.previousOperand === "" || this.currentOperand === "") {
      return;
    }

    const prev = parseFloat(this.previousOperand);
    const current = parseFloat(this.currentOperand);

    try {
      const result = CalculatorEngine.compute(prev, current, this.operation);
      this.currentOperand = String(result);
      this.operation = null;
      this.previousOperand = "";
      this.overwriteOnNextInput = true;
    } catch (err) {
      this.currentOperand = "Error";
      this.hasError = true;
      this.operation = null;
      this.previousOperand = "";
    }
  }

  getSnapshot() {
    return {
      currentDisplay: this.currentOperand,
      previousDisplay: this.previousOperand,
      operation: this.operation,
      hasError: this.hasError
    };
  }
}

步骤三:表现层封装与事件委托绑定(View)

在 HTML 中,我们摒弃每个按钮写内联 onclick 的落后方式,改为在计算器根节点上使用事件委托(Event Delegation)。同时,将键盘 keydown 事件也接入同一个意图映射字典,彻底实现输入通道的标准化:

// modules/CalculatorView.js
import { CalculatorEngine } from "./CalculatorEngine.js";

export class CalculatorView {
  constructor(rootElement) {
    this.root = rootElement;
    this.prevDisplayEl = this.root.querySelector("[data-prev-display]");
    this.currDisplayEl = this.root.querySelector("[data-curr-display]");
  }

  /**
   * 绑定按键交互意图
   * @param {Function} onAction (actionType, payload) => void
   */
  bindEvents(onAction) {
    // 1. 按钮点击事件委托
    this.root.addEventListener("click", (e) => {
      const btn = e.target.closest("button[data-action]");
      if (!btn) return;

      const action = btn.dataset.action;
      const value = btn.dataset.value;
      onAction(action, value);
    });

    // 2. 键盘事件统一映射
    window.addEventListener("keydown", (e) => {
      if ((e.key >= "0" && e.key <= "9") || e.key === ".") {
        onAction("digit", e.key);
      } else if (["+", "-", "*", "/"].includes(e.key)) {
        onAction("operator", e.key);
      } else if (e.key === "Enter" || e.key === "=") {
        e.preventDefault();
        onAction("equal");
      } else if (e.key === "Backspace") {
        onAction("delete");
      } else if (e.key === "Escape") {
        onAction("clear");
      }
    });
  }

  /**
   * 纯渲染方法,根据状态快照刷新 DOM
   */
  render(state) {
    if (state.hasError) {
      this.currDisplayEl.innerText = "Error";
      this.prevDisplayEl.innerText = "";
      return;
    }

    const formattedCurr = CalculatorEngine.formatNumber(state.currentDisplay);
    this.currDisplayEl.innerText = formattedCurr || "0";

    if (state.operation != null) {
      const formattedPrev = CalculatorEngine.formatNumber(state.previousDisplay);
      this.prevDisplayEl.innerText = `${formattedPrev} ${state.operation}`;
    } else {
      this.prevDisplayEl.innerText = "";
    }
  }
}

步骤四:组装控制器与初始化引导(Main Entry)

在主入口模块中,我们仅需把 CalculatorState 和 CalculatorView 组合起来。所有的业务逻辑只在响应动作时触发,形成单向闭环:

// main.js - 应用组装入口
import { CalculatorState } from "./modules/CalculatorState.js";
import { CalculatorView } from "./modules/CalculatorView.js";

document.addEventListener("DOMContentLoaded", () => {
  const container = document.getElementById("calculator-app");
  const state = new CalculatorState();
  const view = new CalculatorView(container);

  // 统一意图分发器
  view.bindEvents((action, payload) => {
    switch (action) {
      case "digit":
        state.appendDigit(payload);
        break;
      case "operator":
        state.chooseOperation(payload);
        break;
      case "equal":
        state.evaluate();
        break;
      case "delete":
        state.delete();
        break;
      case "clear":
        state.clear();
        break;
    }
    // 每次动作执行后,以最新状态刷新视图
    view.render(state.getSnapshot());
  });

  // 首次初始化屏幕
  view.render(state.getSnapshot());
});

四、深度认知辨析:重构中的权衡与易混淆观念

在进行代码重构时,一些表面看似合理的捷径或经验法则,常常会让代码滑入另一种形式的维护陷阱。以下是关于计算器重构中最典型的两项辨析:

观点辨析 1:“只要把所有函数放进一个 ES6 Class 里,就算完成了模块化?”

误区剖析:很多开发者将包含几十个方法的巨型类视为“现代面向对象”。但如果这个类内部既保存 this.displayElement,又包含 this.calculate() 和 this.addEventListener(),这只是把原本的全局变量转移成了类的内部成员变量,代码耦合度丝毫没有降低。

修正结论:模块化的衡量标准是“关注点分离”与“独立可替换性”,而非语法的类封装。真正的模块化使得 CalculatorEngine 可以直接发布为一个脱离浏览器的 npm 数学库,而 CalculatorView 也可以轻松替换为 Canvas、React 甚至终端字符界面。

观点辨析 2:“计算器规则简单,用 eval() 或 new Function() 真的不能接受吗?”

误区剖析:有人认为对于纯前端静态计算器,不存在服务端注入威胁,直接求值最省事。然而安全只是问题的一小部分。根本缺陷在于:eval 强依赖合法的 JavaScript 字符串语法。

例如用户连续按下 5 + * 3 时,eval("5+*3") 会直接抛出无法恢复的语法错误(SyntaxError);同时 eval("0.1 + 0.2") 无法注入任何精度微调钩子;在需要实现“退格”、“千分位展示”或“历史记录撤回”时,字符串逆向解析的复杂度将远超编写状态机。

修正结论:即使是简单的四则运算,显式状态机与运算符调度也具有更完备的健壮性与边界防错能力。

五、验证策略与重构演进路线图

任何有价值的重构,必须建立在行为安全性的前提之下。模块化带来的最大红利,就是让我们能够对计算逻辑脱离 DOM 进行自动化测试。

1. 核心测试用例矩阵(黄金测试用例)

测试场景 输入序列 预期屏幕输出 检验的核心边界
基础运算 1, 2, +, 8, = 20 二元常规加法
浮点数精度 0, ., 1, +, 0, ., 2, = 0.3 消除 0.30000000000000004 精度溢出
连续运算符更换 5, +, *, 2, = 10 最后输入的运算符覆盖先前的运算符
多重小数点防御 3, ., ., 5, +, 1, = 4.5 重复按小数点被状态机静默拦截
除以零异常处理 9, /, 0, = Error 防范 JavaScript 默认 Infinity 破坏显示
结果后直接输入数字 2, +, 3, =, 7 7 正确重置覆盖标志,不拼接为 "57"
JavaScript计算器代码重构:怎么提升可维护性与模块化
图 4:计算器代码重构的四步渐进式演进与交付阶段

六、总结与未来扩展能力

重构并非追求复杂的抽象语法,而是为了在变动来临时拥有确定性与从容感。回顾整套重构体系,我们达成了以下收益:

  1. 无头化(Headless)兼容:由于 CalculatorEngine 与 CalculatorState 完全脱离了 window 和 document,它们可以直接在 Node.js 服务端、Web Worker 乃至原生混合应用中毫无阻碍地复用。
  2. 扩展新特性如履平地:若需扩展“计算历史记录(History)”,只需在 CalculatorState 的 evaluate 方法中向数组推入一个记录对象;若需增加科学计算(如开根号、正弦函数),只需在 Engine 中添加纯函数并在 State 中增加一元运算分支,无需触碰 DOM 代码。
  3. 彻底告别不可控的隐式错误:消除了 eval 注入隐患与浮点数大数尾差,事件委托机制也避免了频繁绑定监听器带来的内存泄漏。

当你掌握了“数学纯函数 + 显式状态机 + 被动渲染视图”这套解耦范式,面对的将不再仅是一个简单的计算器,而是掌握了现代前端单向数据流与高内聚模块化架构的底层精髓。

实用工具推荐

电子包浆

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

使用 ›
图片压缩

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

使用 ›
相关文章