Go 标准库完全参考手册

本文档基于 Go 1.26.5 标准库 整理编写。 涵盖所有公开标准库包的核心用法，每个功能配有代码示例和中文注释。 示例来源：Go 官方文档 pkg.go.dev

fmt — 格式化输入输出

打印函数

• fmt.Print — 默认格式输出
• fmt.Printf — 格式化输出（占位符）
• fmt.Println — 输出后换行
• fmt.Sprint / Sprintf / Sprintln — 返回字符串而非打印
• fmt.Fprint / Fprintf / Fprintln — 写入 io.Writer

常用占位符

package main

import "fmt"

type Person struct {
    Name string
    Age  int
}

func main() {
    // Printf — 格式化输出
    fmt.Printf("Hello, %s!\n", "World")

    // %d — 整数占位符
    fmt.Printf("年龄: %d 岁\n", 25)

    // %v — 任意值的默认格式，适合快速打印
    fmt.Printf("值: %v\n", Person{"Alice", 30})

    // %+v — 结构体带字段名，调试时非常有用
    fmt.Printf("详细: %+v\n", Person{"Bob", 25})

    // %#v — 完整的 Go 语法表示，用于调试复杂类型
    fmt.Printf("Go语法: %#v\n", Person{"Charlie", 35})

    // %T — 打印类型，调试接口值时很常用
    var v interface{} = "hello"
    fmt.Printf("类型: %T\n", v)

    // %.2f — 控制浮点数精度
    fmt.Printf("圆周率: %.2f\n", 3.14159265)

    // Sprintf — 返回格式化字符串而非打印
    msg := fmt.Sprintf("结果: %d 条记录", 42)
    fmt.Println(msg)

    // Fprintf — 写入到 writer（如文件、HTTP 响应）
    // 下面的例子写入到标准错误
    fmt.Fprintf(stderr, "错误: 文件未找到\n")
}

// 模拟 stderr，实际使用 os.Stderr
var stderr = struct{ Write([]byte) (int, error) }{
    Write: func(p []byte) (int, error) {
        return len(p), nil
    },
}

官方文档：https://pkg.go.dev/fmt@go1.26.5

strings — 字符串操作

常用函数

package main

import (
    "fmt"
    "strings"
)

func main() {
    // Contains — 是否包含子串，O(n) 时间
    fmt.Println(strings.Contains("hello world", "world")) // true

    // HasPrefix / HasSuffix — 前后缀判断
    fmt.Println(strings.HasPrefix("main.go", "main")) // true
    fmt.Println(strings.HasSuffix("photo.jpg", ".jpg")) // true

    // Index — 查找子串位置（未找到返回 -1）
    fmt.Println(strings.Index("hello world", "o"))  // 4
    fmt.Println(strings.Index("hello world", "x"))  // -1

    // LastIndex — 从后往前查找
    fmt.Println(strings.LastIndex("hello world", "o")) // 7

    // Replace — 替换（n<0 替换全部，n>=0 替换前 n 个）
    fmt.Println(strings.Replace("oink oink", "oink", "moo", 1))  // moo oink
    fmt.Println(strings.ReplaceAll("oink oink", "oink", "moo"))  // moo moo

    // ToUpper / ToLower — 大小写转换
    fmt.Println(strings.ToUpper("hello")) // HELLO
    fmt.Println(strings.ToLower("WORLD")) // world

    // Trim / TrimSpace — 去除两端字符
    fmt.Println(strings.TrimSpace("  hello  "))     // hello
    fmt.Println(strings.Trim("!!!hello!!!", "!"))   // hello
    fmt.Println(strings.TrimPrefix("prefix/data", "prefix/")) // data

    // Split / SplitN — 分割字符串
    // SplitN 限制分割次数，防止意外分割过多
    parts := strings.Split("a,b,c", ",")
    fmt.Printf("%q\n", parts) // ["a" "b" "c"]

    // Join — 用分隔符合并字符串切片
    fmt.Println(strings.Join([]string{"usr", "local", "bin"}, "/")) // usr/local/bin

    // Fields — 按空白分割（比 Split 更智能）
    fmt.Printf("%q\n", strings.Fields("  hello   world  ")) // ["hello" "world"]

    // Repeat — 重复字符串
    fmt.Println(strings.Repeat("na", 3) + " Batman") // nanana Batman

    // Builder — 高效构建字符串
    var sb strings.Builder
    sb.WriteString("Hello")
    sb.WriteString(" ")
    sb.WriteString("World")
    sb.WriteByte('!')
    fmt.Println(sb.String()) // Hello World!

    // Count — 统计子串出现次数
    fmt.Println(strings.Count("cheese", "e")) // 3

    // Compare — 比较字符串（Go 1.20+ 也可直接用 ==、<、>）
    fmt.Println(strings.Compare("a", "b")) // -1
    fmt.Println(strings.Compare("a", "a")) // 0
}

官方文档：https://pkg.go.dev/strings@go1.26.5

bytes — 字节切片操作

package main

import (
    "bytes"
    "fmt"
)

func main() {
    // Buffer — 高效的字节缓冲区
    var buf bytes.Buffer
    buf.Write([]byte("Hello "))
    buf.WriteString("World")
    buf.WriteByte('!')
    fmt.Println(buf.String()) // Hello World!

    // Buffer 也可以作为 io.Reader 使用
    data := make([]byte, 5)
    n, _ := buf.Read(data)
    fmt.Printf("读取 %d 字节: %s\n", n, data[:n]) // 读取 5 字节: Hello

    // Compare — 比较两个字节切片
    fmt.Println(bytes.Compare([]byte("abc"), []byte("abd"))) // -1

    // Contains — 是否包含子切片
    fmt.Println(bytes.Contains([]byte("hello"), []byte("ell"))) // true

    // Equal — 判断相等（比 bytes.Compare(...)==0 更简洁）
    fmt.Println(bytes.Equal([]byte("go"), []byte("go"))) // true

    // Repeated — 重复连接
    fmt.Printf("%s\n", bytes.Repeat([]byte("ab"), 3)) // ababab

    // Trim — 去掉两端字符
    fmt.Printf("%s\n", bytes.Trim([]byte("!!hello!!"), "!")) // hello

    // Split / Join
    parts := bytes.Split([]byte("a,b,c"), []byte(","))
    for _, p := range parts {
        fmt.Printf("%s ", p) // a b c
    }
    fmt.Println()
    joined := bytes.Join(parts, []byte("-"))
    fmt.Printf("%s\n", joined) // a-b-c

    // NewReader — 从 []byte 创建 io.Reader
    reader := bytes.NewReader([]byte("hello world"))
    readBuf := make([]byte, 5)
    reader.Read(readBuf)
    fmt.Printf("%s\n", readBuf) // hello

    // Go 1.19+: Clone 复制字节切片
    original := []byte("sensitive data")
    cloned := bytes.Clone(original)
    cloned[0] = 'c'
    fmt.Printf("original=%s cloned=%s\n", original, cloned)
}

官方文档：https://pkg.go.dev/bytes@go1.26.5

strconv — 字符串转换

package main

import (
    "fmt"
    "strconv"
)

func main() {
    // Atoi / Itoa — 字符串与整数的互转（最常用）
    n, err := strconv.Atoi("42")
    if err != nil {
        fmt.Println("转换失败:", err)
    }
    fmt.Printf("Atoi: %d (类型: %T)\n", n, n)

    s := strconv.Itoa(42)
    fmt.Printf("Itoa: %s (类型: %T)\n", s, s)

    // ParseInt — 可指定进制和位数
    hex, _ := strconv.ParseInt("FF", 16, 64)
    fmt.Println("十六进制 FF =", hex) // 255

    bin, _ := strconv.ParseInt("1010", 2, 64)
    fmt.Println("二进制 1010 =", bin) // 10

    // FormatInt / FormatFloat — 格式化数字
    // FormatInt 可以格式化为各种进制
    str := strconv.FormatInt(255, 16)
    fmt.Println("255 的十六进制:", str) // "ff"

    // ParseFloat / FormatFloat
    f, _ := strconv.ParseFloat("3.14159", 64)
    fmt.Println("浮点数:", f)

    // 格式化浮点数（保留 2 位小数）
    formatted := strconv.FormatFloat(3.14159, 'f', 2, 64)
    fmt.Println("格式化:", formatted) // "3.14"

    // ParseBool / FormatBool
    b, _ := strconv.ParseBool("true")
    fmt.Println("布尔值:", b)
    fmt.Println("格式化布尔:", strconv.FormatBool(false)) // "false"

    // AppendInt — 追加到字节切片（比 FormatInt + 拼接更高效）
    buf := make([]byte, 0, 32)
    buf = strconv.AppendInt(buf, 12345, 10)
    buf = append(buf, ' ')
    buf = strconv.AppendFloat(buf, 3.14, 'f', 2, 64)
    fmt.Printf("追加结果: %s\n", buf)

    // ParseUint — 无符号整数
    u, _ := strconv.ParseUint("999", 10, 64)
    fmt.Println("无符号整数:", u)
}

官方文档：https://pkg.go.dev/strconv@go1.26.5

errors — 错误处理

package main

import (
    "errors"
    "fmt"
    "io/fs"
    "os"
)

var ErrNotFound = errors.New("not found")
var ErrPermission = errors.New("permission denied")

func main() {
    // errors.New — 创建简单错误
    err := errors.New("发生了错误")
    fmt.Println(err)

    // fmt.Errorf + %w — 包装错误（Go 1.13+）
    err = fmt.Errorf("读取配置: %w", ErrNotFound)
    fmt.Println(err) // "读取配置: not found"

    // errors.Is — 检查错误链中是否包含指定错误
    if errors.Is(err, ErrNotFound) {
        fmt.Println("✅ 匹配 ErrNotFound")
    }

    // errors.As — 将错误断言为特定类型
    _, err = os.Open("/nonexistent")
    var pathErr *fs.PathError
    if errors.As(err, &pathErr) {
        fmt.Printf("操作: %s, 路径: %s\n", pathErr.Op, pathErr.Path)
    }

    // errors.Join — 合并多个错误（Go 1.20+）
    err1 := errors.New("错误1")
    err2 := errors.New("错误2")
    combined := errors.Join(err1, err2)
    fmt.Println("合并:", combined)
    fmt.Println("包含 err1?", errors.Is(combined, err1)) // true

    // errors.Unwrap — 解包一层错误
    wrapped := fmt.Errorf("外层: %w", ErrNotFound)
    unwrapped := errors.Unwrap(wrapped)
    fmt.Println("解包:", unwrapped) // "not found"
}

官方文档：https://pkg.go.dev/errors@go1.26.5

cmp — 可比较类型的比较

package main

import (
    "cmp"
    "fmt"
)

func main() {
    // Compare — 泛型比较 (-1, 0, 1)
    fmt.Println(cmp.Compare(3, 5))   // -1
    fmt.Println(cmp.Compare(5, 5))   // 0
    fmt.Println(cmp.Compare(7, 2))   // 1
    fmt.Println(cmp.Compare("a", "b")) // -1

    // Less — 是否小于（返回 bool）
    fmt.Println(cmp.Less(3, 5))  // true
    fmt.Println(cmp.Less(5, 3))  // false

    // Or — 返回第一个非零值（Go 1.22+）
    zero := 0
    val := cmp.Or(zero, 42, 100)
    fmt.Println("Or 结果:", val) // 42（跳过 0，取第一个非零值）

    // Or 的典型用法：提供默认值
    userInput := ""
    display := cmp.Or(userInput, "默认用户")
    fmt.Println("显示:", display) // "默认用户"
}

官方文档：https://pkg.go.dev/cmp@go1.26.5

time — 时间与时区

package main

import (
    "fmt"
    "time"
)

func main() {
    // Now — 获取当前时间（使用单调时钟）
    now := time.Now()
    fmt.Println("当前时间:", now)

    // Date — 创建特定时间
    t := time.Date(2024, time.January, 15, 10, 30, 0, 0, time.UTC)
    fmt.Println("指定时间:", t)

    // Parse / Format — 时间解析和格式化
    // ⚠️ 为什么 layout 是 "2006-01-02 15:04:05"：
    //   这是 Go 的诞生时间，不是随便写的格式字符串
    t2, _ := time.Parse("2006-01-02 15:04:05", "2024-03-20 14:30:00")
    fmt.Println("解析结果:", t2)

    // Format — 格式化为字符串
    fmt.Println("格式化:", t2.Format("2006-01-02 (Mon) 15:04"))
    fmt.Println("RFC3339:", t2.Format(time.RFC3339))

    // 常用时间常量
    fmt.Println("RFC3339 格式:", time.RFC3339)

    // Duration — 时间间隔
    later := t.Add(2 * time.Hour)
    fmt.Println("两小时后:", later)

    diff := later.Sub(t)
    fmt.Println("差值:", diff) // 2h0m0s

    // Since / Until — 简洁的时间差计算
    started := time.Now()
    // ... 模拟耗时操作
    time.Sleep(10 * time.Millisecond)
    fmt.Printf("耗时: %v\n", time.Since(started))

    // Timer / Ticker — 定时器和周期执行
    // Timer — 一次性定时器
    timer := time.NewTimer(50 * time.Millisecond)
    <-timer.C
    fmt.Println("定时器触发")

    // Ticker — 周期性定时器
    ticker := time.NewTicker(30 * time.Millisecond)
    count := 0
    for range ticker.C {
        count++
        fmt.Printf("tick %d\n", count)
        if count >= 3 {
            ticker.Stop()
            break
        }
    }

    // After — 简化的延迟（返回 channel）
    <-time.After(10 * time.Millisecond)
    fmt.Println("After 延迟完成")

    // Sleep — 休眠
    time.Sleep(5 * time.Millisecond)

    // 时区处理
    loc, _ := time.LoadLocation("America/New_York")
    nyTime := now.In(loc)
    fmt.Printf("纽约时间: %s\n", nyTime.Format("15:04"))

    // Unix 时间戳
    unix := time.Now().Unix()
    fmt.Printf("Unix 时间戳: %d\n", unix)
    fromUnix := time.Unix(unix, 0)
    fmt.Printf("从时间戳恢复: %s\n", fromUnix)
}

官方文档：https://pkg.go.dev/time@go1.26.5

io / io/fs — 输入输出与文件系统

package main

import (
    "fmt"
    "io"
    "os"
    "strings"
)

func main() {
    // Reader / Writer — 最核心的接口
    // io.Reader：任何可以读取数据的对象
    // io.Writer：任何可以写入数据的对象

    // 1. 从字符串创建 Reader
    reader := strings.NewReader("Hello, Go IO!")

    // 2. 复制到标准输出（Writer）
    // io.Copy — 标准的数据传输方式
    n, err := io.Copy(os.Stdout, reader)
    if err != nil {
        fmt.Println("复制出错:", err)
    }
    fmt.Printf("\n复制了 %d 字节\n", n)

    // ReadAll — 读取所有数据（Go 1.16+，替代 ioutil.ReadAll）
    data, err := io.ReadAll(strings.NewReader("hello"))
    fmt.Printf("ReadAll: %s\n", data)

    // ReadFull — 精确读取 len(buf) 字节
    buf := make([]byte, 5)
    _, err = io.ReadFull(strings.NewReader("hello world"), buf)
    fmt.Printf("ReadFull: %s\n", buf) // "hello"

    // NopCloser — 把 Reader 变成 ReadCloser
    rc := io.NopCloser(strings.NewReader("data"))
    defer rc.Close()

    // MultiReader — 合并多个 Reader 顺序读取
    r1 := strings.NewReader("Hello ")
    r2 := strings.NewReader("World")
    mr := io.MultiReader(r1, r2)
    all, _ := io.ReadAll(mr)
    fmt.Printf("MultiReader: %s\n", all)

    // MultiWriter — 同时写入多个 Writer
    var buf1, buf2 strings.Builder
    mw := io.MultiWriter(&buf1, &buf2)
    mw.Write([]byte("同步写入"))
    fmt.Printf("buf1: %s, buf2: %s\n", buf1.String(), buf2.String())

    // io.Discard — 丢弃数据的 Writer
    io.CopyN(io.Discard, strings.NewReader("丢弃"), 3)

    // Pipe — 内存管道
    pr, pw := io.Pipe()
    go func() {
        pw.Write([]byte("管道数据"))
        pw.Close()
    }()
    pipeData, _ := io.ReadAll(pr)
    fmt.Printf("Pipe: %s\n", pipeData)
}

官方文档：https://pkg.go.dev/io@go1.26.5

net — 网络基础

package main

import (
    "fmt"
    "net"
)

func main() {
    // LookupHost — DNS 解析（查 A/AAAA 记录）
    ips, err := net.LookupHost("google.com")
    if err != nil {
        fmt.Println("DNS 查询失败:", err)
    } else {
        fmt.Println("google.com IP:", ips[:2], "...")
    }

    // LookupAddr — 反向 DNS 查询（IP → 域名）
    names, err := net.LookupAddr("8.8.8.8")
    if err == nil && len(names) > 0 {
        fmt.Println("8.8.8.8 域名:", names[0]) // dns.google.
    }

    // ParseIP — 解析 IP 地址字符串
    ip := net.ParseIP("192.168.1.1")
    fmt.Printf("IP: %v (IsLoopback: %v)\n", ip, ip.IsLoopback())

    ipv6 := net.ParseIP("::1")
    fmt.Printf("IPv6 回环: %v\n", ipv6)

    // CIDRMask — 子网掩码
    _, cidr, _ := net.ParseCIDR("192.168.1.0/24")
    fmt.Printf"CIDR 网络: %v, 掩码: %v\n", cidr.IP, cidr.Mask)

    // 判断 IP 是否在网段内
    testIP := net.ParseIP("192.168.1.100")
    fmt.Println("是否在 192.168.1.0/24:", cidr.Contains(testIP)) // true

    // Interfaces — 获取网络接口列表
    ifaces, _ := net.Interfaces()
    for _, iface := range ifaces {
        fmt.Printf("接口: %s, MAC: %s, MTU: %d\n", iface.Name, iface.HardwareAddr, iface.MTU)
    }

    // Dial — 建立 TCP 连接
    conn, err := net.Dial("tcp", "google.com:80")
    if err == nil {
        conn.Write([]byte("GET / HTTP/1.0\r\nHost: google.com\r\n\r\n"))
        buf := make([]byte, 256)
        n, _ := conn.Read(buf)
        fmt.Printf("HTTP 响应前 %d 字节: %s...\n", n, buf[:50])
        conn.Close()
    }
}

官方文档：https://pkg.go.dev/net@go1.26.5

net/http — HTTP 客户端与服务端

HTTP 客户端

package main

import (
    "fmt"
    "io"
    "net/http"
    "strings"
    "time"
)

func main() {
    // Get — 最简单的 GET 请求
    resp, err := http.Get("https://api.github.com")
    if err != nil {
        fmt.Println("请求失败:", err)
        return
    }
    defer resp.Body.Close()

    // 读取响应体
    body, _ := io.ReadAll(resp.Body)
    fmt.Printf("状态码: %d, 响应长度: %d\n", resp.StatusCode, len(body))

    // 带超时的 Client
    client := &http.Client{
        Timeout: 5 * time.Second, // 5 秒超时
    }
    resp2, _ := client.Get("https://httpbin.org/delay/1")
    if resp2 != nil {
        defer resp2.Body.Close()
        fmt.Println("带超时的请求成功")
    }

    // NewRequest — 自定义请求（设置 Header、Body 等）
    jsonBody := `{"name":"test"}`
    req, _ := http.NewRequest("POST", "https://httpbin.org/post",
        strings.NewReader(jsonBody))
    req.Header.Set("Content-Type", "application/json")
    req.Header.Set("Authorization", "Bearer token123")

    resp3, _ := client.Do(req)
    if resp3 != nil {
        defer resp3.Body.Close()
        body3, _ := io.ReadAll(resp3.Body)
        fmt.Printf("自定义请求响应: %s...\n", body3[:50])
    }

    // Transport — 高级配置（连接池、代理等）
    transport := &http.Transport{
        MaxIdleConns:        100,  // 最大空闲连接数
        IdleConnTimeout:     90 * time.Second,
        DisableCompression:  false,
    }
    customClient := &http.Client{
        Transport: transport,
        Timeout:   10 * time.Second,
    }
    _ = customClient

    // Go 1.20+: ResponseController — 控制每个请求的行为
    // 注意：ResponseController 用于服务端，设置 per-request 超时等
}

HTTP 服务端

package main

import (
    "encoding/json"
    "fmt"
    "log"
    "net/http"
)


// UserHandler 处理 /api/users 路由
type UserHandler struct{}

type User struct {
    ID   int    `json:"id"`
    Name string `json:"name"`
}

func (h *UserHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
    switch r.Method {
    case http.MethodGet:
        // 查询用户
        users := []User{{ID: 1, Name: "Alice"}, {ID: 2, Name: "Bob"}}
        w.Header().Set("Content-Type", "application/json")
        json.NewEncoder(w).Encode(users)
    case http.MethodPost:
        // 创建用户
        var user User
        if err := json.NewDecoder(r.Body).Decode(&user); err != nil {
            http.Error(w, err.Error(), http.StatusBadRequest)
            return
        }
        w.WriteHeader(http.StatusCreated)
        json.NewEncoder(w).Encode(map[string]string{"status": "created"})
    }
}

// Go 1.22+: 新的 ServeMux 增强语法
func newRouter() http.Handler {
    mux := http.NewServeMux()

    // 方法 + 路径模式
    mux.HandleFunc("GET /api/users", func(w http.ResponseWriter, r *http.Request) {
        w.Write([]byte("GET users"))
    })

    mux.HandleFunc("POST /api/users", func(w http.ResponseWriter, r *http.Request) {
        w.Write([]byte("POST users"))
    })

    // 路径参数 {id}
    mux.HandleFunc("GET /api/users/{id}", func(w http.ResponseWriter, r *http.Request) {
        id := r.PathValue("id") // 获取路径参数
        w.Write([]byte("GET user: " + id))
    })

    // 通配符匹配
    mux.HandleFunc("GET /files/{path...}", func(w http.ResponseWriter, r *http.Request) {
        path := r.PathValue("path")
        w.Write([]byte("Path: " + path))
    })

    return mux
}

// 中间件模式
func loggingMiddleware(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        log.Printf("%s %s", r.Method, r.URL.Path)
        next.ServeHTTP(w, r)
    })
}

func main() {
    handler := newRouter()
    wrapped := loggingMiddleware(handler)

    // 初始化 HTTP 服务器（生产环境用 Server 结构体配置）
    srv := &http.Server{
        Addr:    ":8080",
        Handler: wrapped,
    }

    log.Println("启动服务器在 :8080")
    log.Fatal(srv.ListenAndServe())
}

官方文档：https://pkg.go.dev/net/http@go1.26.5

net/url — URL 解析

package main

import (
    "fmt"
    "net/url"
)

func main() {
    // Parse — 解析 URL 字符串
    u, err := url.Parse("https://user:pass@example.com:8080/path/to/page?name=Alice&age=30#section")
    if err != nil {
        fmt.Println("URL 解析失败:", err)
        return
    }

    fmt.Printf("Scheme: %s\n", u.Scheme)     // https
    fmt.Printf("Host: %s\n", u.Host)         // example.com:8080
    fmt.Printf("Path: %s\n", u.Path)         // /path/to/page
    fmt.Printf("Fragment: %s\n", u.Fragment) // section
    fmt.Printf("User: %s\n", u.User.Username()) // user

    // Query — 解析 URL 查询参数
    q := u.Query()
    fmt.Printf("name: %s\n", q.Get("name")) // Alice
    fmt.Printf("age: %s\n", q.Get("age"))   // 30

    // Values — 构建查询参数
    params := url.Values{}
    params.Add("q", "go programming")
    params.Add("page", "1")
    params.Add("tags", "golang")
    params.Add("tags", "stdlib") // 同一个 key 多个值
    fmt.Println("Encode:", params.Encode())

    // URL 编码/解码
    encoded := url.QueryEscape("hello world & more")
    fmt.Println("编码:", encoded)
    decoded, _ := url.QueryUnescape(encoded)
    fmt.Println("解码:", decoded)

    // PathEscape — 路径段的编码
    pathSafe := url.PathEscape("hello world")
    fmt.Println("路径编码:", pathSafe)

    // URL 构建
    built := &url.URL{
        Scheme: "https",
        Host:   "example.com",
        Path:   "/search",
        RawQuery: url.Values{
            "q": {"golang"},
        }.Encode(),
    }
    fmt.Println("构建 URL:", built.String())
}

官方文档：https://pkg.go.dev/net/url@go1.26.5

net/netip — IP 地址类型（Go 1.18+）

package main

import (
    "fmt"
    "net/netip"
)

func main() {
    // ParseAddr — 解析 IP 地址
    ip, err := netip.ParseAddr("192.0.2.1")
    if err != nil {
        fmt.Println("IP 解析失败:", err)
    }
    fmt.Printf("IP: %s\n", ip)         // 192.0.2.1
    fmt.Printf("Is4: %v\n", ip.Is4())  // true
    fmt.Printf("Is6: %v\n", ip.Is6())  // false

    // 作为 map 键（net.IP 不能直接当 map 键）
    ipMap := map[netip.Addr]string{
        netip.MustParseAddr("10.0.0.1"): "router1",
        netip.MustParseAddr("10.0.0.2"): "router2",
    }
    fmt.Println("map:", ipMap)

    // Prefix — IP 网段
    prefix, _ := netip.ParsePrefix("10.0.0.0/8")
    fmt.Printf("Prefix: %s\n", prefix)

    // Contains — 检查 IP 是否在网段内
    fmt.Println("10.1.2.3 在网段内?", prefix.Contains(netip.MustParseAddr("10.1.2.3"))) // true

    // AddrPort — 地址 + 端口
    ap := netip.MustParseAddrPort("192.168.1.1:80")
    fmt.Printf("Addr: %s, Port: %d\n", ap.Addr(), ap.Port())

    // IPv6 支持
    ip6 := netip.MustParseAddr("::1")
    fmt.Printf("IPv6 回环: %s, IsLoopback: %v\n", ip6, ip6.IsLoopback())
}

官方文档：https://pkg.go.dev/net/netip@go1.26.5

sync — 同步原语

package main

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

func main() {
    // Mutex — 互斥锁
    var mu sync.Mutex
    counter := 0
    var wg sync.WaitGroup

    for i := 0; i < 100; i++ {
        wg.Add(1)
        go func() {
            defer wg.Done()
            mu.Lock()
            counter++
            mu.Unlock()
        }()
    }
    wg.Wait()
    fmt.Println("计数器:", counter) // 100

    // RWMutex — 读写锁
    var rwmu sync.RWMutex
    var data int
    for i := 0; i < 5; i++ {
        wg.Add(1)
        go func() {
            defer wg.Done()
            rwmu.RLock() // 读锁，可多个同时持有
            fmt.Println("读取 data:", data)
            rwmu.RUnlock()
        }()
    }
    wg.Add(1)
    go func() {
        defer wg.Done()
        time.Sleep(10 * time.Millisecond)
        rwmu.Lock() // 写锁，必须独占
        data = 42
        rwmu.Unlock()
    }()
    wg.Wait()

    // WaitGroup — 等待一组 goroutine 完成
    var wg2 sync.WaitGroup
    for i := 0; i < 5; i++ {
        wg2.Add(1)
        go func(id int) {
            defer wg2.Done()
            fmt.Printf("工作 %d 完成\n", id)
        }(i)
    }
    wg2.Wait()
    fmt.Println("所有工作完成")

    // Once — 只执行一次
    var once sync.Once
    initFunc := func() {
        fmt.Println("初始化（只执行一次）")
    }
    for i := 0; i < 5; i++ {
        go once.Do(initFunc)
    }

    // Pool — 对象池
    var pool = sync.Pool{
        New: func() interface{} {
            return make([]byte, 1024)
        },
    }
    buf := pool.Get().([]byte) // 从池中获取
    buf[0] = 1
    pool.Put(buf) // 放回池中

    // Go 1.21+: WaitGroup.Go（简化 goroutine 启动）
    var wg3 sync.WaitGroup
    wg3.Go(func() {
        fmt.Println("自动 Add/Done")
    })
    wg3.Wait()
}

官方文档：https://pkg.go.dev/sync@go1.26.5

sync/atomic — 原子操作

package main

import (
    "fmt"
    "sync/atomic"
)

func main() {
    // atomic.Int64 — 原子整数（Go 1.19+）
    var counter atomic.Int64
    counter.Add(1)
    counter.Add(1)
    fmt.Println("计数器:", counter.Load()) // 2

    counter.Store(100)
    fmt.Println("设置后:", counter.Load())

    // CompareAndSwap — CAS 操作
    swapped := counter.CompareAndSwap(100, 200)
    fmt.Printf("CAS 成功: %v, 值: %d\n", swapped, counter.Load())

    // Swap — 原子交换
    old := counter.Swap(50)
    fmt.Printf("旧值: %d, 新值: %d\n", old, counter.Load())

    // atomic.Bool — 原子布尔值
    var flag atomic.Bool
    flag.Store(true)
    fmt.Println("flag:", flag.Load())

    // atomic.Pointer — 原子指针
    type Config struct{ Addr string }
    var config atomic.Pointer[Config]
    config.Store(&Config{Addr: ":8080"})
    cfg := config.Load()
    fmt.Println("配置:", cfg.Addr)

    // 旧版函数（int32/int64/uint32/uint64/uintptr/unsafe.Pointer）
    var x int64
    atomic.AddInt64(&x, 1)
    fmt.Println("旧版:", atomic.LoadInt64(&x))
}

官方文档：https://pkg.go.dev/sync/atomic@go1.26.5

context — 上下文（超时/取消/传值）

package main

import (
    "context"
    "fmt"
    "time"
)

func main() {
    // Background — 根 context（从不取消）
    ctx := context.Background()

    // TODO — 当不确定用什么 context 时
    // 用于待迁移的代码
    _ = context.TODO()

    // WithCancel — 可手动取消的 context
    ctx, cancel := context.WithCancel(ctx)
    go func() {
        time.Sleep(20 * time.Millisecond)
        cancel() // 取消 context
    }()
    <-ctx.Done()
    fmt.Println("取消原因:", ctx.Err()) // context canceled

    // WithTimeout — 带超时的 context（最常用）
    ctx2, cancel2 := context.WithTimeout(context.Background(), 50*time.Millisecond)
    defer cancel2()

    select {
    case <-time.After(100 * time.Millisecond):
        fmt.Println("操作完成")
    case <-ctx2.Done():
        fmt.Println("超时:", ctx2.Err()) // context deadline exceeded
    }

    // WithDeadline — 指定绝对时间截止
    deadline := time.Now().Add(50 * time.Millisecond)
    ctx3, cancel3 := context.WithDeadline(context.Background(), deadline)
    defer cancel3()

    // WithValue — 传递请求范围的值
    // ⚠️ 注意：不要用 WithValue 传递函数参数
    ctx4 := context.WithValue(context.Background(), "traceID", "abc-123")
    traceID := ctx4.Value("traceID")
    fmt.Println("TraceID:", traceID)

    // Go 1.20: WithCancelCause — 带取消原因的 context
    ctx5, cancel5 := context.WithCancelCause(context.Background())
    cancel5(fmt.Errorf("数据库连接失败"))
    fmt.Println("Cause:", context.Cause(ctx5))

    // 调用链示例：模拟 API 调用
    type result struct {
        data string
        err  error
    }
    ch := make(chan result, 1)

    // 模拟一个可能慢的外部调用
    go func() {
        time.Sleep(10 * time.Millisecond)
        ch <- result{data: "响应数据", err: nil}
   }()

    // 设置 100ms 超时
    apiCtx, apiCancel := context.WithTimeout(context.Background(), 100*time.Millisecond)
    defer apiCancel()

    select {
    case res := <-ch:
        fmt.Printf("API 响应: %s (err=%v)\n", res.data, res.err)
    case <-apiCtx.Done():
        fmt.Println("API 超时!")
    }
}

官方文档：https://pkg.go.dev/context@go1.26.5

os — 操作系统接口

package main

import (
    "fmt"
    "os"
)

func main() {
    // 文件创建与写入
    // OpenFile / Create / Write — 文件操作
    f, err := os.CreateTemp("", "example-*.txt")
    if err != nil {
        panic(err)
    }
    defer os.Remove(f.Name())

    // WriteString / Write — 写入文件
    _, err = f.WriteString("Hello, Go!")
    if err != nil {
        fmt.Println("写入失败:", err)
    }
    f.Close()

    // ReadFile — 读取整个文件（Go 1.16+）
    data, err := os.ReadFile(f.Name())
    if err != nil {
        fmt.Println("读取失败:", err)
    }
    fmt.Printf("文件内容: %s\n", data)

    // Stat — 获取文件信息
    info, _ := os.Stat(f.Name())
    fmt.Printf("文件名: %s, 大小: %d, 是否为目录: %v\n",
        info.Name(), info.Size(), info.IsDir())

    // 环境变量
    os.Setenv("APP_MODE", "production")
    mode := os.Getenv("APP_MODE")
    fmt.Println("APP_MODE:", mode)

    home := os.Getenv("HOME")
    fmt.Println("HOME:", home)

    // 查找 PATH 中的可执行文件
    path, _ := os.Executable()
    fmt.Println("当前可执行文件:", path)

    // 工作目录
    dir, _ := os.Getwd()
    fmt.Println("当前目录:", dir)

    // MkdirTemp — 创建临时目录
    tmpDir, _ := os.MkdirTemp("", "example-*")
    defer os.RemoveAll(tmpDir)
    fmt.Println("临时目录:", tmpDir)

    // MkdirAll — 创建多层目录
    err = os.MkdirAll(tmpDir+"/a/b/c", 0755)
    if err == nil {
        fmt.Println("创建多层目录成功")
    }

    // IsNotExist — 判断文件不存在
    _, err = os.Stat("/nonexistent")
    if os.IsNotExist(err) {
        fmt.Println("文件不存在")
    }

    // Hostname — 主机名
    host, _ := os.Hostname()
    fmt.Println("主机名:", host)

    // Exit — 退出程序
    // os.Exit(0) // 取消注释以退出

    // Args — 命令行参数
    fmt.Println("命令行参数:", os.Args)
}

官方文档：https://pkg.go.dev/os@go1.26.5

path/filepath — 文件路径操作

package main

import (
    "fmt"
    "path/filepath"
)

func main() {
    // Join — 拼接路径元素（最常用）
    path := filepath.Join("usr", "local", "bin", "go")
    fmt.Println("路径:", path) // usr/local/bin/go

    // Dir / Base — 目录和文件名
    fullPath := "/home/user/docs/file.txt"
    dir := filepath.Dir(fullPath)
    base := filepath.Base(fullPath)
    fmt.Printf("目录: %s, 文件名: %s\n", dir, base)

    // Ext — 文件扩展名
    ext := filepath.Ext("photo.jpg")
    fmt.Println("扩展名:", ext) // .jpg

    // Split — 分为目录和文件名
    d, f := filepath.Split(fullPath)
    fmt.Printf("Split: %q + %q\n", d, f)

    // Glob — 通配符匹配文件
    matches, _ := filepath.Glob("/usr/local/go/bin/*")
    for _, m := range matches[:3] {
        fmt.Println("匹配:", m)
    }

    // Walk — 遍历目录树
    err := filepath.WalkDir(".", func(path string, d os.DirEntry, err error) error {
        if err != nil {
            return err
        }
        if d.IsDir() {
            fmt.Printf("目录: %s\n", path)
        }
        return nil
    })
    if err != nil {
        fmt.Println("遍历错误:", err)
    }

    // Abs — 获取绝对路径
    abs, _ := filepath.Abs(".")
    fmt.Println("绝对路径:", abs)

    // Rel — 计算相对路径
    base2 := "/a/b"
    target := "/a/b/c/d/e"
    rel, _ := filepath.Rel(base2, target)
    fmt.Println("相对路径:", rel) // c/d/e

    // Match — 文件名匹配
    matched, _ := filepath.Match("*.go", "main.go")
    fmt.Println("匹配 *.go:", matched) // true

    // Clean — 清理路径（去除 . 和 ..）
    dirty := "/a/b/../c/./d"
    clean := filepath.Clean(dirty)
    fmt.Println("清理后:", clean) // /a/c/d
}

官方文档：https://pkg.go.dev/path/filepath@go1.26.5

flag — 命令行参数解析

package main

import (
    "flag"
    "fmt"
    "time"
)

func main() {
    // 定义命令行参数
    // 返回指针
    name := flag.String("name", "默认用户", "用户名（必填）")
    age := flag.Int("age", 18, "年龄")
    verbose := flag.Bool("v", false, "详细模式")
    delay := flag.Duration("timeout", 5*time.Second, "超时时间")

    // 绑定到已有变量
    var port int
    flag.IntVar(&port, "port", 8080, "服务端口")

    // 解析命令行参数
    flag.Parse()

    // 使用参数
    fmt.Printf("名称: %s\n", *name)
    fmt.Printf("年龄: %d\n", *age)
    fmt.Printf("详细模式: %v\n", *verbose)
    fmt.Printf("超时: %v\n", *delay)
    fmt.Printf("端口: %d\n", port)

    // 非 flag 参数
    fmt.Println("剩余参数:", flag.Args())

    // 自定义使用说明
    flag.Usage = func() {
        fmt.Printf("用法: %s [选项]\n", flag.CommandLine.Name())
        fmt.Println("选项:")
        flag.PrintDefaults()
    }

    // 子命令风格（通过 flagset）
    installCmd := flag.NewFlagSet("install", flag.ExitOnError)
    force := installCmd.Bool("force", false, "强制安装")
    _ = force
}

// 运行示例：
// go run main.go --name=张三 --age=30 -v --timeout=10s --port=9000 extra arg

官方文档：https://pkg.go.dev/flag@go1.26.5

embed — 文件嵌入（Go 1.16+）

package main

import (
    "embed"
    "fmt"
    "net/http"
)

//go:embed hello.txt
var helloText string

//go:embed hello.txt
var helloBytes []byte

//go:embed template/*.html
//go:embed static/*
var assets embed.FS

func main() {
    // 嵌入为字符串
    fmt.Println("嵌入的文本:", helloText)

    // 嵌入为字节切片
    fmt.Println("嵌入的字节:", string(helloBytes))

    // 嵌入为 FS — 支持目录
    data, _ := assets.ReadFile("hello.txt")
    fmt.Println("通过 FS 读取:", string(data))

    // 列出嵌入文件
    entries, _ := assets.ReadDir("template")
    for _, e := range entries {
        fmt.Println("嵌入的文件:", e.Name())
    }

    // HTTP 文件服务器 — 嵌入静态资源
    mux := http.NewServeMux()
    mux.Handle("/", http.FileServer(http.FS(assets)))
    fmt.Println("静态文件服务器已准备")
}

// 需要创建 hello.txt 文件并写入内容以运行

> 官方文档：https://pkg.go.dev/embed@go1.26.5

---

## sort — 排序


```go
package main

import (
    "fmt"
    "sort"
)

func main() {
    // Ints / Float64s / Strings — 基本类型排序
    sort.Ints([]int{5, 2, 6, 3, 1, 4})
    // 更推荐使用 slices.Sort (Go 1.21+)

    // Sort.Slice — 自定义排序（最常用）
    people := []struct{Name string; Age int}{
        {"Alice", 30}, {"Bob", 25}, {"Charlie", 35},
    }
    sort.Slice(people, func(i, j int) bool {
        return people[i].Age < people[j].Age
    })
    fmt.Println("按年龄排序:", people)

    // Search — 二分查找（在已排序切片中）
    nums := []int{1, 2, 3, 4, 5}
    idx := sort.Search(len(nums), func(i int) bool {
        return nums[i] >= 3
    })
    fmt.Println("3 的索引:", idx)

    // Sort + Reverse — 逆序
    sort.Sort(sort.Reverse(sort.IntSlice(nums)))
    fmt.Println("逆序:", nums)

    // Stable — 稳定排序
    sort.SliceStable(people, func(i, j int) bool {
        return people[i].Name < people[j].Name
    })
}

官方文档：https://pkg.go.dev/sort@go1.26.5

slices — 泛型切片操作（Go 1.21+）

package main

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

func main() {
    // Sort — 泛型排序
    nums := []int{5, 2, 6, 3, 1, 4}
    slices.Sort(nums)
    fmt.Println("排序后:", nums)

    // SortFunc — 自定义排序
    type Person struct{ Name string; Age int }
    people := []Person{{"Alice", 30}, {"Bob", 25}}
    slices.SortFunc(people, func(a, b Person) int {
        return cmp.Compare(a.Age, b.Age)
    })

    // BinarySearch — 二分查找
    idx, found := slices.BinarySearch(nums, 3)
    fmt.Printf("索引: %d, 找到: %v\n", idx, found)

    // Contains — 是否包含
    fmt.Println(slices.Contains([]string{"a", "b"}, "a")) // true

    // Clone — 浅拷贝
    cloned := slices.Clone(nums)

    // Delete — 删除元素
    s := []int{1, 2, 3, 4, 5}
    s = slices.Delete(s, 1, 3) // 删除索引1-2
    fmt.Println("删除后:", s)

    // Insert — 插入
    s2 := []int{1, 5}
    s2 = slices.Insert(s2, 1, 2, 3, 4)
    fmt.Println("插入后:", s2)

    // Compact — 去除连续重复
    fmt.Println(slices.Compact([]int{1, 1, 2, 2, 3})) // [1 2 3]

    // Reverse — 反转
    slices.Reverse(s2)

    // Max / Min
    fmt.Println("Max:", slices.Max([]int{3, 7, 2, 9}))

    // Chunk — 分块迭代（Go 1.26+）
    for chunk := range slices.Chunk([]int{1, 2, 3, 4, 5}, 2) {
        fmt.Println("块:", chunk)
    }
}

官方文档：https://pkg.go.dev/slices@go1.26.5

maps — 泛型 Map 操作（Go 1.21+）

package main

import (
    "fmt"
    "maps"
)

func main() {
    // Clone — 浅拷贝
    m1 := map[string]int{"a": 1, "b": 2}
    m2 := maps.Clone(m1)

    // Copy — 复制到另一个 map
    dest := map[string]int{}
    maps.Copy(dest, m1)

    // Equal — 比较
    fmt.Println(maps.Equal(m1, m2)) // true

    // DeleteFunc — 条件删除
    m := map[string]int{"a": 1, "b": 2, "c": 3}
    maps.DeleteFunc(m, func(k string, v int) bool {
        return v%2 == 0
    })
    fmt.Println("删除偶数后:", m)

    // Keys / Values — 迭代器（Go 1.23+）
    for k := range maps.Keys(m1) {
        fmt.Println("key:", k)
    }
}

官方文档：https://pkg.go.dev/maps@go1.26.5

container/heap — 堆

package main

import (
    "container/heap"
    "fmt"
)

type MinHeap []int

func (h MinHeap) Len() int           { return len(h) }
func (h MinHeap) Less(i, j int) bool { return h[i] < h[j] }
func (h MinHeap) Swap(i, j int)      { h[i], h[j] = h[j], h[i] }
func (h *MinHeap) Push(x any)        { *h = append(*h, x.(int)) }
func (h *MinHeap) Pop() any {
    old := *h; n := len(old); x := old[n-1]
    *h = old[:n-1]; return x
}

func main() {
    h := &MinHeap{3, 1, 4, 1, 5}
    heap.Init(h)
    heap.Push(h, 2)

    for h.Len() > 0 {
        fmt.Printf("%d ", heap.Pop(h))
    } // 1 1 2 3 4 5
}

官方文档：https://pkg.go.dev/container/heap@go1.26.5

container/list — 双向链表

package main

import (
    "container/list"
    "fmt"
)

func main() {
    l := list.New()
    l.PushBack("a")
    l.PushFront("b")
    l.PushBack("c")

    for e := l.Front(); e != nil; e = e.Next() {
        fmt.Println(e.Value)
    }
    fmt.Println("长度:", l.Len())
}

官方文档：https://pkg.go.dev/container/list@go1.26.5

container/ring — 环形链表

package main

import (
    "container/ring"
    "fmt"
)

func main() {
    r := ring.New(3)
    for i := 0; i < r.Len(); i++ {
        r.Value = i
        r = r.Next()
    }
    r.Do(func(p any) { fmt.Println(p) })
}

官方文档：https://pkg.go.dev/container/ring@go1.26.5

encoding/json — JSON 编解码

package main

import (
    "encoding/json"
    "fmt"
    "strings"
)

type User struct {
    ID    int      `json:"id"`
    Name  string   `json:"name"`
    Email string   `json:"email,omitempty"`
    Tags  []string `json:"tags,omitempty"`
}

func main() {
    // Marshal — 编码为 JSON
    u := User{ID: 1, Name: "Alice", Email: "a@b.com"}
    data, _ := json.Marshal(u)
    fmt.Println("JSON:", string(data))

    // Unmarshal — 解码
    var u2 User
    json.Unmarshal([]byte(`{"id":2,"name":"Bob"}`), &u2)
    fmt.Printf("解码: %+v\n", u2)

    // 解码到 map（动态 JSON）
    var m map[string]any
    json.Unmarshal([]byte(`{"name":"Charlie","age":30}`), &m)
    fmt.Println("Map:", m["name"], m["age"])

    // Decoder — 流式解码（适合大 JSON / HTTP 流）
    dec := json.NewDecoder(strings.NewReader(`{"x":1}{"x":2}`))
    for {
        var v map[string]int
        if err := dec.Decode(&v); err != nil {
            break
        }
        fmt.Println("流式:", v)
    }

    // RawMessage — 延迟解析
    raw := json.RawMessage(`{"key":"value"}`)
    fmt.Println("原始:", string(raw))
}

官方文档：https://pkg.go.dev/encoding/json@go1.26.5

encoding/csv — CSV 读写

package main

import (
    "encoding/csv"
    "fmt"
    "strings"
)

func main() {
    // 写入 CSV
    var buf strings.Builder
    w := csv.NewWriter(&buf)
    w.Write([]string{"name", "age", "city"})
    w.Write([]string{"Alice", "30", "Beijing"})
    w.Write([]string{"Bob", "25", "Shanghai"})
    w.Flush()

    fmt.Println("CSV 输出:\n", buf.String())

    // 读取 CSV
    r := csv.NewReader(strings.NewReader(buf.String()))
    records, _ := r.ReadAll()
    for _, record := range records {
        fmt.Println("记录:", record)
    }
}

官方文档：https://pkg.go.dev/encoding/csv@go1.26.5

encoding/xml — XML 编解码

package main

import (
    "encoding/xml"
    "fmt"
)

type Person struct {
    XMLName xml.Name `xml:"person"`
    Name    string   `xml:"name"`
    Age     int      `xml:"age,attr"` // 属性
}

func main() {
    p := Person{Name: "Alice", Age: 30}
    data, _ := xml.MarshalIndent(p, "", "  ")
    fmt.Println("XML:", string(data))

    var p2 Person
    xml.Unmarshal([]byte(`<person age="25"><name>Bob</name></person>`), &p2)
    fmt.Printf("%+v\n", p2)
}

官方文档：https://pkg.go.dev/encoding/xml@go1.26.5

encoding/base64 — Base64 编解码

package main

import (
    "encoding/base64"
    "fmt"
)

func main() {
    data := []byte("hello world")

    // 标准 Base64（末尾带 = 填充）
    s := base64.StdEncoding.EncodeToString(data)
    fmt.Println("标准:", s)

    decoded, _ := base64.StdEncoding.DecodeString(s)
    fmt.Println("解码:", string(decoded))

    // URL 安全的 Base64（替换 +/= 为 URL 安全字符）
    u := base64.URLEncoding.EncodeToString(data)
    fmt.Println("URL 安全:", u)

    // 无填充（适合 JWT）
    r := base64.RawStdEncoding.EncodeToString(data)
    fmt.Println("无填充:", r)

    // RawURLEncoding（JWT 标准）
    jwt := base64.RawURLEncoding.EncodeToString(data)
    fmt.Println("JWT:", jwt)
}

官方文档：https://pkg.go.dev/encoding/base64@go1.26.5

encoding/hex — 十六进制编解码

package main

import (
    "encoding/hex"
    "fmt"
)

func main() {
    data := []byte("hello")
    encoded := hex.EncodeToString(data)
    fmt.Println("十六进制:", encoded) // 68656c6c6f

    decoded, _ := hex.DecodeString(encoded)
    fmt.Println("解码:", string(decoded))

    // Dump — 带格式的调试输出
    dump := hex.Dump([]byte("Hello Go Standard Library!"))
    fmt.Println("Dump:\n", dump)
}

官方文档：https://pkg.go.dev/encoding/hex@go1.26.5