2024年最全最新golang语言面试题总结（三）_golang多态面试题，Golang社招面经分享_golang面试题2024

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要这份系统化的资料的朋友，可以添加戳这里获取

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！

• 除以 0
• 向已经关闭的 channel 发送消息
• 重复关闭 channel
• 关闭未初始化的 channel
• 未初始化 map。注意访问 map 不存在的 key 不会 panic，而是返回 map 类型对应的零值，但是不能直接赋值
• 跨协程的 panic 处理
• sync 计数为负数。
• 类型断言不匹配。var a interface{} = 1; fmt.Println(a.(string)) 会 panic，建议用 s,ok := a.(string)

1
2

8、Http是短连接还是长连接？

• 在HTTP/1.0中，默认使用的其实是短连接。也就是说，浏览器和服务器每进行一次HTTP操作，就要建立一次连接，但任务结束后就会中断连接。如果客户端浏览器访问的某个HTML或其他类型的 Web页中包含有其他的Web资源，如JavaScript文件、图像文件、CSS文件等；当浏览器每遇到这样一个Web资源，就会建立一个HTTP会话；
• 但从HTTP/1.1起，默认使用长连接，用以保持会话的连接特性。使用长连接的HTTP协议，会在响应头中加入这行代码：Connection:keep-alive；
• 在使用长连接的情况下，当一个网页打开完成后，客户端和服务器之间用于传输HTTP数据的 TCP连接不会关闭，如果客户端再次访问这个服务器上的网页，会继续使用这一条已经建立好的连接。但Keep-Alive也不会永久保持连接，它有一个保持时间，可以在不同的服务器软件(如Apache)中设定这个时间。我们要注意，实现长连接要客户端和服务端都支持长连接。
• TCP三次握手和四次挥手过程

既然上面我们说到了三次握手和四次挥手，健哥就再扩展一下说说这两个操作的实现过程。

三次握手：先向HTTP服务器发起TCP的确认请求

• 客户端 --> SYN --> 服务器
• 服务器 --> SYN+ACK —>客户端
• 客户端 --> ACK --> 服务器
• 四次挥手：客户端要和服务器断开TCP连接
• 客户端 --> FIN +ACK —> 服务器
• 服务器 --> FIN —> 客户端
• 服务器 --> ACK --> 客户端
• 客户端 --> ACK —> 服务器

总结

1、Http协议到底是长连接还是短连接，要看HTTP协议的版本，Http1.0中默认是短连接，      2、 Http1.1中默认是长连接；

3、 Http协议位于OSI网络模型的应用层；

4、Http协议底层在传输层上使用的是TCP协议，在网络层使用的是IP协议；

5、TCP协议具有三次握手和四次挥手的过程，传输数据安全稳定。

9、liunx协程和线程初始申请内存大小

协程初始化创立的时候为其调配的栈有2KB。而线程栈要比这个数字大的多，能够通过ulimit 命令查看，个别都在几兆，作者的机器上是10M。如果对每个用户创立一个协程去解决，100万并发用户申请只须要2G内存就够了，而如果用线程模型则须要10T。

协程和线程默认申请的内存是堆内存

10、go面试题实现一个内存缓存系统

面试题内容
1、支持设定过期时间，精度到秒
2、支持设定最大内存，当前超出时做出合适的处理
3、支持并发安全
4、按照以下接口要求实现

1
2
3
4
5
6

type Cache interface {
	//size:1KB 100KB 1MB 2MB 1GB
	SetMaxMemory(size string) bool
	//将value写入缓存
	Set(key string, val interface{}, expire time.Duration) bool
	//根据key值获取value
	Get(key string) (interface{}, bool)
	//删除key
	Del(key string) bool
	//判断key是否存在
	Exists(key string) bool
	//清空所有key
	Flush() bool
	//获取缓存中所有key的数量
	Keys() int64
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

1、util.go文件中代码

package cache

import (
	"encoding/json"
	"log"
	"regexp"
	"strconv"
	"strings"
)

const (
	B = 1 << (iota * 10)
	KB
	MB
	GB
	TB
	PB
)

func ParseSize(size string) (int64, string) {
	//默认大小为100MB
	re, _ := regexp.Compile("[0-9]+")
	unit := string(re.ReplaceAll([]byte(size), []byte("")))
	num, _ := strconv.ParseInt(strings.Replace(size, unit, "", 1), 10, 64)
	unit = strings.ToUpper(unit)
	var byteNum int64 = 0
	switch unit {
	case "B":
		byteNum = num
	case "KB":
		byteNum = num * KB
	case "MB":
		byteNum = num * MB
	case "GB":
		byteNum = num * GB
	case "TB":
		byteNum = num * TB
	case "PB":
		byteNum = num * PB
	default:
		num = 0
		byteNum = 0
	}
	if num == 0 {
		log.Println("ParseSize 仅支持B KB MB GB TB PB")
		num = 100
		unit = "MB"
		byteNum = num * MB
	}
	sizeStr := strconv.FormatInt(num, 10) + unit
	return byteNum, sizeStr
}
func GetValSize(val interface{}) int64 {
	bytes, _ := json.Marshal(val)
	size := int64(len(bytes))
	return size
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58

2、cache.go

package cache

import "time"

type Cache interface {
	//size:1KB 100KB 1MB 2MB 1GB
	SetMaxMemory(size string) bool
	//将value写入缓存
	Set(key string, val interface{}, expire time.Duration) bool
	//根据key值获取value
	Get(key string) (interface{}, bool)
	//删除key
	Del(key string) bool
	//判断key是否存在
	Exists(key string) bool
	//清空所有key
	Flush() bool
	//获取缓存中所有key的数量
	Keys() int64
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

3、memCache.go

package cache

import (
	"fmt"
	"log"
	"sync"
	"time"
)

type memCache struct {
	//最大内存
	maxMemorySize int64
	//最大内存字符串表示
	maxMemorySizeStr string
	//当前已使用内存
	currencyMemorySize int64
	//缓存健值对
	values map[string]*memCacheValue
	//读写锁
	locker sync.RWMutex
	//清除过期缓存时间间隔
	clearExpireItemTimeInterval time.Duration
}
type memCacheValue struct {
	//value值
	val interface{}
	//过期时间
	expireTime time.Time
	//有效时长
	expire time.Duration
	//value 大小
	size int64
}

func NewMemCache() Cache {
	mc := &memCache{
		values:                      make(map[string]*memCacheValue),
		clearExpireItemTimeInterval: time.Second * 10,
	}
	//go mc.clearExpireItem()
	return mc
}

//size:1KB 100KB 1MB 2MB 1GB
func (mc *memCache) SetMaxMemory(size string) bool {
	mc.maxMemorySize, mc.maxMemorySizeStr = ParseSize(size)
	return true
}

//将value写入缓存
func (mc *memCache) Set(key string, val interface{}, expire time.Duration) bool {
	mc.locker.Lock()
	defer mc.locker.Unlock()
	v := &memCacheValue{
		val:        val,
		expireTime: time.Now().Add(expire),
		expire:     expire,
		size:       GetValSize(val),
	}
	mc.del(key)
	mc.add(key, v)
	if mc.currencyMemorySize > mc.maxMemorySize {
		mc.del(key)
		log.Println(fmt.Sprintf("max memory size %d", mc.maxMemorySize))
	}
	return true
}
func (mc *memCache) Get(key string) (interface{}, bool) {
	mc.locker.RLock()
	defer mc.locker.RUnlock()
	mcv, ok := mc.values[key]
	if ok {
		//判断缓存是否过期
		if mcv.expire != 0 && mcv.expireTime.Before(time.Now()) {
			mc.del(key)
			return nil, false
		}
		return mcv.val, ok
	}
	return nil, false
}
func (mc *memCache) del(key string) {
	tmp, ok := mc.get(key)
	if ok && tmp != nil {
		mc.currencyMemorySize -= tmp.size
		delete(mc.values, key)
	}
}
func (mc *memCache) add(key string, val *memCacheValue) {
	mc.values[key] = val
	mc.currencyMemorySize += val.size
}

//根据key值获取value
func (mc *memCache) get(key string) (*memCacheValue, bool) {
	val, ok := mc.values[key]
	return val, ok
}

//删除key
func (mc *memCache) Del(key string) bool {
	mc.locker.Lock()
	defer mc.locker.Unlock()
	mc.del(key)
	return true
}

//判断key是否存在
func (mc *memCache) Exists(key string) bool {
	mc.locker.RLock()
	defer mc.locker.RUnlock()
	_, ok := mc.values[key]
	return ok
}

//清空所有key
func (mc *memCache) Flush() bool {
	mc.locker.Lock()
	defer mc.locker.Unlock()
	mc.values = make(map[string]*memCacheValue, 0)
	mc.currencyMemorySize = 0
	return true
}

//获取缓存中所有key的数量
func (mc *memCache) Keys() int64 {
	mc.locker.RLock()
	defer mc.locker.RUnlock()
	return int64(len(mc.values))
}
func (mc *memCache) clearExpireItem() {
	timeTicker := time.NewTicker(mc.clearExpireItemTimeInterval)
	defer timeTicker.Stop()
	for {
		select {
		case <-timeTicker.C:
			for key, item := range mc.values {
				if item.expire != 0 && time.Now().After(item.expireTime) {
					mc.locker.Lock()
					mc.del(key)
					mc.locker.Unlock()
				}
			}
		}
	}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147

4、memCache_test.go

package cache

import (
	"testing"
	"time"
)

func TestCacheDP(t *testing.T) {
	testData := []struct {
		key    string
		val    interface{}
		expire time.Duration
	}{
		{"slsd", 678, time.Second * 10},
		{"dds", 678, time.Second * 11},
		{"slsddsd", 678, time.Second * 12},
		{"dsd", map[string]interface{}{"a": 3, "b": false}, time.Second * 13},
		{"ds", "aadasdasdad", time.Second * 14},
		{"dsdsd", "这里是的的饿的啊得到", time.Second * 15},
	}
	c := NewMemCache()
	c.SetMaxMemory("10MB")
	for _, item := range testData {
		c.Set(item.key, item.val, item.expire)
		val, ok := c.Get(item.key)
		if !ok {
			t.Error("缓存取值失败")
		}
		if item.key != "slsddsd" && val != item.val {
			t.Error("缓存取值数据与预期不一致")
		}
	}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

5、main.go

package main

import (
	"fmt"
	cache_server "test111/cache-server"
	"time"
)

func main() {
	//fmt.Println(dns_reques.DigDomain("127.0.0.1:53", "www.baidu.com"))
	cache := cache_server.NewMemCache()
	cache.SetMaxMemory("200GB")
	cache.Set("aa", 1, 10*time.Second)
	cache.Set("bb", false, 10*time.Second)
	cache.Set("data", map[string]interface{}{"a": 1}, 10*time.Second)
	/*
		cache.Set("int", 1)
		cache.Set("bool", false)
		cache.Set("data", map[string]interface{}{"a": 1})
	*/
	fmt.Println(cache.Get("aa"))
	fmt.Println(cache.Get("bb"))
	fmt.Println(cache.Get("data"))
	cache.Del("int")
	cache.Flush()
	cache.Keys()
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

11、Go 语言中的 goroutine 是什么，它和线程有什么区别？

在 Go 语言中，goroutine 是一种轻量级的并发执行单元，由 Go runtime 管理的用户态线程。Goroutine 可以通过关键字 go 来创建，可以在同一个地址空间中并发地执行多个函数。

与传统的线程相比，goroutine 有以下几个主要区别：

1. 轻量级：goroutine 的栈空间初始较小（通常只有几 KB），随着需要而动态地增长和收缩，这使得创建和销毁 goroutine 的开销较低，可以在同一个程序中创建成千上万个 goroutine，而不会过度消耗系统资源。
2. 协作式调度：在传统的线程模型中，线程的调度由操作系统内核负责，而在 Go 语言中，goroutine 的调度由 Go runtime 的调度器负责。调度器使用协作式调度方式，即每个 goroutine 在执行时需要主动让出 CPU，而不是由操作系统强制切换，这样可以更好地控制调度和减少上下文切换的开销。
3. 共享内存通信：goroutine 之间通过通道（Channel）进行通信，而不是通过共享内存。通道是一种在 goroutine 之间传递数据的机制，可以实现安全的并发通信，避免了传统线程中需要显式加锁的问题，简化了并发编程。
4. 错误处理：在 Go 语言中，错误处理是一种编码约定，而不是使用异常来处理错误。这使得编写更健壮和可靠的代码更加容易，并且可以避免因异常处理引起的性能损失。

综上所述，goroutine 是 Go 语言中一种轻量级、高效的并发执行单元，通过协作式调度、通道通信和错误处理等特性，使得并发编程更加简洁和可靠。与传统的线程模型相比，goroutine 提供了更高的性能和更好的编程体验。

12、Go 语言中的 channel 是什么，它的作用和用法是什么？

在 Go 语言中，channel（通道）是一种用于在 goroutine 之间进行通信和同步的机制。它是一种类型安全的、阻塞式的、并发安全的数据结构，用于在不同 goroutine 之间传递数据。

Channel 的主要作用和用法如下：

1. 数据传递：Channel 可以用于在不同 goroutine 之间传递数据，通过将数据发送到一个 Channel，并从另一个 goroutine 中接收数据，从而实现数据的传递和共享。
2. 同步机制：Channel 可以用于在多个 goroutine 之间进行同步，例如等待一个 goroutine 完成后再继续执行下一步操作，或者在多个 goroutine 之间实现某种顺序执行的逻辑。
3. 阻塞式操作：Channel 的发送和接收操作都是阻塞式的，即在发送和接收操作完成之前，goroutine 会被阻塞，直到有对应的接收或发送操作可以执行。这种阻塞式的特性使得 Channel 可以有效地在多个 goroutine 之间进行数据同步和通信，避免了常见的竞态条件和其他并发问题。

Channel 的用法主要包括以下几个方面：

1. 创建和初始化：通过使用内建函数 make 创建一个 Channel，并指定通道的类型和容量（可选）。例如：ch := make(chan int)。
2. 发送和接收数据：通过使用 <- 运算符进行数据的发送和接收操作。例如：ch <- 42 表示将值 42 发送到通道 ch 中，x := <-ch 表示从通道 ch 中接收一个值并将其赋值给变量 x。
3. 阻塞和非阻塞操作：Channel 的发送和接收操作可以是阻塞的，也可以是非阻塞的。阻塞的发送和接收操作会导致 goroutine 阻塞，直到有对应的接收或发送操作可以执行；而非阻塞的发送和接收操作会立即返回，无论是否有对应的接收或发送操作可以执行。
4. 关闭通道：可以使用内建函数 close 关闭一个通道，表示不再向通道发送数据，但可以继续从通道接收数据。关闭通道后，对通道的发送操作将导致 panic，而对通道的接收操作可以继续接收通道中的已有数据。

总的来说，Channel 是 Go 语言中用于实现 goroutine 之间通信和同步的重要机制，通过阻塞式的操作和类型安全的特性，可以简化并发编程的复杂性，并避免常见的并发问题。

13、Go 语言中的 defer 关键字有什么作用，它的执行顺序是怎样的？

Go 语言中的 defer 关键字用于在函数执行完毕前（或发生 panic 时）延迟执行一些代码，常用于资源释放、错误处理、日志记录等场景。defer 语句会将其后面的函数调用推迟到当前函数执行完毕之后再执行，不论函数是否正常返回或者发生了 panic。

defer 关键字的作用主要包括以下几个方面：

1. 资源释放：在函数执行完毕后，可以使用 defer 关键字释放已经打开的资源，如文件句柄、数据库连接、网络连接等，以避免资源泄漏。
2. 错误处理：可以使用 defer 关键字在函数发生错误时，通过调用一些错误处理函数或者日志记录函数来处理错误，以保证错误信息能够被捕获并处理。
3. 代码清理：可以使用 defer 关键字在函数执行完毕后，清理一些临时变量、缓存数据等，以保持代码的整洁性和可读性。

defer 语句的执行顺序是后进先出（Last In, First Out，LIFO）的顺序，即最后一个 defer 语句会最先执行，而最先声明的 defer 语句会最后执行。例如：

func foo() {
    defer fmt.Println("Third")
    defer fmt.Println("Second")
    defer fmt.Println("First")
    fmt.Println("Actual Execution")
}

1
2
3
4
5
6
7

在上面的例子中，foo 函数执行时，会先打印 “Actual Execution”，然后 “First”、“Second”、“Third” 会按照逆序依次执行，即先打印 “Third”，然后打印 “Second”，最后打印 “First”。

需要注意的是，defer 关键字只会延迟函数调用的执行，而不会延迟函数内部的表达式的计算。例如：

func foo() {
    x := 10
    defer fmt.Println(x) // 打印 10
    x = 20
}

1
2
3
4
5
6

在上面的例子中，foo 函数执行时，虽然 defer 语句在 x 赋值之前声明，但是 defer 语句实际执行时会打印 x 的当前值，即 10，而不是 20。

总的来说，defer 关键字在 Go 语言中用于在函数执行完毕前延迟执行一些代码，可以方便地进行资源释放、错误处理、代码清理等操作，并且遵循后进先出的执行顺序。

14、Go 语言中的接口(interface)和结构体(struct)有什么区别？它们如何使用？

在 Go 语言中，接口（interface）和结构体（struct）是两种不同的概念，用于实现不同的编程模式。

**接口（interface）**是一种抽象的类型，它定义了一组方法的集合。接口不包含实现，只包含方法的签名。任何类型只要实现了接口中定义的所有方法，就可以被认为是实现了该接口。接口通过定义规范来实现多态性，使得可以在不关心具体类型的情况下，对一组类型进行统一的操作。

**结构体（struct）**是一种复合类型，它可以包含不同类型的字段（field），类似于其他语言中的类（class）或对象（object）。结构体用于定义自定义的数据类型，可以包含各种数据，例如基本数据类型（如 int、float、bool 等）和其他结构体等。结构体可以具有方法（method），用于定义结构体自身的行为。

以下是接口和结构体的主要区别：

1. 定义方式： 接口使用 type 关键字定义，后跟接口名和方法签名，例如 type MyInterface interface { ... }；而结构体使用 type 关键字定义，后跟结构体名和字段定义，例如 type MyStruct struct { ... }。
2. 包含内容： 接口只包含方法的签名，不包含实现；而结构体可以包含字段和方法，可以包含具体的实现。
3. 实现方式： 接口是隐式实现的，即只要一个类型实现了接口中定义的所有方法，就可以被认为是实现了该接口；而结构体必须显式声明实现了某个接口，通过在方法中使用接口名作为接收者来实现接口。
4. 使用场景： 接口通常用于定义抽象的行为规范，可以用于实现多态性和解耦；而结构体通常用于定义自定义的数据类型，包含了具体的字段和方法。

使用接口和结构体的场景取决于具体的需求。通常情况下，当需要定义一组行为规范，并且多个类型都需要实现这些规范时，可以使用接口。而当需要定义自定义的数据类型，并且包含了具体的字段和方法时，可以使用结构体。在实际开发中，接口和结构体常常一起使用，结构体实现接口，以实现特定的行为规范。

15、Go 语言中的垃圾回收机制是怎样的，它的优点和缺点是什么？

Go 语言采用了现代的垃圾回收（Garbage Collection，简称 GC）机制，用于自动管理内存的分配和回收。Go 语言的垃圾回收机制有以下特点：

1. 并发标记清除（Concurrent Mark and Sweep）： Go 语言的垃圾回收是并发进行的，不会阻塞程序的执行。垃圾回收器会在后台运行，并在程序运行过程中逐步清理不再使用的内存。
2. 三色标记法（Tricolor Marking）： Go 语言的垃圾回收器使用了三色标记法来标记活跃对象和垃圾对象。通过将对象分为三个不同的颜色（白色、灰色和黑色），垃圾回收器可以在并发的情况下进行标记，并保证只回收不再使用的内存。
3. 分代回收（Generational Collection）： Go 语言的垃圾回收器使用了分代回收的思想，将堆内存分为不同的代，不同代的对象具有不同的生命周期和回收策略。新分配的对象通常被分配在新生代中，而长时间存活的对象则可能被晋升到老年代。

Go 语言的垃圾回收机制有以下优点：

1. 简化内存管理： Go 语言的垃圾回收机制可以自动管理内存的分配和回收，减轻了程序员的内存管理负担，避免了常见的内存错误，如空指针引用、野指针等。
2. 并发执行： Go 语言的垃圾回收机制是并发执行的，不会阻塞程序的执行，保证了程序的响应性和性能。
3. 高效回收： Go 语言的垃圾回收机制通过并发标记清除和分代回收等技术，可以高效地回收不再使用的内存，减少了内存占用和碎片化。
4. 可预测的延迟： Go 语言的垃圾回收机制可以通过调整参数来控制回收的频率和延迟，从而可以在一定程度上控制垃圾回收对程序性能的影响。

Go 语言的垃圾回收机制也存在一些缺点：

1. 内存占用： Go 语言的垃圾回收机制需要额外的内存空间用于管理和维护垃圾回收器的状态，可能会导致一定的内存占用增加。
2. 延迟： 尽管 Go 语言的垃圾回收机

16、Go 语言中的 map 是如何实现的，它的特点和性能如何？

在 Go 语言中，map 是一种内建的数据结构，用于实现键值对的集合。map 的实现使用了哈希表（Hash Table）的数据结构，其中键（Key）通过哈希函数映射到哈希桶（Hash Bucket），值（Value）存储在对应的哈希桶中。

map 的特点和性能如下：

1. 动态扩容： map 在使用过程中可以动态地增加或减少键值对的数量，不需要预先指定容量大小。当键值对的数量超过哈希桶的容量时，map 会自动进行扩容操作，以保证哈希表的负载因子（Load Factor）在合理范围内，从而维持较高的性能。
2. 高效的增删查操作： map 提供了高效的增删查操作，其时间复杂度通常为 O(1)。但在极端情况下，例如哈希冲突较严重时，查找操作的时间复杂度可能会升级到 O(n)。
3. 无序性： map 中的键值对没有固定的顺序，遍历时不能保证键值对的顺序。
4. 支持任意类型的键和值： map 支持任意类型的键和值，可以通过类似于数组的下标语法进行存取操作。
5. 不支持并发访问： map 在并发环境下不是安全的，需要使用互斥锁或并发安全的 sync.Map 替代。

需要注意的是，map 的性能受到哈希函数的质量和哈希冲突的影响。优化哈希函数的选择和键的设计可以对 map 的性能产生重要影响。在性能敏感的场景下，可以考虑使用第三方的高性能哈希表库，例如 github.com/cespare/xxhash 和 github.com/dgryski/go-farm 等。

17、Go 语言中的反射(reflection)是什么，它的作用和用法是什么？

在 Go 语言中，反射（reflection）是一种强大的特性，允许程序在运行时动态地检查和操作变量、类型和函数等程序结构的能力。Go 语言的反射包（reflect）提供了一组函数和类型，用于实现对程序结构的反射操作。

反射的作用和用法如下：

1. 动态类型检查： 反射可以在运行时检查变量的类型和值，包括基本类型、结构体、数组、切片、字典、函数、接口等。
2. 动态创建和修改变量： 反射可以在运行时创建新的变量、修改变量的值和类型。
3. 调用函数： 反射可以在运行时通过函数名调用函数，并传入参数和获取返回值。

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，涵盖了95%以上Go语言开发知识点，真正体系化！

由于文件比较多，这里只是将部分目录截图出来，全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、讲解视频，并且后续会持续更新

如果你需要这些资料，可以戳这里获取

的作用和用法是什么？

在 Go 语言中，反射（reflection）是一种强大的特性，允许程序在运行时动态地检查和操作变量、类型和函数等程序结构的能力。Go 语言的反射包（reflect）提供了一组函数和类型，用于实现对程序结构的反射操作。

反射的作用和用法如下：

1. 动态类型检查： 反射可以在运行时检查变量的类型和值，包括基本类型、结构体、数组、切片、字典、函数、接口等。
2. 动态创建和修改变量： 反射可以在运行时创建新的变量、修改变量的值和类型。
3. 调用函数： 反射可以在运行时通过函数名调用函数，并传入参数和获取返回值。

[外链图片转存中…(img-rzCAbtdS-1715481976403)]
[外链图片转存中…(img-Upvvpkov-1715481976404)]
[外链图片转存中…(img-qFB1z3xc-1715481976404)]

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，涵盖了95%以上Go语言开发知识点，真正体系化！

由于文件比较多，这里只是将部分目录截图出来，全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、讲解视频，并且后续会持续更新

如果你需要这些资料，可以戳这里获取