【Golang那些事】go1.22和1.23 更新重点及测评

好久没有写文章了，攒了一年的Golang版本特性的技术点以及踩过的坑，那就在新年第一篇的文章中做一个总结吧：

一、关于迭代器

(一)迭代器去掉了共享共享内存

一个经典的面试题

说到Golang经典的面试题，大家可能都刷到过很多，笔者这里也曾经收藏过几个比较有意思的面试题，下面这个就是其中之一：

package mainimport "fmt"func main() {slice := []int{0, 1, 2, 3}mymap := make(map[int]*int)for index, value := range slice {mymap[index] = &value}for key, value := range mymap {fmt.Printf("map[%v]: %v\n", key, *value)}
}

上面的代码输出结果是什么？

看起来似乎比较简单：

其实，在20230915时间之前，输出的结果为：

map[3]=3
map[0]=3
map[1]=3
map[2]=3

因为for range创建了迭代对象每个元素的副本，而不是直接返回每个元素的引用，如果使用该值变量的地址作为指向每个元素的指针，就会导致错误，在迭代时，返回的变量是同一个迭代过程中根据切片依次赋值的变量，所以最终map中存储的地址都是同一个变量的地址，而其值即为最后一次迭代中赋的值

是不是比较容易出错

这里也确实让广大Golang开发者吐槽的地方，所以在golang1.22中，golang官方终于对这里出手了

请在此添加图片描述

可以看到这里官方自己也定义为最常见的Go错误之一

官方吐槽自己也是可以！

参考资料：

https://antonz.org/go-1-22/

https://tip.golang.org/doc/go1.22

(二)迭代器的"For" loops may 支持整数

一个更方便写测试用例的小功能

for i := range 10 {fmt.Print(10 - i, " ")
}
fmt.Println()
fmt.Println("go1.22 has lift-off!")

这个在1.22中进行了添加

参考资料：

https://antonz.org/go-1-22/

https://blog.csdn.net/Wksycxy/article/details/136770738

https://tip.golang.org/ref/spec#For_range

(三)迭代器与range的结合

一致的迭代器形式

历史背景：

Russ发现Go标准库中有很多库（如上截图）中都有迭代器的实现，但形式不统一，没有标准的“实现路径”，各自为战。这与Go面向工程的目标有悖，现状阻碍了大型Go代码库中的代码迁移。因此，Go团队希望给大家带来一致的迭代器形式，具体来说就是允许for range支持对一定类型函数值(function value)进行迭代，即range over func。

2024年2月，iterator以试验特性被Go 1.22版本引入，通过GOEXPERIMENT=rangefunc可以开启range-over-func特性以及使用iter包。
在golang.org/x/exp下面，Go团队还提议维护一个xiter包，这个包内提供了用于组合iterator的基本适配器(adapter)，不过目前该xiter包依旧处于proposal状态，尚未落地。
2024年8月，iterator将伴随Go 1.23版本正式落地，现在我们可以通过Go playground在线体验iterator，当然你也可以安装Go tip版本或Go 1.23的rc版在本地体验。

终于在1.23落地了

请在此添加图片描述

这意味着很多用迭代器的地方可以通过range for的形式显示调用

var m sync.Mapm.Store("alice", 11)
m.Store("bob", 12)
m.Store("cindy", 13)// 1.22
m.Range(func(key, value any) bool {fmt.Println(key, value)return true
})// 1.23
for key, val := range m.Range {fmt.Println(key, val)
}

可以看到后面这种方式更加的简洁

还有一些比较简洁的操作可以参考：

https://antonz.org/go-1-23/#timer-changes

二、关于切片

(一)增加了连接函数，顺道在切片修改的函数做了健壮性处理

用好slices是golang开发的一个重要点

关于新的连接函数

s1 := []int{1, 2}
s2 := []int{3, 4}
s3 := []int{5, 6}
res := slices.Concat(s1, s2, s3)
fmt.Println(res)

关于delete函数

请在此添加图片描述

关于Compact和Replace函数

请在此添加图片描述

关于insert函数，更加的强Schema

如果参数 i 超出范围，Insert函数会报panic。

请在此添加图片描述

参考资料：

https://antonz.org/go-1-22/

(二)关于slices.Repeat

用法比较简单：

s := []int{1, 2}
r := slices.Repeat(s, 3)
fmt.Println(r)

输出为：

1 2 1 2 1 2

三、关于随机数

(一)新的随机库

1.22版本提供了一个新的库math/rand/v2

math/rand/v2 并不是 math/rand的升级

这里可以说一说随机数的历史渊源

其实大家对math/rand不是那么满意。
2017年，#20661 中提到math/rand.Read和crypto/rand.Read相近，导致本来应该使用crypto/rand.Read的地方使用了math/rand.Read，导致了安全问题
2017年，#21835 中 Rob Pike 提议在Go 2中使用PCG Source。
2018年，#26263 中 Josh Bleecher Snyder 提议对math/rand进行彻底的重构。
2023年6月， Russ Cox基于先前的对math/rand的吐槽，以及和Rob Pike的讨论，建立了一个讨论(#60751),准备新建一个包math/rand/v2,重新设计和实现一个新的伪随机数的库讨论也很热烈，最后实现了一个提案#61716，这个提案最直接的动机是清理 math/rand 并解决其中许多悬而未决的问题，特别是使用过时生成器、缓慢的算法，以及与 crypto/rand.Read 的不幸冲突。
由于go module的支持版本v2、v3、…, Go 1.22中将会有一个新的包math/rand/v2，这个包将会是一个新的包，而不是math/rand的升级版本。这个包的目标是提供一个更好的伪随机数生成器，它的 API 也更加简单易用，同时一些检查工具也能支持这个包，不会报错。
看样子，math/rand/v2将会是第一个在标准库中建立v2版本的包，如果大家能够接受，将来会有更多的包加入进来，比如sync/v2、encoding/json/v2等等。

信息来源：https://colobu.com/2023/12/24/new-math-rand-in-Go/

可以看到当一个库的问题足够多的时候，总会有优秀的工程师站出来，进行一波大的重构，解决历史问题，这个也适用于官方代码

这里一个简单的结论，关于随技术

1.考虑到安全避免被人预测的场景下，要使用crypto/rand 包。

2.其他的情况一般来说使用ath/rand/v2就够了

参考资料：

https://antonz.org/go-1-22/

https://colobu.com/2023/12/24/new-math-rand-in-Go/

四、关于HTTP库

(一)增加不同方法的Handle调用及URL模糊匹配能力

如果使用Gin等框架的话，其实这个能力已经有了，现在Go1.22版本也提供

官方表示，我也可以主动提供一些框架的能力，如果大家有想写Web框架的话会更友好

###1.下面这里如果填写了POST，则使用专门handler来处理

mux.HandleFunc("POST /items/create", func(w http.ResponseWriter, r *http.Request) {fmt.Fprint(w, "POST item created")
})mux.HandleFunc("/items/create", func(w http.ResponseWriter, r *http.Request) {fmt.Fprint(w, "item created")
}){// uses POST routeresp, _ := http.Post(server.URL+"/items/create", "text/plain", nil)body, _ := io.ReadAll(resp.Body)fmt.Println("POST /items/create:", string(body))resp.Body.Close()
}{// uses generic routeresp, _ := http.Get(server.URL+"/items/create")body, _ := io.ReadAll(resp.Body)fmt.Println("GET /items/create:", string(body))resp.Body.Close()
}

输出的结果为：

POST /items/create: POST item created
GET /items/create: item created

###2.下面这里可以使用像：/items/{id}通配符的形式获取参数

mux.HandleFunc("/items/{id}", func(w http.ResponseWriter, r *http.Request) {id := r.PathValue("id")fmt.Fprintf(w, "Item ID = %s", id)
})req, _ := http.NewRequest("GET", server.URL+"/items/12345", nil)
resp, _ := http.DefaultClient.Do(req)
body, _ := io.ReadAll(resp.Body)
fmt.Println("GET /items/12345:", string(body))
resp.Body.Close()

以 …结尾的通配符（如 /files/{path…}）必须出现在模式的末尾，也可以获取

mux.HandleFunc("/files/{path...}", func(w http.ResponseWriter, r *http.Request) {path := r.PathValue("path")fmt.Fprintf(w, "File path = %s", path)
})req, _ := http.NewRequest("GET", server.URL+"/files/a/b/c", nil)
resp, _ := http.DefaultClient.Do(req)
body, _ := io.ReadAll(resp.Body)
fmt.Println("GET /files/a/b/c:", string(body))
resp.Body.Close()

以 / 结尾的模式会一如既往地匹配所有将其作为前缀的路径。要匹配包括尾部斜杠的确切模式，请以 { $KaTeX parse error: Expected 'EOF', got '}' at position 1: }̲ 结尾，如 /exact/ma\dots$ }：

mux.HandleFunc("/exact/match/{$}", func(w http.ResponseWriter, r *http.Request) {fmt.Fprint(w, "exact match")
})mux.HandleFunc("/exact/match/", func(w http.ResponseWriter, r *http.Request) {fmt.Fprint(w, "prefix match")
}){// exact matchreq, _ := http.NewRequest("GET", server.URL+"/exact/match/", nil)resp, _ := http.DefaultClient.Do(req)body, _ := io.ReadAll(resp.Body)fmt.Println("GET /exact/match/:", string(body))resp.Body.Close()
}{// prefix matchreq, _ := http.NewRequest("GET", server.URL+"/exact/match/123", nil)resp, _ := http.DefaultClient.Do(req)body, _ := io.ReadAll(resp.Body)fmt.Println("GET /exact/match/123:", string(body))resp.Body.Close()
}

这里有个细节：

**如果两个模式在匹配的请求中重叠，则更具体的模式优先。**如果两者都不更具体，则模式会发生冲突。此规则概括了原始优先规则，并维护了模式的注册顺序无关紧要的属性。

###3.NewRequestWithContext

新的 NewRequestWithContext 方法创建具有上下文的传入请求。

(二)增加Cookies的方法

如果使用Gin等框架的话，其实这个能力已经有了，现在Go1.23版本也提供

ParseCookie 函数

解析 Cookie 标头值并返回在其中设置的所有 Cookie。由于相同的 Cookie 名称可以多次出现，因此返回的 Value 可以包含给定键的多个值。

line := "session_id=abc123; dnt=1; lang=en; lang=de"
cookies, err := http.ParseCookie(line)
if err != nil {panic(err)
}
for _, cookie := range cookies {fmt.Printf("%s: %s\n", cookie.Name, cookie.Value)
}

ParseSetCookie 函数

解析 Set-Cookie 标头值并返回 Cookie

line := "session_id=abc123; SameSite=None; Secure; Partitioned; Path=/; Domain=.example.com"
cookie, err := http.ParseSetCookie(line)
if err != nil {panic(err)
}
fmt.Println("Name:", cookie.Name)
fmt.Println("Value:", cookie.Value)
fmt.Println("Path:", cookie.Path)
fmt.Println("Domain:", cookie.Domain)
fmt.Println("Secure:", cookie.Secure)
fmt.Println("Partitioned:", cookie.Partitioned)

Request.CookiesNamed函数

检索与给定名称匹配的所有 Cookie

func handler(w http.ResponseWriter, r *http.Request) {cookies := r.CookiesNamed("session")if len(cookies) > 0 {fmt.Fprintf(w, "session cookie = %s", cookies[0].Value)} else {fmt.Fprint(w, "session cookie not found")}
}func main() {req := httptest.NewRequest("GET", "/", nil)req.AddCookie(&http.Cookie{Name: "session", Value: "abc123"})w := httptest.NewRecorder()handler(w, req)resp := w.Result()body, _ := io.ReadAll(resp.Body)fmt.Println(string(body))
}

五、关于计时器

(一)新的资源优化

1.23版本对计时器的资源使用做了优化

关于以下代码

// go 1.22
type token struct{}func consumer(ctx context.Context, in <-chan token) {for {select {case <-in:// do stuffcase <-time.After(time.Hour):// log warningcase <-ctx.Done():return}}
}

会事实上导致广义上的内存泄漏，即虽然有指针指向，但其实应用不在使用了

我们可以做个实验：

编写 100K 通道发送后的内存使用情况：

// go 1.22
func main() {ctx, cancel := context.WithCancel(context.Background())defer cancel()tokens := make(chan token)go consumer(ctx, tokens)memBefore := getAlloc()for range 100000 {tokens <- token{}}memAfter := getAlloc()memUsed := memAfter - memBeforefmt.Printf("Memory used: %d KB\n", memUsed/1024)
}

输出结果为：

Memory used: 24325 KB

这是因为，time.After() 一旦调用了，该计时器在过期之前不会释放，所以这里的内存都积压了

而在 Go 1.23 中，不再被程序引用的 Timer和 Ticker立即符合垃圾回收的条件，即使它们的 Stop 方法尚未被调用。所以不会存在内存积压问题

(二)关于reset的坑

看下面这段代码：

// go 1.22
func main() {const timeout = 10 * time.Millisecondt := time.NewTimer(timeout)time.Sleep(20 * time.Millisecond)start := time.Now()t.Reset(timeout)<-t.Cfmt.Printf("Time elapsed: %dms\n", time.Since(start).Milliseconds())// expected: Time elapsed: 10ms// actual:   Time elapsed:  0ms
}

这里输出为：

Time elapsed: 0ms

因为计时器超时时间设置为 10 毫秒。所以在我们等待 20ms 之后，它已经过期并向 t.C 通道发送了一个值。由于Reset 不重置channel，因此 <-t.C 不会阻塞并立即进行。所以第9行会直接执行，从而打印的时间就是当时的时间（此外，由于 Reset函数重启了计时器，在 10ms 后t.C还会收到一个过期的信号）

Go 1.23 中修复说明：

The timer channel associated with a Timer or Ticker is now unbuffered, with capacity 0. The main effect of this change is that Go now guarantees that for any call to a Reset or Stop method, no stale values prepared before that call will be sent or received after the call.

也就是说通过无缓冲的方式解决了通道重制的问题

详细可以参考：

https://antonz.org/go-1-23/#timer-changes

六、关于“字符串驻留”

(一)unique 包

字符串去重

Go 1.23 标准库引入了一个名为 unique 的新包，旨在实现可比较值的规范化。简而言之，该包允许你对值进行去重，使其指向单个规范的唯一副本，并在底层有效管理这些规范副本

这里写一个比较简单的字符串驻留的函数

var internPool map[string]string// Intern 返回一个与 s 相等的字符串，但该字符串可能与之前传递给 Intern 的字符串共享存储空间。
func Intern(s string) string {pooled, ok := internPool[s]if !ok {// 克隆字符串，以防它是某个更大的字符串的一部分。// 如果正确使用字符串驻留，这种情况应该很少见。pooled = strings.Clone(s)internPool[pooled] = pooled}return pooled
}

当你构建许多可能是重复的字符串时（例如在解析文本格式时），这非常有用。

此实现非常简单，在某些情况下效果很好，但它也存在一些问题：

它永远不会从池中删除字符串。

多个 goroutine 无法安全地同时使用它。

它仅适用于字符串，即使该想法非常通用。

此实现还有一个错失的机会，而且很微妙。在底层，字符串是由指针和长度组成的不可变结构。比较两个字符串时，如果指针不相等，则必须比较它们的内容以确定是否相等。但如果我们知道两个字符串是规范化的，那么只需检查它们的指针就_足够_了。

新的 unique 包引入了一个名为 Make 的函数，类似于 Intern

它的工作方式与 Intern 大致相同。在内部，它也使用全局映射（一个快速的泛型并发映射），Make 在该映射中查找提供的值。但它也与 Intern 有两个重要区别。首先，它接受任何可比较类型的值。其次，它返回一个包装值，即 HandleT，可以从中检索规范值。

HandleT 是设计的关键。HandleT 具有以下属性：当且仅当用于创建它们的_值_相等时，两个 HandleT _值_才相等。更重要的是，比较两个 HandleT 值的成本很低：它归结为指针比较。与比较两个长字符串相比，这要便宜一个数量级！

到目前为止，这在普通的 Go 代码中都能做到。

关于使用

使用这里笔者找到了两个例子，不过笔者觉得后续可以再找一些

// Addr 表示 IPv4 或 IPv6 地址（带或不带范围寻址区域），类似于 net.IP 或 net.IPAddr。
type Addr struct {// 其他不相关的未导出字段...// 有关地址的详细信息，汇总在一起并进行规范化。z unique.Handle[addrDetail]
}// addrDetail 指示地址是 IPv4 还是 IPv6，如果是 IPv6，则指定地址的区域名称。
type addrDetail struct {isV6   bool   // IPv4 为 false，IPv6 为 true。zoneV6 string // 如果 IsV6 为 true，则可能 != ""。
}var z6noz = unique.Make(addrDetail{isV6: true})// WithZone 返回一个与 ip 相同但具有提供的区域的 IP。如果区域为空，则删除该区域。如果 ip 是 IPv4 地址，则 WithZone 是无操作的，并返回未更改的 ip。
func (ip Addr) WithZone(zone string) Addr {if !ip.Is6() {return ip}if zone == "" {ip.z = z6nozreturn ip}ip.z = unique.Make(addrDetail{isV6: true, zoneV6: zone})return ip
}

由于许多 IP 地址可能使用相同的区域，并且此区域是其身份的一部分，因此对它们进行规范化非常有意义。区域的去重减少了每个 netip.Addr 的平均内存占用量，而它们被规范化的事实意味着 netip.Addr 值的比较效率更高，因为比较区域名称变成了简单的指针比较。
具体可以参考：https://k8scat.com/posts/go/go-1.23-unique/

另一个例子：

假设我们有一个随机词生成器：

我们用它从 100 个单词的词汇表中生成 10,000 个单词：

// wordGen returns a generator of random words of length wordLen
// from a set of nDistinct unique words.
func wordGen(nDistinct, wordLen int) func() string {vocab := make([]string, nDistinct)for i := range nDistinct {word := randomString(wordLen)vocab[i] = word}return func() string {word := vocab[rand.Intn(nDistinct)]return strings.Clone(word)}
}// randomString returns a random string of length n.
func randomString(n int) string {// omitted for brevity
}var words []stringfunc main() {const nWords = 10000const nDistinct = 100const wordLen = 40generate := wordGen(nDistinct, wordLen)memBefore := getAlloc()// store wordswords = make([]string, nWords)for i := range nWords {words[i] = generate()}memAfter := getAlloc()memUsed := memAfter - memBeforefmt.Printf("Memory used: %d KB\n", memUsed/1024)
}

运行结果为：

Memory used: 622 KB

而如果用unique

var words []unique.Handle[string]func main() {const nWords = 10000const nDistinct = 100const wordLen = 40generate := wordGen(nDistinct, wordLen)memBefore := getAlloc()// store word handleswords = make([]unique.Handle[string], nWords)for i := range nWords {words[i] = unique.Make(generate())}memAfter := getAlloc()memUsed := memAfter - memBeforefmt.Printf("Memory used: %d KB\n", memUsed/1024)
}