mu := new(sync.Mutex)
mu.Lock()
複製程式碼

var mu sync.Mutex
mu.Lock()
複製程式碼

type smap struct {
  sync.Mutex // only for unexported types（僅適用於非匯出型別）

  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]
}
複製程式碼

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
複製程式碼

// package foo

func Open() error {
  return errors.New("could not open")
}

// package bar

func use() {
  if err := foo.Open(); err != nil {
    if err.Error() == "could not open" {
      // handle
    } else {
      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 err == foo.ErrCouldNotOpen {
    // handle
  } else {
    panic("unknown error")
  }
}
複製程式碼

func open(file string) error {
  return fmt.Errorf("file %q not found",file)
}

func use() {
  if err := open(); err != nil {
    if strings.Contains(err.Error(),"not found") {
      // handle
    } else {
      panic("unknown error")
    }
  }
}
複製程式碼

type errNotFound struct {
  file string
}

func (e errNotFound) Error() string {
  return fmt.Sprintf("file %q not found",e.file)
}

func open(file string) error {
  return errNotFound{file: file}
}

func use() {
  if err := open(); err != nil {
    if _,ok := err.(errNotFound); ok {
      // handle
    } else {
      panic("unknown error")
    }
  }
}
複製程式碼

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

s,err := store.New()
if err != nil {
    return fmt.Errorf(
        "new store: %s",err)
}
複製程式碼

failed to x: failed to y: failed to create new store: the error
複製程式碼

x: y: new store: the error
複製程式碼

t := i.(string)
複製程式碼

t,ok := i.(string)
if !ok {
  // 優雅地處理錯誤
}
複製程式碼

func foo(bar string) {
  if len(bar) == 0 {
    panic("bar must not be empty")
  }
  // ...
}

func main() {
  if len(os.Args) != 2 {
    fmt.Println("USAGE: foo <bar>")
    os.Exit(1)
  }
  foo(os.Args[1])
}
複製程式碼

func foo(bar string) error {
  if len(bar) == 0 {
    return errors.New("bar must not be empty")
  }
  // ...
  return nil
}

func main() {
  if len(os.Args) != 2 {
    fmt.Println("USAGE: foo <bar>")
    os.Exit(1)
  }
  if err := foo(os.Args[1]); err != nil {
    panic(err)
  }
}
複製程式碼

// func TestFoo(t *testing.T)

f,err := ioutil.TempFile("","test")
if err != nil {
  panic("failed to set up test")
}
複製程式碼

// func TestFoo(t *testing.T)

f,"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()
}
複製程式碼

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,_ := ioutil.ReadDir("./files")
for _,f := range files {
    m[f.Name()] = f
}
複製程式碼

files,_ := ioutil.ReadDir("./files")

m := make(map[string]os.FileInfo,len(files))
for _,f := range files {
    m[f.Name()] = f
}
複製程式碼

m 是在沒有大小提示的情況下建立的； 在執行時可能會有更多分配。

m 是有大小提示建立的；在執行時可能會有更少的分配。

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
  ENV_VAR = "MY_ENV"
)
複製程式碼

type Operation int

const (
  Add Operation = iota + 1
  Subtract
  Multiply
)

const ENV_VAR = "MY_ENV"
複製程式碼

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

  ...
}
複製程式碼

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

  ...
}
複製程式碼

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
}
複製程式碼

k := User{"John","Doe",true}
複製程式碼

k := User{
    FirstName: "John",LastName: "Doe",Admin: true,}
複製程式碼

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)
    }
  }
}
複製程式碼

err := ioutil.WriteFile(name,data,0644)
if err != nil {
 return err
}
複製程式碼

if err := ioutil.WriteFile(name,0644); err != nil {
 return err
}
複製程式碼

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

  fmt.Println(cfg)
  return nil
} else {
  return err
}
複製程式碼

data,err := ioutil.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,true /* isLocal */,true /* done */)
複製程式碼

wantError := "unknown name:\"test\""
複製程式碼

wantError := `unknown error:"test"`
複製程式碼

sval := T{Name: "foo"}

// inconsistent
sptr := new(T)
sptr.Name = "bar"
複製程式碼

sval := T{Name: "foo"}

sptr := &T{Name: "bar"}
複製程式碼

var (
  // m1 讀寫安全;
  // m2 在寫入時會 panic
  m1 = map[T1]T2{}
  m2 map[T1]T2
)
複製程式碼

var (
  // m1 讀寫安全;
  // m2 在寫入時會 panic
  m1 = make(map[T1]T2)
  m2 map[T1]T2
)
複製程式碼

宣告和初始化看起來非常相似的。

宣告和初始化看起來差別非常大。

m := make(map[T1]T2,3)
m[k1] = v1
m[k2] = v2
m[k3] = v3
複製程式碼

m := map[T1]T2{
  k1: v1,k2: v2,k3: v3,}
複製程式碼

msg := "unexpected values %v,%v\n"
fmt.Printf(msg,1,2)
複製程式碼

const msg = "unexpected values %v,2)
複製程式碼

// func TestSplitHostPort(t *testing.T)

host,port,err := net.SplitHostPort("192.0.2.0:8000")
require.NoError(t,err)
assert.Equal(t,"192.0.2.0",host)
assert.Equal(t,"8000",port)

host,err = net.SplitHostPort("192.0.2.0:http")
require.NoError(t,"http",err = net.SplitHostPort(":8000")
require.NoError(t,"",err = net.SplitHostPort("1:8")
require.NoError(t,"1","8",port)
複製程式碼

// func TestSplitHostPort(t *testing.T)

tests := []struct{
  give     string
  wantHost string
  wantPort string
}{
  {
    give:     "192.0.2.0:8000",wantHost: "192.0.2.0",wantPort: "8000",},{
    give:     "192.0.2.0:http",wantPort: "http",{
    give:     ":8000",wantHost: "",{
    give:     "1:8",wantHost: "1",wantPort: "8",}

for _,tt := range tests {
  t.Run(tt.give,func(t *testing.T) {
    host,err := net.SplitHostPort(tt.give)
    require.NoError(t,err)
    assert.Equal(t,tt.wantHost,host)
    assert.Equal(t,tt.wantPort,port)
  })
}
複製程式碼

// package db

func Connect(
  addr string,timeout time.Duration,caching bool,) (*Connection,error) {
  // ...
}

// Timeout and caching must always be provided,
// even if the user wants to use the default.

db.Connect(addr,db.DefaultTimeout,db.DefaultCaching)
db.Connect(addr,newTimeout,false /* caching */)
db.Connect(addr,false /* caching */)
複製程式碼

type options struct {
  timeout time.Duration
  caching bool
}

// Option overrides behavior of Connect.
type Option interface {
  apply(*options)
}

type optionFunc func(*options)

func (f optionFunc) apply(o *options) {
  f(o)
}

func WithTimeout(t time.Duration) Option {
  return optionFunc(func(o *options) {
    o.timeout = t
  })
}

func WithCaching(cache bool) Option {
  return optionFunc(func(o *options) {
    o.caching = cache
  })
}

// Connect creates a connection.
func Connect(
  addr string,opts ...Option,error) {
  options := options{
    timeout: defaultTimeout,caching: defaultCaching,}

  for _,o := range opts {
    o.apply(&options)
  }

  // ...
}

// Options must be provided only if needed.

db.Connect(addr)
db.Connect(addr,db.WithTimeout(newTimeout))
db.Connect(addr,db.WithCaching(false))
db.Connect(
  addr,db.WithCaching(false),db.WithTimeout(newTimeout),)
複製程式碼