- go fmt your code, make everyone happier
- multiple if statements can be collapsed into switch
- use
chan struct{}to pass signalchan boolmakes it less clear, btwstruct{}is more optimal
- prefer
30 * time.Secondinstead oftime.Duration(30) * time.Second - always wrap for-select idiom to a function
- group
constdeclarations by type andvarby logic and/or type - every blocking or IO function call should be cancelable or at least timeoutable
- implement
Stringerinterface for integers const values - check your defer's error
defer func() { err := ocp.Close() if err != nil { rerr = err } }()
- don't use
checkErrfunction which panics or doesos.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) }
- if you're going to omit returning params, do it explicitly
- so prefer this
_ = f()to thisf()
- so prefer this
- we've a short form for slice initialization
a := []T{}
- run
go formaton CI and compare diff- this will ensure that everything was generated and commited
- to run Travis-CI with the latest Go use
travis 1 - check if there are mistakes in code formatting
diff -u <(echo -n) <(gofmt -d .)
- 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
- 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.Timehas pointer fieldtime.Locationand this is bad for go GC- it's relevant only for big number of
time.Time, use timestamp instead
- it's relevant only for big number of
- prefer
regexp.MustCompileinstead ofregexp.Compile- in most cases your regex is immutable, so init it in
func init
- in most cases your regex is immutable, so init it in
- do not overuse
fmt.Sprintfin 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 usinghex.EncodeToStringorstrconv.FormatInt(var, 16)
- if you are doing
- 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()
- strip your binaries with this command
go build -ldflags="-s -w" ... - easy way to split test into different builds
- use
// +build integrationand run them withgo test -v --tags integration .
- use
-
go test -shortallows to reduce set of tests to be runnedfunc 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_testname for tests, rather thanpackage - for fast benchmark comparison we've a
benchcmptool
- quick replace
gofmt -w -l -r "panic(err) -> log.Error(err)" . -
go listallows to find all direct and transitive dependenciesgo list -f '{{ .Imports }}' packagego list -f '{{ .Deps }}' package
- dump goroutines https://stackoverflow.com/a/27398062/433041
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]) } }()
- check interface implementation during compilation
var _ io.Reader = (*MyFastReader)(nil)
- if a param of len is nil then it's zero
- anonymous structs are cool
var hits struct { sync.Mutex n int } hits.Lock() hits.n++ hits.Unlock()
-
httputil.DumpRequestis very useful thing, don't create your own
React
Typescript
Django
Laravel
Facebook
Microsoft
Google
Alibaba
D3
Tencent