Program on GzzhM

大文件上传

Thu, 30 Jul 2026 00:00:00 +0000

需求分析

对于一个大文件 >= 50mb 的上传, 走单个文件上传的接口很容易超时

单个请求时长过长，容易出发网关/前端axios 超时
中间失败就要整个文件重传
也可能遇见中间件请求大小限制

业务流程

前端拆分文件
通过 /post-init . 初始化本次文件的基本信息

{
file_name  // 文件名
file_size // 文件大小
totalChunks // 总分片数
// .. 
}

/post-init 为每个分片创建临时目录, 然后将本次的 uploadItem 存放到进程级 map中并且返回upload-id
前端分片带上 upload-id 和 chunk_index 以及本次的数据到 post-chunk 接口
所有数据上传完之后前端调用 post-merge接口进行数据到合并，通过 upload-id 遍历每一个分区

一些问题

数据上传信息记录由进程级 map 进行记录，重启之后会丢失 , 并且不支持跨实例续传
- 业务上是允许的，因为客户环境只有每次升级才会进行重启，升级前后的上传操作从业务上看确实需要客户重新操作一次
- 项目是分环境分数据库部署的，没有多实例要求

优化点

业务没有断点续传。如果失败的话需要整体重传
- 如果上传失败了，我们需要重新传整改文件
- 旧的文件也不会主动清理掉，磁盘上会一直留着，直到运维来清理他
并不能保证拼接后绝对正确。

[webook-tidy] Gin & 基本路由

Fri, 17 Jul 2026 00:00:00 +0000

Gin 入门

Gin-Engine

在 Gin 中, 一个 Web 服务器被抽象成为 Engine

Engine 承担了路由器注册、接入 middleware 的核心职责

func main() {
    server := gin.Default()
}

type Engine struct {
	// ... 
    RouterGroup
	// ...
}

Gin-Context

Gin 封装的上下文, 其中 Request 和 Writer 负责处理请求和返回相应

type Context struct {
    writermem responseWriter
    Request   *http.Request
    Writer    ResponseWriter
    
    Params   Params
    handlers HandlersChain
// ..
}

对于 GET 的参数我们使用 query 进行获取参数

`1`	`code := ctx.Query("code")`

对于 POST 的参数我们使用 Bind 进行获取参数

	type Req struct {
		Code  string `json:"code"`
		Phone string `json:"phone"`
	}
	var req Req
	if err := ctx.Bind(&req); err != nil {

Gin 路由注册

在 Engine 的 RouterGroup 支持注册 Restful 的接口

// ... 
func (group *RouterGroup) POST(relativePath string, handlers ...HandlerFunc) IRoutes {
	return group.handle(http.MethodPost, relativePath, handlers)
}

// GET is a shortcut for router.Handle("GET", path, handlers).
func (group *RouterGroup) GET(relativePath string, handlers ...HandlerFunc) IRoutes {
	return group.handle(http.MethodGet, relativePath, handlers)
}

// DELETE is a shortcut for router.Handle("DELETE", path, handlers).
func (group *RouterGroup) DELETE(relativePath string, handlers ...HandlerFunc) IRoutes {
	return group.handle(http.MethodDelete, relativePath, handlers)
}
// ...

基本路由

跨域请求

前端端口是 localhost:3000 请求到了后端 localhost:8080

对于域名和端口任意一个不同都是跨域请求

跨域请求问题是浏览器那边进行控制的

每次浏览器请求前，会提前发送一个 Option 的方法访问 allow-origins,allow-headers,allow-method

如果不在允许范围内就会失败

中间件

对于请求发送到实际业务逻辑。前后插入的额外处理即是 middleware

也就是 AOP编程。

最常见的 AOP 就是

beforeHook()
do()
afterHook()

限流start --> 熔断start --> handler --> 熔断end --> 限流end

Gin 插件支持使用 Use 进行中间件的注册

func (group *RouterGroup) Use(middleware ...HandlerFunc) IRoutes {
group.Handlers = append(group.Handlers, middleware...)
return group.returnObj()
}

面试

什么是 Gin 的 middleware ？能用来解决什么问题？
什么是跨域问题，怎么解决？
跨域问题需要设置哪些头部？

最后

设计并实现一个 Gin插件库

使用 middleware 机制实现 Gin 插件库支持

Web 治理 ：熔断限流降级
可观测性 : 包括日志、metrics、tracing
身份认证与鉴权 :

[webook-tidy] Gorm & 用户基本功能 & docker

Fri, 17 Jul 2026 00:00:00 +0000

Gorm

Orm (Object Relational Mapping) : 对象关系映射。 Orm框架提供不需要关注实体对象与数据库之间的操作关系

Docker Compose

docker compose 启动 mysql8

基本语法 :

services : 服务列表
image : 镜像
command : 启动命令 (启动命令行参数)
volumes : 挂载文件
ports : 端口映射关系

version: '3.7'
services:
  mysql8:
    image: mysql:8.0.29
    command: --default-authentication-plugin=mysql_native_password
    restart: always
    environment:
      MYSQL_ROOT_PASSWORD: root
    volumes:
      - ./script/mysql/:/docker-entrypoint-initdb.d/
    ports:
      - "13316:3306"

基础命令 :

dokcer compose up : 初始化 dokcer-compose 并且懂 docker compose down : 删除 docker-compose 里面创建的容器

项目结构

Service : 代表领域服务完整的业务的处理过程

Repository : 按照 DDD 的说法是代表领域对象的存储，可以认为是存储数据的抽象

Dao : 代表数据库操作

domain : 代表领域对象

├── domain
│   ├── user.go
├── repository
│   ├── cache

│   ├── dao

│   └── user.go
├── service

这里简单提一下 :

我们公司项目的调用逻辑是 :

每一层都有自己相同的 user , 从这里看

htv2-db 操作代表 dao
exgv2 层代表 domain (和 db 弱关联，但是算是底层数据)
cefiacc 即是 Repository
ec代表 service 封装给其他组进行调用

`1`	`ec --> cefiacc --> exgv2 --> htv2(db)`

一些疑问

为什么有了 repository 之后还要有 dao ?
- repository 是一个整体抽象，本质上可以考虑用 ES或者是Mysql或者是 mongoDB 并不代表数据库

HTTP

无状态协议 HTTP

HTTP 是无状态协议，对于连续发送的两次请求, HTTP 并不知道两次都是同一个人发的

只能引入 cookie 和 session 进行记录

浏览器存储一些数据到本地，这些数据就是 Cookie

因为 Cokkie 是放在浏览器本地的，所以很不安全

一些关键配置 :

Domain : cookie 可以用在什么域名下
Path : cookie 可以用在什么路径下
Max-age 和 Expires : 过期时间
Secure : 只用于 HTTPS 协议

func SetCookie(w http.ResponseWriter, r *http.Request) {

 cookie := http.Cookie{
  Name:     "access_token", 
  MaxAge:   3600,       
  Path:     "/",        
  HttpOnly: true,       
  Secure:   true,     
 }

 // send cookie via header
 http.SetCookie(w, &cookie)
 fmt.Fprintln(w, "Cookie has been set!")
}

Session

由于 Cookie 本身不安全的特性，所以大部分我们不把一些关键信息放在 Cookie

关键数据我们希望放在后端，这个存储的东西就是 session

	sess := sessions.Default(ctx)
	sess.Set("userId", user.Id)
	sess.Options(sessions.Options{
		MaxAge: 20,
	})
	sess.Save()

个人理解 :

session也离不开本地化存储，大部分都是放在 cookie中如果禁用了cookie也会考虑放在header或者是query中
使用session无非是把敏感信息的相关校验放在了后端

面试

什么是 cookie 什么是 session ?
cookie 和 Session 比起来有什么缺点
Session ID 可以放在哪里？
用户密码加密算法选取有什么注意事项
怎么做登陆校验

后续

增强扩展 GORM 功能

为 GORM 提供可观测性的插件实现
为 GORM 提供读写分离插件
为 GORM 提供 BeforeFind 功能
为 GORM 提供辅助方法

[webook-tidy] Session & JWT & Security

Fri, 17 Jul 2026 00:00:00 +0000

场景问题

刷新登陆状态

对于一个设置了 10分钟过期时间的 session，我们应该如何采用刷新策略才能够保证用户在用着用着就要重新登陆

用户每次访问，我们都刷新
- 性能差，对 Redis 之类的影响很大。小公司看不出来，但是如果是 10w or 100w用户级别
快要过期了我在刷新，例如 10分钟过期，用户9分钟过来访问的时候刷新
- 如果用户第9分钟没有过来那就寄了

因此只能考虑使用 固定时间间隔刷新,比如每分钟内的第一次访问我们都刷新

即

在sesssion中维护一个 updateAt 的参数
然后在 middleware 中进行更新

JWT

JWT (Json WEB Token) : 很常见的一种机制，主要用于身份认证

基本原理就是通过加密生成一个 token ,每次访问都带上这个token

组成部分 :

Header : JWT 的元数据
Payload : 数据内容
Signature : 签名

基本流程如下 :

使用 NewWithClaims 设定指定的算法
并且传入对应的 userCliams

func (j *jwtHandler) setJWTToken(ctx *gin.Context, uid int64) error {
    userClaims := UserClaims{
    RegisteredClaims: jwt.RegisteredClaims{
    ExpiresAt: jwt.NewNumericDate(time.Now().Add(time.Minute * 30)),
    },
    UserId:     uid,
    UserAgents: ctx.Request.UserAgent(),
    }
    
    token := jwt.NewWithClaims(jwt.SigningMethodHS256, userClaims)
    tokenStr, err := token.SignedString([]byte("secret"))
	
	ctx.Header("x-jwt-token", tokenStr)
//. ..
}

校验方通过同样的 sign-method 和 secret 校验是否正确

JWT 的优缺点

和 Session 比起来优点 :

不依赖第三方存储
适合用于分布式环境
提高性能

缺点 :

对加密依赖非常大
最好不要在 JWT 中存储敏感信息

保护系统

如果有一个人，使用脚本进行大量的发送注册、登陆请求，系统负载会提高所以这时候需要考虑保护系统

最简单的一个办法就是 限流

限流

如何在登陆之前确定限流

我应该怎么认定是哪个用户发送了什么请求？
我应该怎么确定我限流的阈值时多少？

限流对象

IP 是最容易获取的限流方式之一

其中更好的选择还有 MAC 地址 以及 CPU序列号 但是在 web端很难获取

APP端端话可以考虑设备序列号

不过 IP 并不能实际意义上代表一个人，因为两个人可以共用一个 ip 但是这已经是较好的一个选择了

限流阈值

限流阈值时通过 压测 得到的。例如 压测 了整个系统，发现最多只能撑住每秒 1000个请求，那么阈值就是 1000

安全

不管是 JWT 还是 Session 一旦被攻击者拿到关键的 JWT 或 SSid 攻击者就会假冒你

HTTPS 可以有效的阻止攻击者拿到你的 JWT 或者是 ssid

但是如果你电脑中了病毒，那 HTTPS 也无能为力

最好的解决办法是做一个二次校验，即增加 发邮件, 发短信 的形式进行控制

或者是增加一些额信息例如 HTTP 的User-Agent头部，或者是手机硬件信息

面试

刷新 Session 过期时间的几种可行的办法
增强登陆的安全性
- 怎么保护 session id ? 主要还是开启 HTTPS 协议，把 cookie 的 Secure 和 HttpOnly 设置为 true
- 怎么做到在 Session id 或者是 JWT token 泄漏之后保护住用户？要在登陆的时候记录一下登陆的附加信息，例如 user-Agent 在登陆校验的时候统一校验
如何保护 Web 服务？针对 IP 限流、整个集群限

后续

支持 Gin 的限流插件 :

单机限流 :

令牌桶限流
漏桶限流
滑动窗口限流
固定窗口算法

分布式限流 :

基于 Redis 限流
给予 Redis 的 IP 限流

[webook-tidy] Golang 基础语法

Tue, 14 Jul 2026 00:00:00 +0000

函数式编程

Golang 支持定义方法作为变量即 myFunc = func(){}, myFunc() 的形式

同样方法也可以作为返回值

func Say() func(name string) string {
    return func(name string)string {
        return "hello," + name
    }
}

闭包

closure ：方法+它绑定的上下文

组成如下 :

方法
运行时上下文 : 即 name 变量

func Closure(name string) func() string {
	return func() string {
		return "hello " + name
	}
}

闭包如果使用不当会造成内存泄漏, 因为外层 Func 的name变量被直接使用传递出去了。如果一个对象被闭包引用，他是不会被垃圾回收的

不定参数

Golang 支持不定参数传递即,使用...进行，不定参数可以当作切片进行使用

1
2
3

func hanlder(name string ,alias ...string) {
    println(alias[0])
}

其中 Option模式 大量应用了不定参数

Defer

Golang 允许你从方法返回前一刻执行一段逻辑

Defer 的运行逻辑类似于栈即 后进先出

func Defer() {
    defer func() {
        println("第一个defer")
    }()
    defer func() {
        println("第二个defer")
    }()
}

输出如下

1
2

第二个 defer 
第一个 defer

问题

defer 有一个 catch 的机制，主要考 for 中的内容，如果是通过闭包传递或者是通过拷贝变量进行copy 他会catch到当前值而不是最后值

func DeferClosureLoopV1() {
	println()
	for i := 0; i < 10; i++ {
		defer func() {
			print(i)
			print(" ")
		}()
	}
}

// 预计是 10,10,10,10 拿到的是最后一个

func DeferClosureLoopV2() {
	println()
	for i := 0; i < 10; i++ {
		defer func(val int) {
			print(val)
			print(" ")
		}(i)
	}
}

// 预计是 1,2,3... 10
// 实际是 9,8 ,7 ,6 ,5,4,3,2,1

func DeferClosureLoopV3() {
	println()
	for i := 0; i < 10; i++ {
		j := i
		defer func() {
			print(j)
			print(" ")
		}()
	}
}

// 预计是 10，10，10 ？
// 实际上是 9,8,7,6,5,4,3,2,1

基本数据结构

切片

语法 []type ,数组的话是 [int]type

初始化方式 :

`1`	`s1 := []int{1,2,3} //创建了一个 3个亚孙的切片`

1
2

s1 := make([]int,3,4) // 初始化 3个元素，这时候访问 s1[0] = 0 
s2 := make([]int,4) // 创建一个 4个元素的切片， 这时候访问 s1[0] panic

推荐使用 s1 := make([]type,0,cap) 的方式进行创建

子切片

切片可以通过 [start:end] 的形式获取子切片，其中范围是 左闭右开 的

内存共享问题 :

在没有发生扩容的情况下，子切片和切片是共享一个数组的
即如果子切改变了一个数，那么原本的切片也会改变

map

初始化方法

1
2
3

m1 := map[string]string {
    "key": "value"
}

对于 for k,v := range map 来说，每次结果都是不一样的

接口 & 结构体

接口是 一组行为的抽象

type name interface{}

结构体

1
2
3

type a struct {

}

衍生类型

如果我们想使用第三方库，但是又没办法修改代码，又想扩展这个库的结构体，我们会使用到这个

衍生类型只共享字段并不共享实现的方法

即 typeB 拥有的方法 , typeA并不能够调用

`1`	`type typeA typeB`

类型别名

不同于衍生类型，可以说是一个别名类型本质上是没有变的

`1`	`type typeA = typeB`

泛型

对于下面这个例子，其中 T 就是泛型可以是任意类型

1
2

type List[T any] interface {
}

泛型语法

对于 Number 来说就是一个泛型约束

func Sum[T Number](vals ...T) T {
	var res T
	for _, val := range vals {
		res += val
	}
	return res
}

type Number interface {
	int | int64
}

面试重点

[✅] 什么是闭包？闭包有什么缺陷
[✅] 什么情况下会栈溢出
- 自己循环调用自己
[✅] 什么是不定参数？调用方法的时候不定参数可以传入 0个值吗？方法内部怎么使用不定参数？
- 函数参数以 … 方式进行传递就是不定参数
- 0值预计是个nil ,会自动初始化
- 和切片一样使用即可

什么是 defer ? 能解释一下 defer 的运行机制吗？
- Go 语言提供的一种延迟调用机制。它通常用于处理成对出现的操作，比如打开/关闭连接、加锁/释放锁。无论函数是正常执行结束还是发生了 panic，defer 注册的函数都会被确保执行，这能有效防止资源泄漏。

[已删除] 一个方法内部 defer 能不能超过 8个？
[待定] defer 内部能不能修改返回值? 怎么改？

数组和切片有什么区别？
- 类型与长度限制：
  - 数组是定长的，长度是其类型的一部分（[3]int 和 [4]int 是不同类型）
  - 切片是动态的，长度不属于类型的一部分（类型统称为 []T）
- 底层数据结构：
  - 数组是一段连续的内存空间，直接存储了所有的元素。
  - 切片本质上是一个引用类型（描述符），它的底层结构包含三个字段：一个指向底层数组的指针（Pointer）、切片的长度（Len）和容量（Cap）。
- 函数传参的性能开销:
  - Go 语言是值传递。如果把数组作为参数传递，会触发整个数组的深拷贝，对于大数组来说内存和 CPU 开销很大。
  - 传递切片时，只会拷贝切片头部的三个字段（指针、长度、容量），开销非常小。并且在函数内部修改切片的元素，会直接影响到底层的真实数组。
- 扩容机制：
  - 数组创建后不可扩容。切片支持使用 append 函数追加元素，当容量不足时，Go 运行时会自动分配一块更大的新内存，将旧数组的数据拷贝过去，并让切片的指针指向新数组。
切片怎么扩容？
- 在 256 以下进行双倍扩容
- 在 256 以上进行 (原容量 + 3 * 256) / 4 即 1.25倍的扩容

最后

了解函数式编程在在业务中的使用
了解内存泄漏，业务上的内存泄漏，排查方法，解决办法
了解垃圾回收的机制
了解 Option 模式
slice 的底层实现
map 的底层实现
defer 的实现原理和机制
闭包

写出一个泛型工具支持

切片的辅助方法 : 添加、删除、查找、求并集、交集、map reduce API
map 辅助方法
扩展 map 实现 : 接受任意类型的 HashMap, TreeMap, LinkedMap
List 实现 : LinkedList, ArraryList 和 SkipList
Set: 包括 HashSet 和 TreeSet, SortedSet
队列: 普通队列,优先队列
bean 操作操作辅助类 : 高性能高扩展的 bean copier机制
并发扩展工具 : 包括并发队列,并发阻塞队列,并发阻塞优先队列
协程池

闭包

Tue, 14 Jul 2026 00:00:00 +0000

基础概念

闭包 : 引用了自由变量的函数，即函数 + 引用环境

例子 :

func intSeq() func() int {

	i := 0
	return func() int {
		i++
		return i
	}
}

func main() {
	nextInt := intSeq()

	fmt.Println(nextInt())
	fmt.Println(nextInt())

	nextInt2 := intSeq()
	fmt.Println(nextInt2())
}

输出如下

1
2
3

1
2
1

我们发现，对于程序内定义的变量 i, 他被外部函数引用了。并且对于 nextInt 和 nextIn2 是两个不同的环境，他们拥有不同的 i

怎么理解这个过程 :

函数的局部变量是分配在栈上面的
但是闭包上的变量会逃逸到堆上

原理如下 :

对于一个以函数返回到形式的 Func，我们称为 FuncValue 其分配是在堆上
当我们通过其他变量进行接收的时候，会先去堆上找到该 FuncValue 的地址，由于闭包 Capture 了局部变量所以会在堆上额外分配一块地址

垃圾回收

以下是一些概念

逃逸 :

变量生命周期超出声明它的函数栈帧，编译器不得不把它放到堆上

GC回收 :

堆上对象在没人引用后，由 GC 回收；程序结束进程退出时也会一起释放

对于下面这种形式，因为 nextInt 已经输出完成了，虽然main函数没有退出，但是已经没有引用了，虽然产生了逃逸但是同样会被回收

func main(){
	nextInt := intSeq()
	fmt.Println(nextInt())
	fmt.Println(nextInt())

	nextInt2 := intSeq()
	fmt.Println(nextInt2())

	for {} // 卡住不让 main 退出
}

只有在循环内一直被引用，以及包级变量引用的时候才不会被回收。

1
2
3

for {
    _ = nextInt() // 循环里还在用 → 仍存活
}

var keep func() int // 包级变量

nextInt := intSeq()
fmt.Println(nextInt())
keep = nextInt       // 挂到全局 → 一直可达

for {}

包级变量理论上来说是和当前进程一起存活的。但是如果在引用期间，主动进行解引用同样也会被回收

var keep func() int

func main() {
	keep = intSeq()
	fmt.Println(keep())

	keep = nil        // 断掉引用
	runtime.GC()      // 演示用；生产里不必手动调

	for {}            // 之后闭包就可能已被回收
}

应用场景

隔离数据

如果不想让其他人访问该数据,例如生成一个斐波那契数列，但是不想让其他人更改其 value

func main() {
  gen := makeFibGen()
  for i := 0; i < 10; i++ {
    fmt.Println(gen())
  }
}

func makeFibGen() func() int {
  f1 := 0
  f2 := 1
  return func() int {
    f2, f1 = (f1 + f2), f2
    return f1
  }
}

封装函数和创建中间件

Go 的函数是一等公民，如果我们想要实现一个，接口在运行前后的请求耗时中间件的话

我们需要使用到闭包进行处理，因为 handleFunc 需要接受一个 FuncValue

func main() {
  http.HandleFunc("/hello", timed(hello))
  http.ListenAndServe(":3000", nil)
}

func timed(f func(http.ResponseWriter, *http.Request)) func(http.ResponseWriter, *http.Request) {
  return func(w http.ResponseWriter, r *http.Request) {
    start := time.Now()
    f(w, r)
    end := time.Now()
    fmt.Println("The request took", end.Sub(start))
  }
}

func hello(w http.ResponseWriter, r *http.Request) {
  fmt.Fprintln(w, "<h1>Hello!</h1>")
}

不过这并不会产生 OOM ，因为端口一直监听，但是堆上的逃逸只产生了一次

同理可以分析下面这两个情况，对于第一个场景，我们只产生了一个新的环境，而对于第二个场景我们每次都产生了新环境

nextInt := intSeq()
for {
	nextInt()
} 

for {
	nextInt := intSeq() // 每次新环境
	_ = nextInt
	// 若再塞进全局 cache / 切片 → 环境越堆越多 → 可能 OOM
}

sort 包

people := []string{"Alice", "Bob", "Dave"}
sort.Slice(people, func(i, j int) bool {
    return len(people[i]) < len(people[j])
} )
fmt.Println(people)

面试

什么是闭包？闭包有什么缺陷？

闭包的本质是引用了自由变量的函数，即函数+引用环境是闭包

闭包有什么缺陷 : 在我们反复使用新环境引用闭包变量的时候，会产生大量的内存逃逸从而使得CPU上涨和OOM

闭包的优点 :

可以规避一些函数定义的接收器不允许传入的参数, 例如中间件只允许传入 Write 和Request .但是我们如果想要引用其他 Param，那么就需要定义一个 FuncValue的返回， func(otherParm) FuncValue
做数据的隔离防止一些不想让其他人访问该数据。例如 Sort

🛠️ 改进项与“满分回答”建议 (Improvements)
为了在面试中拿到 9-10 分，你可以将回答按照“定义 -> 常见应用(优点) -> 底层代价(缺陷) -> 语言特有陷阱”的逻辑来组织。

你可以参考以下改进后的表述：

1. 什么是闭包？（保持你的精准定义）
闭包的本质是函数体加上它所引用的外部环境（自由变量）的结合体。在 Go 中，当一个匿名函数引用了它外部作用域的变量时，就形成了闭包。

2. 闭包的优点（优化你的实战案例）
函数签名适配与状态保持（柯里化）：在 Web 开发中，标准库的 http.HandlerFunc 只接受 ResponseWriter 和 Request。我们可以利用闭包将外部配置（如 DB 连接池、日志记录器）封装进去，返回一个符合签名的函数。

数据封装与隔离：闭包可以用来隐藏状态，实现类似面向对象中“私有变量”的效果。比如实现一个计数器生成器，每次调用返回的函数都能修改外层的局部变量，而这个变量对全局是不可见的。同时，在使用 sort.Slice 时，闭包能直接捕获并操作外部的切片，免去了繁琐的参数传递。

3. 闭包的缺陷与坑（重点重构）
性能代价（内存逃逸与 GC 压力）：
闭包引用的外部变量，其生命周期会超越原本的函数调用栈。因此，Go 编译器会通过逃逸分析将这些变量分配到堆上，而不是栈上。如果高频创建闭包，会导致堆内存分配增多，加重 GC（垃圾回收）的负担，进而可能引发 CPU 占用率上升。

经典陷阱：循环变量捕获问题：
(重点展示你的技术深度和对 Go 版本更迭的了解)
在 Go 1.22 之前，for 循环中的迭代变量是共享同一个内存地址的。如果在循环里启动 Goroutine 并使用闭包引用该变量，往往会导致所有 Goroutine 最终打印的都是最后一个元素的值。
补充加分项：不过，自 Go 1.22 起，官方已经修改了 for 循环的语义，每次迭代都会创建一个新的变量，从而从根本上解决了这个经典的闭包陷阱。

面试官点评：如果你能在面试中流利地按照上述逻辑回答，不仅展现了你扎实的理论功底和实战经验，还顺带秀了一把底层（逃逸分析、GC）原理，以及对 Go 语言最新版本（1.22+）演进的关注。这绝对是一个一锤定音的高分回答！

其他

多协程快排的实现闭包

Program on GzzhM

大文件上传

需求分析

业务流程

一些问题

优化点

[webook-tidy] Gin & 基本路由

Gin 入门

Gin-Engine

Gin-Context

Gin 路由注册

基本路由

跨域请求

中间件

面试

最后

[webook-tidy] Gorm & 用户基本功能 & docker

Gorm

Docker Compose

项目结构

一些疑问

HTTP

无状态协议 HTTP

Cookie

Session

面试

后续

[webook-tidy] Session & JWT & Security

场景问题

刷新登陆状态

JWT

JWT 的优缺点

保护系统

限流

限流对象

限流阈值

安全

面试

后续

[webook-tidy] Golang 基础语法

函数式编程

闭包

不定参数

Defer

问题

基本数据结构

切片

子切片

map

接口 & 结构体

衍生类型

类型别名

泛型

面试重点

最后

闭包

基础概念

垃圾回收

应用场景

隔离数据

封装函数 和 创建中间件

sort 包

面试

什么是闭包 ？ 闭包有什么缺陷？

其他

封装函数和创建中间件

什么是闭包？闭包有什么缺陷？