声明slice
声明空的slice应该使用下面的格式:
1 var t []string
而不是这种格式:
1 t := []string{}
前者声明了一个nil slice而后者是一个长度为0的非nil的slice。
关于字符串大小写
错误字符串不应该大写。
应该写成：
1 fmt.Errorf("failed to write data")
而不是写成：
1 fmt.Errorf("Failed to write data")
这是因为这些字符串可能和其它字符串相连接，组合后的字符串如果中间有大写字母开头的单词很突兀，除非这些首字母大写单词是固定使用的单词。
缩写词必须保持一致，比如都大写URL或者小写url。比如HTTP、ID等。
例如sendOAuth或者oauthSend。
常量一般声明为MaxLength,而不是以下划线分隔MAX_LENGTH或者MAXLENGTH。
也就是Go语言一般使用MixedCaps或者mixedCaps命名的方式区分包含多个单词的名称。
处理error而不是panic或者忽略
为了编写强壮的代码，不用使用_忽略错误，而是要处理每一个错误，尽管代码写起来可能有些繁琐。
尽量不要使用panic。
一些名称
有些单词可能有多种写法，在项目中应该保持一致，比如Golang采用的写法:
// marshaling
// unmarshaling
// canceling
// cancelation
而不是
// marshalling
// unmarshalling
// cancelling
// cancellation
包名应该用单数的形式，比如util、model,而不是utils、models。
Receiver 的名称应该缩写，一般使用一个或者两个字符作为Receiver的名称，如
func (f foo) method() {
...
}
如果方法中没有使用receiver,还可以省略receiver name,这样更清晰的表明方法中没有使用它:
func (foo) method() {
...
}
package级的Error变量
通常会把自定义的Error放在package级别中，统一进行维护:
var (
ErrCacheMiss = errors.New("memcache: cache miss")
ErrCASConflict = errors.New("memcache: compare-and-swap conflict")
ErrNotStored = errors.New("memcache: item not stored")
ErrServerError = errors.New("memcache: server error")
ErrNoStats = errors.New("memcache: no statistics available")
ErrMalformedKey = errors.New("malformed: key is too long or contains invalid characters")
ErrNoServers = errors.New("memcache: no servers configured or available")
)
并且变量以Err开头。
空字符串检查
不要使用下面的方式检查空字符串:
if len(s) == 0 {
...
}
而是使用下面的方式
if s == "" {
...
}
下面的方法更是语法不对：
if s == nil || s == "" {
...
}
非空slice检查
不要使用下面的方式检查空的slice:
if s != nil && len(s) > 0 {
...
}
直接比较长度即可：
if len(s) > 0 {
...
}
同样的道理也适用 map和channel。
省略不必要的变量
比如
1 var whitespaceRegex, _ = regexp.Compile("\\s+")
可以简写为
1 var whitespaceRegex = regexp.MustCompile(\s+)
有时候你看到的一些第三方的类提供了类似的方法:
func Foo(...) (...,error)
func MustFoo(...) (...)
MustFoo一般提供了一个不带error返回的类型。
直接使用bool值
对于bool类型的变量var b bool,直接使用它作为判断条件，而不是使用它和true/false进行比较
if b {
...
}
if !b {
...
}
而不是
if b == true {
...
}
if b == false {
...
}
byte/string slice相等性比较
不要使用
var s1 []byte
var s2 []byte
...
bytes.Compare(s1, s2) == 0
bytes.Compare(s1, s2) != 0
而是:
var s1 []byte
var s2 []byte
...
bytes.Equal(s1, s2) == 0
bytes.Equal(s1, s2) != 0
检查是否包含子字符串
不要使用 strings.IndexRune(s1, 'x') > -1及其类似的方法IndexAny、Index检查字符串包含，
而是使用strings.ContainsRune、strings.ContainsAny、strings.Contains来检查。
使用类型转换而不是struct字面值
对于两个类型:
type t1 struct {
a int
b int
}
type t2 struct {
a int
b int
}
可以使用类型转换将类型t1的变量转换成类型t2的变量，而不是像下面的代码进行转换
v1 := t1{1, 2}
_ = t2{v1.a, v1.b}
应该使用类型转换，因为这两个struct底层的数据结构是一致的。
_ = t2(v1)
复制slice
不要使用下面的复制slice的方式:
var b1, b2 []byte
for i, v := range b1 {
b2[i] = v
}
for i := range b1 {
b2[i] = b1[i]
}
而是使用内建的copy函数：
copy(b2, b1)
不要在for中使用多此一举的true
不要这样:
for true {}
而是要这样:
for {}
尽量缩短if
下面的代码:
x := true
if x {
return true
}
return false
可以用return x代替。
同样下面的代码也可以使用return err代替：
func fn1() error {
var err error
if err != nil {
return err
}
return nil
}
func fn1() bool{
...
b := fn()
if b {
...
return true
} else {
return false
}
}
应该写成:
func fn1() bool{
...
b := fn()if !b {
return false
}
...
return true
}
也就是减少if的分支／缩进。
append slice
不要这样:
var a, b []int
for _, v := range a {
b = append(b, v)
}
而是要这样
var a, b []int
b = append(b, a...)
简化range
var m map[string]int
for _ = range m {
}
for _, _ = range m {
}
可以简化为
for range m {
}
对slice和channel也适用。
正则表达式中使用raw字符串避免转义字符
在使用正则表达式时，不要:
regexp.MustCompile("\\.")
regexp.Compile("\\.")
而是直接使用raw字符串，可以避免大量的\出现：
regexp.MustCompile(`\.`)
regexp.Compile(`\.`)
简化只包含单个case的select
select {
case <-ch:
}
直接写成<-ch即可。send也一样。
for {
select {
case x := <-ch:
_ = x
}
}
直接改成 for-range即可。
这种简化只适用包含单个case的情况。
slice的索引
有时可以忽略slice的第一个索引或者第二个索引：
var s []int
_ = s[:len(s)]
_ = s[0:len(s)]
可以写成s[:]
使用time.Since
下面的代码经常会用到：
_ = time.Now().Sub(t1)
可以简写为:
_ = time.Since(t1)
使用strings.TrimPrefix／strings.TrimSuffix 掐头去尾
不要自己判断字符串是否以XXX开头或者结尾，然后自己再去掉XXX,而是使用现成的strings.TrimPrefix／strings.TrimSuffix。
var s1 = "a string value"
var s2 = "a "
var s3 string
if strings.HasPrefix(s1, s2) {
s3 = s1[len(s2):]
}
可以简化为
var s1 = "a string value"
var s2 = "a "
var s3 = strings.TrimPrefix(s1, s2)