JS 保留一位小数：toFixed、Math 与正则方案对比选型

一、方案一：toFixed(1) 原生方法及其舍入陷阱

Number.prototype.toFixed() 是 JavaScript 语言内置的格式化方法。当传入参数 1 时，它会将数字四舍五入并以字符串形式返回，保留一位小数。如果原数字是整数或小数位不足一位，它会自动在末尾补零。

1. 基础用法与预期表现

// 浏览器控制台或 Node.js 环境执行
const val1 = 3.46;
const res1 = val1.toFixed(1);

const val2 = 5;
const res2 = val2.toFixed(1);

console.log('val1 结果:', res1, '类型:', typeof res1);
console.log('val2 结果:', res2, '类型:', typeof res2);

2. 致命陷阱：偶合偏差与非标准四舍五入

在实际业务中，许多开发者常将 toFixed(1) 当作标准的数学“四舍五入”使用，但在面对边界值 .x5 时，它经常产生反直觉的结果。例如：

// 常见 .x5 边界测试
console.log((1.05).toFixed(1)); // 输出 "1.0"（直觉预期应为 "1.1"）
console.log((1.15).toFixed(1)); // 输出 "1.1"（直觉预期应为 "1.2"）
console.log((1.25).toFixed(1)); // 输出 "1.3"（符合预期）
console.log((1.35).toFixed(1)); // 输出 "1.4"（符合预期）
console.log((1.45).toFixed(1)); // 输出 "1.4"（直觉预期应为 "1.5"）

产生这种现象的根源在于：JavaScript 中的数字均遵循 IEEE 754 双精度 64 位浮点数标准。在二进制浮点表示下，绝大多数十进制小数无法精确表达为有限位数的二进制，必须进行近似存储。十进制的 1.05 在内存中实际存储的值大约是：

1.049999999999999933386618522491770684719085693359375

当执行 toFixed(1) 时，V8 引擎并不是在十进制的 1.05 上进行判断，而是在这个略小于 1.05 的近似二进制浮点数上进行运算。因为该值甚至没有触及理想分界线 1.05，引擎自然将其向下归为 "1.0"。

二、方案二：Math 算术缩放法（数值运算与截断）

如果需要的结果是 Number 类型，或者需要严格的“向下截断”而不是四舍五入，通常采用 Math 对象配合乘除 10 的缩放运算。

1. 常规乘除缩放实现

// 模式 A：四舍五入为纯数字
function roundOne(num) {
  return Math.round(num * 10) / 10;
}

// 模式 B：向下截断为纯数字（不向上进位）
function truncOne(num) {
  return Math.trunc(num * 10) / 10;
}

console.log('roundOne(4.56):', roundOne(4.56));
console.log('roundOne(2.00):', roundOne(2.00));
console.log('truncOne(4.59):', truncOne(4.59));

2. Math 缩放法的精度局限与指数位移修复

直接使用 num * 10 同样可能触碰浮点数算术误差。例如 1.005 * 100 会变成 100.49999999999999。为了在保留一位小数时得到严格可靠的四舍五入，行业内标准的轻量级解法是科学计数法指数位移法：

// 稳健的四舍五入保留一位小数
function safeRoundOne(num) {
  if (isNaN(num)) return 0;
  // 利用指数字符串形式位移小数点，完全避开浮点乘法带来的中间失真
  return Number(Math.round(Number(num + 'e1')) + 'e-1');
}

console.log('safeRoundOne(1.05):', safeRoundOne(1.05)); // 得到 1.1
console.log('safeRoundOne(1.45):', safeRoundOne(1.45)); // 得到 1.5

三、方案三：正则与字符串截断法（绝对无误差截断）

在电商提现、优惠券满减、阶梯分润等业务中，业务规则通常明确要求“只舍不入”：即无论第二位小数是多大，均不进位，且要求展示格式固定为包含一位小数的字符串（如 "12.0"）。

使用字符串切分或正则表达式截取，可以完全绕过任何浮点算术乘除运算，直接在字符层面进行精准截断与补零，具有极高的确定性。

1. 正则匹配模式

// 利用正则直接提取符号、整数部分以及第一位小数
function regexTruncOne(num) {
  const str = String(num);
  // 匹配可选负号、整数部分及至多一位小数
  const match = str.match(/^-?\d+(?:\.\d)?/);
  return match ? match[0] : '0';
}

console.log(regexTruncOne(12.38));  // "12.3"
console.log(regexTruncOne(-8.96));  // "-8.9"
console.log(regexTruncOne(7));      // "7"（未补零）

2. 字符串分割 + 规范补零（推荐模板）

如果要求同时满足“截断”与“强制补足一位小数”，使用 split('.') 进行解构拼接通常比复杂正则更加清晰且易维护：

function truncWithPadding(num) {
  const n = Number(num);
  if (isNaN(n)) return '0.0';
  
  // 处理极小科学计数法（如 1e-7）
  const str = n.toFixed(10); // 适度展开为常规小数字符串
  const [integerPart, decimalPart = ''] = str.split('.');
  const firstDecimal = decimalPart[0] || '0';
  
  return `${integerPart}.${firstDecimal}`;
}

console.log(truncWithPadding(12.39)); // "12.3"
console.log(truncWithPadding(8));     // "8.0"
console.log(truncWithPadding(0.06));  // "0.0"

四、操作步骤：如何为你的业务选择最优实现

在实际项目编码中，请按照以下 4 个连续步骤进行快速判定：

1. 步骤一：确认业务取整规则。明确需求是“四舍五入”（如均值统计）还是“向下截断”（如金币折现）。若是向下截断，直接排除 toFixed。
2. 步骤二：确认数据类型与补零要求。如果返回值需要继续参与后续代数方程或坐标运算，选择 Number 返回形态；如果是传给前端模板展示，且要求 2 显示为 "2.0"，选择带补零的格式化字符串。
3. 步骤三：评估输入数据范围。确认是否存在负数（负数向下取整需特别注意 Math.floor 会向负无穷靠拢导致 -1.2 变成 -2，应统一使用 Math.trunc），以及是否存在科学计数法极小数。
4. 步骤四：装配对应的标准函数。

五、多维度对比矩阵与工程总结

综合对比各方案的技术指标与适用边界，汇总如下表：

工程落地建议

在企业级业务中，建议将保留一位小数的逻辑统一收敛为公用工具函数，避免各个业务页面零散调用 toFixed 导致的偶合 Bug：

/**
 * 保留一位小数通用处理工具
 * @param {number|string} val 输入值
 * @param {'round'|'trunc'} mode 模式：'round' 四舍五入，'trunc' 向下截断
 * @param {boolean} padZero 是否强制补零返回字符串
 * @returns {number|string}
 */
function formatToOneDecimal(val, mode = 'round', padZero = false) {
  const num = Number(val);
  if (isNaN(num)) return padZero ? '0.0' : 0;

  let resultNum;
  if (mode === 'round') {
    resultNum = Number(Math.round(Number(num + 'e1')) + 'e-1');
  } else {
    // 截断采用字符分割，杜绝浮点算术偏差
    const str = num.toFixed(10);
    const [i, d = ''] = str.split('.');
    resultNum = Number(`${i}.${d[0] || '0'}`);
  }

  if (padZero) {
    return resultNum.toFixed(1);
  }
  return resultNum;
}

通过明确业务规则是“舍入”还是“截断”，并根据消费端需求决定输出类型与补零策略，即可在 JavaScript 各种复杂业务场景中稳健、优雅地实现保留一位小数。