Go 1.21 相比 Go 1.20 有哪些值得注意的改动？

package main

import (
    "fmt"
    "slices"
    "strings"
)

var prefix string = "ap"

// 一个泛型函数，检查字符串是否以特定前缀开头
func HasPrefix[E ~string](s E) bool {
    return strings.HasPrefix(string(s), prefix)
}

func main() {
    strs := []string{"apple", "banana", "apricot"}

    // 在 Go 1.21 之前，直接传递 HasPrefix 可能需要显式实例化类型参数，
    // 或者编译器可能无法推断。
    // index := slices.IndexFunc(strs, func(s string) bool { // 需要定义一个闭包
    //     return HasPrefix(s)
    // })

    // 在 Go 1.21 中，可以直接传递泛型函数 HasPrefix（部分实例化，省略了类型参数 E），
    // 编译器能够根据 strs 的类型 ( []string ) 推断出 E 应该是 string，
    // 同时也能推断出 slices.IndexFunc 的类型参数 S 应该是 string。
    index := slices.IndexFunc(strs, HasPrefix)

    // 修正：虽然文档描述了更强的推断，但实际例子中直接传 HasPrefix 仍然可能不工作
    // 最自然的用法还是通过闭包，闭包内部调用泛型函数会更容易推断
    // 或者更典型的例子是推断返回类型或赋值

    fmt.Println("Index of first string starting with 'ap':", index) // Output: 0

    // 另一个例子：泛型函数赋值
    // var myHasPrefix func(string) bool = HasPrefix // Go 1.21 可以推断
    // fmt.Println(myHasPrefix("app"))
}

package main

import "fmt"

func MakePair[F, S any](f F, s S) func() (F, S) {
    return func() (F, S) {
        return f, s
    }
}

func main() {
    // Go 1.21 可以从 p1 的类型推断出 MakePair 的 F 和 S
    var p1 func() (int, string)
    p1 = MakePair(10, "hello") // 推断 F=int, S=string
    f, s := p1()
    fmt.Println(f, s) // Output: 10 hello

    // 也可以直接在 return 语句中使用
    getP2 := func() func() (bool, float64) {
        return MakePair(true, 3.14) // 推断 F=bool, S=float64
    }
    p2 := getP2()
    b, fl := p2()
    fmt.Println(b, fl) // Output: true 3.14
}

package main

import "fmt"

// F 的类型参数 T 会根据传入的 x 和 y 推断
func F[T any](x, y T) T {
    // 注意：这里不能直接做 x + y，因为 T 是 any，不支持 +
    // 这个例子主要演示类型推断，而不是运算
    fmt.Printf("In F: x type = %T, y type = %T, T inferred as = %T\n", x, y, *new(T))
    return x
}

func main() {
    // 在 Go 1.21 之前，传递 1 (untyped int) 和 2.0 (untyped float)
    // 给类型参数 T 会导致推断失败。
    // Go 1.21 中，会根据常量运算规则推断 T 为默认类型。
    // 对于 1 和 2.0，整数和浮点数混合，结果类型倾向于浮点数，默认是 float64。
    _ = F(1, 2.0) // 输出会显示 T 被推断为 float64

    _ = F(1, 2) // T 会被推断为 int
}

In F: x type = float64, y type = float64, T inferred as = float64
In F: x type = int, y type = int, T inferred as = int

package main

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

func main() {
    var wg sync.WaitGroup
    nums := []int{1, 2, 3}

    fmt.Println("Default behavior (Go <= 1.21 or without experiment):")
    for _, v := range nums {
        wg.Add(1)
        go func() { // 这个 goroutine 捕获的是循环变量 v 的地址
            defer wg.Done()
            time.Sleep(10 * time.Millisecond) // 模拟延迟，确保循环结束
            fmt.Printf("Goroutine sees v = %d\n", v)
        }()
    }
    wg.Wait()
    // 通常输出 (顺序不定):
    // Goroutine sees v = 3
    // Goroutine sees v = 3
    // Goroutine sees v = 3

    fmt.Println("\nCommon workaround:")
    for _, v := range nums {
        v := v // 创建一个当前迭代的局部副本
        wg.Add(1)
        go func() {
            defer wg.Done()
            time.Sleep(10 * time.Millisecond)
            fmt.Printf("Goroutine sees v = %d\n", v) // 捕获的是副本 v
        }()
    }
    wg.Wait()
    // 输出 (顺序不定):
    // Goroutine sees v = 1
    // Goroutine sees v = 2
    // Goroutine sees v = 3
}

GOEXPERIMENT=loopvar go run your_code.go

package main

import "fmt"

func main() {
    fmt.Println("Testing panic(nil)")
    defer func() {
        fmt.Println("Deferred function starts.")
        r := recover()
        if r == nil {
            fmt.Println("recover returned nil. Either no panic or panic(nil) in Go <= 1.20.")
        } else {
            fmt.Printf("recover returned non-nil: %T, value: %[1]v\n", r)
            // 在 Go 1.21+，如果由 panic(nil) 触发，这里会捕获 *runtime.PanicNilError
        }
        fmt.Println("Deferred function ends.")
    }()

    fmt.Println("Calling panic(nil)...")
    panic(nil) // 引发 panic
    // 这行不会执行
    fmt.Println("After panic call (should not be reached).")
}

Testing panic(nil)
Calling panic(nil)...
Deferred function starts.
recover returned nil. Either no panic or panic(nil) in Go <= 1.20.
Deferred function ends.

Testing panic(nil)
Calling panic(nil)...
Deferred function starts.
recover returned non-nil: *runtime.PanicNilError, value: panic called with nil argument
Deferred function ends.

package main

import (
    "log"
    "time"
    //"encoding/json" // 或者使用 JSON
)

func main() {
    requestID := "req-123"
    userID := "user-456"
    startTime := time.Now()

    // 模拟处理
    time.Sleep(50 * time.Millisecond)

    duration := time.Since(startTime)

    // 方式一：手动格式化字符串
    log.Printf("INFO: request processing finished. request_id=%s user_id=%s duration=%s",
        requestID, userID, duration)

    // 方式二：尝试输出 JSON (更繁琐)
    // entry := map[string]interface{}{
    //     "level":      "INFO",
    //     "message":    "request processing finished",
    //     "request_id": requestID,
    //     "user_id":    userID,
    //     "duration_ms": duration.Milliseconds(),
    // }
    // jsonData, _ := json.Marshal(entry)
    // log.Println(string(jsonData))
}

2025/05/02 22:57:14 INFO: request processing finished. request_id=req-123 user_id=user-456 duration=54.537229ms

package main

import (
    "log/slog"
    "os"
    "time"
)

func main() {
    // 创建一个使用默认 TextHandler 的 Logger，输出到 stderr
    // logger := slog.Default() // 或者使用默认 logger

    // 或者创建一个 JSON Handler
    logger := slog.New(slog.NewJSONHandler(os.Stdout, nil)) // 输出 JSON 到 stdout

    requestID := "req-123"
    userID := "user-456"
    startTime := time.Now()

    // 模拟处理
    time.Sleep(50 * time.Millisecond)

    duration := time.Since(startTime)

    // 使用 Info 级别记录日志，并附带属性
    logger.Info("request processing finished",
        slog.String("request_id", requestID),
        slog.String("user_id", userID),
        slog.Duration("duration", duration), // slog 有 Duration 类型
    )

    // 也可以记录其他级别，例如警告
    logger.Warn("potential issue detected",
        slog.String("request_id", requestID),
        slog.Int("error_code", 503),
    )
}

{"time":"2025-05-02T22:58:34.003809744+08:00","level":"INFO","msg":"request processing finished","request_id":"req-123","user_id":"user-456","duration":51303289}
{"time":"2025-05-02T22:58:34.007783138+08:00","level":"WARN","msg":"potential issue detected","request_id":"req-123","error_code":503}

package mylogger_test

import (
    "bytes"
    "context"
    "log/slog"
    "strings"
    "testing"
    "testing/slogtest" // 引入测试包
)

// --- 我们想要测试的自定义 Handler (简单示例) ---
type MyHandler struct {
    buf *bytes.Buffer
    mu  sync.Mutex // 假设需要并发安全
    attrs []slog.Attr
    group string
}

func NewMyHandler(buf *bytes.Buffer) *MyHandler {
    return &MyHandler{buf: buf}
}

func (h *MyHandler) Enabled(ctx context.Context, level slog.Level) bool {
    return true // 简单起见，总是启用
}

func (h *MyHandler) Handle(ctx context.Context, r slog.Record) error {
    h.mu.Lock()
    defer h.mu.Unlock()

    var sb strings.Builder
    sb.WriteString(r.Level.String())
    sb.WriteString(": ")
    sb.WriteString(r.Message)

    allAttrs := h.attrs
    r.Attrs(func(a slog.Attr) bool {
        allAttrs = append(allAttrs, a)
        return true
    })

    for _, attr := range allAttrs {
        // 简单处理 group
        key := attr.Key
        if h.group != "" {
            key = h.group + "." + key
        }
        sb.WriteString(" ")
        sb.WriteString(key)
        sb.WriteString("=")
        sb.WriteString(attr.Value.String()) // 简化处理，都转为 String
    }
    sb.WriteString("\n")
    _, err := h.buf.Write([]byte(sb.String()))
    return err
}

func (h *MyHandler) WithAttrs(attrs []slog.Attr) slog.Handler {
    h.mu.Lock()
    defer h.mu.Unlock()
    newH := *h // 浅拷贝
    newH.attrs = append(slices.Clip(h.attrs), attrs...) // copy on write
    return &newH
}

func (h *MyHandler) WithGroup(name string) slog.Handler {
    h.mu.Lock()
    defer h.mu.Unlock()
    newH := *h // 浅拷贝
    if newH.group != "" {
        newH.group += "." + name
    } else {
        newH.group = name
    }
    return &newH
}


// --- 测试代码 ---
func TestMyHandler(t *testing.T) {
    var buf bytes.Buffer // 用于捕获 Handler 输出

    // 提供创建 Handler 的函数
    newHandler := func(*testing.T) slog.Handler {
        // 注意：每次 TestHandler 调用这个函数时，都应该返回一个全新的 Handler 实例
        buf.Reset() // 重置 buffer，确保每个子测试用例干净
        return NewMyHandler(&buf)
    }

    // 提供获取结果的函数
    results := func(*testing.T) map[string]any {
        // 将 buffer 内容按行分割，模拟多个日志条目
        // 注意：实际的 results 函数可能需要更复杂的解析逻辑，
        // 取决于 TestHandler 的具体要求以及 Handler 的输出格式。
        // slogtest 需要能理解这些结果来和预期进行比较。
        // 对于复杂格式，可能需要解析为 map[string]any 或类似结构。
        // 这里简化为直接返回字符串 map，key 通常是测试用例名。
        // ！！！重要：slogtest 的 results 函数需要返回 map[string]any
        // 以便与内部的预期结果进行比较。简单的字符串分割可能不足以
        // 通过所有测试。一个更健壮的方法是解析日志行回结构化数据。
        // 为简单起见，我们这里仅演示流程，实际实现需要更细致的解析。
        lines := strings.Split(strings.TrimSpace(buf.String()), "\n")
        resMap := make(map[string]any)
        for i, line := range lines {
            // 使用某种方式将 line 关联到 slogtest 内部的测试名
            // 这通常比较困难，除非你的 handler 输出包含测试名信息
            // 或者 slogtest 提供某种机制来关联输入和输出。
            // 另一种常见做法是让 results 返回能够代表“状态”的结构。
            resMap[fmt.Sprintf("line%d", i)] = line // 极简示例
        }
        return resMap
    }

    // 运行 slogtest 的测试套件
    // 注意：这里需要传递一个 results 函数指针
    // 由于 results 函数的正确实现依赖于对 slogtest 内部工作方式的理解
    // （如何匹配日志输出和测试用例），以下调用可能需要调整 results 函数才能真正工作。
    err := slogtest.TestHandler(newHandler(t), results) // 传递 results 函数指针
    if err != nil {
        t.Fatal(err)
    }

    // slogtest v0.3.0 开始推荐使用 t.Run 调用
    // t.Run("slogtest", func(t *testing.T) {
    //     err := slogtest.TestHandler(newHandler(t), results)
    //     if err != nil {
    //         t.Fatal(err)
    //     }
    // })
}

package main

import (
    "fmt"
    "slices"
)

func main() {
    ints := []int{3, 1, 4, 1, 5, 9}
    slices.Sort(ints)
    fmt.Println("Sorted ints:", ints) // Output: Sorted ints: [1 1 3 4 5 9]

    strs := []string{"c", "a", "b"}
    slices.Sort(strs)
    fmt.Println("Sorted strs:", strs) // Output: Sorted strs: [a b c]
}

package main

import (
    "fmt"
    "slices"
)

func main() {
    nums := []int{1, 2, 3, 4}
    fmt.Println("Contains 3?", slices.Contains(nums, 3)) // Output: Contains 3? true
    fmt.Println("Contains 5?", slices.Contains(nums, 5)) // Output: Contains 5? false
}

package main

import (
    "fmt"
    "slices"
    "strings"
)

func main() {
    strs := []string{"apple", "banana", "apricot"}
    // 查找第一个以 "ap" 开头的字符串
    index := slices.IndexFunc(strs, func(s string) bool {
        return strings.HasPrefix(s, "ap")
    })
    fmt.Println("Index of first string starting with 'ap':", index) // Output: 0
}

package main

import (
    "fmt"
    "maps"
    "slices" // 需要用来排序以获得稳定输出
)

func main() {
    m := map[string]int{"a": 1, "c": 3, "b": 2}
    keys := maps.Keys(m)
    slices.Sort(keys) // map 遍历顺序不定，排序后输出稳定
    fmt.Println("Keys:", keys) // Output: Keys: [a b c]
}

package main

import (
    "fmt"
    "maps"
    "slices" // 需要用来排序以获得稳定输出
)

func main() {
    m := map[string]int{"a": 1, "c": 3, "b": 2}
    values := maps.Values(m)
    slices.Sort(values) // map 遍历顺序不定，排序后输出稳定
    fmt.Println("Values:", values) // Output: Values: [1 2 3]
}

package main

import (
    "fmt"
    "maps"
)

func main() {
    m1 := map[string]int{"a": 1}
    m2 := maps.Clone(m1)
    m2["b"] = 2

    fmt.Println("m1:", m1) // Output: m1: map[a:1]
    fmt.Println("m2:", m2) // Output: m2: map[a:1 b:2]
}

type Ordered interface {
    ~int | ~int8 | ~int16 | ~int32 | ~int64 |
        ~uint | ~uint8 | ~uint16 | ~uint32 | ~uint64 | ~uintptr |
        ~float32 | ~float64 |
        ~string
}

package main

import (
    "cmp"
    "fmt"
)

func main() {
    fmt.Println(cmp.Compare(1, 2))    // Output: -1
    fmt.Println(cmp.Compare(2, 2))    // Output: 0
    fmt.Println(cmp.Compare("b", "a")) // Output: 1
}

package main

import (
    "cmp"
    "fmt"
    "slices"
)

func main() {
    fmt.Println(cmp.Less(1, 2)) // Output: true
    fmt.Println(cmp.Less("a", "b")) // Output: true

    // 可以用于 slices.SortFunc
    nums := []int{3, 1, 4}
    slices.SortFunc(nums, cmp.Compare[int]) // 使用 Compare 作为比较函数
    // 或者 slices.SortFunc(nums, func(a, b int) int { return cmp.Compare(a,b) })
    fmt.Println("Sorted with cmp.Compare:", nums) // Output: [1 3 4]
}

package main

import (
    "fmt"
    "maps"
    "slices"
)

// Person struct - all fields (string, int) are comparable
type Person struct {
    Name string
    Age  int
}

func main() {
    p1 := Person{Name: "Alice", Age: 30}
    p2 := Person{Name: "Bob", Age: 25}
    p3 := Person{Name: "Alice", Age: 30} // Same as p1

    people := []Person{p1, p2}

    // 1. 使用 slices.Contains (需要 comparable)
    fmt.Println("Contains p1?", slices.Contains(people, p1)) // Output: true
    fmt.Println("Contains p3?", slices.Contains(people, p3)) // Output: true (value equality)
    fmt.Println("Contains {Carol, 40}?", slices.Contains(people, Person{Name: "Carol", Age: 40})) // Output: false

    // 2. 用作 map 的 key (需要 comparable)
    scores := map[Person]int{
        p1: 100,
        p2: 95,
    }
    fmt.Println("Score for p1:", scores[p1]) // Output: 100
    keys := maps.Keys(scores)
    fmt.Println("Map keys:", keys) // Output: Map keys: [{Alice 30} {Bob 25}] (顺序不定)
}

// import "slices"
// people := []Person{p1, p2}
// slices.Sort(people) // !!! 编译错误：Person does not satisfy cmp.Ordered

package main

import (
    "cmp" // 需要用 cmp.Compare 来辅助比较字段
    "fmt"
    "slices"
)

type Person struct {
    Name string
    Age  int
}

func main() {
    people := []Person{
        {Name: "Alice", Age: 30},
        {Name: "Bob", Age: 25},
        {Name: "Charlie", Age: 30},
    }

    // 定义比较函数：先按年龄升序，年龄相同则按姓名升序
    comparePeople := func(a, b Person) int {
        // 比较年龄
        if diff := cmp.Compare(a.Age, b.Age); diff != 0 {
            return diff // 年龄不同，直接返回年龄比较结果 (-1 or 1)
        }
        // 年龄相同，比较姓名 (姓名是 string，满足 cmp.Ordered)
        return cmp.Compare(a.Name, b.Name)
    }

    // 使用自定义比较函数进行排序
    slices.SortFunc(people, comparePeople)

    fmt.Println("Sorted people:", people)
    // Output: Sorted people: [{Bob 25} {Alice 30} {Charlie 30}]
}