Uber Go 语言编码规范

1// 如果Handler没有实现http.Handler,会在运行时报错 2type Handler struct { 3 // ... 4} 5func (h *Handler) ServeHTTP( 6 w http.ResponseWriter, 7 r *http.Request, 8) { 9 ... 10}

1type Handler struct { 2 // ... 3} 4// 用于触发编译期的接口的合理性检查机制 5// 如果Handler没有实现http.Handler,会在编译期报错 6var _ http.Handler = (*Handler)(nil) 7func (h *Handler) ServeHTTP( 8 w http.ResponseWriter, 9 r *http.Request, 10) { 11 // ... 12}

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

1var mu sync.Mutex 2mu.Lock()

1type SMap struct { 2 sync.Mutex 3 4 data map[string]string 5} 6 7func NewSMap() *SMap { 8 return &SMap{ 9 data: make(map[string]string), 10 } 11} 12 13func (m *SMap) Get(k string) string { 14 m.Lock() 15 defer m.Unlock() 16 17 return m.data[k] 18}

1type SMap struct { 2 mu sync.Mutex 3 4 data map[string]string 5} 6 7func NewSMap() *SMap { 8 return &SMap{ 9 data: make(map[string]string), 10 } 11} 12 13func (m *SMap) Get(k string) string { 14 m.mu.Lock() 15 defer m.mu.Unlock() 16 17 return m.data[k] 18}

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

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

1func (d *Driver) SetTrips(trips []Trip) { 2 d.trips = trips 3} 4 5trips := ... 6d1.SetTrips(trips) 7 8// 你是要修改 d1.trips 吗？ 9trips[0] = ...

1func (d *Driver) SetTrips(trips []Trip) { 2 d.trips = make([]Trip, len(trips)) 3 copy(d.trips, trips) 4} 5 6trips := ... 7d1.SetTrips(trips) 8 9// 这里我们修改 trips[0]，但不会影响到 d1.trips 10trips[0] = ...

1type Stats struct { 2 mu sync.Mutex 3 4 counters map[string]int 5} 6 7// Snapshot 返回当前状态。 8func (s *Stats) Snapshot() map[string]int { 9 s.mu.Lock() 10 defer s.mu.Unlock() 11 12 return s.counters 13} 14 15// snapshot 不再受互斥锁保护 16// 因此对 snapshot 的任何访问都将受到数据竞争的影响 17// 影响 stats.counters 18snapshot := stats.Snapshot()

1type Stats struct { 2 mu sync.Mutex 3 4 counters map[string]int 5} 6 7func (s *Stats) Snapshot() map[string]int { 8 s.mu.Lock() 9 defer s.mu.Unlock() 10 11 result := make(map[string]int, len(s.counters)) 12 for k, v := range s.counters { 13 result[k] = v 14 } 15 return result 16} 17 18// snapshot 现在是一个拷贝 19snapshot := stats.Snapshot()

1p.Lock() 2if p.count < 10 { 3 p.Unlock() 4 return p.count 5} 6 7p.count++ 8newCount := p.count 9p.Unlock() 10 11return newCount 12 13// 当有多个 return 分支时，很容易遗忘 unlock

1p.Lock() 2defer p.Unlock() 3 4if p.count < 10 { 5 return p.count 6} 7 8p.count++ 9return p.count 10 11// 更可读

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

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

1type Operation int 2 3const ( 4 Add Operation = iota 5 Subtract 6 Multiply 7) 8 9// Add=0, Subtract=1, Multiply=2

1type Operation int 2 3const ( 4 Add Operation = iota + 1 5 Subtract 6 Multiply 7) 8 9// Add=1, Subtract=2, Multiply=3

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

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

1func poll(delay int) { 2 for { 3 // ... 4 time.Sleep(time.Duration(delay) * time.Millisecond) 5 } 6} 7poll(10) // 是几秒钟还是几毫秒?

1func poll(delay time.Duration) { 2 for { 3 // ... 4 time.Sleep(delay) 5 } 6} 7poll(10*time.Second)

1// {"interval": 2} 2type Config struct { 3 Interval int `json:"interval"` 4}

1// {"intervalMillis": 2000} 2type Config struct { 3 IntervalMillis int `json:"intervalMillis"` 4}

1// package foo 2 3func Open() error { 4 return errors.New("could not open") 5} 6 7// package bar 8 9func use() { 10 if err := foo.Open(); err != nil { 11 if err.Error() == "could not open" { 12 // handle 13 } else { 14 panic("unknown error") 15 } 16 } 17}

1// package foo 2 3var ErrCouldNotOpen = errors.New("could not open") 4 5func Open() error { 6 return ErrCouldNotOpen 7} 8 9// package bar 10 11if err := foo.Open(); err != nil { 12 if errors.Is(err, foo.ErrCouldNotOpen) { 13 // handle 14 } else { 15 panic("unknown error") 16 } 17}

1func open(file string) error { 2 return fmt.Errorf("file %q not found", file) 3} 4 5func use() { 6 if err := open("testfile.txt"); err != nil { 7 if strings.Contains(err.Error(), "not found") { 8 // handle 9 } else { 10 panic("unknown error") 11 } 12 } 13}

1type errNotFound struct { 2 file string 3} 4 5func (e errNotFound) Error() string { 6 return fmt.Sprintf("file %q not found", e.file) 7} 8 9func open(file string) error { 10 return errNotFound{file: file} 11} 12 13func use() { 14 if err := open("testfile.txt"); err != nil { 15 if _, ok := err.(errNotFound); ok { 16 // handle 17 } else { 18 panic("unknown error") 19 } 20 } 21}

1s, err := store.New() 2if err != nil { 3 return fmt.Errorf( 4 "failed to create new store: %v", err) 5}

1s, err := store.New() 2if err != nil { 3 return fmt.Errorf( 4 "new store: %v", err) 5}

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

1x: y: new store: the error

1t := i.(string)

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

1func run(args []string) { 2 if len(args) == 0 { 3 panic("an argument is required") 4 } 5 // ... 6} 7 8func main() { 9 run(os.Args[1:]) 10}

1func run(args []string) error { 2 if len(args) == 0 { 3 return errors.New("an argument is required") 4 } 5 // ... 6 return nil 7} 8 9func main() { 10 if err := run(os.Args[1:]); err != nil { 11 fmt.Fprintln(os.Stderr, err) 12 os.Exit(1) 13 } 14}

1// func TestFoo(t *testing.T) 2 3f, err := ioutil.TempFile("", "test") 4if err != nil { 5 panic("failed to set up test") 6}

1// func TestFoo(t *testing.T) 2 3f, err := ioutil.TempFile("", "test") 4if err != nil { 5 t.Fatal("failed to set up test") 6}

1type foo struct { 2 running int32 // atomic 3} 4 5func (f* foo) start() { 6 if atomic.SwapInt32(&f.running, 1) == 1 { 7 // already running… 8 return 9 } 10 // start the Foo 11} 12 13func (f *foo) isRunning() bool { 14 return f.running == 1 // race! 15}

1type foo struct { 2 running atomic.Bool 3} 4 5func (f *foo) start() { 6 if f.running.Swap(true) { 7 // already running… 8 return 9 } 10 // start the Foo 11} 12 13func (f *foo) isRunning() bool { 14 return f.running.Load() 15}

1// sign.go 2var _timeNow = time.Now 3func sign(msg string) string { 4 now := _timeNow() 5 return signWithTime(msg, now) 6}

1// sign.go 2type signer struct { 3 now func() time.Time 4} 5func newSigner() *signer { 6 return &signer{ 7 now: time.Now, 8 } 9} 10func (s *signer) Sign(msg string) string { 11 now := s.now() 12 return signWithTime(msg, now) 13}

1// sign_test.go 2func TestSign(t *testing.T) { 3 oldTimeNow := _timeNow 4 _timeNow = func() time.Time { 5 return someFixedTime 6 } 7 defer func() { _timeNow = oldTimeNow }() 8 assert.Equal(t, want, sign(give)) 9}

1// sign_test.go 2func TestSigner(t *testing.T) { 3 s := newSigner() 4 s.now = func() time.Time { 5 return someFixedTime 6 } 7 assert.Equal(t, want, s.Sign(give)) 8}

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

1// ConcreteList 是一个实体列表。 2type ConcreteList struct { 3 list *AbstractList 4} 5// 添加将实体添加到列表中。 6func (l *ConcreteList) Add(e Entity) { 7 l.list.Add(e) 8} 9// 移除从列表中移除实体。 10func (l *ConcreteList) Remove(e Entity) { 11 l.list.Remove(e) 12}

1// AbstractList 是各种实体列表的通用实现。 2type AbstractList interface { 3 Add(Entity) 4 Remove(Entity) 5} 6// ConcreteList 是一个实体列表。 7type ConcreteList struct { 8 AbstractList 9}

1// ConcreteList 是一个实体列表。 2type ConcreteList struct { 3 list AbstractList 4} 5// 添加将实体添加到列表中。 6func (l *ConcreteList) Add(e Entity) { 7 l.list.Add(e) 8} 9// 移除从列表中移除实体。 10func (l *ConcreteList) Remove(e Entity) { 11 l.list.Remove(e) 12}

1var error string 2// `error` 作用域隐式覆盖 3 4// or 5 6func handleErrorMessage(error string) { 7 // `error` 作用域隐式覆盖 8}

1var errorMessage string 2// `error` 指向内置的非覆盖 3 4// or 5 6func handleErrorMessage(msg string) { 7 // `error` 指向内置的非覆盖 8}

1type Foo struct { 2 // 虽然这些字段在技术上不构成阴影，但`error`或`string`字符串的重映射现在是不明确的。 3 error error 4 string string 5} 6 7func (f Foo) Error() error { 8 // `error` 和 `f.error` 在视觉上是相似的 9 return f.error 10} 11 12func (f Foo) String() string { 13 // `string` and `f.string` 在视觉上是相似的 14 return f.string 15}

1type Foo struct { 2 // `error` and `string` 现在是明确的。 3 err error 4 str string 5} 6 7func (f Foo) Error() error { 8 return f.err 9} 10 11func (f Foo) String() string { 12 return f.str 13}

1type Foo struct { 2 // ... 3} 4var _defaultFoo Foo 5func init() { 6 _defaultFoo = Foo{ 7 // ... 8 } 9}

1var _defaultFoo = Foo{ 2 // ... 3} 4// or, 为了更好的可测试性: 5var _defaultFoo = defaultFoo() 6func defaultFoo() Foo { 7 return Foo{ 8 // ... 9 } 10}

1type Config struct { 2 // ... 3} 4var _config Config 5func init() { 6 // Bad: 基于当前目录 7 cwd, _ := os.Getwd() 8 // Bad: I/O 9 raw, _ := ioutil.ReadFile( 10 path.Join(cwd, "config", "config.yaml"), 11 ) 12 yaml.Unmarshal(raw, &_config) 13}

1type Config struct { 2 // ... 3} 4func loadConfig() Config { 5 cwd, err := os.Getwd() 6 // handle err 7 raw, err := ioutil.ReadFile( 8 path.Join(cwd, "config", "config.yaml"), 9 ) 10 // handle err 11 var config Config 12 yaml.Unmarshal(raw, &config) 13 return config 14}

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

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

1BenchmarkBad-4 100000000 2.48s

1BenchmarkGood-4 100000000 0.21s

1func main() { 2 body := readFile(path) 3 fmt.Println(body) 4} 5func readFile(path string) string { 6 f, err := os.Open(path) 7 if err != nil { 8 log.Fatal(err) 9 } 10 b, err := ioutil.ReadAll(f) 11 if err != nil { 12 log.Fatal(err) 13 } 14 return string(b) 15}

1func main() { 2 body, err := readFile(path) 3 if err != nil { 4 log.Fatal(err) 5 } 6 fmt.Println(body) 7} 8func readFile(path string) (string, error) { 9 f, err := os.Open(path) 10 if err != nil { 11 return "", err 12 } 13 b, err := ioutil.ReadAll(f) 14 if err != nil { 15 return "", err 16 } 17 return string(b), nil 18}

1package main 2func main() { 3 args := os.Args[1:] 4 if len(args) != 1 { 5 log.Fatal("missing file") 6 } 7 name := args[0] 8 f, err := os.Open(name) 9 if err != nil { 10 log.Fatal(err) 11 } 12 defer f.Close() 13 // 如果我们调用log.Fatal 在这条线之后 14 // f.Close 将会被执行. 15 b, err := ioutil.ReadAll(f) 16 if err != nil { 17 log.Fatal(err) 18 } 19 // ... 20}

1package main 2func main() { 3 if err := run(); err != nil { 4 log.Fatal(err) 5 } 6} 7func run() error { 8 args := os.Args[1:] 9 if len(args) != 1 { 10 return errors.New("missing file") 11 } 12 name := args[0] 13 f, err := os.Open(name) 14 if err != nil { 15 return err 16 } 17 defer f.Close() 18 b, err := ioutil.ReadAll(f) 19 if err != nil { 20 return err 21 } 22 // ... 23}

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

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

1BenchmarkFmtSprint-4 143 ns/op 2 allocs/op

1BenchmarkStrconv-4 64.2 ns/op 1 allocs/op

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

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

1BenchmarkBad-4 50000000 22.2 ns/op

1BenchmarkGood-4 500000000 3.25 ns/op

1m := make(map[string]os.FileInfo) 2 3files, _ := ioutil.ReadDir("./files") 4for _, f := range files { 5 m[f.Name()] = f 6}

1 2files, _ := ioutil.ReadDir("./files") 3 4m := make(map[string]os.FileInfo, len(files)) 5for _, f := range files { 6 m[f.Name()] = f 7}

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

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

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

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

1BenchmarkBad-4 100000000 2.48s

1BenchmarkGood-4 100000000 0.21s

1import "a" 2import "b"

1import ( 2 "a" 3 "b" 4)

1 2const a = 1 3const b = 2 4 5var a = 1 6var b = 2 7 8type Area float64 9type Volume float64

1const ( 2 a = 1 3 b = 2 4) 5 6var ( 7 a = 1 8 b = 2 9) 10 11type ( 12 Area float64 13 Volume float64 14)

1type Operation int 2 3const ( 4 Add Operation = iota + 1 5 Subtract 6 Multiply 7 EnvVar = "MY_ENV" 8)

1type Operation int 2 3const ( 4 Add Operation = iota + 1 5 Subtract 6 Multiply 7) 8 9const EnvVar = "MY_ENV"

1func f() string { 2 var red = color.New(0xff0000) 3 var green = color.New(0x00ff00) 4 var blue = color.New(0x0000ff) 5 6 ... 7}

1func f() string { 2 var ( 3 red = color.New(0xff0000) 4 green = color.New(0x00ff00) 5 blue = color.New(0x0000ff) 6 ) 7 8 ... 9}

1import ( 2 "fmt" 3 "os" 4 "go.uber.org/atomic" 5 "golang.org/x/sync/errgroup" 6)

1import ( 2 "fmt" 3 "os" 4 5 "go.uber.org/atomic" 6 "golang.org/x/sync/errgroup" 7)

1import ( 2 "fmt" 3 "os" 4 5 nettrace "golang.net/x/trace" 6)

1import ( 2 "fmt" 3 "os" 4 "runtime/trace" 5 6 nettrace "golang.net/x/trace" 7)

1func (s *something) Cost() { 2 return calcCost(s.weights) 3} 4 5type something struct{ ... } 6 7func calcCost(n []int) int {...} 8 9func (s *something) Stop() {...} 10 11func newSomething() *something { 12 return &something{} 13}

1type something struct{ ... } 2 3func newSomething() *something { 4 return &something{} 5} 6 7func (s *something) Cost() { 8 return calcCost(s.weights) 9} 10 11func (s *something) Stop() {...} 12 13func calcCost(n []int) int {...}

1for _, v := range data { 2 if v.F1 == 1 { 3 v = process(v) 4 if err := v.Call(); err == nil { 5 v.Send() 6 } else { 7 return err 8 } 9 } else { 10 log.Printf("Invalid v: %v", v) 11 } 12}

1for _, v := range data { 2 if v.F1 != 1 { 3 log.Printf("Invalid v: %v", v) 4 continue 5 } 6 7 v = process(v) 8 if err := v.Call(); err != nil { 9 return err 10 } 11 v.Send() 12}

1var a int 2if b { 3 a = 100 4} else { 5 a = 10 6}

1a := 10 2if b { 3 a = 100 4}

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

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

1// foo.go 2 3const ( 4 defaultPort = 8080 5 defaultUser = "user" 6) 7 8// bar.go 9 10func Bar() { 11 defaultPort := 9090 12 ... 13 fmt.Println("Default port", defaultPort) 14 15 // We will not see a compile error if the first line of 16 // Bar() is deleted. 17}

1// foo.go 2 3const ( 4 _defaultPort = 8080 5 _defaultUser = "user" 6)

1type Client struct { 2 version int 3 http.Client 4}

1type Client struct { 2 http.Client 3 4 version int 5}

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

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

1type Book struct { 2 // Bad: 指针更改零值的有用性 3 io.ReadWriter 4 // other fields 5} 6// later 7var b Book 8b.Read(...) // panic: nil pointer 9b.String() // panic: nil pointer 10b.Write(...) // panic: nil pointer

1type Book struct { 2 // Good: 有用的零值 3 bytes.Buffer 4 // other fields 5} 6// later 7var b Book 8b.Read(...) // ok 9b.String() // ok 10b.Write(...) // ok

1type Client struct { 2 sync.Mutex 3 sync.WaitGroup 4 bytes.Buffer 5 url.URL 6}

1type Client struct { 2 mtx sync.Mutex 3 wg sync.WaitGroup 4 buf bytes.Buffer 5 url url.URL 6}

1k := User{"John", "Doe", true}

1k := User{ 2 FirstName: "John", 3 LastName: "Doe", 4 Admin: true, 5}

1var s = "foo"

1s := "foo"

1func f(list []int) { 2 filtered := []int{} 3 for _, v := range list { 4 if v > 10 { 5 filtered = append(filtered, v) 6 } 7 } 8}

1func f(list []int) { 2 var filtered []int 3 for _, v := range list { 4 if v > 10 { 5 filtered = append(filtered, v) 6 } 7 } 8}

1if x == "" { 2 return []int{} 3}

1if x == "" { 2 return nil 3}

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

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

1nums := []int{} 2// or, nums := make([]int) 3 4if add1 { 5 nums = append(nums, 1) 6} 7 8if add2 { 9 nums = append(nums, 2) 10}

1var nums []int 2 3if add1 { 4 nums = append(nums, 1) 5} 6 7if add2 { 8 nums = append(nums, 2) 9}

1err := ioutil.WriteFile(name, data, 0644) 2if err != nil { 3 return err 4}

1if err := ioutil.WriteFile(name, data, 0644); err != nil { 2 return err 3}

1if data, err := ioutil.ReadFile(name); err == nil { 2 err = cfg.Decode(data) 3 if err != nil { 4 return err 5 } 6 7 fmt.Println(cfg) 8 return nil 9} else { 10 return err 11}

1data, err := ioutil.ReadFile(name) 2if err != nil { 3 return err 4} 5 6if err := cfg.Decode(data); err != nil { 7 return err 8} 9 10fmt.Println(cfg) 11return nil

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

1// func printInfo(name string, isLocal, done bool) 2 3printInfo("foo", true /* isLocal */, true /* done */)

1wantError := "unknown name:\"test\""

1wantError := `unknown error:"test"`

1k := User{"John", "Doe", true}

1k := User{ 2 FirstName: "John", 3 LastName: "Doe", 4 Admin: true, 5}

1user := User{ 2 FirstName: "John", 3 LastName: "Doe", 4 MiddleName: "", 5 Admin: false, 6}

1user := User{ 2 FirstName: "John", 3 LastName: "Doe", 4}

1user := User{}

1var user User

1sval := T{Name: "foo"} 2 3// inconsistent 4sptr := new(T) 5sptr.Name = "bar"

1sval := T{Name: "foo"} 2 3sptr := &T{Name: "bar"}

1var ( 2 // m1 读写安全; 3 // m2 在写入时会 panic 4 m1 = map[T1]T2{} 5 m2 map[T1]T2 6)

1var ( 2 // m1 读写安全; 3 // m2 在写入时会 panic 4 m1 = make(map[T1]T2) 5 m2 map[T1]T2 6)

声明和初始化看起来非常相似的。

声明和初始化看起来差别非常大。

1m := make(map[T1]T2, 3) 2m[k1] = v1 3m[k2] = v2 4m[k3] = v3

1m := map[T1]T2{ 2 k1: v1, 3 k2: v2, 4 k3: v3, 5}

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

1const msg = "unexpected values %v, %v\n" 2fmt.Printf(msg, 1, 2)

1// func TestSplitHostPort(t *testing.T) 2 3host, port, err := net.SplitHostPort("192.0.2.0:8000") 4require.NoError(t, err) 5assert.Equal(t, "192.0.2.0", host) 6assert.Equal(t, "8000", port) 7 8host, port, err = net.SplitHostPort("192.0.2.0:http") 9require.NoError(t, err) 10assert.Equal(t, "192.0.2.0", host) 11assert.Equal(t, "http", port) 12 13host, port, err = net.SplitHostPort(":8000") 14require.NoError(t, err) 15assert.Equal(t, "", host) 16assert.Equal(t, "8000", port) 17 18host, port, err = net.SplitHostPort("1:8") 19require.NoError(t, err) 20assert.Equal(t, "1", host) 21assert.Equal(t, "8", port)

1// func TestSplitHostPort(t *testing.T) 2 3tests := []struct{ 4 give string 5 wantHost string 6 wantPort string 7}{ 8 { 9 give: "192.0.2.0:8000", 10 wantHost: "192.0.2.0", 11 wantPort: "8000", 12 }, 13 { 14 give: "192.0.2.0:http", 15 wantHost: "192.0.2.0", 16 wantPort: "http", 17 }, 18 { 19 give: ":8000", 20 wantHost: "", 21 wantPort: "8000", 22 }, 23 { 24 give: "1:8", 25 wantHost: "1", 26 wantPort: "8", 27 }, 28} 29 30for _, tt := range tests { 31 t.Run(tt.give, func(t *testing.T) { 32 host, port, err := net.SplitHostPort(tt.give) 33 require.NoError(t, err) 34 assert.Equal(t, tt.wantHost, host) 35 assert.Equal(t, tt.wantPort, port) 36 }) 37}

1// package db 2 3func Open( 4 addr string, 5 cache bool, 6 logger *zap.Logger 7) (*Connection, error) { 8 // ... 9}

1// package db 2 3type Option interface { 4 // ... 5} 6 7func WithCache(c bool) Option { 8 // ... 9} 10 11func WithLogger(log *zap.Logger) Option { 12 // ... 13} 14 15// Open creates a connection. 16func Open( 17 addr string, 18 opts ...Option, 19) (*Connection, error) { 20 // ... 21}

必须始终提供缓存和记录器参数，即使用户希望使用默认值。 1db.Open(addr, db.DefaultCache, zap.NewNop()) 2db.Open(addr, db.DefaultCache, log) 3db.Open(addr, false /* cache */, zap.NewNop()) 4db.Open(addr, false /* cache */, log)

只有在需要时才提供选项。 1db.Open(addr) 2db.Open(addr, db.WithLogger(log)) 3db.Open(addr, db.WithCache(false)) 4db.Open( 5 addr, 6 db.WithCache(false), 7 db.WithLogger(log), 8)