答案是使用反射实现自定义深度比较可处理不可比较类型、忽略特定字段并支持浮点数精度控制，而==仅适用于所有字段可比较的结构体，DeepEqual无法跳过字段或自定义比较逻辑。
在 Go 语言中，结构体的深度比较通常使用 reflect.DeepEqual 函数即可完成。但在某些场景下，比如需要自定义比较逻辑、忽略特定字段或处理不可比较类型时，直接使用反射实现一个灵活的动态比对函数会更实用。
为什么不能只用 == 或 DeepEqual？
Go 中结构体支持 == 比较的前提是所有字段都可比较，但包含 slice、map、func 等字段的结构体无法直接使用 ==。而 reflect.DeepEqual 虽然能处理大多数情况，但它无法跳过某些字段（如时间戳、ID），也不能自定义浮点数精度等比较规则。
使用反射实现自定义深度比较函数
下面是一个基于反射的结构体动态比对示例，支持：
- 递归遍历结构体字段
- 跳过 tag 标记为 cmp:"-" 的字段
- 处理基础类型、指针、嵌套结构体
- 浮点数按近似值比较（可选）
package main
import (
"fmt"
"math"
"reflect"
)
// approxEqual 判断两个浮点数是否接近
func approxEqual(a, b, epsilon float64) bool {
return math.Abs(a-b) < epsilon
}
// deepCompare 使用反射进行深度比较，可忽略指定字段
func deepCompare(x, y interface{}, opts ...CompareOption) bool {
opt := defaultOptions()
for _, o := range opts {
o(opt)
}
vx := reflect.ValueOf(x)
vy := reflect.ValueOf(y)
if !vx.IsValid() && !vy.IsValid() {
return true
}
if !vx.IsValid() || !vy.IsValid() {
return false
}
// 解引用指针
if vx.Kind() == reflect.Ptr {
if !vx.IsNil() {
vx = vx.Elem()
} else {
return vy.IsNil()
}
}
if vy.Kind() == reflect.Ptr {
if !vy.IsNil() {
vy = vy.Elem()
} else {
return vx.IsNil()
}
}
return compareValue(vx, vy, opt)
}
type CompareOptions struct {
skipTags map[string]bool
floatEpsilon float64
}
type CompareOption func(*CompareOptions)
func WithSkipTag(tag string) CompareOption {
return func(o *CompareOptions) {
o.skipTags[tag] = true
}
}
func WithFloatPrecision(eps float64) CompareOption {
return func(o *CompareOptions) {
o.floatEpsilon = eps
}
}
func defaultOptions() *CompareOptions {
return &CompareOptions{
skipTags: make(map[string]bool),
floatEpsilon: 1e-9,
}
}
func compareValue(vx, vy reflect.Value, opt *CompareOptions) bool {
if vx.Type() != vy.Type() {
return false
}
switch vx.Kind() {
case reflect.Struct:
for i := 0; i < vx.NumField(); i++ {
field := vx.Type().Field(i)
if opt.skipTags[field.Name] {
continue
}
// 检查 cmp tag
if tag := field.Tag.Get("cmp"); tag == "-" {
continue
}
if !compareValue(vx.Field(i), vy.Field(i), opt) {
return false
}
}
return true
case reflect.Slice:
if vx.Len() != vy.Len() {
return false
}
for i := 0; i < vx.Len(); i++ {
if !compareValue(vx.Index(i), vy.Index(i), opt) {
return false
}
}
return true
case reflect.Map:
if vx.Len() != vy.Len() {
return false
}
for _, k := range vx.MapKeys() {
v1 := vx.MapIndex(k)
v2 := vy.MapIndex(k)
if !v2.IsValid() || !compareValue(v1, v2, opt) {
return false
}
}
return true
case reflect.Float32, reflect.Float64:
f1 := vx.Float()
f2 := vy.Float()
return approxEqual(f1, f2, opt.floatEpsilon)
default:
return reflect.DeepEqual(vx.Interface(), vy.Interface())
}
}
实际使用示例
定义两个结构体并进行智能比对：
立即学习“go语言免费学习笔记（深入）”；
type User struct {
ID int `cmp:"-"`
Name string
Email string `cmp:"-"`
Age float64
Metadata map[string]interface{}
}
func main() {
u1 := User{
ID: 1,
Name: "Alice",
Email: "a@example.com",
Age: 30.000000001,
Metadata: map[string]interface{}{
"tags": []string{"user", "vip"},
},
}
u2 := User{
ID: 2,
Name: "Alice",
Email: "alice@new.com",
Age: 30.0,
Metadata: map[string]interface{}{
"tags": []string{"user", "vip"},
},
}
equal := deepCompare(u1, u2,
WithSkipTag("ID"),
WithFloatPrecision(1e-6),
)
fmt.Println("结构体内容基本一致:", equal) // 输出 true
}
在这个例子中，尽管 ID 和 Email 不同，Age 存在微小误差，但由于我们配置了忽略 ID 字段、使用近似浮点比较，最终结果仍判定为“相等”。
基本上就这些。通过反射你可以构建出高度灵活的比对逻辑，适用于测试断言、数据同步、缓存校验等场景。关键在于控制递归边界、处理特殊情况，并提供清晰的扩展接口。
