Go-变量& 常量

---

一、变量

• 因为go语言是用C 写的 所以很多时候是类似于C语言
• 变量定义在func 中的是局部变量，定义在方法外部的是全局变量

1.1、 局部变量：

定义在函数内部的变量以及函数的形参称为局部变量
作用域：从定义哪一行开始直到与其所在的代码块结束
生命周期:从程序运行到定义哪一行开始分配存储空间到程序离开该变量所在的作用域
1
2
3

1.2 、全局变量：

定义在函数外面的变量称为全局变量
作用域范围：从定义哪行开始直到文件结尾
生命周期:程序一启动就会分配存储空间，直到程序结束
1
2
3

二、 单变量

1、指定变量类型，声明后若不赋值，使用默认值
			eg：
				 var i int
				 i = 10;
2、根据值自行判断变量类型（类型推导）
		   eg:
		   		var i = 10
3、第三种：省略 var, 注意 :=左侧的变量不应该是已经声明过的，否则会导致编译错误   // 简短格式(golang官方推荐格式
			eg:
				i := 10
1
2
3
4
5
6
7
8
9
10

// 标准格式
var 变量名称 数据类型 = 值;
// 自动推到类型格式
var 变量名称 = 值;
// 简短格式(golang官方推荐格式)
变量名称 := 值;
1
2
3
4
5
6
7

2.1 指定变量类型，声明后若不赋值，使用默认值

	var a int   // 先定义
	a = 11     // 后赋值
	fmt.Println(a)
1
2
3
4

2.2 、定义的同时赋值，并省略数据类型

	var b = 10 
	fmt.Println(b)

1
2
3

2.3、省略 var, 注意 :=左侧的变量不应该是已经声明过的，否则会导致编译错误

num4 := 40 // 定义的同时赋值, 并省略关键字和数据类型
/*
num4 := 40 等价于
var num4 int
num4 = 40
*/

1
2
3
4
5
6
7

三、多变量声明

• 在编程中，有时我们需要一次性声明多个变量，Golang 也提供这样的语法

3.1 、方式一 定义的同时赋值

	// 一次性声明多个变量1
	var n1, n2, n3, n4 int
	fmt.Println(n1, n2, n3, n4)

------------
	var num1, num2, num3 int  //先定义
	num1 = 10  // 后赋值
	num2 = 20
	num3 = 30
	fmt.Println(num1, num2, num3)

1
2
3
4
5
6
7
8
9
10
11

3.2 、方式二 定义的同时赋值并省略数据类型

	var n1, n2, n3 = "老王", "我是字符串", 888
	fmt.Println(n1, n2, n3)  // 老王 我是字符串 888, 由此可以看出 值会自动一一对应匹配

-------------


	var num1, num2, num3 int = 30, 40, 50 //定义的同时赋值
	fmt.Println(num1, num2, num3)  //30 40 50

----------
	 var num1, num2, num3 = 30, 40, 50  //要携带上=
	 fmt.Println(num1, num2, num3)

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

3.3 方式三、:= 定义的同时赋值并省略关键字和数据类型

• :=只能用于定义局部变量,不能用于定义全局变量

	n1, n2, n3 := 10, "老王", 888 //因为使用了 := 所以不可以声明变量使用var
	fmt.Println(n1, n2, n3)  //10 老王 888 , 由此可以看出 值会自动一一对应匹配
----------------
	num7, num8 := "老王", 13 //定义的同时赋值并省略关键字和数据类型
	fmt.Println(num7, num8)

1
2
3
4
5
6

四、变量组

4.1 、先定义后赋值

	var ( //先定义
		num1 int
		num2 float32
	)
	num1 = 10 //后赋值
	num2 = 3.14
	fmt.Println(num1, num2)

1
2
3
4
5
6
7
8

4.2、定义的同时赋值

	var (  //定义的同时赋值，并省略数据类型
		num1 = 10
		num2 = "老王"
	)
	fmt.Println(num1, num2)

----	
	var (  //定义的同时赋值
		num1 int     = 10
		num2 float32 = 3.14
	)
	fmt.Println(num1, num2)
1
2
3
4
5
6
7
8
9
10
11
12

4.3

	var (  // 一行定义多个
		num1, num2 = 70, 80
		num3, num4 = 3.14, "老王"
	)
	fmt.Println(num1, num2, num3, num4)

1
2
3
4
5
6

五、全局变量

• 在 go 中函数外部定义变量就是全局变量

var (
	name = "老王"
	age  = 10
)

func main() {
	fmt.Println(name, age)
}

1
2
3
4
5
6
7
8
9

• 作用域不同 调取的值也不同
• 也可在在函数内部最全局变量的值重新定义

var (
	name = "老王"
	age  = 10
)

func main() {
	fmt.Println(name, age)  // 老王 10

	// 也可以在内部改变外部的全局变量
	name = "老李"
	age = 56
	fmt.Println(name, age)  // 老李 56

}

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

六、变量使用注意

6.1 变量名定义时在同一作用域不可重名

变量在同一个作用域(在一个函数或者在代码块)内不能重名

	var i int = 59
	i := 90
	fmt.Println(i) //报错 两个变量重名，  no new variables on left side of := (exit status 2)
1
2
3
4

6.2 、变量=变量名+值+数据类型，这一点请大家注意，变量的三要素

6.3 、Golang 的变量如果没有赋初值，编译器会使用默认值, 比如 int 默认值 0 string 默认值为空串，

小数默认为 0

• 变量表示内存中的一个存储区域
• 该区域有自己的名称（变量名）和类型（数据类型）

6.4 、:=只能用于定义局部变量,不能用于定义全局变量

package main
import "fmt"
num := 10 // 编译报错
func main() {
fmt.Println("num = ", num)
}
1
2
3
4
5
6

6.5、 一定不要把:=当做赋值运算符来使用 ， := 是定义变量

package main
import "fmt"
var num = 10 // 定义一个全局变量
func main() {
num := 20 // 定义一个局部变量
fmt.Println("num = ", num)
test()
}
func test() {
fmt.Println("num = ", num) // 还是输出10
}

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

6.6 、使用:=定义变量时,不能指定var关键字和数据类型

6.7 、变量组中不可以使用 :=

6.8、通过:= 同时定义多个变量时，必须给所有变量初始化

	num1, num2 := 666, 888 //正确
	num1, num2 : =666 //错误
	fmt.Println(num1, num2)
1
2
3

6.9、通过:=同时定义多个变量, 只要任意一个变量没有定义过，都会做退化赋值操作

	// 定义一个num1
	num1 := 10
	// 同时定义两个变量num1和num2, 由于num2从来没有定义过,
	// 所以对于num1来说:=退化为赋值运算符, 而对于num2来说:=仍然是定义+赋值
	num1, num2 := 20, 30

	fmt.Println(num1, num2)
1
2
3
4
5
6
7

6.10 定义的局部变量或者导入的包没有被使用, 那么编译器会报错,无法编译运行,但是定义的全局变量没有被使用,编译器不会报错, 可以编译运行

七、常量

• 和C语言一样Go语言中的常量也分为 整型常量 、 实型常量 、 字符常量 、 字符串常量、自定义常量

7.1、自定义常量

const 常量名称 数据类型 = 值 or const 常量名称 = 值

	const num1, num2 int = 333, 555 //const 常量名称 数据类型 = 值
	fmt.Println(num1, num2)

	const num3 = 40 // const 常量名称 = 值
	fmt.Println(num3)

	// 常量组
	const (
		num7 = 70
		num8 = 80
	)

	fmt.Println(num7, num8)

	// 常量组+多重赋值
	const (
		num9, num10 int = 90, 100
		num11           = 110
	)
	fmt.Println(num9, num10, num11)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

7.2 常量注意点

1、定义的局部变量或者导入的包没有被使用, 那么编译器会报错,无法编译运行，但是定义的常量没有被使用,编译器不会报错, 可以编译运行
2、常量不支持 := 定义赋值
3、在常量组中, 如果上一行常量有初始值,但是下一行没有初始值, 那么下一行的值就是上一行的
值
1
2
3
4

7.2.3、在常量组中, 如果上一行常量有初始值,但是下一行没有初始值, 那么下一行的值就是上一行的

值

	const (
		num1 = 998
		num2 // 和上一行的值一样
		num3 // 和上一行的值一样
		num4 = 999
		num5 // 和上一行的值一样
		num6 // 和上一行的值一样
	)
	fmt.Println(num1) // 998
	fmt.Println(num2) // 998
	fmt.Println(num3) // 998
	fmt.Println(num4) // 999
	fmt.Println(num5) // 999
	fmt.Println(num6) // 999


-------------

	const (
		num1, num2 int = 100, 200
		num3, num4   // 和上一行的值相同，注意变量个数必须也和上一行一样
	)
	fmt.Println(num1, num2)  //100 200
	fmt.Println(num3, num4)  //100 200
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

• 注意：常量不支持 := 定义赋值

八、 枚举

• go的枚举通过iota 标识符来实现

8.1、go语言实现枚举的格式

const(
枚举元素1 = iota
枚举元素2 = iota
... ...
)
1
2
3
4
5

• 利用iota标识符标识符实现从0开始递增的枚举

	const (
		num5 = iota
		num6 = iota
		num7 = iota
	)
	fmt.Println(num5)  // 0
	fmt.Println(num6)  // 1
	fmt.Println(num7)  // 2
1
2
3
4
5
6
7
8

8.2、 iota注意点:

在同一个常量组中,iota从0开始递增, 每一行递增1
在同一个常量组中,只要上一行出现了iota,那么后续行就会自动递增
在同一个常量组中,如果iota被中断, 那么必须显示恢复
iota也支持常量组+多重赋值, 在同一行的iota值相同
iota自增默认数据类型为int类型, 也可以显示指定类型
1
2
3
4
5

九、程序中 +号的使用

1、当左右两边都是数值型时，则做加法运算
2、当左右两边都是字符串，则做字符串拼接

1
2
3

	name := "老王"
	age := 30
	sex := "男"
	ageOne := 10
	//fmt.Println(name + age) //  invalid operation: name + age (mismatched types string and int) (exit status 2) 不是同一类型，不可以使用+ 和python一样

	fmt.Println(name + sex) // 老王男
	fmt.Println(age + ageOne) // 40


1
2
3
4
5
6
7
8
9
10

---