floor函数和round函数有什么区别？用例子看懂取整方式

“把小数变成整数”听起来像一个简单操作，但结果取决于采用哪种取整规则。floor 和 round 的区别尤其容易在负数、临界值和跨语言代码中被忽略：前者始终朝负无穷方向取整，后者则按照特定的舍入规则取最近值，而“正好一半时怎么办”还可能因语言而异。

本文先讲清楚数学定义，再用 Python 和 JavaScript 的可运行示例展示差异，最后说明它们适合什么场景、有哪些边界，以及为什么不能随手用它们处理金额或安全判断。

先看结论：floor 向下，round 取最近

函数	基本规则	例子
floor(x)	取小于或等于 x 的最大整数，也就是向负无穷方向取整。	floor(3.8) = 3，floor(-3.2) = -4
round(x)	取距离 x 最近的整数；距离正好相等时如何处理，要看语言或所用类型的规则。	round(3.2) 通常为 3；临界值 3.5 的结果因规则而异。

最重要的区别在负数上。floor(-3.2) 是 -4，不是 -3。-3 虽然看起来像“去掉小数部分”，但它比 -3.2 大，不符合 floor 的数学定义。

floor 的准确含义：不大于原数的最大整数

数学上的 floor 函数常写作 ⌊x⌋，定义是：

floor(x) = 不大于 x 的最大整数

因此：

• floor(4.9) = 4
• floor(4.0) = 4
• floor(0.1) = 0
• floor(-0.1) = -1
• floor(-4.9) = -5

理解负数时，可以把数轴想象成从左到右递增。负数越往左，数值越小。-1 比 -0.1 小，所以小于或等于 -0.1 的最大整数是 -1。

floor 不等于“删除小数部分”

有些语言或场景中的“截断”是直接朝零靠近：3.8 变成 3，-3.8 变成 -3。这与 floor 只在非负数上看起来一样，负数结果不同：

原数	floor：朝负无穷	截断：朝零
3.8	3	3
-3.8	-4	-3

若需求是“向零截断”，应使用对应语言提供的截断函数，而不是把 floor 当作它的同义词。例如 Python 有 math.trunc，JavaScript 可使用 Math.trunc。函数名称和返回类型仍应以目标语言文档为准。

round 的含义：取最近整数，但临界值规则不统一

普通的 round 会选择距离输入值最近的整数。比如离 3 更近的 3.2 通常取为 3，离 4 更近的 3.8 通常取为 4。

麻烦出在恰好位于两个整数中间的值，例如 2.5：它到 2 和 3 的距离完全相同。此时并不存在唯一的数学答案，程序语言必须选择一条约定。常见规则包括：

• ties-to-even（五成双、银行家舍入）：临界值取到最近的偶数整数。2.5 取 2，3.5 取 4。
• 远离零舍入：临界值朝远离零的方向取整。2.5 取 3，-2.5 取 -3。
• 向正无穷方向处理临界值：临界值取较大的那个整数。2.5 取 3，-2.5 取 -2。

这些规则在非临界值上通常给出相同结果，在恰好一半时才会暴露差异。因此，比较不同语言、库或数据格式的结果时，不要只测试 2.4 和 2.6，还要测试正负临界值。

Python 示例：math.floor 与 round

下面的代码适用于 Python 3，可直接运行：

import math

values = [3.8, 3.2, 0.5, -0.5, -3.2, -3.8]

for x in values:
    print(
        f"x={x:4}, "
        f"floor={math.floor(x):2}, "
        f"round={round(x):2}, "
        f"trunc={math.trunc(x):2}"
    )

print("round(2.5) =", round(2.5))
print("round(3.5) =", round(3.5))
print("round(-2.5) =", round(-2.5))

典型输出如下：

x= 3.8, floor= 3, round= 4, trunc= 3
x= 3.2, floor= 3, round= 3, trunc= 3
x= 0.5, floor= 0, round= 0, trunc= 0
x=-0.5, floor=-1, round= 0, trunc= 0
x=-3.2, floor=-4, round=-3, trunc=-3
x=-3.8, floor=-4, round=-4, trunc=-3
round(2.5) = 2
round(3.5) = 4
round(-2.5) = -2

Python 内置的 round 对内置数值类型采用 ties-to-even 规则，所以 2.5 取为 2，3.5 取为 4，-2.5 取为 -2。这不是“总是向上”或“总是远离零”。

math.floor(x) 返回整数。对支持取整协议的数值对象，它会调用相应的取整行为；通常的使用对象是实数。round(x) 不传第二个参数时，对内置整数和浮点数返回整数；但 Python 允许自定义数值类型实现自己的舍入行为，不能据此推断所有对象都具有完全相同的返回类型和细节。

Python 的 round 还能指定保留位数

Python 的 round(number, ndigits) 可以指定舍入到小数点后多少位；ndigits 为正数时保留小数位，为负数时舍入到十位、百位等：

print(round(12.345, 2))   # 12.35
print(round(1234, -2))    # 1200
print(round(2.5))         # 2
print(round(3.5))         # 4

这里还要留意二进制浮点数的表示误差。很多十进制小数不能被二进制浮点格式精确表示，因此程序内部的实际值可能略高于或略低于你写下的十进制数。round(2.675, 2) 在 Python 中可能得到 2.67，不能简单解释成“Python 的规则失效了”：舍入依据是浮点数实际保存的值，而它不一定正好是十进制的 2.675。

JavaScript 示例：Math.floor 与 Math.round

JavaScript 的 Math.floor 同样是朝负无穷方向取整；Math.round 的临界值规则则与 Python 不同。对正负半整数，JavaScript 的 Math.round 选择较大的整数，也就是朝正无穷方向处理：

const values = [3.8, 3.2, 0.5, -0.5, -3.2, -3.8];

for (const x of values) {
  console.log(
    `x=${x}, floor=${Math.floor(x)}, ` +
    `round=${Math.round(x)}, trunc=${Math.trunc(x)}`
  );
}

console.log("Math.round(2.5) =", Math.round(2.5));
console.log("Math.round(3.5) =", Math.round(3.5));
console.log("Math.round(-2.5) =", Math.round(-2.5));

输出为：

x=3.8, floor=3, round=4, trunc=3
x=3.2, floor=3, round=3, trunc=3
x=0.5, floor=0, round=1, trunc=0
x=-0.5, floor=-1, round=0, trunc=0
x=-3.2, floor=-4, round=-3, trunc=-3
x=-3.8, floor=-4, round=-4, trunc=-3
Math.round(2.5) = 3
Math.round(3.5) = 4
Math.round(-2.5) = -2

特别注意：JavaScript 中 Math.round(-2.5) 是 -2，不是 -3。把“半数总是远离零”当成 JavaScript 的规则会导致错误。JavaScript 的 Math.round 对某些负数还可能返回负零；它与正零在比较时相等，但可以通过 Object.is(value, -0) 检查。

JavaScript 的 Math.floor 和 Math.round 接收数值参数，并在必要时尝试将参数转换为数值。无法转换的输入会得到 NaN；正负无穷本身也会作为结果保留。它们不是用于验证输入格式的函数：需要可靠输入时，应先明确检查类型和取值范围，而不是依赖隐式转换。

floor 适合哪些场景

当问题描述的是“完整单位的数量”或“落在哪个更低的区间”时，floor 往往合适。关键是先确认业务语义确实要求朝负无穷方向取整，尤其要确认输入是否可能为负数。

计算分组或区间编号

若要将整数编号按每 10 个一组，常见做法是用 floor 计算组号。但对于负数，编程语言的整数除法规则可能与 floor 除法不同。若业务编号允许负数，应明确使用 floor 除法的含义，不要默认“整数除法”就等于 floor。

import math

def bucket_index(value, width):
    if width <= 0:
        raise ValueError("width 必须为正数")
    return math.floor(value / width)

for value in [0, 9, 10, -1, -10, -11]:
    print(value, bucket_index(value, 10))

这里的区间编号基于数学上的 floor。例如 -1 除以宽度 10 得到约 -0.1，floor 后是 -1。如果程序改用朝零截断，结果就会是 0，负数会被分到另一组。

计算容器能容纳多少个完整单位

若有长度为 12.7 的材料，每段需要 3 个长度单位，完整段数是 floor(12.7 / 3) = 4。这类计算常见于分页、容量估算和固定大小的数据块规划。实际代码仍需处理零、负数、单位不一致和浮点误差等输入问题。

import math

length = 12.7
unit_length = 3.0

if unit_length <= 0:
    raise ValueError("unit_length 必须大于 0")

count = math.floor(length / unit_length)
print(count)  # 4

若输入来自二进制浮点计算，且理论上应恰好是整数的比值可能落在整数稍下方，floor 就可能少算一段。不能为了“修正”而盲目加一个很小的常数；应先定义允许误差，再选择适合数据类型和业务精度的算法。

round 适合哪些场景

当需求是“给用户展示一个近似值”时，round 通常比 floor 更自然。例如把距离显示到整数米、将测量读数展示到指定小数位。不过展示规则也要和产品或行业约定一致：临界值采用哪种舍入方式、是否显示末尾零，都可能影响结果。

当 round 用于计算而非显示时，也应先写清业务规则。统计结果采用 ties-to-even 可能有助于减少大量数据重复舍入时的系统性偏差；但财务、税务、计费等场景的规则可能由合同、法规或系统规范决定，不能因为某语言默认这样做就直接采用。

参数限制与输入边界

floor 的参数不是“随便一个字符串”

floor 的数学定义针对数值。各语言具体接受什么类型，取决于语言及其数值协议：Python 的 math.floor 面向可转换为整数的数值对象，不会把任意文本都当作合法数值；JavaScript 则会对传入值进行数值转换，因而可能出现字符串被转换为数字、无效内容变成 NaN 的情况。跨语言搬运代码时，不要假设输入检查行为相同。

还要区分“参数合法”与“结果可用于业务”。例如 NaN、无穷大、超大数值、负的长度或零除数，都可能需要单独处理。函数能够返回一个值，不代表这个值符合业务约束。

round 的位数参数并非所有语言都一样

不同语言的 round 接口并不统一。Python 的内置 round 支持可选的 ndigits，负数表示舍入到小数点左侧；JavaScript 的 Math.round 只有一个参数，不提供“保留几位小数”的参数。看到跨语言示例时，应确认使用的到底是语言内置函数，还是某个库的扩展函数。

即便语言允许指定位数，也要看参数类型、返回类型、临界值规则和数值精度。例如 Python 的 ndigits 应按整数位数理解；对于自定义数值类型，具体支持能力还可能由类型自身决定。不要把一种语言的调用方式直接照搬到另一种语言。

常见错误一：把 floor 当成向零取整

这是负数计算中最常见的混淆。若要计算“向零截断”，对 -2.7 应得到 -2；若要计算 floor，则结果是 -3。先用一句话写出规则，再选择函数，比根据函数名称猜含义可靠。

import math

x = -2.7

print(math.floor(x))  # -3：朝负无穷方向
print(math.trunc(x))  # -2：朝零方向

常见错误二：假定 round 在所有语言中都一样

Python 与 JavaScript 对临界值的处理不同：round(2.5) 在 Python 中是 2，Math.round(2.5) 在 JavaScript 中是 3。负数同样不能用“半数向上”这类含糊说法代替精确定义：向数值更大的一侧、远离零的一侧和绝对值更大的偶数，可能是不同结果。

迁移代码、重写服务或对账时，建议为正负临界值都建立测试，例如 2.5、3.5、-2.5、-3.5。如果业务要求固定规则，应在程序中明确实现或使用提供该规则的数值类型，而不要依赖语言默认行为。

常见错误三：认为 round 能解决浮点精度问题

round 是舍入操作，不是十进制精确计算工具。用二进制浮点数表示金额，再在最后调用 round，并不能保证每一步都符合十进制规则。中间计算的表示误差可能影响边界判断、累加结果和舍入结果。

对金额、税额和费率，应根据系统要求使用十进制定点数、整数最小货币单位，或明确规定精度和舍入流程的数值库。Python 可使用 decimal.Decimal 表示十进制数，并根据需要指定舍入模式。注意从字符串构造十进制值，通常比先转成二进制浮点数再构造更符合预期：

from decimal import Decimal, ROUND_HALF_UP

amount = Decimal("2.675")
rounded = amount.quantize(
    Decimal("0.01"),
    rounding=ROUND_HALF_UP
)

print(rounded)  # 2.68

这里的 ROUND_HALF_UP 是十进制模块提供的一种明确舍入模式。它只是示例，不代表所有金融场景都应采用该模式；实际使用应以适用的业务规范为准。

常见错误四：用舍入后的值做精确相等判断

把浮点结果先 round 再比较，有时能满足显示或容差需求，但不能一概而论。对于测量值，更合适的办法往往是比较差值是否小于事先定义的容差；对于金额，则应使用符合业务精度的数据表示。舍入可能掩盖本应被发现的精度差异，也可能把两个不同输入压成同一个结果。

例如判断两个浮点测量值是否足够接近，可以明确规定容差：

def nearly_equal(a, b, tolerance=1e-9):
    if tolerance < 0:
        raise ValueError("tolerance 不能为负数")
    return abs(a - b) <= tolerance

print(nearly_equal(0.1 + 0.2, 0.3))

容差应该来自应用对误差的要求，而不是随手挑一个看起来够小的数字。不同数量级、不同单位下，同一绝对容差可能意义完全不同。

常见错误五：把取整当作安全校验

floor 和 round 都不是安全函数，也不会自动验证输入可信、限制取值范围或防止越权。它们不能代替服务端校验、权限检查、参数边界检查或防止数值溢出的处理。

尤其不要在安全敏感逻辑里先把输入 round，再判断权限或额度是否达标。舍入可能让略低于阈值的值看起来刚好达标，也可能让无效输入经过转换后混入正常流程。应先验证原始输入的格式、类型、范围与来源，再按照明确的业务规则计算；安全决策应基于验证后的权威数据，而不是客户端可修改的显示值。

取整本身也不提供密码学安全性。它不适合生成随机数、校验令牌或掩盖敏感数据。如果目的是限制信息泄露或处理安全边界，应采用经过设计和审查的专门机制，不能寄希望于减少小数位。

JavaScript 中还要留意大整数精度

JavaScript 的普通 Number 使用双精度浮点格式。安全整数范围之外的整数不一定能被精确区分，取整函数也无法恢复已经丢失的精度。因此，不能因为 Math.floor 返回了一个整数样子的数，就认为它适合表示任意大的精确整数。

如果业务需要精确处理超出安全整数范围的整数，应评估使用 BigInt 或其他适当的数据表示。BigInt 与 Number 是不同类型，不能直接混合运算；而且 Math.floor、Math.round 面向的是 Number，不能直接拿来处理任意精度的 BigInt。应按目标运行环境的类型规则设计计算过程。

快速选择：应该用哪个函数？

• 需要“不大于原数的最大整数”，例如向负无穷方向分桶：选 floor。
• 需要“直接朝零丢弃小数部分”：选截断函数，而不是 floor。
• 需要“取最近整数或指定精度展示”：考虑 round，并确认临界值规则。
• 处理金额或税费：先确定十进制精度与业务舍入规范，优先使用合适的精确数值表示。
• 处理用户输入或安全阈值：先做类型、范围、权限等校验，不能把取整函数当作验证机制。

小结

floor 的规则明确：始终取不大于原数的最大整数，所以负数会朝更小的方向变化。round 则取最近值，但在恰好一半时可能采用不同规则，Python、JavaScript 等语言的行为并不完全相同。

编写取整代码时，重点检查三个问题：输入是否可能为负数，临界值按什么规则舍入，所用数值类型是否能精确表达业务需要。把这些规则写进测试和接口约定，比只记住一个函数名称更可靠。