1. channel关闭后读的问题

当 channel 关闭之后再去读取它，虽然不会引发 panic，但会直接得到零值，而且 ok 的值为 false。

package main

import "fmt"

func main() {
    ch := make(chan int)
    go func() {
        for i := 0; i < 5; i++ {
            ch <- i
        }
        close(ch) // 发送完毕后关闭channel
    }()

    // 方法1:一旦 channel 关闭，循环就会自行终止
    fmt.Println("方法1:")
    for num := range ch {
        fmt.Println("接收到:", num)
    }

    // 方法2：明确判断出数据是正常接收到的，还是因为 channel 关闭而得到的零值
    ch = make(chan int)
    go func() {
        for i := 0; i < 5; i++ {
            ch <- i
        }
        close(ch)
    }()
    
    fmt.Println("\n方法2:")
    for {
        num, ok := <-ch
        if !ok {
            fmt.Println("channel已关闭")
            break
        }
        fmt.Println("接收到:", num)
    }

    // 关闭后的channel读取零值
    num, ok := <-ch
    fmt.Printf("读取结果: %d, 是否成功: %v\n", num, ok)
    //读取结果: 0, 是否成功: false
}

2.slice 和 array 区别

1. Array（数组）
2. 固定长度：声明时必须指定长度，且长度不可变。
3. 值类型：数组变量存储的是整个数组的值，而非指针。
4. 内存分配：数组在栈上或堆上分配连续内存，大小为元素类型大小 × 长度。
5. Slice（切片）
6. 动态长度：切片长度可动态变化，通过append操作扩展。
7. 引用类型：切片变量是一个结构体，包含三个字段：指针，长度，容量
8. 内存分配：切片本身在栈上分配，但其指向的底层数组在堆上分配。
9. 多个切片可能指向同一个底层数组，修改其中一个会影响其他切片

数组

var a [5]int          // 长度为5的整数数组，初始值为[0, 0, 0, 0, 0]
b := [3]string{"a", "b", "c"}  // 初始化数组
c := [...]int{1, 2, 3, 4}      // 编译器自动推断长度为4

切片

var s []int           // 声明空切片，初始值为nil
s := make([]int, 5)   // 创建长度和容量均为5的切片
s := make([]int, 3, 5) // 长度3，容量5的切片
s := []int{1, 2, 3}   // 直接初始化切片，长度和容量均为3

切片提供了动态扩容和低开销的特性，而数组主要用于特定的底层优化场景

3. sync.WaitGroup 同步原语

一个常用的同步原语，用于等待一组 goroutine 完成执行。它允许主线程阻塞，直到所有子 goroutine 都执行完毕，常用于并行任务的协调

原理：

WaitGroup 内部维护一个计数器，记录尚未完成的 goroutine 数量。 Add(delta int)：增加计数器的值（通常在启动 goroutine 前调用）。 Done()：减少计数器的值（等同于Add(-1)，通常在 goroutine 完成时调用）。 Wait()：阻塞当前线程，直到计数器变为 0。

1.等待多个 goroutine 完成

package main

import (
    "fmt"
    "sync"
)

func worker(id int, wg *sync.WaitGroup) {
    defer wg.Done() // 任务完成后减少计数器
    fmt.Printf("Worker %d starting\n", id)
    // 模拟工作
    for i := 0; i < 1000; i++ {
        // ...
    }
    fmt.Printf("Worker %d done\n", id)
}

func main() {
    var wg sync.WaitGroup

    // 启动3个goroutine，计数器加3
    wg.Add(3)
    for i := 1; i <= 3; i++ {
        go worker(i, &wg)
    }

    // 等待所有goroutine完成
    wg.Wait()
    fmt.Println("All workers finished")
}

2.动态调整计数器

func main() {
    var wg sync.WaitGroup
    jobs := []int{1, 2, 3, 4, 5}

    wg.Add(len(jobs))
    for _, job := range jobs {
        go func(j int) {
            defer wg.Done()
            processJob(j)
        }(job)
    }

    wg.Wait()
}

注意事项：

1. Add () 必须在 Wait () 之前调用

2. 禁止复制 WaitGroup，应该通过指针传参

func correctUsage(wg *sync.WaitGroup) {
    defer wg.Done()
    // ...
}

3. 避免重复调用 Done (),每个Add(n)必须对应n次Done()，多调用会导致计数器为负，引发 panic

4.struct能不能比较？

struct 的比较规则取决于其字段类型和结构体本身的定义方式。

1.如果 struct 的所有字段类型都是可比较的（如基本类型、指针、数组、可比较的结构体等），则该 struct 是可比较的。

type Point struct {
    X int
    Y int
}

func main() {
    p1 := Point{1, 2}
    p2 := Point{1, 2}
    p3 := Point{3, 4}
    
    fmt.Println(p1 == p2) // 输出: true
    fmt.Println(p1 == p3) // 输出: false
    
}

2.如果 struct 包含不可比较的字段类型（如 slice、map、function），则该 struct 不可比较。 不可比较操作：

type Person struct {
    Name string
    Friends []string // slice类型，不可比较
}

func main() {
    p1 := Person{Name: "Alice", Friends: []string{"Bob"}}
    p2 := Person{Name: "Alice", Friends: []string{"Bob"}}
    
    // 编译错误：invalid operation: p1 == p2 (struct containing []string cannot be compared)
    // fmt.Println(p1 == p2) 
    
    // 编译错误：invalid map key type Person (struct containing []string cannot be compared)
    // m := map[Person]int{p1: 1} 
}

3.如果 struct 包含interface 字段，则比较时需确保 interface 的动态值是可比较的。不可比较则运行时 panic。

type Container struct {
    Value interface{}
}

func main() {
    // 动态值为int（可比较）
    c1 := Container{Value: 1}
    c2 := Container{Value: 1}
    fmt.Println(c1 == c2) // 输出: true
    
    // 动态值为slice（不可比较）
    c3 := Container{Value: []int{1}}
    c4 := Container{Value: []int{1}}
    // 运行时panic: runtime error: comparing uncomparable type []int
    // fmt.Println(c3 == c4) 
}

4. 如何比较包含不可比较字段的 struct？reflect.DeepEqual 性能较低，适用于测试或非性能敏感场景

import "reflect"

type Person struct {
    Name    string
    Friends []string
}

// 自定义比较函数
func EqualPerson(p1, p2 Person) bool {
    if p1.Name != p2.Name {
        return false
    }
    // 使用reflect.DeepEqual比较slice
    return reflect.DeepEqual(p1.Friends, p2.Friends)
}

func main() {
    p1 := Person{Name: "Alice", Friends: []string{"Bob"}}
    p2 := Person{Name: "Alice", Friends: []string{"Bob"}}
    
    fmt.Println(EqualPerson(p1, p2)) // 输出: true
}

5.defer 应该怎么用

defer 语句用于延迟执行函数，通常用于资源释放、解锁等操作。

机制：

延迟执行：defer 语句会在当前函数返回前执行，无论函数是正常返回还是 panic。

栈式执行：多个 defer 按后进先出（LIFO）的顺序执行。

参数绑定：defer 语句中的参数在定义时立即求值，但函数体在返回前执行。

1. 循环内的 defer会被压入栈累积，但不执行；在循环结束后，函数返回前执行

func main() {
    for i := 0; i < 3; i++ {
        defer fmt.Println(i) // 循环结束后按LIFO顺序执行
    }
    // 输出顺序：2 → 1 → 0
}

2. 参数值在 defer 定义时确定

func main() {
    for i := 0; i < 3; i++ {
        func(x int) {
            defer fmt.Println(x) // 参数x在闭包创建时已确定
        }(i)
    }
    // 输出顺序：2 → 1 → 0
}

注意对比区别

func main() {
    for i := 0; i < 3; i++ {
        defer func() {
            fmt.Println(i) // 闭包捕获循环变量i的引用，最终i=3
        }()
    }
    // 输出顺序：3 → 3 → 3
}

异常捕获：recover() 用于捕获 panic，恢复程序控制流

func main() {
    defer func() {
        if r := recover(); r != nil {
            fmt.Println("Recovered:", r) // 捕获 panic 信息
        }
    }()
    panic("Something went wrong")
}

作用域限制：recover() 必须在直接 defer 的函数内部调用才有效，嵌套调用无效。

func main() {
    defer func() {
        func() {
            recover() // 无效！必须在直接 defer 的函数中调用
        }()
    }()
    panic("Fail")
}

多层 panic：第二次 panic 会导致程序崩溃，无法被捕获。

defer func() {
    recover()       // 捕获第一次 panic
    panic("new")    // 再次 panic，程序崩溃
}()
panic("old")

3. 并发锁释放（需配合闭包）

func processItems(items []Item) {
    var mu sync.Mutex
    for i := range items {
        go func(idx int) {
            mu.Lock()
            defer mu.Unlock() // 每个goroutine独立解锁
            // 处理items[idx]...
        }(i)
    }
}

4. 资源释放

func readFiles(files []string) {
    for _, file := range files {
        f, err := os.Open(file)
        if err != nil {
            continue
        }
        defer f.Close() // 所有文件句柄在函数结束时关闭
        // 使用f读取文件...
    }
}

5. defer 与 return 的执行顺序,语句实际分为两步：

返回值赋值,执行 defer（若有）

函数真正返回

func test() (x int) {
    // 1. 函数开始时，x 已初始化为 0（命名返回值特性）

    defer func() {
       // 3. defer 执行时，x 已被赋值为 1，执行 x++ 后，x = 2
       x++
    }()

    return 1 // 2. 等价于 x = 1 → 触发 defer → 函数返回 x（此时 x=2）
}