// 如果 Handler 没有实现 http.Handler，会在运行时报错
type Handler struct {
  // ...
}
func (h *Handler) ServeHTTP(
  w http.ResponseWriter,
  r *http.Request,
) {
  ...
}

type Handler struct {
  // ...
}
// 用于触发编译期的接口的合理性检查机制
// 如果 Handler 没有实现 http.Handler，会在编译期报错
var _ http.Handler = (*Handler)(nil)
func (h *Handler) ServeHTTP(
  w http.ResponseWriter,
  r *http.Request,
) {
  // ...
}

mu := new(sync.Mutex)
mu.Lock()

var mu sync.Mutex
mu.Lock()

type SMap struct {
  sync.Mutex
data map[string]string }
func NewSMap() *SMap {   return &SMap{     data: make(map[string]string),   } }
func (m *SMap) Get(k string) string {   m.Lock()   defer m.Unlock()
return m.data[k] }

type SMap struct {
  mu sync.Mutex
data map[string]string }
func NewSMap() *SMap {   return &SMap{     data: make(map[string]string),   } }
func (m *SMap) Get(k string) string {   m.mu.Lock()   defer m.mu.Unlock()
return m.data[k] }

Mutex 字段，Lock 和 Unlock 方法是 SMap 导出的 API 中不刻意说明的一部分。

mutex 及其方法是 SMap 的实现细节，对其调用者不可见。

func (d *Driver) SetTrips(trips []Trip) {
  d.trips = trips
}
trips := ... d1.SetTrips(trips)
// 你是要修改 d1.trips 吗？ trips[0] = ...

func (d *Driver) SetTrips(trips []Trip) {
  d.trips = make([]Trip, len(trips))
  copy(d.trips, trips)
}
trips := ... d1.SetTrips(trips)
// 这里我们修改 trips[0]，但不会影响到 d1.trips trips[0] = ...

type Stats struct {
  mu sync.Mutex
counters map[string]int }
// Snapshot 返回当前状态。 func (s *Stats) Snapshot() map[string]int {   s.mu.Lock()   defer s.mu.Unlock()
return s.counters }
// snapshot 不再受互斥锁保护 // 因此对 snapshot 的任何访问都将受到数据竞争的影响 // 影响 stats.counters snapshot := stats.Snapshot()

type Stats struct {
  mu sync.Mutex
counters map[string]int }
func (s *Stats) Snapshot() map[string]int {   s.mu.Lock()   defer s.mu.Unlock()
result := make(map[string]int, len(s.counters))   for k, v := range s.counters {     result[k] = v   }   return result }
// snapshot 现在是一个拷贝 snapshot := stats.Snapshot()

p.Lock()
if p.count < 10 {
  p.Unlock()
  return p.count
}
p.count++ newCount := p.count p.Unlock()
return newCount
// 当有多个 return 分支时，很容易遗忘 unlock

p.Lock()
defer p.Unlock()
if p.count < 10 {   return p.count }
p.count++ return p.count
// 更可读

// 应该足以满足任何情况！
c := make(chan int, 64)

// 大小：1
c := make(chan int, 1) // 或者
// 无缓冲 channel，大小为 0
c := make(chan int)

type Operation int
const (   Add Operation = iota   Subtract   Multiply )
// Add=0, Subtract=1, Multiply=2

type Operation int
const (   Add Operation = iota + 1   Subtract   Multiply )
// Add=1, Subtract=2, Multiply=3

func isActive(now, start, stop int) bool {
  return start <= now && now < stop
}

func isActive(now, start, stop time.Time) bool {
  return (start.Before(now) || start.Equal(now)) && now.Before(stop)
}

func poll(delay int) {
  for {
    // ...
    time.Sleep(time.Duration(delay) * time.Millisecond)
  }
}
poll(10) // 是几秒钟还是几毫秒？

func poll(delay time.Duration) {
  for {
    // ...
    time.Sleep(delay)
  }
}
poll(10*time.Second)

// {"interval": 2}
type Config struct {
  Interval int json:"interval"
}

// {"intervalMillis": 2000}
type Config struct {
  IntervalMillis int json:"intervalMillis"
}

// package foo
func Open() error {   return errors.New("could not open") }
// package bar
if err := foo.Open(); err != nil {   // Can't handle the error.   panic("unknown error") }

// package foo
var ErrCouldNotOpen = errors.New("could not open")
func Open() error {   return ErrCouldNotOpen }
// package bar
if err := foo.Open(); err != nil {   if errors.Is(err, foo.ErrCouldNotOpen) {     // handle the error   } else {     panic("unknown error")   } }

// package foo
func Open(file string) error {   return fmt.Errorf("file %q not found", file) }
// package bar
if err := foo.Open("testfile.txt"); err != nil {   // Can't handle the error.   panic("unknown error") }

// package foo
type NotFoundError struct {   File string }
func (e *NotFoundError) Error() string {   return fmt.Sprintf("file %q not found", e.File) }
func Open(file string) error {   return &NotFoundError{File: file} }
// package bar
if err := foo.Open("testfile.txt"); err != nil {   var notFound *NotFoundError   if errors.As(err, &notFound) {     // handle the error   } else {     panic("unknown error")   } }

s, err := store.New()
if err != nil {
    return fmt.Errorf(
        "failed to create new store: %w", err)
}

s, err := store.New()
if err != nil {
    return fmt.Errorf(
        "new store: %w", err)
}

failed to x: failed to y: failed to create new store: the error

x: y: new store: the error

Bad: 记录错误并将其返回

堆栈中的调用程序可能会对该错误采取类似的操作。这样做会在应用程序日志中造成大量噪音，但收效甚微。

u, err := getUser(id)
if err != nil {
  // BAD: See description
  log.Printf("Could not get user %q: %v", id, err)
  return err
}

Good: 将错误换行并返回

堆栈中更靠上的调用程序将处理该错误。使用%w可确保它们可以将错误与errors.Is或errors.As相匹配（如果相关）。

u, err := getUser(id)
if err != nil {
  return fmt.Errorf("get user %q: %w", id, err)
}

Good: 记录错误并正常降级

如果操作不是绝对必要的，我们可以通过从中恢复来提供降级但不间断的体验。

if err := emitMetrics(); err != nil {
  // Failure to write metrics should not
  // break the application.
  log.Printf("Could not emit metrics: %v", err)
}

Good: 匹配错误并适当降级

如果被调用者在其约定中定义了一个特定的错误，并且失败是可恢复的，则匹配该错误案例并正常降级。对于所有其他案例，请包装错误并返回。

堆栈中更靠上的调用程序将处理其他错误。

tz, err := getUserTimeZone(id)
if err != nil {
  if errors.Is(err, ErrUserNotFound) {
    // User doesn't exist. Use UTC.
    tz = time.UTC
  } else {
    return fmt.Errorf("get user %q: %w", id, err)
  }
}

t := i.(string)

t, ok := i.(string)
if !ok {
  // 优雅地处理错误
}

func run(args []string) {
  if len(args) == 0 {
    panic("an argument is required")
  }
  // ...
}
func main() {   run(os.Args[1:]) }

func run(args []string) error {
  if len(args) == 0 {
    return errors.New("an argument is required")
  }
  // ...
  return nil
}
func main() {   if err := run(os.Args[1:]); err != nil {     fmt.Fprintln(os.Stderr, err)     os.Exit(1)   } }

// func TestFoo(t *testing.T)
f, err := os.CreateTemp("", "test") if err != nil {   panic("failed to set up test") }

// func TestFoo(t *testing.T)
f, err := os.CreateTemp("", "test") if err != nil {   t.Fatal("failed to set up test") }

type foo struct {
  running int32  // atomic
}
func (f* foo) start() {   if atomic.SwapInt32(&f.running, 1) == 1 {      // already running…      return   }   // start the Foo }
func (f *foo) isRunning() bool {   return f.running == 1  // race! }

type foo struct {
  running atomic.Bool
}
func (f *foo) start() {   if f.running.Swap(true) {      // already running…      return   }   // start the Foo }
func (f *foo) isRunning() bool {   return f.running.Load() }

// sign.go
var _timeNow = time.Now
func sign(msg string) string {
  now := _timeNow()
  return signWithTime(msg, now)
}

// sign.go
type signer struct {
  now func() time.Time
}
func newSigner() *signer {
  return &signer{
    now: time.Now,
  }
}
func (s *signer) Sign(msg string) string {
  now := s.now()
  return signWithTime(msg, now)
}

// sign_test.go
func TestSign(t *testing.T) {
  oldTimeNow := _timeNow
  _timeNow = func() time.Time {
    return someFixedTime
  }
  defer func() { _timeNow = oldTimeNow }()
  assert.Equal(t, want, sign(give))
}

// sign_test.go
func TestSigner(t *testing.T) {
  s := newSigner()
  s.now = func() time.Time {
    return someFixedTime
  }
  assert.Equal(t, want, s.Sign(give))
}

// ConcreteList 是一个实体列表。
type ConcreteList struct {
  *AbstractList
}

// ConcreteList 是一个实体列表。
type ConcreteList struct {
  list *AbstractList
}
// 添加将实体添加到列表中。
func (l *ConcreteList) Add(e Entity) {
  l.list.Add(e)
}
// 移除从列表中移除实体。
func (l *ConcreteList) Remove(e Entity) {
  l.list.Remove(e)
}

// AbstractList 是各种实体列表的通用实现。
type AbstractList interface {
  Add(Entity)
  Remove(Entity)
}
// ConcreteList 是一个实体列表。
type ConcreteList struct {
  AbstractList
}

// ConcreteList 是一个实体列表。
type ConcreteList struct {
  list AbstractList
}
// 添加将实体添加到列表中。
func (l *ConcreteList) Add(e Entity) {
  l.list.Add(e)
}
// 移除从列表中移除实体。
func (l *ConcreteList) Remove(e Entity) {
  l.list.Remove(e)
}

var error string
// error 作用域隐式覆盖
// or
func handleErrorMessage(error string) {     // error 作用域隐式覆盖 }

var errorMessage string
// error 指向内置的非覆盖
// or
func handleErrorMessage(msg string) {     // error 指向内置的非覆盖 }

type Foo struct {
    // 虽然这些字段在技术上不构成阴影，但error或string字符串的重映射现在是不明确的。
    error  error
    string string
}
func (f Foo) Error() error {     // error 和 f.error 在视觉上是相似的     return f.error }
func (f Foo) String() string {     // string and f.string 在视觉上是相似的     return f.string }

type Foo struct {
    // error and string 现在是明确的。
    err error
    str string
}
func (f Foo) Error() error {     return f.err }
func (f Foo) String() string {     return f.str }

type Foo struct {
    // ...
}
var _defaultFoo Foo
func init() {
    _defaultFoo = Foo{
        // ...
    }
}

var _defaultFoo = Foo{
    // ...
}
// or，为了更好的可测试性：
var _defaultFoo = defaultFoo()
func defaultFoo() Foo {
    return Foo{
        // ...
    }
}

type Config struct {
    // ...
}
var _config Config
func init() {
    // Bad: 基于当前目录
    cwd, _ := os.Getwd()
    // Bad: I/O
    raw, _ := os.ReadFile(
        path.Join(cwd, "config", "config.yaml"),
    )
    yaml.Unmarshal(raw, &_config)
}

type Config struct {
    // ...
}
func loadConfig() Config {
    cwd, err := os.Getwd()
    // handle err
    raw, err := os.ReadFile(
        path.Join(cwd, "config", "config.yaml"),
    )
    // handle err
    var config Config
    yaml.Unmarshal(raw, &config)
    return config
}

for n := 0; n < b.N; n++ {
  data := make([]int, 0)
  for k := 0; k < size; k++{
    data = append(data, k)
  }
}

for n := 0; n < b.N; n++ {
  data := make([]int, 0, size)
  for k := 0; k < size; k++{
    data = append(data, k)
  }
}

BenchmarkBad-4    100000000    2.48s

BenchmarkGood-4   100000000    0.21s

func main() {
  body := readFile(path)
  fmt.Println(body)
}
func readFile(path string) string {
  f, err := os.Open(path)
  if err != nil {
    log.Fatal(err)
  }
  b, err := os.ReadAll(f)
  if err != nil {
    log.Fatal(err)
  }
  return string(b)
}

func main() {
  body, err := readFile(path)
  if err != nil {
    log.Fatal(err)
  }
  fmt.Println(body)
}
func readFile(path string) (string, error) {
  f, err := os.Open(path)
  if err != nil {
    return "", err
  }
  b, err := os.ReadAll(f)
  if err != nil {
    return "", err
  }
  return string(b), nil
}

package main
func main() {
  args := os.Args[1:]
  if len(args) != 1 {
    log.Fatal("missing file")
  }
  name := args[0]
  f, err := os.Open(name)
  if err != nil {
    log.Fatal(err)
  }
  defer f.Close()
  // 如果我们调用 log.Fatal 在这条线之后
  // f.Close 将会被执行。
  b, err := os.ReadAll(f)
  if err != nil {
    log.Fatal(err)
  }
  // ...
}

package main
func main() {
  if err := run(); err != nil {
    log.Fatal(err)
  }
}
func run() error {
  args := os.Args[1:]
  if len(args) != 1 {
    return errors.New("missing file")
  }
  name := args[0]
  f, err := os.Open(name)
  if err != nil {
    return err
  }
  defer f.Close()
  b, err := os.ReadAll(f)
  if err != nil {
    return err
  }
  // ...
}

type Stock struct {
  Price int
  Name  string
}
bytes, err := json.Marshal(Stock{
  Price: 137,
  Name:  "UBER",
})

type Stock struct {
  Price int    json:"price"
  Name  string json:"name"
  // Safe to rename Name to Symbol.
}
bytes, err := json.Marshal(Stock{
  Price: 137,
  Name:  "UBER",
})

go func() {
  for {
    flush()
    time.Sleep(delay)
  }
}()

var (
  stop = make(chan struct{}) // 告诉 goroutine 停止
  done = make(chan struct{}) // 告诉我们 goroutine 退出了
)
go func() {
  defer close(done)
  ticker := time.NewTicker(delay)
  defer ticker.Stop()
  for {
    select {
    case <-tick.C:
      flush()
    case <-stop:
      return
    }
  }
}()
// 其它...
close(stop)  // 指示 goroutine 停止
<-done       // and wait for it to exit

没有办法阻止这个 goroutine。这将一直运行到应用程序退出。

这个 goroutine 可以用 close(stop), 我们可以等待它退出 <-done.

func init() {
  go doWork()
}
func doWork() {
  for {
    // ...
  }
}

type Worker struct{ / ... / }
func NewWorker(...) *Worker {
  w := &Worker{
    stop: make(chan struct{}),
    done: make(chan struct{}),
    // ...
  }
  go w.doWork()
}
func (w *Worker) doWork() {
  defer close(w.done)
  for {
    // ...
    case <-w.stop:
      return
  }
}
// Shutdown 告诉 worker 停止
// 并等待它完成。
func (w *Worker) Shutdown() {
  close(w.stop)
  <-w.done
}

当用户导出这个包时，无条件地生成一个后台 goroutine。 用户无法控制 goroutine 或停止它的方法。

仅当用户请求时才生成工作人员。 提供一种关闭工作器的方法，以便用户可以释放工作器使用的资源。

请注意，如果工作人员管理多个 goroutine，则应使用WaitGroup。 请参阅 等待 goroutines 退出。

for i := 0; i < b.N; i++ {
  s := fmt.Sprint(rand.Int())
}

for i := 0; i < b.N; i++ {
  s := strconv.Itoa(rand.Int())
}

BenchmarkFmtSprint-4    143 ns/op    2 allocs/op

BenchmarkStrconv-4    64.2 ns/op    1 allocs/op

for i := 0; i < b.N; i++ {
  w.Write([]byte("Hello world"))
}

data := []byte("Hello world")
for i := 0; i < b.N; i++ {
  w.Write(data)
}

BenchmarkBad-4   50000000   22.2 ns/op

BenchmarkGood-4  500000000   3.25 ns/op

m := make(map[string]os.FileInfo)
files, _ := os.ReadDir("./files") for _, f := range files {     m[f.Name()] = f }

files, _ := os.ReadDir("./files")
m := make(map[string]os.FileInfo, len(files)) for _, f := range files {     m[f.Name()] = f }

m 是在没有大小提示的情况下创建的；在运行时可能会有更多分配。

m 是有大小提示创建的；在运行时可能会有更少的分配。

for n := 0; n < b.N; n++ {
  data := make([]int, 0)
  for k := 0; k < size; k++{
    data = append(data, k)
  }
}

for n := 0; n < b.N; n++ {
  data := make([]int, 0, size)
  for k := 0; k < size; k++{
    data = append(data, k)
  }
}

BenchmarkBad-4    100000000    2.48s

BenchmarkGood-4   100000000    0.21s

import "a"
import "b"

import (
  "a"
  "b"
)

const a = 1
const b = 2
var a = 1 var b = 2
type Area float64 type Volume float64

const (
  a = 1
  b = 2
)
var (   a = 1   b = 2 )
type (   Area float64   Volume float64 )

type Operation int
const (   Add Operation = iota + 1   Subtract   Multiply   EnvVar = "MY_ENV" )

type Operation int
const (   Add Operation = iota + 1   Subtract   Multiply )
const EnvVar = "MY_ENV"

func f() string {
  red := color.New(0xff0000)
  green := color.New(0x00ff00)
  blue := color.New(0x0000ff)
... }

func f() string {
  var (
    red   = color.New(0xff0000)
    green = color.New(0x00ff00)
    blue  = color.New(0x0000ff)
  )
... }

func (c *client) request() {
  caller := c.name
  format := "json"
  timeout := 5*time.Second
  var err error
  // ...
}

func (c *client) request() {
  var (
    caller  = c.name
    format  = "json"
    timeout = 5*time.Second
    err error
  )
  // ...
}

import (
  "fmt"
  "os"
  "go.uber.org/atomic"
  "golang.org/x/sync/errgroup"
)

import (
  "fmt"
  "os"
"go.uber.org/atomic"   "golang.org/x/sync/errgroup" )

import (
  "fmt"
  "os"
nettrace "golang.net/x/trace" )

import (
  "fmt"
  "os"
  "runtime/trace"
nettrace "golang.net/x/trace" )

func (s *something) Cost() {
  return calcCost(s.weights)
}
type something struct{ ... }
func calcCost(n []int) int {...}
func (s *something) Stop() {...}
func newSomething() *something {     return &something{} }

type something struct{ ... }
func newSomething() *something {     return &something{} }
func (s *something) Cost() {   return calcCost(s.weights) }
func (s *something) Stop() {...}
func calcCost(n []int) int {...}

for _, v := range data {
  if v.F1 == 1 {
    v = process(v)
    if err := v.Call(); err == nil {
      v.Send()
    } else {
      return err
    }
  } else {
    log.Printf("Invalid v: %v", v)
  }
}

for _, v := range data {
  if v.F1 != 1 {
    log.Printf("Invalid v: %v", v)
    continue
  }
v = process(v)   if err := v.Call(); err != nil {     return err   }   v.Send() }

var a int
if b {
  a = 100
} else {
  a = 10
}

a := 10
if b {
  a = 100
}

var _s string = F()
func F() string { return "A" }

var _s = F()
// 由于 F 已经明确了返回一个字符串类型，因此我们没有必要显式指定_s 的类型
// 还是那种类型
func F() string { return "A" }

// foo.go
const (   defaultPort = 8080   defaultUser = "user" )
// bar.go
func Bar() {   defaultPort := 9090   ...   fmt.Println("Default port", defaultPort)
// We will not see a compile error if the first line of   // Bar() is deleted. }

// foo.go
const (   _defaultPort = 8080   _defaultUser = "user" )

type Client struct {
  version int
  http.Client
}

type Client struct {
  http.Client
version int }

type A struct {
    // Bad: A.Lock() and A.Unlock() 现在可用
    // 不提供任何功能性好处，并允许用户控制有关 A 的内部细节。
    sync.Mutex
}

type countingWriteCloser struct {
    // Good: Write() 在外层提供用于特定目的，
    // 并且委托工作到内部类型的 Write() 中。
    io.WriteCloser
    count int
}
func (w *countingWriteCloser) Write(bs []byte) (int, error) {
    w.count += len(bs)
    return w.WriteCloser.Write(bs)
}

type Book struct {
    // Bad: 指针更改零值的有用性
    io.ReadWriter
    // other fields
}
// later
var b Book
b.Read(...)  // panic: nil pointer
b.String()   // panic: nil pointer
b.Write(...) // panic: nil pointer

type Book struct {
    // Good: 有用的零值
    bytes.Buffer
    // other fields
}
// later
var b Book
b.Read(...)  // ok
b.String()   // ok
b.Write(...) // ok

type Client struct {
    sync.Mutex
    sync.WaitGroup
    bytes.Buffer
    url.URL
}

type Client struct {
    mtx sync.Mutex
    wg  sync.WaitGroup
    buf bytes.Buffer
    url url.URL
}

var s = "foo"

s := "foo"

func f(list []int) {
  filtered := []int{}
  for _, v := range list {
    if v > 10 {
      filtered = append(filtered, v)
    }
  }
}

func f(list []int) {
  var filtered []int
  for _, v := range list {
    if v > 10 {
      filtered = append(filtered, v)
    }
  }
}

if x == "" {
    return []int{}
  }

if x == "" {
    return nil
  }

func isEmpty(s []string) bool {
    return s == nil
  }

func isEmpty(s []string) bool {
    return len(s) == 0
  }

nums := []int{}
  // or, nums := make([]int)
if add1 {     nums = append(nums, 1)   }
if add2 {     nums = append(nums, 2)   }

var nums []int
if add1 {     nums = append(nums, 1)   }
if add2 {     nums = append(nums, 2)   }

err := os.WriteFile(name, data, 0644)
if err != nil {
 return err
}

if err := os.WriteFile(name, data, 0644); err != nil {
 return err
}

if data, err := os.ReadFile(name); err == nil {
  err = cfg.Decode(data)
  if err != nil {
    return err
  }
fmt.Println(cfg)   return nil } else {   return err }

data, err := os.ReadFile(name)
if err != nil {
   return err
}
if err := cfg.Decode(data); err != nil {   return err }
fmt.Println(cfg) return nil

// func printInfo(name string, isLocal, done bool)
printInfo("foo", true, true)

// func printInfo(name string, isLocal, done bool)
printInfo("foo", true / isLocal /, true / done /)