mu := new(sync.Mutex)
mu.Lock()
复制代码

var mu sync.Mutex
mu.Lock()
复制代码

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 {
 sync.Mutex
 counters map[string]int
}
// Snapshot 返回当前状态
func (s *Stats) Snapshot() map[string]int {
 s.Lock()
 defer s.Unlock()
 return s.counters
}
// snapshot 不再受锁保护了!
snapshot := stats.Snapshot()
复制代码

type Stats struct {
 sync.Mutex
 counters map[string]int
}
func (s *Stats) Snapshot() map[string]int {
 s.Lock()
 defer s.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 时容易忘记释放锁
复制代码

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) // or
// 无缓冲 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 {
 // handle the error gracefully
}
复制代码

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, err := ioutil.TempFile("", "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
复制代码

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 := range list {
 if v > 10 {
 filtered = append(filtered, v)
 }
 }
}
复制代码

err := ioutil.WriteFile(name, data, 0644)
if err != nil {
 return err
}
复制代码

if err := ioutil.WriteFile(name, data, 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, isLocal, done bool)
printInfo("foo", true /* isLocal */, true /* done */)
复制代码

wantError := "unknown name:\"test\""
复制代码

wantError := `unknown error:"test"`
复制代码

sval := T{Name: "foo"}
// 定义方式不一致
sptr := new(T)
sptr.Name = "bar"
复制代码

sval := T{Name: "foo"}
sptr := &T{Name: "bar"}
复制代码

msg := "unexpected values %v, %v\n"
fmt.Printf(msg, 1, 2)
复制代码

const msg = "unexpected values %v, %v\n"
fmt.Printf(msg, 1, 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, port, err = net.SplitHostPort("192.0.2.0:http")
require.NoError(t, err)
assert.Equal(t, "192.0.2.0", host)
assert.Equal(t, "http", port)
host, port, err = net.SplitHostPort(":8000")
require.NoError(t, err)
assert.Equal(t, "", host)
assert.Equal(t, "8000", port)
host, port, err = net.SplitHostPort("1:8")
require.NoError(t, err)
assert.Equal(t, "1", host)
assert.Equal(t, "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",
 wantHost: "192.0.2.0",
 wantPort: "http",
 },
 {
 give: ":8000",
 wantHost: "",
 wantPort: "8000",
 },
 {
 give: "1:8",
 wantHost: "1",
 wantPort: "8",
 },
}
for _, tt := range tests {
 t.Run(tt.give, func(t *testing.T) {
 host, port, 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, db.DefaultCaching)
db.Connect(addr, db.DefaultTimeout, false /* caching */)
db.Connect(addr, newTimeout, 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,
) (*Connection, 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),
)
复制代码