1
// src/runtime/runtime2.go — https://github.com/golang/go/blob/go1.25.0/src/runtime/runtime2.go
2
type eface struct {
3
    _type *_type   // 类型信息
4
    data  unsafe.Pointer // 数据指针
5
}

1
// src/runtime/type.go — https://github.com/golang/go/blob/go1.25.0/src/runtime/type.go
2
type _type struct {
3
    size       uintptr // 类型大小
4
    ptrbytes   uintptr // 前缀中包含指针的字节数
5
    hash       uint32  // 类型哈希，用于快速比较
6
    tflag      tflag   // 类型标志
7
    align      uint8   // 对齐方式
8
    fieldAlign uint8   // 字段对齐
9
    kind       uint8   // 类型种类（Kind）
10
    equal      func(unsafe.Pointer, unsafe.Pointer) bool // 相等比较函数
11
    gcdata     *byte   // GC 数据
12
    str        nameOff // 类型名称偏移
13
    ptrToThis  typeOff // 指向该类型的指针类型
14
}

1
// src/runtime/runtime2.go — https://github.com/golang/go/blob/go1.25.0/src/runtime/runtime2.go
2
type iface struct {
3
    tab  *itab      // 接口表，包含类型和方法信息
4
    data unsafe.Pointer // 数据指针
5
}

1
// src/runtime/runtime2.go — https://github.com/golang/go/blob/go1.25.0/src/runtime/runtime2.go
2
type itab struct {
3
    inter *interfacetype // 接口类型信息
4
    _type *_type         // 具体类型信息
5
    hash  uint32         // 类型哈希（复制自 _type.hash）
6
    _     [4]byte        // 填充
7
    fun   [1]uintptr     // 方法表（变长数组）
8
}

1
type interfacetype struct {
2
    typ     _type     // 接口类型
3
    pkgpath name      // 包路径
4
    methods []imethod // 接口声明的方法列表
5
}

1
var i interface{} = 42  // 装箱 int 值
2

3
// 等价于 runtime 操作：
4
// 1. 分配 _type（全局唯一，指向 runtime.intType）
5
// 2. 分配堆内存存储值 42
6
// 3. 构造 eface{_type, data}

1
// 1. 变量赋值
2
var r io.Reader = &os.File{}  // 检查 *os.File 是否实现了 io.Reader
3

4
// 2. 函数参数传递
5
func ReadAll(r io.Reader) []byte { ... }
6
ReadAll(&os.File{})  // 检查 *os.File 是否实现了 io.Reader
7

8
// 3. 函数返回值
9
func NewReader() io.Reader {
10
    return &os.File{}  // 检查 *os.File 是否实现了 io.Reader
11
}

1
cannot use Cat literal (type Cat) as type Duck in assignment:
2
    Cat does not implement Duck (Quack method has pointer receiver)

1
type Duck interface {
2
    Quack()
3
}
4

5
type Cat struct{}
6

7
func (c *Cat) Quack() { println("meow") }  // 指针接收者

1
var i interface{} = 42
2

3
// 形式 1：断言失败会 panic
4
n := i.(int)
5

6
// 形式 2：断言失败返回 false
7
n, ok := i.(int)

1
// 形式 1：n := i.(int)
2
func assert1(i interface{}) int {
3
    e := (*eface)(unsafe.Pointer(&i))
4
    if e._type != runtime.intType {
5
        runtime.panicdottype(e._type, runtime.intType, "int")
6
    }
7
    return *(*int)(e.data)
8
}
9

10
// 形式 2：n, ok := i.(int)
11
func assert2(i interface{}) (int, bool) {
12
    e := (*eface)(unsafe.Pointer(&i))
13
    if e._type != runtime.intType {
14
        return 0, false
15
    }
16
    return *(*int)(e.data), true
17
}

1
var r io.Reader = os.Stdin
2
w := r.(io.Writer)  // 断言是否实现了 Writer

1
func assertInterface(r io.Reader) io.Writer {
2
    // 获取 r 的 itab
3
    tab := (*iface)(unsafe.Pointer(&r)).tab
4

5
    // 查找 io.Writer 的 itab
6
    // 检查 *os.File 是否实现了 io.Writer
7
    writerItab := runtime.acquireitab(writerInterfacetype, tab._type, true)
8

9
    if writerItab == nil {
10
        runtime.panicdottype(...)
11
    }
12

13
    // 构造新的 iface
14
    return iface{tab: writerItab, data: r.data}
15
}

1
// src/runtime/iface.go — 简化版
2

3
// iface → iface，失败 panic
4
func assertI2I(inter *interfacetype, i iface) iface {
5
    tab := i.tab
6
    if tab == nil {
7
        // 接口本身是 nil，直接返回 nil iface
8
        return iface{}
9
    }
10
    // 查找目标接口的 itab
11
    tab = getitab(inter, tab._type, false)  // canfail=false，失败会 panic
12
    return iface{tab: tab, data: i.data}
13
}
14

15
// iface → iface，失败返回 ok=false
16
func assertI2I2(inter *interfacetype, i iface) (r iface, ok bool) {
17
    tab := i.tab
18
    if tab == nil {
19
        return iface{}, false
20
    }
21
    tab = getitab(inter, tab._type, true)  // canfail=true，失败返回 nil
22
    if tab == nil {
23
        return iface{}, false
24
    }
25
    r = iface{tab: tab, data: i.data}
26
    return r, true
27
}

1
// eface → 具体类型，失败 panic
2
func assertE2T(t *_type, e eface) {
3
    if e._type != t {
4
        panicdottype(e._type, t, t)
5
    }
6
}

1
func classify(i interface{}) string {
2
    switch v := i.(type) {
3
    case int:
4
        return fmt.Sprintf("int: %d", v)
5
    case string:
6
        return fmt.Sprintf("string: %s", v)
7
    case bool:
8
        return fmt.Sprintf("bool: %t", v)
9
    default:
10
        return fmt.Sprintf("unknown: %T", v)
11
    }
12
}

1
func classify(i interface{}) string {
2
    e := (*eface)(unsafe.Pointer(&i))
3

4
    if e._type == runtime.intType {
5
        v := *(*int)(e.data)
6
        return fmt.Sprintf("int: %d", v)
7
    }
8
    if e._type == runtime.stringType {
9
        v := *(*string)(e.data)
10
        return fmt.Sprintf("string: %s", v)
11
    }
12
    if e._type == runtime.boolType {
13
        v := *(*bool)(e.data)
14
        return fmt.Sprintf("bool: %t", v)
15
    }
16
    return fmt.Sprintf("unknown: %T", i)
17
}

1
type Duck interface {
2
    Quack()
3
}
4

5
type Cat struct {
6
    Name string
7
}
8

9
//go:noinline
10
func (c *Cat) Quack() {
11
    println(c.Name + " meow")
12
}
13

14
func main() {
15
    var c Duck = &Cat{Name: "draven"}
16
    c.Quack()             // 接口方法调用：动态派发
17
    c.(*Cat).Quack()      // 直接方法调用：编译期确定
18
}

1
# 1. 从 iface 中取出 tab 指针
2
MOVQ "".c+48(SP), AX          # AX = iface.tab
3

4
# 2. 从 itab 中取出 fun[0]，即 Quack 方法地址
5
MOVQ 24(AX), AX               # AX = itab.fun[0] = *Cat.Quack
6

7
# 3. 从 iface 中取出 data 指针，作为方法接收者
8
MOVQ "".c+56(SP), CX          # CX = iface.data = &Cat{...}
9
MOVQ CX, (SP)                 # 将接收者放到栈顶
10

11
# 4. 间接调用：通过寄存器中的函数指针跳转
12
CALL AX                        # 调用 Quack

1
# 直接取数据指针，放到栈顶
2
MOVQ "".c+56(SP), AX          # AX = &Cat{...}
3
MOVQ AX, (SP)                 # 接收者入栈
4

5
# 直接调用，函数地址在编译期已确定
6
CALL "".(*Cat).Quack(SB)      # 静态调用

1
func main() {
2
    var c Duck = &Cat{Name: "draven"}
3
    c.Quack()  // 编译器知道 c 的具体类型是 *Cat，
4
               // 优化后等价于 c.(*Cat).Quack()
5
}

1
# switch c.(type) { case *Cat: ... }
2
CMPL go.itab.*""."".Cat,"".Duck+16(SB), $593696792
3
JEQ  80
4
# ... 不匹配则直接返回

1
// 接口组合示例
2
type Reader interface {
3
    Read(p []byte) (n int, err error)
4
}
5

6
type Writer interface {
7
    Write(p []byte) (n int, err error)
8
}
9

10
type Closer interface {
11
    Close() error
12
}
13

14
// 组合接口
15
type ReadWriteCloser interface {
16
    Reader
17
    Writer
18
    Closer
19
}

1
var s *TestStruct      // s == nil
2
var i interface{} = s  // i != nil
3

4
fmt.Println(s == nil)  // true
5
fmt.Println(i == nil)  // false

1
// nil 接口
2
eface {
3
    _type: nil      // 类型指针为 nil
4
    data:  nil      // 数据指针为 nil
5
}

1
// 持有 *TestStruct(nil) 的接口
2
eface {
3
    _type: &runtime.ptrType  // 类型指针指向 *TestStruct 的元数据
4
    data:  nil               // 数据指针为 nil（指针本身的零值）
5
}

1
var r io.Reader   // r 是 nil 接口
2
// iface { tab: nil, data: nil }
3

4
var f *os.File    // f == nil
5
var r2 io.Reader = f  // r2 不是 nil 接口
6
// iface { tab: &itab{inter: io.Reader, _type: *os.File, ...}, data: nil }

1
func GetError() error {
2
    var err *MyError  // err == nil
3
    return err        // 返回的 error 接口不是 nil！
4
}
5

6
func main() {
7
    if err := GetError(); err != nil {
8
        fmt.Println("error occurred")  // 会走到这里，违背直觉
9
    }
10
}

1
func GetError() error {
2
    var err *MyError
3
    if err == nil {
4
        return nil   // 返回真正的 nil 接口
5
    }
6
    return err
7
}

1
package main
2

3
import (
4
    "fmt"
5
    "reflect"
6
)
7

8
func main() {
9
    var x float64 = 3.14
10

11
    // TypeOf 返回类型信息
12
    t := reflect.TypeOf(x)
13
    fmt.Println("type:", t)              // type: float64
14
    fmt.Println("kind:", t.Kind())        // kind: float64
15
    fmt.Println("name:", t.Name())        // name: float64
16
    fmt.Println("size:", t.Size())        // size: 8
17

18
    // ValueOf 返回值信息
19
    v := reflect.ValueOf(x)
20
    fmt.Println("value:", v)              // value: 3.14
21
    fmt.Println("type:", v.Type())        // type: float64
22
    fmt.Println("kind:", v.Kind())        // kind: float64
23
    fmt.Println("float:", v.Float())      // float: 3.14
24
}

1
// reflect.TypeOf 返回 *rtype
2
type rtype struct {
3
    size    uintptr
4
    ptrdata uintptr
5
    hash    uint32
6
    tflag   tflag
7
    align   uint8
8
    fieldAlign uint8
9
    kind    uint8
10
    equal   func(unsafe.Pointer, unsafe.Pointer) bool
11
    gcdata  *byte
12
    str     nameOff
13
    ptrToThis typeOff
14
}
15

16
// reflect.ValueOf 返回 Value 结构
17
type Value struct {
18
    typ  *rtype          // 类型信息
19
    ptr  unsafe.Pointer  // 数据指针
20
    flag flag            // 标志位（包含 Kind、可寻址性等）
21
}

1
func main() {
2
    var x float64 = 3.14
3
    v := reflect.ValueOf(x)
4

5
    // 从反射对象创建接口值
6
    i := v.Interface()
7

8
    // 类型断言获取原值
9
    f := i.(float64)
10
    fmt.Println("value:", f)  // value: 3.14
11
}

1
func main() {
2
    var x float64 = 3.14
3

4
    // 错误：传的是 x 的副本
5
    v := reflect.ValueOf(x)
6
    fmt.Println("settability:", v.CanSet())  // settability: false
7

8
    // v.SetFloat(7.1) // panic: reflect.Value.SetFloat using unaddressable value
9

10
    // 正确：传 x 的指针
11
    pv := reflect.ValueOf(&x)
12
    fmt.Println("settability of pointer:", pv.CanSet())  // false
13

14
    // 解引用指针
15
    v2 := pv.Elem()
16
    fmt.Println("settability after Elem:", v2.CanSet())  // true
17
    v2.SetFloat(7.1)
18
    fmt.Println("x after set:", x)  // x after set: 7.1
19
}

1
type MyInt int
2

3
func main() {
4
    var x MyInt = 42
5
    t := reflect.TypeOf(x)
6

7
    fmt.Println("Type:", t)        // Type: main.MyInt
8
    fmt.Println("Kind:", t.Kind()) // Kind: int
9

10
    // Kind 枚举值
11
    fmt.Println(reflect.Bool)      // bool
12
    fmt.Println(reflect.Int)       // int
13
    fmt.Println(reflect.Struct)    // struct
14
    fmt.Println(reflect.Ptr)       // ptr
15
    fmt.Println(reflect.Func)      // func
16
}

1
type Kind uint
2

3
const (
4
    Invalid Kind = iota
5
    Bool
6
    Int
7
    Int8
8
    Int16
9
    Int32
10
    Int64
11
    Uint
12
    Uint8
13
    Uint16
14
    Uint32
15
    Uint64
16
    Uintptr
17
    Float32
18
    Float64
19
    Complex64
20
    Complex128
21
    Array
22
    Chan
23
    Func
24
    Interface
25
    Map
26
    Pointer
27
    Slice
28
    String
29
    Struct
30
    UnsafePointer
31
)

1
type User struct {
2
    Name string `json:"name" validate:"required"`
3
    Age  int    `json:"age" validate:"min=0"`
4
}
5

6
func inspectStruct(x interface{}) {
7
    t := reflect.TypeOf(x)
8
    v := reflect.ValueOf(x)
9

10
    // 确保是结构体
11
    if t.Kind() == reflect.Ptr {
12
        t = t.Elem()
13
        v = v.Elem()
14
    }
15

16
    fmt.Printf("Type: %s\n", t.Name())
17

18
    // 遍历字段
19
    for i := 0; i < t.NumField(); i++ {
20
        field := t.Field(i)
21
        value := v.Field(i)
22

23
        fmt.Printf("  Field %d: %s (%s) = %v\n",
24
            i, field.Name, field.Type, value.Interface())
25

26
        // 读取标签
27
        if tag := field.Tag.Get("json"); tag != "" {
28
            fmt.Printf("    json tag: %s\n", tag)
29
        }
30
    }
31

32
    // 遍历方法
33
    for i := 0; i < t.NumMethod(); i++ {
34
        method := t.Method(i)
35
        fmt.Printf("  Method %d: %s\n", i, method.Name)
36
    }
37
}
38

39
func main() {
40
    user := User{Name: "Alice", Age: 30}
41
    inspectStruct(user)
42
}

1
type Calculator struct{}
2

3
func (c Calculator) Add(a, b int) int {
4
    return a + b
5
}
6

7
func (c Calculator) Multiply(a, b int) int {
8
    return a * b
9
}
10

11
func callMethod(obj interface{}, name string, args ...interface{}) []interface{} {
12
    v := reflect.ValueOf(obj)
13

14
    // 获取方法
15
    method := v.MethodByName(name)
16
    if !method.IsValid() {
17
        panic(fmt.Sprintf("method %s not found", name))
18
    }
19

20
    // 构造参数
21
    in := make([]reflect.Value, len(args))
22
    for i, arg := range args {
23
        in[i] = reflect.ValueOf(arg)
24
    }
25

26
    // 调用方法
27
    out := method.Call(in)
28

29
    // 转换结果
30
    result := make([]interface{}, len(out))
31
    for i, v := range out {
32
        result[i] = v.Interface()
33
    }
34
    return result
35
}
36

37
func main() {
38
    calc := Calculator{}
39

40
    result := callMethod(calc, "Add", 3, 5)
41
    fmt.Println("Add(3, 5) =", result[0])  // Add(3, 5) = 8
42

43
    result = callMethod(calc, "Multiply", 4, 6)
44
    fmt.Println("Multiply(4, 6) =", result[0])  // Multiply(4, 6) = 24
45
}

1
func main() {
2
    // 创建基本类型
3
    intType := reflect.TypeOf(0)
4
    intPtr := reflect.New(intType)  // 返回 *int 类型的 Value
5
    intPtr.Elem().SetInt(42)
6
    fmt.Println("new int:", intPtr.Elem().Int())  // new int: 42
7

8
    // 创建切片
9
    sliceType := reflect.SliceOf(reflect.TypeOf(0))
10
    slice := reflect.MakeSlice(sliceType, 0, 10)
11
    slice = reflect.Append(slice, reflect.ValueOf(1))
12
    slice = reflect.Append(slice, reflect.ValueOf(2))
13
    fmt.Println("slice:", slice.Interface())  // slice: [1 2]
14

15
    // 创建 map
16
    mapType := reflect.MapOf(reflect.TypeOf(""), reflect.TypeOf(0))
17
    m := reflect.MakeMap(mapType)
18
    m.SetMapIndex(reflect.ValueOf("a"), reflect.ValueOf(1))
19
    fmt.Println("map:", m.Interface())  // map: map[a:1]
20

21
    // 创建结构体
22
    userType := reflect.TypeOf(User{})
23
    userValue := reflect.New(userType).Elem()
24
    userValue.FieldByName("Name").SetString("Bob")
25
    userValue.FieldByName("Age").SetInt(25)
26
    fmt.Printf("user: %+v\n", userValue.Interface())  // user: {Name:Bob Age:25}
27
}

1
// benchmark 示例
2
func BenchmarkDirectCall(b *testing.B) {
3
    var sum int
4
    for i := 0; i < b.N; i++ {
5
        sum += add(i, i+1)
6
    }
7
}
8

9
func BenchmarkInterfaceCall(b *testing.B) {
10
    var sum interface{}
11
    for i := 0; i < b.N; i++ {
12
        sum = addInterface(i, i+1)
13
    }
14
}
15

16
func add(a, b int) int {
17
    return a + b
18
}
19

20
func addInterface(a, b interface{}) interface{} {
21
    return a.(int) + b.(int)
22
}

1
// 第一次转换：需要生成 itab
2
var r io.Reader = &os.File{}
3
// 后续相同类型的转换：直接从缓存获取
4

5
// 类型断言：需要验证 itab
6
w := r.(io.Writer)

1
// 避免：在热点路径中使用接口
2
func sumInts(nums []interface{}) int {
3
    var sum int
4
    for _, n := range nums {
5
        sum += n.(int)
6
    }
7
    return sum
8
}
9

10
// 推荐：使用泛型或具体类型
11
func sumIntsGeneric[T int | int32 | int64](nums []T) T {
12
    var sum T
13
    for _, n := range nums {
14
        sum += n
15
    }
16
    return sum
17
}
18

19
// 推荐：在边界使用接口，内部使用具体类型
20
func Process(data interface{}) error {
21
    // 在边界断言一次
22
    d, ok := data.(*Data)
23
    if !ok {
24
        return errors.New("invalid type")
25
    }
26
    // 内部使用具体类型
27
    return processConcrete(d)
28
}

1
// 通用队列
2
type Queue struct {
3
    items []interface{}
4
}
5

6
func (q *Queue) Push(v interface{}) {
7
    q.items = append(q.items, v)
8
}
9

10
func (q *Queue) Pop() interface{} {
11
    if len(q.items) == 0 {
12
        return nil
13
    }
14
    v := q.items[0]
15
    q.items = q.items[1:]
16
    return v
17
}

1
// 处理多种类型
2
func process(v interface{}) error {
3
    switch val := v.(type) {
4
    case int:
5
        return processInt(val)
6
    case string:
7
        return processString(val)
8
    case []byte:
9
        return processBytes(val)
10
    default:
11
        return fmt.Errorf("unsupported type: %T", v)
12
    }
13
}

1
var data interface{}
2
json.Unmarshal([]byte(`{"name": "Alice", "age": 30}`), &data)
3
// data 类型为 map[string]interface{}
4

5
// 类型安全的方式
6
type Person struct {
7
    Name string `json:"name"`
8
    Age  int    `json:"age"`
9
}
10
var person Person
11
json.Unmarshal([]byte(`{"name": "Alice", "age": 30}`), &person)

1
type FieldAccessor struct {
2
    fieldIndex int
3
    fieldType  reflect.Type
4
}
5

6
func NewFieldAccessor(t reflect.Type, name string) *FieldAccessor {
7
    field, ok := t.FieldByName(name)
8
    if !ok {
9
        panic("field not found")
10
    }
11
    return &FieldAccessor{
12
        fieldIndex: field.Index[0],
13
        fieldType:  field.Type,
14
    }
15
}
16

17
func (a *FieldAccessor) Get(v reflect.Value) reflect.Value {
18
    return v.Field(a.fieldIndex)
19
}

1
//go:generate go run github.com/your/gen/cmd/structmapper
2

3
// 生成的代码避免了反射
4
func (u *User) GetName() string { return u.Name }
5
func (u *User) SetName(v string) { u.Name = v }

1
// 使用反射
2
func validate(v interface{}) error {
3
    rv := reflect.ValueOf(v)
4
    if rv.Kind() == reflect.Struct {
5
        for i := 0; i < rv.NumField(); i++ {
6
            // 反射检查每个字段
7
        }
8
    }
9
    return nil
10
}
11

12
// 使用接口
13
type Validator interface {
14
    Validate() error
15
}
16

17
func validate(v Validator) error {
18
    return v.Validate()
19
}