go 经典译文：uber 开源的《go 语言编码规范》 | go 技术论坛-金年会app官方网

介绍

英文原文标题是 ，这里的 style 是指在编码时遵从的一些约定。

这篇编程指南的初衷是更好的管理我们的代码，包括去编写什么样的代码，以及不要编写什么样的代码。我们希望通过这份编程指南，代码可以具有更好的维护性，同时能够让我们的开发同学更高效地编写 go 语言代码。

这份编程指南最初由  和  编写，旨在让其他同事快速地熟悉和编写 go 程序。经过多年发展，现在的版本经过了多番修改和改进了。这是我们在 uber 遵从的编程范式，但是很多都是可以通用的，如下是其他可以参考的链接：

所有的提交代码都应该通过 golint 和 go vet 检测，建议在代码编辑器上面做如下设置：

• 保存的时候运行 goimports
• 使用 golint 和 go vet 去做错误检测。

你可以通过下面链接发现更多的 go 编辑器的插件: 

编程指南

指向 interface 的指针

在我们日常使用中，基本上不会需要使用指向 interface 的指针。当我们将 interface 作为值传递的时候，底层数据就是指针。interface 包括两方面：

• 一个包含 type 信息的指针
• 一个指向数据的指针

如果你想要修改底层的数据，那么你只能使用 pointer。

接收器 (receiver) 与接口

使用值接收器的方法既可以通过值调用，也可以通过指针调用。

type s struct {
  data string
}
func (s s) read() string {
  return s.data
}
func (s *s) write(str string) {
  s.data = str
}
svals := map[int]s{1: {"a"}}
// 你只能通过值调用 read
svals[1].read()
// 这不能编译通过：
//  svals[1].write("test")
sptrs := map[int]*s{1: {"a"}}
// 通过指针既可以调用 read，也可以调用 write 方法
sptrs[1].read()
sptrs[1].write("test")

同样，即使该方法具有值接收器，也可以通过指针来满足接口。

type f interface {
  f()
}
type s1 struct{}
func (s s1) f() {}
type s2 struct{}
func (s *s2) f() {}
s1val := s1{}
s1ptr := &s1{}
s2val := s2{}
s2ptr := &s2{}
var i f
i = s1val
i = s1ptr
i = s2ptr
//  下面代码无法通过编译。因为 s2val 是一个值，而 s2 的 f 方法中没有使用值接收器
//   i = s2val

effective go 中有一段关于  的精彩讲解。

零值 mutex 是有效的

零值 sync.mutex 和 sync.rwmutex 是有效的。所以指向 mutex 的指针基本是不必要的。

bad

mu := new(sync.mutex)
mu.lock()

good

var mu sync.mutex
mu.lock()

如果你使用结构体（struct）指针，mutex 可以非指针形式作为结构体的组成字段，或者更好的方式是直接嵌入到结构体中。 如果是私有结构体类型或是要实现 mutex 接口的类型，我们可以使用嵌入 mutex 的方法：

为私有类型或需要实现互斥接口的类型嵌入：

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]
}

在边界处拷贝 slices 和 maps

slices 和 maps 包含了指向底层数据的指针，因此在需要复制它们时要特别注意。

接收 slices 和 maps

请记住，当 map 或 slice 作为函数参数传入时，如果您存储了对它们的引用，则用户可以对其进行修改。

bad

func (d *driver) settrips(trips []trip) {
  d.trips = trips
}
trips := ...
d1.settrips(trips)
// did you mean to modify d1.trips?
trips[0] = ...

good

func (d *driver) settrips(trips []trip) {
  d.trips = make([]trip, len(trips))
  copy(d.trips, trips)
}
trips := ...
d1.settrips(trips)
// we can now modify trips[0] without affecting d1.trips.
trips[0] = ...

slice 和 map 作为返回值

同样，请注意用户对暴露内部状态的 map 或 slice 的修改。

bad

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 is no longer protected by the lock!
snapshot := stats.snapshot()

good

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()

使用 defer 做资源清理

使用 defer 释放资源，诸如文件和锁。

bad

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

good

p.lock()
defer p.unlock()
if p.count < 10 {
  return p.count
}
p.count  
return p.count
// 可读性越佳

尽管使用 defer 会导致一定的性能开销，但是大部分情况下这个开销在你的整个链路上所占的比重往往是微乎其微，除非说真的是有非常高的性能需求。另外使用 defer 从可读性改进以及代码错误减少上来看，都是值得的。

channel 的 size 最好是 1 或者是 unbuffered

在使用 channel 的时候，最好将 size 设置为 1 或者使用 unbuffered channel。其他 size 的 channel 往往都会引入更多的复杂度，需要更多考虑上下游的设计。

bad

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

good

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

枚举变量应该从 1 开始

在 go 语言中枚举值的声明典型方式是通过 const 和 iota 来声明。由于 0 是默认值，所以枚举值最好从一个非 0 值开始，比如 1。

bad

type operation int
const (
  add operation = iota
  subtract
  multiply
)
// add=0, subtract=1, multiply=2

good

type operation int
const (
  add operation = iota   1
  subtract
  multiply
)
// add=1, subtract=2, multiply=3

有一种例外情况：0 值是预期的默认行为的时候，枚举值可以从 0 开始。

type logoutput int
const (
  logtostdout logoutput = iota
  logtofile
  logtoremote
)
// logtostdout=0, logtofile=1, logtoremote=2

错误类型

go 中有多种声明错误（error) 的选项：

•  对于简单静态字符串的错误
•  用于格式化的错误字符串
• 实现 error() 方法的自定义类型
• 用  的 wrapped errors

返回错误时，请考虑以下因素以确定最佳选择：

• 这是一个不需要额外信息的简单错误吗？如果是这样， 足够了。
• 客户需要检测并处理此错误吗？如果是这样，则应使用自定义类型并实现该 error() 方法。
• 您是否正在传播下游函数返回的错误？如果是这样，请查看本文后面有关错误包装  部分的内容。
• 否则  就可以了。

如果客户端需要检测错误，并且您已使用创建了一个简单的错误 ，请使用一个错误变量。

bad

// 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")
    }
  }
}

good

// 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")
  }
}

如果您有可能需要客户端检测的错误，并且想向其中添加更多信息（例如，它不是静态字符串），则应使用自定义类型。

bad

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")
    }
  }
}

good

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")
    }
  }
}

直接导出自定义错误类型时要小心，因为它们已成为程序包公共 api 的一部分。最好公开匹配器功能以检查错误。

// package foo
type errnotfound struct {
  file string
}
func (e errnotfound) error() string {
  return fmt.sprintf("file %q not found", e.file)
}
func isnotfounderror(err error) bool {
  _, ok := err.(errnotfound)
  return ok
}
func open(file string) error {
  return errnotfound{file: file}
}
// package bar
if err := foo.open("foo"); err != nil {
  if foo.isnotfounderror(err) {
    // handle
  } else {
    panic("unknown error")
  }
}

错误包装 (error wrapping)

一个（函数/方法）调用失败时，有三种主要的错误传播方式：

• 如果没有要添加的其他上下文，并且您想要维护原始错误类型，则返回原始错误。

• 添加上下文，使用  以便错误消息提供更多上下文 , 可用于提取原始错误。 use fmt.errorf if the callers do not need to detect or handle that specific error case.

• 如果调用者不需要检测或处理的特定错误情况，使用 。

建议在可能的地方添加上下文，以使您获得诸如“调用服务 foo：连接被拒绝”之类的更有用的错误，而不是诸如“连接被拒绝”之类的模糊错误。

在将上下文添加到返回的错误时，请避免使用“failed to”之类的短语来保持上下文简洁，这些短语会陈述明显的内容，并随着错误在堆栈中的渗透而逐渐堆积：

bad

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

good

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

但是，一旦将错误发送到另一个系统，就应该明确消息是错误消息（例如使用err标记，或在日志中以”failed”为前缀）。

另请参见 . 不要只是检查错误，要优雅地处理错误。

类型转换失败处理

类型转换失败会导致进程 panic，所以对于类型转换，一定要使用 !ok 的范式来处理。

bad

t := i.(string)

good

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

不要 panic

在生产环境中运行的代码必须避免出现 panic。panic 是  级联失败的主要根源 。如果发生错误，该函数必须返回错误，并允许调用方决定如何处理它。

bad

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 ")
    os.exit(1)
  }
  foo(os.args[1])
}

good

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 ")
    os.exit(1)
  }
  if err := foo(os.args[1]); err != nil {
    panic(err)
  }
}

panic/recover 并不是一种 error 处理策略。仅当发生不可恢复的事情（例如：nil 引用）时，程序才必须 panic。程序初始化是一个例外：程序启动时应使程序中止的不良情况可能会引起 panic。

var _statustemplate = template.must(template.new("name").parse("_statushtml"))

即使在测试代码中，也优先使用t.fatal或者t.failnow而不是 panic 来确保失败被标记。

bad

// func testfoo(t *testing.t)
f, err := ioutil.tempfile("", "test")
if err != nil {
  panic("failed to set up test")
}

good

// func testfoo(t *testing.t)
f, err := ioutil.tempfile("", "test")
if err != nil {
  t.fatal("failed to set up test")
}

使用 

使用  包的原子操作对原始类型 (int32, int64等）进行操作，因为很容易忘记使用原子操作来读取或修改变量。

 通过隐藏基础类型为这些操作增加了类型安全性。此外，它包括一个方便的atomic.bool类型。

这个是 uber 内部对原生包 sync/atomic 的一种封装，隐藏了底层数据类型。

bad

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!
}

good

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()
}

避免可变全局变量

使用选择依赖注入方式避免改变全局变量。 既适用于函数指针又适用于其他值类型。

bad

// sign.go
var _timenow = time.now
func sign(msg string) string {
  now := _timenow()
  return signwithtime(msg, now)
}

good

// 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)
}

性能相关

性能方面的特定准则只适用于高频场景。

类型转换时，使用 strconv 替换 fmt

当基本类型和 string 互转的时候，strconv 要比 fmt 快。

bad

for i := 0; i < b.n; i   {
  s := fmt.sprint(rand.int())
}
// benchmarkfmtsprint-4    143 ns/op    2 allocs/op

good

for i := 0; i < b.n; i   {
  s := strconv.itoa(rand.int())
}
// benchmarkstrconv-4    64.2 ns/op    1 allocs/op

避免字符串到字节的转换

不要反复从固定字符串创建字节 slice。相反，请执行一次转换并捕获结果。

bad

for i := 0; i < b.n; i   {
  w.write([]byte("hello world"))
}
// benchmarkbad-4   50000000   22.2 ns/op

good

data := []byte("hello world")
for i := 0; i < b.n; i   {
  w.write(data)
}
// benchmarkgood-4  500000000   3.25 ns/op

尽量初始化时指定 map 容量

在尽可能的情况下，在使用 make() 初始化的时候提供容量信息

make(map[t1]t2, hint)

为 make() 提供容量信息（hint）尝试在初始化时调整 map 大小， 这减少了在将元素添加到 map 时增长和分配的开销。 注意，map 不能保证分配 hint 个容量。因此，即使提供了容量，添加元素仍然可以进行分配。

bad

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

m := make(map[string]os.fileinfo)
files, _ := ioutil.readdir("./files")
for _, f := range files {
    m[f.name()] = f
}

good

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

files, _ := ioutil.readdir("./files")
m := make(map[string]os.fileinfo, len(files))
for _, f := range files {
    m[f.name()] = f
}

编程风格

一致性

本文中概述的一些标准都是客观性的评估，是根据场景、上下文、或者主观性的判断；

但是最重要的是，保持一致.

一致性的代码更容易维护、是更合理的、需要更少的学习成本、并且随着新的约定出现或者出现错误后更容易迁移、更新、修复 bug

相反，一个单一的代码库会导致维护成本开销、不确定性和认知偏差。所有这些都会直接导致速度降低、 代码审查痛苦、而且增加 bug 数量

将这些标准应用于代码库时，建议在 package（或更大）级别进行更改，子包级别的应用程序通过将多个样式引入到同一代码中，违反了上述关注点。

相似的声明放在一组

go 语言支持将相似的声明放在一个组内。

bad

import "a"
import "b"

good

import (
  "a"
  "b"
)

这同样适用于常量、变量和类型声明：

bad

const a = 1
const b = 2
var a = 1
var b = 2
type area float64
type volume float64

good

const (
  a = 1
  b = 2
)
var (
  a = 1
  b = 2
)
type (
  area float64
  volume float64
)

仅将相关的声明放在一组。不要将不相关的声明放在一组。

bad

type operation int
const (
  add operation = iota   1
  subtract
  multiply
  env_var = "my_env"
)

good

type operation int
const (
  add operation = iota   1
  subtract
  multiply
)
const env_var = "my_env"

分组使用的位置没有限制，例如：你可以在函数内部使用它们：

bad

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

good

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

import 分组

导入应该分为两组：

• 标准库
• 其他库

默认情况下，这是 goimports 应用的分组。

bad

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

good

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

包名

当命名包时，请按下面规则选择一个名称：

• 全部小写。没有大写或下划线。
• 大多数使用命名导入的情况下，不需要重命名。
• 简短而简洁。请记住，在每个使用的地方都完整标识了该名称。
• 不用复数。例如net/url，而不是net/urls。
• 不要用“common”，“util”，“shared”或“lib”。这些是不好的，信息量不足的名称。

另请参阅  和 .

函数名

我们遵循 go 社区关于使用  的约定。有一个例外，为了对相关的测试用例进行分组，函数名可能包含下划线，如：testmyfunction_whatisbeingtested。

导入别名

如果程序包名称与导入路径的最后一个元素不匹配，则必须使用导入别名。

import (
  "net/http"
  client "example.com/client-go"
  trace "example.com/trace/v2"
)

在所有其他情况下，除非导入之间有直接冲突，否则应避免导入别名。

bad

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

good

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

函数分组与顺序

• 函数应按粗略的调用顺序排序。
• 同一文件中的函数应按接收者分组。

因此，导出的函数应先出现在文件中，放在struct, const, var定义的后面。

在定义类型之后，但在接收者的其余方法之前，可能会出现一个 newxyz()/newxyz()

由于函数是按接收者分组的，因此普通工具函数应在文件末尾出现。

bad

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{}
}

good

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 {...}

减少嵌套

代码应通过尽可能先处理错误情况/特殊情况并尽早返回或继续循环来减少嵌套。减少嵌套多个级别的代码的代码量。

bad

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)
  }
}

good

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()
}

不必要的 else

如果在 if 的两个分支中都设置了变量，则可以将其替换为单个 if。

bad

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

good

a := 10
if b {
  a = 100
}

顶层变量声明

在顶层，使用标准var关键字。请勿指定类型，除非它与表达式的类型不同。

bad

var _s string = f()
func f() string { return "a" }

good

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

如果表达式的类型与所需的类型不完全匹配，请指定类型。

type myerror struct{}
func (myerror) error() string { return "error" }
func f() myerror { return myerror{} }
var _e error = f()
// f 返回一个 myerror 类型的实例，但是我们要 error 类型

对于未导出的顶层常量和变量，使用_作为前缀

在未导出的顶级vars和consts， 前面加上前缀_，以使它们在使用时明确表示它们是全局符号。

例外：未导出的错误值，应以err开头。

基本依据：顶级变量和常量具有包范围作用域。使用通用名称可能很容易在其他文件中意外使用错误的值。

bad

// 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.
}

good

// foo.go
const (
  _defaultport = 8080
  _defaultuser = "user"
)

结构体中的嵌入

嵌入式类型（例如 mutex）应位于结构体内的字段列表的顶部，并且必须有一个空行将嵌入式字段与常规字段分隔开。

bad

type client struct {
  version int
  http.client
}

good

type client struct {
  http.client
  version int
}

使用字段名初始化结构体

初始化结构体时，几乎始终应该指定字段名称。现在由  强制执行。

bad

k := user{"john", "doe", true}

good

k := user{
    firstname: "john",
    lastname: "doe",
    admin: true,
}

例外：如果有 3 个或更少的字段，则可以在测试表中省略字段名称。

tests := []struct{
  op operation
  want string
}{
  {add, "add"},
  {subtract, "subtract"},
}

本地变量声明

如果将变量明确设置为某个值，则应使用短变量声明形式 (:=)。

bad

var s = "foo"

good

s := "foo"

但是，在某些情况下，var 使用关键字时默认值会更清晰。例如，声明空切片。

bad

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

good

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

nil 是一个有效的 slice

nil 是一个有效的长度为 0 的 slice，这意味着，

• 您不应明确返回长度为零的切片。应该返回nil 来代替。

bad

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

good

if x == "" {
  return nil
}

• 要检查切片是否为空，请始终使用len(s) == 0。而非 nil。

bad

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

good

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

• 零值切片（用var声明的切片）可立即使用，无需调用make()创建。

bad

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

good

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

小变量作用域

如果有可能，尽量缩小变量作用范围。除非它与减少嵌套的规则冲突。

bad

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

good

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

如果需要在 if 之外使用函数调用的结果，则不应尝试缩小范围。

bad

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
}

good

data, err := ioutil.readfile(name)
if err != nil {
   return err
}
if err := cfg.decode(data); err != nil {
  return err
}
fmt.println(cfg)
return nil

避免参数语义不明确(avoid naked parameters)

函数调用中的意义不明确的参数可能会损害可读性。当参数名称的含义不明显时，请为参数添加 c 样式注释 (/* ... */)

bad

// func printinfo(name string, islocal, done bool)
printinfo("foo", true, true)

good

// func printinfo(name string, islocal, done bool)
printinfo("foo", true /* islocal */, true /* done */)

对于上面的示例代码，还有一种更好的处理方式是将上面的 bool 类型换成自定义类型。将来，该参数可以支持不仅仅局限于两个状态（true/false）。

type region int
const (
  unknownregion region = iota
  local
)
type status int
const (
  statusready = iota   1
  statusdone
  // maybe we will have a statusinprogress in the future.
)
func printinfo(name string, region region, status status)

使用原始字符串字面值，避免转义

go 支持使用 ，也就是 ` 来表示原生字符串，在需要转义的场景下，我们应该尽量使用这种方案来替换。

可以跨越多行并包含引号。使用这些字符串可以避免更难阅读的手工转义的字符串。

bad

wanterror := "unknown name:.test."

good

wanterror := `unknown error:"test"`

初始化 struct 引用

在初始化结构引用时，请使用&t{}代替new(t)，以使其与结构体初始化一致。

bad

sval := t{name: "foo"}
// inconsistent
sptr := new(t)
sptr.name = "bar"

good

sval := t{name: "foo"}
sptr := &t{name: "bar"}

初始化 maps

对于空 map 请使用 make(..) 初始化， 并且 map 是通过编程方式填充的。 这使得 map 初始化在表现上不同于声明，并且它还可以方便地在 make 后添加大小提示。

bad

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

var (
  // m1 读写安全;
  // m2 在写入时会 panic
  m1 = map[t1]t2{}
  m2 map[t1]t2
)

good

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

var (
  // m1 读写安全;
  // m2 在写入时会 panic
  m1 = make(map[t1]t2)
  m2 map[t1]t2
)

字符串 string format

如果你为printf-style 函数声明格式字符串，请将格式化字符串放在外面，并将其设置为const常量。

这有助于go vet对格式字符串执行静态分析。

bad

msg := "unexpected values %v, %v."
fmt.printf(msg, 1, 2)

good

const msg = "unexpected values %v, %v."
fmt.printf(msg, 1, 2)

命名 printf 样式的函数

声明printf-style 函数时，请确保go vet可以检测到它并检查格式字符串。

这意味着您应尽可能使用预定义的printf-style 函数名称。go vet将默认检查这些。有关更多信息，请参见 。

如果不能使用预定义的名称，请以 f 结束选择的名称：wrapf，而不是wrap。go vet可以要求检查特定的 printf 样式名称，但名称必须以f结尾。

$ go vet -printfuncs=wrapf,statusf

更多参考: .

编程模式（patterns）

表驱动测试

当测试逻辑是重复的时候，通过  使用 table 驱动的方式编写 case 代码看上去会更简洁。

bad

// 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)

good

// 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)
  })
}

很明显，使用 test table 的方式在代码逻辑扩展的时候，比如新增 test case，都会显得更加的清晰。

我们遵循这样的约定：将结构体切片称为tests。 每个测试用例称为tt。此外，我们鼓励使用give和want前缀说明每个测试用例的输入和输出值。

tests := []struct{
  give     string
  wanthost string
  wantport string
}{
  // ...
}
for _, tt := range tests {
  // ...
}

功能选项

功能选项是一种模式，您可以在其中声明一个不透明 option 类型，该类型在某些内部结构中记录信息。您接受这些选项的可变编号，并根据内部结构上的选项记录的全部信息采取行动。

将此模式用于您需要扩展的构造函数和其他公共 api 中的可选参数，尤其是在这些功能上已经具有三个或更多参数的情况下。

bad

// package db
func connect(
  addr string,
  timeout time.duration,
  caching bool,
) (*connection, error) {
  // ...
}

必须始终提供缓存和记录器参数，即使用户希望使用默认值。

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 */)

good

// package db
type option interface {
  // ...
}
func withcache(c bool) option {
  // ...
}
func withlogger(log *zap.logger) option {
  // ...
}
// open creates a connection.
func open(
  addr string,
  opts ...option,
) (*connection, error) {
  // ...
}

只有在需要时才提供选项。

db.open(addr)
db.open(addr, db.withlogger(log))
db.open(addr, db.withcache(false))
db.open(
  addr,
  db.withcache(false),
  db.withlogger(log),
)

我们建议实现此模式的方法是使用一个 option 接口，该接口保存一个未导出的方法，在一个未导出的 options 结构上记录选项。

type options struct {
  cache  bool
  logger *zap.logger
}
type option interface {
  apply(*options)
}
type cacheoption bool
func (c cacheoption) apply(opts *options) {
  opts.cache = bool(c)
}
func withcache(c bool) option {
  return cacheoption(c)
}
type loggeroption struct {
  log *zap.logger
}
func (l loggeroption) apply(opts *options) {
  opts.logger = l.log
}
func withlogger(log *zap.logger) option {
  return loggeroption{log: log}
}
// open creates a connection.
func open(
  addr string,
  opts ...option,
) (*connection, error) {
  options := options{
    cache:  defaultcache,
    logger: zap.newnop(),
  }
  for _, o := range opts {
    o.apply(&options)
  }
  // ...
}

注意: 还有一种使用闭包实现这个模式的方法，但是我们相信上面的模式为作者提供了更多的灵活性，并且更容易对用户进行调试和测试。特别是，在不可能进行比较的情况下它允许在测试和模拟中对选项进行比较。此外，它还允许选项实现其他接口，包括 fmt.stringer，允许用户读取选项的字符串表示形式。

还可以参考下面资料：

译者注

uber 开源的这个文档给我印象最深的就是：保持代码简洁，并具有良好可读性。不得不说，相比于国内很多『代码能跑就完事了』这种写代码的态度，这篇文章或许可以给我们更多的启示和参考。

译文参考：