Go基础语法：变量和常量

2.1 变量的声明

变量名、常量名、函数名统称为标识符。标识符由字母、数字和下划线组成，只能以字母或下划线开头。

Go 语言中推荐使用驼峰命名方式。

命名方式：stu_name 下划线方式；stuName 小驼峰方式；StuName 大驼峰方式

Go 语言中的变量必须先声明再使用；非全局变量（函数内的变量）声明之后必须使用，否则报错

同一个作用域内不能有重名的变量。

2.1.1 标准声明方式

var 变量名 变量类型

如：

var s1 string
var num int
var isok bool
1
2
3

2.1.2 批量声明

var (
	a string
	b int
	c bool
	d float32
)
1
2
3
4
5
6

2.1.4 类型推导方式声明

即在声明变量时直接赋值，且并不需要声明其类型，系统会根据变量值自动推断变量的类型，推荐使用这种方式：

var age = 28
1

2.1.5 短变量声明

在函数内部时，可以直接使用简短的声明方式——:=

package main

import "fmt"

func main() {
	// 简短声明方式，省略了 var ,仅能用于函数内部
	s3 := 13
	fmt.Printf("%d \n", s3)
}
1
2
3
4
5
6
7
8
9

2.1.6 匿名变量

在使用多重赋值时，如果想要忽略某个值，可以使用 匿名变量（anonymous variable） 。匿名变量用下划线 _ 表示。

匿名变量不占用命名空间，不会分配内存，所以匿名变量之间不存在重复声明。

package main

import "fmt"

func main() {
	x, _ := foo()
	_, y := foo()

	// x= 10
	fmt.Println("x=", x)
	// y= 张三
	fmt.Println("y=", y)
}

func foo() (int, string) {
	return 10, "张三"
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

2.2 变量的初始化

2.2.1 声明时初始化

可以在声明的同时初始化，格式为：var 变量名 类型 = 表达式，如：

var name string = "张三"
var age int = 18
1
2

2.2.2 先声明后初始化

也可以先声明再初始化，声明后系统会自动对变量对应的内存区域进行初始化操作。每个变量会被初始化为其类型的默认值。如：整型和浮点型变量的默认值为 0，字符串变量的默认值为空字符串，布尔类型的变量默认为 flase ，切片、函数、指针变量的默认值为 nil。如下：

package main

import "fmt"

var age int

func main() {
	//输出 0 
	fmt.Printf("%d \n", age)
	age = 18
	//输出 18
	fmt.Printf("%d \n", age)
}
1
2
3
4
5
6
7
8
9
10
11
12
13

fmt 包中有三种 print : Print——普通打印，Printf——可以使用占位符的格式化打印，Println——带有换行符的打印

2.2.3 批量初始化

var name, age = "张三", 18
1

2.3 常量

常量是恒定不变的值，多用于定义程序运行期间不会改变的一些值。常量关键字 const，在定义常量时必须赋值。如：

const pi = 3.1415
const e = 2.7182
1
2

多个常量也可以一起声明

const (
	pi = 3.1415
	e  = 2.7182
)
1
2
3
4

const 同时声明多个常量时，如果省略了值则表示和上面一行的值相同，如：

package main

import "fmt"

const (
	a = 100
	b
	c = 200
	d
)

func main() {
	// 100
	fmt.Println("a=", a)
	// 100
	fmt.Println("b=", b)
	//200
	fmt.Println("c=", c)
	//200
	fmt.Println("d=", d)
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

2.4 iota

2.4.1 iota 的基本定义和使用

iota 是 go 语言中的常量计数器，只能在常量的表达式中使用。

iota 在 const 关键字出现时将被重置为 0，const 中每新增一行常量声明都将使 iota 计数一次。

使用 iota 能简化定义，在定义枚举时很有用。

package main

import "fmt"

const (
	a = iota
	b
	c
)

func main() {
	// 0
	fmt.Println("a=", a)
	// 1
	fmt.Println("b=", b)
	//2
	fmt.Println("c=", c)
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

2.4.2 常见示例

• 使用 _ 跳过某些值：

package main

import "fmt"

const (
	a = iota
	b
	_
	c
)

func main() {
	// 0
	fmt.Println("a=", a)
	// 1
	fmt.Println("b=", b)
	// 3
	fmt.Println("c=", c)
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

• iota 声明中间插队

package main

import "fmt"

const (
	a = iota
	b = 100
	c
	d = iota
	e
)

func main() {
	// 0
	fmt.Println("a=", a)
	// 100
	fmt.Println("b=", b)
	// 100
	fmt.Println("c=", c)
	// 3
	fmt.Println("d=", d)
	// 4
	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() {
	// 1
	fmt.Println("a=", a)
	// 2
	fmt.Println("b=", b)
	// 2
	fmt.Println("c=", c)
	// 3
	fmt.Println("d=", d)
	// 3
	fmt.Println("e=", e)
	// 4
	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() {
	// 1
	fmt.Println("a=", a)
	// 2
	fmt.Println("b=", b)
	// 2
	fmt.Println("c=", c)
	// 3
	fmt.Println("d=", d)
	// 3
	fmt.Println("e=", e)
	// 4
	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 (
	_  = iota
	KB = 1 << (10 * iota)
	MB = 1 << (10 * iota)
	GB = 1 << (10 * iota)
	TB = 1 << (10 * iota)
	PB = 1 << (10 * iota)
)

func main() {
	// KB = 1024
	fmt.Println("KB =", KB)
	// MB = 1048576
	fmt.Println("MB =", MB)
	// GB = 1073741824
	fmt.Println("GB =", GB)
	// TB = 1099511627776
	fmt.Println("TB =", TB)
	// PB = 1125899906842624
	fmt.Println("PB =", PB)
}
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