一、标识符

标识符，通俗的讲，就是给变量、常量、函数、方法、结构体、数组、切片、接口起名字

1.1 标识符的组成

在 Go 语言中，标识符的组成和其他编程语言类似，如下：

• 标识符有字母、数字和下划线组成
• 标识符只能以字母或下划线开头，不能以数字开头
• 标识符区分大小写

二、关键字

关键字字，就是在Go语言中内置定义了一些标识符，这些标识符已经存在固定的含义了，在自定义变量名时不能再使用关键字了，Go语言中的关键字包含25个基本关键字和36个预定义标识符

2.1 25个基本关键字

2.2 36个预定义标识符

三、命名规范

命名规则涉及变量、常量、全局函数、结构、接口、方法等的命名

3.1 公有私有的命名规范

• 当命名（包括常量、变量、类型、函数名、结构字段等等）以一个大写字母开头，如：GetUserName，那么使用这种形式的标识符的对象就可以被外部包的代码所使用（客户端程序需要先导入这个包），这被称为导出（像面向对象语言中的 public）；

• 命名如果以小写字母开头，则对包外是不可见的，但是他们在整个包的内部是可见并且可用的（像面向对象语言中的 private ）

3.2 包名称命名规范

• 保持package的名字和目录保持一致，尽量采取有意义的包名，简短，有意义，尽量和标准库不要冲突。包名应该为小写单词，不要使用下划线或者混合大小写

如：

package user
package service
1
2

3.3 文件命名规范

• 尽量采取有意义的文件名，简短，有意义，应该为小写单词，使用下划线分隔各个单词。

如：

user_api.go
1

3.4 结构体命名规范

结构体命名规范采用驼峰法，首字母根据是否提供外部使用决定是否使用大小写

type CustomerOrder struct {
    Name string
    Address string
}
1
2
3
4

3.5 接口命名规范

接口命名规范也是采用驼峰法，此外单个函数的结构名以 “er” 作为后缀，例如 Reader , Writer

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

3.6 变量名命名规范

变量名称一般遵循驼峰法，首字母根据访问控制原则大写或者小写，但遇到特有名词时，需要遵循以下规则：

• 如果变量为私有，且特有名词为首个单词，则使用小写，如 appService
• 若变量类型为 bool 类型，则名称应以 Has, Is, Can 或 Allow 开头

如：

var isExist bool
var hasConflict bool
var canManage bool
var allowGitHook bool
1
2
3
4

3.7 常量命名规范

常量均需使用全部大写字母组成，并使用下划线分词

const APP_URL = "https://www.baidu.com"
1

3.8 异常处理的规范

错误处理的原则就是不能丢弃任何有返回err的调用，不要使用 _ 丢弃，必须全部处理。接收到错误，要么返回err，或者使用log记录下来尽早return：一旦有错误发生，马上返回，尽量不要使用panic，除非你知道你在做什么，错误描述如果是英文必须为小写，不需要标点结尾，采用独立的错误流进行处理

// 错误写法
if err != nil {
    // 错误处理
} else {
    // 正常代码
}

// 正确写法
if err != nil {
    // 错误处理
    return // 或者继续
}
// 正常代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14

3.9 单元测试规范

单元测试文件名命名规范为 example_test.go 测试用例的函数名称必须以 Test 开头，例如：TestExample 每个重要的函数都要首先编写测试用例，测试用例和正规代码一起提交方便进行回归测试 。

四、变量

4.1 声明一个变量

Go 语言中声明变量使用关键字var，然后变量名，最后变量类型，即

var  变量名  变量类型
1

如：

var name string
var age int
var isTrue bool
1
2
3

4.2 批量声明变量

Go 语言中可以一次性声明多个变量，使用一个 var 关键字，把变量写到一对小括号中，如下：

var (
	name string
	age int
	isTrue bool
)
1
2
3
4
5

4.3 变量的初始化

4.3.1 声明变量默认的初始化值

Go 语言中在声明变量的时候，如果不对变量赋值 Go 语言默认会对变量进行初始化，比如字符串类型默认初始化值为 “”，整型变量默认初始化值为0，布尔类型默认初始化值为false，切片、函数、指针类型变量默认初始化值为 nil，如下：

package main

import "fmt"

func main() {
	var name string
	var age int
	var isTrue bool
	fmt.Println(name)
	fmt.Println(age)
	fmt.Println(isTrue)
}
1
2
3
4
5
6
7
8
9
10
11
12

执行结果为：

0
false
1
2
3

4.3.2 变量声明时赋值

变量声明时赋值格式如下：

var 变量名  变量类型 = 变量赋值表达式
1

如下：

package main

import "fmt"

func main() {
	var name string = "Jack"
	var age int =20
	var isTrue bool = true
	fmt.Println(name)
	fmt.Println(age)
	fmt.Println(isTrue)
}
1
2
3
4
5
6
7
8
9
10
11
12

执行结果为：

Jack
20
true
1
2
3

4.3.3 类型推导

变量在声明时如果直接赋值可以不指定变量类型，此时 Go 语言会自动从变量的赋值中推导出变量的类型，格式如下：

var 变量名 = 变量值
1

如下：

package main

import "fmt"

func main() {
	var name = "Jack"
	var age =20
	var isTrue = true
	fmt.Println(name)
	fmt.Println(age)
	fmt.Println(isTrue)
}
1
2
3
4
5
6
7
8
9
10
11
12

执行结果如下：

Jack
20
true
1
2
3

4.3.4 一次性给多个变量赋值

Go 语言支持一次性对多个变量进行赋值，如下：

package main

import "fmt"

func main() {
	var name, age, isTrue = "Jack", 20, true
	fmt.Println(name)
	fmt.Println(age)
	fmt.Println(isTrue)
}
1
2
3
4
5
6
7
8
9
10

执行结果如下：

Jack
20
true
1
2
3

4.4 短变量声明

在 Go 语言中，可以通过 := 运算符对变量进行声明，从而不需要使用var关键字，这里需要注意的是，这种用法只能在函数内使用，在函数外是不可以这么使用的，使用格式如下：

变量名 := 变量值
1

如下：

package main

import "fmt"

func main() {
	name := "Jack"
	age := 20
	isTrue := true
	fmt.Println(name)
	fmt.Println(age)
	fmt.Println(isTrue)
}
1
2
3
4
5
6
7
8
9
10
11
12

执行结果如下：

Jack
20
true
1
2
3

4.5 匿名变量

因为 Go 语言中，声明的变量必须使用，因此，当调用函数有多个返回值，匿名变量就很重要了，在 Go 语言中，匿名变量使用 _ 表示

如下：

import "fmt"

func getNameAndAge()(string,int){
	return "Jack", 20
}

func main() {
	name, _ := getNameAndAge()
	fmt.Println(name)
}
1
2
3
4
5
6
7
8
9
10

执行结果为：

Jack
1

五、常量

5.1 定义单个常量

定义常量使用 const 关键字，定义格式如下：

const 常量名 常量类型 = 常量值
1

如：

const PI float64 = 3.14
1

5.2 类型推导

常量声明中，和变量声明一样，也支持类型推导，即可以不用明确声明常量类型，如下：

const PI = 3.14
1

5.3 声明多个常量

声明多个常量有两种方式，一种是使用一对小括号，如下：

const (
		WIDTH  = 100
		HEIGHT = 200
	)
1
2
3
4

另一种方式是直接使用多重赋值的方式，如下：

const WIDTH, HEIGHT = 100, 200
1

当声明多个常量的值相同时，只有第一个赋值，后面几个可以省略赋值语句，如下表示声明的三个变量值都为100

const (
    WIDTH = 100
	HEIGHT
	DEPTH
)
1
2
3
4
5

5.4 iota 的用法

iota 比较特殊，可以被认为是一个可被编译器修改的常量，它默认开始值是0，每调用一次加1。遇到 const 关键字时被重置为 0

5.4.1 连续定义多个常量，每个常量值递增

如下，定义三个变量

package main

import "fmt"

func main() {
	const (
		ID1 = iota
		ID2 = iota
		ID3 = iota
	)
	fmt.Println(ID1)
	fmt.Println(ID2)
	fmt.Println(ID3)
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

执行结果为：

0
1
2
1
2
3

5.4.2 连续赋值时，可以省略后面的赋值

如下，同样表示将此三个常量赋值为 0， 1， 2

func main() {
	const (
		ID1 = iota
		ID2
		ID3
	)
	fmt.Println(ID1)
	fmt.Println(ID2)
	fmt.Println(ID3)
}
1
2
3
4
5
6
7
8
9
10

执行结果为：

0
1
2
1
2
3

5.4.3 通过 _ 可跳过一些值

如下，可以实现跳跃赋值

package main

import "fmt"

func main() {
	const (
		ID1 = iota
		_
		ID3
	)
	fmt.Println(ID1)
	fmt.Println(ID3)
}
1
2
3
4
5
6
7
8
9
10
11
12
13

执行结果为：

0
2
1
2

5.4.4 iota 声明中间可以插队，但插队后第一个必须再次使用 iota 赋值

如下，

package main

import "fmt"

func main() {
	const (
		ID1 = iota
		ID2 = 100
		ID3 = iota
	)
	fmt.Println(ID1)
	fmt.Println(ID2)
	fmt.Println(ID3)
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

执行结果为：

0
100
2
1
2
3