| Bad | Good |
|---|---|
| \n\n```go\nBAD CODE GOES HERE\n```\n\n | \n\n```go\nGOOD CODE GOES HERE\n```\n\n |
| Bad | Good |
|---|---|
| \n\n```go\ntype foo struct {\n running int32 // atomic\n}\n\nfunc (f* foo) start() {\n if atomic.SwapInt32(&f.running, 1) == 1 {\n // already running…\n return\n }\n // start the Foo\n}\n\nfunc (f *foo) isRunning() bool {\n return f.running == 1 // race!\n}\n```\n\n | \n\n```go\ntype foo struct {\n running atomic.Bool\n}\n\nfunc (f *foo) start() {\n if f.running.Swap(true) {\n // already running…\n return\n }\n // start the Foo\n}\n\nfunc (f *foo) isRunning() bool {\n return f.running.Load()\n}\n```\n\n |
| Bad | Good |
|---|---|
| \n\n```go\nvar error string\n// `error` shadows the builtin\n\n// or\n\nfunc handleErrorMessage(error string) {\n // `error` shadows the builtin\n}\n```\n\n | \n\n```go\nvar errorMessage string\n// `error` refers to the builtin\n\n// or\n\nfunc handleErrorMessage(msg string) {\n // `error` refers to the builtin\n}\n```\n\n |
| \n\n```go\ntype Foo struct {\n // While these fields technically don't\n // constitute shadowing, grepping for\n // `error` or `string` strings is now\n // ambiguous.\n error error\n string string\n}\n\nfunc (f Foo) Error() error {\n // `error` and `f.error` are\n // visually similar\n return f.error\n}\n\nfunc (f Foo) String() string {\n // `string` and `f.string` are\n // visually similar\n return f.string\n}\n```\n\n | \n\n```go\ntype Foo struct {\n // `error` and `string` strings are\n // now unambiguous.\n err error\n str string\n}\n\nfunc (f Foo) Error() error {\n return f.err\n}\n\nfunc (f Foo) String() string {\n return f.str\n}\n```\n\n |
| Bad | Good |
|---|---|
| \n\n```go\n// Ought to be enough for anybody!\nc := make(chan int, 64)\n```\n\n | \n\n```go\n// Size of one\nc := make(chan int, 1) // or\n// Unbuffered channel, size of zero\nc := make(chan int)\n```\n\n |
| Bad | Good |
|---|---|
| \n\n```go\nfiles, _ := os.ReadDir(\"./files\")\n\nm := make(map[string]os.DirEntry)\nfor _, f := range files {\n m[f.Name()] = f\n}\n```\n\n | \n\n```go\n\nfiles, _ := os.ReadDir(\"./files\")\n\nm := make(map[string]os.DirEntry, len(files))\nfor _, f := range files {\n m[f.Name()] = f\n}\n```\n\n |
| \n\n`m` is created without a size hint; the map will resize \ndynamically, causing multiple allocations as it grows.\n\n | \n\n`m` is created with a size hint; there may be fewer\nallocations at assignment time.\n\n |
| Bad | Good |
|---|---|
| \n\n```go\nfor n := 0; n < b.N; n++ {\n data := make([]int, 0)\n for k := 0; k < size; k++{\n data = append(data, k)\n }\n}\n```\n\n | \n\n```go\nfor n := 0; n < b.N; n++ {\n data := make([]int, 0, size)\n for k := 0; k < size; k++{\n data = append(data, k)\n }\n}\n```\n\n |
| \n\n```plain\nBenchmarkBad-4 100000000 2.48s\n```\n\n | \n\n```plain\nBenchmarkGood-4 100000000 0.21s\n```\n\n |
| Bad | Good |
|---|---|
| \n\n```go\nfunc (d *Driver) SetTrips(trips []Trip) {\n d.trips = trips\n}\n\ntrips := ...\nd1.SetTrips(trips)\n\n// Did you mean to modify d1.trips?\ntrips[0] = ...\n```\n\n | \n\n\n```go\nfunc (d *Driver) SetTrips(trips []Trip) {\n d.trips = make([]Trip, len(trips))\n copy(d.trips, trips)\n}\n\ntrips := ...\nd1.SetTrips(trips)\n\n// We can now modify trips[0] without affecting d1.trips.\ntrips[0] = ...\n```\n\n | \n
| Bad | Good |
|---|---|
| \n\n```go\ntype Stats struct {\n mu sync.Mutex\n counters map[string]int\n}\n\n// Snapshot returns the current stats.\nfunc (s *Stats) Snapshot() map[string]int {\n s.mu.Lock()\n defer s.mu.Unlock()\n\n return s.counters\n}\n\n// snapshot is no longer protected by the mutex, so any\n// access to the snapshot is subject to data races.\nsnapshot := stats.Snapshot()\n```\n\n | \n\n```go\ntype Stats struct {\n mu sync.Mutex\n counters map[string]int\n}\n\nfunc (s *Stats) Snapshot() map[string]int {\n s.mu.Lock()\n defer s.mu.Unlock()\n\n result := make(map[string]int, len(s.counters))\n for k, v := range s.counters {\n result[k] = v\n }\n return result\n}\n\n// Snapshot is now a copy.\nsnapshot := stats.Snapshot()\n```\n\n |
| Bad | Good |
|---|---|
| \n\n```go\nimport \"a\"\nimport \"b\"\n```\n\n | \n\n```go\nimport (\n \"a\"\n \"b\"\n)\n```\n\n |
| Bad | Good |
|---|---|
| \n\n```go\n\nconst a = 1\nconst b = 2\n\n\n\nvar a = 1\nvar b = 2\n\n\n\ntype Area float64\ntype Volume float64\n```\n\n | \n\n```go\nconst (\n a = 1\n b = 2\n)\n\nvar (\n a = 1\n b = 2\n)\n\ntype (\n Area float64\n Volume float64\n)\n```\n\n |
| Bad | Good |
|---|---|
| \n\n```go\ntype Operation int\n\nconst (\n Add Operation = iota + 1\n Subtract\n Multiply\n EnvVar = \"MY_ENV\"\n)\n```\n\n | \n\n```go\ntype Operation int\n\nconst (\n Add Operation = iota + 1\n Subtract\n Multiply\n)\n\nconst EnvVar = \"MY_ENV\"\n```\n\n |
| Bad | Good |
|---|---|
| \n\n```go\nfunc f() string {\n red := color.New(0xff0000)\n green := color.New(0x00ff00)\n blue := color.New(0x0000ff)\n\n // ...\n}\n```\n\n | \n\n```go\nfunc f() string {\n var (\n red = color.New(0xff0000)\n green = color.New(0x00ff00)\n blue = color.New(0x0000ff)\n )\n\n // ...\n}\n```\n\n |
| Bad | Good |
|---|---|
| \n\n```go\nfunc (c *client) request() {\n caller := c.name\n format := \"json\"\n timeout := 5*time.Second\n var err error\n\n // ...\n}\n```\n\n | \n\n```go\nfunc (c *client) request() {\n var (\n caller = c.name\n format = \"json\"\n timeout = 5*time.Second\n err error\n )\n\n // ...\n}\n```\n\n |
| Bad | Good |
|---|---|
| \n\n```go\np.Lock()\nif p.count < 10 {\n p.Unlock()\n return p.count\n}\n\np.count++\nnewCount := p.count\np.Unlock()\n\nreturn newCount\n\n// easy to miss unlocks due to multiple returns\n```\n\n | \n\n```go\np.Lock()\ndefer p.Unlock()\n\nif p.count < 10 {\n return p.count\n}\n\np.count++\nreturn p.count\n\n// more readable\n```\n\n |
| Bad | Good |
|---|---|
| \n\n```go\nvar a int\nif b {\n a = 100\n} else {\n a = 10\n}\n```\n\n | \n\n```go\na := 10\nif b {\n a = 100\n}\n```\n\n |
| Bad | Good |
|---|---|
| \n\n```go\n// ConcreteList is a list of entities.\ntype ConcreteList struct {\n *AbstractList\n}\n```\n\n | \n\n```go\n// ConcreteList is a list of entities.\ntype ConcreteList struct {\n list *AbstractList\n}\n\n// Add adds an entity to the list.\nfunc (l *ConcreteList) Add(e Entity) {\n l.list.Add(e)\n}\n\n// Remove removes an entity from the list.\nfunc (l *ConcreteList) Remove(e Entity) {\n l.list.Remove(e)\n}\n```\n\n |
| Bad | Good |
|---|---|
| \n\n```go\n// AbstractList is a generalized implementation\n// for various kinds of lists of entities.\ntype AbstractList interface {\n Add(Entity)\n Remove(Entity)\n}\n\n// ConcreteList is a list of entities.\ntype ConcreteList struct {\n AbstractList\n}\n```\n\n | \n\n```go\n// ConcreteList is a list of entities.\ntype ConcreteList struct {\n list AbstractList\n}\n\n// Add adds an entity to the list.\nfunc (l *ConcreteList) Add(e Entity) {\n l.list.Add(e)\n}\n\n// Remove removes an entity from the list.\nfunc (l *ConcreteList) Remove(e Entity) {\n l.list.Remove(e)\n}\n```\n\n |
| Bad | Good |
|---|---|
| \n\n```go\ntype Operation int\n\nconst (\n Add Operation = iota\n Subtract\n Multiply\n)\n\n// Add=0, Subtract=1, Multiply=2\n```\n\n | \n\n```go\ntype Operation int\n\nconst (\n Add Operation = iota + 1\n Subtract\n Multiply\n)\n\n// Add=1, Subtract=2, Multiply=3\n```\n\n |
| Description | Code |
|---|---|
| \n\n**Bad**: Log the error and return it\n\nCallers further up the stack will likely take a similar action with the error.\nDoing so makes a lot of noise in the application logs for little value.\n\n | \n\n```go\nu, err := getUser(id)\nif err != nil {\n // BAD: See description\n log.Printf(\"Could not get user %q: %v\", id, err)\n return err\n}\n```\n\n |
| \n\n**Good**: Wrap the error and return it\n\nCallers further up the stack will handle the error.\nUse of `%w` ensures they can match the error with `errors.Is` or `errors.As`\nif relevant.\n\n | \n\n```go\nu, err := getUser(id)\nif err != nil {\n return fmt.Errorf(\"get user %q: %w\", id, err)\n}\n```\n\n |
| \n\n**Good**: Log the error and degrade gracefully\n\nIf the operation isn't strictly necessary,\nwe can provide a degraded but unbroken experience\nby recovering from it.\n\n | \n\n```go\nif err := emitMetrics(); err != nil {\n // Failure to write metrics should not\n // break the application.\n log.Printf(\"Could not emit metrics: %v\", err)\n}\n\n```\n\n |
| \n\n**Good**: Match the error and degrade gracefully\n\nIf the callee defines a specific error in its contract,\nand the failure is recoverable,\nmatch on that error case and degrade gracefully.\nFor all other cases, wrap the error and return it.\n\nCallers further up the stack will handle other errors.\n\n | \n\n```go\ntz, err := getUserTimeZone(id)\nif err != nil {\n if errors.Is(err, ErrUserNotFound) {\n // User doesn't exist. Use UTC.\n tz = time.UTC\n } else {\n return fmt.Errorf(\"get user %q: %w\", id, err)\n }\n}\n```\n\n |
| No error matching | Error matching |
|---|---|
| \n\n```go\n// package foo\n\nfunc Open() error {\n return errors.New(\"could not open\")\n}\n\n// package bar\n\nif err := foo.Open(); err != nil {\n // Can't handle the error.\n panic(\"unknown error\")\n}\n```\n\n | \n\n```go\n// package foo\n\nvar ErrCouldNotOpen = errors.New(\"could not open\")\n\nfunc Open() error {\n return ErrCouldNotOpen\n}\n\n// package bar\n\nif err := foo.Open(); err != nil {\n if errors.Is(err, foo.ErrCouldNotOpen) {\n // handle the error\n } else {\n panic(\"unknown error\")\n }\n}\n```\n\n |
| No error matching | Error matching |
|---|---|
| \n\n```go\n// package foo\n\nfunc Open(file string) error {\n return fmt.Errorf(\"file %q not found\", file)\n}\n\n// package bar\n\nif err := foo.Open(\"testfile.txt\"); err != nil {\n // Can't handle the error.\n panic(\"unknown error\")\n}\n```\n\n | \n\n```go\n// package foo\n\ntype NotFoundError struct {\n File string\n}\n\nfunc (e *NotFoundError) Error() string {\n return fmt.Sprintf(\"file %q not found\", e.File)\n}\n\nfunc Open(file string) error {\n return &NotFoundError{File: file}\n}\n\n\n// package bar\n\nif err := foo.Open(\"testfile.txt\"); err != nil {\n var notFound *NotFoundError\n if errors.As(err, ¬Found) {\n // handle the error\n } else {\n panic(\"unknown error\")\n }\n}\n```\n\n |
| Bad | Good |
|---|---|
| \n\n```go\ns, err := store.New()\nif err != nil {\n return fmt.Errorf(\n \"failed to create new store: %w\", err)\n}\n```\n\n | \n\n```go\ns, err := store.New()\nif err != nil {\n return fmt.Errorf(\n \"new store: %w\", err)\n}\n```\n\n |
| \n\n```plain\nfailed to x: failed to y: failed to create new store: the error\n```\n\n | \n\n```plain\nx: y: new store: the error\n```\n\n |
| Bad | Good |
|---|---|
| \n\n```go\nfunc main() {\n body := readFile(path)\n fmt.Println(body)\n}\n\nfunc readFile(path string) string {\n f, err := os.Open(path)\n if err != nil {\n log.Fatal(err)\n }\n\n b, err := io.ReadAll(f)\n if err != nil {\n log.Fatal(err)\n }\n\n return string(b)\n}\n```\n\n | \n\n```go\nfunc main() {\n body, err := readFile(path)\n if err != nil {\n log.Fatal(err)\n }\n fmt.Println(body)\n}\n\nfunc readFile(path string) (string, error) {\n f, err := os.Open(path)\n if err != nil {\n return \"\", err\n }\n\n b, err := io.ReadAll(f)\n if err != nil {\n return \"\", err\n }\n\n return string(b), nil\n}\n```\n\n |
| Bad | Good |
|---|---|
| \n\n```go\npackage main\n\nfunc main() {\n args := os.Args[1:]\n if len(args) != 1 {\n log.Fatal(\"missing file\")\n }\n name := args[0]\n\n f, err := os.Open(name)\n if err != nil {\n log.Fatal(err)\n }\n defer f.Close()\n\n // If we call log.Fatal after this line,\n // f.Close will not be called.\n\n b, err := io.ReadAll(f)\n if err != nil {\n log.Fatal(err)\n }\n\n // ...\n}\n```\n\n | \n\n```go\npackage main\n\nfunc main() {\n if err := run(); err != nil {\n log.Fatal(err)\n }\n}\n\nfunc run() error {\n args := os.Args[1:]\n if len(args) != 1 {\n return errors.New(\"missing file\")\n }\n name := args[0]\n\n f, err := os.Open(name)\n if err != nil {\n return err\n }\n defer f.Close()\n\n b, err := io.ReadAll(f)\n if err != nil {\n return err\n }\n\n // ...\n}\n```\n\n |
| Bad | Good |
|---|---|
| \n\n```go\nfunc (s *something) Cost() {\n return calcCost(s.weights)\n}\n\ntype something struct{ ... }\n\nfunc calcCost(n []int) int {...}\n\nfunc (s *something) Stop() {...}\n\nfunc newSomething() *something {\n return &something{}\n}\n```\n\n | \n\n```go\ntype something struct{ ... }\n\nfunc newSomething() *something {\n return &something{}\n}\n\nfunc (s *something) Cost() {\n return calcCost(s.weights)\n}\n\nfunc (s *something) Stop() {...}\n\nfunc calcCost(n []int) int {...}\n```\n\n |
| Bad | Good |
|---|---|
| \n\n```go\n// package db\n\nfunc Open(\n addr string,\n cache bool,\n logger *zap.Logger\n) (*Connection, error) {\n // ...\n}\n```\n\n | \n\n```go\n// package db\n\ntype Option interface {\n // ...\n}\n\nfunc WithCache(c bool) Option {\n // ...\n}\n\nfunc WithLogger(log *zap.Logger) Option {\n // ...\n}\n\n// Open creates a connection.\nfunc Open(\n addr string,\n opts ...Option,\n) (*Connection, error) {\n // ...\n}\n```\n\n |
| \n\nThe cache and logger parameters must always be provided, even if the user\nwants to use the default.\n\n```go\ndb.Open(addr, db.DefaultCache, zap.NewNop())\ndb.Open(addr, db.DefaultCache, log)\ndb.Open(addr, false /* cache */, zap.NewNop())\ndb.Open(addr, false /* cache */, log)\n```\n\n | \n\nOptions are provided only if needed.\n\n```go\ndb.Open(addr)\ndb.Open(addr, db.WithLogger(log))\ndb.Open(addr, db.WithCache(false))\ndb.Open(\n addr,\n db.WithCache(false),\n db.WithLogger(log),\n)\n```\n\n |
| Bad | Good |
|---|---|
| \n\n```go\nvar _s string = F()\n\nfunc F() string { return \"A\" }\n```\n\n | \n\n```go\nvar _s = F()\n// Since F already states that it returns a string, we don't need to specify\n// the type again.\n\nfunc F() string { return \"A\" }\n```\n\n |
| Bad | Good |
|---|---|
| \n\n```go\n// sign.go\n\nvar _timeNow = time.Now\n\nfunc sign(msg string) string {\n now := _timeNow()\n return signWithTime(msg, now)\n}\n```\n\n | \n\n```go\n// sign.go\n\ntype signer struct {\n now func() time.Time\n}\n\nfunc newSigner() *signer {\n return &signer{\n now: time.Now,\n }\n}\n\nfunc (s *signer) Sign(msg string) string {\n now := s.now()\n return signWithTime(msg, now)\n}\n```\n\n |
| \n\n```go\n// sign_test.go\n\nfunc TestSign(t *testing.T) {\n oldTimeNow := _timeNow\n _timeNow = func() time.Time {\n return someFixedTime\n }\n defer func() { _timeNow = oldTimeNow }()\n\n assert.Equal(t, want, sign(give))\n}\n```\n\n | \n\n```go\n// sign_test.go\n\nfunc TestSigner(t *testing.T) {\n s := newSigner()\n s.now = func() time.Time {\n return someFixedTime\n }\n\n assert.Equal(t, want, s.Sign(give))\n}\n```\n\n |
| Bad | Good |
|---|---|
| \n\n```go\n// foo.go\n\nconst (\n defaultPort = 8080\n defaultUser = \"user\"\n)\n\n// bar.go\n\nfunc Bar() {\n defaultPort := 9090\n ...\n fmt.Println(\"Default port\", defaultPort)\n\n // We will not see a compile error if the first line of\n // Bar() is deleted.\n}\n```\n\n | \n\n```go\n// foo.go\n\nconst (\n _defaultPort = 8080\n _defaultUser = \"user\"\n)\n```\n\n |
| Bad | Good |
|---|---|
| \n\n```go\ngo func() {\n for {\n flush()\n time.Sleep(delay)\n }\n}()\n```\n\n | \n\n```go\nvar (\n stop = make(chan struct{}) // tells the goroutine to stop\n done = make(chan struct{}) // tells us that the goroutine exited\n)\ngo func() {\n defer close(done)\n\n ticker := time.NewTicker(delay)\n defer ticker.Stop()\n for {\n select {\n case <-ticker.C:\n flush()\n case <-stop:\n return\n }\n }\n}()\n\n// Elsewhere...\nclose(stop) // signal the goroutine to stop\n<-done // and wait for it to exit\n```\n\n |
| \n\nThere's no way to stop this goroutine.\nThis will run until the application exits.\n\n | \n\nThis goroutine can be stopped with `close(stop)`,\nand we can wait for it to exit with `<-done`.\n\n |
| Bad | Good |
|---|---|
| \n\n```go\nfunc init() {\n go doWork()\n}\n\nfunc doWork() {\n for {\n // ...\n }\n}\n```\n\n | \n\n```go\ntype Worker struct{ /* ... */ }\n\nfunc NewWorker(...) *Worker {\n w := &Worker{\n stop: make(chan struct{}),\n done: make(chan struct{}),\n // ...\n }\n go w.doWork()\n return w\n}\n\nfunc (w *Worker) doWork() {\n defer close(w.done)\n for {\n // ...\n case <-w.stop:\n return\n }\n}\n\n// Shutdown tells the worker to stop\n// and waits until it has finished.\nfunc (w *Worker) Shutdown() {\n close(w.stop)\n <-w.done\n}\n```\n\n |
| \n\nSpawns a background goroutine unconditionally when the user exports this package.\nThe user has no control over the goroutine or a means of stopping it.\n\n | \n\nSpawns the worker only if the user requests it.\nProvides a means of shutting down the worker so that the user can free up\nresources used by the worker.\n\nNote that you should use `WaitGroup`s if the worker manages multiple\ngoroutines.\nSee [Wait for goroutines to exit](goroutine-exit.md).\n\n |
| Bad | Good |
|---|---|
| \n\n```go\nimport (\n \"fmt\"\n \"os\"\n runtimetrace \"runtime/trace\"\n\n nettrace \"golang.net/x/trace\"\n)\n```\n\n | \n\n```go\nimport (\n \"fmt\"\n \"os\"\n \"runtime/trace\"\n\n nettrace \"golang.net/x/trace\"\n)\n```\n\n |
| Bad | Good |
|---|---|
| \n\n```go\nimport (\n \"fmt\"\n \"os\"\n \"go.uber.org/atomic\"\n \"golang.org/x/sync/errgroup\"\n)\n```\n\n | \n\n```go\nimport (\n \"fmt\"\n \"os\"\n\n \"go.uber.org/atomic\"\n \"golang.org/x/sync/errgroup\"\n)\n```\n\n |
| Bad | Good |
|---|---|
| \n\n```go\ntype Foo struct {\n // ...\n}\n\nvar _defaultFoo Foo\n\nfunc init() {\n _defaultFoo = Foo{\n // ...\n }\n}\n```\n\n | \n\n```go\nvar _defaultFoo = Foo{\n // ...\n}\n\n// or, better, for testability:\n\nvar _defaultFoo = defaultFoo()\n\nfunc defaultFoo() Foo {\n return Foo{\n // ...\n }\n}\n```\n\n |
| \n\n```go\ntype Config struct {\n // ...\n}\n\nvar _config Config\n\nfunc init() {\n // Bad: based on current directory\n cwd, _ := os.Getwd()\n\n // Bad: I/O\n raw, _ := os.ReadFile(\n path.Join(cwd, \"config\", \"config.yaml\"),\n )\n\n yaml.Unmarshal(raw, &_config)\n}\n```\n\n | \n\n```go\ntype Config struct {\n // ...\n}\n\nfunc loadConfig() Config {\n cwd, err := os.Getwd()\n // handle err\n\n raw, err := os.ReadFile(\n path.Join(cwd, \"config\", \"config.yaml\"),\n )\n // handle err\n\n var config Config\n yaml.Unmarshal(raw, &config)\n\n return config\n}\n```\n\n |
| Bad | Good |
|---|---|
| \n\n```go\ntype Handler struct {\n // ...\n}\n\n\n\nfunc (h *Handler) ServeHTTP(\n w http.ResponseWriter,\n r *http.Request,\n) {\n ...\n}\n```\n\n | \n\n```go\ntype Handler struct {\n // ...\n}\n\nvar _ http.Handler = (*Handler)(nil)\n\nfunc (h *Handler) ServeHTTP(\n w http.ResponseWriter,\n r *http.Request,\n) {\n // ...\n}\n```\n\n |
| Bad | Good |
|---|---|
| \n\n```go\nvar (\n // m1 is safe to read and write;\n // m2 will panic on writes.\n m1 = map[T1]T2{}\n m2 map[T1]T2\n)\n```\n\n | \n\n```go\nvar (\n // m1 is safe to read and write;\n // m2 will panic on writes.\n m1 = make(map[T1]T2)\n m2 map[T1]T2\n)\n```\n\n |
| \n\nDeclaration and initialization are visually similar.\n\n | \n\nDeclaration and initialization are visually distinct.\n\n |
| Bad | Good |
|---|---|
| \n\n```go\nm := make(map[T1]T2, 3)\nm[k1] = v1\nm[k2] = v2\nm[k3] = v3\n```\n\n | \n\n```go\nm := map[T1]T2{\n k1: v1,\n k2: v2,\n k3: v3,\n}\n```\n\n |
| Bad | Good |
|---|---|
| \n\n```go\nmu := new(sync.Mutex)\nmu.Lock()\n```\n\n | \n\n```go\nvar mu sync.Mutex\nmu.Lock()\n```\n\n |
| Bad | Good |
|---|---|
| \n\n```go\ntype SMap struct {\n sync.Mutex\n\n data map[string]string\n}\n\nfunc NewSMap() *SMap {\n return &SMap{\n data: make(map[string]string),\n }\n}\n\nfunc (m *SMap) Get(k string) string {\n m.Lock()\n defer m.Unlock()\n\n return m.data[k]\n}\n```\n\n | \n\n```go\ntype SMap struct {\n mu sync.Mutex\n\n data map[string]string\n}\n\nfunc NewSMap() *SMap {\n return &SMap{\n data: make(map[string]string),\n }\n}\n\nfunc (m *SMap) Get(k string) string {\n m.mu.Lock()\n defer m.mu.Unlock()\n\n return m.data[k]\n}\n```\n\n |
| \n\nThe `Mutex` field, and the `Lock` and `Unlock` methods are unintentionally part\nof the exported API of `SMap`.\n\n | \n\nThe mutex and its methods are implementation details of `SMap` hidden from its\ncallers.\n\n |
| Bad | Good |
|---|---|
| \n\n```go\nfor _, v := range data {\n if v.F1 == 1 {\n v = process(v)\n if err := v.Call(); err == nil {\n v.Send()\n } else {\n return err\n }\n } else {\n log.Printf(\"Invalid v: %v\", v)\n }\n}\n```\n\n | \n\n```go\nfor _, v := range data {\n if v.F1 != 1 {\n log.Printf(\"Invalid v: %v\", v)\n continue\n }\n\n v = process(v)\n if err := v.Call(); err != nil {\n return err\n }\n v.Send()\n}\n```\n\n |
| Bad | Good |
|---|---|
| \n\n```go\nfunc run(args []string) {\n if len(args) == 0 {\n panic(\"an argument is required\")\n }\n // ...\n}\n\nfunc main() {\n run(os.Args[1:])\n}\n```\n\n | \n\n```go\nfunc run(args []string) error {\n if len(args) == 0 {\n return errors.New(\"an argument is required\")\n }\n // ...\n return nil\n}\n\nfunc main() {\n if err := run(os.Args[1:]); err != nil {\n fmt.Fprintln(os.Stderr, err)\n os.Exit(1)\n }\n}\n```\n\n |
| Bad | Good |
|---|---|
| \n\n```go\n// func TestFoo(t *testing.T)\n\nf, err := os.CreateTemp(\"\", \"test\")\nif err != nil {\n panic(\"failed to set up test\")\n}\n```\n\n | \n\n```go\n// func TestFoo(t *testing.T)\n\nf, err := os.CreateTemp(\"\", \"test\")\nif err != nil {\n t.Fatal(\"failed to set up test\")\n}\n```\n\n |
| Bad | Good |
|---|---|
| \n\n```go\n// func printInfo(name string, isLocal, done bool)\n\nprintInfo(\"foo\", true, true)\n```\n\n | \n\n```go\n// func printInfo(name string, isLocal, done bool)\n\nprintInfo(\"foo\", true /* isLocal */, true /* done */)\n```\n\n |
| Bad | Good |
|---|---|
| \n\n```go\nmsg := \"unexpected values %v, %v\\n\"\nfmt.Printf(msg, 1, 2)\n```\n\n | \n\n```go\nconst msg = \"unexpected values %v, %v\\n\"\nfmt.Printf(msg, 1, 2)\n```\n\n |
| Bad | Good |
|---|---|
| \n\n ```go\n if x == \"\" {\n return []int{}\n }\n ```\n\n | \n\n ```go\n if x == \"\" {\n return nil\n }\n ```\n\n |
| Bad | Good |
|---|---|
| \n\n ```go\n func isEmpty(s []string) bool {\n return s == nil\n }\n ```\n\n | \n\n ```go\n func isEmpty(s []string) bool {\n return len(s) == 0\n }\n ```\n\n |
| Bad | Good |
|---|---|
| \n\n ```go\n nums := []int{}\n // or, nums := make([]int)\n\n if add1 {\n nums = append(nums, 1)\n }\n\n if add2 {\n nums = append(nums, 2)\n }\n ```\n\n | \n\n ```go\n var nums []int\n\n if add1 {\n nums = append(nums, 1)\n }\n\n if add2 {\n nums = append(nums, 2)\n }\n ```\n\n |
| Bad | Good |
|---|---|
| \n\n```go\nfor i := 0; i < b.N; i++ {\n s := fmt.Sprint(rand.Int())\n}\n```\n\n | \n\n```go\nfor i := 0; i < b.N; i++ {\n s := strconv.Itoa(rand.Int())\n}\n```\n\n |
| \n\n```plain\nBenchmarkFmtSprint-4 143 ns/op 2 allocs/op\n```\n\n | \n\n```plain\nBenchmarkStrconv-4 64.2 ns/op 1 allocs/op\n```\n\n |
| Bad | Good |
|---|---|
| \n\n```go\nfor i := 0; i < b.N; i++ {\n w.Write([]byte(\"Hello world\"))\n}\n```\n\n | \n\n```go\ndata := []byte(\"Hello world\")\nfor i := 0; i < b.N; i++ {\n w.Write(data)\n}\n```\n\n |
| \n\n```plain\nBenchmarkBad-4 50000000 22.2 ns/op\n```\n\n | \n\n```plain\nBenchmarkGood-4 500000000 3.25 ns/op\n```\n\n |
| Bad | Good |
|---|---|
| \n\n```go\nwantError := \"unknown name:\\\"test\\\"\"\n```\n\n | \n\n```go\nwantError := `unknown error:\"test\"`\n```\n\n |
| Bad | Good |
|---|---|
| \n\n```go\ntype Client struct {\n version int\n http.Client\n}\n```\n\n | \n\n```go\ntype Client struct {\n http.Client\n\n version int\n}\n```\n\n |
| Bad | Good |
|---|---|
| \n\n```go\ntype A struct {\n // Bad: A.Lock() and A.Unlock() are\n // now available, provide no\n // functional benefit, and allow\n // users to control details about\n // the internals of A.\n sync.Mutex\n}\n```\n\n | \n\n```go\ntype countingWriteCloser struct {\n // Good: Write() is provided at this\n // outer layer for a specific\n // purpose, and delegates work\n // to the inner type's Write().\n io.WriteCloser\n\n count int\n}\n\nfunc (w *countingWriteCloser) Write(bs []byte) (int, error) {\n w.count += len(bs)\n return w.WriteCloser.Write(bs)\n}\n```\n\n |
| \n\n```go\ntype Book struct {\n // Bad: pointer changes zero value usefulness\n io.ReadWriter\n\n // other fields\n}\n\n// later\n\nvar b Book\nb.Read(...) // panic: nil pointer\nb.String() // panic: nil pointer\nb.Write(...) // panic: nil pointer\n```\n\n | \n\n```go\ntype Book struct {\n // Good: has useful zero value\n bytes.Buffer\n\n // other fields\n}\n\n// later\n\nvar b Book\nb.Read(...) // ok\nb.String() // ok\nb.Write(...) // ok\n```\n\n |
| \n\n```go\ntype Client struct {\n sync.Mutex\n sync.WaitGroup\n bytes.Buffer\n url.URL\n}\n```\n\n | \n\n```go\ntype Client struct {\n mtx sync.Mutex\n wg sync.WaitGroup\n buf bytes.Buffer\n url url.URL\n}\n```\n\n |
| Bad | Good |
|---|---|
| \n\n```go\nk := User{\"John\", \"Doe\", true}\n```\n\n | \n\n```go\nk := User{\n FirstName: \"John\",\n LastName: \"Doe\",\n Admin: true,\n}\n```\n\n |
| Bad | Good |
|---|---|
| \n\n```go\nuser := User{\n FirstName: \"John\",\n LastName: \"Doe\",\n MiddleName: \"\",\n Admin: false,\n}\n```\n\n | \n\n```go\nuser := User{\n FirstName: \"John\",\n LastName: \"Doe\",\n}\n```\n\n |
| Bad | Good |
|---|---|
| \n\n```go\nsval := T{Name: \"foo\"}\n\n// inconsistent\nsptr := new(T)\nsptr.Name = \"bar\"\n```\n\n | \n\n```go\nsval := T{Name: \"foo\"}\n\nsptr := &T{Name: \"bar\"}\n```\n\n |
| Bad | Good |
|---|---|
| \n\n```go\ntype Stock struct {\n Price int\n Name string\n}\n\nbytes, err := json.Marshal(Stock{\n Price: 137,\n Name: \"UBER\",\n})\n```\n\n | \n\n```go\ntype Stock struct {\n Price int `json:\"price\"`\n Name string `json:\"name\"`\n // Safe to rename Name to Symbol.\n}\n\nbytes, err := json.Marshal(Stock{\n Price: 137,\n Name: \"UBER\",\n})\n```\n\n |
| Bad | Good |
|---|---|
| \n\n```go\nuser := User{}\n```\n\n | \n\n```go\nvar user User\n```\n\n |
| Bad | Good |
|---|---|
| \n\n```go\n// func TestSplitHostPort(t *testing.T)\n\nhost, port, err := net.SplitHostPort(\"192.0.2.0:8000\")\nrequire.NoError(t, err)\nassert.Equal(t, \"192.0.2.0\", host)\nassert.Equal(t, \"8000\", port)\n\nhost, port, err = net.SplitHostPort(\"192.0.2.0:http\")\nrequire.NoError(t, err)\nassert.Equal(t, \"192.0.2.0\", host)\nassert.Equal(t, \"http\", port)\n\nhost, port, err = net.SplitHostPort(\":8000\")\nrequire.NoError(t, err)\nassert.Equal(t, \"\", host)\nassert.Equal(t, \"8000\", port)\n\nhost, port, err = net.SplitHostPort(\"1:8\")\nrequire.NoError(t, err)\nassert.Equal(t, \"1\", host)\nassert.Equal(t, \"8\", port)\n```\n\n | \n\n```go\n// func TestSplitHostPort(t *testing.T)\n\ntests := []struct{\n give string\n wantHost string\n wantPort string\n}{\n {\n give: \"192.0.2.0:8000\",\n wantHost: \"192.0.2.0\",\n wantPort: \"8000\",\n },\n {\n give: \"192.0.2.0:http\",\n wantHost: \"192.0.2.0\",\n wantPort: \"http\",\n },\n {\n give: \":8000\",\n wantHost: \"\",\n wantPort: \"8000\",\n },\n {\n give: \"1:8\",\n wantHost: \"1\",\n wantPort: \"8\",\n },\n}\n\nfor _, tt := range tests {\n t.Run(tt.give, func(t *testing.T) {\n host, port, err := net.SplitHostPort(tt.give)\n require.NoError(t, err)\n assert.Equal(t, tt.wantHost, host)\n assert.Equal(t, tt.wantPort, port)\n })\n}\n```\n\n |
| Bad | Good |
|---|---|
| \n\n```go\nfunc TestComplicatedTable(t *testing.T) {\n tests := []struct {\n give string\n want string\n wantErr error\n shouldCallX bool\n shouldCallY bool\n giveXResponse string\n giveXErr error\n giveYResponse string\n giveYErr error\n }{\n // ...\n }\n\n for _, tt := range tests {\n t.Run(tt.give, func(t *testing.T) {\n // setup mocks\n ctrl := gomock.NewController(t)\n xMock := xmock.NewMockX(ctrl)\n if tt.shouldCallX {\n xMock.EXPECT().Call().Return(\n tt.giveXResponse, tt.giveXErr,\n )\n }\n yMock := ymock.NewMockY(ctrl)\n if tt.shouldCallY {\n yMock.EXPECT().Call().Return(\n tt.giveYResponse, tt.giveYErr,\n )\n }\n\n got, err := DoComplexThing(tt.give, xMock, yMock)\n\n // verify results\n if tt.wantErr != nil {\n require.EqualError(t, err, tt.wantErr)\n return\n }\n require.NoError(t, err)\n assert.Equal(t, want, got)\n })\n }\n}\n```\n\n | \n\n```go\nfunc TestShouldCallX(t *testing.T) {\n // setup mocks\n ctrl := gomock.NewController(t)\n xMock := xmock.NewMockX(ctrl)\n xMock.EXPECT().Call().Return(\"XResponse\", nil)\n\n yMock := ymock.NewMockY(ctrl)\n\n got, err := DoComplexThing(\"inputX\", xMock, yMock)\n\n require.NoError(t, err)\n assert.Equal(t, \"want\", got)\n}\n\nfunc TestShouldCallYAndFail(t *testing.T) {\n // setup mocks\n ctrl := gomock.NewController(t)\n xMock := xmock.NewMockX(ctrl)\n\n yMock := ymock.NewMockY(ctrl)\n yMock.EXPECT().Call().Return(\"YResponse\", nil)\n\n _, err := DoComplexThing(\"inputY\", xMock, yMock)\n assert.EqualError(t, err, \"Y failed\")\n}\n```\n |
| Bad | Good |
|---|---|
| \n\n```go\nfunc isActive(now, start, stop int) bool {\n return start <= now && now < stop\n}\n```\n\n | \n\n```go\nfunc isActive(now, start, stop time.Time) bool {\n return (start.Before(now) || start.Equal(now)) && now.Before(stop)\n}\n```\n\n |
| Bad | Good |
|---|---|
| \n\n```go\nfunc poll(delay int) {\n for {\n // ...\n time.Sleep(time.Duration(delay) * time.Millisecond)\n }\n}\n\npoll(10) // was it seconds or milliseconds?\n```\n\n | \n\n```go\nfunc poll(delay time.Duration) {\n for {\n // ...\n time.Sleep(delay)\n }\n}\n\npoll(10*time.Second)\n```\n\n |
| Bad | Good |
|---|---|
| \n\n```go\n// {\"interval\": 2}\ntype Config struct {\n Interval int `json:\"interval\"`\n}\n```\n\n | \n\n```go\n// {\"intervalMillis\": 2000}\ntype Config struct {\n IntervalMillis int `json:\"intervalMillis\"`\n}\n```\n\n |
| Bad | Good |
|---|---|
| \n\n```go\nt := i.(string)\n```\n\n | \n\n```go\nt, ok := i.(string)\nif !ok {\n // handle the error gracefully\n}\n```\n\n |
| Bad | Good |
|---|---|
| \n\n```go\nvar s = \"foo\"\n```\n\n | \n\n```go\ns := \"foo\"\n```\n\n |
| Bad | Good |
|---|---|
| \n\n```go\nfunc f(list []int) {\n filtered := []int{}\n for _, v := range list {\n if v > 10 {\n filtered = append(filtered, v)\n }\n }\n}\n```\n\n | \n\n```go\nfunc f(list []int) {\n var filtered []int\n for _, v := range list {\n if v > 10 {\n filtered = append(filtered, v)\n }\n }\n}\n```\n\n |
| Bad | Good |
|---|---|
| \n\n```go\nerr := os.WriteFile(name, data, 0644)\nif err != nil {\n return err\n}\n```\n\n | \n\n```go\nif err := os.WriteFile(name, data, 0644); err != nil {\n return err\n}\n```\n\n |
| Bad | Good |
|---|---|
| \n\n```go\nif data, err := os.ReadFile(name); err == nil {\n err = cfg.Decode(data)\n if err != nil {\n return err\n }\n\n fmt.Println(cfg)\n return nil\n} else {\n return err\n}\n```\n\n | \n\n```go\ndata, err := os.ReadFile(name)\nif err != nil {\n return err\n}\n\nif err := cfg.Decode(data); err != nil {\n return err\n}\n\nfmt.Println(cfg)\nreturn nil\n```\n\n |
| Bad | Good |
|---|---|
| \n\n```go\nconst (\n _defaultPort = 8080\n _defaultUser = \"user\"\n)\n\nfunc Bar() {\n fmt.Println(\"Default port\", _defaultPort)\n}\n```\n\n | \n\n```go\nfunc Bar() {\n const (\n defaultPort = 8080\n defaultUser = \"user\"\n )\n fmt.Println(\"Default port\", defaultPort)\n}\n```\n\n |
| Bad | Good |
|---|---|
| \n\n```go\ntype Handler struct {\n // ...\n}\n\n\n\nfunc (h *Handler) ServeHTTP(\n w http.ResponseWriter,\n r *http.Request,\n) {\n ...\n}\n```\n\n | \n\n```go\ntype Handler struct {\n // ...\n}\n\nvar _ http.Handler = (*Handler)(nil)\n\nfunc (h *Handler) ServeHTTP(\n w http.ResponseWriter,\n r *http.Request,\n) {\n // ...\n}\n```\n\n |
| Bad | Good |
|---|---|
| \n\n```go\nmu := new(sync.Mutex)\nmu.Lock()\n```\n\n | \n\n```go\nvar mu sync.Mutex\nmu.Lock()\n```\n\n |
| Bad | Good |
|---|---|
| \n\n```go\ntype SMap struct {\n sync.Mutex\n\n data map[string]string\n}\n\nfunc NewSMap() *SMap {\n return &SMap{\n data: make(map[string]string),\n }\n}\n\nfunc (m *SMap) Get(k string) string {\n m.Lock()\n defer m.Unlock()\n\n return m.data[k]\n}\n```\n\n | \n\n```go\ntype SMap struct {\n mu sync.Mutex\n\n data map[string]string\n}\n\nfunc NewSMap() *SMap {\n return &SMap{\n data: make(map[string]string),\n }\n}\n\nfunc (m *SMap) Get(k string) string {\n m.mu.Lock()\n defer m.mu.Unlock()\n\n return m.data[k]\n}\n```\n\n |
| \n\nThe `Mutex` field, and the `Lock` and `Unlock` methods are unintentionally part\nof the exported API of `SMap`.\n\n | \n\nThe mutex and its methods are implementation details of `SMap` hidden from its\ncallers.\n\n |
| Bad | Good |
|---|---|
| \n\n```go\nfunc (d *Driver) SetTrips(trips []Trip) {\n d.trips = trips\n}\n\ntrips := ...\nd1.SetTrips(trips)\n\n// Did you mean to modify d1.trips?\ntrips[0] = ...\n```\n\n | \n\n\n```go\nfunc (d *Driver) SetTrips(trips []Trip) {\n d.trips = make([]Trip, len(trips))\n copy(d.trips, trips)\n}\n\ntrips := ...\nd1.SetTrips(trips)\n\n// We can now modify trips[0] without affecting d1.trips.\ntrips[0] = ...\n```\n\n | \n
| Bad | Good |
|---|---|
| \n\n```go\ntype Stats struct {\n mu sync.Mutex\n counters map[string]int\n}\n\n// Snapshot returns the current stats.\nfunc (s *Stats) Snapshot() map[string]int {\n s.mu.Lock()\n defer s.mu.Unlock()\n\n return s.counters\n}\n\n// snapshot is no longer protected by the mutex, so any\n// access to the snapshot is subject to data races.\nsnapshot := stats.Snapshot()\n```\n\n | \n\n```go\ntype Stats struct {\n mu sync.Mutex\n counters map[string]int\n}\n\nfunc (s *Stats) Snapshot() map[string]int {\n s.mu.Lock()\n defer s.mu.Unlock()\n\n result := make(map[string]int, len(s.counters))\n for k, v := range s.counters {\n result[k] = v\n }\n return result\n}\n\n// Snapshot is now a copy.\nsnapshot := stats.Snapshot()\n```\n\n |
| Bad | Good |
|---|---|
| \n\n```go\np.Lock()\nif p.count < 10 {\n p.Unlock()\n return p.count\n}\n\np.count++\nnewCount := p.count\np.Unlock()\n\nreturn newCount\n\n// easy to miss unlocks due to multiple returns\n```\n\n | \n\n```go\np.Lock()\ndefer p.Unlock()\n\nif p.count < 10 {\n return p.count\n}\n\np.count++\nreturn p.count\n\n// more readable\n```\n\n |
| Bad | Good |
|---|---|
| \n\n```go\n// Ought to be enough for anybody!\nc := make(chan int, 64)\n```\n\n | \n\n```go\n// Size of one\nc := make(chan int, 1) // or\n// Unbuffered channel, size of zero\nc := make(chan int)\n```\n\n |
| Bad | Good |
|---|---|
| \n\n```go\ntype Operation int\n\nconst (\n Add Operation = iota\n Subtract\n Multiply\n)\n\n// Add=0, Subtract=1, Multiply=2\n```\n\n | \n\n```go\ntype Operation int\n\nconst (\n Add Operation = iota + 1\n Subtract\n Multiply\n)\n\n// Add=1, Subtract=2, Multiply=3\n```\n\n |
| Bad | Good |
|---|---|
| \n\n```go\nfunc isActive(now, start, stop int) bool {\n return start <= now && now < stop\n}\n```\n\n | \n\n```go\nfunc isActive(now, start, stop time.Time) bool {\n return (start.Before(now) || start.Equal(now)) && now.Before(stop)\n}\n```\n\n |
| Bad | Good |
|---|---|
| \n\n```go\nfunc poll(delay int) {\n for {\n // ...\n time.Sleep(time.Duration(delay) * time.Millisecond)\n }\n}\n\npoll(10) // was it seconds or milliseconds?\n```\n\n | \n\n```go\nfunc poll(delay time.Duration) {\n for {\n // ...\n time.Sleep(delay)\n }\n}\n\npoll(10*time.Second)\n```\n\n |
| Bad | Good |
|---|---|
| \n\n```go\n// {\"interval\": 2}\ntype Config struct {\n Interval int `json:\"interval\"`\n}\n```\n\n | \n\n```go\n// {\"intervalMillis\": 2000}\ntype Config struct {\n IntervalMillis int `json:\"intervalMillis\"`\n}\n```\n\n |
| No error matching | Error matching |
|---|---|
| \n\n```go\n// package foo\n\nfunc Open() error {\n return errors.New(\"could not open\")\n}\n\n// package bar\n\nif err := foo.Open(); err != nil {\n // Can't handle the error.\n panic(\"unknown error\")\n}\n```\n\n | \n\n```go\n// package foo\n\nvar ErrCouldNotOpen = errors.New(\"could not open\")\n\nfunc Open() error {\n return ErrCouldNotOpen\n}\n\n// package bar\n\nif err := foo.Open(); err != nil {\n if errors.Is(err, foo.ErrCouldNotOpen) {\n // handle the error\n } else {\n panic(\"unknown error\")\n }\n}\n```\n\n |
| No error matching | Error matching |
|---|---|
| \n\n```go\n// package foo\n\nfunc Open(file string) error {\n return fmt.Errorf(\"file %q not found\", file)\n}\n\n// package bar\n\nif err := foo.Open(\"testfile.txt\"); err != nil {\n // Can't handle the error.\n panic(\"unknown error\")\n}\n```\n\n | \n\n```go\n// package foo\n\ntype NotFoundError struct {\n File string\n}\n\nfunc (e *NotFoundError) Error() string {\n return fmt.Sprintf(\"file %q not found\", e.File)\n}\n\nfunc Open(file string) error {\n return &NotFoundError{File: file}\n}\n\n\n// package bar\n\nif err := foo.Open(\"testfile.txt\"); err != nil {\n var notFound *NotFoundError\n if errors.As(err, ¬Found) {\n // handle the error\n } else {\n panic(\"unknown error\")\n }\n}\n```\n\n |
| Bad | Good |
|---|---|
| \n\n```go\ns, err := store.New()\nif err != nil {\n return fmt.Errorf(\n \"failed to create new store: %w\", err)\n}\n```\n\n | \n\n```go\ns, err := store.New()\nif err != nil {\n return fmt.Errorf(\n \"new store: %w\", err)\n}\n```\n\n |
| \n\n```plain\nfailed to x: failed to y: failed to create new store: the error\n```\n\n | \n\n```plain\nx: y: new store: the error\n```\n\n |
| Description | Code |
|---|---|
| \n\n**Bad**: Log the error and return it\n\nCallers further up the stack will likely take a similar action with the error.\nDoing so makes a lot of noise in the application logs for little value.\n\n | \n\n```go\nu, err := getUser(id)\nif err != nil {\n // BAD: See description\n log.Printf(\"Could not get user %q: %v\", id, err)\n return err\n}\n```\n\n |
| \n\n**Good**: Wrap the error and return it\n\nCallers further up the stack will handle the error.\nUse of `%w` ensures they can match the error with `errors.Is` or `errors.As`\nif relevant.\n\n | \n\n```go\nu, err := getUser(id)\nif err != nil {\n return fmt.Errorf(\"get user %q: %w\", id, err)\n}\n```\n\n |
| \n\n**Good**: Log the error and degrade gracefully\n\nIf the operation isn't strictly necessary,\nwe can provide a degraded but unbroken experience\nby recovering from it.\n\n | \n\n```go\nif err := emitMetrics(); err != nil {\n // Failure to write metrics should not\n // break the application.\n log.Printf(\"Could not emit metrics: %v\", err)\n}\n\n```\n\n |
| \n\n**Good**: Match the error and degrade gracefully\n\nIf the callee defines a specific error in its contract,\nand the failure is recoverable,\nmatch on that error case and degrade gracefully.\nFor all other cases, wrap the error and return it.\n\nCallers further up the stack will handle other errors.\n\n | \n\n```go\ntz, err := getUserTimeZone(id)\nif err != nil {\n if errors.Is(err, ErrUserNotFound) {\n // User doesn't exist. Use UTC.\n tz = time.UTC\n } else {\n return fmt.Errorf(\"get user %q: %w\", id, err)\n }\n}\n```\n\n |
| Bad | Good |
|---|---|
| \n\n```go\nt := i.(string)\n```\n\n | \n\n```go\nt, ok := i.(string)\nif !ok {\n // handle the error gracefully\n}\n```\n\n |
| Bad | Good |
|---|---|
| \n\n```go\nfunc run(args []string) {\n if len(args) == 0 {\n panic(\"an argument is required\")\n }\n // ...\n}\n\nfunc main() {\n run(os.Args[1:])\n}\n```\n\n | \n\n```go\nfunc run(args []string) error {\n if len(args) == 0 {\n return errors.New(\"an argument is required\")\n }\n // ...\n return nil\n}\n\nfunc main() {\n if err := run(os.Args[1:]); err != nil {\n fmt.Fprintln(os.Stderr, err)\n os.Exit(1)\n }\n}\n```\n\n |
| Bad | Good |
|---|---|
| \n\n```go\n// func TestFoo(t *testing.T)\n\nf, err := os.CreateTemp(\"\", \"test\")\nif err != nil {\n panic(\"failed to set up test\")\n}\n```\n\n | \n\n```go\n// func TestFoo(t *testing.T)\n\nf, err := os.CreateTemp(\"\", \"test\")\nif err != nil {\n t.Fatal(\"failed to set up test\")\n}\n```\n\n |
| Bad | Good |
|---|---|
| \n\n```go\ntype foo struct {\n running int32 // atomic\n}\n\nfunc (f* foo) start() {\n if atomic.SwapInt32(&f.running, 1) == 1 {\n // already running…\n return\n }\n // start the Foo\n}\n\nfunc (f *foo) isRunning() bool {\n return f.running == 1 // race!\n}\n```\n\n | \n\n```go\ntype foo struct {\n running atomic.Bool\n}\n\nfunc (f *foo) start() {\n if f.running.Swap(true) {\n // already running…\n return\n }\n // start the Foo\n}\n\nfunc (f *foo) isRunning() bool {\n return f.running.Load()\n}\n```\n\n |
| Bad | Good |
|---|---|
| \n\n```go\n// sign.go\n\nvar _timeNow = time.Now\n\nfunc sign(msg string) string {\n now := _timeNow()\n return signWithTime(msg, now)\n}\n```\n\n | \n\n```go\n// sign.go\n\ntype signer struct {\n now func() time.Time\n}\n\nfunc newSigner() *signer {\n return &signer{\n now: time.Now,\n }\n}\n\nfunc (s *signer) Sign(msg string) string {\n now := s.now()\n return signWithTime(msg, now)\n}\n```\n\n |
| \n\n```go\n// sign_test.go\n\nfunc TestSign(t *testing.T) {\n oldTimeNow := _timeNow\n _timeNow = func() time.Time {\n return someFixedTime\n }\n defer func() { _timeNow = oldTimeNow }()\n\n assert.Equal(t, want, sign(give))\n}\n```\n\n | \n\n```go\n// sign_test.go\n\nfunc TestSigner(t *testing.T) {\n s := newSigner()\n s.now = func() time.Time {\n return someFixedTime\n }\n\n assert.Equal(t, want, s.Sign(give))\n}\n```\n\n |
| Bad | Good |
|---|---|
| \n\n```go\n// ConcreteList is a list of entities.\ntype ConcreteList struct {\n *AbstractList\n}\n```\n\n | \n\n```go\n// ConcreteList is a list of entities.\ntype ConcreteList struct {\n list *AbstractList\n}\n\n// Add adds an entity to the list.\nfunc (l *ConcreteList) Add(e Entity) {\n l.list.Add(e)\n}\n\n// Remove removes an entity from the list.\nfunc (l *ConcreteList) Remove(e Entity) {\n l.list.Remove(e)\n}\n```\n\n |
| Bad | Good |
|---|---|
| \n\n```go\n// AbstractList is a generalized implementation\n// for various kinds of lists of entities.\ntype AbstractList interface {\n Add(Entity)\n Remove(Entity)\n}\n\n// ConcreteList is a list of entities.\ntype ConcreteList struct {\n AbstractList\n}\n```\n\n | \n\n```go\n// ConcreteList is a list of entities.\ntype ConcreteList struct {\n list AbstractList\n}\n\n// Add adds an entity to the list.\nfunc (l *ConcreteList) Add(e Entity) {\n l.list.Add(e)\n}\n\n// Remove removes an entity from the list.\nfunc (l *ConcreteList) Remove(e Entity) {\n l.list.Remove(e)\n}\n```\n\n |
| Bad | Good |
|---|---|
| \n\n```go\nvar error string\n// `error` shadows the builtin\n\n// or\n\nfunc handleErrorMessage(error string) {\n // `error` shadows the builtin\n}\n```\n\n | \n\n```go\nvar errorMessage string\n// `error` refers to the builtin\n\n// or\n\nfunc handleErrorMessage(msg string) {\n // `error` refers to the builtin\n}\n```\n\n |
| \n\n```go\ntype Foo struct {\n // While these fields technically don't\n // constitute shadowing, grepping for\n // `error` or `string` strings is now\n // ambiguous.\n error error\n string string\n}\n\nfunc (f Foo) Error() error {\n // `error` and `f.error` are\n // visually similar\n return f.error\n}\n\nfunc (f Foo) String() string {\n // `string` and `f.string` are\n // visually similar\n return f.string\n}\n```\n\n | \n\n```go\ntype Foo struct {\n // `error` and `string` strings are\n // now unambiguous.\n err error\n str string\n}\n\nfunc (f Foo) Error() error {\n return f.err\n}\n\nfunc (f Foo) String() string {\n return f.str\n}\n```\n\n |
| Bad | Good |
|---|---|
| \n\n```go\ntype Foo struct {\n // ...\n}\n\nvar _defaultFoo Foo\n\nfunc init() {\n _defaultFoo = Foo{\n // ...\n }\n}\n```\n\n | \n\n```go\nvar _defaultFoo = Foo{\n // ...\n}\n\n// or, better, for testability:\n\nvar _defaultFoo = defaultFoo()\n\nfunc defaultFoo() Foo {\n return Foo{\n // ...\n }\n}\n```\n\n |
| \n\n```go\ntype Config struct {\n // ...\n}\n\nvar _config Config\n\nfunc init() {\n // Bad: based on current directory\n cwd, _ := os.Getwd()\n\n // Bad: I/O\n raw, _ := os.ReadFile(\n path.Join(cwd, \"config\", \"config.yaml\"),\n )\n\n yaml.Unmarshal(raw, &_config)\n}\n```\n\n | \n\n```go\ntype Config struct {\n // ...\n}\n\nfunc loadConfig() Config {\n cwd, err := os.Getwd()\n // handle err\n\n raw, err := os.ReadFile(\n path.Join(cwd, \"config\", \"config.yaml\"),\n )\n // handle err\n\n var config Config\n yaml.Unmarshal(raw, &config)\n\n return config\n}\n```\n\n |
| Bad | Good |
|---|---|
| \n\n```go\nfunc main() {\n body := readFile(path)\n fmt.Println(body)\n}\n\nfunc readFile(path string) string {\n f, err := os.Open(path)\n if err != nil {\n log.Fatal(err)\n }\n\n b, err := io.ReadAll(f)\n if err != nil {\n log.Fatal(err)\n }\n\n return string(b)\n}\n```\n\n | \n\n```go\nfunc main() {\n body, err := readFile(path)\n if err != nil {\n log.Fatal(err)\n }\n fmt.Println(body)\n}\n\nfunc readFile(path string) (string, error) {\n f, err := os.Open(path)\n if err != nil {\n return \"\", err\n }\n\n b, err := io.ReadAll(f)\n if err != nil {\n return \"\", err\n }\n\n return string(b), nil\n}\n```\n\n |
| Bad | Good |
|---|---|
| \n\n```go\npackage main\n\nfunc main() {\n args := os.Args[1:]\n if len(args) != 1 {\n log.Fatal(\"missing file\")\n }\n name := args[0]\n\n f, err := os.Open(name)\n if err != nil {\n log.Fatal(err)\n }\n defer f.Close()\n\n // If we call log.Fatal after this line,\n // f.Close will not be called.\n\n b, err := io.ReadAll(f)\n if err != nil {\n log.Fatal(err)\n }\n\n // ...\n}\n```\n\n | \n\n```go\npackage main\n\nfunc main() {\n if err := run(); err != nil {\n log.Fatal(err)\n }\n}\n\nfunc run() error {\n args := os.Args[1:]\n if len(args) != 1 {\n return errors.New(\"missing file\")\n }\n name := args[0]\n\n f, err := os.Open(name)\n if err != nil {\n return err\n }\n defer f.Close()\n\n b, err := io.ReadAll(f)\n if err != nil {\n return err\n }\n\n // ...\n}\n```\n\n |
| Bad | Good |
|---|---|
| \n\n```go\ntype Stock struct {\n Price int\n Name string\n}\n\nbytes, err := json.Marshal(Stock{\n Price: 137,\n Name: \"UBER\",\n})\n```\n\n | \n\n```go\ntype Stock struct {\n Price int `json:\"price\"`\n Name string `json:\"name\"`\n // Safe to rename Name to Symbol.\n}\n\nbytes, err := json.Marshal(Stock{\n Price: 137,\n Name: \"UBER\",\n})\n```\n\n |
| Bad | Good |
|---|---|
| \n\n```go\ngo func() {\n for {\n flush()\n time.Sleep(delay)\n }\n}()\n```\n\n | \n\n```go\nvar (\n stop = make(chan struct{}) // tells the goroutine to stop\n done = make(chan struct{}) // tells us that the goroutine exited\n)\ngo func() {\n defer close(done)\n\n ticker := time.NewTicker(delay)\n defer ticker.Stop()\n for {\n select {\n case <-ticker.C:\n flush()\n case <-stop:\n return\n }\n }\n}()\n\n// Elsewhere...\nclose(stop) // signal the goroutine to stop\n<-done // and wait for it to exit\n```\n\n |
| \n\nThere's no way to stop this goroutine.\nThis will run until the application exits.\n\n | \n\nThis goroutine can be stopped with `close(stop)`,\nand we can wait for it to exit with `<-done`.\n\n |
| Bad | Good |
|---|---|
| \n\n```go\nfunc init() {\n go doWork()\n}\n\nfunc doWork() {\n for {\n // ...\n }\n}\n```\n\n | \n\n```go\ntype Worker struct{ /* ... */ }\n\nfunc NewWorker(...) *Worker {\n w := &Worker{\n stop: make(chan struct{}),\n done: make(chan struct{}),\n // ...\n }\n go w.doWork()\n return w\n}\n\nfunc (w *Worker) doWork() {\n defer close(w.done)\n for {\n // ...\n case <-w.stop:\n return\n }\n}\n\n// Shutdown tells the worker to stop\n// and waits until it has finished.\nfunc (w *Worker) Shutdown() {\n close(w.stop)\n <-w.done\n}\n```\n\n |
| \n\nSpawns a background goroutine unconditionally when the user exports this package.\nThe user has no control over the goroutine or a means of stopping it.\n\n | \n\nSpawns the worker only if the user requests it.\nProvides a means of shutting down the worker so that the user can free up\nresources used by the worker.\n\nNote that you should use `WaitGroup`s if the worker manages multiple\ngoroutines.\nSee [Wait for goroutines to exit](#wait-for-goroutines-to-exit).\n\n |
| Bad | Good |
|---|---|
| \n\n```go\nfor i := 0; i < b.N; i++ {\n s := fmt.Sprint(rand.Int())\n}\n```\n\n | \n\n```go\nfor i := 0; i < b.N; i++ {\n s := strconv.Itoa(rand.Int())\n}\n```\n\n |
| \n\n```plain\nBenchmarkFmtSprint-4 143 ns/op 2 allocs/op\n```\n\n | \n\n```plain\nBenchmarkStrconv-4 64.2 ns/op 1 allocs/op\n```\n\n |
| Bad | Good |
|---|---|
| \n\n```go\nfor i := 0; i < b.N; i++ {\n w.Write([]byte(\"Hello world\"))\n}\n```\n\n | \n\n```go\ndata := []byte(\"Hello world\")\nfor i := 0; i < b.N; i++ {\n w.Write(data)\n}\n```\n\n |
| \n\n```plain\nBenchmarkBad-4 50000000 22.2 ns/op\n```\n\n | \n\n```plain\nBenchmarkGood-4 500000000 3.25 ns/op\n```\n\n |
| Bad | Good |
|---|---|
| \n\n```go\nfiles, _ := os.ReadDir(\"./files\")\n\nm := make(map[string]os.DirEntry)\nfor _, f := range files {\n m[f.Name()] = f\n}\n```\n\n | \n\n```go\n\nfiles, _ := os.ReadDir(\"./files\")\n\nm := make(map[string]os.DirEntry, len(files))\nfor _, f := range files {\n m[f.Name()] = f\n}\n```\n\n |
| \n\n`m` is created without a size hint; the map will resize\ndynamically, causing multiple allocations as it grows.\n\n | \n\n`m` is created with a size hint; there may be fewer\nallocations at assignment time.\n\n |
| Bad | Good |
|---|---|
| \n\n```go\nfor n := 0; n < b.N; n++ {\n data := make([]int, 0)\n for k := 0; k < size; k++{\n data = append(data, k)\n }\n}\n```\n\n | \n\n```go\nfor n := 0; n < b.N; n++ {\n data := make([]int, 0, size)\n for k := 0; k < size; k++{\n data = append(data, k)\n }\n}\n```\n\n |
| \n\n```plain\nBenchmarkBad-4 100000000 2.48s\n```\n\n | \n\n```plain\nBenchmarkGood-4 100000000 0.21s\n```\n\n |
| Bad | Good |
|---|---|
| \n\n```go\nimport \"a\"\nimport \"b\"\n```\n\n | \n\n```go\nimport (\n \"a\"\n \"b\"\n)\n```\n\n |
| Bad | Good |
|---|---|
| \n\n```go\n\nconst a = 1\nconst b = 2\n\n\n\nvar a = 1\nvar b = 2\n\n\n\ntype Area float64\ntype Volume float64\n```\n\n | \n\n```go\nconst (\n a = 1\n b = 2\n)\n\nvar (\n a = 1\n b = 2\n)\n\ntype (\n Area float64\n Volume float64\n)\n```\n\n |
| Bad | Good |
|---|---|
| \n\n```go\ntype Operation int\n\nconst (\n Add Operation = iota + 1\n Subtract\n Multiply\n EnvVar = \"MY_ENV\"\n)\n```\n\n | \n\n```go\ntype Operation int\n\nconst (\n Add Operation = iota + 1\n Subtract\n Multiply\n)\n\nconst EnvVar = \"MY_ENV\"\n```\n\n |
| Bad | Good |
|---|---|
| \n\n```go\nfunc f() string {\n red := color.New(0xff0000)\n green := color.New(0x00ff00)\n blue := color.New(0x0000ff)\n\n // ...\n}\n```\n\n | \n\n```go\nfunc f() string {\n var (\n red = color.New(0xff0000)\n green = color.New(0x00ff00)\n blue = color.New(0x0000ff)\n )\n\n // ...\n}\n```\n\n |
| Bad | Good |
|---|---|
| \n\n```go\nfunc (c *client) request() {\n caller := c.name\n format := \"json\"\n timeout := 5*time.Second\n var err error\n\n // ...\n}\n```\n\n | \n\n```go\nfunc (c *client) request() {\n var (\n caller = c.name\n format = \"json\"\n timeout = 5*time.Second\n err error\n )\n\n // ...\n}\n```\n\n |
| Bad | Good |
|---|---|
| \n\n```go\nimport (\n \"fmt\"\n \"os\"\n \"go.uber.org/atomic\"\n \"golang.org/x/sync/errgroup\"\n)\n```\n\n | \n\n```go\nimport (\n \"fmt\"\n \"os\"\n\n \"go.uber.org/atomic\"\n \"golang.org/x/sync/errgroup\"\n)\n```\n\n |
| Bad | Good |
|---|---|
| \n\n```go\nimport (\n \"fmt\"\n \"os\"\n runtimetrace \"runtime/trace\"\n\n nettrace \"golang.net/x/trace\"\n)\n```\n\n | \n\n```go\nimport (\n \"fmt\"\n \"os\"\n \"runtime/trace\"\n\n nettrace \"golang.net/x/trace\"\n)\n```\n\n |
| Bad | Good |
|---|---|
| \n\n```go\nfunc (s *something) Cost() {\n return calcCost(s.weights)\n}\n\ntype something struct{ ... }\n\nfunc calcCost(n []int) int {...}\n\nfunc (s *something) Stop() {...}\n\nfunc newSomething() *something {\n return &something{}\n}\n```\n\n | \n\n```go\ntype something struct{ ... }\n\nfunc newSomething() *something {\n return &something{}\n}\n\nfunc (s *something) Cost() {\n return calcCost(s.weights)\n}\n\nfunc (s *something) Stop() {...}\n\nfunc calcCost(n []int) int {...}\n```\n\n |
| Bad | Good |
|---|---|
| \n\n```go\nfor _, v := range data {\n if v.F1 == 1 {\n v = process(v)\n if err := v.Call(); err == nil {\n v.Send()\n } else {\n return err\n }\n } else {\n log.Printf(\"Invalid v: %v\", v)\n }\n}\n```\n\n | \n\n```go\nfor _, v := range data {\n if v.F1 != 1 {\n log.Printf(\"Invalid v: %v\", v)\n continue\n }\n\n v = process(v)\n if err := v.Call(); err != nil {\n return err\n }\n v.Send()\n}\n```\n\n |
| Bad | Good |
|---|---|
| \n\n```go\nvar a int\nif b {\n a = 100\n} else {\n a = 10\n}\n```\n\n | \n\n```go\na := 10\nif b {\n a = 100\n}\n```\n\n |
| Bad | Good |
|---|---|
| \n\n```go\nvar _s string = F()\n\nfunc F() string { return \"A\" }\n```\n\n | \n\n```go\nvar _s = F()\n// Since F already states that it returns a string, we don't need to specify\n// the type again.\n\nfunc F() string { return \"A\" }\n```\n\n |
| Bad | Good |
|---|---|
| \n\n```go\n// foo.go\n\nconst (\n defaultPort = 8080\n defaultUser = \"user\"\n)\n\n// bar.go\n\nfunc Bar() {\n defaultPort := 9090\n ...\n fmt.Println(\"Default port\", defaultPort)\n\n // We will not see a compile error if the first line of\n // Bar() is deleted.\n}\n```\n\n | \n\n```go\n// foo.go\n\nconst (\n _defaultPort = 8080\n _defaultUser = \"user\"\n)\n```\n\n |
| Bad | Good |
|---|---|
| \n\n```go\ntype Client struct {\n version int\n http.Client\n}\n```\n\n | \n\n```go\ntype Client struct {\n http.Client\n\n version int\n}\n```\n\n |
| Bad | Good |
|---|---|
| \n\n```go\ntype A struct {\n // Bad: A.Lock() and A.Unlock() are\n // now available, provide no\n // functional benefit, and allow\n // users to control details about\n // the internals of A.\n sync.Mutex\n}\n```\n\n | \n\n```go\ntype countingWriteCloser struct {\n // Good: Write() is provided at this\n // outer layer for a specific\n // purpose, and delegates work\n // to the inner type's Write().\n io.WriteCloser\n\n count int\n}\n\nfunc (w *countingWriteCloser) Write(bs []byte) (int, error) {\n w.count += len(bs)\n return w.WriteCloser.Write(bs)\n}\n```\n\n |
| \n\n```go\ntype Book struct {\n // Bad: pointer changes zero value usefulness\n io.ReadWriter\n\n // other fields\n}\n\n// later\n\nvar b Book\nb.Read(...) // panic: nil pointer\nb.String() // panic: nil pointer\nb.Write(...) // panic: nil pointer\n```\n\n | \n\n```go\ntype Book struct {\n // Good: has useful zero value\n bytes.Buffer\n\n // other fields\n}\n\n// later\n\nvar b Book\nb.Read(...) // ok\nb.String() // ok\nb.Write(...) // ok\n```\n\n |
| \n\n```go\ntype Client struct {\n sync.Mutex\n sync.WaitGroup\n bytes.Buffer\n url.URL\n}\n```\n\n | \n\n```go\ntype Client struct {\n mtx sync.Mutex\n wg sync.WaitGroup\n buf bytes.Buffer\n url url.URL\n}\n```\n\n |
| Bad | Good |
|---|---|
| \n\n```go\nvar s = \"foo\"\n```\n\n | \n\n```go\ns := \"foo\"\n```\n\n |
| Bad | Good |
|---|---|
| \n\n```go\nfunc f(list []int) {\n filtered := []int{}\n for _, v := range list {\n if v > 10 {\n filtered = append(filtered, v)\n }\n }\n}\n```\n\n | \n\n```go\nfunc f(list []int) {\n var filtered []int\n for _, v := range list {\n if v > 10 {\n filtered = append(filtered, v)\n }\n }\n}\n```\n\n |
| Bad | Good |
|---|---|
| \n\n ```go\n if x == \"\" {\n return []int{}\n }\n ```\n\n | \n\n ```go\n if x == \"\" {\n return nil\n }\n ```\n\n |
| Bad | Good |
|---|---|
| \n\n ```go\n func isEmpty(s []string) bool {\n return s == nil\n }\n ```\n\n | \n\n ```go\n func isEmpty(s []string) bool {\n return len(s) == 0\n }\n ```\n\n |
| Bad | Good |
|---|---|
| \n\n ```go\n nums := []int{}\n // or, nums := make([]int)\n\n if add1 {\n nums = append(nums, 1)\n }\n\n if add2 {\n nums = append(nums, 2)\n }\n ```\n\n | \n\n ```go\n var nums []int\n\n if add1 {\n nums = append(nums, 1)\n }\n\n if add2 {\n nums = append(nums, 2)\n }\n ```\n\n |
| Bad | Good |
|---|---|
| \n\n```go\nerr := os.WriteFile(name, data, 0644)\nif err != nil {\n return err\n}\n```\n\n | \n\n```go\nif err := os.WriteFile(name, data, 0644); err != nil {\n return err\n}\n```\n\n |
| Bad | Good |
|---|---|
| \n\n```go\nif data, err := os.ReadFile(name); err == nil {\n err = cfg.Decode(data)\n if err != nil {\n return err\n }\n\n fmt.Println(cfg)\n return nil\n} else {\n return err\n}\n```\n\n | \n\n```go\ndata, err := os.ReadFile(name)\nif err != nil {\n return err\n}\n\nif err := cfg.Decode(data); err != nil {\n return err\n}\n\nfmt.Println(cfg)\nreturn nil\n```\n\n |
| Bad | Good |
|---|---|
| \n\n```go\nconst (\n _defaultPort = 8080\n _defaultUser = \"user\"\n)\n\nfunc Bar() {\n fmt.Println(\"Default port\", _defaultPort)\n}\n```\n\n | \n\n```go\nfunc Bar() {\n const (\n defaultPort = 8080\n defaultUser = \"user\"\n )\n fmt.Println(\"Default port\", defaultPort)\n}\n```\n\n |
| Bad | Good |
|---|---|
| \n\n```go\n// func printInfo(name string, isLocal, done bool)\n\nprintInfo(\"foo\", true, true)\n```\n\n | \n\n```go\n// func printInfo(name string, isLocal, done bool)\n\nprintInfo(\"foo\", true /* isLocal */, true /* done */)\n```\n\n |
| Bad | Good |
|---|---|
| \n\n```go\nwantError := \"unknown name:\\\"test\\\"\"\n```\n\n | \n\n```go\nwantError := `unknown error:\"test\"`\n```\n\n |
| Bad | Good |
|---|---|
| \n\n```go\nk := User{\"John\", \"Doe\", true}\n```\n\n | \n\n```go\nk := User{\n FirstName: \"John\",\n LastName: \"Doe\",\n Admin: true,\n}\n```\n\n |
| Bad | Good |
|---|---|
| \n\n```go\nuser := User{\n FirstName: \"John\",\n LastName: \"Doe\",\n MiddleName: \"\",\n Admin: false,\n}\n```\n\n | \n\n```go\nuser := User{\n FirstName: \"John\",\n LastName: \"Doe\",\n}\n```\n\n |
| Bad | Good |
|---|---|
| \n\n```go\nuser := User{}\n```\n\n | \n\n```go\nvar user User\n```\n\n |
| Bad | Good |
|---|---|
| \n\n```go\nsval := T{Name: \"foo\"}\n\n// inconsistent\nsptr := new(T)\nsptr.Name = \"bar\"\n```\n\n | \n\n```go\nsval := T{Name: \"foo\"}\n\nsptr := &T{Name: \"bar\"}\n```\n\n |
| Bad | Good |
|---|---|
| \n\n```go\nvar (\n // m1 is safe to read and write;\n // m2 will panic on writes.\n m1 = map[T1]T2{}\n m2 map[T1]T2\n)\n```\n\n | \n\n```go\nvar (\n // m1 is safe to read and write;\n // m2 will panic on writes.\n m1 = make(map[T1]T2)\n m2 map[T1]T2\n)\n```\n\n |
| \n\nDeclaration and initialization are visually similar.\n\n | \n\nDeclaration and initialization are visually distinct.\n\n |
| Bad | Good |
|---|---|
| \n\n```go\nm := make(map[T1]T2, 3)\nm[k1] = v1\nm[k2] = v2\nm[k3] = v3\n```\n\n | \n\n```go\nm := map[T1]T2{\n k1: v1,\n k2: v2,\n k3: v3,\n}\n```\n\n |
| Bad | Good |
|---|---|
| \n\n```go\nmsg := \"unexpected values %v, %v\\n\"\nfmt.Printf(msg, 1, 2)\n```\n\n | \n\n```go\nconst msg = \"unexpected values %v, %v\\n\"\nfmt.Printf(msg, 1, 2)\n```\n\n |
| Bad | Good |
|---|---|
| \n\n```go\n// func TestSplitHostPort(t *testing.T)\n\nhost, port, err := net.SplitHostPort(\"192.0.2.0:8000\")\nrequire.NoError(t, err)\nassert.Equal(t, \"192.0.2.0\", host)\nassert.Equal(t, \"8000\", port)\n\nhost, port, err = net.SplitHostPort(\"192.0.2.0:http\")\nrequire.NoError(t, err)\nassert.Equal(t, \"192.0.2.0\", host)\nassert.Equal(t, \"http\", port)\n\nhost, port, err = net.SplitHostPort(\":8000\")\nrequire.NoError(t, err)\nassert.Equal(t, \"\", host)\nassert.Equal(t, \"8000\", port)\n\nhost, port, err = net.SplitHostPort(\"1:8\")\nrequire.NoError(t, err)\nassert.Equal(t, \"1\", host)\nassert.Equal(t, \"8\", port)\n```\n\n | \n\n```go\n// func TestSplitHostPort(t *testing.T)\n\ntests := []struct{\n give string\n wantHost string\n wantPort string\n}{\n {\n give: \"192.0.2.0:8000\",\n wantHost: \"192.0.2.0\",\n wantPort: \"8000\",\n },\n {\n give: \"192.0.2.0:http\",\n wantHost: \"192.0.2.0\",\n wantPort: \"http\",\n },\n {\n give: \":8000\",\n wantHost: \"\",\n wantPort: \"8000\",\n },\n {\n give: \"1:8\",\n wantHost: \"1\",\n wantPort: \"8\",\n },\n}\n\nfor _, tt := range tests {\n t.Run(tt.give, func(t *testing.T) {\n host, port, err := net.SplitHostPort(tt.give)\n require.NoError(t, err)\n assert.Equal(t, tt.wantHost, host)\n assert.Equal(t, tt.wantPort, port)\n })\n}\n```\n\n |
| Bad | Good |
|---|---|
| \n\n```go\nfunc TestComplicatedTable(t *testing.T) {\n tests := []struct {\n give string\n want string\n wantErr error\n shouldCallX bool\n shouldCallY bool\n giveXResponse string\n giveXErr error\n giveYResponse string\n giveYErr error\n }{\n // ...\n }\n\n for _, tt := range tests {\n t.Run(tt.give, func(t *testing.T) {\n // setup mocks\n ctrl := gomock.NewController(t)\n xMock := xmock.NewMockX(ctrl)\n if tt.shouldCallX {\n xMock.EXPECT().Call().Return(\n tt.giveXResponse, tt.giveXErr,\n )\n }\n yMock := ymock.NewMockY(ctrl)\n if tt.shouldCallY {\n yMock.EXPECT().Call().Return(\n tt.giveYResponse, tt.giveYErr,\n )\n }\n\n got, err := DoComplexThing(tt.give, xMock, yMock)\n\n // verify results\n if tt.wantErr != nil {\n require.EqualError(t, err, tt.wantErr)\n return\n }\n require.NoError(t, err)\n assert.Equal(t, want, got)\n })\n }\n}\n```\n\n | \n\n```go\nfunc TestShouldCallX(t *testing.T) {\n // setup mocks\n ctrl := gomock.NewController(t)\n xMock := xmock.NewMockX(ctrl)\n xMock.EXPECT().Call().Return(\"XResponse\", nil)\n\n yMock := ymock.NewMockY(ctrl)\n\n got, err := DoComplexThing(\"inputX\", xMock, yMock)\n\n require.NoError(t, err)\n assert.Equal(t, \"want\", got)\n}\n\nfunc TestShouldCallYAndFail(t *testing.T) {\n // setup mocks\n ctrl := gomock.NewController(t)\n xMock := xmock.NewMockX(ctrl)\n\n yMock := ymock.NewMockY(ctrl)\n yMock.EXPECT().Call().Return(\"YResponse\", nil)\n\n _, err := DoComplexThing(\"inputY\", xMock, yMock)\n assert.EqualError(t, err, \"Y failed\")\n}\n```\n |
| Bad | Good |
|---|---|
| \n\n```go\n// package db\n\nfunc Open(\n addr string,\n cache bool,\n logger *zap.Logger\n) (*Connection, error) {\n // ...\n}\n```\n\n | \n\n```go\n// package db\n\ntype Option interface {\n // ...\n}\n\nfunc WithCache(c bool) Option {\n // ...\n}\n\nfunc WithLogger(log *zap.Logger) Option {\n // ...\n}\n\n// Open creates a connection.\nfunc Open(\n addr string,\n opts ...Option,\n) (*Connection, error) {\n // ...\n}\n```\n\n |
| \n\nThe cache and logger parameters must always be provided, even if the user\nwants to use the default.\n\n```go\ndb.Open(addr, db.DefaultCache, zap.NewNop())\ndb.Open(addr, db.DefaultCache, log)\ndb.Open(addr, false /* cache */, zap.NewNop())\ndb.Open(addr, false /* cache */, log)\n```\n\n | \n\nOptions are provided only if needed.\n\n```go\ndb.Open(addr)\ndb.Open(addr, db.WithLogger(log))\ndb.Open(addr, db.WithCache(false))\ndb.Open(\n addr,\n db.WithCache(false),\n db.WithLogger(log),\n)\n```\n\n |