序言
🐒：
我在学习学习 Go 语言的 数据类型 中的 浮点型 时遇到的不解：浮点数为什么不能直接比较？要比较的话推荐用 差值容限 ？什么是 差值容限 ？我去找 deepseek 问了一下，整理出了这篇文章。
差值容限
🐋：
在 Go 语言（以及大多数遵循 IEEE 754 标准的编程语言）中，差值容限（Epsilon） 是指在进行浮点数比较时，允许两个数值之间存在的最大微小误差范围。
一、为什么需要差值容限？
🐋：
计算机使用 二进制 存储浮点数（
float32或float64），许多十进制小数（如 0.1、0.2 ）在二进制中是 无限循环小数，无法被精确表示，只能存储为一个近似值，这导致运算结果会出现微小的精度丢失。
经典案例：
go
package main
import "fmt"
func main() {
f1 := 0.1
f2 := 0.2
sum := f1 + f2
// 数学上 0.1 + 0.2 == 0.3，但在计算机中：
fmt.Printf("%.20f\n", sum)
fmt.Println(sum == 0.3)
}
bash
0.30000000000000004441
false直接使用
==比较会返回false，因为 sum 实际上比 0.3 大了一点点。为了解决这个问题，我们引入 差值容限。
二、差值容限的含义
🐋：
差值容限 是一个极小的正数（通常记为 ϵϵ 或 epsilon ）。如果两个浮点数 AA 和 BB 的差的绝对值 小于这个容限，我们就认为它们在 "工程意义" 或 "业务意义" 上是相等的。
公式如下：
∣A−B∣< ϵ其中 ∣A−B∣ 是 两个数的绝对差值 ；ϵ 是你设定的 容忍误差阈值。
Go 语言如何实现差值容限？
方法一：固定容限（适用于已知数据范围较小的场景）
定义一个常量 epsilon ，通常设为 1e-9 （对于
float64）或 1e-6 （对于float32）。
go
package main
import (
"fmt"
"math"
)
// 定义容限，根据业务精度需求调整
const epsilon = 1e-9
// IsEqual 判断两个 float64 是否 "近似相等"
func IsEqual(f1, f2 float64) bool {
return math.Abs(f1-f2) < epsilon
}
func main() {
f1 := 0.1 + 0.2
f2 := 0.3
if IsEqual(f1, f2) {
fmt.Println("a 和 b 近似相等")
} else {
fmt.Println("a 和 b 不相等")
}
}
bash
a 和 b 近似相等方法二：相对容限（适用于数据跨度大的场景，更严谨）
如果参与比较的数字 非常大 （如
1e20）或 非常小 （如1e-20），固定的1e-9可能不再适用。
- 对于 大数 ，
1e-9太严格，正常的舍入误差可能超过它。- 对于 小数 ，
1e-9太宽松，可能导致不相关的数被判为相等。此时应使用 相对误差 ，即 容限随数值的大小动态变化：
go
package main
import (
"fmt"
"math"
)
// IsApproximatelyEqual 使用相对容限比较
func IsApproximatelyEqual(f1, f2, epsilon float64) bool {
// 处理特殊情况：如果两个数都非常接近0，直接比较绝对差
if math.Abs(f1) < epsilon && math.Abs(f2) < epsilon {
return math.Abs(f1-f2) < epsilon
}
// 相对误差公式: |f1 - f2| / max(|f1|, |f2|) < epsilon 等价于: |f1 - f2| < max(|f1|, |f2|) * epsilon
// 分母取两者中较大的绝对值，避免除以零或过小值
largest := math.Max(math.Abs(f1), math.Abs(f2))
return math.Abs(f1-f2) <= largest*epsilon
}
func main() {
// 场景：大数运算
// 在 float64 中，1e15 的精度大约是 1e-1 (即小数点后 1 位左右是可靠的)
// 任何更小的尾数变化都可能因为舍入而丢失或产生较大绝对误差
// 让我们构造一个更典型的 "计算后应相等但存在误差" 的例子
// 比如：(1e15 + 0.1) - 1e15 理论上等于 0.1
// 但实际上，由于 1e15 太大，0.1 加上去可能被舍入掉，或者产生微小偏差
f1 := 1e15
f2 := 1e15 + 0.1
f3 := f2 - 1e15
fmt.Printf("原始值 f1: %.20f\n", f1)
fmt.Printf("中间值 f2 (f1 + 0.1): %.20f\n", f2)
fmt.Printf("计算值 f3 (f2 - f1): %.20f\n", f3)
fmt.Printf("期望值: 0.1\n")
fmt.Printf("绝对差值 |f3 - 0.1|: %.20e\n", math.Abs(f3-0.1))
epsilon := 1e-9
fmt.Println("\n--- 比较 f3 和 0.1 ---")
relativeResult := IsApproximatelyEqual(f3, 0.1, epsilon)
fmt.Printf("相对容限 (%.0e): %v\n", epsilon, relativeResult)
if relativeResult {
fmt.Println("-> 成功原因：虽然绝对差值大，但相对于数值大小，误差在允许范围内")
}
// 另一个更极端的例子：两个非常大的数，它们只差一点点，但绝对差值很大
fmt.Println("\n--- 极端大数比较 ---")
x := 1e20
y := 1e20 + 1e10 // 相差 100亿，相对于 1e20 来说很小
fmt.Printf("x: %.2e\n", x)
fmt.Printf("y: %.2e\n", y)
fmt.Printf("绝对差值: %.2e\n", math.Abs(x-y))
// 相对容限：差值 1e10 / 最大值 1e20 = 1e-10，小于 1e-9，所以成功
fmt.Printf("相对容限 (%.0e) 比较 x 和 y: %v (成功，因为相对误差仅为 1e-10)\n", epsilon, IsApproximatelyEqual(x, y, epsilon))
}
bash
原始值 f1: 1000000000000000.00000000000000000000
中间值 f2 (f1 + 0.1): 1000000000000000.12500000000000000000
计算值 f3 (f2 - f1): 0.12500000000000000000
期望值: 0.1
绝对差值 |f3 - 0.1|: 2.49999999999999944489e-02
--- 比较 f3 和 0.1 ---
相对容限 (1e-09): false
--- 极端大数比较 ---
x: 1.00e+20
y: 1.00e+20
绝对差值: 1.00e+10
相对容限 (1e-09) 比较 x 和 y: true (成功，因为相对误差仅为 1e-10)如何选择容限值？
| 数据类型 | 推荐默认容限 | 说明 |
|---|---|---|
float32 |
1e-6 | 精度约为 7 位十进制数字 |
float64 |
1e-9 ~ 1e-15 | 精度约为 15-17 位十进制数字; 一般业务用 1e-9 足够； 科学计算可能需要更小。 |
注意：
- 金融/货币场景 ：不要 使用浮点数比较，即使加了容限也不推荐。应将金额转换为整数（如 "分" ）进行精确比较，或使用
github.com/shopspring/decimal等高精度库。- 图形/物理引擎 ：通常使用固定容限（如 1e-5），因为坐标值范围通常可控。
总结
在 Go 语言中比较浮点数时：
- 严禁 直接使用
==。- 常用做法 ：计算两数之差的绝对值
math.Abs(a - b)。- 判断标准 ：检查该差值是否小于你定义的 差值容限（epsilon） 。
- 进阶做法 ：若数值范围差异巨大，使用 相对容限 比较。