Go空接口

空接口interface{}没有方法约束，Go中任何类型都自动满足空接口。

空接口定义

基本语法

// 空接口：无方法
type Any interface{}  // 或直接用 interface{}

// interface{} 是空接口类型
var i interface{}

任意类型满足

var i interface{}

// 任意类型赋值
i = 42           // int
i = "hello"      // string
i = true         // bool
i = []int{1,2}   // slice
i = map[string]int{}  // map
i = User{}       // struct
i = func() {}    // 函数

// 所有类型都满足interface{}

空接口无约束，类似Java的Object或C的void*。

空接口用法

接收任意类型

func printAny(i interface{}) {
    fmt.Println(i)
}

printAny(42)
printAny("hello")
printAny([]int{1, 2, 3})

存储任意类型

// slice存储任意类型
var items []interface{}
items = append(items, 1)
items = append(items, "two")
items = append(items, 3.0)

// map存储任意类型
var m map[string]interface{}
m = make(map[string]interface{})
m["name"] = "Tom"
m["age"] = 25
m["data"] = []int{1, 2, 3}

JSON解析

var data interface{}
json.Unmarshal(jsonBytes, &data)

// data可能是map、array等
// 需类型断言处理

类型断言

基本断言

var i interface{} = 42

// 断言类型
n := i.(int)
fmt.Println(n)  // 42

// 断言失败panic
s := i.(string)  // panic!

安全断言

var i interface{} = 42

// ok检查
n, ok := i.(int)
if ok {
    fmt.Println("是int:", n)
}

s, ok := i.(string)
if !ok {
    fmt.Println("不是string")
}

使用ok形式避免panic。

类型选择

func process(i interface{}) {
    switch v := i.(type) {
    case int:
        fmt.Println("int:", v)
    case string:
        fmt.Println("string:", v)
    case []int:
        fmt.Println("slice:", v)
    default:
        fmt.Printf("未知类型: %T\n", v)
    }
}

空接口与具体接口对比

空接口底层

eface结构

// interface{}使用eface
type eface struct {
    _type *_type           // 类型信息
    data  unsafe.Pointer   // 数据指针
}

// 存储时：
// _type → 具体类型信息
// data  → 具体数据地址

类型信息

var i interface{} = 42

// 获取类型信息
fmt.Printf("类型: %T\n", i)  // int
fmt.Printf("值: %v\n", i)   // 42

// 反射
v := reflect.ValueOf(i)
t := reflect.TypeOf(i)

空接口最佳实践

避免滥用

// 不推荐：参数用interface{}
func process(data interface{}) {
    // 需类型断言，效率低
}

// 推荐：具体类型参数
func processInt(data int) {
    // 直接使用，效率高
}

适用场景

// 适合场景：
// 1. JSON解析结果
var data interface{}
json.Unmarshal(raw, &data)

// 2. 通用容器
var storage []interface{}

// 3. 与动态语言交互
// 4. 函数需要接受多种类型

要点总结

• interface{}是无方法的空接口
• 任意类型都满足空接口
• 空接口可存储任意类型值
• 类型断言获取具体类型值
• 使用ok形式安全断言
• type switch处理多种类型
• 不能直接调用方法（无方法约束）
• 避免滥用，优先使用具体类型
• 适用：JSON解析、通用容器、多类型函数