1. 介绍
2. 格式化
3. 注释
4. 命名
5. 分号
6. 控制结构
7. 函数
8. 数据
9. 初始化
10. 方法
11. 接口和其它类型
12. 空白标识符
13. 内嵌
14. 并发
15. 错误处理
1. 介绍[1]
本文档提供了编写清晰、惯用的GO代码的技巧。
2. 格式化[2]
gofmt自动生成统一风格代码格式，程序员无需关心代码格式问题。
3. 注释[3]
Go提供C风格的块注释/* */和C++风格的行注释//。一般使用行注释，包注释使用块注释。
4. 命名[4]
首字母大写的命名包外可见。
包名
包名应该简洁明了，便于记忆。建议是一个小写单词，不包含下划线和混合大小写。
import "src/encoding/base64"后，导入包用base64代替。这使得包中导出名字避免冗余，bufio.Reader和bufio.BufReader相比，更简洁明了。
Getters
小写命名做为包内成员变量，大写命名做为公开成员读方法，公开成员写方法。例如，owner为包内成员变量，Owner()为公开方法返回owner，SetOwner()为公开方法修改owner变量。
接口命名
单方法接口采用方法名加er后缀方式命名，例如Reader，Wrtier。除非用途和签名完全一致，不要采用Read，Write，String等系统保留方法名。转换字符串的方法名为String而非ToString。
多词命名
采用MixedCaps或mixedCaps风格，而非下划线。
5. 分号[5]
大多数情况下不需要输入分号，go语法分析器会自动插入。for语句或多条语句在一行时，需要输入分号分割语句。自动插入的一个副作用是左花括号不能在一行开头。
6. 控制结构[6]
If
if可以接受一个初始语句
if err := file.Chmod(0664); err != nil {
log.Print(err)
return err
}
重声明和重赋值
f, err := os.Open(name)这条语句声明并赋值两个变量f和err。符合下面条件时:=可对已存在变量v重赋值。
- 同一作用域中
v已存在。(否则在不同作用域中声明新变量v） - 右边值可以正确赋给
v - 至少产生一个新声明变量
例如，d, err := f.Stat()
go语言中，函数参数和返回值同函数体具有相同的作用域。
For
// Like a C for
for init; condition; post { }
// Like a C while
for condition { }
// Like a C for(;;)
for { }
针对集合对象，使用range
for key, value := range oldMap {
newMap[key] = value
}
for key := range m {
if key.expired() {
delete(m, key)
}
}
sum := 0
for _, value := range array {
sum += value
}
go不支持++，--运算，但支持多赋值
// Reverse a
for i, j := 0, len(a)-1; i < j; i, j = i+1, j-1 {
a[i], a[j] = a[j], a[i]
}
Switch
go的switch表达式可以不为常量甚至不为数字，依次比较每个case直到匹配。表达式为空意味匹配true。
func unhex(c byte) byte {
switch {
case '0' <= c && c <= '9':
return c - '0'
case 'a' <= c && c <= 'f':
return c - 'a' + 10
case 'A' <= c && c <= 'F':
return c - 'A' + 10
}
return 0
}
匹配成功后就会返回，case子句支持逗号分隔。
func shouldEscape(c byte) bool {
switch c {
case ' ', '?', '&', '=', '#', '+', '%':
return true
}
return false
}
break在swtich中并不常见，但也可以和label配合，直接跳到外层。
Loop:
for n := 0; n < len(src); n += size {
switch {
case src[n] < sizeOne:
if validateOnly {
break
}
size = 1
update(src[n])
case src[n] < sizeTwo:
if n+1 >= len(src) {
err = errShortInput
break Loop
}
if validateOnly {
break
}
size = 2
update(src[n] + src[n+1]<<shift)
}
}
Type Swtich
switch也可以用来判断一个变量的类型，switch表达式中声明一个变量，它在每个case子句中具有相应的类型。
var t interface{}
t = functionOfSomeType()
switch t := t.(type) {
default:
fmt.Printf("unexpected type %T\n", t) // %T prints whatever type t has
case bool:
fmt.Printf("boolean %t\n", t) // t has type bool
case int:
fmt.Printf("integer %d\n", t) // t has type int
case *bool:
fmt.Printf("pointer to boolean %t\n", *t) // t has type *bool
case *int:
fmt.Printf("pointer to integer %d\n", *t) // t has type *int
}
7. 函数[7]
多返回值
go函数和方法支持多返回值。
命名结果参数
返回值可以命名，并像输入参数一样使用。它们的初始值为0。
Defer
defer调用一个函数，使其在被调用函数返回前运行。defer的典型用法是释放资源。defer函数的参数是在defer调用时赋值并被保持住。defer调用的执行顺序是后进先出。
for i := 0; i < 5; i++ {
defer fmt.Printf("%d ", i)
}
上面代码的运行结果是4 3 2 1 0
8. 数据[8]
new分配
new(T)返回类型T的新分配的0值对象指针*T。
构造器和对象构造方法（复合文字）
构造器就是对象工厂方法分配对象并进行初始化工作。
func NewFile(fd int, name string) *File {
if fd < 0 {
return nil
}
return File{fd, name, nil, 0}
}
go可以返回临时对象指针（go采用垃圾回收机制）。默认对象构造方法必须依次列举所有的成员。采用field：name对方式，可以只列举需要初始化的成员，return &File{fd: fd, name: name}。new(File)和&File{}相同
make分配
make只能用来创建slice，map和channel，并返回初始化号的对象（不是对象指针）。例如
make([]int, 10, 100)生成一个slice对象，长度是10，容量是100，并指向一个长度为100的int数组。相反，new([]int)返回的0值slice指针并不能使用。
数组
go数组定义需要制定大小，并且大小是类型的一部分。[10]int和[20]int是2个不同的类型。go数组是值类型。赋值或传入函数参数时会发生值拷贝。如果需要指针类型数组，一般使用切片。
切片
切片是基于数组的方便使用对象，它具有底层数组引用和当前数组长度以及数组最大长度。切片本身是值对象，但是赋值后，两个切片会指向同一段底层数组，故此能够传递修改。数组支持范围访问n, err := f.Read(buf[0:32])。切片增加元素建议使用内置方法append，它支持自动扩容。
二维数组和切片
type Transform [3][3]float64
type LinesOfText [][]byte
二维切片中的每个切片长度可以不同。分配二维切片有两种方式，如果切片们的长度不同，应该为每个切片单独分配。如果它们的长度一样，可以只分配一次。
- 单独分配例子，注意每个slice都有独立的make分配
// Allocate the top-level slice.
picture := make([][]uint8, YSize) // One row per unit of y.
// Loop over the rows, allocating the slice for each row.
for i := range picture {
picture[i] = make([]uint8, XSize)
}
- 分配一次例子，注意底层切片只分配一次，然后把对应段赋给每个切片。
// Allocate the top-level slice, the same as before.
picture := make([][]uint8, YSize) // One row per unit of y.
// Allocate one large slice to hold all the pixels.
pixels := make([]uint8, XSize*YSize) // Has type []uint8 even though picture is [][]uint8.
// Loop over the rows, slicing each row from the front of the remaining pixels slice.
for i := range picture {
picture[i], pixels = pixels[:XSize], pixels[XSize:]
}
映射
键值对映射是一种很有用的类型。键可以是任何定义了equality操作的类型，注意切片不支持equality。映射也是持有底层数据结构引用，能够传递修改。映射支持复合文字构造，
var timeZone = map[string]int{
"UTC": 0*60*60,
"EST": -5*60*60,
"CST": -6*60*60,
"MST": -7*60*60,
"PST": -8*60*60,
}
获取不存在的键值，会返回值类型的0值。如果要明确知道是否存在，使用多返回
var seconds int
var ok bool
seconds, ok = timeZone[tz]
如果只想判断键值是否存在，采用空标记符_。_, present := timeZone[tz]
删除键值采用内置函数delete，它确保键不存在也能工作。
格式化打印
fmt包提供一系列格式化打印的方法，例如fmt.Printf, fmt.Fprintf, fmt.Sprintf，以及默认格式版本，fmt.Print, fmt.Fprint, fmt.Sprint，默认格式会在每个参数前后插入一个空格。
- %d 显示数字
- %v 显示所有类型的值
- %+v 对于结构体显示字段名
- %#v 显示对象全部信息
- %q 显示字符串或字节数组,也可用于数字或rune，显示单引号标记的rune字符
- %#q 尽可能使用反引号
- %x 用于字符串、字节数组或数字，显示十六进制值
- % x 在显示字节前后增加空格
- %T 显示类型
var x uint64 = 1<<64 - 1
fmt.Printf("%d %x; %d %x\n", x, x, int64(x), int64(x))
结果
18446744073709551615 ffffffffffffffff; -1 -1
fmt.Printf("%v\n", timeZone) // or just fmt.Println(timeZone)
结果
map[CST:-21600 PST:-28800 EST:-18000 UTC:0 MST:-25200]
type T struct {
a int
b float64
c string
}
t := &T{ 7, -2.35, "abc\tdef" }
fmt.Printf("%v\n", t)
fmt.Printf("%+v\n", t)
fmt.Printf("%#v\n", t)
fmt.Printf("%#v\n", timeZone)
结果
&{7 -2.35 abc def}
&{a:7 b:-2.35 c:abc def}
&main.T{a:7, b:-2.35, c:"abc\tdef"}
map[string] int{"CST":-21600, "PST":-28800, "EST":-18000, "UTC":0, "MST":-25200}
fmt.Printf("%T\n", timeZone)
结果
map[string] int
自定义显示方法只需重写类型的String() string方法
func (t *T) String() string {
return fmt.Sprintf("%d/%g/%q", t.a, t.b, t.c)
}
fmt.Printf("%v\n", t)
结果
7/-2.35/"abc\tdef"
重写方法时避免无限重入
type MyString string
func (m MyString) String() string {
return fmt.Sprintf("MyString=%s", m) // Error: will recur forever.
}
应改为
type MyString string
func (m MyString) String() string {
return fmt.Sprintf("MyString=%s", string(m)) // OK: note conversion.
}
不定参数...
- 作为参数传入
func Println(v ...interface{}) {
std.Output(2, fmt.Sprintln(v...)) // Output takes parameters (int, string)
}
- 作为slice使用
func Min(a ...int) int {
min := int(^uint(0) >> 1) // largest int
for _, i := range a {
if i < min {
min = i
}
}
return min
}
Append
append内置函数签名func append(slice []T, elements ...T) []T。T表示任何类型。切片通过...方式转换为可变参数。
x := []int{1,2,3}
y := []int{4,5,6}
x = append(x, y...)
fmt.Println(x)
9. 初始化[9]
go的初始化比c和c++更强大，可以构造复杂结构体，不同包之间的初始化顺序也会被正确处理。
常量
go常量在编译时生成，只能是数字、字符、字符串或布尔类型。定义支持常量表达式，例如1<<3，math.Sin(math.Pi/4)不支持，因为math.Sin是运行时函数。
iota枚举器用来定义枚举常量
type ByteSize float64
const (
_ = iota // ignore first value by assigning to blank identifier
KB ByteSize = 1 << (10 * iota)
MB
GB
TB
PB
EB
ZB
YB
)
func (b ByteSize) String() string {
switch {
case b >= YB:
return fmt.Sprintf("%.2fYB", b/YB)
case b >= ZB:
return fmt.Sprintf("%.2fZB", b/ZB)
case b >= EB:
return fmt.Sprintf("%.2fEB", b/EB)
case b >= PB:
return fmt.Sprintf("%.2fPB", b/PB)
case b >= TB:
return fmt.Sprintf("%.2fTB", b/TB)
case b >= GB:
return fmt.Sprintf("%.2fGB", b/GB)
case b >= MB:
return fmt.Sprintf("%.2fMB", b/MB)
case b >= KB:
return fmt.Sprintf("%.2fKB", b/KB)
}
return fmt.Sprintf("%.2fB", b)
}
ByteSize(1e13)显示结果为9.09TB
变量
变量在运行时完成初始化
var (
home = os.Getenv("HOME")
user = os.Getenv("USER")
gopath = os.Getenv("GOPATH")
)
init函数
每个原文件可以定义init函数（支持多个init函数）。init函数会在所有变量初始化完成、所有导入包初始化完成后运行。init函数除了进行初始化外，也常做一些状态验证和修复。
10. 方法[10]
指针 vs 值
任何命名类型都可以定义方法（除了指针和接口）。方法定义需要接收者，它可以是指针也可以是值。值将传递拷贝，方法内做的修改无法影响传入值。指针可以将修改带出方法外。
值接收者的方法可以在值和指针上执行，指针接收者的方法只能在指针上执行。一个特例是，如果值能够转为指针，值上调用指针接收者方法会自动转换为指针再调用。例如，b是值变量且可以取地址，b.Write会被自动重写为(&b).Write。
11. 接口和其它类型[11]
接口
和其它语言一样，go的接口是定义对象行为。只要具有接口方法，就可以当接口使用。go的接口一般只有1、2个方法，名字也来源于方法。
一个类型可以实现多个接口，只要它含有指定接口的方法。
转型
T(value)将一个类型值转换成另一个指定类型T，如果两个类型完全一样，此过程并不会产生新值。（int转为float，会产生新值）。
接口转型和类型断言
Type Switch已涉及接口转型，每个case都会转换成对应类型。如果已知接口类型，就要使用类型断言。value.(typeName)。typeName是具体的类型名字，例如str := value.(string)。但如果转型失败，会发生运行时错误。可用下面方式避免错误。
str, ok := value.(string)
if ok {
fmt.Printf("string value is: %q\n", str)
} else {
fmt.Printf("value is not a string\n")
}
如果转型失败，str仍然存在，只是0值。
概述
如果一个类型只是实现了一个接口，并不需要暴露这个类型而应暴露它实现的接口，以隐藏具体的实现细节。这要求构造器返回接口而不是具体实现类型。例如crc32.NewIEEE和adler32.New都返回接口hash.Hash32。替换crc32算法为adler32算法，只需要修改构造器调用，而其它代码都保持不变。
接口和方法
只要实现了接口方法的类型就实现了接口，由于几乎所有的类型都可定义方法，故此几乎所有的类型都可以实现接口。
例如Handler接口
type Handler interface {
ServeHTTP(ResponseWriter, *Request)
}
下面的结构实现了此接口
type Counter struct {
n int
}
func (ctr *Counter) ServeHTTP(w http.ResponseWriter, req *http.Request) {
ctr.n++
fmt.Fprintf(w, "counter = %d\n", ctr.n)
}
也可以用整数类型实现这个接口
type Counter int
func (ctr *Counter) ServeHTTP(w http.ResponseWriter, req *http.Request) {
*ctr++
fmt.Fprintf(w, "counter = %d\n", *ctr)
}
也可以是其它类型，比如管道
type Chan chan *http.Request
func (ch Chan) ServeHTTP(w http.ResponseWriter, req *http.Request) {
ch <- req
fmt.Fprint(w, "notification sent")
}
函数类型可以实现接口，例如
type HandlerFunc func(ResponseWriter, *Request)
func (f HandlerFunc) ServeHTTP(w ResponseWriter, req *Request) {
f(w, req)
}
func ArgServer(w http.ResponseWriter, req *http.Request) {
fmt.Fprintln(w, os.Args)
}
http.Handle("/args", http.HandlerFunc(ArgServer))
上面的代码实现了访问/args时，返回系统参数。
12. 空白标识符[12]
空白标识符类似unix中的 /dev/null文件，是一个占位符但不关心它的值。
在多赋值中使用
if _, err := os.Stat(path); os.IsNotExist(err) {
fmt.Printf("%s does not exist\n", path)
}
未使用导入和变量
package main
import (
"fmt"
"io"
"log"
"os"
)
var _ = fmt.Printf // For debugging; delete when done.
var _ io.Reader // For debugging; delete when done.
func main() {
fd, err := os.Open("test.go")
if err != nil {
log.Fatal(err)
}
// TODO: use fd.
_ = fd
}
按照约定，这些空白标记符语句必须紧随导入块之后，并且需要提供相应的注释信息，以便将来很容易找到并清除它们。
副作用导入
import _ "net/http/pprof"
导入这个包只是为了运行它的init函数
接口检查
对于运行时接口检查，如果不关心转换值，采用空白标识符忽略转换结果
if _, ok := val.(json.Marshaler); ok {
fmt.Printf("value %v of type %T implements json.Marshaler\n", val, val)
}
有种罕见情况，需要在编译时确认一个代码中未使用到的接口检查，采用空白标识符忽略转换值。
var _ json.Marshaler = (*RawMessage)(nil)
13. 内嵌[13]
go不支持标准面向对象的继承。go推荐使用组合，并提供内嵌达到类似继承的效果。接口和结构都可使用内嵌。
type Reader interface {
Read(p []byte) (n int, err error)
}
type Writer interface {
Write(p []byte) (n int, err error)
}
type ReadWriter interface {
Reader
Writer
}
接口只能内嵌接口。
type ReadWriter struct {
*Reader // *bufio.Reader
*Writer // *bufio.Writer
}
type Job struct {
Command string
*log.Logger
}
内嵌是在外部类型中定义了一个类型同名字段，并可从外部类型中直接访问内嵌数据。内嵌不支持重载和多态。go通过接口实现多态。需要多态的方法都定义为小接口（go推荐小接口），用组合代替继承。
14. 并发[14]
不同的并发方式
go没有采用资源竞争方式实现并发，而通过共享资源确保每个线程访问各自的资源。总结为一句话
勿以共享内存实现通讯，而以通讯实现共享内存
go的并发方式源于CSP模型(Communicating Sequential Processes)。
go协程
在函数或方法调用前加上go就会启动一个go协程，不同的协程能够并发的运行在同一个代码地址上。协程非常轻量，比分配栈大不了多少。协程可以多路复用操作系统线程，它屏蔽了线程创建、管理等的复杂细节。
func Announce(message string, delay time.Duration) {
go func() {
time.Sleep(delay)
fmt.Println(message)
}() // Note the parentheses - must call the function.
}
go函数支持闭包。
通道
通道由make分配，类似队列类型。make通道是可指定缓存大小，默认为0。通道接收方一直被拥塞直到有数据收到。对于发送方，如果通道中的数据小于缓存，只拥塞到数据复制进通道，如果通道已满（或缓存为0），会一直拥塞到直到有数据被接收。
缓存通道可用作信号量，缓存数量就是控制的并发数量。见下例
var sem = make(chan int, MaxOutstanding)
func handle(r *Request) {
sem <- 1 // Wait for active queue to drain.
process(r) // May take a long time.
<-sem // Done; enable next request to run.
}
func Serve(queue chan *Request) {
for {
req := <-queue
go handle(req) // Don't wait for handle to finish.
}
}
上面的代码有个问题，可能创建无限个协程，但只有MaxOutstanding个运行。改进一下，把创建协程也放入信号量控制中。
func Serve(queue chan *Request) {
for req := range queue {
sem <- 1
go func(req *Request) {
process(req)
<-sem
}(req)
}
}
注意上面代码采用函数闭包将公共变量req的值固定在每个函数调用中。
也可用声明新的局部变量方式完成
func Serve(queue chan *Request) {
for req := range queue {
req := req // Create new instance of req for the goroutine.
sem <- 1
go func() {
process(req)
<-sem
}()
}
}
函数式编程中，更推荐闭包方式。
还有另一个方法，开启指定数量个处理协程，同时处理。这种方案更自然。
func handle(queue chan *Request) {
for r := range queue {
process(r)
}
}
func Serve(clientRequests chan *Request, quit chan bool) {
// Start handlers
for i := 0; i < MaxOutstanding; i++ {
go handle(clientRequests)
}
<-quit // Wait to be told to exit.
}
通道类型的通道
通道可以传递任何类型，也包括通道本身。下面例子实现一个简单的RPC。
type Request struct {
args []int
f func([]int) int
resultChan chan int
}
客户端代码
func sum(a []int) (s int) {
for _, v := range a {
s += v
}
return
}
request := &Request{[]int{3, 4, 5}, sum, make(chan int)}
// Send request
clientRequests <- request
// Wait for response.
fmt.Printf("answer: %d\n", <-request.resultChan)
服务端代码
func handle(queue chan *Request) {
for req := range queue {
req.resultChan <- req.f(req.args)
}
}
并行
另个应用是将一个复杂计算分散到多个CPU同时运行。见下例
type Vector []float64
// Apply the operation to v[i], v[i+1] ... up to v[n-1].
func (v Vector) DoSome(i, n int, u Vector, c chan int) {
for ; i < n; i++ {
v[i] += u.Op(v[i])
}
c <- 1 // signal that this piece is done
}
const numCPU = runtime.GOMAXPROCS(0) // number of CPU cores runtime.NumCPU()
func (v Vector) DoAll(u Vector) {
c := make(chan int, numCPU) // Buffering optional but sensible.
for i := 0; i < numCPU; i++ {
go v.DoSome(i*len(v)/numCPU, (i+1)*len(v)/numCPU, u, c)
}
// Drain the channel.
for i := 0; i < numCPU; i++ {
<-c // wait for one task to complete
}
// All done.
}
务必理解并发和并行的区别。并发是指程序能够独立执行各个模块。并行是指在多个CPU上同时执行运算以提高效率。go是一个并发语言，并不是并行语言，有些并行问题go并不适合。
简单垃圾回收例子
go的并发设计也简化一些非并发问题的解决。如下面这个源于RPC框架的简单垃圾回收例子。
var freeList = make(chan *Buffer, 100)
var serverChan = make(chan *Buffer)
func client() {
for {
var b *Buffer
// Grab a buffer if available; allocate if not.
select {
case b = <-freeList:
// Got one; nothing more to do.
default:
// None free, so allocate a new one.
b = new(Buffer)
}
load(b) // Read next message from the net.
serverChan <- b // Send to server.
}
}
func server() {
for {
b := <-serverChan // Wait for work.
process(b)
// Reuse buffer if there's room.
select {
case freeList <- b:
// Buffer on free list; nothing more to do.
default:
// Free list full, just carry on.
}
}
}
select语句如果找不到满足子句，会执行default子句，这意味着它是非拥塞的。
15. 错误处理[15]
包开发者应该提供丰富的错误信息包含全部的错误信息，比如包名、操作名等。也可以使用类型断言转换为某种指定错误，进一步处理。
运行时错误
常见的错误处理方式是返回它。由调用者判断如何处理。但如果发现一个严重错误无法处理或绕过，调用内置函数panic产生一个运行时错误，panic接收一个任何类型的参数，一般是表示错误信息的字符串。
错误恢复
当运行时错误发生时，无论是显示产生的，还是隐式产生的例如数组下标越界，都会立刻停止当前执行并开始层层退出调用栈，退出前会执行对应的defer函数。可以使用recover方法重新截获运行时错误。recover只能在defer函数中使用，因为退栈时只有defer函数能够执行。例子如下
func server(workChan <-chan *Work) {
for work := range workChan {
go safelyDo(work)
}
}
func safelyDo(work *Work) {
defer func() {
if err := recover(); err != nil {
log.Println("work failed:", err)
}
}()
do(work)
}
recover只有在defer函数中才可能返回非nil，defer函数中的调用不受panic和recover的影响。错误恢复也用来处理内部错误，下面的例子是regexp包处理解析错误。
// Error is the type of a parse error; it satisfies the error interface.
type Error string
func (e Error) Error() string {
return string(e)
}
// error is a method of *Regexp that reports parsing errors by
// panicking with an Error.
func (regexp *Regexp) error(err string) {
panic(Error(err))
}
// Compile returns a parsed representation of the regular expression.
func Compile(str string) (regexp *Regexp, err error) {
regexp = new(Regexp)
// doParse will panic if there is a parse error.
defer func() {
if e := recover(); e != nil {
regexp = nil // Clear return value.
err = e.(Error) // Will re-panic if not a parse error.
}
}()
return regexp.doParse(str), nil
}
doParse代码
if pos == 0 {
re.error("'*' illegal at start of expression")
}
一个需要遵守的原则是，内部运行时错误被转成error返回，不要暴露到包外。
使用re-panic重新抛出运行时错误，错误栈中会包含新旧错误信息。
