在 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
}
}