本章深入解析Go语言核心标准库的关键功能与生产级应用技巧，结合性能优化与安全实践，提供高效开发指南。

10.1 fmt/io/os

10.1.1 fmt高级格式化

// 结构化输出
fmt.Printf("%+v\n", user)     // 输出结构体字段名
fmt.Printf("%#v\n", user)     // 输出Go语法表示

// 自定义格式（实现fmt.Formatter接口）
type Point struct{ X, Y int }
func (p Point) Format(f fmt.State, verb rune) {
    fmt.Fprintf(f, "(%d, %d)", p.X, p.Y)
}

// 输出：(10, 20)

10.1.2 高效IO操作

// 使用bufio提升读写性能
file, _ := os.Open("data.log")
defer file.Close()

scanner := bufio.NewScanner(file)
for scanner.Scan() {
    process(scanner.Text())
}

// 零拷贝文件复制
src, _ := os.Open("source.txt")
dst, _ := os.Create("dest.txt")
defer src.Close()
defer dst.Close()

io.Copy(dst, src)  // 比ioutil.ReadAll更高效

10.1.3 文件系统操作

// 原子文件写入
tmpFile := "data.tmp"
finalFile := "data.txt"
os.WriteFile(tmpFile, data, 0644)
os.Rename(tmpFile, finalFile)

// 目录遍历
filepath.WalkDir(".", func(path string, d fs.DirEntry, err error) error {
    if !d.IsDir() {
        fmt.Println(path)
    }
    return nil
})

10.2 strings/strconv

10.2.1 高性能字符串处理

// 使用strings.Builder拼接字符串
var sb strings.Builder
sb.Grow(1024)  // 预分配内存
for _, s := range []string{"a","b","c"} {
    sb.WriteString(s)
}
result := sb.String()

// 内存复用优化
var buf []byte
buf = append(buf, "hello"...)
buf = append(buf, "world"...)
str := string(buf)

10.2.2 类型转换安全实践

// 安全数字转换
num, err := strconv.ParseInt("42", 10, 64)
if err != nil {
    log.Fatal(err)
}

// 高效转换
str := strconv.Itoa(1024)  // 比fmt.Sprintf快3倍

10.3 time

10.3.1 时区处理规范

// 始终使用Location处理时间
loc, _ := time.LoadLocation("Asia/Shanghai")
t := time.Date(2023, 10, 1, 0, 0, 0, 0, loc)

// 时间解析标准格式
layout := "2006-01-02 15:04:05"  // Go的参考时间格式
ts, _ := time.Parse(layout, "2023-10-01 12:00:00")

10.3.2 性能敏感场景优化

// 复用时间对象
var timerPool = sync.Pool{
    New: func() interface{} { return time.NewTimer(0) },
}

func getTimer(d time.Duration) *time.Timer {
    t := timerPool.Get().(*time.Timer)
    t.Reset(d)
    return t
}

10.4 math/rand

10.4.1 安全随机数生成

// 使用crypto/rand生成安全随机数
import "crypto/rand"

buf := make([]byte, 16)
rand.Read(buf)  // 适合密钥生成

// 高性能伪随机
r := rand.New(rand.NewSource(time.Now().UnixNano()))
num := r.Intn(100)

10.4.2 并发安全方案

var (
    mu sync.Mutex
    r  = rand.New(rand.NewSource(42))
)

func safeRand() int {
    mu.Lock()
    defer mu.Unlock()
    return r.Intn(100)
}

10.5 encoding/json

10.5.1 高性能序列化

// 使用json.Encoder优化大文件输出
file, _ := os.Create("data.json")
enc := json.NewEncoder(file)
enc.SetEscapeHTML(false)  // 禁用HTML转义
enc.Encode(data)

// 自定义序列化逻辑
type CustomTime time.Time
func (ct *CustomTime) MarshalJSON() ([]byte, error) {
    return []byte(`"` + time.Time(*ct).Format(time.RFC3339) + `"`), nil
}

10.5.2 流式处理

dec := json.NewDecoder(resp.Body)
for dec.More() {
    var item Data
    if err := dec.Decode(&item); err != nil {
        break
    }
    process(item)
}

10.6 net/http

10.6.1 高性能服务端

// 复用连接池
client := &http.Client{
    Transport: &http.Transport{
        MaxIdleConns:        100,
        MaxIdleConnsPerHost: 20,
        IdleConnTimeout:     90 * time.Second,
    },
    Timeout: 10 * time.Second,
}

// 中间件链
func loggingMiddleware(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        start := time.Now()
        next.ServeHTTP(w, r)
        log.Printf("%s %s %v", r.Method, r.URL.Path, time.Since(start))
    })
}

10.6.2 客户端最佳实践

// 带超时的请求
ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
defer cancel()

req, _ := http.NewRequestWithContext(ctx, "GET", url, nil)
resp, err := client.Do(req)

10.7 database/sql

10.7.1 连接池配置

db, _ := sql.Open("mysql", dsn)
db.SetMaxOpenConns(25)        // 最大连接数
db.SetMaxIdleConns(10)        // 最大空闲连接
db.SetConnMaxLifetime(5*time.Minute)  // 连接最大存活时间

// 预处理语句复用
stmt, _ := db.Prepare("SELECT * FROM users WHERE id=?")
defer stmt.Close()

10.7.2 事务处理规范

tx, err := db.BeginTx(ctx, &sql.TxOptions{
    Isolation: sql.LevelReadCommitted,
    ReadOnly:  false,
})
defer func() {
    if err != nil {
        tx.Rollback()
    }
}()

_, err = tx.Exec("UPDATE accounts SET balance=?", newBalance)
if err != nil {
    return err
}
return tx.Commit()

总结

本章系统梳理了Go标准库的核心功能与生产级应用技巧，重点包含：

1. IO性能优化的零拷贝与缓冲技术
2. 时间处理的时区安全实践
3. JSON序列化的高效流式处理
4. HTTP服务的连接池调优策略
5. 数据库操作的防注入与事务管理

关键原则：

• 优先使用标准库提供的并发安全实现
• 资源密集型操作（文件/网络/DB）必须处理超时和取消
• 敏感数据操作（随机数/序列化）需考虑安全因素

建议通过以下实践巩固知识：

• 实现一个支持百万级并发的HTTP代理服务
• 开发支持事务回滚的数据库迁移工具
• 构建高性能的JSON日志处理流水线
• 对比不同字符串拼接方法的性能差异