在 Golang中,编程规范对于一个人的认知很重要.因而一开始就希望可以养成好的习惯！
- 一行最长不超过80个字符，超过的使用换行展示，尽量保持格式优雅。
- 文件名命名用小写，尽量见名思义，看见文件名就可以知道这个文件下的大概内容，对于源代码里的文件，文件名要很好的代表了一个模块实现的功能。
- 包名应该为小写单词，不要使用下划线或者混合大小写。
- 每个包都应该有一个包注释，包如果有多个go文件，就只需要在入口文件写包注释.
- 概况以 Package 开头。
// Copyright 2009 The Go Authors. All rights reserved.
// Use of this source code is Governed by a BSD-style
// license that can be found in the LICENSE file.
// Package strings implements simple functions to manipulate strings.
package strings- 包名用小写,使用短命名,尽量和标准库不要冲突.
- 使用短命名，因为长名字并不会使得事物更易读，文档注释会比格外长的名字更有用.
- 需要导出的任何类型必须以大写字母开头.
- 全局变量：驼峰式，可导出的使用大写字母开头.
- 参数传递：驼峰式，小写字母开头.
- 局部变量：下划线风格命名.
- 单个函数的接口名以”er”作为后缀，如Reader,Writer
- 接口的实现则去掉“er”
type Reader interface {
Read(p []byte) (n int, err error)
}- 两个函数的接口名综合两个函数名
type WriteFlusher interface {
Write([]byte) (int, error)
Flush() error
}- 三个以上函数的接口名，类似于结构体名
type Vehicle interface {
Start([]byte)
Stop() error
Recover()
}- 函数名采用驼峰命名法，尽量不要使用下划线
- 写概况，并且使用被声明的名字作为开头。
// 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) {
// Request represents a request to run a command.
type Request struct { ...}- 采用命名的多返回值，在godoc生成的文档中，带有返回值的函数声明更利于理解。
func nextInt(b []byte, pos int) (value, nextPos int, err error) {}- 对标准包，程序内部包，第三方包进行分组。
import (
"encoding/json" //标准包
"strings"
"spike/models" //内部包
"spike/utils"
"github.com/go-sql-driver/mysql" //第三方包
)- 引用包时不要使用相对路径。
// 错误的做法
import “../net”
// 正确的做法
import “github.com/repo/proj/src/net”- error作为函数的值返回,必须尽快对error进行处理
- 错误描述如果是英文必须为小写，不需要标点结尾
- 采用独立的错误流进行处理
- 不要在逻辑代码中使用panic
不推荐的方式：
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
在main包中只有当实在不可运行的情况采用panic，例如文件无法打开，数据库无法连接导致程序无法 正常运行，但是对于其他的package对外的接口不能有panic，只能在包内采用。 建议在main包中使用log.Fatal来记录错误，这样就可以由log来结束程序。
- Recover
recover用于捕获runtime的异常，禁止滥用recover，在开发测试阶段尽量不要用recover，recover一般放在你认为会有不可预期的异常的地方。
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 函数可能会有不可预期的异常
do(work)
}- Defer
defer在函数return之前执行，对于一些资源的回收用defer是好的，但也禁止滥用defer，defer是需要消耗性能的,所以频繁调用的函数尽量不要使用defer。
// Contents returns the file's contents as a string.
func Contents(filename string) (string, error) {
f, err := os.Open(filename)
if err != nil {
return "", err
}
defer f.Close() // f.Close will run when we're finished.
var result []byte
buf := make([]byte, 100)
for {
n, err := f.Read(buf[0:])
result = append(result, buf[0:n]...) // append is discussed later.
if err != nil {
if err == io.EOF {
break
}
return "", err // f will be closed if we return here.
}
}
return string(result), nil // f will be closed if we return here.
}- 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
}- switch
Go的switch比C更普遍.
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
}没有自动转换，但可以用逗号分隔的列表呈现:
func shouldEscape(c byte) bool {
switch c {
case ' ', '?', '&', '=', '#', '+', '%':
return true
}
return false
}虽然它们在Go中几乎不像其他类似C语言那么常见，但可以使用break语句尽早终止切换:
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)
}
}这里是使用两个switch语句的字节片的:
// Compare returns an integer comparing the two byte slices,
// lexicographically.
// The result will be 0 if a == b, -1 if a < b, and +1 if a > b
func Compare(a, b []byte) int {
for i := 0; i < len(a) && i < len(b); i++ {
switch {
case a[i] > b[i]:
return 1
case a[i] < b[i]:
return -1
}
}
switch {
case len(a) > len(b):
return 1
case len(a) < len(b):
return -1
}
return 0
}使用类型断言的语法和关键字类型:
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
}- 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)- 名称 一般采用strcut的第一个字母且为小写，而不是this或者其他不符合的命名习惯
type Buffer struct {
buf []byte // contents are the bytes buf[off : len(buf)]
off int // read at &buf[off], write at &buf[len(buf)]
bootstrap [64]byte // memory to hold first slice; helps small buffers avoid allocation.
lastRead readOp // last read operation, so that Unread* can work correctly.
// FIXME: it would be advisable to align Buffer to cachelines to avoid false
// sharing.
}
func (b *Buffer) Bytes() []byte { return b.buf[b.off:] }- 如果接收者是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())
}- 如果需要对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)
}- 如果接收者是含有sync.Mutex或者类似同步字段的结构体，必须使用指针传递避免复制
package main
import (
"sync"
)
type T struct {
m sync.Mutex
}
func (t *T) lock() {
t.m.Lock()
}
func main() {
t := new(T)
t.lock()
}- 如果接收者是大的结构体或者数组，使用指针传递会更有效率。
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())
}- append
var a, b []int
b = append(b, a...)- 使用strings.TrimPrefix 去掉前缀，strings.TrimSuffix去掉后缀
var s1 = "a value"
var s2 = "a"
var s3 = strings.TrimPrefix(s1, s2)var s1 = "value"
var s2 = "e"
var s3 = strings.TrimSuffix(s1,s2)This is free software distributed under the terms of the MIT license