如何用Golang通过reflect检查类型兼容性_Golang 类型兼容性检查实践

package main

import (
    "fmt"
    "reflect"
)

type MyInt int

type Greeter interface {
    Greet() string
}

type Person struct {
    Name string
    Age  int
}

func (p Person) Greet() string {
    return "Hello, I'm " + p.Name
}

func main() {
    // 1. 获取reflect.Type
    var i int = 10
    var f float64 = 20.0
    var myInt MyInt = 30
    var p Person = Person{Name: "Alice", Age: 30}
    var g Greeter = p // p implements Greeter

    typeOfInt := reflect.TypeOf(i)
    typeOfFloat := reflect.TypeOf(f)
    typeOfMyInt := reflect.TypeOf(myInt)
    typeOfPerson := reflect.TypeOf(p)
    typeOfGreeter := reflect.TypeOf((*Greeter)(nil)).Elem() // 获取接口类型

    fmt.Println("--- 基本类型兼容性判断 ---")

    // 2. AssignableTo: 判断一个类型的值是否可以赋值给另一个类型的变量
    // int 可以赋值给 interface{}
    fmt.Printf("int AssignableTo interface{}: %t\n", typeOfInt.AssignableTo(reflect.TypeOf((*interface{})(nil)).Elem()))
    // MyInt 可以赋值给 int 吗？不行，它们是不同类型
    fmt.Printf("MyInt AssignableTo int: %t\n", typeOfMyInt.AssignableTo(typeOfInt))
    // int 可以赋值给 MyInt 吗？不行
    fmt.Printf("int AssignableTo MyInt: %t\n", typeOfInt.AssignableTo(typeOfMyInt))
    // Person 可以赋值给 Greeter 吗？可以，因为 Person 实现了 Greeter
    fmt.Printf("Person AssignableTo Greeter: %t\n", typeOfPerson.AssignableTo(typeOfGreeter))
    // Greeter 可以赋值给 Person 吗？不行，接口不能直接赋值给具体类型
    fmt.Printf("Greeter AssignableTo Person: %t\n", typeOfGreeter.AssignableTo(typeOfPerson))

    fmt.Println("\n--- 类型转换兼容性判断 ---")

    // 3. ConvertibleTo: 判断一个类型的值是否可以被转换为另一个类型
    // int 可以转换为 float64
    fmt.Printf("int ConvertibleTo float64: %t\n", typeOfInt.ConvertibleTo(typeOfFloat))
    // MyInt 可以转换为 int
    fmt.Printf("MyInt ConvertibleTo int: %t\n", typeOfMyInt.ConvertibleTo(typeOfInt))
    // int 可以转换为 MyInt
    fmt.Printf("int ConvertibleTo MyInt: %t\n", typeOfInt.ConvertibleTo(typeOfMyInt))
    // Person 可以转换为 Greeter 吗？不行，不能直接转换，只能赋值（通过接口实现）
    fmt.Printf("Person ConvertibleTo Greeter: %t\n", typeOfPerson.ConvertibleTo(typeOfGreeter))

    fmt.Println("\n--- 接口实现判断 ---")

    // 4. Implements: 判断一个类型是否实现了某个接口
    // Person 实现了 Greeter 接口
    fmt.Printf("Person Implements Greeter: %t\n", typeOfPerson.Implements(typeOfGreeter))
    // MyInt 实现了 Greeter 接口吗？没有
    fmt.Printf("MyInt Implements Greeter: %t\n", typeOfMyInt.Implements(typeOfGreeter))

    // 5. 检查值的类型兼容性（需要 reflect.Value）
    fmt.Println("\n--- 值与类型兼容性判断 ---")
    valueOfP := reflect.ValueOf(p)
    // valueOfP (类型 Person) 是否可以赋值给 Greeter 类型的变量？
    fmt.Printf("reflect.ValueOf(p).Type().AssignableTo(Greeter): %t\n", valueOfP.Type().AssignableTo(typeOfGreeter))
}

package main

import (
    "fmt"
    "reflect"
)

type CustomInt int

type Validator interface {
    Validate() bool
}

type User struct {
    Name string
}

func (u User) Validate() bool {
    return u.Name != ""
}

func main() {
    typeOfInt := reflect.TypeOf(0)
    typeOfFloat := reflect.TypeOf(0.0)
    typeOfCustomInt := reflect.TypeOf(CustomInt(0))
    typeOfUser := reflect.TypeOf(User{})
    typeOfValidator := reflect.TypeOf((*Validator)(nil)).Elem()
    typeOfInterface := reflect.TypeOf((*interface{})(nil)).Elem()

    fmt.Println("--- AssignableTo 示例 ---")
    // int 可以赋值给 interface{}
    fmt.Printf("int AssignableTo interface{}: %t\n", typeOfInt.AssignableTo(typeOfInterface))
    // CustomInt 不能直接赋值给 int (除非通过转换)
    fmt.Printf("CustomInt AssignableTo int: %t\n", typeOfCustomInt.AssignableTo(typeOfInt))
    // User 可以赋值给 Validator (因为 User 实现了 Validator)
    fmt.Printf("User AssignableTo Validator: %t\n", typeOfUser.AssignableTo(typeOfValidator))

    fmt.Println("\n--- ConvertibleTo 示例 ---")
    // int 可以转换为 float64
    fmt.Printf("int ConvertibleTo float64: %t\n", typeOfInt.ConvertibleTo(typeOfFloat))
    // CustomInt 可以转换为 int
    fmt.Printf("CustomInt ConvertibleTo int: %t\n", typeOfCustomInt.ConvertibleTo(typeOfInt))
    // User 不能直接转换为 Validator
    fmt.Printf("User ConvertibleTo Validator: %t\n", typeOfUser.ConvertibleTo(typeOfValidator))

    fmt.Println("\n--- Implements 示例 ---")
    // User 实现了 Validator 接口
    fmt.Printf("User Implements Validator: %t\n", typeOfUser.Implements(typeOfValidator))
    // CustomInt 没有实现 Validator 接口
    fmt.Printf("CustomInt Implements Validator: %t\n", typeOfCustomInt.Implements(typeOfValidator))
}