GO-变量&常量&类型

GO的变量

go时静态语言，所以不支持在运行时改变变量的类型。
go变量的类型是由关键字var来表示的。

var i int = 1 //定义int型变量i

在定义go的变量时，可以不显示制定变量的类型，而有编译器来推断。

var i : = 1 //定义变量i，类型由编译器推断

go支持同时定义多个变量，同时对多个变量进行赋值。

//同时定义三个变量int型变量 x,y,z
var x,y,z int

//同时定义两个变量 a 和 b，他们的值都是使用的默认值
var (
a int
b float32
)

//同时对两个变量赋值
a, b := 1, 1.0

在对变量赋值时，先计算相关值，然后从左向右依次赋值。

data, i := [3]int{0, 1, 2}, 0 //定义data为int型数组，初始化为{0,1,2};定义int型值i，初始化为0
i, data[i] : = 2, 100 //将i的值设置为2，将data[0]设置为100，这里的i还是0。注意这里的i还没有赋值为2，所以不是data[2]=100

在go语言中，支持使用下划线(_)作为占位符，抛弃不需要的返回值。

func test() (int, string) {
	return 1, "a"
}

func main() {
	_, a = test()
}

在go语言中定义的局部变量为使用的话，在代码编译时会报错；但是全局变量不会。

var s string //此处不会
func main() {
	i := 0 //此处编译时会报错
}

常量

常量由关键值 const 指定。常量必须时编译时可以预期的数值、布尔值或字符串。

const i, j int = 0, 1

//定义常量组，注意此处是直接使用的=, 而不是 :=
const (
a = 1
b = "b"
)

在函数中，未使用的局部常量不会引发编译错误。

func main() {
	const a = 10 //此处不会引发编译错误
}

常量值还可以是 len、cap、unsafe.Sizeof 等编译期可确定结果的函数返回值。

const (
a = "abc"
b = len(a)
c   = unsafe.Sizeof(b)
)

枚举

go语言的枚举多由常量组组成。在go中 iota 定义常量组中从0开始开始，按行计数的自增枚举值。

const (
a iota // a = 0
b      // b = 1
c.     // c = 2
)

常量组的定义可以使用表达式，并自行向下复制。

const (
_  iota
KB  1<<(10 * iota)  //iota的值为1
MB                  //iota值为2，MB = 1 <<(10 * 2)
GB
)

在同一组常量中，可以定义多个iota，各自增长。

const (
a, b = iota, iota
c, d = iota, iota
)

在常量组中，iota可以被打断，并显示恢复。

const (
  a = iota //a = 0
  b
  c = 'c'
  d = iota //d = 3,显示恢复了，并且b，c的行数被记录使用。
)

还可以通过自定义类型实现枚举

type Color int

const (
  RED Color = iota
  BLACK
  BLUE
)

func test(Color c) {}

func main() {
  c := BLACK
  test(c)
  
  test(1) // 编译器会自动做类型转换
  x := 1
  test(x) //编译器会报错，因为 x 为int 类型 
}

基本类型

类型	长度	默认值	说明
bool	1	false
byte	1	0	uint8
rune	4	0	Unicode Code Point, int32
int, uin	4 or 8	0	32位 or 64位
int8, uin8	1	0	-128~127, 0~255
int16, uint16	2	0	-32768 ~ 32767, 0 ~ 65535
int32, uint32	4	0	-21亿~ 21亿, 0 ~ 42亿