Golang編碼規範

注:此文是做者所在團隊約定的編碼規範，參考官方指南Effective Golang和Golang Code Review Comments進行整理，力圖與官方及社區編碼風格保持一致。

gofmt

大部分的格式問題能夠經過gofmt解決，gofmt自動格式化代碼，保證全部的go代碼一致的格式。

正常狀況下，採用Sublime編寫go代碼時，插件GoSublilme已經調用gofmt對代碼實現了格式化。

註釋

在編碼階段同步寫好變量、函數、包註釋，註釋能夠經過godoc導出生成文檔。

註釋必須是完整的句子，以須要註釋的內容做爲開頭，句點做爲結尾。

程序中每個被導出的（大寫的）名字，都應該有一個文檔註釋。

• 包註釋

每一個程序包都應該有一個包註釋，一個位於package子句以前的塊註釋或行註釋。

包若是有多個go文件，只須要出如今一個go文件中便可。

//Package regexp implements a simple library 
//for regular expressions.
package regexp

• 可導出類型

第一條語句應該爲一條歸納語句，而且使用被聲明的名字做爲開頭。

// Compile parses a regular expression and returns, if successful, a Regexp
// object that can be used to match against text.
func Compile(str string) (regexp *Regexp, err error) {

命名

使用短命名，長名字並不會自動使得事物更易讀，文檔註釋會比格外長的名字更有用。

• 包名

包名應該爲小寫單詞，不要使用下劃線或者混合大小寫。

• 接口名

單個函數的接口名以"er"做爲後綴，如Reader,Writer

接口的實現則去掉「er」

type Reader interface {
        Read(p []byte) (n int, err error)
}

兩個函數的接口名綜合兩個函數名

type WriteFlusher interface {
    Write([]byte) (int, error)
    Flush() error
}

三個以上函數的接口名，相似於結構體名

type Car interface {
    Start([]byte) 
    Stop() error
    Recover()
}

• 混合大小寫

採用駝峯式命名

MixedCaps 大寫開頭，可導出
mixedCaps 小寫開頭，不可導出

• 變量

  全局變量：駝峯式，結合是否可導出肯定首字母大小寫
  參數傳遞：駝峯式，小寫字母開頭
  局部變量：下劃線形式

控制結構

• if

if接受初始化語句，約定以下方式創建局部變量

if err := file.Chmod(0664); err != nil {
    return err
}

• for

採用短聲明創建局部變量

sum := 0
for i := 0; i < 10; i++ {
    sum += i
}

• range

若是隻須要第一項（key），就丟棄第二個：

for key := range m {
    if key.expired() {
        delete(m, key)
    }
}

若是隻須要第二項，則把第一項置爲下劃線

sum := 0
for _, value := range array {
    sum += value
}

• return

儘早return：一旦有錯誤發生，立刻返回

f, err := os.Open(name)
if err != nil {
    return err
}
d, err := f.Stat()
if err != nil {
    f.Close()
    return err
}
codeUsing(f, d)

函數（必須）

• 函數採用命名的多值返回

• 傳入變量和返回變量以小寫字母開頭

  func nextInt(b []byte, pos int) (value, nextPos int) {

  在godoc生成的文檔中，帶有返回值的函數聲明更利於理解

錯誤處理

• error做爲函數的值返回,必須對error進行處理
• 錯誤描述若是是英文必須爲小寫，不須要標點結尾
• 採用獨立的錯誤流進行處理

不要採用這種方式

if err != nil {
        // error handling
    } else {
        // normal code
    }

而要採用下面的方式

if err != nil {
        // error handling
        return // or continue, etc.
    }
    // normal code

若是返回值須要初始化，則採用下面的方式

x, err := f()
if err != nil {
    // error handling
    return
}
// use x

panic

• 儘可能不要使用panic，除非你知道你在作什麼

import

• 對import的包進行分組管理，並且標準庫做爲第一組

  package main
  
  import (
      "fmt"
      "hash/adler32"
      "os"
  
      "appengine/user"
      "appengine/foo"
  
      "code.google.com/p/x/y"
      "github.com/foo/bar"
  )

goimports實現了自動格式化

縮寫

• 採用所有大寫或者所有小寫來表示縮寫單詞

好比對於url這個單詞，不要使用

UrlPony

而要使用

urlPony 或者 URLPony

參數傳遞

• 對於少許數據，不要傳遞指針
• 對於大量數據的struct能夠考慮使用指針
• 傳入參數是map，slice，chan不要傳遞指針

由於map，slice，chan是引用類型，不須要傳遞指針的指針

接受者

• 名稱

統一採用單字母'p'而不是this，me或者self

type T struct{} 

    func (p *T)Get(){}

• 類型

對於go初學者，接受者的類型若是不清楚，統一採用指針型

func (p *T)Get(){}

而不是

func (p T)Get(){}

在某些狀況下，出於性能的考慮，或者類型原本就是引用類型，有一些特例

• 若是接收者是map,slice或者chan，不要用指針傳遞

//Map
package main

import (
    "fmt"
)

type mp map[string]string

func (m mp) Set(k, v string) {
    m[k] = v
}

func main() {
    m := make(mp)
    m.Set("k", "v")
    fmt.Println(m)
}

//Channel
package main

import (
    "fmt"
)

type ch chan interface{}

func (c ch) Push(i interface{}) {
    c <- i
}

func (c ch) Pop() interface{} {
    return <-c
}

func main() {
    c := make(ch, 1)
    c.Push("i")
    fmt.Println(c.Pop())
}


<pre><code><br /></code></pre>

若是須要對slice進行修改，經過返回值的方式從新賦值
//Slice
package main

import (
    "fmt"
)

type slice []byte

func main() {
    s := make(slice, 0)
    s = s.addOne(42)
    fmt.Println(s)
}

func (s slice) addOne(b byte) []byte {
    return append(s, b)
}

<pre><code><br /></code></pre>

若是接收者是含有sync.Mutex或者相似同步字段的結構體，必須使用指針傳遞避免複製
package main

import (
    "sync"
)

type T struct {
    m sync.Mutex
}

func (t *T) lock() {
    t.m.Lock()
}

/*
Wrong !!!
func (t T) lock() {
    t.m.Lock()
}
*/

func main() {
    t := new(T)
    t.lock()
}

<pre><code><br /></code></pre>

若是接收者是大的結構體或者數組，使用指針傳遞會更有效率。

package main

import (
    "fmt"
)

type T struct {
    data [1024]byte
}

func (t *T) Get() byte {
    return t.data[0]
}

func main() {
    t := new(T)
    fmt.Println(t.Get())
}