Go语言中通过反射检测接口值是否为零值

func IsZeroOfUnderlyingTypeInitial(x interface{}) bool {
    // 如果接口本身就是nil，则直接返回true
    if x == nil {
        return true
    }
    // 获取底层类型并创建其零值
    zeroValue := reflect.Zero(reflect.TypeOf(x)).Interface()
    // 尝试直接比较
    return x == zeroValue
}

var s1 []int // nil slice
var s2 []int // nil slice
// fmt.Println(s1 == s2) // 编译错误: slice can only be compared to nil

import (
    "reflect"
)

// IsZeroOfUnderlyingType 检测接口x所持有的底层值是否为其类型的零值。
// 该函数能够处理所有Go类型，包括不可比较的类型。
func IsZeroOfUnderlyingType(x interface{}) bool {
    // 特殊情况：如果接口本身就是nil，则其底层值也是零值。
    if x == nil {
        return true
    }

    // 获取x的反射值和类型
    v := reflect.ValueOf(x)
    t := reflect.TypeOf(x)

    // 获取该类型的零值
    zeroValue := reflect.Zero(t)

    // 使用reflect.DeepEqual进行深度比较
    // 将反射值转换为interface{}类型进行比较
    return reflect.DeepEqual(v.Interface(), zeroValue.Interface())
}

package main

import (
    "fmt"
    "reflect"
)

// IsZeroOfUnderlyingType 检测接口x所持有的底层值是否为其类型的零值。
// 该函数能够处理所有Go类型，包括不可比较的类型。
func IsZeroOfUnderlyingType(x interface{}) bool {
    if x == nil {
        return true
    }
    v := reflect.ValueOf(x)
    t := reflect.TypeOf(x)
    zeroValue := reflect.Zero(t)
    return reflect.DeepEqual(v.Interface(), zeroValue.Interface())
}

func main() {
    // 基本类型
    var i int
    fmt.Printf("int(0) is zero: %v\n", IsZeroOfUnderlyingType(i)) // true
    i = 10
    fmt.Printf("int(10) is zero: %v\n", IsZeroOfUnderlyingType(i)) // false

    var s string
    fmt.Printf("string(\"\") is zero: %v\n", IsZeroOfUnderlyingType(s)) // true
    s = "hello"
    fmt.Printf("string(\"hello\") is zero: %v\n", IsZeroOfUnderlyingType(s)) // false

    var b bool
    fmt.Printf("bool(false) is zero: %v\n", IsZeroOfUnderlyingType(b)) // true
    b = true
    fmt.Printf("bool(true) is zero: %v\n", IsZeroOfUnderlyingType(b)) // false

    // 引用类型 (零值为nil)
    var ptr *int
    fmt.Printf("nil *int is zero: %v\n", IsZeroOfUnderlyingType(ptr)) // true
    val := 5
    ptr = &val
    fmt.Printf("non-nil *int is zero: %v\n", IsZeroOfUnderlyingType(ptr)) // false

    var sl []int
    fmt.Printf("nil []int is zero: %v\n", IsZeroOfUnderlyingType(sl)) // true
    sl = []int{1, 2}
    fmt.Printf("non-nil []int is zero: %v\n", IsZeroOfUnderlyingType(sl)) // false
    sl = []int{} // 空切片，但不是nil
    fmt.Printf("empty []int is zero: %v\n", IsZeroOfUnderlyingType(sl)) // false (reflect.DeepEqual认为[]int{}和nil []int是不同的)

    var m map[string]int
    fmt.Printf("nil map is zero: %v\n", IsZeroOfUnderlyingType(m)) // true
    m = make(map[string]int)
    fmt.Printf("empty map is zero: %v\n", IsZeroOfUnderlyingType(m)) // false (reflect.DeepEqual认为map{}和nil map是不同的)

    var ch chan int
    fmt.Printf("nil chan is zero: %v\n", IsZeroOfUnderlyingType(ch)) // true

    var f func()
    fmt.Printf("nil func is zero: %v\n", IsZeroOfUnderlyingType(f)) // true

    // 结构体
    type MyStruct struct {
        ID   int
        Name string
    }
    var ms MyStruct // 零值结构体 {0, ""}
    fmt.Printf("zero MyStruct is zero: %v\n", IsZeroOfUnderlyingType(ms)) // true
    ms = MyStruct{ID: 1, Name: "Test"}
    fmt.Printf("non-zero MyStruct is zero: %v\n", IsZeroOfUnderlyingType(ms)) // false

    // nil interface{} 本身
    var ni interface{}
    fmt.Printf("nil interface{} is zero: %v\n", IsZeroOfUnderlyingType(ni)) // true
}