Go 标准库速览

// 核心接口（组合自这些基本接口）
type Reader interface { Read(p []byte) (n int, err error) }
type Writer interface { Write(p []byte) (n int, err error) }
type Closer interface { Close() error }
type Seeker interface { Seek(offset int64, whence int) (int64, error) }

// 组合接口
type ReadWriter interface { Reader; Writer }
type ReadCloser interface { Reader; Closer }
type WriteCloser interface { Writer; Closer }
type ReadWriteCloser interface { Reader; Writer; Closer }
type ReadSeeker interface { Reader; Seeker }

// os.ReadFile / os.WriteFile：简化全部读入/写出
data, err := os.ReadFile("config.yaml")
err := os.WriteFile("output.txt", data, 0644)

// io.ReadAll：全部读入
data, err := io.ReadAll(reader)

// io.Copy：流式复制
written, err := io.Copy(dst, src)

// io.NopCloser：给 Reader 包装一个空 Close
r := io.NopCloser(strings.NewReader("data"))

// io.TeeReader：读取时同时写入另一个 Writer
tee := io.TeeReader(reader, writer)

before, after, found := strings.CutLast("a.b.c", ".")
// before="a.b", after="c", found=true
// sep 不存在时返回 (s, "", false)，与 Cut 的约定一致

// JSON 常用模式
type Config struct {
    Host string `json:"host"`
    Port int    `json:"port,omitempty"`
    Mode string `json:"mode,omitempty"`
}

data, _ := json.Marshal(config)                    // 结构体 → JSON
json.Unmarshal(data, &config)                      // JSON → 结构体

// json.NewDecoder：流式解码（http body、大文件）
decoder := json.NewDecoder(resp.Body)
decoder.Decode(&config)

// 美化输出
data, _ := json.MarshalIndent(config, "", "  ")

// 基本 HTTP Server
http.HandleFunc("/api", func(w http.ResponseWriter, r *http.Request) {
    w.Header().Set("Content-Type", "application/json")
    w.WriteHeader(http.StatusOK)
    json.NewEncoder(w).Encode(response)
})
http.ListenAndServe(":8080", nil)

// HTTP Client（Go 1.16+ 推荐用 context）
ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
defer cancel()

req, _ := http.NewRequestWithContext(ctx, "GET", url, nil)
req.Header.Set("Authorization", "Bearer "+token)
resp, err := http.DefaultClient.Do(req)
if err != nil { return err }
defer resp.Body.Close()

body, _ := io.ReadAll(resp.Body)

t := time.Now()
t.Format("2006-01-02 15:04:05")   // Go 的参考时间是 Mon Jan 2 15:04:05 MST 2006
t, _ = time.Parse("2006-01-02", "2024-12-31")

// Duration 运算
time.Sleep(100 * time.Millisecond)
d := time.Since(t)                // 时间间隔

// Timer / Ticker
timer := time.NewTimer(5 * time.Second)
<-timer.C                         // 等待 5 秒

ticker := time.NewTicker(1 * time.Second)
for t := range ticker.C { ... }   // 每秒触发
ticker.Stop()

// 定时执行：Tick 适合"与进程同寿命"的全局周期任务
go func() {
    for range time.Tick(1 * time.Minute) {
        doTask()
    }
}()

// 单元测试
func TestAdd(t *testing.T) {
    got := Add(1, 2)
    want := 3
    if got != want {
        t.Errorf("Add(1, 2) = %d, want %d", got, want)
    }
}

// 表驱动测试（Go 惯用法）
func TestAdd(t *testing.T) {
    tests := []struct {
        name     string
        a, b, want int
    }{
        {"positive", 1, 2, 3},
        {"negative", -1, -2, -3},
        {"zero", 0, 0, 0},
    }
    for _, tt := range tests {
        t.Run(tt.name, func(t *testing.T) {
            if got := Add(tt.a, tt.b); got != tt.want {
                t.Errorf("got %d, want %d", got, tt.want)
            }
        })
    }
}

// 基准测试
func BenchmarkAdd(b *testing.B) {
    for i := 0; i < b.N; i++ {
        Add(1, 2)
    }
}

// Fuzz 测试（Go 1.18+）
func FuzzAdd(f *testing.F) {
    f.Add(1, 2)
    f.Fuzz(func(t *testing.T, a, b int) {
        Add(a, b)
    })
}

// Go 1.27：httptest.NewTestServer 跑在内存假网络上，专为 testing/synctest 气泡设计，
// 不起真实端口、不吃真实时钟，用法与 NewServer 一致（srv.URL / srv.Client()）
func TestFetch(t *testing.T) {
    synctest.Test(t, func(t *testing.T) {
        srv := httptest.NewTestServer(t, handler)      // handler 传 nil 则一律回 500
        resp, err := srv.Client().Get(srv.URL)
        if err != nil {
            t.Fatal(err)
        }
        defer resp.Body.Close()
    })
}

// 运行
// go test ./...                      运行所有测试
// go test -run TestAdd              运行指定测试
// go test -bench=. -benchmem        基准测试 + 内存分析
// go test -fuzz=FuzzAdd             运行 fuzz 测试
// go test -coverprofile=cover.out   生成覆盖率
// go tool cover -html=cover.out     覆盖率可视化

// slog 结构化日志（Go 1.21+）
logger := slog.New(slog.NewJSONHandler(os.Stdout, nil))
logger.Info("request processed",
    slog.String("method", "GET"),
    slog.Int("status", 200),
    slog.Duration("latency", 10*time.Millisecond),
)
// {"time":"2024-01-01T00:00:00Z","level":"INFO","msg":"request processed","method":"GET","status":200,"latency":"10ms"}

// Go 1.20+：无需手动 Seed
n := rand.Intn(100)               // 0 ≤ n < 100
f := rand.Float64()               // 0.0 ≤ f < 1.0

// 加密安全的随机数
import "crypto/rand"
b := make([]byte, 32)
rand.Read(b)

// math/rand/v2（Go 1.22+）：新代码推荐；Go 1.27 起泛型函数 N 同时提供方法版 (*Rand).N
vr := rand.New(rand.NewPCG(1, 2))
vr.IntN(100)              // int，0 ≤ n < 100
u8 := vr.N[uint8](7)      // 方法版 N，任意整数类型按需（n ≤ 0 会 panic）
_ = u8

// gzip 写入
var buf bytes.Buffer
w := gzip.NewWriter(&buf)
w.Write([]byte("hello"))
w.Close()

// gzip 读取
r, _ := gzip.NewReader(&buf)
data, _ := io.ReadAll(r)
fmt.Println(string(data))          // hello

// SHA256
h := sha256.Sum256([]byte("hello"))
fmt.Printf("%x\n", h)

// 流式
hasher := sha256.New()
hasher.Write([]byte("hello"))
hasher.Write([]byte(" world"))
hash := hasher.Sum(nil)

import (
    "database/sql"
    _ "github.com/lib/pq"          // 仅执行 init() 注册驱动
)

db, err := sql.Open("postgres", dsn)
defer db.Close()

// 查询单行
var name string
err = db.QueryRowContext(ctx, "SELECT name FROM users WHERE id=$1", id).Scan(&name)

// 查询多行
rows, err := db.QueryContext(ctx, "SELECT id, name FROM users")
defer rows.Close()
for rows.Next() {
    var id int
    var name string
    rows.Scan(&id, &name)
}

// 事务
tx, err := db.BeginTx(ctx, nil)
_, err = tx.ExecContext(ctx, "UPDATE users SET name=$1 WHERE id=$2", name, id)
tx.Commit()  // 或 tx.Rollback()