JavaScript实现简易计算器:HTML/CSS/JS完整代码与逻辑解析

作者:小圆点

时间:2026-11-18

浏览:77

使用原生 HTML、CSS 和 JavaScript 构建功能完备的简易计算器。详解 CSS Grid 网格布局、事件委托监听、有限状态机流转、连续链式运算及 IEEE 754 浮点精度规整方案。

文章目录
实现一个功能可靠的原生 JavaScript 计算器,关键在于明确划分骨架结构、网格表现与状态调度三大职责。本文通过 HTML 构建语义化按键结构,利用 CSS Grid 实现自适应按键排布,并使用基于有限状态机的 JavaScript 逻辑处理连续四则运算、小数点防重、首位零规整与浮点数精度截断,提供完整可直接运行的源码与底层运作机制剖析。
JavaScript实现简易计算器:HTML/CSS/JS完整代码与逻辑解析
图 0:JavaScript 简易计算器系统全貌与技术架构

一、计算器整体架构与 HTML 骨架构建

前端计算器的交互本质上是“用户操作输入序列”向“数学运算结果”的转化过程。为了让代码结构清晰且易于维护,我们首先在 DOM 表现层建立严谨的层次划分。一个标准的计算器界面通常包含两大部分:用于反馈状态的输出屏幕(Screen)和承载用户点击行为的操作键盘(Keys)。

在屏幕设计上,推荐采用“双层显示区”方案:顶部的较小字号区域用于记录上一操作数及当前选定的运算符(形成简易历史表达式),底部的较大字号区域用于实时展示当前输入值或最终运算结果。这种设计使用户在多步输入过程中随时知晓当前上下文,大幅提升交互体验。

在按键设计上,使用 HTML 原生 <button> 元素保证无障碍访问与原生按压语义。为了便于 JavaScript 统一识别按键职责,我们通过 HTML5 自定义数据属性 data-action 和 data-value 进行职责标记:

  • 数字键:不设置 data-action,或者统一通过 data-value="0"~"9" 标记其字面值。
  • 运算符键:设置 data-action="operator",并通过 data-operator="+"、"-"、"*"、"/" 明确运算类型。
  • 小数点键:设置 data-action="decimal"。
  • 控制键:设置 data-action="clear"(全部清空 AC)与 data-action="delete"(单字退格 DEL)。
  • 等号键:设置 data-action="calculate"。
<!-- 计算器完整 HTML 结构 -->
<div class="calculator">
  <!-- 显示屏:历史算式与当前数值 -->
  <div class="calculator-screen">
    <div class="screen-history" id="screenHistory"></div>
    <div class="screen-current" id="screenCurrent">0</div>
  </div>

  <!-- 按键区:4 列网格容器 -->
  <div class="calculator-keys" id="calculatorKeys">
    <!-- 第一行:清空、退格、取余/百分比、除法 -->
    <button type="button" class="key-tool" data-action="clear">AC</button>
    <button type="button" class="key-tool" data-action="delete">DEL</button>
    <button type="button" class="key-tool" data-action="percent">%</button>
    <button type="button" class="key-operator" data-action="operator" data-operator="/">&divide;</button>

    <!-- 第二行:7、8、9、乘法 -->
    <button type="button" class="key-number" data-value="7">7</button>
    <button type="button" class="key-number" data-value="8">8</button>
    <button type="button" class="key-number" data-value="9">9</button>
    <button type="button" class="key-operator" data-action="operator" data-operator="*">&times;</button>

    <!-- 第三行:4、5、6、减法 -->
    <button type="button" class="key-number" data-value="4">4</button>
    <button type="button" class="key-number" data-value="5">5</button>
    <button type="button" class="key-number" data-value="6">6</button>
    <button type="button" class="key-operator" data-action="operator" data-operator="-">&minus;</button>

    <!-- 第四行:1、2、3、加法 -->
    <button type="button" class="key-number" data-value="1">1</button>
    <button type="button" class="key-number" data-value="2">2</button>
    <button type="button" class="key-number" data-value="3">3</button>
    <button type="button" class="key-operator" data-action="operator" data-operator="+">+</button>

    <!-- 第五行:0 (跨两列)、小数点、等号 -->
    <button type="button" class="key-number key-zero" data-value="0">0</button>
    <button type="button" class="key-number" data-action="decimal">.</button>
    <button type="button" class="key-equal" data-action="calculate">=</button>
  </div>
</div>

上述 HTML 标签完全脱离具体的业务脚本,所有按钮的信息均存放在 class 与 data-* 属性中。这为后文采用高效的“事件委托”机制提供了坚实基础。

JavaScript实现简易计算器:HTML/CSS/JS完整代码与逻辑解析
图 1:DOM 表现层、事件委托中枢与业务逻辑分发流

二、CSS Grid 网格布局与交互反馈设计

计算器的按键布局是典型的二维网格。传统的 float 或 inline-block 方案需要精细计算各元素边距与盒模型,且容易产生错位。使用现代 CSS Grid(网格布局)可以用极少的声明搭建出稳固自适应的计算器面板。

通过 display: grid 和 grid-template-columns: repeat(4, 1fr),我们将按键区平均划分为 4 等列。使用 gap: 12px 设置行列间隙,无需为单个按钮设置外边距。对于占据更宽空间的数字键 0,只需设置 grid-column: span 2 即可平滑横跨两列。

/* 计算器样式层 */
.calculator {
  width: 320px;
  background-color: #FFFFFF;
  border: 1px solid #DED8C9;
  border-radius: 12px;
  box-shadow: 0 8px 24px rgba(70, 75, 72, 0.08);
  padding: 20px;
  user-select: none;
}

/* 双层屏幕区域 */
.calculator-screen {
  background-color: #F7F4ED;
  border: 1px solid #DED8C9;
  border-radius: 8px;
  padding: 12px 16px;
  margin-bottom: 20px;
  text-align: right;
  min-height: 80px;
  display: flex;
  flex-direction: column;
  justify-content: flex-end;
  word-break: break-all;
}

.screen-history {
  font-size: 13px;
  color: #8A9478;
  min-height: 18px;
  line-height: 18px;
}

.screen-current {
  font-size: 30px;
  font-weight: 700;
  color: #464B48;
  line-height: 1.2;
}

/* 4 列弹性按键网格 */
.calculator-keys {
  display: grid;
  grid-template-columns: repeat(4, 1fr);
  gap: 10px;
}

/* 基础按键风格 */
.calculator-keys button {
  height: 48px;
  font-size: 18px;
  border: 1px solid #DED8C9;
  border-radius: 6px;
  cursor: pointer;
  background-color: #FAF8F5;
  color: #464B48;
  outline: none;
  transition: background-color 0.15s ease, transform 0.05s ease;
}

.calculator-keys button:hover {
  background-color: #F0EDE4;
}

.calculator-keys button:active {
  transform: scale(0.96);
}

/* 功能工具键 */
.key-tool {
  background-color: rgba(138, 148, 120, 0.15) !important;
  font-weight: 600;
  color: #464B48 !important;
}

/* 运算符键 */
.key-operator {
  background-color: #8A9478 !important;
  color: #FFFFFF !important;
  font-weight: 600;
  border-color: #8A9478 !important;
}

.key-operator:hover {
  background-color: #798369 !important;
}

/* 等号键 */
.key-equal {
  background-color: #464B48 !important;
  color: #FFFFFF !important;
  font-weight: 600;
  border-color: #464B48 !important;
}

.key-equal:hover {
  background-color: #383C39 !important;
}

/* 横跨两列的数字 0 */
.key-zero {
  grid-column: span 2;
}

为了避免在连续快速敲击时触发浏览器的文本选中文本蓝底效果,为计算器外层容器添加了 user-select: none。按键悬浮和被按压时的 scale(0.96) 缩放动画,能为用户带来清晰直接的触控反馈。

三、核心逻辑设计:辨析 eval() 与有限状态机

容易混淆的实现思路:直接使用 eval() 进行字符串求值

初学者在实现计算器时,常常会采用一种直观做法:把用户点击的所有数字和符号拼接成一个长字符串(如 "12+5*3"),最后调用 eval(str) 一次性求出结果。这种做法看似极其简单省事,在输入完全合法的情况下也确实能运算,但在严谨的前端工程中需要予以修正。

为什么直接拼接字符串并使用 eval() 是不可取的?主要有三个关键原因:

  1. 安全隐患与代码注入:eval() 拥有完整的 JavaScript 执行权限。如果输入来源被篡改或用于开放环境,它将直接执行任意脚本,破坏系统安全性。现代前端开发规范普遍明确禁用 eval()。
  2. 无法精细管理交互状态与输入纠错:真实计算器在用户连续点击两个不同运算符时(例如先按了 +,紧接着意识到该用 *),应当优雅地覆盖前一个运算符,而不是拼接成非法语法字符串 "12+*"。基于纯字符串的拼接需要编写大量脆弱的正规表达式才能处理更正、退格与中间态展示。
  3. 缺乏除零与浮点精度防护:纯字符串表达式在语法求值时会直接抛出原生 Infinity 或产生恶性的精度漂移(如 0.1 + 0.2 === 0.30000000000000004),无法在数据流流转的中间节点进行拦截。

因此,标准而优雅的解法是引入有限状态机(Finite State Machine, FSM)。我们将计算器的全部生命周期提炼为四个核心状态变量:

状态变量名称 初始默认值 核心职责说明
displayValue '0' 当前屏幕上展示的字符串内容,也是用户正在录入或刚刚计算完成的操作数。
firstOperand null 运算的第一操作数(数值型),在用户按下四则运算符时固化存储。
operator null 当前挂起的待执行运算符(如 +、-、*、/)。
waitingForSecondOperand false 布尔标记位。当用户点击运算符后置为 true,指示下一次输入数字时应清空屏幕重新录入,而非拼接在旧数字后。
JavaScript实现简易计算器:HTML/CSS/JS完整代码与逻辑解析
图 2:计算器内部四大核心状态的流转模型与连续计算时序

如状态图所示,当用户输入 12 + 5 = 时:

  1. 键入 12:displayValue 从 '0' 更新为 '12'。
  2. 点击 +:将 12 转为浮点数暂存至 firstOperand,将 operator 记为 '+',并将 waitingForSecondOperand 设为 true。
  3. 键入 5:检测到 waitingForSecondOperand === true,立即将屏幕内容重写为 '5',并将标记重置为 false。
  4. 点击 =:读取 firstOperand(12)与当前值(5),通过预设的双目运算映射表完成求值,将计算结果写入 displayValue,历史状态清空。

四、关键细节与边界防护机制

一个优秀的计算器与玩具代码的区别,恰恰体现在边界条件的处理上。以下四个典型边界问题在开发过程中必须逐一设防:

1. 首位 0 与无效多位 0 拦截

当屏幕初始值为 '0' 时,若用户继续点击 0,屏幕应当保持 '0',防止输出 '000' 这类不符合常规数学书写的字符串。而当用户输入 1~9 时,应当直接替换掉当前的 '0'。只有在用户输入小数点时,才形成 '0.' 的小数前缀。

2. 小数点单例约束

一个合法的十进制浮点数只能包含一个小数点。若用户输入了 3.14 后再次点击 .,程序必须拦截此次操作。此外,如果用户在刚按完运算符后(此时 waitingForSecondOperand === true)立刻点击了 .,程序不能展示裸露的 .,而应自动为其前置补 0,展示为 '0.'。

3. 除以零防护

在纯数学逻辑中,除数不能为零。JavaScript 原生机制对于非零数除以零会返回 Infinity,零除以零返回 NaN。直接将此类英文常量显示给用户是不友好的。我们应在执行除法前主动校验第二操作数是否为零,若是则返回明确的中文错误提示 "除数不能为0",并将内部状态挂起,直到用户点击 AC 或输入新数字时重置。

4. IEEE 754 浮点数精度截断

JavaScript 采用 IEEE 754 标准双精度 64 位二进制浮点数,十进制小数无法完全用有限二进制精确表示,因此常见 0.1 + 0.2 === 0.30000000000000004 的精度微小漂移。为防止此类多余尾数污染显示屏,我们在完成计算后使用 parseFloat(result.toFixed(12)) 进行规整。此方法先将数字保留 12 位有效小数消除尾部漂移,再由 parseFloat 自动剥除尾部无意义的 0。

JavaScript实现简易计算器:HTML/CSS/JS完整代码与逻辑解析
图 3:输入校验管道、异常拦截门禁与浮点精度规整流程

五、完整一体化源码实现

以下是集成了上述结构、样式与状态机逻辑的完整独立 HTML 页面代码。代码未引入任何第三方库,复制保存为 .html 文件后双击即可在任意现代浏览器中运行验证。

<!DOCTYPE html>
<html lang="zh-CN">
<head>
  <meta charset="UTF-8">
  <meta name="viewport" content="width=device-width, initial-scale=1.0">
  <title>原生 JavaScript 简易计算器</title>
  <style>
    * {
      box-sizing: border-box;
      margin: 0;
      padding: 0;
    }
    body {
      display: flex;
      justify-content: center;
      align-items: center;
      min-height: 100vh;
      background-color: #F7F4ED;
      font-family: -apple-system, BlinkMacSystemFont, "PingFang SC", "Microsoft YaHei", sans-serif;
    }
    .calculator {
      width: 320px;
      background: #FFFFFF;
      border: 1px solid #DED8C9;
      border-radius: 12px;
      padding: 20px;
      box-shadow: 0 8px 24px rgba(70, 75, 72, 0.08);
      user-select: none;
    }
    .calculator-screen {
      background-color: #F7F4ED;
      border: 1px solid #DED8C9;
      border-radius: 8px;
      padding: 12px 16px;
      margin-bottom: 18px;
      text-align: right;
      min-height: 80px;
      display: flex;
      flex-direction: column;
      justify-content: flex-end;
    }
    .screen-history {
      font-size: 13px;
      color: #8A9478;
      min-height: 18px;
      line-height: 18px;
    }
    .screen-current {
      font-size: 32px;
      font-weight: 700;
      color: #464B48;
      line-height: 1.2;
      overflow-x: hidden;
    }
    .calculator-keys {
      display: grid;
      grid-template-columns: repeat(4, 1fr);
      gap: 10px;
    }
    .calculator-keys button {
      height: 48px;
      font-size: 18px;
      border: 1px solid #DED8C9;
      border-radius: 6px;
      cursor: pointer;
      background-color: #FAF8F5;
      color: #464B48;
      outline: none;
      transition: background-color 0.15s ease, transform 0.05s ease;
    }
    .calculator-keys button:hover {
      background-color: #F0EDE4;
    }
    .calculator-keys button:active {
      transform: scale(0.96);
    }
    .key-tool {
      background-color: rgba(138, 148, 120, 0.15) !important;
      font-weight: 600;
    }
    .key-operator {
      background-color: #8A9478 !important;
      color: #FFFFFF !important;
      font-weight: 600;
      border-color: #8A9478 !important;
    }
    .key-operator:hover {
      background-color: #798369 !important;
    }
    .key-equal {
      background-color: #464B48 !important;
      color: #FFFFFF !important;
      font-weight: 600;
      border-color: #464B48 !important;
    }
    .key-equal:hover {
      background-color: #383C39 !important;
    }
    .key-zero {
      grid-column: span 2;
    }
  </style>
</head>
<body>

<div class="calculator">
  <div class="calculator-screen">
    <div class="screen-history" id="screenHistory"></div>
    <div class="screen-current" id="screenCurrent">0</div>
  </div>
  <div class="calculator-keys" id="calculatorKeys">
    <button type="button" class="key-tool" data-action="clear">AC</button>
    <button type="button" class="key-tool" data-action="delete">DEL</button>
    <button type="button" class="key-tool" data-action="percent">%</button>
    <button type="button" class="key-operator" data-action="operator" data-operator="/">&divide;</button>

    <button type="button" class="key-number" data-value="7">7</button>
    <button type="button" class="key-number" data-value="8">8</button>
    <button type="button" class="key-number" data-value="9">9</button>
    <button type="button" class="key-operator" data-action="operator" data-operator="*">&times;</button>

    <button type="button" class="key-number" data-value="4">4</button>
    <button type="button" class="key-number" data-value="5">5</button>
    <button type="button" class="key-number" data-value="6">6</button>
    <button type="button" class="key-operator" data-action="operator" data-operator="-">&minus;</button>

    <button type="button" class="key-number" data-value="1">1</button>
    <button type="button" class="key-number" data-value="2">2</button>
    <button type="button" class="key-number" data-value="3">3</button>
    <button type="button" class="key-operator" data-action="operator" data-operator="+">+</button>

    <button type="button" class="key-number key-zero" data-value="0">0</button>
    <button type="button" class="key-number" data-action="decimal">.</button>
    <button type="button" class="key-equal" data-action="calculate">=</button>
  </div>
</div>

<script>
  // 1. 状态管理对象
  const calculator = {
    displayValue: '0',
    historyValue: '',
    firstOperand: null,
    waitingForSecondOperand: false,
    operator: null,
  };

  // 2. 双目基础运算引擎
  const performCalculation = {
    '/': (first, second) => second === 0 ? '除数不能为0' : first / second,
    '*': (first, second) => first * second,
    '+': (first, second) => first + second,
    '-': (first, second) => first - second,
  };

  // 运算符展示符号映射
  const operatorSymbols = {
    '/': '÷',
    '*': '×',
    '+': '+',
    '-': '−',
  };

  // 3. 数字键录入
  function inputDigit(digit) {
    const { displayValue, waitingForSecondOperand } = calculator;

    // 如果刚点击完错误状态,直接重置
    if (displayValue === '除数不能为0') {
      calculator.displayValue = digit;
      calculator.historyValue = '';
      return;
    }

    if (waitingForSecondOperand) {
      calculator.displayValue = digit;
      calculator.waitingForSecondOperand = false;
    } else {
      // 当前为 '0' 时覆盖,否则向后追加
      calculator.displayValue = displayValue === '0' ? digit : displayValue + digit;
    }
  }

  // 4. 小数点处理
  function inputDecimal() {
    if (calculator.displayValue === '除数不能为0') {
      resetCalculator();
    }

    if (calculator.waitingForSecondOperand) {
      calculator.displayValue = '0.';
      calculator.waitingForSecondOperand = false;
      return;
    }

    // 单例约束:如果当前数值尚不包含小数点,才允许添加
    if (!calculator.displayValue.includes('.')) {
      calculator.displayValue += '.';
    }
  }

  // 5. 运算符处理与连续链式计算
  function handleOperator(nextOperator) {
    const { firstOperand, displayValue, operator } = calculator;
    const inputValue = parseFloat(displayValue);

    if (displayValue === '除数不能为0') {
      resetCalculator();
      return;
    }

    // 若已经处于等待第二操作数阶段,用户再次点击运算符表示更改运算符号
    if (operator && calculator.waitingForSecondOperand) {
      calculator.operator = nextOperator;
      calculator.historyValue = `${firstOperand} ${operatorSymbols[nextOperator]}`;
      return;
    }

    // 首次按下运算符,归档第一操作数
    if (firstOperand === null && !isNaN(inputValue)) {
      calculator.firstOperand = inputValue;
    } else if (operator) {
      // 连续链式操作(如 5 + 3 + ...):先对前序进行就地结算
      const result = performCalculation[operator](firstOperand, inputValue);

      if (typeof result === 'string') {
        // 捕获除零等异常
        calculator.displayValue = result;
        calculator.historyValue = '';
        calculator.firstOperand = null;
        calculator.operator = null;
        calculator.waitingForSecondOperand = false;
        return;
      }

      // 消除浮点数精度多余尾数
      const rounded = parseFloat(result.toFixed(12));
      calculator.displayValue = String(rounded);
      calculator.firstOperand = rounded;
    }

    calculator.waitingForSecondOperand = true;
    calculator.operator = nextOperator;
    calculator.historyValue = `${calculator.firstOperand} ${operatorSymbols[nextOperator]}`;
  }

  // 6. 等号最终结算
  function handleCalculate() {
    const { firstOperand, displayValue, operator } = calculator;
    const inputValue = parseFloat(displayValue);

    if (operator === null || calculator.waitingForSecondOperand || displayValue === '除数不能为0') {
      return;
    }

    const result = performCalculation[operator](firstOperand, inputValue);

    if (typeof result === 'string') {
      calculator.displayValue = result;
      calculator.historyValue = '';
    } else {
      const rounded = parseFloat(result.toFixed(12));
      calculator.historyValue = `${firstOperand} ${operatorSymbols[operator]} ${inputValue} =`;
      calculator.displayValue = String(rounded);
      calculator.firstOperand = rounded;
    }

    calculator.operator = null;
    calculator.waitingForSecondOperand = false;
  }

  // 7. 单字退格 DEL
  function handleDelete() {
    if (calculator.waitingForSecondOperand || calculator.displayValue === '除数不能为0') {
      return;
    }
    if (calculator.displayValue.length === 1 || (calculator.displayValue.length === 2 && calculator.displayValue.startsWith('-'))) {
      calculator.displayValue = '0';
    } else {
      calculator.displayValue = calculator.displayValue.slice(0, -1);
    }
  }

  // 8. 百分比操作
  function handlePercent() {
    if (calculator.displayValue === '除数不能为0') return;
    const current = parseFloat(calculator.displayValue);
    if (!isNaN(current)) {
      calculator.displayValue = String(parseFloat((current / 100).toFixed(12)));
    }
  }

  // 9. 全局重置 AC
  function resetCalculator() {
    calculator.displayValue = '0';
    calculator.historyValue = '';
    calculator.firstOperand = null;
    calculator.waitingForSecondOperand = false;
    calculator.operator = null;
  }

  // 10. 屏幕渲染更新
  function updateDisplay() {
    const screenCurrent = document.getElementById('screenCurrent');
    const screenHistory = document.getElementById('screenHistory');

    screenCurrent.textContent = calculator.displayValue;
    screenHistory.textContent = calculator.historyValue;
  }

  // 11. 事件委托:统一监听键盘区点击
  const keysContainer = document.getElementById('calculatorKeys');
  keysContainer.addEventListener('click', (event) => {
    const target = event.target;

    // 过滤非按钮元素的点击
    if (!target.matches('button')) {
      return;
    }

    const { action, value, operator } = target.dataset;

    if (!action) {
      // 无 action 标记即为纯数字键
      inputDigit(value);
    } else {
      switch (action) {
        case 'operator':
          handleOperator(operator);
          break;
        case 'decimal':
          inputDecimal();
          break;
        case 'clear':
          resetCalculator();
          break;
        case 'delete':
          handleDelete();
          break;
        case 'percent':
          handlePercent();
          break;
        case 'calculate':
          handleCalculate();
          break;
      }
    }

    // 执行任意操作后,驱动视图更新
    updateDisplay();
  });

  // 初始化首次渲染
  updateDisplay();
</script>
</body>
</html>

六、执行测试用例与验证步骤

为了确保计算器各项逻辑的稳定性,建议按照以下测试用例在浏览器中执行验证:

  • 基础双目运算:连续点击 2、5、+、7、=,主屏幕应正确展示 32,历史屏显示 25 + 7 =。
  • 连续链式计算:点击 1、0、+、5、*,在按下 * 的瞬间,主屏幕应就地显示前序结果 15,历史屏变为 15 ×,继续输入 2、=,最终得出 30。
  • 连续按错符号更正:点击 8、+,随后改变主意点击 -,历史屏应立即由 8 + 更新为 8 −,且 firstOperand 依旧保持为 8。
  • 小数点单例防护:连续快速点击 1、.、2、.、3,屏幕必须稳定展示 1.23,第二个点被成功忽略。
  • 除以零友好拦截:点击 9、÷、0、=,屏幕应展示明确提示 "除数不能为0",而非原生 Infinity。
  • 浮点精度消除:点击 0、.、1、+、0、.、2、=,屏幕应精准呈现 0.3,而非 0.30000000000000004。
JavaScript实现简易计算器:HTML/CSS/JS完整代码与逻辑解析
图 4:简易计算器工程验证矩阵与核心质量指标

七、总结与常见问题排查

在实现前端简易计算器的过程中,最核心的思维转变是从“依赖 DOM 文本拼接”升级为“状态驱动视图渲染”。

初学者在编码过程中常常会遇到以下三个典型问题:

  1. 为什么点击按键后屏幕没有反应?
    排查 calculatorKeys 的点击监听是否被 button 内部嵌套的图标或文字遮挡。使用 event.target.closest('button') 或直接给 <button> 绑定纯文本可以有效避免事件目标偏差。
  2. 为什么按下等号后再输入数字,旧结果没有被清除?
    在等号结算函数 handleCalculate() 执行完成后,若希望下一次输入数字直接开启全新算式,可在计算器状态中引入 isCalculated: true 标记。当检测到该标记时,输入数字直接触发全局重置再录入。
  3. 如何支持物理键盘敲击?
    可以在 window 上挂载 keydown 事件监听器,通过 event.key 映射至对应的数字、运算符和回车等号键。由于业务逻辑已经全部封装为 inputDigit()、handleOperator()、handleCalculate() 等独立纯函数,键盘事件只需作为另一个分发源直接调用相应函数即可,无需重复编写计算逻辑。

实用工具推荐

电子包浆

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

使用 ›
图片压缩

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

使用 ›
相关文章