不要依赖于计算顺序，特别是在 return 语句中。
// BAD return res, json.Unmarshal(b, &res) // GOOD err := json.Unmarshal(b, &res) return res, err
防止结构体字段用纯值方式初始化，添加 _ struct {} 字段：
type Point struct { X, Y float64 _ struct{} // to prevent unkeyed literals }
对于 Point {X：1，Y：1} 都可以，但是对于 Point {1,1} 则会出现编译错误：
./file.go:1:11: too few values in Point literal
当在你所有的结构体中添加了 _ struct{} 后，使用 go vet 命令进行检查，（原来声明的方式）就会提示没有足够的参数。
为了防止结构比较，添加 func 类型的空字段
type Point struct { _ [0]func() // unexported, zero-width non-comparable field X, Y float64 }
http.HandlerFunc 比 http.Handler 更好
用 http.HandlerFunc 你仅需要一个 func，http.Handler 需要一个类型。
移动 defer 到顶部
这可以提高代码可读性并明确函数结束时调用了什么。
JavaScript 解析整数为浮点数并且你的 int64 可能溢出
用 json:"id,string" 代替
type Request struct { ID int64 `json:"id,string"` }
并发
** 以线程安全的方式创建单例（只创建一次）的最好选择是 sync.Once
不要用 flags, mutexes, channels or atomics
** 永远不要使用 select{}, 省略通道， 等待信号
** 不要关闭一个发送（写入）管道，应该由创建者关闭
往一个关闭的 channel 写数据会引起 panic
** math/rand 中的 func NewSource(seed int64) Source 不是并发安全的，默认的 lockedSource 是并发安全的。
** 当你需要一个自定义类型的 atomic 值时，可以使用 atomic.Value
性能
- ** 不要省略
defer
- 在大多数情况下 200ns 加速可以忽略不计
- ** 总是关闭 http body
defer r.Body.Close()
- 除非你需要泄露 goroutine
- ** 过滤但不分配新内存
b := a[:0] for _, x := range a { if f(x) { b = append(b, x) } }
为了帮助编译器删除绑定检查，请参见此模式 _ = b [7]
** time.Time 有指针字段 time.Location 并且这对 go GC 不好
只有使用了大量的 time.Time 才（对性能）有意义，否则用 timestamp 代替
** regexp.MustCompile 比 regexp.Compile 更好
在大多数情况下，你的正则表达式是不可变的，所以你最好在 func init 中初始化它
** 请勿在你的热点代码中过度使用 fmt.Sprintf. 由于维护接口的缓冲池和动态调度，它是很昂贵的。
如果你正在使用 fmt.Sprintf("%s%s", var1, var2), 考虑使用简单的字符串连接。
如果你正在使用 fmt.Sprintf("%x", var), 考虑使用 hex.EncodeToString or strconv.FormatInt(var, 16)
** 如果你不需要用它，可以考虑丢弃它，例如io.Copy(ioutil.Discard, resp.Body)
HTTP 客户端的传输不会重用连接，直到body被读完和关闭。
res, _ := client.Do(req) io.Copy(ioutil.Discard, res.Body) defer res.Body.Close()
- ** 不要在循环中使用 defer，否则会导致内存泄露
- 因为这些 defer 会不断地填满你的栈（内存）
- ** 不要忘记停止 ticker, 除非你需要泄露 channel
ticker := time.NewTicker(1 * time.Second) defer ticker.Stop()
- ** 用自定义的 marshaler 去加速 marshaler 过程
- 但是在使用它之前要进行定制！
func (entry Entry) MarshalJSON() ([]byte, error) { buffer := bytes.NewBufferString("{") first := true for key, value := range entry { jsonValue, err := json.Marshal(value) if err != nil { return nil, err } if !first { buffer.WriteString(",") } first = false buffer.WriteString(key + ":" + string(jsonValue)) } buffer.WriteString("}") return buffer.Bytes(), nil }
- **
sync.Map不是万能的，没有很强的理由就不要使用它。 - **
在sync.Pool中分配内存存储非指针数据 - **
为了隐藏逃生分析的指针，你可以小心使用这个函数：:
// noescape hides a pointer from escape analysis. noescape is // the identity function but escape analysis doesn't think the // output depends on the input. noescape is inlined and currently // compiles down to zero instructions. //go:nosplit func noescape(p unsafe.Pointer) unsafe.Pointer { x := uintptr(p) return unsafe.Pointer(x ^ 0) }
**
对于最快的原子交换，你可以使用这个 m := (*map[int]int)(atomic.LoadPointer(&ptr))
**
如果执行许多顺序读取或写入操作，请使用缓冲 I/O
减少系统调用次数
**
有 2 种方法清空一个 map：
重用 map 内存 （但是也要注意 m 的回收）
for k := range m { delete(m, k) }
- 分配新的
m = make(map[int]int)
构建
** 用这个命令 go build -ldflags="-s -w" ... 去掉你的二进制文件
** 拆分构建不同版本的简单方法
用 // +build integration 并且运行他们 go test -v --tags integration .
** 最小的 Go Docker 镜像
https://twitter.com/bbrodriges/status/873414658178396160
CGO_ENABLED=0 go build -ldflags="-s -w" app.go && tar C app | docker import - myimage:latest
** run go format on CI and compare diff
这将确保一切都是生成的和承诺的
** 用最新的 Go 运行 Travis-CI，用 travis 1
** 检查代码格式是否有错误 diff -u <(echo -n) <(gofmt -d .)
测试
** 测试名称 package_test 比 package 要好
** go test -short 允许减少要运行的测试数
func TestSomething(t *testing.T) { if testing.Short() { t.Skip("skipping test in short mode.") } }
- ** 根据系统架构跳过测试
if runtime.GOARM == "arm" { t.Skip("this doesn't work under ARM") }
** 用 testing.AllocsPerRun 跟踪你的内存分配
** 多次运行你的基准测试可以避免噪音。
go test -test.bench=. -count=20
工具
**
快速替换 gofmt -w -l -r "panic(err) -> log.Error(err)" .
**
go list 允许找到所有直接和传递的依赖关系
go list -f '{{ .Imports }}' package
go list -f '{{ .Deps }}' package
**
对于快速基准比较，我们有一个 benchstat 工具。
**
go-critic linter 从这个文件中强制执行几条建议
**
go mod why -m <module> 告诉我们为什么特定的模块在 go.mod 文件中。
**
GOGC=off go build ... 应该会加快构建速度 source
**
内存分析器每 512KB 记录一次分配。你能通过 GODEBUG 环境变量增加比例，来查看你的文件的更多详细信息。
**
go mod why -m <module> 告诉我们为什么特定的模块是在 go.mod 文件中。
其他
** dump goroutines
go func() { sigs := make(chan os.Signal, 1) signal.Notify(sigs, syscall.SIGQUIT) buf := make([]byte, 1<<20) for { <-sigs stacklen := runtime.Stack(buf, true) log.Printf("=== received SIGQUIT ===\n*** goroutine dump...\n%s\n*** end\n" , buf[:stacklen]) } }()
** 在编译期检查接口的实现
var _ io.Reader = (*MyFastReader)(nil)
- ** len(nil) = 0
- ** 匿名结构很酷
var hits struct { sync.Mutex n int } hits.Lock() hits.n++ hits.Unlock()
**
httputil.DumpRequest 是非常有用的东西，不要自己创建
**
获得调用堆栈，我们可以使用 runtime.Caller
**
要 marshal 任意的 JSON， 你可以 marshal 为 map[string]interface{}{}
**
配置你的 CDPATH 以便你能在任何目录执行 cd github.com/golang/go
添加这一行代码到 bashrc(或者其他类似的) export CDPATH=$CDPATH:$GOPATH/src
**
从一个 slice 生成简单的随机元素
[]string{"one", "two", "three"}[rand.Intn(3)]
