接口与反射

接口值的本质是什么？

回答重点

一个接口值在语义上包含两部分：

• 动态类型。
• 动态值。

接口的零值只有在动态类型和动态值都不存在时才等于 nil。把一个具体值赋给接口后，接口会保留它的动态类型，并可通过方法调用、类型断言或反射操作该值。

标准运行时历史上常用 eface 和 iface 解释空接口与非空接口，但这些结构是实现细节。Go 1.18 起 any 只是 interface{} 的别名，不是新的运行时类型。

为什么“值为 nil 的指针”放进接口后不等于 nil？

回答重点

因为接口仍然保存了动态类型 *T，只是动态值为 nil。此时接口本身不是零值。

package main

import "fmt"

type Worker interface {
	Work()
}

type job struct{}

func (*job) Work() {}

func main() {
	var pointer *job
	var worker Worker = pointer

	fmt.Println(pointer == nil) // true
	fmt.Println(worker == nil)  // false
}

这类值作为 error 返回时尤其容易造成误判。若没有错误，应直接返回 nil 接口，而不是返回一个动态类型非 nil、动态值为 nil 的具体错误指针。

两个接口值可以比较吗？

回答重点

接口值可以使用 == 和 !=，但结果取决于动态类型：

• 两个接口的动态类型相同，且动态值相等时，接口相等。
• 两个接口都为零值时相等。
• 动态类型不同则不相等。
• 如果两个接口具有相同动态类型，但该类型不可比较，例如 slice、map 或 function，比较会发生 panic。

package main

import "fmt"

func main() {
	var left any = []int{1}
	var right any = []int{1}

	fmt.Println(left == right) // panic: comparing uncomparable type []int
}

因此，“interface 总能比较”是错误结论。泛型代码可以使用 comparable 约束表达可比较要求。

类型转换和类型断言有什么区别？

回答重点

• 类型转换写作 T(x)，按语言规定把值 x 转成类型 T，是否合法在编译期检查。
• 类型断言写作 x.(T)，要求 x 是接口值，在运行时检查其动态类型是否满足 T。

直接断言失败会 panic；逗号 ok 形式会返回零值和 false：

value, ok := input.(string)
if !ok {
	return errors.New("input is not a string")
}

类型转换不一定只是“重新解释内存”。例如整数转字符串会生成对应码点的字符串，字符串与字节切片之间转换通常需要复制数据。

接口有哪些常见应用场景？

回答重点

• 依赖倒置：调用方依赖所需行为，而不是依赖具体实现。
• 可替换实现：生产实现、测试桩和不同后端实现共享契约。
• 组合能力：通过小接口组合更大的行为，例如 io.ReadWriter。
• 标准扩展点：实现 error、fmt.Stringer、json.Marshaler 等接口。

Go 倾向于由使用方定义小接口。不要为了“以后可能替换”给每个结构体机械地创建同名大接口。

值接收者和指针接收者如何影响接口实现？

回答重点

方法集决定一个类型是否实现接口：

• T 的方法集包含接收者为 T 的方法。
• *T 的方法集包含接收者为 T 和 *T 的方法。

因此，如果接口要求的方法使用指针接收者实现，通常只有 *T 实现接口，T 不实现。

package main

import "fmt"

type Stringer interface {
	String() string
}

type Name string

func (name *Name) String() string {
	return string(*name)
}

func main() {
	name := Name("Go")
	var value Stringer = &name
	fmt.Println(value.String())
}

什么是反射？

回答重点

反射是在运行时检查类型和值，并在满足规则时动态构造、读取或修改值的能力。Go 通过 reflect.Type 表示类型，通过 reflect.Value 表示运行时值。

反射常用于序列化、ORM、依赖注入、配置解析、RPC 编解码和测试工具。代价是静态类型信息减少、代码更难推理，并可能带来额外分配和运行时检查。

reflect.TypeOf 和 reflect.ValueOf 如何工作？

回答重点

两者接收接口值，从接口携带的动态类型和值中构造反射对象：

• reflect.TypeOf(x) 返回动态类型；传入 nil 接口时返回 nil。
• reflect.ValueOf(x) 返回动态值；传入 nil 接口时返回零 Value。
• 只有可设置的 Value 才能通过反射修改。通常需要传入指针并调用 Elem。

package main

import (
	"fmt"
	"reflect"
)

func main() {
	number := 1
	value := reflect.ValueOf(&number).Elem()
	value.SetInt(2)
	fmt.Println(number)
}

调用 Elem、Interface 或具体类型访问方法前，应检查 IsValid、Kind、CanSet 等条件，否则可能 panic。

如何比较两个对象是否相等？

回答重点

应先明确业务上的“相等”：

• 可比较类型可以直接使用 ==。
• slice 和 map 可使用标准库 slices.Equal、slices.EqualFunc、maps.Equal 或 maps.EqualFunc。
• 业务实体通常应实现明确的 Equal 方法，只比较有业务意义的字段。
• reflect.DeepEqual 可做递归比较，但其语义不一定符合业务要求。

reflect.DeepEqual 的一些特殊行为包括：非 nil 空 slice 与 nil slice 不相等；函数值只有都为 nil 时才相等；浮点 NaN 与自身不相等。测试中若需要更友好的比较和差异输出，可使用成熟的比较库。

扩展知识

• Go 语言规范：接口类型
• reflect 包文档