interface 底层实现

// 两个 word 怎么摆：分接口种类

// 空接口（无方法）：
type eface struct {
    _type *_type      // word 1: 类型元数据
    data  unsafe.Pointer // word 2: 数据指针
}

// 非空接口（有方法）：
type iface struct {
    tab  *itab        // word 1: itab（含类型+方法表）
    data unsafe.Pointer // word 2: 数据指针
}

// 同一文件定义于 runtime/runtime2.go
// var x any 的零值：两个 word 全零 = nil

// runtime/iface.go · 对照 Go 1.27
type itab struct {
    inter *interfacetype // 接口元数据
    _type *_type         // 具体类型元数据
    hash  uint32         // _type.hash 拷贝，快速断言
    _     [4]byte
    fun   [1]uintptr     // 变长：方法表（fun[0] 起）
}

// fun[i]：接口第 i 个方法的实现地址
// 顺序 = 接口方法按字典序排列（编译期确定）
// 调用 = CALL itab.fun[i]（间接跳转）

PGO devirtualization（Go 1.21+）

// 编译时 -pgo=cpu.pprof：
// profile 显示该调用点 ~单一具体类型占多数

// before（每次走 itab）：
i.Write(b)        // CALL fun[0]

// after（devirtualize + 内联机会）：
if f, ok := i.(*bytes.Buffer); ok {
    f.Write(b)    // 直接调用 → 可内联
} else {
    i.Write(b)    // fallback 保语义
}

官方博客 go.dev/blog/pgo：devirtualization 把"类型可静态确定的间接调用"转为直接调用，从而解锁内联

可寻址性：编译器取址的边界

type T struct{ n int }
func (t *T) String() string { return "x" }

// ✓ 可寻址 → 自动 (&s[0]).String()
ss := []T{{1}}
var _ fmt.Stringer = ss[0]

// ✗ 不可寻址 → 编译错误
mm := map[int]T{1: {n: 1}}
// var _ fmt.Stringer = mm[1] / T{1}  // ✗ 函数返回值同理

// ✓ 显式取址/指针元素
var _ fmt.Stringer = &T{1}
m2 := map[int]*T{1: {}}
var _ fmt.Stringer = m2[1]

type MyErr struct{ msg string }
func (e *MyErr) Error() string {
    return e.msg
}

func work(fail bool) error {
    var e *MyErr          // nil
    if fail { e = &MyErr{"boom"} }
    return e              // ⚠ 陷阱行
}

err := work(false)
fmt.Println(err == nil)   // false！
// iface{tab: *MyErr 的 itab,
//       data: nil}
fmt.Println(err)          // <nil> 更迷惑
// fmt 对 nil 指针显示 <nil>；
// 若 Error() 解引用字段 → fmt 内部 panic 被转义打印

减负三板斧

// ① 热路径传具体类型，接口只留边界
func process(b *bytes.Buffer)  // ✓
func process(w io.Writer)      // 慎用于热点

// ② fmt 热点慎用：参数全装箱 + 反射
log.Printf("x=%d", x)  // x 装箱逃逸
log.Printf("x=", x)    // 结构化日志同理

// ③ 复用已装箱值（once 装箱多次读）
var boxed any = compute()
for … { use(boxed) }  // 只箱一次

接口使用坑清单

DeepEqual 的坑：对 error 接口比较 DeepEqual 与 == 语义不同——前者比内容，后者比 (类型,值) 二元组

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          // 嵌入
}
// ReadWriter 方法集 = 并集
// （嵌入同名方法会合并；签名不同则编译错）