Skip to content

Latest commit

 

History

History
176 lines (163 loc) · 5.76 KB

go-advice.md

File metadata and controls

176 lines (163 loc) · 5.76 KB

go语言tips

代码风格

  • go fmt 代码, 让代码更清晰

  • 多个if判断可以改成switch

  • 使用 chan struct{} 来传递信号 - chan bool makes it less clear, btw struct{} 更优化 struct{}不需要占用任何内存空间

  • 使用 30 * time.Second 代替 time.Duration(30) * time.Second

  • for-select 结构 封装成 函数 ``` func main() { foo() fmt.Println("ending") }

      func foo() {
      for {
          select {
          case <-time.After(time.Second):
              fmt.Println("hello")
          default:
              return
          }
      }
  }
 ```

  • group const declarations by type and var by logic and/or type

  • every blocking or IO function 阻塞程序必须能取消或取超时机制

  • implement Stringer interface for integers const values

  • check your defer's error

    defer func() {
    err := ocp.Close()
    if err != nil {
        rerr = err
    }
}()

  • don't use checkErr function which panics or does os.Exit

  • don't use alias for enums 'cause this breaks type safety

    package main
type Status = int
type Format = int // remove `=` to have type safety

const A Status = 1
const B Format = 1

func main() {
  println(A == B)
}

  • 省略函数返回参数：

    • so prefer this _ = f() to this f()

  • we've a short form for slice initialization a := []T{}

  • iterate over array or slice using range loop

    • instead of for i := 3; i < 7; i++ {...} prefer for _, c := range a[3:7] {...}

  • use backquote(`) for multiline strings

CI

Concurrency

  • best candidate to make something once in a thread-safe way is sync.Once
    • don't use flags, mutexes, channels or atomics
  • to block forever use select{}, omit channels, waiting for a signal

Performance

  • do not omit defer
    • 200ns speedup is negligible in most cases
  • always close http body aka defer r.Body.Close()
    • unless you need leaked goroutine
  • filtering without allocating 
      b := a[:0]
  for _, x := range a {
  	if f(x) {
  	    b = append(b, x)
  	}
  }
  • time.Time has pointer field time.Location and this is bad for go GC
    • it's relevant only for big number of time.Time, use timestamp instead
  • prefer regexp.MustCompile instead of regexp.Compile
    • in most cases your regex is immutable, so init it in func init
  • do not overuse fmt.Sprintf in your hot path. It is costly due to maintaining the buffer pool and dynamic dispatches for interfaces.
    • if you are doing fmt.Sprintf("%s%s", var1, var2), consider simple string concatenation.
    • if you are doing fmt.Sprintf("%x", var), consider using hex.EncodeToString or strconv.FormatInt(var, 16)
  • always discard body e.g. io.Copy(ioutil.Discard, resp.Body) if you don't use it
    • HTTP client's Transport will not reuse connections unless the body is read to completion and closed
      res, _ := client.Do(req)
  io.Copy(ioutil.Discard, res.Body)
  defer res.Body.Close()
  • don't use defer in a loop or you'll get a small memory leak
    • 'cause defers will grow your stack without the reason
  • don't forget to stop ticker, unless you need leaked channel 
    ticker := time.NewTicker(1 * time.Second)
defer ticker.Stop()

Build

  • strip your binaries with this command go build -ldflags="-s -w" ...
  • easy way to split test into different builds
    • use // +build integration and run them with go test -v --tags integration .

Testing

  • go test -short allows to reduce set of tests to be runned 
    func TestSomething(t *testing.T) {
  if testing.Short() {
    t.Skip("skipping test in short mode.")
  }
}
  • skip test deppending on architecture 
    if runtime.GOARM == "arm" {
  t.Skip("this doesn't work under ARM")
}
  • prefer package_test name for tests, rather than package
  • for fast benchmark comparison we've a benchcmp tool
  • track your allocations with testing.AllocsPerRun

Tools

  • quick replace gofmt -w -l -r "panic(err) -> log.Error(err)" .
  • go list allows to find all direct and transitive dependencies
    • go list -f '{{ .Imports }}' package
    • go list -f '{{ .Deps }}' package

Misc