变量声明关键字：var

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
package main

import "fmt"

func main() {

	//声明一个变量不初始化，int类型默认初始化为0，string默认为空字符串，bool默认为false，切片/函数默认为nil
	var a int
	var b string
	var c bool
	fmt.Printf("a=%d,b=%s,c=%t\n", a, b, c)

	//变量的批量声明
	var (
		d int = 1
		e string = "Hello"
	)
	fmt.Printf("d=%d,e=%s\n", d, e)

	//类型推导，声明变量时省略数据类型，由编译器根据等号右边的值来推导变量的数据类型
	var name = "daqian"
	var age = 99
	fmt.Printf("name=%s,age=%d\n", name, age)

	//短变量声明，使用 := 方式声明并初始化变量，此方式只能在函数内部使用
	year := 2022
	fmt.Printf("year=%d\n", year)
	//短变量声明注意点：左边的变量至少有一个是新的未被定义的变量名，否则会编译不通过
	var short = 100
	fmt.Println(short)
	short, long := 2000, "长" //short进行第二次声明时由于long没有被定义，所以short会被重新赋值，对long进行定义，如果只有单个short会编译失败
	fmt.Println(short, long)
	//全局变量不支持短变量形式的声明
}

匿名变量 _ 多用于占位表示忽略值，在使用多重赋值时想要忽略某个值，可以使用匿名变量。匿名变量不占用命名空间，不会分配内存，所以匿名变量不存在重复声明。

  • go语言中变量需要声明才能使用，同一个作用域不支持重复声明，而且go语言的变量声明后必须使用
  • 当 + 两边都是数值型时，则做加法运算
  • 当 + 两边都是字符串时，则做字符串拼接

unsafe.Sizeof()函数，用来计算变量所占内存空间

1
fmt.Printf("year size is %d\n", unsafe.Sizeof(year))

strconv string类型转换包，使用前需要import

1
2
3
4
5
6
7
8
9
10
year := 2022
//int类型转string
year2 := strconv.Itoa(year)
//bool转string
year2 = strconv.FormatBool(c)
//float转string
year2 = strconv.FormatFloat(g)
......

//string转int用ParseInt，转bool用ParseBool，转float用ParseFloat，如果string原值类型与目标值类型不匹配则会被直接转成默认值不会报错。
常量

常量定义关键字const，常量在定义的时候就必须初始化

1
2
3
4
5
6
7
8
const pi = 3.1415
const a = "Hello"

//常量批量声明，如果前一个已经初始化的常量后的常量没有进行初始化，那未初始化的所有常量的值都和前一个常量的值相同
const (
	pa = 999
	b
)

iota关键字，在const关键字出现时会自动置为0值，每新增一行常量声明则iota的值+1，在下一次遇到const关键字时仍然会自动重置为0值

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
const (
	a = iota
	b
	c
	d
)
fmt.Printf("a=%d, b=%d, c=%d, d=%d\n", a, b, c, d)

% go run main.go
a=0, b=1, c=2, d=3


const e = iota
fmt.Println(e)

% go run main.go
a=0, b=1, d=3
0

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

1
2
3
4
5
6
7
8
const(
		_  = iota //忽略iota第一次计数
		KB = 1 << (10 * iota) //10*1
		MB = 1 << (10 * iota) //10*2
		GB = 1 << (10 * iota)
		TB = 1 << (10 * iota)
		PB = 1 << (10 * iota)
)

多个iota定义在一行

1
2
3
4
5
6
7
8
const (
		a, b = iota + 1, iota + 2 //iota=0, 1,2
		c, d                      //iota=1, 2,3
		e, f                      //iota=2, 3,4
)

% go run main.go
1 2 2 3 3 4