Go 是一门静态类型语言，这意味着每个变量在编译时就已经确定好了它的静态类型，比如 int、float32、[]byte 等等。
type MyInt int
var i int
var j MyInt
尽管变量 i 和 j 的底层类型都是 int，但由于它们的静态类型不同（分别是 int 和 MyInt），因此在没有进行类型转换的情况下，它们是不能互相赋值的。
Go 提供了布尔、数值和字符串等基础类型，同时也支持使用这些基础类型来构建复合类型，例如数组、结构体、指针、切片、map 和 channel 等。此外，interface（接口）也可以视为一种特殊的复合类型。
1. 接口 (interface) 类型
每个接口类型都定义了一个特定的方法集，这个集合中的方法被称为该接口所要求的方法。例如：
type Animal interface {
Speak() string
}
接口变量
和其他类型一样，我们也可以声明接口类型的变量。
var animal Animal
type Animal interface {
Speak() string
}
此时，animal 变量的值为 nil。
实现接口
任何类型，只要它实现了某个接口类型所定义的全部方法，我们就可以说这个类型“实现”了该接口。这个类型的值就可以被存储到该接口类型的变量中。这是 Go语言 多态性的基础。
type Animal interface {
Speak() string
}
type Dog struct{}
func (dog *Dog) Speak() string {
return "Woof!"
}
func testAnimal() {
var animal Animal
var dog Dog
animal = &dog
}
因为结构体 Dog 实现了 Speak() 方法，所以它的指针 &dog 可以被存储到 animal 变量中。
关键点：接口变量可以存储任意实现了该接口的类型的值。
接口的底层表示
一个接口变量为什么能存储多种不同类型的值呢？因为 Go 在底层将接口变量实现为一个“对”，它同时保存了所存储值的类型和值本身。
源码位置：src/runtime/runtime2.go:iface
type iface struct {
tab *itab
data unsafe.Pointer
}
tab：保存了值的类型信息以及相关的方法集。data：一个指向实际存储值的指针（可能在堆或栈上）。
Go 的反射能力，其核心正是基于运行时操作这个接口内部对（值和类型）的特性。理解这一点是掌握反射的前提。
空接口
空接口 (interface{} 或其别名 any) 是一种非常特殊的接口类型，它没有定义任何方法。这意味着任何类型都自动实现了空接口。因此，一个空接口类型的变量就可以存储任意类型的值，这为动态类型处理提供了可能性。
2. 反射的三大定律
reflect 包是 Go 反射机制的入口，它提供了两个核心类型：reflect.Type 和 reflect.Value，分别对应接口内部存储的类型和值。
// TypeOf 返回一个代表 i 的动态类型的反射类型 [Type]。
// 如果 i 是一个值为 nil 的接口，TypeOf 返回 nil。
func TypeOf(i any) Type {
return toType(abi.TypeOf(i))
}
// ValueOf 返回一个新的 Value，其被初始化为存储在接口 i 中的具体值。
// ValueOf(nil) 返回零值 Value。
func ValueOf(i any) Value {
if i == nil {
return Value{}
}
return unpackEface(i)
}
第一定律：从接口值到反射对象
反射可以将接口类型变量转换为反射对象（reflect.Type 或 reflect.Value）。
func main() {
var x float64 = 3.4
// t 的类型是 reflect.Type
t := reflect.TypeOf(x)
fmt.Println(t)
value := reflect.ValueOf(x)
fmt.Println(value)
}
执行结果：
你可能注意到，上面的例子似乎没有显式地使用接口变量。实际上，当变量 x 被传入 reflect.TypeOf() 和 reflect.ValueOf() 时，Go 会执行一次隐式的类型转换，将其作为一个空接口 (any) 传入。这个例子展示了反射最基本的功能——获取接口变量背后的类型和值信息，这是进行后续所有反射操作的基础。
第二定律：从反射对象到接口值
反射可以将反射对象（reflect.Value）还原为接口对象（interface{}）。
反射之所以称为“反射”，正是因为这种双向转换的能力。
func main() {
var A interface{}
A = 100
v := reflect.ValueOf(A)
B := v.Interface()
if A == B {
fmt.Println("they ara same")
}
}
执行结果：
在这个例子中，我们通过 reflect.ValueOf() 获取了接口变量 A 的反射对象 v，然后又通过 v.Interface() 方法将 v 转换回一个普通的接口值 B。比较发现，A 和 B 是相等的。
第三定律：要修改反射对象，其值必须“可设置 (Settable)”
通过反射，我们不仅能读取，有时还需要修改接口变量持有的值。reflect.Value 提供了一系列 SetXXX() 方法（如 SetInt， SetFloat）来实现这一点。但这里有一个重要的前提：反射对象必须是可设置的 (Settable)。
先看一个失败的例子：
func main() {
var x float64 = 3.4
v := reflect.ValueOf(x)
v.SetFloat(7.1)
}
执行结果（报错）：
错误信息明确指出：reflect.Value.SetFloat using unaddressable value（使用不可寻址的值）。为什么会这样？
问题在于 reflect.ValueOf(x) 传入的是变量 x 的一个拷贝，而非 x 本身。通过这个拷贝的反射对象去修改值，是无法影响到原始变量 x 的，因此 Go 的反射机制禁止了这种无意义的操作，直接抛出 panic。
那么，如何才能修改原变量的值呢？我们需要传递原变量的指针，然后通过 reflect.Value 的 Elem() 方法来获取这个指针指向的、可设置的 Value。
func main() {
var x float64 = 3.4
v := reflect.ValueOf(&x) // 注意：这里传递的是 x 的地址
v.Elem().SetFloat(7.1)
fmt.Println(v.Elem().Interface())
}
执行结果：
v.Elem() 相当于对指针进行了解引用（* 操作），它返回的 Value 代表指针指向的那个原始变量 x，这个 Value 就是“可设置的”。因此，对其调用 SetFloat 就能成功地修改 x 的值。
总结与延伸
Go 的反射机制强大但需要谨慎使用。它建立在 接口(interface)类型 的运行时表示之上，通过 reflect.Type 和 reflect.Value 两大核心类型，遵循三大定律进行值、类型和接口间的转换。理解 interface 的底层结构 (iface/eface) 是理解反射原理的关键。在实际应用中，反射常用于编写通用库、序列化/反序列化工具（如 JSON、XML 编码器）、依赖注入框架等场景。
虽然反射提供了极大的灵活性，但它也带来了性能开销和代码可读性降低的问题。在决定是否使用反射时，应仔细权衡其利弊。希望这篇关于 反射定律 的剖析能帮助你更深入地理解 Go 的这一高级特性。如果你想与其他开发者交流 Go 或其他后端技术心得，欢迎访问 云栈社区 参与讨论。
山是四季的山，水是山水的水。
发表于 6 小时前
|
查看: 1|
回复: 0
