接口
问题
Go 的接口是如何实现的？iface 和 eface 的区别是什么？nil 接口有什么陷阱？
答案
接口基础
Go 的接口是隐式实现的——不需要 implements 关键字，只要类型实现了接口定义的所有方法，就自动满足该接口：
type Stringer interface {
String() string
}
type User struct {
Name string
}
// User 实现了 String() 方法，自动满足 Stringer 接口
func (u User) String() string {
return u.Name
}
var s Stringer = User{Name: "Alice"} // OK
这种设计的好处：
- 解耦：接口定义者和实现者不需要知道彼此
- 灵活：可以为任何类型（包括第三方库的类型）实现接口
- 小接口：鼓励定义 1-2 个方法的小接口
底层实现——iface 和 eface
Go 内部有两种接口表示：
// eface：空接口 interface{}（没有方法）
type eface struct {
_type *_type // 类型信息
data unsafe.Pointer // 数据指针
}
// iface：非空接口（有方法要求）
type iface struct {
tab *itab // 类型信息 + 方法表
data unsafe.Pointer // 数据指针
}
// itab 缓存了接口类型和具体类型的关系
type itab struct {
inter *interfacetype // 接口类型
_type *_type // 具体类型
hash uint32 // 类型哈希（用于类型断言加速）
_ [4]byte
fun [1]uintptr // 方法表（变长数组）
}
itab 会被缓存在一个全局哈希表中。第一次将具体类型赋值给接口时，运行时会查找或创建 itab，后续相同类型组合会直接复用，避免重复计算方法表。
空接口 interface{}（any）
空接口没有方法要求，任何类型都满足空接口：
var x interface{} = 42
x = "hello"
x = []int{1, 2, 3}
// Go 1.18+ 可以用 any 代替 interface{}
var y any = 42 // any 是 interface{} 的类型别名
空接口常用于：
- 函数接受任意类型参数：
func Print(v any) - 容器存储不同类型：
[]any{1, "hello", true} - JSON 解析到未知结构：
map[string]any
类型断言
从接口值中提取具体类型：
var i interface{} = "hello"
// 类型断言（不安全，失败会 panic）
s := i.(string) // "hello"
// n := i.(int) // panic: interface conversion: interface {} is string, not int
// 安全的类型断言（comma ok）
s, ok := i.(string) // "hello", true
n, ok := i.(int) // 0, false
// type switch
switch v := i.(type) {
case string:
fmt.Println("string:", v)
case int:
fmt.Println("int:", v)
default:
fmt.Println("unknown type")
}
nil 接口陷阱——最经典的面试题
type MyError struct {
Msg string
}
func (e *MyError) Error() string {
return e.Msg
}
func getError() error {
var err *MyError = nil
return err // 返回的不是 nil 接口！
}
func main() {
err := getError()
fmt.Println(err == nil) // false !!!
}
为什么 err != nil？因为接口值由 (type, value) 两部分组成：
| 阶段 | 类型（type） | 值（value） | == nil |
|---|---|---|---|
var err *MyError = nil | *MyError | nil | — |
return err（赋给 error 接口） | *MyError | nil | false |
| 接口为 nil | nil | nil | true |
接口值只有在类型和值都是 nil 时才等于 nil。getError 返回的接口值类型是 *MyError（非 nil），即使值是 nil，接口也不等于 nil。
修复方法：
func getError() error {
var err *MyError = nil
if err == nil {
return nil // 直接返回 nil，不要返回具体类型的 nil
}
return err
}
永远不要返回一个具体类型的 nil 指针给接口类型的返回值。在函数最后检查并显式返回 nil。
接口设计原则
// ✅ 好的接口设计：小而精
type Reader interface {
Read(p []byte) (n int, err error)
}
type Writer interface {
Write(p []byte) (n int, err error)
}
// 接口组合
type ReadWriter interface {
Reader
Writer
}
// ✅ "Accept interfaces, return structs"
func Process(r io.Reader) (*Result, error) {
// 参数接受接口（灵活）
// 返回具体类型（明确）
}
"The bigger the interface, the weaker the abstraction." — Rob Pike
接口越大，抽象越弱。Go 标准库中的接口大多只有 1-3 个方法：io.Reader（1 个）、io.ReadWriter（2 个）、sort.Interface（3 个）。
在消费者（使用方）定义接口，而非提供方——这是 Go 与 Java 的重大区别。
接口的零值可用
// io.Writer 接口的零值（nil）可以安全检查
var w io.Writer
if w != nil {
w.Write([]byte("hello"))
}
// 但不能直接调用 nil 接口的方法
// w.Write([]byte("hello")) // panic: nil pointer dereference
常见面试问题
Q1: 接口是用值接收者还是指针接收者实现有什么区别？
答案：
- 值接收者实现：
T和*T都实现了接口 - 指针接收者实现：只有
*T实现了接口
type Sayer interface {
Say() string
}
type Cat struct{}
func (c Cat) Say() string { return "meow" } // 值接收者
type Dog struct{}
func (d *Dog) Say() string { return "woof" } // 指针接收者
var s Sayer
s = Cat{} // ✅
s = &Cat{} // ✅
s = &Dog{} // ✅
// s = Dog{} // ❌ 编译错误：Dog 没实现 Sayer，只有 *Dog 实现了
Q2: interface{} 和 any 有什么区别？
答案：
Go 1.18 引入了 any 作为 interface{} 的类型别名（type any = interface{}），两者完全等价，any 只是更简洁的写法。
Q3: 接口可以嵌入其他接口吗？
答案：
可以，这是 Go 接口组合的标准方式：
type Reader interface {
Read(p []byte) (n int, err error)
}
type Closer interface {
Close() error
}
// 组合接口
type ReadCloser interface {
Reader
Closer
}
// 等价于定义了 Read + Close 两个方法
Go 1.14 起还支持重叠接口嵌入（嵌入的接口可以有相同的方法）。
Q4: 如何判断一个接口值的具体类型？
答案：
三种方式：
var i interface{} = "hello"
// 1. 类型断言
s, ok := i.(string)
// 2. type switch
switch v := i.(type) {
case string:
fmt.Println("string:", v)
case int:
fmt.Println("int:", v)
}
// 3. reflect
fmt.Println(reflect.TypeOf(i)) // string
Q5: 接口值的比较规则是什么？
答案：
两个接口值相等的条件：
- 动态类型相同 且 动态值相等
- 或者两者都是 nil
var a, b interface{}
a = 42
b = 42
fmt.Println(a == b) // true
a = []int{1}
b = []int{1}
// fmt.Println(a == b) // panic! slice 不可比较
如果接口的动态类型是不可比较类型（slice、map、func），用 == 比较会 panic（不是编译错误，是运行时 panic）。
Q6: Go 接口和 Java 接口有什么本质区别？
答案：
| 维度 | Go 接口 | Java 接口 |
|---|---|---|
| 实现方式 | 隐式（不需要声明） | 显式（implements） |
| 定义位置 | 消费方定义 | 提供方定义 |
| 大小倾向 | 小接口（1-2 方法） | 大接口（多方法） |
| 是否有默认方法 | ❌ | ✅（Java 8 default） |
| 是否有字段 | ❌ | ✅（常量字段） |
| 是否支持泛型 | ✅（Go 1.18，类型约束） | ✅ |
Go 隐式接口的核心优势是解耦——实现者不需要知道接口的存在，接口的定义可以事后添加。