Go 语言常用标准库详解

Go 语言常用标准库详解

一、基础类型与工具

fmt --- 格式化 I/O

fmt.Println("hello")
fmt.Printf("name: %s, age: %d\n", "tom", 18)
fmt.Sprintf("%04d", 42)          // 格式化到字符串
fmt.Errorf("failed: %w", err)    // 错误包装

核心三件套：Print/Sprintf/Fprintf，支持 %v（默认）、%+v（结构体带字段名）、%#v（Go 语法表示）。

strings --- 字符串操作

strings.Contains(s, "sub")
strings.HasPrefix(s, "http")
strings.Split(s, ",")
strings.Join([]string{"a","b"}, "-")
strings.TrimSpace(s)
strings.ReplaceAll(s, old, new)
strings.Builder{}                 // 高性能拼接

strconv --- 类型转换

strconv.Atoi("123")              // string → int
strconv.Itoa(123)                // int → string
strconv.ParseFloat("3.14", 64)
strconv.FormatBool(true)
strconv.ParseInt("0xff", 16, 64) // 带进制

regexp --- 正则表达式

re := regexp.MustCompile(`\d+`)
re.FindAllString(s, -1)
re.MatchString(s)
re.ReplaceAllString(s, "NUM")

---

二、容器与集合

map（内置）& slices（Go 1.21+）

// map
m := make(map[string]int)
m["key"] = 1
delete(m, "key")

// slices 泛型工具（Go 1.21）
import "slices"
slices.Sort([]int{3,1,2})
slices.Contains(s, target)
slices.Reverse(s)
slices.Compact(s)                // 去重相邻重复

container --- 专用数据结构

// container/list --- 双向链表
list.New()
l.PushBack(1)
l.Front()

// container/heap --- 优先队列（需实现 heap.Interface）
// container/ring --- 环形链表

---

三、I/O 与文件操作

os --- 系统调用入口

os.Open("file.txt")              // 只读打开
os.Create("out.txt")             // 创建/截断
os.ReadFile("data.json")         // 读取全部
os.WriteFile("out.txt", data, 0644)
os.MkdirAll("a/b/c", 0755)
os.Getenv("HOME")
os.Args                          // 命令行参数
os.Exit(1)

io --- I/O 原语

io.Copy(dst, src)                // 流式拷贝（核心）
io.ReadAll(r)                    // 读取全部
io.MultiReader(r1, r2)           // 合并多个 Reader
io.LimitReader(r, 1024)          // 限制读取量
io.TeeReader(r, w)               // 读取同时写入

bufio --- 缓冲 I/O

scanner := bufio.NewScanner(file)
for scanner.Scan() {             // 逐行读取
    line := scanner.Text()
}

writer := bufio.NewWriter(file)
writer.WriteString("line\n")
writer.Flush()                   // 别忘了 Flush！

filepath --- 路径操作

filepath.Join("a", "b", "c.txt")    // 跨平台路径拼接
filepath.Ext("file.txt")            // ".txt"
filepath.Base("/a/b/c.txt")         // "c.txt"
filepath.Dir("/a/b/c.txt")          // "/a/b"
filepath.Glob("*.go")               // 通配符匹配

---

四、编码与序列化

encoding/json --- JSON

// 序列化
data, _ := json.Marshal(obj)
data, _ := json.MarshalIndent(obj, "", "  ")  // 美化

// 反序列化
json.Unmarshal(data, &obj)

// 流式处理（大文件友好）
dec := json.NewDecoder(file)
enc := json.NewEncoder(file)

// 结构体标签
type User struct {
    Name string `json:"name,omitempty"`
    Age  int    `json:"age,string"`
}

encoding/xml、encoding/csv、encoding/base64

// CSV
reader := csv.NewReader(file)
records, _ := reader.ReadAll()

// Base64
encoded := base64.StdEncoding.EncodeToString(data)
decoded, _ := base64.StdEncoding.DecodeString(encoded)

---

五、网络

net/http --- HTTP 客户端/服务端

// 服务端
http.HandleFunc("/api", func(w http.ResponseWriter, r *http.Request) {
    json.NewEncoder(w).Encode(map[string]string{"status": "ok"})
})
http.ListenAndServe(":8080", nil)

// 客户端
resp, err := http.Get("https://api.example.com/data")
defer resp.Body.Close()
body, _ := io.ReadAll(resp.Body)

// 带超时和 Context 的客户端
client := &http.Client{Timeout: 10 * time.Second}
req, _ := http.NewRequestWithContext(ctx, "GET", url, nil)

net/url --- URL 解析

u, _ := url.Parse("https://example.com/path?q=1")
u.Query().Get("q")
url.Values{"key": []string{"val"}}.Encode()

net/rpc、net（TCP/UDP）

listener, _ := net.Listen("tcp", ":9000")
conn, _ := net.Dial("tcp", "localhost:9000")

---

六、并发

sync --- 同步原语

var mu sync.Mutex
mu.Lock()
defer mu.Unlock()

var rw sync.RWMutex
rw.RLock()                      // 读锁（多个读者可并发）
rw.RUnlock()

sync.Once{}                     // 只执行一次
sync.WaitGroup{}                // 等待一组 goroutine 完成
sync.Pool{}                     // 对象池，减少 GC 压力

context --- 请求生命周期管理

// 传播超时、取消信号、请求级值
ctx, cancel := context.WithTimeout(ctx, 5*time.Second)
defer cancel()

ctx, cancel := context.WithCancel(parentCtx)

// 传值（不要滥用）
ctx = context.WithValue(ctx, "requestID", "abc123")

channel（内置）--- goroutine 通信

ch := make(chan int, 10)        // 带缓冲
ch <- 1                         // 发送
v := <-ch                       // 接收
select {                        // 多路复用
case v := <-ch:
case <-time.After(time.Second):
case <-ctx.Done():
}

---

七、时间

time --- 时间与定时器

now := time.Now()
t, _ := time.Parse("2006-01-02", "2024-01-01")
t.Format("2006-01-02 15:04:05") // Go 的日期模板是固定数字

time.Sleep(2 * time.Second)
time.AfterFunc(5*time.Second, func() { ... })  // 延迟执行

ticker := time.NewTicker(1 * time.Second)
for range ticker.C { ... }

---

八、测试与诊断

testing --- 单元测试与基准测试

func TestAdd(t *testing.T) {
    if add(1, 2) != 3 {
        t.Errorf("expected 3, got %d", add(1, 2))
    }
}

func BenchmarkAdd(b *testing.B) {
    for i := 0; i < b.N; i++ {
        add(1, 2)
    }
}
// go test -bench=. -cover

log & log/slog（Go 1.21+ 结构化日志）

slog.Info("user login", "user_id", uid, "ip", ip)
slog.Error("db failed", "err", err)
// 支持 JSON/Text 输出，可自定义 Handler

---

九、错误处理

errors --- 错误创建与检查

errors.New("something failed")
errors.Is(err, targetErr)        // 错误链匹配
errors.As(err, &target)          // 类型断言
errors.Unwrap(err)               // 解包
fmt.Errorf("context: %w", err)   // 包装（%w 保留类型）

---

十、其他高频库

库	用途
os/exec	执行外部命令
flag	命令行参数解析
math/rand / crypto/rand	随机数（安全场景用 crypto）
sort	排序（1.21+ 被 slices 覆盖大部分场景）
math/big	大整数/高精度浮点
crypto/tls	TLS 配置
crypto/sha256	哈希摘要
runtime	GC 控制、goroutine 数量、CPU 核数
reflect	运行时反射（性能敏感场景慎用）
text/template	模板引擎
database/sql	SQL 数据库接口（配合驱动如 pq、mysql）
embed（Go 1.16+）	编译时嵌入静态文件

---

最佳实践速查

1. 错误处理 ：永远 if err != nil，用 %w 包装保持错误链
2. Context 优先 ：HTTP handler、数据库调用、RPC 请求都传 ctx
3. io.Copy 万能：文件拷贝、响应体转发，一行搞定
4. defer 及时释放 ：文件、锁、响应体都要 defer Close/Unlock
5. strings.Builder 拼接字符串，比 + 拼接性能好
6. sync.Pool 用于高频创建销毁的对象（如 []byte 缓冲区）
7. Go 1.21+ 优先用 slices、maps、log/slog 等新泛型库