Golang基础 变量与常量

01 变量声明

变量就是内存堆栈区的一块地址空间用于存储数据，Go语言在使用变量时需要先声明变量，常用的声明方式有两种：

1. 使用var关键字声明

使用关键字var声明变量的格式如下所示，以关键字var开头，被声明的变量放在数据类型之前（与其他语言形式上有较大区别）。（这种声明方式通常用于全局变量的声明）

var 变量名称 数据类型

// example:
var age int
var score float32
var qualified bool
var name string
1
2
3
4
5
6
7

当你需要一口气声明多个变量时，Go也提供了简洁的声明方式，仅使用一个var关键字，将多个变量名称及其数据类型放在该关键字后的括号中。

var (
  变量名称 数据类型
  ...
)

// example:
var (
    age int
    score float32
    qualified bool
    name string
)
1
2
3
4
5
6
7
8
9
10
11
12

2. 使用:=符号声明短变量

短变量声明也是Go语言中一种特殊的变量声明方式，类似于=赋值运算符的使用方式，使用:=连接变量名称和变量值两个部分声明用于函数体内的变量。（这种声明方式通常用于函数内局部变量的声明）

变量名称 := 变量值

// example:
func (){
    name := "Jack"
    age := 10
    score := 99.6
}
1
2
3
4
5
6
7
8

=和:=的区别：前者是赋值运算符，仅将右值赋给左侧变量；后者用于短变量声明，完成变量声明和变量初始化赋值两个任务，要注意的是变量仅能被声明一次，不能在同一作用域内使用:=多次声明同名短变量，但是可以用=多次赋值短变量。

02 常量声明

常量是一种恒定不变的数值或者数据项。常量多用于定义程序运行期间不随时间变化的某些量和信息，也可以是表示某一数值的字符或字符串，常被用来标识、测量和比较。

常量的声明使用const关键字声明，在常量声明时必须被赋值初始化且在整个程序运行期间都不能再改变。

const 常量名称 = 常量值

// example-1:
const pi = 3.1415926
const e = 2.7182

// example-2:
const (
    pi = 3.1415926
    e = 2.7182
)
1
2
3
4
5
6
7
8
9
10
11

03 变量初始化

Go语言编译器在声明变量时，如果没有显式地初始化，则会根据变量的数据类型用默认值对其进行初始化。显示表达式初始化变量的格式如下所示：

var 变量名称 数据类型 = 表达式

// example:
var name string = "Jack"
var age int = 18
1
2
3
4
5

类型自动推导：在显示初始化变量时，可以省略变量的数据类型，编译器自动根据赋值运算符右值来自动推导出变量的数据类型完成初始化。

多变量初始化：Go语言中可以用一个赋值运算符一次性初始化多个变量，这是Go语言赋值运算符的一大特点。

var 变量名称 = 表达式


// example-1:
var name = "Jack"
var age = 18

// example-2:
var (
    name = "Jack"
    age = 18
)

// example-3:
var name, age = "Jack", 18
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

匿名变量：在多重赋值时，用下划线_占位，表示忽略值，这也是Go语言的一语法特点，匿名变量不占用命名空间，不会分配内存，所以也不存在重复声明。

// example:
func foo() (string, int){
	return "Jack", 18
}

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

04 常量初始化

常量在定义时必须被初始化，变量的初始化方式都适用于常量，将var关键字替换成const即可。

同值多常量省略初始化：但在声明多个常量时，可以通过省略值的方式初始化值相同的常量，如果省略了值则表示该常量的值与其上一行的常量值相同，这是变量中无法实现的初始化方式。

// example: num1,num2,num3三个常量的值都被初始化
const (
	num1 = 100
	num2 
	num3
)
1
2
3
4
5
6

iota常量计数器实现枚举：iota智能用于常量表达式中，在const关键字出现是被置为0，每新增一行常量声明将被iota计数一次。

// example-1: 一般情况
const (
    num1 = iota // 0
    num2        // 1
    num3        // 2
)

// example-2: 中间插队恢复
const (
    num1 = iota // 0
    other = 100 
    num2 = iota // 2
    num3        // 3
)

// example-3: 插队导致 iota 失效
const (
    num1 = iota // 0
    other = 100 
    num2        // 100
    num3        // 100
)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

iota的使用技巧：iota可以被用于表达式中，也可以将多个iota定义在一行枚举多个变量

1. iota用于表达式

iota结合表达式构成更加赋值的枚举

// example:
const (
	_  = iota
	KB = 1 << (10 * iota)
	MB = 1 << (10 * iota)
	GB = 1 << (10 * iota)
	TB = 1 << (10 * iota)
	PB = 1 << (10 * iota)
)
1
2
3
4
5
6
7
8
9

定义数量级 （这里的<<表示左移操作，1<<10表示将1的二进制表示向左移10位，也就是由1变成了10000000000，也就是十进制的1024。同理2<<2表示将2的二进制表示向左移2位，也就是由10变成了1000，也就是十进制的8。）

2. 多个iota

将多个iota定义在一行枚举多个变量

// example:
const (
	c, d = iota, 2*iota // 0 0
	e, f                // 1 2
	_, _
	g, h                // 3 6
)
1
2
3
4
5
6
7

参考资料

变量和常量 · Go语言中文文档