【Golang那些事】go1.22和1.23 更新重点及测评
好久没有写文章了，攒了一年的Golang版本特性的技术点以及踩过的坑，那就在新年第一篇的文章中做一个总结吧：
一、关于迭代器
(一)迭代器去掉了共享共享内存
一个经典的面试题
说到Golang经典的面试题，大家可能都刷到过很多，笔者这里也曾经收藏过几个比较有意思的面试题，下面这个就是其中之一：
package main
import "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.Map
m.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 route
resp, _ := 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 route
resp, _ := 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…}：
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 match
req, _ := 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 match
req, _ := 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 stuff
case <-time.After(time.Hour):
// log warning
case <-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 - memBefore
fmt.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.Millisecond
t := time.NewTimer(timeout)
time.Sleep(20 * time.Millisecond)
start := time.Now()
t.Reset(timeout)
<-t.C
fmt.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 = z6noz
return 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 []string
func main() {
const nWords = 10000
const nDistinct = 100
const wordLen = 40
generate := wordGen(nDistinct, wordLen)
memBefore := getAlloc()
// store words
words = make([]string, nWords)
for i := range nWords {
words[i] = generate()
}
memAfter := getAlloc()
memUsed := memAfter - memBefore
fmt.Printf("Memory used: %d KB\n", memUsed/1024)
}
运行结果为：
Memory used: 622 KB
而如果用unique
var words []unique.Handle[string]
func main() {
const nWords = 10000
const nDistinct = 100
const wordLen = 40
generate := wordGen(nDistinct, wordLen)
memBefore := getAlloc()
// store word handles
words = make([]unique.Handle[string], nWords)
for i := range nWords {
words[i] = unique.Make(generate())
}
memAfter := getAlloc()
memUsed := memAfter - memBefore
fmt.Printf("Memory used: %d KB\n", memUsed/1024)
}
结果为：
Memory used: 96 KB
具体可以参考：https://antonz.org/go-1-23/#timer-changes