1. 标识符和关键字
所有语言中都有自己的关键字和保留字，在定义函数、变量、方法的时候要规避这些关键字和保留字。
1.1. 标识符
在编程语言中标识符就是程序员定义的具有特殊意义的词，比如变量名、常量名、函数名等等。 Go语言中标识符要求如下：
- 标识符由字母数字和
_(下划线）组成，并且只能以字母或_开头。_表示丢弃该变量(不分配内存) - 严格区分大小写，首字母大写的标识符可以被其它包访问，即对外可见
- Go中通常使用驼峰式命名，而不是下划线连接，如
ApiServer或apiServer - 不能与关键字、保留字冲突，避免和已有的包名冲突
1.2. Go中保留字和关键字
# 25个关键字
break default func interface select
case defer go map struct
chan else goto package switch
const fallthrough if range type
continue for import return var
# 37个保留字
Constants:
true false iota nil
Types:
int int8 int16 int32 int64
uint uint8 uint16 uint32 uint64 uintptr
float32 float64
complex128 complex64
bool string error
byte rune
Functions:
make len cap new append copy close delete
complex real imag
panic recover
2. 变量
2.1. 变量的定义方式
Python和Bash shell中变量赋值的过程自动完成变量定义。go中的变量需要声明其类型(如字符串、浮点数等)，也可以由编译器自动完成数据类型的识别。Go语言中，变量的命名建议采用小驼峰方式命名，如: userName , studentKey
1. 变量声明的类型
(1) 标准声明
var name type // var为关键字定义当前在定义变量
(2) 批量声明
var (
name1 type1
name2 type2
...
)
2. 变量的初始化
Go语言在声明简单数据类型变量的时候，会自动对变量的内存区域进行初始化操作，每个类型的变量在赋值之前都有默认值(零值)：
int --> 0 ; bool --> 0 ; string --> "" ; 指针类型 --> nil
3. 变量的定义
(1) 先声明后赋值，声明过程中会有一个默认值，然后赋值给变量替换默认值(赋值过程不能在全局作用域)
var varName string
varName = value
(2) 直接指定类型和默认值，可以在全局作用域
var varName string = value
(3) 类型推导，即直接赋值，由编译器根据值自动判断数据类型，然后自动完成声明
var varName = value
(4) 短变量声明(仅在函数内部使用)
func funcName() {
varName := value // 声明并完成赋值
}
(5) 匿名变量(不占内存空间，也不会分配内存)
func main() {
x, _ := foo() // foo函数返回值为2个，但是第二值用不到，可以将其丢弃
}
4. 注意事项
(1) 变量命令方式建议采用小驼峰式命名
(2) 同一个作用域内不能重复声明变量
(3) 全局作用域内，不能直接使用 varName := value 方式给变量赋值
(4) 局部赋值后，必须调用，否则编译出错
(5) := 不能用在func之外
(6) _ 表示丢弃某个值，起到占位的作用
2.2. 案例
package main
import "fmt"
var (
name string
age int
)
func main() {
name = "zhangsan"
fmt.Println(name)
fmt.Println(age)
var isStudent bool
fmt.Println(isStudent)
}
e:\OneDrive\Projects\Go\src\gitee.com\studygo\day01\01-variables>go run main.go
zhangsan
0
false
3. 常量
3.1. 常量的定义
与Python不同，Go中存在常量(constant)，这类变量在定义的时候必须赋值，且一旦定义，代码运行期间就不能修改
1. 常量的定义方式
const name = value
const (
name1 = value1
name2 = value2
)
2. 常量的默认值
常量必须赋值，如果常量没赋值，则继承上一行定义的常量值
3.1.1. 案例一
package main
import "fmt"
const meta = "10.4.7.111"
const (
aaa = 100
bbb
ccc = "xxx"
ddd
)
func main() {
fmt.Println(meta)
fmt.Println(aaa,bbb,ccc,ddd)
}
e:\OneDrive\Projects\Go\src\gitee.com\studygo\day01\01-variables>go run main.go
10.4.7.111
100 100 xxx xxx
3.1.2. 案例二
package main
import "fmt"
const (
dbHost string = "app01.mysql.prod.com"
dbUser string = "app01"
dbPassword string = "App01.owksok199241@333"
)
func main() {
fmt.Printf("MySQL connections info:\n host:%s user:%s password:%s\n", dbHost,dbUser,dbPassword)
}
[root@heyingsheng 2020-03-12]# go run 02.go
MySQL connections info:
host:app01.mysql.prod.com user:app01 password:App01.owksok199241@333
3.2. iota
iota是go语言的常量计数器，只能在常量的表达式中使用。
iota是当前const语句块中的变量位置索引，每次出现新的const，iota的值就0重新计数
3.2.1. iota 案例1
package main
import "fmt"
const v1 = 1
const v2 = iota // 当前是一个新的const语句块，因此iota从0开始，v2是当前const第一个变量，因此v2为0
const v3 = iota // 当前是一个新的const语句块，因此iota从0开始，v3是当前const第一个变量，因此v3为0
const (
x1 = 100
x2
x3 = "s1"
x4
x5 = iota // x5在当前const语句块中索引为4，因此x5=4
)
func main() {
fmt.Println(v1, v2, v3) // 1 0 0
fmt.Println(x1,x2,x3,x4,x5) // 100 100 s1 s1 4
}
3.2.2. iota案例2
package main
import "fmt"
const (
_ = iota
KB = 1 << (10 * iota) // 位移运算，这是iota的一种使用场景
MB = 1 << (10 * iota)
GB = 1 << (10 * iota)
TB = 1 << (10 * iota)
PB = 1 << (10 * iota)
)
const (
Debug = iota // 日志级别定义
Info
Warning
Error
Fatal
)
