反射的引入#

【1】反射可以做什么？ 1）反射可以在运行时动态获取变量的各种信息，比如变量的类型，类别等信息 2)如果是结构体变量，还可以获取到结构体本身的信息(包括结构体的字段、方法) 3)通过反射，可以修改变量的值，可以调用关联的方法。 4)使用反射，需要import(“reflect”) 【2】反射相关的函数 1)reflect.TypeOf(变量名)，获取变量的类型，返回reflect.Type类型 2)reflect.ValueOf(变量名)，获取变量的值，返回reflect.Value类型(reflect.Value是一个结构体类型),通过reflect.Value，可以获取到关于该变量的很多信息。

PixPin_2025-07-15_18-23-14 PixPin_2025-07-15_18-23-29

对基本数据类型反射#

【1】反射相关的函数 1)reflect.TypeOf(变量名)，获取变量的类型，返回reflect.Type类型 2)reflectValueOf变量名)，获取变量的值，返回reflect.Value类型(reflect.Value是一个结构体类型),通过reflect.Value，可以获取到关于该变量的很多信息。【2】代码：

1
package main
2

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

8
//利用一个函数,函数的参数定义为空接口:
9
func testReflect(i interface{})  {//空接口没有任何方法，所以可以理解为所有类型都实现了空接口，也可以理解为我们可以把任何一个变量赋给空接口。
10
  //1.调用TypeOf函数,返回reflect.Type类型数据:
11
  reType := reflect.TypeOf(i)
12
  fmt.Println("reType:",reType)
13
  fmt.Printf("reType的具体类型是:%T",reType)
14
  //2.调用ValueOf函数,返回reflect.Value类型数据:
15
  reValue := reflect.ValueOf(i)
16
  fmt.Println("reValue",reValue)
17
  fmt.Printf("reValue的具体类型是:%T",reValue)
18
  //num1 := 100
19
  //如果真想获取reValue的数值,要调用Int方法：返回v持有的有符号整数
20
  num2 := 80 + reValue.Int()
21
  fmt.Println(num2)
22

23
  //reValue转成空接口：
24
  i2 := reValue.Interface()
25
  //类型断言：
26
  n := i2.(int)
27
  n2 := n + 30
28
  fmt.Println(n2)
29

30
}
31
func main()  {
32
  //对基本数据类型进行反射:
33
  //定义一个基本数据类型:
34
  var num int = 100
35
  testReflect(num)
36

37
}

PixPin_2025-07-15_22-05-28 这段代码演示了 Go 中反射（reflect）的核心用法，并且还结合了类型断言。我来帮你详细讲解，包括：

为什么要用 reflect
每一步干了什么
interface{} 的作用
最后断言部分为什么需要、怎么做

✅ 先看 big picture：做了什么？#

定义了一个函数：testReflect(i interface{})
接收任何类型的值（因为参数是 interface{}，即空接口）
用反射拿到：
- 类型信息（reflect.Type）
- 值信息（reflect.Value）
通过 reValue.Int() 获取实际的 int 数值
最后通过 reValue.Interface() 转回 interface{}，再用类型断言拿到真正的 int

🧩 逐行讲解#

🌱 空接口：万能参数#

1
func testReflect(i interface{})

在 Go 里，空接口 interface{} 表示任意类型都可以传进来
所以可以对任意值进行反射

1️⃣ 获取类型#

1
reType := reflect.TypeOf(i)
2
fmt.Println("reType:", reType) // 输出：int
3
fmt.Printf("reType的具体类型是:%T", reType) // 输出：*reflect.rtype（或 reflect.Type）

reflect.TypeOf(i) 返回一个 reflect.Type 对象
可以用它看变量的类型，比如 int、string、struct 等

2️⃣ 获取值#

1
reValue := reflect.ValueOf(i)
2
fmt.Println("reValue", reValue) // 输出：100
3
fmt.Printf("reValue的具体类型是:%T", reValue) // reflect.Value

reflect.ValueOf(i) 返回 reflect.Value
reflect.Value 可以进一步操作：获取值、修改值（如果可修改）

3️⃣ 真正获取数值#

1
num2 := 80 + reValue.Int()
2
fmt.Println(num2)

因为 reValue 是 int 类型的值，想得到它的数值，需要用 reValue.Int() 方法
Int() 返回 int64（注意是 int64）
可以做加法运算

4️⃣ 转回 interface{} 并断言#

1
i2 := reValue.Interface()
2
n := i2.(int) // 类型断言
3
n2 := n + 30
4
fmt.Println(n2)

这里很关键：

reValue.Interface() 返回一个空接口（interface{}）
想要拿到真正的 int，需要告诉编译器：我确定这个 interface{} 里装的就是 int
所以用类型断言：i2.(int)

类型断言语法：

1
v, ok := i2.(int)

如果是 int 类型：ok == true
如果不是 int 类型：ok == false，v 是默认值（0）

这里直接用：

1
n := i2.(int)

如果不是 int，会 panic（运行时报错）

✅ 为什么需要类型断言？#

因为：

空接口 interface{} 自身什么都不能做，只能装值
要想用里面的值（比如做加法、调用方法），必须先确定具体类型

类型断言：让编译器/运行时知道：我确定这是 int，然后就能当作 int 用。

🔧 总结下流程：#

步骤	作用
reflect.TypeOf(i)	得到类型
reflect.ValueOf(i)	得到值
reValue.Int()	从 reflect.Value 得到真实的 int 数值
reValue.Interface()	转成 interface{}
.(int)	类型断言，拿到具体类型的值

✏ 为什么要 Interface() 再断言？#

reflect.Value 是反射的容器，如果要拿回「原始值」就要用 .Interface()
Interface() 返回值是 interface{}
然后类型断言拿到真正的值，继续用

🧠 一图总结：#

1
值 num=100 --> 空接口 i=interface{} --> reflect.Value reValue --> reValue.Int()
2
                                     \
3
                                      --> reValue.Interface()=interface{} --> 类型断言 .(int) --> n=100

🚀 一句话总结：#

Go 的反射：先拿到 Type 和 Value，如果要用 Value 的真实值：

用 reValue.Int()/String() 等直接取

或者 reValue.Interface() 转回 interface{}，再类型断言拿到原始类型

⚡ 反射灵活，但慢，不建议频繁用。

对结构体类型反射#

【1】反射相关的函数 1)reflect.TypeOf(变量名)，获取变量的类型，返回reflect.Type类型 2)reflect.ValueOf(变量名)，获取变量的值，返回reflect.Value类型(reflect.Value是一个结构体类型),通过reflect.Value，可以获取到关于该变量的很多信息。【2】代码：

1
package main
2

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

8
//利用一个函数,函数的参数定义为空接口:
9
func testReflect(i interface{})  {//空接口没有任何方法，所以可以理解为所有类型都实现了空接口，也可以理解为我们可以把任何一个变量赋给空接口。
10
  //1.调用TypeOf函数,返回reflect.Type类型数据:
11
  reType := reflect.TypeOf(i)
12
  fmt.Println("reType:",reType)
13
  fmt.Printf("reType的具体类型是:%T",reType)
14
  //2.调用ValueOf函数,返回reflect.Value类型数据:
15
  reValue := reflect.ValueOf(i)
16
  fmt.Println("reValue",reValue)
17
  fmt.Printf("reValue的具体类型是:%T",reValue)
18

19

20
  //reValue转成空接口：
21
  i2 := reValue.Interface()
22
  //类型断言：
23
  n ,flag := i2.(Student)
24
  if flag == true {//断言成功
25
    fmt.Printf("学生的名字是:%v,学生的年龄是%v",n.Name,n.Age)
26
  }
27

28
}
29

30
type Student struct{
31
  Name string
32
  Age int
33

34
}
35

36

37
func main()  {
38
  //对结构体类型进行反射:
39
  //定义结构体具体的类型:
40
  stu := Student{
41
    Name: "丽丽",
42
    Age: 18,
43
  }
44
  testReflect(stu)
45

46
}

获取变量的类别#

【1】获取变量的类别：两种方式： (1) reflect.Type.Kind0 (2)reflect.Value.Kind0 【2】Kind的值是常量值：

type Kind #

1
type Kind uint

Kind代表Type类型值表示的具体分类。零值表示非法分类。

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

【3】代码：

1
package main
2

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

8
//利用一个函数,函数的参数定义为空接口:
9
func testReflect(i interface{})  {//空接口没有任何方法，所以可以理解为所有类型都实现了空接口，也可以理解为我们可以把任何一个变量赋给空接口。
10
  //1.调用TypeOf函数,返回reflect.Type类型数据:
11
  reType := reflect.TypeOf(i)
12

13
  //2.调用ValueOf函数,返回reflect.Value类型数据:
14
  reValue := reflect.ValueOf(i)
15

16

17
  //获取变量的类别：
18
  //(1)reType.kind()
19
  k1:=reType.Kind()
20
  fmt.Println(k1)
21

22
  //(2)reValue.kind()
23
  k2:=reValue.Kind()
24
  fmt.Println(k2)
25

26
  //获取变量的类型：
27
  //reValue转成空接口：
28
  i2 := reValue.Interface()
29
  //类型断言：
30
  n ,flag := i2.(Student)
31
  if flag == true {//断言成功
32
    fmt.Printf("结构体的类型是:%T",n)
33
  }
34
}
35

36
type Student struct{
37
  Name string
38
  Age int
39

40
}
41

42

43
func main()  {
44
  //对结构体类型进行反射:
45
  //定义结构体具体的类型:
46
  stu := Student{
47
    Name: "丽丽",
48
    Age: 18,
49
  }
50
  testReflect(stu)
51

52
}

通过反射修改变量#

【1】修改基本数据类型的值：

1
package main
2

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

9
//利用一个函数,函数的参数定义为空接口:
10
func testReflect(i interface{})  {//空接口没有任何方法，所以可以理解为所有类型都实现了空接口，也可以理解为我们可以把任何一个变量赋给空接口。
11
  reValue := reflect.ValueOf(i)
12
  //通过SetInt()来改变值:
13
  reValue.Elem().SetInt(40)
14

15
}
16
func main()  {
17
  //对基本数据类型进行反射:
18
  //定义一个基本数据类型:
19
  var num int = 100
20
  testReflect(&num)//传入指针地址
21
  fmt.Println(num)
22
}

func (Value) Elem #

1
func (v Value) Elem() Value

Elem返回v持有的接口保管的值的Value封装，或者v持有的指针指向的值的Value封装。如果v的Kind不是Interface或Ptr会panic；如果v持有的值为nil，会返回Value零值。

通过反射操作结构体的属性和方法#

【1】代码：(熟知API）

1
package main
2

3
import (
4
  // "fmt"
5
  "fmt"
6
  "reflect"
7
)
8
//定义一个结构体:
9
type Student struct {
10
  Name string
11
  Age int
12
}
13

14
//给结构体绑定方法:
15
func (s Student)CPrint(){
16
  fmt.Println("调用了CPrint()方法")
17
  fmt.Println("学生的名字是:",s.Name)
18
}
19

20
func (s Student)AGetSum(n1,n2 int) int {
21
  fmt.Println("调用了AGetSum()方法")
22
  return n1+ n2
23
}
24

25
func (s Student)BSet(name string,age int)  {
26
  fmt.Println("调用了BSet()方法")
27
  s.Name = name
28
  s.Age = age
29
}
30

31
//定义函数操作结构体进行反射操作:
32
func TestStudentStruct(a interface{})  {
33
  //a转成reflect.Value类型:
34
  val := reflect.ValueOf(a)
35
  fmt.Println(val)
36

37

38

39
  //通过Ireflect.Value类型操作结构体内部的字段：
40
  n1 := val.NumField()
41
  fmt.Println(n1)
42
  //遍历-获取具体的字段:
43
  for i:=0;i<n1;i++{
44
    fmt.Printf("第%d个字段的值是:%v\n",i,val.Field(i))
45
  }
46

47

48
  //通过reflect.Value类型操作结构体内部的方法：
49
  n2 := val.NumMethod()
50
  fmt.Println(n2)
51

52
  //调用CPrint()方法:
53
  //调用方法,方法的首字母必须大写才能用=有对应的反射的访问权限
54
  //方法的顺序按照ASCII的顺序排列的,a,b,c,,,,,索引:
55

56
  val.Method(2).Call(nil)
57

58
  //调用AGetSum方法:
59
  //定义Value的切片:
60
  var params []reflect.Value
61
  params = append(params, reflect.ValueOf(10))
62
  params = append(params, reflect.ValueOf(20))
63
  result := val.Method(0).Call(params)
64
  fmt.Println("AGetSum方法的返回值为:",result[0].Int())
65
}
66
func main()  {
67
  s:= Student{
68
    Name: "丽丽",
69
    Age: 18,
70
  }
71
  //调用TestStudentStruct:
72
  TestStudentStruct(s)
73
}

通过反射修改变量#

【1】代码：

1
package main
2

3
import (
4
  // "fmt"
5
  "fmt"
6
  "reflect"
7
)
8
//定义一个结构体:
9
type Student struct {
10
  Name string
11
  Age int
12
}
13

14
//给结构体绑定方法:
15
func (s Student)CPrint(){
16
  fmt.Println("调用了CPrint()方法")
17
  fmt.Println("学生的名字是:",s.Name)
18
}
19

20
func (s Student)AGetSum(n1,n2 int) int {
21
  fmt.Println("调用了AGetSum()方法")
22
  return n1+ n2
23
}
24

25
func (s Student)BSet(name string,age int)  {
26
  fmt.Println("调用了BSet()方法")
27
  s.Name = name
28
  s.Age = age
29
}
30

31
//定义函数操作结构体进行反射操作:
32
func TestStudentStruct(a interface{})  {
33
  //a转成reflect.Value类型:
34
  val := reflect.ValueOf(a)
35
  fmt.Println(val)
36

37
  n := val.Elem().NumField()
38
  fmt.Println(n)
39

40
  //修改字段的值:
41
  val.Elem().Field(0).SetString("张三")
42

43

44
}
45
func main()  {
46
  s:= Student{
47
    Name: "丽丽",
48
    Age: 18,
49
  }
50
  //调用TestStudentStruct:
51
  TestStudentStruct(&s)
52
  fmt.Println(s)
53
}

✅ 反射到底有什么用？ ✅ 为什么不用正常写法而要用反射？ ✅ 实际项目里什么情况下才用？

我帮你从原理、作用到实际应用详细讲解：

🧪 📦 反射的本质：#

反射就是在运行时（runtime）获取、修改对象的结构和行为：

获取：查看一个变量的类型、字段、方法
修改：修改字段值
调用：动态调用方法

而不是在编译期就写死。

🎯 为什么不用正常写法，而用反射？#

正常写：

1
s.Name = "张三"
2
fmt.Println(s.AGetSum(1, 2))

优点：

简洁
类型安全（编译时检查）

反射写：

不知道变量具体类型，只知道它是 interface{}
要到运行时再确定字段名、方法名、参数个数
可以写「通用」代码，对很多不同类型对象进行同样的处理

🧰 实际项目中常见用途：#

下面举几个经典例子：

1️⃣ 通用序列化 / 反序列化#

比如：

把结构体转 JSON
从 JSON 转结构体

你需要动态访问结构体字段：

1
for i := 0; i < val.NumField(); i++ {
2
   fieldName := val.Type().Field(i).Name
3
   fieldValue := val.Field(i).Interface()
4
   // 组装成 map/json
5
}

Go 自带的 encoding/json 包就大量用反射实现。

2️⃣ ORM 框架（对象关系映射）#

比如 GORM：

用户定义结构体：

1
type User struct {
2
    ID int
3
    Name string
4
}

框架需要自动生成 SQL：

1
INSERT INTO users (id, name) VALUES (?, ?)

就需要用反射获取字段名、字段值。

3️⃣ 写通用工具 / 库#

比如写一个：

日志工具：能打印任意结构体内容
验证工具：校验结构体字段
Web 框架：把 HTTP 请求参数自动绑定到结构体

这些都需要对「未知类型」做操作，只能在运行时用反射。

4️⃣ RPC 框架 / 接口注册#

比如写一个远程调用框架：

用户写了：
```
1
func Add(a, b int) int { return a+b }
```
框架在启动时，把这个函数注册到一个 map
收到网络请求时，根据函数名动态找到方法，用反射调用

🚀 总结一句话：#

反射的作用是：在不知道类型或字段/方法名的情况下，在运行时对对象进行统一、动态的操作。

⚠️ 注意：#

反射灵活，但有缺点：
- 性能慢（需要做很多运行时检查）
- 写起来复杂
- 失去类型安全
所以：正常业务逻辑尽量不用反射，只在做框架、通用库、工具时用。

assert(0)

反射的引入#

对基本数据类型反射#

✅ 先看 big picture：做了什么？#

🧩 逐行讲解#

🌱 空接口：万能参数#

1️⃣ 获取类型#

2️⃣ 获取值#

3️⃣ 真正获取数值#

4️⃣ 转回 interface{} 并断言#

✅ 为什么需要类型断言？#

🔧 总结下流程：#

✏ 为什么要 Interface() 再断言？#

🧠 一图总结：#

🚀 一句话总结：#

对结构体类型反射#

获取变量的类别#

type Kind#

通过反射修改变量#

func (Value) Elem#

通过反射操作结构体的属性和方法#

通过反射修改变量#

🧪 📦 反射的本质：#

🎯 为什么不用正常写法，而用反射？#

🧰 实际项目中常见用途：#

1️⃣ 通用序列化 / 反序列化#

2️⃣ ORM 框架（对象关系映射）#

3️⃣ 写通用工具 / 库#

4️⃣ RPC 框架 / 接口注册#

🚀 总结一句话：#

⚠️ 注意：#

type Kind #

func (Value) Elem #