Go on 纪伟的个人博客

Go 学习笔记（七）：进阶特性

Tue, 05 May 2026 16:00:00 +0800

写在前面

本文是 Go 学习笔记系列的第七篇，介绍 Go 的进阶特性：泛型、反射、逃逸分析和性能分析工具。前置知识：标准库与工程实践（第六篇）。

一、泛型（Go 1.18+）

1.1 泛型函数

// 泛型函数：支持多种类型
func Print[T any](value T) {
    fmt.Println(value)
}

Print(42)          // int
Print("hello")     // string
Print(3.14)        // float64

// 带约束的泛型
func Sum[T int | float64](nums []T) T {
    var total T
    for _, n := range nums {
        total += n
    }
    return total
}

Sum([]int{1, 2, 3})        // 6
Sum([]float64{1.1, 2.2})   // 3.3

1.2 类型约束

// 自定义类型约束
type Number interface {
    int | int8 | int16 | int32 | int64 |
    float32 | float64
}

func Max[T Number](a, b T) T {
    if a > b {
        return a
    }
    return b
}

// comparable 约束（可比较的类型，支持 == 和 !=）
func Contains[T comparable](slice []T, target T) bool {
    for _, v := range slice {
        if v == target {
            return true
        }
    }
    return false
}

1.3 泛型切片工具

// 通用的 Map 函数（对切片每个元素做变换）
func Map[T any, U any](slice []T, fn func(T) U) []U {
    result := make([]U, len(slice))
    for i, v := range slice {
        result[i] = fn(v)
    }
    return result
}

// 通用的 Filter 函数
func Filter[T any](slice []T, fn func(T) bool) []T {
    var result []T
    for _, v := range slice {
        if fn(v) {
            result = append(result, v)
        }
    }
    return result
}

// 使用
nums := []int{1, 2, 3, 4, 5}
doubled := Map(nums, func(n int) int { return n * 2 })       // [2 4 6 8 10]
evens := Filter(nums, func(n int) bool { return n%2 == 0 })  // [2 4]

1.4 泛型结构体

// 泛型栈
type Stack[T any] struct {
    items []T
}

func (s *Stack[T]) Push(item T) {
    s.items = append(s.items, item)
}

func (s *Stack[T]) Pop() (T, bool) {
    if len(s.items) == 0 {
        var zero T
        return zero, false
    }
    top := s.items[len(s.items)-1]
    s.items = s.items[:len(s.items)-1]
    return top, true
}

func (s *Stack[T]) Len() int {
    return len(s.items)
}

// 使用
stack := Stack[int]{}
stack.Push(1)
stack.Push(2)
v, _ := stack.Pop()   // 2

二、反射（reflect）

反射用于在运行时检查类型信息，主要场景：JSON 序列化、ORM、通用框架。

2.1 基本用法

import "reflect"

type User struct {
    Name string `json:"name"`
    Age  int    `json:"age"`
}

user := User{Name: "张三", Age: 25}

// 获取类型信息
t := reflect.TypeOf(user)
fmt.Println(t.Name())    // User
fmt.Println(t.Kind())    // struct

// 获取值信息
v := reflect.ValueOf(user)
fmt.Println(v.Kind())    // struct

// 遍历结构体字段
for i := 0; i < t.NumField(); i++ {
    field := t.Field(i)
    value := v.Field(i)
    fmt.Printf("%s (%s) = %v, tag=%s\n",
        field.Name, field.Type, value.Interface(), field.Tag.Get("json"))
}
// Name (string) = 张三, tag=name
// Age (int) = 25, tag=age

2.2 修改值

// 必须传指针才能修改
user := User{Name: "张三"}
v := reflect.ValueOf(&user).Elem()

// 修改字段
nameField := v.FieldByName("Name")
nameField.SetString("李四")
fmt.Println(user.Name)   // 李四

2.3 调用方法

type Calculator struct{}

func (c Calculator) Add(a, b int) int {
    return a + b
}

c := Calculator{}
v := reflect.ValueOf(c)
method := v.MethodByName("Add")

args := []reflect.Value{reflect.ValueOf(1), reflect.ValueOf(2)}
results := method.Call(args)
fmt.Println(results[0].Int())   // 3

反射的代价：反射比直接调用慢很多，可读性也差。能用泛型替代的就不要用反射。

三、闭包进阶

3.1 闭包捕获变量

func counter(start int) func() int {
    count := start
    return func() int {
        count++
        return count
    }
}

c := counter(0)
fmt.Println(c())   // 1
fmt.Println(c())   // 2
fmt.Println(c())   // 3

// 独立的闭包，互不影响
c2 := counter(100)
fmt.Println(c2())  // 101

3.2 闭包的常见用法

// 中间件模式
func withLogging(fn http.HandlerFunc) http.HandlerFunc {
    return func(w http.ResponseWriter, r *http.Request) {
        start := time.Now()
        fn(w, r)
        log.Printf("%s %s %v", r.Method, r.URL.Path, time.Since(start))
    }
}

// 延迟计算
func lazyCompute(fn func() int) func() int {
    var result int
    var computed bool
    return func() int {
        if !computed {
            result = fn()
            computed = true
        }
        return result
    }
}

四、内存与逃逸分析

4.1 栈和堆

1
2

栈 — 分配释放快，函数结束时自动回收
堆 — 需要 GC 回收，分配和回收都有开销

Go 编译器会自动决定变量分配在栈还是堆（逃逸分析）：

4.2 逃逸到堆的情况

// 1. 返回局部变量的指针
func newUser() *User {
    u := User{Name: "张三"}
    return &u   // u 逃逸到堆
}

// 2. 发送到 channel
func sendToChannel(ch chan *User) {
    u := User{Name: "张三"}
    ch <- &u   // u 逃逸到堆
}

// 3. 在闭包中引用
func closure() func() int {
    x := 0
    return func() int {
        x++      // x 逃逸到堆
        return x
    }
}

// 4. 接口类型
func print(v interface{}) {
    fmt.Println(v)  // v 可能逃逸
}

// 5. 切片扩容
s := make([]int, 0)
for i := 0; i < 10000; i++ {
    s = append(s, i)  // 可能多次扩容，逃逸到堆
}

4.3 查看逃逸分析

# 编译时查看逃逸分析
go build -gcflags="-m" main.go

# 更详细的输出
go build -gcflags="-m -m" main.go

# 输出示例：
# ./main.go:5:6: &u escapes to heap
# ./main.go:5:6: moved to heap: u

4.4 减少逃逸的技巧

// 不好的写法：返回指针
func createUser() *User {
    return &User{Name: "张三"}
}

// 好的写法：返回值类型
func createUser() User {
    return User{Name: "张三"}
}

// 不好的写法：频繁使用 interface{}
func process(v interface{}) { }

// 好的写法：使用泛型（Go 1.18+）
func process[T any](v T) { }

// 预分配切片容量，避免扩容
s := make([]int, 0, 1000)   // 一步到位

五、性能分析（pprof）

5.1 CPU 分析

import "runtime/pprof"

func main() {
    // 创建 CPU profile 文件
    f, err := os.Create("cpu.prof")
    if err != nil {
        log.Fatal(err)
    }
    defer f.Close()

    // 开始 CPU profiling
    pprof.StartCPUProfile(f)
    defer pprof.StopCPUProfile()

    // 你的业务代码
    doWork()
}

# 分析 CPU profile
go tool pprof cpu.prof

# 常用 pprof 交互命令：
# top       — 显示最耗 CPU 的函数
# top 20    — 显示前20个
# list func — 显示某函数的代码和耗时
# web       — 生成可视化图表（需要安装 graphviz）

# 或者用 Web UI 查看
go tool pprof -http=:8080 cpu.prof

5.2 内存分析

func main() {
    doWork()

    // 写入内存 profile
    f, _ := os.Create("mem.prof")
    defer f.Close()
    runtime.GC()               // 先触发 GC
    pprof.WriteHeapProfile(f)
}

1
2
3

# 分析内存 profile
go tool pprof mem.prof
go tool pprof -http=:8080 mem.prof

5.3 HTTP 服务中集成 pprof

import _ "net/http/pprof"

func main() {
    // 只需 import pprof，然后启动 HTTP 服务
    // 访问 http://localhost:8080/debug/pprof/ 即可
    go func() {
        log.Println(http.ListenAndServe("localhost:6060", nil))
    }()

    // 你的业务代码...
}

# 远程分析运行中的服务
go tool pprof http://localhost:6060/debug/pprof/profile?seconds=30   # CPU
go tool pprof http://localhost:6060/debug/pprof/heap                 # 内存
go tool pprof http://localhost:6060/debug/pprof/goroutine            # goroutine

5.4 benchmark 生成 profile

# 生成 CPU profile
go test -bench=. -cpuprofile=cpu.prof

# 生成内存 profile
go test -bench=. -memprofile=mem.prof

# 分析
go tool pprof cpu.prof

六、代码优化技巧

6.1 减少内存分配

// 使用 sync.Pool 复用对象
var bufPool = sync.Pool{
    New: func() any {
        return new(bytes.Buffer)
    },
}

func process() {
    buf := bufPool.Get().(*bytes.Buffer)
    defer func() {
        buf.Reset()
        bufPool.Put(buf)
    }()

    buf.WriteString("hello")
    // 使用 buf...
}

// 用 strings.Builder 拼接字符串（比 + 高效）
var builder strings.Builder
for _, s := range parts {
    builder.WriteString(s)
}
result := builder.String()

6.2 预分配容量

// 切片预分配
users := make([]User, 0, len(ids))

// Map 预分配
m := make(map[string]int, len(keys))

6.3 避免 []byte 和 string 频繁转换

1
2
3

// 频繁转换会产生内存分配
// 如果只是读，可以用 unsafe 零拷贝（高级用法，谨慎使用）
// 一般情况下用 bytes 包操作 []byte，减少转换

七、小结

本文学习了 Go 的进阶特性：

泛型（类型参数、约束、泛型函数和结构体）
反射（获取类型信息、修改值、调用方法）
闭包进阶用法
逃逸分析（理解栈和堆的分配）
性能分析（pprof 的 CPU、内存分析）
代码优化技巧

到此 Go 学习笔记的语法和工具部分已经覆盖完毕。下一篇将进入实战项目，把前面学到的知识综合运用。

Go 学习笔记（六）：标准库与工程实践

Tue, 05 May 2026 15:00:00 +0800

写在前面

本文是 Go 学习笔记系列的第六篇，介绍 Go 标准库的常用功能，以及工程实践中需要掌握的技能：文件操作、HTTP 服务、数据库、命令行和单元测试。前置知识：并发编程（第五篇）。

一、文件操作

1.1 读取文件

import "os"

// 方式1：一次性读取整个文件（小文件适用）
data, err := os.ReadFile("config.yaml")
if err != nil {
    log.Fatal(err)
}
fmt.Println(string(data))

// 方式2：逐行读取（大文件适用）
file, err := os.Open("access.log")
if err != nil {
    log.Fatal(err)
}
defer file.Close()

scanner := bufio.NewScanner(file)
for scanner.Scan() {
    line := scanner.Text()
    fmt.Println(line)
}
if err := scanner.Err(); err != nil {
    log.Fatal(err)
}

1.2 写入文件

// 方式1：一次性写入
err := os.WriteFile("output.txt", []byte("Hello Go"), 0644)

// 方式2：创建并写入（覆盖）
file, err := os.Create("output.txt")
if err != nil {
    log.Fatal(err)
}
defer file.Close()
file.WriteString("Hello Go\n")

// 方式3：追加写入
file, err := os.OpenFile("output.txt", os.O_APPEND|os.O_WRONLY|os.O_CREATE, 0644)
if err != nil {
    log.Fatal(err)
}
defer file.Close()
file.WriteString("追加的内容\n")

// 方式4：带缓冲写入
writer := bufio.NewWriter(file)
writer.WriteString("缓冲写入\n")
writer.Flush()   // 别忘了 Flush

1.3 文件和目录操作

// 创建目录
os.Mkdir("mydir", 0755)           // 创建一层
os.MkdirAll("a/b/c", 0755)        // 递归创建多层

// 删除
os.Remove("file.txt")              // 删除文件
os.RemoveAll("mydir")              // 递归删除目录

// 重命名/移动
os.Rename("old.txt", "new.txt")

// 获取文件信息
info, err := os.Stat("file.txt")
fmt.Println(info.Size())           // 文件大小
fmt.Println(info.IsDir())          // 是否目录
fmt.Println(info.ModTime())        // 修改时间

// 判断文件是否存在
_, err := os.Stat("file.txt")
if os.IsNotExist(err) {
    fmt.Println("文件不存在")
}

1.4 io 工具函数

import "io"

// 复制（从 Reader 复制到 Writer）
io.Copy(dst, src)

// 读取全部内容
data, err := io.ReadAll(reader)

// 字符串当 Reader 用
reader := strings.NewReader("hello")

// 多个 Reader 拼接
reader := io.MultiReader(r1, r2, r3)

// 写入多个 Writer
writer := io.MultiWriter(w1, w2)

二、HTTP 服务

2.1 基础 HTTP 服务

import "net/http"

func main() {
    // 注册路由
    http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
        w.Write([]byte("Hello, Go!"))
    })

    http.HandleFunc("/api/user", handleUser)

    // 启动服务
    fmt.Println("服务启动在 :8080")
    log.Fatal(http.ListenAndServe(":8080", nil))
}

func handleUser(w http.ResponseWriter, r *http.Request) {
    // 根据 Method 区分操作
    switch r.Method {
    case http.MethodGet:
        w.Header().Set("Content-Type", "application/json")
        w.Write([]byte(`{"name": "张三", "age": 25}`))
    case http.MethodPost:
        // 读取请求体
        body, _ := io.ReadAll(r.Body)
        defer r.Body.Close()
        fmt.Println("收到:", string(body))
        w.WriteHeader(http.StatusCreated)
    default:
        w.WriteHeader(http.StatusMethodNotAllowed)
    }
}

2.2 处理请求参数

func handler(w http.ResponseWriter, r *http.Request) {
    // 获取 Query 参数
    name := r.URL.Query().Get("name")
    page := r.URL.Query().Get("page")

    // 获取路径参数（需要自定义路由或用框架）
    // 标准库不直接支持，推荐用 Gin 等框架

    // 获取 Header
    auth := r.Header.Get("Authorization")

    // 获取 Content-Type
    contentType := r.Header.Get("Content-Type")

    // 读取请求体
    body, err := io.ReadAll(r.Body)
    defer r.Body.Close()
}

2.3 发送 HTTP 请求

import "net/http"

// GET 请求
resp, err := http.Get("https://api.example.com/users")
if err != nil {
    log.Fatal(err)
}
defer resp.Body.Close()
body, _ := io.ReadAll(resp.Body)
fmt.Println(string(body))

// POST 请求（JSON）
data := strings.NewReader(`{"name": "张三"}`)
resp, err := http.Post("https://api.example.com/users", "application/json", data)
defer resp.Body.Close()

// 自定义请求（设置 Header、超时等）
req, _ := http.NewRequest("GET", "https://api.example.com/users", nil)
req.Header.Set("Authorization", "Bearer xxx")

client := &http.Client{Timeout: 10 * time.Second}
resp, err := client.Do(req)
defer resp.Body.Close()

2.4 JSON 响应

func jsonHandler(w http.ResponseWriter, r *http.Request) {
    user := User{Name: "张三", Age: 25}

    w.Header().Set("Content-Type", "application/json")
    json.NewEncoder(w).Encode(user)
}

// 接收 JSON 请求
func createUser(w http.ResponseWriter, r *http.Request) {
    var user User
    if err := json.NewDecoder(r.Body).Decode(&user); err != nil {
        http.Error(w, "无效的 JSON", http.StatusBadRequest)
        return
    }
    fmt.Println(user.Name)
}

三、数据库操作

3.1 基础连接

import "database/sql"
import _ "github.com/go-sql-driver/mysql"  // MySQL 驱动

func main() {
    // 连接数据库
    db, err := sql.Open("mysql", "user:password@tcp(127.0.0.1:3306)/mydb?charset=utf8mb4&parseTime=true")
    if err != nil {
        log.Fatal(err)
    }
    defer db.Close()

    // 验证连接
    if err := db.Ping(); err != nil {
        log.Fatal(err)
    }

    // 设置连接池
    db.SetMaxOpenConns(25)          // 最大连接数
    db.SetMaxIdleConns(5)           // 最大空闲连接
    db.SetConnMaxLifetime(5 * time.Minute)
}

3.2 查询操作

// 查询单行
var name string
var age int
err := db.QueryRow("SELECT name, age FROM users WHERE id = ?", 1).Scan(&name, &age)
if err == sql.ErrNoRows {
    fmt.Println("未找到")
}

// 查询多行
rows, err := db.Query("SELECT id, name, age FROM users WHERE age > ?", 18)
if err != nil {
    log.Fatal(err)
}
defer rows.Close()

for rows.Next() {
    var id, age int
    var name string
    if err := rows.Scan(&id, &name, &age); err != nil {
        log.Fatal(err)
    }
    fmt.Println(id, name, age)
}

3.3 增删改

// 插入
result, err := db.Exec("INSERT INTO users (name, age) VALUES (?, ?)", "张三", 25)
if err != nil {
    log.Fatal(err)
}
id, _ := result.LastInsertId()   // 获取自增 ID

// 更新
result, err := db.Exec("UPDATE users SET age = ? WHERE id = ?", 26, 1)
affected, _ := result.RowsAffected()   // 影响行数

// 删除
result, err := db.Exec("DELETE FROM users WHERE id = ?", 1)

3.4 事务

tx, err := db.Begin()
if err != nil {
    log.Fatal(err)
}

// 执行事务中的操作
_, err = tx.Exec("UPDATE accounts SET balance = balance - 100 WHERE id = ?", 1)
if err != nil {
    tx.Rollback()
    log.Fatal(err)
}

_, err = tx.Exec("UPDATE accounts SET balance = balance + 100 WHERE id = ?", 2)
if err != nil {
    tx.Rollback()
    log.Fatal(err)
}

// 提交
if err := tx.Commit(); err != nil {
    log.Fatal(err)
}

实际项目中推荐用 sqlx 或 GORM 等库简化数据库操作。

四、命令行参数

4.1 os.Args

func main() {
    // os.Args[0] 是程序名，之后是参数
    if len(os.Args) < 2 {
        fmt.Println("用法: myapp <name>")
        os.Exit(1)
    }
    name := os.Args[1]
    fmt.Println("Hello,", name)
}

4.2 flag 包

import "flag"

func main() {
    // 定义命令行参数
    host := flag.String("host", "localhost", "服务器地址")
    port := flag.Int("port", 8080, "端口号")
    debug := flag.Bool("debug", false, "调试模式")

    // 也可以绑定到变量
    var config string
    flag.StringVar(&config, "config", "app.yaml", "配置文件路径")

    // 解析参数
    flag.Parse()

    fmt.Printf("host: %s, port: %d, debug: %v, config: %s\n", *host, *port, *debug, config)
}

// 使用：
// go run main.go -host 0.0.0.0 -port 3000 -debug -config prod.yaml

4.3 获取环境变量

// 获取环境变量
dbHost := os.Getenv("DB_HOST")
dbPort := os.Getenv("DB_PORT")

// 带默认值
func getEnv(key, defaultValue string) string {
    if value := os.Getenv(key); value != "" {
        return value
    }
    return defaultValue
}

host := getEnv("DB_HOST", "localhost")

五、单元测试

5.1 基本测试

Go 的测试文件以 _test.go 结尾，测试函数以 Test 开头：

// math.go
package math

func Add(a, b int) int {
    return a + b
}

// math_test.go（同包下）
package math

import "testing"

func TestAdd(t *testing.T) {
    result := Add(1, 2)
    if result != 3 {
        t.Errorf("Add(1, 2) = %d, want 3", result)
    }
}

运行测试：

# 运行当前包的测试
go test

# 详细输出
go test -v

# 运行指定测试函数
go test -run TestAdd

# 运行所有测试
go test ./...

5.2 表驱动测试（推荐）

func TestAdd(t *testing.T) {
    tests := []struct {
        name     string
        a, b     int
        expected int
    }{
        {"正数相加", 1, 2, 3},
        {"负数相加", -1, -2, -3},
        {"零值相加", 0, 0, 0},
        {"正负混合", 5, -3, 2},
    }

    for _, tt := range tests {
        t.Run(tt.name, func(t *testing.T) {
            result := Add(tt.a, tt.b)
            if result != tt.expected {
                t.Errorf("Add(%d, %d) = %d, want %d", tt.a, tt.b, result, tt.expected)
            }
        })
    }
}

5.3 基准测试

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

1
2
3

# 运行基准测试
go test -bench=.
go test -bench=. -benchmem   # 显示内存分配情况

5.4 测试 HTTP Handler

import "net/http/httptest"

func TestHandler(t *testing.T) {
    req := httptest.NewRequest("GET", "/api/user?name=张三", nil)
    w := httptest.NewRecorder()

    handleUser(w, req)

    if w.Code != http.StatusOK {
        t.Errorf("状态码 = %d, want %d", w.Code, http.StatusOK)
    }

    body := w.Body.String()
    fmt.Println(body)
}

六、日志

6.1 标准库 log

import "log"

log.Println("普通日志")
log.Printf("用户 %s 登录", name)
log.Fatal("致命错误，程序退出")   // 输出后调用 os.Exit(1)
log.Panic("严重错误")            // 输出后调用 panic

// 自定义日志格式
logger := log.New(os.Stdout, "[APP] ", log.LstdFlags|log.Lshortfile)
logger.Println("自定义格式日志")

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

import "log/slog"

// 基本使用
slog.Info("用户登录", "user", "张三", "ip", "192.168.1.1")
slog.Error("操作失败", "err", err, "path", "/api/users")

// 结构化日志输出（JSON 格式）
handler := slog.NewJSONHandler(os.Stdout, &slog.HandlerOptions{Level: slog.LevelDebug})
logger := slog.New(handler)
slog.SetDefault(logger)

slog.Info("请求处理完成",
    "method", "GET",
    "path", "/api/users",
    "status", 200,
    "duration", time.Since(start),
)
// {"time":"...","level":"INFO","msg":"请求处理完成","method":"GET","path":"/api/users","status":200,"duration":"1.2ms"}

七、项目结构规范

Go 项目没有强制的目录结构，但社区有推荐的规范：

myproject/
├── cmd/                // 可执行程序入口
│   └── server/
│       └── main.go
├── internal/           // 私有代码（不能被外部导入）
│   ├── handler/        // HTTP 处理器
│   ├── service/        // 业务逻辑
│   └── repository/     // 数据访问
├── pkg/                // 可被外部导入的公共包
│   └── utils/
├── config/             // 配置文件
│   └── app.yaml
├── go.mod
├── go.sum
└── Makefile

internal 目录是 Go 编译器强制约束的：其他模块无法导入 internal 下的包。

八、小结

本文学习了 Go 的标准库和工程实践：

文件操作（os、io、bufio）
HTTP 服务与客户端（net/http）
数据库操作（database/sql）
命令行参数与环境变量
单元测试（testing、表驱动测试、httptest）
日志（log、slog）
项目结构规范

下一篇将学习 Go 的进阶特性：泛型、反射、性能分析。

Go 学习笔记（五）：并发编程

Tue, 05 May 2026 14:00:00 +0800

写在前面

本文是 Go 学习笔记系列的第五篇，介绍 Go 的并发编程。并发是 Go 的核心优势，goroutine + channel 的模型简洁而强大。前置知识：接口与错误处理（第四篇）。

一、goroutine

1.1 启动 goroutine

// 普通函数调用（同步）
doSomething()

// 加 go 关键字启动 goroutine（异步）
go doSomething()

// 匿名函数启动
go func() {
    fmt.Println("goroutine 中执行")
}()

1.2 goroutine 基本示例

func main() {
    // 启动多个 goroutine
    go func() {
        for i := 0; i < 3; i++ {
            fmt.Println("goroutine A:", i)
        }
    }()

    go func() {
        for i := 0; i < 3; i++ {
            fmt.Println("goroutine B:", i)
        }
    }()

    // 问题：main 函数结束后所有 goroutine 都会被终止
    // 输出可能什么都看不到，因为 main 先退出了
}

1.3 等待 goroutine 结束

import "sync"

func main() {
    var wg sync.WaitGroup

    for i := 0; i < 5; i++ {
        wg.Add(1)           // 计数器 +1
        go func(id int) {
            defer wg.Done()  // 计数器 -1
            fmt.Printf("worker %d 完成\n", id)
        }(i)
    }

    wg.Wait()  // 阻塞直到计数器归零
    fmt.Println("所有 worker 完成")
}

注意：循环变量要作为参数传入 goroutine，否则闭包会捕获循环变量的引用（Go 1.22 之前会出问题）。

1.4 goroutine 特点

- 极轻量：初始栈只有 2KB（可动态增长），比线程轻得多
- 非阻塞：goroutine 的调度由 Go 运行时管理，不依赖 OS 线程
- 数量：轻松创建数万个 goroutine
- 调度：GMP 模型（Goroutine-Machine-Processor），由运行时自动调度

二、channel

channel 是 goroutine 之间通信的管道，Go 的并发哲学：不要通过共享内存来通信，而要通过通信来共享内存。

2.1 创建和使用

// 创建 channel
ch := make(chan int)       // 无缓冲 channel
ch := make(chan int, 10)   // 带缓冲 channel，容量10

// 发送数据
ch <- 42

// 接收数据
value := <-ch

// 接收并判断是否关闭
value, ok := <-ch
if !ok {
    fmt.Println("channel 已关闭")
}

// 关闭 channel
close(ch)

2.2 无缓冲 channel

// 无缓冲 channel：发送和接收必须同时就绪（同步）
ch := make(chan string)

go func() {
    ch <- "hello"   // 发送后阻塞，直到有人接收
}()

msg := <-ch         // 阻塞，直到有数据
fmt.Println(msg)    // hello

无缓冲 channel 也叫同步 channel，发送和接收是握手操作。

2.3 带缓冲 channel

// 带缓冲 channel：缓冲区满之前发送不阻塞
ch := make(chan int, 3)   // 容量3

ch <- 1   // 不阻塞
ch <- 2   // 不阻塞
ch <- 3   // 不阻塞
// ch <- 4  // 阻塞，缓冲区满了

fmt.Println(len(ch))  // 3（当前缓冲区中的元素数）
fmt.Println(cap(ch))  // 3（容量）

v1 := <-ch   // 1
v2 := <-ch   // 2

2.4 关闭 channel

ch := make(chan int, 5)

// 生产者发送完数据后关闭
ch <- 1
ch <- 2
ch <- 3
close(ch)

// 消费者用 range 遍历（自动在 close 后退出）
for v := range ch {
    fmt.Println(v)   // 1 2 3
}

// 注意：
// - 只有发送方应该关闭 channel
// - 关闭后不能再发送（panic）
// - 关闭后仍可以接收（返回零值和 false）
// - 不需要关闭的 channel 就不要关（GC 会回收）

2.5 单向 channel

// 只发送（生产者）
func producer(ch chan<- int) {
    for i := 0; i < 5; i++ {
        ch <- i
    }
    close(ch)
}

// 只接收（消费者）
func consumer(ch <-chan int) {
    for v := range ch {
        fmt.Println(v)
    }
}

func main() {
    ch := make(chan int, 5)
    go producer(ch)
    consumer(ch)
}

三、select

select 同时监听多个 channel，类似 switch 但专门用于 channel 操作。

3.1 基本用法

ch1 := make(chan string)
ch2 := make(chan string)

go func() {
    time.Sleep(1 * time.Second)
    ch1 <- "来自 ch1"
}()

go func() {
    time.Sleep(2 * time.Second)
    ch2 <- "来自 ch2"
}()

// 哪个先就绪就执行哪个
for i := 0; i < 2; i++ {
    select {
    case msg1 := <-ch1:
        fmt.Println(msg1)
    case msg2 := <-ch2:
        fmt.Println(msg2)
    }
}

3.2 超时控制

select {
case result := <-ch:
    fmt.Println("收到:", result)
case <-time.After(3 * time.Second):
    fmt.Println("超时了")
}

3.3 非阻塞操作

select {
case msg := <-ch:
    fmt.Println("收到:", msg)
default:
    fmt.Println("没有数据，做其他事")
}

四、sync 包

4.1 Mutex — 互斥锁

import "sync"

type SafeCounter struct {
    mu sync.Mutex
    m  map[string]int
}

func (c *SafeCounter) Inc(key string) {
    c.mu.Lock()
    defer c.mu.Unlock()
    c.m[key]++
}

func (c *SafeCounter) Get(key string) int {
    c.mu.Lock()
    defer c.mu.Unlock()
    return c.m[key]
}

// 使用
counter := SafeCounter{m: make(map[string]int)}
counter.Inc("hello")
fmt.Println(counter.Get("hello"))   // 1

4.2 RWMutex — 读写锁

type Cache struct {
    mu   sync.RWMutex
    data map[string]string
}

// 写操作用写锁（互斥）
func (c *Cache) Set(key, value string) {
    c.mu.Lock()
    defer c.mu.Unlock()
    c.data[key] = value
}

// 读操作用读锁（共享，多个读者可以同时读）
func (c *Cache) Get(key string) string {
    c.mu.RLock()
    defer c.mu.RUnlock()
    return c.data[key]
}

读多写少的场景用 RWMutex 比Mutex 性能更好。

4.3 sync.Once — 只执行一次

var once sync.Once
var instance *Config

func GetConfig() *Config {
    once.Do(func() {
        instance = loadConfig()  // 无论多少 goroutine 调用，只执行一次
    })
    return instance
}

4.4 sync.Map — 并发安全的 Map

var m sync.Map

// 写入
m.Store("name", "张三")
m.Store("age", 25)

// 读取
val, ok := m.Load("name")
if ok {
    fmt.Println(val)   // 张三
}

// 遍历
m.Range(func(key, value any) bool {
    fmt.Println(key, value)
    return true   // 返回 false 停止遍历
})

// 删除
m.Delete("age")

sync.Map 适合读多写少的场景。读写都频繁的场景用 map + Mutex 更好。

五、context

context 用于在 goroutine 之间传递取消信号、超时、截止时间和请求级别的值。

5.1 取消（WithCancel）

import "context"

func worker(ctx context.Context, id int) {
    for {
        select {
        case <-ctx.Done():
            fmt.Printf("worker %d 收到取消信号，退出\n", id)
            return
        default:
            fmt.Printf("worker %d 工作中...\n", id)
            time.Sleep(500 * time.Millisecond)
        }
    }
}

func main() {
    ctx, cancel := context.WithCancel(context.Background())

    go worker(ctx, 1)
    go worker(ctx, 2)

    time.Sleep(2 * time.Second)
    cancel()   // 通知所有 worker 退出

    time.Sleep(1 * time.Second)  // 等待 worker 退出
}

5.2 超时（WithTimeout）

func doWork(ctx context.Context) error {
    // 模拟耗时操作
    select {
    case <-time.After(5 * time.Second):
        return nil
    case <-ctx.Done():
        return ctx.Err()   // context deadline exceeded
    }
}

func main() {
    // 3秒超时
    ctx, cancel := context.WithTimeout(context.Background(), 3*time.Second)
    defer cancel()

    if err := doWork(ctx); err != nil {
        fmt.Println("操作失败:", err)   // context deadline exceeded
    }
}

5.3 传值（WithValue）

func main() {
    // 传请求级别的值（如 trace_id）
    ctx := context.WithValue(context.Background(), "traceID", "abc-123")

    handleRequest(ctx)
}

func handleRequest(ctx context.Context) {
    traceID := ctx.Value("traceID")
    fmt.Println("traceID:", traceID)   // abc-123
}

WithValue 只用于请求级别的跨函数传值（trace_id、user_id 等），不要用来传可选参数。

5.4 context 使用规则

- 不要把 context 放在结构体里，作为函数第一个参数传递
- 传递 context 给子函数，子函数可以随时被取消
- context.WithValue 的 key 建议用自定义类型，避免冲突
- 函数接收 context 时，不要传 nil，用 context.TODO() 代替
- cancel() 要 defer 调用，避免资源泄漏

六、常见并发模式

6.1 Worker Pool（工作池）

func workerPool(jobs <-chan int, results chan<- int, id int) {
    for job := range jobs {
        fmt.Printf("worker %d 处理任务 %d\n", id, job)
        results <- job * 2
    }
}

func main() {
    jobs := make(chan int, 10)
    results := make(chan int, 10)

    // 启动3个 worker
    for w := 1; w <= 3; w++ {
        go workerPool(jobs, results, w)
    }

    // 发送5个任务
    for j := 1; j <= 5; j++ {
        jobs <- j
    }
    close(jobs)

    // 收集结果
    for r := 1; r <= 5; r++ {
        fmt.Println("结果:", <-results)
    }
}

6.2 Pipeline（管道模式）

// 阶段1：生成数据
func generate(nums ...int) <-chan int {
    out := make(chan int)
    go func() {
        for _, n := range nums {
            out <- n
        }
        close(out)
    }()
    return out
}

// 阶段2：平方
func square(in <-chan int) <-chan int {
    out := make(chan int)
    go func() {
        for n := range in {
            out <- n * n
        }
        close(out)
    }()
    return out
}

func main() {
    // 组装管道：生成 → 平方 → 输出
    ch := square(square(generate(2, 3, 4)))
    for v := range ch {
        fmt.Println(v)   // 16, 81, 256
    }
}

6.3 Fan-out / Fan-in（扇出/扇入）

// Fan-out：多个 goroutine 从同一个 channel 读取（自动分发）
ch1 := square(generate(1, 2, 3, 4, 5))
ch2 := square(generate(1, 2, 3, 4, 5))   // 两个 worker 同时处理

// Fan-in：合并多个 channel 到一个
func merge(cs ...<-chan int) <-chan int {
    out := make(chan int)
    var wg sync.WaitGroup

    for _, c := range cs {
        wg.Add(1)
        go func(ch <-chan int) {
            defer wg.Done()
            for v := range ch {
                out <- v
            }
        }(c)
    }

    go func() {
        wg.Wait()
        close(out)
    }()
    return out
}

七、小结

本文学习了 Go 的并发编程：

goroutine（轻量级协程，go 关键字启动）
channel（goroutine 间通信，无缓冲 vs 带缓冲）
select（多路复用、超时控制）
sync 包（Mutex、RWMutex、WaitGroup、Once、sync.Map）
context（取消、超时、传值）
常见并发模式（Worker Pool、Pipeline、Fan-out/Fan-in）

下一篇将学习标准库与工程实践，包括 HTTP 服务、数据库操作和单元测试。

Go 学习笔记（四）：接口与错误处理

Tue, 05 May 2026 13:00:00 +0800

写在前面

本文是 Go 学习笔记系列的第四篇，介绍 Go 的接口和错误处理机制。接口是 Go 实现多态的核心，错误处理是 Go 的设计哲学（没有 try-catch）。前置知识：结构体和方法（第三篇）。

一、接口基础

1.1 定义接口

// 定义接口
type Speaker interface {
    Speak() string
}

// 实现接口（隐式实现，不需要 implements 关键字）
type Dog struct {
    Name string
}

func (d Dog) Speak() string {
    return d.Name + "：汪汪汪"
}

type Cat struct {
    Name string
}

func (c Cat) Speak() string {
    return c.Name + "：喵喵喵"
}

Go 的接口是隐式实现：只要一个类型实现了接口的所有方法，它就自动实现了该接口。不需要声明 implements。

1.2 使用接口

// 接口作为参数（多态）
func makeSound(s Speaker) {
    fmt.Println(s.Speak())
}

func main() {
    d := Dog{Name: "旺财"}
    c := Cat{Name: "小橘"}

    makeSound(d)   // 旺财：汪汪汪
    makeSound(c)   // 小橘：喵喵喵

    // 接口切片
    animals := []Speaker{d, c}
    for _, a := range animals {
        fmt.Println(a.Speak())
    }
}

1.3 接口变量

var s Speaker

s = Dog{Name: "旺财"}
fmt.Println(s.Speak())

// 接口变量包含两部分：
// 1. 类型信息（动态类型）
// 2. 值信息（动态值）

二、类型断言与类型选择

2.1 类型断言

var s Speaker = Dog{Name: "旺财"}

// 断言（如果类型不对会 panic）
d := s.(Dog)
fmt.Println(d.Name)

// 安全断言（推荐）
d, ok := s.(Dog)
if ok {
    fmt.Println("是 Dog:", d.Name)
}

// 错误的断言
c, ok := s.(Cat)
fmt.Println(ok)   // false

2.2 类型选择（type switch）

func checkType(s Speaker) {
    switch v := s.(type) {
    case Dog:
        fmt.Println("Dog:", v.Name)
    case Cat:
        fmt.Println("Cat:", v.Name)
    default:
        fmt.Println("未知类型")
    }
}

三、常用接口

3.1 Stringer（类似 Java 的 toString）

type User struct {
    Name string
    Age  int
}

// 实现 fmt.Stringer 接口
func (u User) String() string {
    return fmt.Sprintf("%s (%d岁)", u.Name, u.Age)
}

user := User{Name: "张三", Age: 25}
fmt.Println(user)   // 张三 (25岁)

3.2 error 接口

// error 是一个内置接口
type error interface {
    Error() string
}

// 自定义错误（实现 Error() 方法即可）
type NotFoundError struct {
    Resource string
    ID       int
}

func (e NotFoundError) Error() string {
    return fmt.Sprintf("%s #%d 未找到", e.Resource, e.ID)
}

3.3 io.Reader 和 io.Writer

// io.Reader 接口
type Reader interface {
    Read(p []byte) (n int, err error)
}

// io.Writer 接口
type Writer interface {
    Write(p []byte) (n int, err error)
}

// 文件同时实现了 Reader 和 Writer
// net.Conn 也同时实现了两者
// 这两个接口是 Go I/O 的基础

3.4 空接口 interface

// 空接口没有任何方法，所有类型都实现了它
// 类似 Java 的 Object 或 Python 的 Any

func printAnything(v interface{}) {
    fmt.Println(v)
}

printAnything(42)
printAnything("hello")
printAnything([]int{1, 2, 3})

// Go 1.18+ 可以用 any 代替 interface{}
func printAnything(v any) {
    fmt.Println(v)
}

空接口要慎用，能确定类型就用具体类型或泛型。

四、错误处理

4.1 基本模式

Go 没有 try-catch，错误通过返回值传递：

// 函数返回错误
func divide(a, b float64) (float64, error) {
    if b == 0 {
        return 0, errors.New("除数不能为零")
    }
    return a / b, nil
}

// 调用时检查错误
result, err := divide(10, 0)
if err != nil {
    fmt.Println("出错:", err)
    return
}
fmt.Println("结果:", result)

nil 表示没有错误。Go 的错误处理就是 if err != nil，写多了就习惯了。

4.2 创建错误

import "errors"
import "fmt"

// 方式1：errors.New
err1 := errors.New("文件不存在")

// 方式2：fmt.Errorf（支持格式化，最常用）
err2 := fmt.Errorf("用户 %s 不存在", name)

// 方式3：自定义错误类型
type ValidationError struct {
    Field   string
    Message string
}

func (e ValidationError) Error() string {
    return fmt.Sprintf("验证失败: %s — %s", e.Field, e.Message)
}

err3 := ValidationError{Field: "email", Message: "格式不正确"}

4.3 errors.Is 和 errors.As（Go 1.13+）

import "errors"

// 定义哨兵错误（Sentinel Error）
var (
    ErrNotFound  = errors.New("未找到")
    ErrForbidden = errors.New("无权限")
)

// errors.Is：判断错误链中是否包含指定错误
err := someFunc()
if errors.Is(err, ErrNotFound) {
    fmt.Println("资源不存在")
}

// errors.As：从错误链中提取指定类型的错误
var valErr *ValidationError
if errors.As(err, &valErr) {
    fmt.Println("字段:", valErr.Field)
}

4.4 错误包装（Wrapping）

// 用 %w 包装错误（保留原始错误信息）
func readConfig(path string) error {
    data, err := os.ReadFile(path)
    if err != nil {
        return fmt.Errorf("读取配置文件失败: %w", err)
    }
    // ...
    return nil
}

// 调用方可以用 errors.Is / errors.As 追溯到原始错误
err := readConfig("config.yaml")
if errors.Is(err, os.ErrNotExist) {
    fmt.Println("配置文件不存在")
}

4.5 常见错误处理模式

// 模式1：逐层返回
func handler() error {
    if err := validate(); err != nil {
        return fmt.Errorf("参数校验失败: %w", err)
    }
    if err := process(); err != nil {
        return fmt.Errorf("处理失败: %w", err)
    }
    return nil
}

// 模式2：错误后清理资源
func copyFile(src, dst string) error {
    in, err := os.Open(src)
    if err != nil {
        return err
    }
    defer in.Close()

    out, err := os.Create(dst)
    if err != nil {
        return err
    }
    defer out.Close()

    _, err = io.Copy(out, in)
    return err
}

// 模式3：记录日志后继续
if err := retryableOp(); err != nil {
    log.Printf("操作失败，稍后重试: %v", err)
    // 不返回，继续执行
}

五、panic 与 recover

5.1 panic

panic 用于不可恢复的严重错误，类似其他语言的异常抛出：

func mustParse(s string) int {
    n, err := strconv.Atoi(s)
    if err != nil {
        panic(fmt.Sprintf("无法解析 %q 为整数", s))
    }
    return n
}

正常业务逻辑不要用 panic，应该返回 error。panic 适合程序初始化阶段的致命错误。

5.2 recover

recover 用于捕获 panic，只在 defer 中有效：

func safeCall() {
    defer func() {
        if r := recover(); r != nil {
            fmt.Println("捕获到 panic:", r)
        }
    }()

    panic("出了大问题")
}

func main() {
    safeCall()
    fmt.Println("程序继续运行")   // 会正常执行
}

5.3 panic vs error

error — 正常的错误处理方式，调用方决定怎么处理
panic — 不可恢复的错误，程序崩溃（除非 recover）

使用场景：
- 返回 error：文件不存在、网络超时、参数无效等可预期的错误
- panic：数组越界、空指针、初始化失败等程序 bug 或致命错误

六、接口组合

Go 通过接口组合实现类似继承的效果：

type Reader interface {
    Read(p []byte) (n int, err error)
}

type Writer interface {
    Write(p []byte) (n int, err error)
}

// 接口组合
type ReadWriter interface {
    Reader
    Writer
}

// 一个类型只需同时实现 Read 和 Write 就自动实现 ReadWriter
type File struct{}

func (f File) Read(p []byte) (int, error)  { return 0, nil }
func (f File) Write(p []byte) (int, error) { return 0, nil }

var rw ReadWriter = File{}   // 合法

七、小结

本文学习了 Go 的接口和错误处理：

接口的隐式实现和多态
类型断言和类型选择
常用接口（Stringer、error、Reader/Writer）
错误处理的惯用模式（if err != nil）
errors.Is / errors.As / 错误包装
panic 与 recover
接口组合

下一篇将学习 Go 的并发编程：goroutine、channel 和 context。

Go 学习笔记（三）：复合数据类型

Tue, 05 May 2026 12:00:00 +0800

写在前面

本文是 Go 学习笔记系列的第三篇，介绍 Go 的复合数据类型：数组、切片、字典、结构体，以及 JSON 处理和字符串操作。前置知识：Go 基础语法（第二篇）。

一、数组

1.1 声明与初始化

// 声明指定长度的数组
var nums [5]int                       // [0 0 0 0 0]
var names [3]string                   // ["" "" ""]

// 声明并初始化
colors := [3]string{"红", "绿", "蓝"}
nums := [5]int{1, 2, 3, 4, 5}

// 让编译器计算长度
nums := [...]int{1, 2, 3, 4, 5}      // 长度自动推断为 5

// 指定索引初始化
nums := [5]int{1: 10, 3: 30}         // [0 10 0 30 0]

1.2 数组操作

nums := [5]int{1, 2, 3, 4, 5}

// 访问元素
fmt.Println(nums[0])   // 1
fmt.Println(nums[4])   // 5

// 修改元素
nums[0] = 10

// 获取长度
fmt.Println(len(nums))  // 5

// 遍历
for i, v := range nums {
    fmt.Println(i, v)
}

注意：Go 数组的长度是类型的一部分，[3]int 和 [5]int 是不同的类型，不能互相赋值。实际开发中很少直接用数组，基本都用切片。

二、切片（Slice）

切片是 Go 中最常用的数据结构，可以理解为动态数组。

2.1 创建切片

// 从数组创建
arr := [5]int{1, 2, 3, 4, 5}
s1 := arr[1:4]            // [2 3 4]，左闭右开

// 直接创建
s2 := []int{1, 2, 3}      // 切片字面量

// 用 make 创建（推荐，可指定容量）
s3 := make([]int, 5)            // 长度5，容量5，元素全为0
s4 := make([]int, 0, 10)        // 长度0，容量10（预分配）

2.2 切片三要素

1
2
3

指针 — 指向底层数组的地址
长度 — len(s)，当前元素个数
容量 — cap(s)，从指针位置到底层数组末尾的元素数

1
2
3

s := make([]int, 3, 5)
fmt.Println(len(s))   // 3
fmt.Println(cap(s))   // 5

2.3 添加元素

s := []int{1, 2, 3}

// append 返回新切片（必须接收返回值）
s = append(s, 4)          // [1 2 3 4]
s = append(s, 5, 6)       // [1 2 3 4 5 6]

// 追加另一个切片
other := []int{7, 8}
s = append(s, other...)    // [1 2 3 4 5 6 7 8]

append 可能触发扩容，扩容后地址可能改变，所以必须用 s = append(s, x) 接收返回值。

2.4 切片截取

s := []int{1, 2, 3, 4, 5}

s1 := s[1:3]     // [2 3]
s2 := s[:3]      // [1 2 3]
s3 := s[2:]      // [3 4 5]
s4 := s[:]       // [1 2 3 4 5]（完整拷贝视图）

切片截取和原切片共享底层数组，修改一个会影响另一个。要完全独立需要用 copy。

2.5 复制切片

src := []int{1, 2, 3}
dst := make([]int, len(src))
copy(dst, src)        // 深拷贝，互不影响

// 或者用 append 创建独立副本
dst2 := append([]int{}, src...)

2.6 删除元素

Go 没有内置的删除方法，需要手动操作：

s := []int{1, 2, 3, 4, 5}

// 删除索引 2 的元素（保持顺序）
s = append(s[:2], s[3:]...)   // [1 2 4 5]

// 删除索引 2 的元素（不保持顺序，性能更好）
s[2] = s[len(s)-1]
s = s[:len(s)-1]

2.7 扩容机制

切片容量不够时，append 会自动扩容：

1
2

新容量 < 256     → 新容量 = 旧容量 * 2（翻倍）
新容量 >= 256    → 新容量 = 旧容量 * 1.25 + 192（渐进增长）

建议：如果知道大致元素数量，用 make([]T, 0, n) 预分配容量，避免频繁扩容。

三、字典（Map）

3.1 创建与初始化

// 字面量创建
ages := map[string]int{
    "张三": 25,
    "李四": 30,
}

// 用 make 创建
scores := make(map[string]int)
scores["数学"] = 90
scores["英语"] = 85

// 空的 map（可以直接使用）
m := make(map[string]string)

var m map[string]string 声明的是 nil map，直接赋值会 panic。必须用 make 或字面量初始化。

3.2 基本操作

m := map[string]int{"a": 1, "b": 2, "c": 3}

// 取值
fmt.Println(m["a"])    // 1
fmt.Println(m["x"])    // 0（不存在的 key 返回零值）

// 判断 key 是否存在
value, ok := m["x"]
if ok {
    fmt.Println("存在:", value)
} else {
    fmt.Println("不存在")
}

// 修改
m["a"] = 10

// 删除
delete(m, "b")

// 遍历（顺序不确定）
for key, value := range m {
    fmt.Println(key, value)
}

// 获取长度
fmt.Println(len(m))

3.3 Map 的注意事项

- 遍历顺序不确定（每次运行可能不同）
- Map 不是并发安全的，并发读写需要加锁或用 sync.Map
- Map 的 key 必须是可比较的类型（不能用 slice、map、func 作为 key）
- 取值时用 value, ok 模式判断 key 是否存在

四、结构体（Struct）

4.1 定义与实例化

// 定义结构体
type User struct {
    Name string
    Age  int
}

// 实例化
u1 := User{Name: "张三", Age: 25}      // 指定字段名（推荐）
u2 := User{"李四", 30}                  // 按顺序（不推荐，不好维护）
u3 := User{}                            // 零值初始化：Name="" Age=0

// 访问和修改
fmt.Println(u1.Name)   // 张三
u1.Age = 26

// 指针结构体（避免大结构体拷贝）
u4 := &User{Name: "王五", Age: 28}
u4.Age = 29   // Go 自动解引用，不需要 ->

// new 创建（返回指针，所有字段零值）
u5 := new(User)   // *User，Name="" Age=0

4.2 结构体方法

type Circle struct {
    Radius float64
}

// 值接收者：不修改原对象，操作的是副本
func (c Circle) Area() float64 {
    return 3.14 * c.Radius * c.Radius
}

// 指针接收者：可以修改原对象
func (c *Circle) Scale(factor float64) {
    c.Radius = c.Radius * factor
}

// 调用
c := Circle{Radius: 5}
fmt.Println(c.Area())    // 78.5
c.Scale(2)
fmt.Println(c.Radius)    // 10

何时用指针接收者：需要修改对象、结构体较大（避免拷贝）、保持一致性（建议一个类型的方法统一用指针或统一用值）。

4.3 结构体嵌套

type Address struct {
    City    string
    Street  string
}

type Employee struct {
    Name    string
    Address            // 匿名嵌套（类似继承）
}

e := Employee{
    Name: "张三",
    Address: Address{
        City:   "北京",
        Street: "长安街",
    },
}

// 直接访问内嵌字段
fmt.Println(e.City)    // 北京（直接访问，不需要 e.Address.City）

4.4 结构体标签（Tag）

标签常用于 JSON、数据库映射：

type User struct {
    ID       int    `json:"id" db:"user_id"`
    Name     string `json:"name"`
    Email    string `json:"email,omitempty"`   // omitempty: 零值时省略
    Password string `json:"-"`                 // - 表示忽略
}

五、JSON 处理

5.1 序列化（结构体 → JSON）

import "encoding/json"

type User struct {
    Name  string `json:"name"`
    Age   int    `json:"age"`
    Email string `json:"email,omitempty"`
}

user := User{Name: "张三", Age: 25, Email: "zhangsan@example.com"}

// 转成 JSON 字符串
data, err := json.Marshal(user)
if err != nil {
    log.Fatal(err)
}
fmt.Println(string(data))
// {"name":"张三","age":25,"email":"zhangsan@example.com"}

// 格式化输出（带缩进）
data, _ = json.MarshalIndent(user, "", "  ")
fmt.Println(string(data))

5.2 反序列化（JSON → 结构体）

jsonStr := `{"name":"李四","age":30}`

var user User
err := json.Unmarshal([]byte(jsonStr), &user)
if err != nil {
    log.Fatal(err)
}
fmt.Println(user.Name)  // 李四
fmt.Println(user.Age)   // 30

5.3 处理不确定结构

// 用 map 接收不确定结构的 JSON
var result map[string]interface{}
json.Unmarshal([]byte(jsonStr), &result)
fmt.Println(result["name"])   // 李四

// 读取嵌套字段（需要类型断言）
if data, ok := result["address"].(map[string]interface{}); ok {
    fmt.Println(data["city"])
}

六、字符串处理

6.1 strings 包

import "strings"

s := "Hello, World"

// 查找
strings.Contains(s, "World")          // true
strings.HasPrefix(s, "Hello")         // true
strings.HasSuffix(s, "World")         // true
strings.Index(s, "World")             // 7

// 变换
strings.ToUpper(s)                    // "HELLO, WORLD"
strings.ToLower(s)                    // "hello, world"
strings.TrimSpace("  hi  ")          // "hi"
strings.Trim("--hi--", "-")           // "hi"

// 分割与合并
strings.Split("a,b,c", ",")           // ["a", "b", "c"]
strings.Join([]string{"a","b"}, "-")  // "a-b"

// 替换
strings.Replace("foo bar foo", "foo", "baz", 1)  // "baz bar foo"（替换1次）
strings.ReplaceAll("foo bar foo", "foo", "baz")   // "baz bar baz"

// 重复
strings.Repeat("Go", 3)               // "GoGoGo"

6.2 strconv 包

import "strconv"

// 数字 → 字符串
strconv.Itoa(42)                            // "42"
strconv.FormatFloat(3.14, 'f', 2, 64)       // "3.14"
strconv.FormatBool(true)                    // "true"

// 字符串 → 数字
n, err := strconv.Atoi("42")               // 42
f, err := strconv.ParseFloat("3.14", 64)   // 3.14
b, err := strconv.ParseBool("true")         // true

七、小结

本文学习了 Go 的复合数据类型：

数组（长度固定，实际少用）和切片（动态数组，最常用）
Map（字典，注意零值和并发问题）
结构体（方法、嵌套、标签）
JSON 序列化与反序列化
strings 和 strconv 包

下一篇将学习接口与错误处理，这是 Go 的核心设计理念。

Go 学习笔记（二）：基础语法与数据类型

Tue, 05 May 2026 11:00:00 +0800

写在前面

本文是 Go 学习笔记系列的第二篇，介绍 Go 的基础语法，包括变量声明、数据类型、常量、流程控制和函数。前置知识：已完成 Go 环境搭建（第一篇）。

一、变量声明

1.1 var 声明

// 基本声明（类型在变量名后面）
var name string = "Go"

// 类型推断（省略类型）
var age = 18

// 声明但不赋值（使用零值）
var score int     // 0
var active bool   // false
var msg string    // ""（空字符串）

// 批量声明
var (
    x    int
    y    int
    flag bool
)

1.2 短变量声明 :=

// 只能在函数内使用
name := "Go"          // 等价于 var name string = "Go"
age := 18             // 等价于 var age int = 18
x, y := 1, 2          // 多变量同时声明

// 注意：左边至少要有一个新变量才能用 :=
name := "Go"
name := "Python"   // 编译错误，name 已声明
name, lang := "Go", 1   // 正确，lang 是新变量

何时用 var，何时用 :=：函数内优先用 :=；包级别变量、需要零值或指定类型时用 var。

1.3 零值

Go 的变量声明后如果没有赋值，会自动初始化为零值：

int       → 0
float64   → 0.0
bool      → false
string    → ""
pointer   → nil
slice     → nil
map       → nil
chan       → nil
interface → nil
func      → nil

1.4 匿名变量

// 用 _ 忽略不需要的返回值
_, err := os.Stat("/tmp/test")
if err != nil {
    fmt.Println("文件不存在")
}

二、基本数据类型

2.1 整型

var a int     = 10    // 平台相关（32位或64位）
var b int8    = 127   // -128 到 127
var c int16   = 1000
var d int32   = 100000
var e int64   = 1000000
var f uint    = 10    // 无符号，平台相关
var g uint8   = 255   // 0 到 255（也叫做 byte）
var h uintptr        // 存放指针

// 实际开发中最常用的是 int 和 int64
// uint8 的别名是 byte，int32 的别名是 rune（表示一个 Unicode 字符）

2.2 浮点型

var pi float32 = 3.14
var e  float64 = 2.71828

// 默认推断为 float64
x := 3.14    // float64

// 实际开发中基本都用 float64

2.3 布尔型

var active bool = true
var deleted bool   // false

// 不能用 0/1 代替布尔值
// var flag bool = 1  // 编译错误

2.4 字符串

s1 := "Hello"               // 双引号，可转义
s2 := `Hello\nWorld`        // 反引号，原样输出（\n 不会转义）
s3 := "你好，Go"            // UTF-8 编码，天然支持中文

// 字符串拼接
greeting := "Hello" + " " + "Go"

// 字符串长度
fmt.Println(len("Go"))       // 2（字节数）
fmt.Println(len("你好"))     // 6（每个中文3个字节）

// 字符串不可变（不能修改某个字符）
// s1[0] = 'h'  // 编译错误

// 遍历字符串
for i, ch := range "你好Go" {
    fmt.Printf("%d: %c\n", i, ch)  // 按 rune 遍历，不会乱码
}

2.5 字符类型

// byte 是 uint8 的别名，表示 ASCII 字符
// rune 是 int32 的别名，表示一个 Unicode 字符

var ch byte = 'A'     // 65
var zh  rune = '中'   // 20013

fmt.Printf("%c\n", ch)   // A
fmt.Printf("%c\n", zh)   // 中

2.6 类型转换

Go 没有隐式类型转换，必须显式转换：

var i int = 42
var f float64 = float64(i)    // int → float64
var j int = int(f)            // float64 → int

// string 和数字互转（需要用 strconv 包）
import "strconv"

s := strconv.Itoa(42)         // int → string："42"
n, err := strconv.Atoi("42")  // string → int：42
f := strconv.FormatFloat(3.14, 'f', 2, 64)  // float64 → string："3.14"

三、常量

3.1 基本用法

const pi = 3.14159
const greeting string = "Hello"

// 批量声明
const (
    StatusOK    = 200
    StatusError = 500
)

3.2 iota 枚举

iota 是 Go 的常量生成器，在 const 块中每行自动加 1：

const (
    Sunday    = iota   // 0
    Monday             // 1
    Tuesday            // 2
    Wednesday          // 3
    Thursday           // 4
    Friday             // 5
    Saturday           // 6
)

// 跳过值
const (
    _  = iota   // 0（跳过）
    KB = 1 << (10 * iota)  // 1 << 10 = 1024
    MB                      // 1 << 20
    GB                      // 1 << 30
    TB                      // 1 << 40
)

四、流程控制

4.1 if-else

age := 18

// 基本用法
if age >= 18 {
    fmt.Println("成年")
} else {
    fmt.Println("未成年")
}

// if 带初始化语句（常用模式）
if err := doSomething(); err != nil {
    fmt.Println("出错:", err)
}
// err 只在 if-else 块内有效

// 多条件
if score >= 90 {
    fmt.Println("优秀")
} else if score >= 60 {
    fmt.Println("及格")
} else {
    fmt.Println("不及格")
}

Go 的 if 不需要小括号，但花括号必须有。

4.2 for 循环

Go 只有 for 一种循环，没有 while：

// 经典 for
for i := 0; i < 10; i++ {
    fmt.Println(i)
}

// 当作 while 用
n := 0
for n < 10 {
    fmt.Println(n)
    n++
}

// 无限循环
for {
    // break 或 return 退出
    break
}

// for-range 遍历（类似 foreach）
names := []string{"Go", "Python", "Java"}
for index, value := range names {
    fmt.Println(index, value)
}

// 只要 value 不要 index
for _, value := range names {
    fmt.Println(value)
}

4.3 switch

day := "Monday"

// 基本用法（自动 break，不需要手动加）
switch day {
case "Monday":
    fmt.Println("周一")
case "Tuesday":
    fmt.Println("周二")
default:
    fmt.Println("其他")
}

// 多值匹配
switch score {
case 90, 100:
    fmt.Println("优秀")
case 80:
    fmt.Println("良好")
}

// 无条件 switch（替代 if-else if 链）
score := 85
switch {
case score >= 90:
    fmt.Println("优秀")
case score >= 80:
    fmt.Println("良好")
case score >= 60:
    fmt.Println("及格")
default:
    fmt.Println("不及格")
}

// fallthrough：穿透到下一个 case（少用）
switch x {
case 1:
    fmt.Println("1")
    fallthrough   // 无条件执行下一个 case
case 2:
    fmt.Println("2")
}

4.4 defer

defer 延迟执行，在函数返回前执行，常用于资源释放：

func readFile(path string) {
    file, err := os.Open(path)
    if err != nil {
        return
    }
    defer file.Close()   // 函数返回前自动关闭文件

    // 读取文件...
}

// 多个 defer 按 LIFO（后进先出）顺序执行
func main() {
    defer fmt.Println("第一")
    defer fmt.Println("第二")
    defer fmt.Println("第三")
    fmt.Println("先执行")
}
// 输出：
// 先执行
// 第三
// 第二
// 第一

// defer 的参数在声明时就确定了
func main() {
    x := 1
    defer fmt.Println(x)  // 输出 1，不是 2
    x = 2
}

4.5 break 和 continue

// break 跳出当前循环
for i := 0; i < 10; i++ {
    if i == 5 {
        break
    }
    fmt.Println(i)  // 0 1 2 3 4
}

// continue 跳过本次迭代
for i := 0; i < 10; i++ {
    if i%2 == 0 {
        continue
    }
    fmt.Println(i)  // 1 3 5 7 9
}

// 跳出外层循环（使用标签）
outer:
for i := 0; i < 3; i++ {
    for j := 0; j < 3; j++ {
        if i == 1 && j == 1 {
            break outer   // 跳出外层循环
        }
    }
}

五、函数

5.1 基本定义

// 基本函数
func add(a int, b int) int {
    return a + b
}

// 相同类型的参数可以省略前面的类型
func add(a, b int) int {
    return a + b
}

// 调用
result := add(1, 2)

5.2 多返回值

// Go 函数可以返回多个值（非常常用）
func divide(a, b float64) (float64, error) {
    if b == 0 {
        return 0, errors.New("除数不能为零")
    }
    return a / b, nil
}

// 调用
result, err := divide(10, 3)
if err != nil {
    fmt.Println("出错:", err)
} else {
    fmt.Println("结果:", result)
}

5.3 命名返回值

// 给返回值命名，可以在函数内直接赋值
func rectangle(length, width float64) (area, perimeter float64) {
    area = length * width
    perimeter = 2 * (length + width)
    return   // 裸 return，自动返回 area 和 perimeter
}

5.4 可变参数

// 可变参数（类似 Java 的 ...params）
func sum(nums ...int) int {
    total := 0
    for _, n := range nums {
        total += n
    }
    return total
}

// 调用
sum(1, 2, 3)        // 6
sum(1, 2, 3, 4, 5)  // 15

// 展开切片
numbers := []int{1, 2, 3}
sum(numbers...)      // 传切片时加 ...

5.5 函数是一等公民

// 函数作为变量
add := func(a, b int) int {
    return a + b
}
fmt.Println(add(1, 2))  // 3

// 函数作为参数（回调）
func apply(nums []int, fn func(int) int) []int {
    result := make([]int, len(nums))
    for i, n := range nums {
        result[i] = fn(n)
    }
    return result
}

doubled := apply([]int{1, 2, 3}, func(n int) int {
    return n * 2
})
// doubled = [2, 4, 6]

// 函数作为返回值（闭包）
func counter() func() int {
    count := 0
    return func() int {
        count++
        return count
    }
}

c := counter()
fmt.Println(c())  // 1
fmt.Println(c())  // 2
fmt.Println(c())  // 3

六、指针

6.1 基本用法

x := 42
p := &x         // & 取地址，p 是 *int 类型

fmt.Println(p)   // 地址，如 0xc0000b2008
fmt.Println(*p)  // * 解引用，输出 42

*p = 100         // 通过指针修改值
fmt.Println(x)   // 100

6.2 指针作为函数参数

// 不用指针：值传递，函数内修改不影响外部
func double(n int) {
    n = n * 2   // 只修改了副本
}

// 用指针：可以在函数内修改外部变量
func doublePtr(n *int) {
    *n = *n * 2
}

x := 10
double(x)
fmt.Println(x)   // 10（没变）

doublePtr(&x)
fmt.Println(x)   // 20（变了）

Go 指针不能做指针运算（不能 p++），比 C 安全得多。实际开发中指针主要用于结构体方法（接收者）和避免大对象拷贝。

七、小结

本文学习了 Go 的基础语法：

变量声明（var、:=、零值）
基本数据类型（整型、浮点、字符串、布尔）和类型转换
常量与 iota 枚举
流程控制（if、for、switch、defer）
函数（多返回值、可变参数、一等公民）
指针基础

下一篇将学习复合数据类型：数组、切片、字典和结构体。

Go 学习笔记（一）：环境搭建与入门基础

Tue, 05 May 2026 10:00:00 +0800

写在前面

这是 Go 学习笔记系列的第一篇，目标是从零搭建 Go 开发环境，理解项目结构和常用工具链。读完本文你将能够独立创建、编译、运行一个 Go 项目。

本系列适合有其他语言编程经验、刚开始学 Go 的开发者。

一、安装 Go

1.1 下载安装

到 Go 官方网站下载对应系统的安装包：

官网：https://go.dev/dl/
国内镜像：https://golang.google.cn/dl/

# 安装后验证
go version
# go version go1.24.x linux/amd64

# 查看 Go 安装路径
go env GOROOT
# /usr/local/go

1.2 环境变量

Go 安装后会自动配置，一般不需要手动设置。了解即可：

1
2
3

GOROOT — Go 的安装目录（类似 JAVA_HOME）
GOPATH — Go 的工作空间目录（旧版本项目放这里，go mod 之后不太重要了）
GOBIN  — go install 安装的可执行文件存放路径（默认 $GOPATH/bin）

# 查看所有环境变量
go env

# 设置 Go 代理（国内加速模块下载）
go env -w GOPROXY=https://goproxy.cn,direct

1.3 开发工具

推荐使用 VS Code + Go 扩展，或 GoLand（JetBrains 出品）。

VS Code 安装 Go 扩展后会自动提示安装相关工具（gopls、dlv 等），全部安装即可。

二、第一个 Go 程序

2.1 创建项目

# 创建项目目录
mkdir hello && cd hello

# 初始化 Go 模块（类似 npm init）
go mod init example.com/hello
# 会生成 go.mod 文件，内容：
# module example.com/hello
# go 1.24

2.2 编写代码

创建 main.go：

package main

import "fmt"

func main() {
    fmt.Println("Hello, Go!")
}

2.3 运行

# 直接运行（不生成可执行文件）
go run main.go
# Hello, Go!

# 编译生成可执行文件
go build -o hello main.go

# 运行编译后的文件
./hello
# Hello, Go!

三、代码结构解析

3.1 package 声明

// 每个 Go 文件必须以 package 声明开头
// main 包是特殊的，定义了可执行程序的入口
package main

// 其他包名通常和目录名一致
package utils    // 放在 utils/ 目录下
package models   // 放在 models/ 目录下

3.2 import 导入

// 单个导入
import "fmt"

// 多个导入（推荐写法）
import (
    "fmt"
    "os"
    "strings"
)

// 导入但不直接使用（只执行 init 函数）
import _ "github.com/lib/pq"

// 给包起别名
import (
    f "fmt"
)

// 使用别名调用
f.Println("hello")

注意：Go 要求导入的包必须使用，未使用的导入会编译报错。

3.3 main 函数

// main 包中的 main 函数是程序入口
// 没有 main 函数无法编译成可执行文件
func main() {
    // 程序从这里开始执行
}

3.4 语句规则

// 不需要分号（编译器自动添加）
fmt.Println("hello")

// 左花括号不能换行（编译错误）
// 错误写法：
// func main()
// {
// }

// 正确写法：
func main() {
}

四、go mod 包管理

Go 从 1.11 开始使用 Go Modules 管理依赖，类似 npm、pip。

4.1 常用命令

# 初始化模块
go mod init example.com/myproject

# 添加依赖（import 后执行，自动下载）
go mod tidy

# 下载依赖到本地缓存
go mod download

# 查看依赖列表
go list -m all

# 查看某个依赖的可用版本
go list -m -versions github.com/gin-gonic/gin

4.2 go.mod 文件

module example.com/myproject    // 模块名
go 1.24                         // Go 版本

require (
    github.com/gin-gonic/gin v1.10.0    // 直接依赖
)

4.3 安装第三方包

# 安装指定包（会加到 go.mod）
go get github.com/gin-gonic/gin@latest

# 安装指定版本
go get github.com/gin-gonic/gin@v1.10.0

# 清理未使用的依赖
go mod tidy

# 把依赖复制到项目的 vendor 目录
go mod vendor

4.4 项目结构示例

myproject/
├── go.mod          // 模块定义和依赖
├── go.sum          // 依赖的校验和（自动生成，不要手动改）
├── main.go         // 程序入口
├── internal/       // 私有代码（其他模块不能导入）
│   └── handler/
│       └── user.go
├── pkg/            // 可被外部导入的包
│   └── utils/
│       └── string.go
└── cmd/            // 多个可执行程序
    └── server/
        └── main.go

五、工具链

5.1 常用命令

# 运行
go run main.go

# 编译
go build                # 编译当前包
go build -o app .       # 指定输出文件名
go build ./...          # 编译当前目录下所有包

# 测试
go test                 # 运行当前包的测试
go test ./...           # 运行所有测试
go test -v ./...        # 详细输出
go test -run TestName   # 运行指定测试函数

# 格式化代码
go fmt ./...            # 格式化所有文件
gofmt -w .              # 另一种写法（-w 直接修改文件）

# 静态检查
go vet ./...            # 发现常见错误

# 安装可执行工具
go install github.com/go-delve/delve/cmd/dlv@latest

5.2 go run vs go build

1
2

go run   — 编译并立即运行，适合开发调试
go build — 编译生成可执行文件，适合部署分发

5.3 交叉编译

Go 支持交叉编译，在任意平台编译其他平台的可执行文件：

# 编译 Linux 可执行文件（在 Windows/Mac 上执行）
GOOS=linux GOARCH=amd64 go build -o app-linux .

# 编译 Windows 可执行文件
GOOS=windows GOARCH=amd64 go build -o app.exe .

# 编译 Mac 可执行文件
GOOS=darwin GOARCH=arm64 go build -o app-mac .

# Windows 下交叉编译（PowerShell）
$env:GOOS="linux"; $env:GOARCH="amd64"; go build -o app-linux .

六、输出与基本 I/O

6.1 fmt 包 — 格式化输出

package main

import "fmt"

func main() {
    name := "Go"
    version := 1.24

    // 基本输出
    fmt.Println("Hello", name)        // 输出后换行
    fmt.Printf("版本: %.2f\n", version) // 格式化输出

    // 格式化并返回字符串（不输出）
    s := fmt.Sprintf("Hello %s", name)

    // 格式化动词
    fmt.Printf("字符串: %s\n", "hello")     // 字符串
    fmt.Printf("整数: %d\n", 42)            // 十进制整数
    fmt.Printf("浮点: %.2f\n", 3.14159)     // 保留2位小数
    fmt.Printf("布尔: %t\n", true)          // 布尔值
    fmt.Printf("类型: %T\n", name)          // 变量类型
    fmt.Printf("值: %v\n", struct{}{})      // 默认格式
    fmt.Printf("详细: %+v\n", struct{}{})   // 带字段名
}

6.2 常用格式化动词

%s — 字符串
%d — 十进制整数
%f — 浮点数（%.2f 保留2位小数）
%t — 布尔值
%T — 类型
%v — 默认格式（万能）
%+v — 带字段名的格式（用于结构体）
%p — 指针地址
%c — 字符（Unicode 码点转字符）
%02d — 至少2位，不足补0

七、小结

本文完成了以下内容：

Go 环境安装与配置
第一个 Go 程序的编写与运行
Go 代码的基本结构（package、import、main）
go mod 依赖管理
常用工具链命令

下一篇将学习 Go 的基础语法，包括变量声明、数据类型、流程控制和函数。