封装一个精准的JS四舍五入函数

在前端或 Node.js 日常业务开发中，四舍五入是最常见的数值处理需求。然而 JavaScript 官方提供的 Number.prototype.toFixed() 和基于 Math.round 的常规乘除法，在处理诸如 1.005、0.35、1.055 等数值时频繁出现“该入不入”的舍入偏差。本文直接说明核心解法：利用科学计数法进行指数位移，规避浮点数直接乘除导致的精度截断，并一步步封装一个生产环境通用的精准四舍五入函数。

一、常规四舍五入方法为何屡屡失效？

面对四舍五入需求，开发者最先想到的通常是两种现成方式：直接调用数字的原生方法 toFixed()，或是采用“乘以 10 的 n 次方，取整后再除以 10 的 n 次方”。我们先来看看它们在实际运行中的具体表现：

// 方式一：原生 toFixed()
console.log((1.005).toFixed(2)); // 输出 "1.00"（预期是 "1.01" ❌）
console.log((0.35).toFixed(1));  // 输出 "0.3" （预期是 "0.4" ❌）

// 方式二：Math.round 放大倍数法
function simpleRound(num, d) {
  const factor = Math.pow(10, d);
  return Math.round(num * factor) / factor;
}
console.log(simpleRound(1.005, 2)); // 输出 1（预期是 1.01 ❌）
console.log(simpleRound(35.855, 2)); // 输出 35.85（预期是 35.86 ❌）

这两种方法之所以在特定数值上同时失效，根源并不在于函数实现的逻辑 bug，而在于 JavaScript 遵循的 IEEE 754 双精度 64 位浮点数标准。

在计算机硬件底层，所有数字均采用二进制进行存储。然而，像 0.005、0.05 这类在十进制中有限的小数，转换为二进制浮点表示时是无限循环小数。为了保存在有限的 52 位尾数中，计算机会进行近似截断：

• 十进制字面量 1.005 在内存中的真实值其实是 1.00499999999999989341858963598...。
• 当调用 (1.005).toFixed(2) 时，底层引擎查看第三位小数，发现实际对应的是数字 4，自然执行舍去，输出 "1.00"。
• 当执行 1.005 * 100 时，浮点乘法运算导致误差放大，结果直接成为 100.49999999999999。Math.round 接收到小于 100.5 的数值，向下取整为 100，除以 100 后得到 1。

二、四舍五入常见解决思路对比

要解决浮点数四舍五入的精度丢失，业界通常有以下几种探索思路。理解它们各自的局限与适用边界，有助于我们设计出最合理的封装。

方案类型	核心原理	优势	劣势 / 适用场景
原生 toFixed	V8 引擎内置底层 C++ 转换	极速、无额外代码	精度不可靠，部分边界失真严重，不可用于金额计算
乘除法缩放法	Math.round(x * 10^n) / 10^n	实现简单、执行极快	未解决根源，乘法时依然出现二进制截断误差
第三方大数库	Decimal.js / BigNumber.js	全精度支持、算术完备	额外引入 30KB+ 体积，对象实例化有额外性能开销
科学计数法位移	利用 'e+' 与 'e-' 平移小数点	零依赖、精准度极高、性能轻量	本文推荐解法，适合作为基础工具函数集成

三、核心算法推导：科学计数法位移的精妙之处

为什么科学计数法位移能够避开浮点乘法的精度误差？关键在于：让 JavaScript 引擎以十进制文本解析器的方式，无损移动小数点位置，而不是通过二进制乘法运算来移动小数点。

来看一个直观的对比：

// 乘法放大：经历了二进制浮点相乘，丢失精度
1.005 * 100 // 结果: 100.49999999999999

// 科学计数法转换：借助字符串 'e2' 告知引擎以十进制指数解析
Number('1.005' + 'e' + 2) // 结果: 100.5

通过字符串拼接 'e2'，JavaScript 内部的字符串转数字解析器会直接将十进制小数点向右平移 2 位，精准解析为数值 100.5。此时再调用 Math.round(100.5)，标准的数学四舍五入生效，准确得到整数 101。

接着，再次通过科学计数法 Number(101 + 'e-2') 将小数点向左平移 2 位，就能还原为正确的精确数值 1.01。

四、精准四舍五入函数的完整实现

基于以上推导，我们封装两个互相配合的高可靠函数：核心数值计算函数 round，以及用于末尾补零格式化输出的 roundToFixed。

/**
 * 精准四舍五入函数（返回数值类型）
 * 采用十进制科学计数法位移，兼顾负数对称四舍五入与已含指数的极端数值
 * @param {number|string} value - 需要舍入的原始数值或数字字符串
 * @param {number} [decimals=0] - 保留的小数位数（必须是非负整数）
 * @returns {number} 舍入后的精准数值
 */
function round(value, decimals = 0) {
  // 1. 类型预处理与有效性校验
  const num = Number(value);
  if (!Number.isFinite(num)) {
    throw new TypeError(`[round] 传入的值必须是合法的有效数字，当前传入: ${value}`);
  }
  if (!Number.isInteger(decimals) || decimals < 0) {
    throw new RangeError(`[round] 保留小数位数 decimals 必须为非负整数，当前传入: ${decimals}`);
  }

  // 2. 提取符号位并处理绝对值，保证负数与正数四舍五入的对称性
  const sign = num < 0 ? -1 : 1;
  const absNum = Math.abs(num);

  // 3. 小数位为 0 时直接返回取整结果
  if (decimals === 0) {
    return sign * Math.round(absNum);
  }

  // 4. 处理已包含科学计数法表示的数字（例如 1.23e-4）
  const parts = absNum.toString().split('e');
  const base = parts[0];
  const exponent = parts[1] ? Number(parts[1]) : 0;

  // 5. 正向指数平移：将目标小数位移动至整数位后第一位，避开浮点乘法截断
  const shiftedValue = Number(`${base}e${exponent + decimals}`);

  // 6. 整数标准四舍五入
  const roundedValue = Math.round(shiftedValue);

  // 7. 逆向指数平移还原尺度
  const restoredParts = roundedValue.toString().split('e');
  const restoredBase = restoredParts[0];
  const restoredExponent = restoredParts[1] ? Number(restoredParts[1]) : 0;
  const result = Number(`${restoredBase}e${restoredExponent - decimals}`);

  return sign * result;
}

/**
 * 精准四舍五入并格式化为固定小数位数文本（末位自动补零）
 * @param {number|string} value - 需要舍入的原始数值
 * @param {number} [decimals=0] - 保留的小数位数
 * @returns {string} 包含固定小数位数的格式化字符串
 */
function roundToFixed(value, decimals = 0) {
  const roundedNum = round(value, decimals);
  if (decimals === 0) {
    return roundedNum.toString();
  }

  // 拆分为整数部分与小数部分进行补零
  const parts = roundedNum.toString().split('.');
  const integerPart = parts[0];
  const fractionalPart = parts[1] || '';

  // 补齐末尾缺失的 0
  const paddedFractional = fractionalPart.padEnd(decimals, '0');
  return `${integerPart}.${paddedFractional}`;
}

五、测试用例验证与结果复盘

为了验证封装函数的鲁棒性，我们选取了日常业务中最容易触发 bug 的 7 组经典边界数据，与 JavaScript 原生 toFixed 进行横向对比测试：

// 自动化测试套件
const testSuite = [
  { val: 1.005, d: 2, expectedNum: 1.01, expectedStr: "1.01" },
  { val: 0.35, d: 1, expectedNum: 0.4, expectedStr: "0.4" },
  { val: 1.055, d: 2, expectedNum: 1.06, expectedStr: "1.06" },
  { val: 35.855, d: 2, expectedNum: 35.86, expectedStr: "35.86" },
  { val: -1.005, d: 2, expectedNum: -1.01, expectedStr: "-1.01" },
  { val: 10, d: 2, expectedNum: 10, expectedStr: "10.00" },
  { val: '1.2e-4', d: 5, expectedNum: 0.00012, expectedStr: "0.00012" }
];

console.log('--- 测试执行结果 ---');
testSuite.forEach((item) => {
  const numResult = round(item.val, item.d);
  const strResult = roundToFixed(item.val, item.d);
  const passed = numResult === item.expectedNum && strResult === item.expectedStr;
  console.log(`输入: ${item.val} | 保留: ${item.d}位 -> 得到数值: ${numResult}, 字符: "${strResult}" | ${passed ? '通过 ✅' : '失败 ❌'}`);
});

六、生产环境应用与工程建议

1. 区分运算态与展现态：在购物车计算、折扣汇总等链路中间计算过程中，统一使用返回数值类型的 round(val, 2)，避免过早将数值转为字符串而破坏后续数学链式计算；在最终呈现在前台结账金额、打印发票凭证时，使用 roundToFixed(val, 2) 确保两位小数的视觉规范。
2. 何时需要升级为大数库？本文封装的 round 函数在 JavaScript 安全数字范围（即 Number.MIN_SAFE_INTEGER 到 Number.MAX_SAFE_INTEGER 之间，约 15~17 位有效数字）内是完全绝对精确的，能胜任 99.9% 的电商、数据大屏及报表业务。如果系统涉及极高精度的天文学模拟、密码学密钥、或大于 16 位的超大金额金融清算，才建议引入 decimal.js 等完整的大数运算框架。