Golang_枚举(iota)的使用

枚举就是将数据值一一列出来，枚举可以用来表示一些固定的值，枚举是常量组成的。在Go可以通过iota实现枚举的功能。

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
	)

_跳过值

	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一样循环
)
fmt.Println(a, b, c, d, e, f, g, i)

如果使用多个常量赋值的时候，后面的数据都会跟着第一行的格式走，直到下一个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(100) // 100并未超出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)
}