本文探讨了在 Go 语言中，当一个类型通过类型转换被当作另一个类型使用时，如何在被调用的方法内部判断其原始类型。核心结论是，通过类型转换后，原始类型的信息会丢失。文章提供了一种使用接口的替代方案，允许在方法内部区分不同的实现类型。
在 Go 语言中，类型系统与面向对象语言有所不同。当我们基于一个类型创建新的类型时，并不会像面向对象语言那样建立继承关系。这意味着，如果将一个类型 T1 转换为类型 T，那么在 T 的方法中，无法直接得知它是由 T1 转换而来。
问题描述
假设我们有类型 T，以及基于 T 创建的类型 T1 和 T2。我们希望在 T 的方法 WhoAmI() 中判断调用该方法的实例究竟是 T1 还是 T2 转换而来。
立即学习“go语言免费学习笔记（深入）”；
package main
import "fmt"
import "reflect"
type T struct{ s string }
func (v *T) WhoAmI() string {
// pull type name with reflect
fmt.Println(reflect.TypeOf(v).Elem().Name()) // always prints "T"!
// todo: if I am actually T1
return "T1"
// todo: else if I am actually T2
return "T2"
}
type T1 T
func NewT1(s string) T1 { return T1{s} }
type T2 T
func NewT2(s string) T2 { return T2{s} }
func main() {
var t1 = T1{"xyz"}
var t2 = T2{"pdq"}
s1 := ((*T)(&t1)).WhoAmI() // would like to return "T1"
s2 := ((*T)(&t2)).WhoAmI() // would like to return "T2"
fmt.Println(s1, s2)
}上述代码中，WhoAmI() 方法总是返回 "T"，因为在类型转换后，原始类型的信息已经丢失。
解决方案：使用接口
Go 语言提供了一种更灵活的方式来实现类似的功能，即使用接口。我们可以定义一个接口 T，然后让 T1 和 T2 都实现这个接口。
type T interface {
WhoAmI() string
}
type T1 struct {
s string
}
func (t *T1) WhoAmI() string { return "T1" }
type T2 struct {
s string
}
func (t *T2) WhoAmI() string { return "T2" }
func main() {
var t1 T = &T1{"xyz"}
var t2 T = &T2{"pdq"}
fmt.Println(t1.WhoAmI(), t2.WhoAmI())
}在这个例子中，T1 和 T2 都实现了接口 T。因此，我们可以将 T1 和 T2 的实例赋值给类型为 T 的变量。当我们调用 WhoAmI() 方法时，会根据实际的类型执行对应的方法，从而得到正确的结果。
示例代码解释
- 定义接口 T: 接口 T 定义了一个方法 WhoAmI()，任何实现了这个方法的类型都可以被认为是 T 类型。
- 定义类型 T1 和 T2: T1 和 T2 是结构体类型，它们各自实现了 WhoAmI() 方法，并返回不同的字符串。
- 接口的使用: 在 main() 函数中，我们创建了 T1 和 T2 的实例，并将它们的指针赋值给类型为 T 的变量。由于 T1 和 T2 都实现了 T 接口，所以这种赋值是合法的。
- 方法调用: 当我们通过接口变量调用 WhoAmI() 方法时，Go 语言会根据实际的类型选择对应的方法执行，这就是接口的多态性。
注意事项
- Go 语言的类型转换与面向对象语言的继承不同，类型转换会丢失原始类型的信息。
- 使用接口可以实现类似多态的功能，允许在运行时根据实际类型执行不同的代码。
- 在设计程序时，应该根据实际需求选择合适的类型系统特性，以达到最佳的灵活性和可维护性。
总结
在 Go 语言中，如果需要根据类型转换前的原始类型来执行不同的逻辑，应该使用接口来实现。通过接口，我们可以实现多态，并在运行时根据实际类型选择对应的方法执行。这是一种更灵活、更强大的方式来处理类型相关的逻辑。
