Go_常量、iota(枚举)的使用
常量
-
常量是在程序运行过程中，其值不可以发生改变的数据，常量无法被获取地址 -
常量中的数据类型能是布尔型、数字型（整型、浮点型和复数型）、字符串
-
常量的定义是通过
const关键字完成的，并且常量名称大写为公开，小写为私有，一般定义在函数外，定义在函数内属于局部常量 -
常量和变量一样，可以省略数据类型，由编译器推断完成
常量的定义
const Name string = "不知火舞"
const Age = 99
const Address = "峡谷76号"
// 当常量比较多的时候可以使用常量块来表示，比较简洁
const (
USERNAME = "干将莫邪"
AGE = 88
ADDRESS = "中路草丛"
)
// 也可以批量赋值
const name, age, address = "李白", 99, "峡谷野区草丛"
常量除不可以再次赋值外，和变量究竟有什么不同?
-
常量不会分配存储空间，无需像变量那样通过内存地址取值，因此无法获取内存地址。
-
常量值不能修改，变量可以
const NAME = "itzhuzhu"
func main() {
NAME = "haha" // 报错，不能修改
}
函数内外都有相同常量时采用就近原则
const (
USERNAME = "干将莫邪"
AGE = 88
ADDRESS = "中路草丛"
)
func main() {
const USERNAME, AGE, ADDRESS = "itzhuzhu", 24, "中国"
fmt.Println(USERNAME, AGE, ADDRESS) // 就近原则打印的是itzhuzhu
}
定义常量不使用不会报编译错误，不同作用域也可以定义相同常量
func main() {
const X = 123
fmt.Println("我是外面的：", &X)
const Y = 1.23 // 未使用不会引发编译错误
{
const X = 321 // 不同作用域定义同名常量
fmt.Println("我是里面的：", &X)
}
}
常量值也可以是某些编译器能直接计算结果的表达式，如unsafe.Sizeof、len、cap等
func main() {
const (
ptrSize = unsafe.Sizeof(uintptr(0)) // 函数返回操作数在内存中的字节大小
strSize = len("hello, world!")
)
fmt.Println(ptrSize)
fmt.Println(strSize)
}
在常量组中如不指定类型和初始化值，则与上一行非空常量的值相同
func main() {
const (
X uint16 = 120
Y // 与上一行x类型、右值相同
W = "abc"
Z // 与s类型、右值相同
)
fmt.Printf("%T, %v\n", Y, Y) // 输出类型和值
fmt.Printf("%T, %v\n", Z, Z)
}
打印结果
uint16, 120
string, abc
显示常量和隐式定义常量区别，这里没搞懂为什么隐式不会做强类型检查
func main() {
const x = 100 // 隐式无常量类型，值随便写
const y byte = x // 相当于const y byte = 100
const a int = 100 // 显式指定常量类型，编译器会做强类型検查
const b byte = a // 错误：无法将 'a' (类型 int) 用作类型 byt
const b byte = byte(a) // 只能通过强转
}
iota：
枚举就是将数据值一一列出来，枚举可以用来表示一些固定的值，枚举是常量组成的。在Go可以通过iota实现枚举的功能。
iota是Go语言的常量计数器，const出现时，会将iota初始化为0，const中每新增一行iota就会计数一次，递增默认数据类型为int
iota可以持续递增
const (
a = 1
b = 2
c = 3
)
上面代码使用iota可以简化为
const (
a = iota // 第一行 重置为0 a:0
b // 第二行 新增1行 b:1
c // 第三行 新增1行 c:2
)
自增默认类型为int，不过可显式指定常量类型
const (
a = iota // int iota = 0
b float32 = iota // float32 iota = 1
c // float32 iota = 2
)
fmt.Println(a, b, c)
fmt.Printf("%T\n%T\n%T\n", a, b, c)
_跳过当前常量值
const (
a = iota // 0
_ // 1
c // 2
d // 3
)
fmt.Println(a, c, d)
使用位移计算
const (
_ = iota // 0
KB = 1 << (10 * iota) // 1 << (10 * 1)
MB // 1 << (10 * 2)
GB // 1 << (10 * 3)
)
如果中断iota递增，必须再次遇到iota才会恢复按行递增，否则将沿用上一次取值
const (
a = 1 + iota // 第0行 重置为0 a = 1 + 0
b // 第1行 新增1行 b = 1 + 1
c // 第2行 新增1行 c = 1 + 2
d = 4 // 第3行 新增1行 d = 4
e // 第4行 新增1行 e = 4 与上一行常量右值表达式相同
f // 第5行 新增1行 f = 4 只要不遇到iota，就一直是上次赋值的值，就是4
g = iota // 第6行 重置为0 g = 6 这里遇到了iota，恢复iota自增，计数包括前面所有的常量
i // 第7行 新增1行 i = 7 接着g+1,如果再定义常量初始化，就还是和4一样循环
j // 第8行 新增1行 i = 8
)
func main() {
fmt.Println(a, b, c, d, e, f, g, i, j)
}
如果使用多个常量赋值的时候，后面的数据都会跟着第一行的格式走，直到下一个iota出现
const (
a, b = 1 + iota, 2 + iota // iota = 0 a = iota + 1 b = iota + 2 a = 1 ,b = 2
c, d // iota = 1 c = iota + 1 d = iota + 2 c = 2 ,d = 3
e, f // iota = 2 e = iota + 1 f = iota + 2 e = 3 ,f = 4
g, h = 3 + iota, 4 + iota // iota = 3 g = iota + 3 h = iota + 4 g = 6 ,h = 7
i, j // iota = 4 i = iota + 3 j = iota + 4 i = 7 ,j = 8
)
fmt.Println(a, b, c, d, e, f, g, h, i, j)
可以自定义类型来实现用途明确的枚举类型。但须注意，这并不能将取值限定在预定义的枚举常量值范围内。
func main() {
test(red)
test(10000000) // 错误：10000000超出color/byte类型取值范围。
x := 2
test(x) // 错误：无法将 'x' (类型 int) 用作类型 color
}
type color byte // 自定义类型
const (
black color = iota // 指定常量类型
red
blue
)
func test(c color) {
fmt.Println(c)
}