iota常量计数器

iota是go语言中的常量计数器，只能在常量表达式中用。iota在const关键字出现时重置为0，然后const中每新增一条数据，iota计数一次

关键字实现枚举

package main

import "fmt"

const(
	a = iota
	b
	c
	d,e,f = iota , iota , iota
	g = iota
	h = "h"
	i = iota
	j = iota
)
const z = iota
func main() {
	fmt.Println(a,b,c,d,e,f,g,h,i,j)
}

首先，定义一个常量 a = iota ，因为 const 出现了，iota 默认为 0 ，所以 a = 0.
依次递增 b = 1 ，c = 2 ，d e f 为同一级，递增到这里时，iota值跟新为了3， 所以
d e f 都等于 3 ，接下来继续递增 g = 4 ，原本 h 应该等于 5 但是定义了 h = “h” ，
所以这里 h 是 5 ，但会显示 “h” ，依然算一位，接下来 i = 6 ，j = 7 。

自定义实现枚举

package main

import "fmt"

type kaigll int

const(
	tyk kaigll = iota
	tyka
	tykb
	tykc
	tykd
)

func main () {
	fmt.Println("tyk = ",tyk)
	fmt.Println("tyka = ",tyka)
	fmt.Println("tykb = ",tykb)
	fmt.Println("tykc = ",tykc)
	fmt.Println("tykd = ",tykd)
}

自定义一个变量 kaigll ，类型是 int ，因为关键字 const 的出现，iota 将重置为 0 ，
所以 tyk = 0 ，依次往下递增，tyka = 1 ，tykb = 2 ，tykc = 3 ， tykd = 4 。

可跳过枚举

package main

import "fmt"

type kaigl int

const(
	typk kaigl = iota
	typka
	typkb
	_
	_
	typkc
	typkd
)
func main() {
	fmt.Println("typk = ",typk)
	fmt.Println("typka = ",typka)
	fmt.Println("typab = ",typkb)
	fmt.Println("typkc = ",typkc)
	fmt.Println("typkd = ",typkd)
}

这个和上面的那个差不多，iota 遇见 const 重置为 0 ，再赋给提前声明好的自定义变量上，
接下来依次递增，里面那个符号是下划线，起着占位符的作用，虽然没有被赋值，但是同样
也占着那个位置应有的值，所以 typk = 0 ，typka = 1 ，typkb = 2 ，typkc = 5 ，typkd = 6

掩码表达式

package main

import "fmt"

type kh666 int

const(
	kh kh666 = 1 << iota
	kha
	khb
	khc
	khd
)

const(
	khe kh666 = 16 >> iota
	khf
	khg
	khh
	khi
)

func main() {
	fmt.Println("NO.1:",kh)
	fmt.Println("NO.2:",kha)
	fmt.Println("NO.3:",khb)
	fmt.Println("NO.4:",khc)
	fmt.Println("NO.5:",khd)
	fmt.Println("NO.6:",khe)
	fmt.Println("NO.7:",khf)
	fmt.Println("NO.8:",khg)
	fmt.Println("NO.9:",khh)
	fmt.Println("NO.10:",khi)
}

与上同理，将 “1” 转换为二进制为：“0001” ，若将 “0001” 向右移 “0” 位 ，结果还为 “0001”
转换回来，还为 “1” ，那么以此类推，kha 是将 “0001” 向左移动 “1”位，那么就变成了 “0010” 
转换回来，成为 “2” ，khb = 0100 = 4 ，khc = 1000 = 8 ，khd = 0001 0000 = 16 。
接下来这些都是向左移的，上面是升序，这就是降序了。

定义数量级

package main

import "fmt"

type kaihuang int

const(
	_ kaihuang = iota
	KB kaihuang = 1 << ( 10 * iota)
	MB
	GB
	TB
	PB
	EB
)

func main() {
	fmt.Println("KB:",KB)
	fmt.Println("MB:",MB)
	fmt.Println("GB:",GB)
	fmt.Println("TB:",TB)
	fmt.Println("PB:",PB)
	fmt.Println("EB:",EB)
}

这个和上面的掩码表达式差不多，这个是更高级的运算，KB kaihuang = 1 << ( 10 * iota ) 这
个的意思就是将 0001 中的 1 向左移动 10 * 1 位，最终结果就是 0100 0000 0000 转换过来就
是 1024 ，下面的同理，我就不一一敲了。

一行多定义

package main

import "fmt"

const(
	Jerry , Marry = iota + 1 , iota + 2
	play , stady
	jump , run
)
func main() {
	fmt.Println("Jerry:",Jerry)
	fmt.Println("Marry:",Marry)
	fmt.Println("play:",play)
	fmt.Println("stady:",stady)
	fmt.Println("jump:",jump)
	fmt.Println("run:",run)
}

这个多赋值其实也很好理解一个变量对应一个值，那么多个变量依次往下对应多个值，
Jerry对应iota+1也就是0+1，Marry对应iota+2，也就是0+2，接着往下piay对应iota+1
这时的iota变为了1，也就变成了1+1，对应的stady也就成了1+2，往下推就更简单了。

其实这些都不难，主要是多想，多练，多探索！