初识 GoLang

go mod init <模块名>
# 例如：go mod init hello

module hello

go 1.21

# 安装指定版本的 Go
go install golang.org/dl/go1.16.15@latest
go1.16.15 download

# 使用指定版本编译项目
go1.16.15 build main.go
go1.16.15 run main.go

hello/
├── go.mod      ← 模块声明文件
└── main.go     ← 程序入口

package main // 声明属于 main 包，Go 中可执行程序必须在 main 包内

import "fmt" // 导入格式化输出标准库

func main() { // main 函数是程序执行入口
    fmt.Println("Hello, World!")
}

# 方式一：直接运行（开发阶段常用）
go run main.go

# 方式二：编译为可执行文件
go build
.\hello.exe

go env              # 查看所有环境变量
go env GOPATH       # 查看 GOPATH
go env GOPROXY      # 查看代理配置
go env GOROOT       # 查看 Go SDK 安装目录
go env -w KEY=VALUE # 永久写入环境变量配置

func TestHello(t *testing.T) {
    got := say_hello()       // 第一步：执行目标函数，获取实际结果
    want := "Hello World!"   // 第二步：定义期望的正确结果

    if got != want {         // 第三步：比对两者，不一致则报错
        t.Errorf("got '%q' want '%q'", got, want)
    }
}

go test          # 运行当前包的所有测试
go test -v       # 显示详细输出（包括每个测试函数的名称和结果）
go test -run Xxx # 仅运行函数名匹配 Xxx 的测试

got := say_hello()        // 自动推断 got 的类型为 say_hello() 的返回类型
count := 42               // 自动推断为 int
pi := 3.14                // 自动推断为 float64

drink := "可乐"   // 创建新变量（:=）
drink = "雪碧"    // 修改已有变量的值（=）
// drink := "雪碧" // ❌ 错误：不能对已存在的变量再次使用 :=

var a int = 100
var b int64

// b = a           // ❌ 编译错误：cannot use a (type int) as type int64
b = int64(a)       // ✅ 必须显式类型转换

// 降序排列：从大到小
sort.Sort(sort.Reverse(sort.IntSlice(ints)))

// 方式一：自定义排序规则（Go 1.8+）
sort.Slice(ints, func(i, j int) bool {
    return ints[i] > ints[j] // 降序
})

// 方式二：使用 slices 标准库（Go 1.21+）
import "slices"
slices.Sort(ints)      // 升序
slices.Reverse(ints)   // 物理反转（这里的 Reverse 才是真正的反转动作）

if score >= 90 {
    fmt.Println("优秀")
} else if score >= 60 {   // ✅ 必须和 } 同行
    fmt.Println("及格")
} else {
    fmt.Println("不及格")
}

func SaveUser(user *User) error {
    if user == nil {
        return errors.New("用户不存在")   // 提前退出
    }
    if user.Age < 0 {
        return errors.New("年龄非法")     // 提前退出
    }

    // 核心业务：所有校验通过后才执行，无嵌套负担
    db.Save(user)
    return nil
}

switch {
case score >= 90:
    fmt.Println("优秀")
case score >= 60:
    fmt.Println("及格")
default:
    fmt.Println("不及格")
}

func change(age *int) {   // 接收指针
    *age = 20              // 通过指针修改原始值
}

func main() {
    a := 18
    change(&a)             // 传递 a 的内存地址
    fmt.Println(a)         // 输出 20
}

type slice struct {
    array unsafe.Pointer   // 指向底层数组的指针
    len   int              // 切片长度
    cap   int              // 切片容量
}

go pay("张三")   // 启动一个新协程执行 pay 函数
go pay("李四")   // 再启动一个，与上一个并行执行
go pay("王五")   // 三个协程几乎同时运行

var wg sync.WaitGroup

func pay(name string) {
    defer wg.Done()           // 函数结束时计数器 -1
    fmt.Printf("%s 在付钱\n", name)
    time.Sleep(1 * time.Second)
}

func main() {
    startTime := time.Now()
    wg.Add(3)                 // 告知计数器：共有 3 个协程需要等待

    go pay("张三")
    go pay("李四")
    go pay("王五")

    wg.Wait()                 // 阻塞主协程，直到计数器归 0
    fmt.Println("总耗时:", time.Since(startTime))
}

var num int32 = 3

func pay(name string) {
    fmt.Printf("%s 在付钱\n", name)
    time.Sleep(1 * time.Second)
    atomic.AddInt32(&num, -1)     // 原子减 1，硬件级别保证安全
}

for {
    if atomic.LoadInt32(&num) == 0 {
        break
    }
    runtime.Gosched()    // 主动让出 CPU 时间片，让子协程有机会执行
    // 或使用 time.Sleep(1 * time.Millisecond) 短暂休眠
}

call of pay copies lock value: sync.WaitGroup contains sync.noCopy

func pay(name string, wait sync.WaitGroup) {   // ❌ 值传递，产生副本
    fmt.Printf("%s 在付钱\n", name)
    time.Sleep(1 * time.Second)
    wait.Done()   // 操作的是副本的计数器，对原始对象无效
}

func main() {
    var wait sync.WaitGroup
    wait.Add(3)
    go pay("张三", wait)   // ❌ 把整个 WaitGroup 拷贝了一份传进去
    go pay("李四", wait)
    go pay("王五", wait)
    wait.Wait()            // 永远等不到计数器归零 → 死锁
}

func pay(name string, wait *sync.WaitGroup) {  // ✅ 指针传递
    defer wait.Done()
    fmt.Printf("%s 在付钱\n", name)
    time.Sleep(1 * time.Second)
}

func main() {
    var wait sync.WaitGroup
    wait.Add(3)
    go pay("张三", &wait)   // ✅ 传递地址，所有协程共享同一个计数器
    go pay("李四", &wait)
    go pay("王五", &wait)
    wait.Wait()
}

var moneyChan = make(chan int)   // 无缓冲信道

func pay(name string, money int, wait *sync.WaitGroup) {
    defer wait.Done()
    fmt.Printf("%s 在付钱\n", name)
    time.Sleep(1 * time.Second)
    moneyChan <- money           // 向信道发送数据
}

func main() {
    var wait sync.WaitGroup
    wait.Add(3)

    startTime := time.Now()
    go pay("张三", 2, &wait)
    go pay("李四", 3, &wait)
    go pay("王五", 5, &wait)

    // 关键：用独立协程等待完成并关闭信道
    go func() {
        defer close(moneyChan)
        wait.Wait()
    }()

    var moneyList []int
    for val := range moneyChan {
        moneyList = append(moneyList, val)
    }

    fmt.Println("总耗时:", time.Since(startTime))
    fmt.Println(moneyList)
}

// ❌ 错误写法：会死锁
func() {
    defer close(moneyChan)
    wait.Wait()          // 主协程被卡在这里
}()

// 下面这行永远执行不到
for val := range moneyChan { ... }

┌─────────────────────────────────────────────────────────────────┐
│                        ❌ 不加 go 的情况                        │
├──────────────────┬──────────────────────────────────────────────┤
│ 主协程           │ pay 协程（×3）                               │
├──────────────────┼──────────────────────────────────────────────┤
│ wait.Wait() 阻塞 │ 执行到 moneyChan <- money                   │
│ 等 Done() 被调用 │ 无缓冲信道，等待有人接收……                   │
│                  │ 没人接收 → 无法继续 → Done() 永远不会被调用  │
│ 永远等不到 Done  │                                              │
│       💀 双方互等 = 死锁                                        │
└─────────────────────────────────────────────────────────────────┘

┌─────────────────────────────────────────────────────────────────┐
│                        ✅ 加 go 的情况                          │
├──────────────────┬───────────────┬──────────────────────────────┤
│ 主协程           │ 监听协程       │ pay 协程（×3）              │
├──────────────────┼───────────────┼──────────────────────────────┤
│                  │ wait.Wait()   │                              │
│                  │ 后台等待中……  │                              │
│ for range 接收数据│              │ moneyChan <- money 发送成功  │
│ 收到数据 ✓       │              │ defer Done() 计数器 -1       │
│ ……继续接收……     │              │ ……3个协程依次完成……          │
│                  │ 计数器归 0 ✓  │                              │
│                  │ close(chan) ✓ │                              │
│ range 感知关闭   │              │                              │
│ 退出循环 ✓       │              │                              │
└──────────────────┴───────────────┴──────────────────────────────┘

// 定义并立即调用（IIFE：Immediately Invoked Function Expression）
func() {
    fmt.Println("我被立即执行了")
}()   // ← 这对括号 = 立刻调用

go func(msg string, times int) {
    for i := 0; i < times; i++ {
        fmt.Println(msg)
    }
}("你好", 3)    // ← 传入参数并立即执行

var moneyChan = make(chan int)
var nameChan = make(chan string)

func pay(name string, money int, wait *sync.WaitGroup) {
    defer wait.Done()
    moneyChan <- money   // 第一步：发送 money
    nameChan <- name     // 第二步：发送 name（必须等第一步完成）
}

func main() {
    // ...启动 3 个 pay 协程...

    go func() {
        defer close(moneyChan)
        defer close(nameChan)
        wait.Wait()
    }()

    // ❌ 顺序读取：先读完 moneyChan，再读 nameChan
    for money := range moneyChan {
        moneyList = append(moneyList, money)
    }
    for name := range nameChan {
        nameList = append(nameList, name)
    }
}

┌──────────────────────────────────────────────────────────────────────┐
│                         死锁全过程                                    │
├──────────────────┬───────────────────────────────────────────────────┤
│ 主协程           │ 3 个 pay 协程                                     │
├──────────────────┼───────────────────────────────────────────────────┤
│ for range        │ moneyChan <- money  ✅ 发送成功（主协程在接收）    │
│ 收到 3 个 money  │                                                   │
│ 等待更多数据……   │ nameChan <- name  ❌ 阻塞！无人接收               │
│                  │ （卡死在此，defer wait.Done() 永远不会执行）       │
│ 因信道未关闭     │                                                   │
│ 无法退出循环     │                                                   │
│       💀 所有 Goroutine 互等 = 死锁                                  │
└──────────────────┴───────────────────────────────────────────────────┘

go func() {
    defer close(moneyChan) // ① 第一个入栈 → 最后执行
    defer close(nameChan)  // ② 第二个入栈 → 倒数第二执行
    defer close(doneChan)  // ③ 最后入栈 → 最先执行
    wait.Wait()
}()

var quit = make(chan struct{})   // 空结构体不占内存，专用于信号传递

// 100 个工作协程都在监听同一个退出信号
for i := 0; i < 100; i++ {
    go func() {
        for {
            select {
            case <-quit:
                fmt.Println("收到退出信号，安全退出")
                return
            default:
                // 继续执行正常工作……
            }
        }
    }()
}

// 主协程只需关闭一次，100 个协程全部同时收到信号
close(quit)

// ✅ 正确：doneChan 最先关闭，触发 select 退出，避免读到脏数据
defer close(moneyChan)   // 第三个关闭
defer close(nameChan)    // 第二个关闭
defer close(doneChan)    // 第一个关闭 → 主协程 select 立即退出

// ❌ 危险：moneyChan/nameChan 先关闭，doneChan 最后才关闭
defer close(doneChan)    // 第三个关闭（太迟了！）
defer close(moneyChan)   // 第二个关闭
defer close(nameChan)    // 第一个关闭
// 在 doneChan 关闭之前的真空期，select 会疯狂从已关闭的信道中收到零值

for {
    select {
    case money, ok := <-moneyChan:
        if ok {
            moneyList = append(moneyList, money)
        }
    case name, ok := <-nameChan:
        if ok {
            nameList = append(nameList, name)
        }
    case <-doneChan:
        // 收到退出信号，结束循环
        return
    }
}

value, ok := <-channel

var moneyChan = make(chan int)
var nameChan = make(chan string)
var doneChan = make(chan struct{})   // 空结构体信道，专用于退出信号

func pay(name string, money int, wait *sync.WaitGroup) {
    defer wait.Done()
    fmt.Printf("%s 在付钱\n", name)
    time.Sleep(1 * time.Second)
    moneyChan <- money
    nameChan <- name
}

func main() {
    var wait sync.WaitGroup
    wait.Add(3)

    startTime := time.Now()
    go pay("张三", 2, &wait)
    go pay("李四", 3, &wait)
    go pay("王五", 5, &wait)

    // 后台协程：等待所有任务完成后，按正确顺序关闭信道
    go func() {
        defer close(moneyChan)     // 第三个关闭
        defer close(nameChan)      // 第二个关闭
        defer close(doneChan)      // 第一个关闭（触发退出信号）
        wait.Wait()
    }()

    var moneyList []int
    var nameList []string

    // select 多路复用：同时监听数据信道和退出信号
    for {
        select {
        case money, ok := <-moneyChan:
            if ok {
                moneyList = append(moneyList, money)
            }
        case name, ok := <-nameChan:
            if ok {
                nameList = append(nameList, name)
            }
        case <-doneChan:
            fmt.Println("总耗时:", time.Since(startTime))
            fmt.Println(moneyList)
            fmt.Println(nameList)
            return
        }
    }
}

func counter() func() int {
    n := 0
    return func() int {
        n++
        return n
    }
}

func add() int {
    n := 0
    n++
    return n
}

count := 0
for i := 0; i < 3; i++ {
    count++
    fmt.Println(count)
}

c1 := counter()
c2 := counter()

fmt.Println(c1()) // 1
fmt.Println(c1()) // 2
fmt.Println(c2()) // 1

func prefixLogger(prefix string) func(string) {
    return func(msg string) {
        fmt.Println(prefix, msg)
    }
}

for i := 0; i < 3; i++ {
    go func(v int) {
        fmt.Println(v)
    }(i)
}

具体值 := 接口变量.(目标类型)

var box interface{} = "hello"

str := box.(string)       // ✅ 猜对了，str = "hello"
num := box.(int)          // ❌ 猜错了，程序直接 Panic 崩溃！

var box interface{} = 666

if str, ok := box.(string); ok {
    fmt.Println("猜对了！值是:", str)
} else {
    fmt.Println("猜错了，它不是字符串") // 程序不会崩溃，走到这里
}

switch v1.Elem().Kind() {
case reflect.String:
    // 方式 A：通过类型断言从 interface{} 直接提取原生 string
    v1.Elem().SetString(value.(string))
case reflect.Int:
    // 方式 B：通过反射对象的 .Int() 方法提取原生 int64
    v1.Elem().SetInt(v2.Int())
}

file, err := os.Open("test.txt")    // 文件操作
resp, err := http.Get("https://...")  // 网络请求
rows, err := db.Query("SELECT ...")   // 数据库查询

var data map[string]interface{}
json.Unmarshal(body, &data)

if name, ok := data["name"].(string); ok {
    fmt.Println("用户名:", name)
}
if age, ok := data["age"].(float64); ok {  // JSON 数字默认解析为 float64
    fmt.Println("年龄:", int(age))
}

if netErr, ok := err.(net.Error); ok {
    if netErr.Timeout() {
        fmt.Println("网络超时，正在重试……")
    }
}

func describe(value interface{}) {
    switch v := value.(type) {   // 特殊语法：.(type) 只能在 switch 中使用
    case string:
        fmt.Println("字符串，长度:", len(v))
    case int:
        fmt.Println("整数，值:", v)
    case bool:
        fmt.Println("布尔值:", v)
    default:
        fmt.Println("未知类型")
    }
}