golang使用iota

最新推荐文章于 2024-09-09 16:30:19 发布

止语---

最新推荐文章于 2024-09-09 16:30:19 发布

阅读量1.4k

点赞数 1

分类专栏： go 文章标签： iota

本文链接：https://blog.csdn.net/rhx_qiuzhi/article/details/89069970

版权

go 专栏收录该内容

9 篇文章 0 订阅

订阅专栏

最近学习起了go语言，发现runoob上的入门写的较为简单，但是仍不是很理解，找了一些资料学习下。

iota是golang语言的常量计数器,只能在常量的表达式中使用；这里首先表明了iota的作用。

iota在const关键字出现时将被重置为0(const内部的第一行之前)，const中每新增一行常量声明将使iota计数一次(iota可理解为const语句块中的行索引)。使用iota能简化定义，主要用于定义枚举，而且很有用。

1、iota只能用于常量表达式

package main
import "fmt"

func main() {
    fmt.Println(iota)
}

# command-line-arguments
.\goplay.go:83:17: undefined: iota

错误: 进程退出代码 2.

2、每次const出现时，都会使得iota初始化为0

package main
import "fmt"

func main() {
	const a = iota //a = 0
	const (
		b = iota //b = 0
		c // c = 1 
	)
    fmt.Println(a,b,c)
}

0 0 1

成功: 进程退出代码 0.

3、自定义类型

自增长的常量如果顶一个为一个枚举类型，实现变量自增

package main
import "fmt"

func main() {
	const (
		Sun = iota //Sun = 0
		Mon // Mon = 1 
		Tue
		Wed
		Thu
		Fri
		Sat
	)
    fmt.Println(Sun,Mon,Tue,Wed,Thu,Fri,Sat)
}

0 1 2 3 4 5 6

成功: 进程退出代码 0.

4、中间插入一个值

package main
import "fmt"

func main() {
	const (
		Sun = iota //Sun = 0
		Mon // Mon = 1 
		Tue = 7
		Thu= iota   // 3
		Fri         //4
	)
    fmt.Println(Sun,Mon,Tue,Thu,Fri)
}

5、掩码表示

package main
import "fmt"

func main() {
    const(
    	IgEggs = 1 << iota          //1 << 0 whic is  00000001
		IgChocolate                 // 1 << 1 which is 00000010
		IgNuts                      // 1 << 2 which is 00000100 
        //IgStrawberries              // 1 << 3 which is 00001000 
        //IgShellfish                 // 1 << 4 which is 00010000 
    )
    fmt.Println(IgEggs,IgChocolate,IgNuts)
}

1 2 4

发现每次可以左移一位，因此对于定义数量级大有裨益

const (
    _           = iota                   // ignore first value by assigning to blank identifier
    KB ByteSize = 1 << (10 * iota) // 1 << (10*1)
    MB                                   // 1 << (10*2)
    GB                                   // 1 << (10*3)
    TB                                   // 1 << (10*4)
    PB                                   // 1 << (10*5)
    EB                                   // 1 << (10*6)
    ZB                                   // 1 << (10*7)
    YB                                   // 1 << (10*8)
)