JS中除了Math.floor还有哪些向下取整的方法？

一、取整核心分水岭：向下取整与向零截断的本质区别

在日常开发中，许多人习惯把 ~~x 或 x | 0 当作 Math.floor(x) 的极简写法。这种认知在仅处理正数（如像素坐标、分页页码、数组索引）时不会报错，但其底层数学定义存在本质分歧：

• 向下取整（Floor）：沿着数轴始终向负无穷（-∞）方向寻找小于或等于当前数值的最大整数。例如：Math.floor(3.7) 得到 3，而 Math.floor(-3.2) 会继续向左得到 -4。
• 向零截断（Truncate）：无论数值正负，直接丢弃小数点后的一切数字，向数轴原点（0）收敛。例如：3.7 截断后为 3，而 -3.2 截断后向右收敛为 -3。

// 关键对比示例
console.log(Math.floor(3.7));   // 3
console.log(Math.floor(-3.2));  // -4 （向负无穷寻找）

console.log(3.7 | 0);          // 3 （与 Math.floor 一致）
console.log(-3.2 | 0);         // -3 （本质是截断，与 Math.floor 不一致！）

二、位运算替代方法：~~x、x | 0 与 x >> 0

位运算能够在无需调用任何函数的情况下快速抹去浮点数的小数位，是许多开源库与图形算法中常见的技巧。常见的形式有三种：

1. 双按位非（~~x）：两次按位取反。第一次 ~x 将浮点数转为 32 位整数并按位取反，第二次 ~ 再次取反恢复原数值符号。
2. 按位或零（x | 0）：将数值与 32 位整型 0 执行按位或运算，整数位保持不变，小数部分被丢弃。
3. 有符号右移零位（x >> 0）：将数值保留符号位右移 0 位，同样触发整型转换机制。

为什么位运算能“抹去”小数？

JavaScript 中的所有数字在底层都以 IEEE 754 标准的 64 位双精度浮点数存储。但在执行任何按位操作之前，ECMAScript 规范会强制执行抽象操作 ToInt32(value)。该操作包含四个核心阶段：

这一过程不经过任何函数栈调用，直接在 CPU 的整型寄存器级别完成转换，因此在处理大规模密集运算时，微观执行速度非常快。

三、位运算替代方案的三大致命边界陷阱

尽管位运算书写简洁，但在没有充分防御的前提下使用它替代 Math.floor，极易引发生产环境隐蔽 bug：

1. 32 位有符号整型溢出

JavaScript 的 Number.MAX_SAFE_INTEGER 为 2^53 - 1（即 9,007,199,254,740,991），在这个范围内常规数字都不会丢失精度。但位运算符强制将数值限制在 32 位有符号补码区间 [-2^31, 2^31 - 1]，也就是 -2,147,483,648 到 2,147,483,647。

const largeNumber = 2147483648.5; // 刚好超过 2^31 - 1

console.log(Math.floor(largeNumber)); // 2147483648 （正确）
console.log(largeNumber | 0);         // -2147483648 （最高位溢出为符号位，突变为负数！）
console.log(~~largeNumber);           // -2147483648 （同样溢出错误）

在当今业务中，13 位 Unix 毫秒时间戳（例如 1731240000000）或者数据库分布式 ID 远大于 21 亿，对它们使用位运算取整会产生不可逆的数据破坏。

2. 异常值静默抹平为 0

当计算出现异常传入 NaN 或 Infinity 时，Math.floor(NaN) 返回 NaN，Math.floor(Infinity) 返回 Infinity，能够忠实保留异常上下文。

console.log(Math.floor(NaN));       // NaN
console.log(~~NaN);                 // 0
console.log(Infinity | 0);          // 0
console.log(~~undefined);           // 0

位运算会把所有无法转换为数字的值静默变为 0，导致原本应当暴露的计算错误或数据缺失被彻底掩盖。

四、ES6 标准方法：Math.trunc() 及其向下兼容转换

为了解决位运算溢出和语义不清的问题，ECMAScript 2015 (ES6) 原生引入了 Math.trunc()。它的语义就是清晰的“向零截断”：

console.log(Math.trunc(3.7));   // 3
console.log(Math.trunc(-3.2));  // -3
console.log(Math.trunc(2147483648.5)); // 2147483648 （不受 32 位限制，大数安全）

如果你需要一个不依赖 Math.floor、但又能对负数严格向下取整的方法，可以结合 Math.trunc() 进行条件修正：

/**
 * 基于 Math.trunc 构造严格向下取整
 * @param {number} num
 * @returns {number}
 */
function strictFloor(num) {
  const trunc = Math.trunc(num);
  // 当为负数且含有小数位时，截断值需再减 1
  return num < 0 && num !== trunc ? trunc - 1 : trunc;
}

console.log(strictFloor(3.7));   // 3
console.log(strictFloor(-3.2));  // -4 （符合严格向下取整）

五、其他替代路径：parseInt() 与纯算术公式

1. parseInt(x, 10) 的解析机制与弊端

很多初学者会使用 parseInt(num, 10) 来抹掉小数。虽然对于一般正数它确实能输出整数，但它在纯数值计算中并不推荐：

1. 类型转换损耗：parseInt 会先将数值转化为字符串，再按字符解析，性能显著慢于数学计算。
2. 科学计数法陷阱：当浮点数极大或极小时，JavaScript 会自动将其转为科学计数法字符串。例如 1e21 转为字符串是 "1e+21"，parseInt 遇到非数字字符 e 便会立即终止解析，返回 1！

   console.log(Math.floor(1e21));    // 1000000000000000000000
   console.log(parseInt(1e21, 10));  // 1 （严重错误！）
   console.log(parseInt(0.0000005, 10)); // "5e-7" -> 5 （同样解析失真）

2. 纯算术公式推导（基于模运算 %）

在完全不使用任何内置函数的情况下，可以通过减去浮点数自身的小数部分实现纯数学向下取整：

/**
 * 基于模运算的纯算术严格向下取整
 * @param {number} n
 * @returns {number}
 */
function arithmeticFloor(n) {
  const rem = n % 1;
  if (rem === 0) return n;
  // 正数减去余数；负数减去余数后再减 1（例如 -3.2 % 1 = -0.2，-3.2 - (-0.2) - 1 = -4）
  return rem > 0 ? n - rem : n - rem - 1;
}

console.log(arithmeticFloor(3.7));   // 3
console.log(arithmeticFloor(-3.2));  // -4

这种做法完全在 64 位浮点数安全范围内运行，不依赖任何 Math 对象属性，且对全实数域保持严格一致的向下取整结果。

六、工程实战：如何选择最合适的取整方案？

面对多样化的取整语法，选择的核心在于对输入数据范围的掌控度以及对代码可维护性的权衡：

七、横向特性全景对照速查

下表和图示总结了本文讨论的所有取整方式的关键特性：