变量和常量
变量
变量声明
Go 语言中的每一个变量都有自己的类型，并且变量必须经过声明才能开始使用，同一作用域内不支持重复声明。并且 Go 语言的变量声明后必须使用。
package main
import (
"fmt"
)
//声明全局变量 方法一、方法二、方法三是可以的
var gA int = 100
var gB = 200
//用方法四来声明全局变量
// := 只能够用在 函数体内来声明
//gC := 200
func main() {
//方法一：声明一个变量 默认的值是0
var a int
fmt.Println("a = ", a)
fmt.Printf("type of a = %T\n", a)
//方法二：声明一个变量，初始化一个值
var b int = 100
fmt.Println("b = ", b)
fmt.Printf("type of b = %T\n", b)
var bb string = "abcd"
fmt.Printf("bb = %s, type of bb = %T\n", bb, bb)
//方法三：在初始化的时候，可以省去数据类型，通过值自动匹配当前的变量的数据类型
var c = 100
fmt.Println("c = ", c)
fmt.Printf("type of c = %T\n", c)
var cc = "abcd"
fmt.Printf("cc = %s, type of cc = %T\n", cc, cc)
//方法四：(常用的方法) 省去var关键字，直接自动匹配
e := 100
fmt.Println("e = ", e)
fmt.Printf("type of e = %T\n", e)
f := "abcd"
fmt.Println("f = ", f)
fmt.Printf("type of f = %T\n", f)
g := 3.14
fmt.Println("g = ", g)
fmt.Printf("type of g = %T\n", g)
// =====
fmt.Println("gA = ", gA, ", gB = ", gB)
//fmt.Println("gC = ", gC)
// 声明多个变量
var xx, yy int = 100, 200
fmt.Println("xx = ", xx, ", yy = ", yy)
var kk, ll = 100, "Aceld"
fmt.Println("kk = ", kk, ", ll = ", ll)
//多行的多类型变量声明
var (
vv int = 100
jj bool = true
)
fmt.Println("vv = ", vv, ", jj = ", jj)
mm, nn := 99 , 19
fmt.Println("mm = ", mm, ", nn = ", nn)
//匿名变量
//在使用多重赋值时，如果想要忽略某个值，匿名变量。 匿名变量用一个下划线\_表示，例如：
x, _ := foo()
_, y := foo()
fmt.Println("x=", x)
fmt.Println("y=", y)
//匿名变量不占用命名空间，不会分配内存，所以匿名变量之间不存在重复声明。
}
func foo() (int, string) {
return 10, "Q1mi"
}
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
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
注意事项：
函数外的每个语句都必须以关键字开始（var、const、func等）
:=不能使用在函数外。
_多用于占位，表示忽略值。
1
2
3
2
3
常量
多个常量也可以一起声明：
const (
pi = 3.1415926
e = 2.7182
)
1
2
3
4
2
3
4
const同时声明多个常量时，如果省略了值则表示和上面一行的值相同。 例如：
const (
n1 = 100
n2
n3
//常量`n1、n2、n3`的值都是`100`
)
1
2
3
4
5
6
2
3
4
5
6
iota
iota是go语言的常量计数器，只能在常量的表达式中使用。 iota在const关键字出现时将被重置为0。const中每新增一行常量声明将使iota计数一次(iota可理解为const语句块中的行索引)。 使用iota能简化定义，在定义枚举时使用较多
const (
//每行的iota都会累加1, 第一行的iota的默认值是0,
n1 = iota //0
n2 //1
n3 //2
n4 //3
)
1
2
3
4
5
6
7
2
3
4
5
6
7
计算方式也会继承
const (
//计算方式也会继承前一行的计算。
BEIJING = 10 * iota //iota = 0
SHANGHAI //iota = 1
SHENZHEN //iota = 2
//BEIJIGN = 0 SHANGHAI = 10 SHENZHEN = 20
)
1
2
3
4
5
6
7
2
3
4
5
6
7
几个常见的 iota 示例:
使用_跳过某些值
const (
n1 = iota //0
n2 //1
_
n4 //3
)
1
2
3
4
5
6
2
3
4
5
6
iota声明中间插队
const (
n1 = iota //0
n2 = 100 //100
n3 = iota //2
n4 //3
)
const n5 = iota //0
1
2
3
4
5
6
7
2
3
4
5
6
7
多个iota定义在一行
const (
a, b = iota + 1, iota + 2 // iota = 0, a = iota + 1, b = iota + 2, a = 1, b = 2
c, d // iota = 1, c = iota + 1, d = iota + 2, c = 2, d = 3
e, f // iota = 2, e = iota + 1, f = iota + 2, e = 3, f = 4
g, h = iota * 2, iota * 3 // iota = 3, g = iota * 2, h = iota * 3, g = 6, h = 9
i, k // iota = 4, i = iota * 2, k = iota * 3 , i = 8, k = 12
)
1
2
3
4
5
6
7
8
2
3
4
5
6
7
8