Golang的一些学习

Posted 2020-12-31 przz

在 Go 中使用命名返回变量捕获 panic

在下面代码中，如果pressButton发生panic，那么不会执行到return err，导致返回的err是nil。

    func doStuff() error {  
        var err error
        // If there is a panic we need to recover in a deferred func
        defer func() {
            if r := recover(); r != nil {
                err = errors.New("the meeseeks went crazy!")
            }
        }()
    
        pressButton()
        return err
    }

可以使用命名返回变量解决，即使我们从未触碰到 doStuff 函数的末尾的返回语句，也会立刻返回这个 err 变量。

    func doStuff() (err error) {  
        // If there is a panic we need to recover in a deferred func
        defer func() {
            if r := recover(); r != nil {
                err = errors.New("the meeseeks went crazy!")
            }
        }()
    
        pressButton()
        return err
    }

重新切片（slice）

从 slice 中重新切出新 slice 时，新 slice 会引用原 slice 的底层数组，将导致难以预料的内存使用。可以通过拷贝临时 slice 的数据，而不是重新切片来解决：

    func get() (res []byte) {
        raw := make([]byte, 10000)
        fmt.Println(len(raw), cap(raw), &raw[0])    // 10000 10000 0xc420080000
        res = make([]byte, 3)
        copy(res, raw[:3])
        return
    }
    func test() {
        slice := a[2:3:4]
        //可以利用第三个参数控制容量
        //如果设置容量和长度相同，可以append时新创建底层数组，不影响原有的
    }

---

类型声明与方法

从一个现有的非 interface 类型创建新类型时，并不会继承原有的方法：

    // 定义 Mutex 的自定义类型
    type myMutex sync.Mutex
    
    func main() {
        var mtx myMutex
        mtx.Lock()
        mtx.UnLock()
    }
    //mtx.Lock undefined (type myMutex has no field or method Lock)…

如果你需要使用原类型的方法，可将原类型以匿名字段的形式嵌到你定义的新 struct 中：

    // 类型以字段形式直接嵌入
    type myLocker struct {
        sync.Mutex
    }
    
    func main() {
        var locker myLocker
        locker.Lock()
        locker.Unlock()
    }

---

for + 闭包函数

    type field struct {
        name string
    }
    
    func (p *field) print() {
        fmt.Println(p.name)
    }
    
    // 错误示例
    func main() {
        data := []field{{"one"}, {"two"}, {"three"}}
        for _, v := range data {
            go v.print()
        }
        time.Sleep(3 * time.Second)
        // 输出 three three three 
    }
    
    
    // 正确示例
    func main() {
        data := []field{{"one"}, {"two"}, {"three"}}
        for _, v := range data {
            v := v
            go v.print()
        }
        time.Sleep(3 * time.Second)
        // 输出 one two three
    }
    
    // 正确示例
    func main() {
        data := []*field{{"one"}, {"two"}, {"three"}}
        for _, v := range data {    // 此时迭代值 v 是三个元素值的地址，每次 v 指向的值不同
            go v.print()
        }
        time.Sleep(3 * time.Second)
        // 输出 one two three
    }

---

defer函数参数

对 defer 延迟执行的函数，它的参数会在声明时候就会求出具体值，而不是在执行时才求值：

    // 在 defer 函数中参数会提前求值
    func main() {
        var i = 1
        defer fmt.Println("result: ", func() int { return i * 2 }())
        i++
    }

---

select default

如果有default子句，case不满足条件时执行该语句。

如果没有default字句，select将阻塞，直到某个case可以运行；Go不会重新对channel或值进行求值。

缓冲通道中，刚好相反，由于元素值的传递是异步的，所以发送操作在成功向通道发送元素值之后就会立即结束(它不会关心是否有接收操作)。

如果使用非缓冲，ret值必须被接收。如果此函数等待超时直接返回nil，会导致Ret这个Chan在模块那边写不进去堵死。

    func (m *friendModule) Gift*****(cmd GiftCmd) *GiftRet {
        ctx, cancel := context.WithTimeout(context.Background(), util.ASyncCmdTimeOut)
        defer cancel()
        cmd.Ret = make(chan GiftRet, 1) ##非缓冲bug
        select {
        case m.GiftChan <- cmd:
        case <-ctx.Done():
            logs.Error("friend moduel gift cmdChan is full")
        }
        select {
        case ret := <-cmd.Ret:
            return &ret
        case <-ctx.Done():
            logs.Error("friend moduel gift cmdChan apply <-retChan timeout")
            return nil
        }
    }