使用类型参数编写函数：

func compare[T comparable](a *T, b *T) bool {
    return a != nil && b != nil && *a == *b
}

字符串
下面是一些调用函数的示例：

a := "hello"
b := "world"
c := "hello"
var z *string
fmt.Println(compare(z, z))   // prints false
fmt.Println(compare(&a, z))  // prints false
fmt.Println(compare(z, &a))  // prints false
fmt.Println(compare(&a, &b)) // prints false
fmt.Println(compare(&a, &a)) // prints true
fmt.Println(compare(&a, &c)) // prints true

型
Run it in the playground的一个。
下面是如何在Go语言1.17及更早版本中编写该函数：
假设您只使用两种类型，请使用类型Assert获取具体的指针类型并进行比较：

func compare(a interface{}, b interface{}) bool {
    switch a := a.(type) {
    case *string:
        b, _ := b.(*string)
        return a != nil && b != nil && *a == *b
    case *int:
        b, _ := b.(*int)
        return a != nil && b != nil && *a == *b
    default:
        return false
    }
}

型
下面是一些调用函数的示例：

a := "hello"
b := "world"
c := "hello"
fmt.Println(compare(&a, nil))
fmt.Println(compare(nil, &a))
fmt.Println(compare(&a, &b))
fmt.Println(compare(&a, &a))
fmt.Println(compare(&a, &c))

型
Run it in the Playground的
使用reflect API比较所有可比较的类型：

func compare(a interface{}, b interface{}) bool {
    if a == nil && b == nil {
        return true
    }
    if a == nil || b == nil {
        return false
    }
    va := reflect.ValueOf(a)
    vb := reflect.ValueOf(b)
    if va.Type() != vb.Type() {
        return false
    }
    if va.Kind() == reflect.Ptr {
        if va.IsNil() || vb.IsNil() {
            return false
        }
        va = va.Elem()
        vb = vb.Elem()
    }
    if !va.Type().Comparable() {
        return false
    }
    return va.Interface() == vb.Interface()
}

型