2.1 变量的声明
变量名、常量名、函数名统称为标识符。标识符由字母、数字和下划线组成，只能以字母或下划线开头。
Go 语言中推荐使用驼峰命名方式。
命名方式：stu_name 下划线方式；stuName 小驼峰方式；StuName 大驼峰方式
Go 语言中的变量必须先声明再使用；非全局变量（函数内的变量）声明之后必须使用，否则报错
同一个作用域内不能有重名的变量。
2.1.1 标准声明方式
var 变量名 变量类型
如：
1
2
3
| var s1 string
var num int
var isok bool
|
2.1.2 批量声明
1
2
3
4
5
6
| var (
a string
b int
c bool
d float32
)
|
2.1.4 类型推导方式声明
即在声明变量时直接赋值，且并不需要声明其类型，系统会根据变量值自动推断变量的类型，推荐使用这种方式：
2.1.5 短变量声明
在函数内部时，可以直接使用简短的声明方式——:=
1
2
3
4
5
6
7
8
9
| package main
import "fmt"
func main() {
s3 := 13
fmt.Printf("%d \n", s3)
}
|
2.1.6 匿名变量
在使用多重赋值时，如果想要忽略某个值，可以使用 匿名变量（anonymous variable） 。匿名变量用下划线 _ 表示。
匿名变量不占用命名空间，不会分配内存，所以匿名变量之间不存在重复声明。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
| package main
import "fmt"
func main() {
x, _ := foo()
_, y := foo()
fmt.Println("x=", x)
fmt.Println("y=", y)
}
func foo() (int, string) {
return 10, "张三"
}
|
2.2 变量的初始化
2.2.1 声明时初始化
可以在声明的同时初始化，格式为：var 变量名 类型 = 表达式，如：
1
2
| var name string = "张三"
var age int = 18
|
2.2.2 先声明后初始化
也可以先声明再初始化，声明后系统会自动对变量对应的内存区域进行初始化操作。每个变量会被初始化为其类型的默认值。如：整型和浮点型变量的默认值为 0，字符串变量的默认值为空字符串，布尔类型的变量默认为 flase ，切片、函数、指针变量的默认值为 nil。如下：
1
2
3
4
5
6
7
8
9
10
11
12
13
| package main
import "fmt"
var age int
func main() {
fmt.Printf("%d \n", age)
age = 18
fmt.Printf("%d \n", age)
}
|
fmt 包中有三种 print : Print——普通打印，Printf——可以使用占位符的格式化打印，Println——带有换行符的打印
2.2.3 批量初始化
1
| var name, age = "张三", 18
|
2.3 常量
常量是恒定不变的值，多用于定义程序运行期间不会改变的一些值。常量关键字 const，在定义常量时必须赋值。如：
1
2
| const pi = 3.1415
const e = 2.7182
|
多个常量也可以一起声明
1
2
3
4
| const (
pi = 3.1415
e = 2.7182
)
|
const 同时声明多个常量时，如果省略了值则表示和上面一行的值相同，如：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
| package main
import "fmt"
const (
a = 100
b
c = 200
d
)
func main() {
fmt.Println("a=", a)
fmt.Println("b=", b)
fmt.Println("c=", c)
fmt.Println("d=", d)
}
|
2.4 iota
2.4.1 iota 的基本定义和使用
iota 是 go 语言中的常量计数器，只能在常量的表达式中使用。
iota 在 const 关键字出现时将被重置为 0，const 中每新增一行常量声明都将使 iota 计数一次。
使用 iota 能简化定义，在定义枚举时很有用。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
| package main
import "fmt"
const (
a = iota
b
c
)
func main() {
fmt.Println("a=", a)
fmt.Println("b=", b)
fmt.Println("c=", c)
}
|
2.4.2 常见示例
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
| package main
import "fmt"
const (
a = iota
b
_
c
)
func main() {
fmt.Println("a=", a)
fmt.Println("b=", b)
fmt.Println("c=", c)
}
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
| package main
import "fmt"
const (
a = iota
b = 100
c
d = iota
e
)
func main() {
fmt.Println("a=", a)
fmt.Println("b=", b)
fmt.Println("c=", c)
fmt.Println("d=", d)
fmt.Println("e=", e)
}
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
| package main
import "fmt"
const (
a, b = iota + 1, iota + 2
c, d = iota + 1, iota + 2
e, f
)
func main() {
fmt.Println("a=", a)
fmt.Println("b=", b)
fmt.Println("c=", c)
fmt.Println("d=", d)
fmt.Println("e=", e)
fmt.Println("f=", f)
}
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
| package main
import "fmt"
const (
a, b = iota + 1, iota + 2
c, d
e, f
)
func main() {
fmt.Println("a=", a)
fmt.Println("b=", b)
fmt.Println("c=", c)
fmt.Println("d=", d)
fmt.Println("e=", e)
fmt.Println("f=", f)
}
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
| package main
import "fmt"
const (
_ = iota
KB = 1 << (10 * iota)
MB = 1 << (10 * iota)
GB = 1 << (10 * iota)
TB = 1 << (10 * iota)
PB = 1 << (10 * iota)
)
func main() {
fmt.Println("KB =", KB)
fmt.Println("MB =", MB)
fmt.Println("GB =", GB)
fmt.Println("TB =", TB)
fmt.Println("PB =", PB)
}
|
