Go的黑魔法：iota

描述

iota，特殊常量，可以认为是一个可以被编译器修改的常量。

在每一个const关键字出现时，被重置为0，然后再下一个const出现之前，每出现一次iota，其所代表的数字会自动增加1。

例子

1.在每一个const关键字出现时，被重置为0，然后再下一个const出现之前，每出现一次iota，其所代表的数字会自动增加1。

const(
	a0 = iota
	a1 = iota
	a2 = iota
)

func main() {
	fmt.Println("a0 =",a0)
	fmt.Println("a1 =",a1)
	fmt.Println("a2 =",a2)
}

# output
a0 = 0
a1 = 1
a2 = 2

2.在每一个const关键字出现时，被重置为0

func main() {
    const i = iota;
	const j = iota;
	fmt.Println("i = ",i)
	fmt.Println("j = ",j)
}
# output
i =  0
j =  0

3. 只能在常量表达式中使用

func main() {
	const i =iota;
	fmt.Println("i =",i)
	fmt.Println("iota = ",iota)
}
# output
./main.go:8:24: undefined: iota
# 注释后
i = 0

4. 当在多个常量表达式且赋值过程中存在独立值时

package main

import "fmt"

func main() {
    const (
            a = iota   //0
            b          //1
            c          //2
            d = "ha"   //独立值，iota += 1
            e          //"ha"   iota += 1
            f = 100    //iota +=1
            g          //100  iota +=1
            h = iota   //7,恢复计数
            i          //8
    )
    fmt.Println(a,b,c,d,e,f,g,h,i)
}

# output
0 1 2 ha ha 100 100 7 8

5. 当涉及到位运算时的iota

package main

import "fmt"
const (
    i=1<<iota
    j=3<<iota
    k
    l
)

func main() {
    fmt.Println("i=",i)
    fmt.Println("j=",j)
    fmt.Println("k=",k)
    fmt.Println("l=",l)
}

#output
i= 1
j= 6
k= 12
l= 24

6. iota不能被手动赋值，否则iota将成为常量

const (
	iota = 8
	i = iota
	j = iota

)
func main() {
	fmt.Println("i=",i)
	fmt.Println("j=",j)
}

# output
i= 8
j= 8

左移运算符"<<"是双目运算符。左移n位就是乘以2的n次方。 其功能把"<<"左边的运算数的各二进位全部左移若干位，由"<<"右边的数指定移动的位数，高位丢弃，低位补0。

总结：

iota只能用于const定义中，只有出现新的const时，iota才被重定义为0。
iota是一个从0开始的行数索引器,无论该行是否使用到iota,iota都会自增1。
iota初始值只能为0，不能被手动赋值，否则将会被当做常量处理。