go学习计划

Table of Contents

让 DeepSeek 给我生成了一个快速的 go 学习计划，它说需要 2-3 个月，可是我没那么多时间，只有 2 到 3 天，打个对折吧，2-3 天学一半，应该问题不大

第一章：基础语法（深度扩展）

示例 1：作用域与闭包

func scopeDemo() {
    x := 10
    { // 代码块作用域
        x := 20  // 新建局部变量
        fmt.Println(x) // 20
    }
    fmt.Println(x) // 10

    // 闭包捕获变量
    adder := func() func(int) int {
        sum := 0
        return func(n int) int {
            sum += n
            return sum
        }
    }
    a := adder()
    fmt.Println(a(1), a(2)) // 1, 3
}

示例 2：类型转换与断言

func typeConversion() {
    // 基本类型转换
    var i int = 42
    f := float64(i)

    // 接口类型断言
    var val interface{} = "hello"
    if s, ok := val.(string); ok {
        fmt.Println(s + " world!") // hello world!
    }
}

示例 3：常量与 iota

const (
    _ = iota  // 忽略0
    KB = 1 << (10 * iota) // 1 << 10
    MB                     // 1 << 20
)

func main() {
    fmt.Println(KB, MB) // 1024 1048576
}

第二章：数据结构（实战强化）

示例 1：切片高级操作

func sliceAdvanced() {
    // 预分配容量
    s := make([]int, 0, 5)  // len=0, cap=5
    s = append(s, 1,2,3)

    // 内存共享机制
    arr := []int{1,2,3,4,5}
    s1 := arr[1:3]  // [2,3] (cap=4)
    s2 := s1[:4]     // 扩展至底层数组末尾 [2,3,4,5]
}

示例 2：结构体嵌套

type Address struct {
    City string
    Zip  string
}

type User struct {
    Name    string
    Age     int
    Address // 匿名嵌套
}

func main() {
    u := User{
        Name: "Alice",
        Age:  25,
        Address: Address{City: "Beijing", Zip: "100000"},
    }
    fmt.Println(u.City) // 直接访问嵌套字段
}

示例 3：JSON 序列化

type Book struct {
    Title  string `json:"title"`
    Author string `json:"author,omitempty"` // omitempty表示空值忽略
}

func main() {
    b := Book{Title: "Go语言实战"}
    data, _ := json.Marshal(b)
    fmt.Println(string(data)) // {"title":"Go语言实战"}
}

第三章：并发编程（工业级案例）

示例 1：工作池模式

func workerPool() {
    jobs := make(chan int, 100)
    results := make(chan int, 100)

    // 启动3个worker
    for w := 1; w <= 3; w++ {
        go func(id int) {
            for j := range jobs {
                fmt.Printf("Worker %d processing job %d\n", id, j)
                results <- j * 2
            }
        }(w)
    }

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

    // 收集结果
    for a := 1; a <= 5; a++ {
        <-results
    }
}

示例 2：通道超时控制

func fetchWithTimeout(url string) (string, error) {
    ch := make(chan string, 1)
    go func() {
        resp, _ := http.Get(url)
        defer resp.Body.Close()
        body, _ := io.ReadAll(resp.Body)
        ch <- string(body)
    }()

    select {
    case res := <-ch:
        return res, nil
    case <-time.After(2 * time.Second): // 2秒超时
        return "", fmt.Errorf("timeout")
    }
}

示例 3：sync.WaitGroup 同步

func waitGroupDemo() {
    var wg sync.WaitGroup
    urls := []string{"url1", "url2", "url3"}

    for _, url := range urls {
        wg.Add(1)
        go func(u string) {
            defer wg.Done()
            http.Get(u) // 模拟请求
            fmt.Println("Done:", u)
        }(url)
    }
    wg.Wait() // 等待所有完成
    fmt.Println("All jobs done")
}

第四章：工程实践（生产级代码）

示例 1：Gin 中间件

func AuthMiddleware() gin.HandlerFunc {
    return func(c *gin.Context) {
        token := c.GetHeader("Authorization")
        if token != "valid_token" {
            c.AbortWithStatusJSON(401, gin.H{"error": "Unauthorized"})
            return
        }
        c.Next()
    }
}

func main() {
    r := gin.Default()
    r.Use(AuthMiddleware()) // 全局中间件
    r.GET("/secure", func(c *gin.Context) {
        c.String(200, "Secret Data")
    })
}

示例 2：Viper 配置读取

func loadConfig() {
    viper.SetConfigName("config")
    viper.AddConfigPath(".")
    viper.SetConfigType("yaml")

    if err := viper.ReadInConfig(); err != nil {
        panic(err)
    }

    fmt.Println("DB Host:", viper.GetString("database.host"))
}

// config.yaml内容：
// database:
//   host: localhost
//   port: 3306

示例 3：单元测试

// math.go
func Add(a, b int) int {
    return a + b
}

// math_test.go
func TestAdd(t *testing.T) {
    tests := []struct {
        a, b, expected int
    }{
        {2, 3, 5},
        {-1, 1, 0},
    }

    for _, test := range tests {
        result := Add(test.a, test.b)
        if result != test.expected {
            t.Errorf("Add(%d, %d) = %d, 期望 %d",
                test.a, test.b, result, test.expected)
        }
    }
}

第五章：实战项目（复杂场景）

项目 1：JWT 用户认证系统

// 生成JWT令牌
func GenerateToken(userID string) (string, error) {
    token := jwt.NewWithClaims(jwt.SigningMethodHS256, jwt.MapClaims{
        "user_id": userID,
        "exp":     time.Now().Add(24 * time.Hour).Unix(),
    })
    return token.SignedString([]byte("your_secret_key"))
}

// 验证中间件
func JWTVerify() gin.HandlerFunc {
    return func(c *gin.Context) {
        tokenString := c.GetHeader("Authorization")
        // 验证逻辑...
    }
}

项目 2：GORM 事务处理

func TransferMoney(db *gorm.DB, from, to uint, amount float64) error {
    tx := db.Begin()
    defer func() {
        if r := recover(); r != nil {
            tx.Rollback()
        }
    }()

    // 扣款
    if err := tx.Model(&Account{}).Where("id = ?", from).
        Update("balance", gorm.Expr("balance - ?", amount)).Error; err != nil {
        tx.Rollback()
        return err
    }

    // 存款
    if err := tx.Model(&Account{}).Where("id = ?", to).
        Update("balance", gorm.Expr("balance + ?", amount)).Error; err != nil {
        tx.Rollback()
        return err
    }

    return tx.Commit().Error
}

学习效果验证

完成所有示例后，尝试实现以下功能：

  1. 编写一个并发执行的网页爬虫，控制最大并发数为 5
  2. 使用 Gin+GORM 实现一个支持 CRUD 的 API 服务
  3. 开发一个命令行工具，支持配置文件读取和日志记录

明天再让 DeepSeek 给我生成一份 NextJS 的学习计划