在实际开发中,我们经常需要定义一组按顺序递增的编号,比如星期几或者订单状态。如果按普通方式定义常量,通常得像下面这样手动逐个赋值:
const (
Sunday = 0
Monday = 1
Tuesday = 2
)当常量只有两三个时,手动写数字还不算麻烦。但如果有十几个状态码,一旦中间要插入新状态或者调整顺序,后面的数字全都得手动重改一遍,非常容易出错。为了解决这个问题,Go 语言提供了 iota 常量计数器,用来自动生成按规律递增的编号。
iota 的计数规则
iota 源自希腊字母表中的第 9 个字母(ι),在英文中表示 “极微小的一点”。Go 语言借用这个词作为特殊计数器,你可以直接把 iota 看成 const 小括号块内部的计数器(初始从 0 开始计数),如下图所示。

语法:
const (
常量1 = iota
常量2
常量3
)说明:
想要弄清楚 iota 的变化规律,小伙伴们只需要把握以下 3 条规则:
- 遇到 const 重置为 0:每当代码中出现
const关键字时,iota的初始值都会自动重置为 0。 - 每新增一行常量声明加 1:在
const小括号块内部,第 1 行常量声明的iota为 0;之后每往下增加一行常量声明,iota就自动加 1(第 2 行是 1、第 3 行是 2,以此类推)。中间的空行和纯注释行不参与计数。 - 省略赋值自动沿用:结合
const块 “省略赋值自动沿用上一行表达式” 的规则,我们只需要在第 1 行写上= iota,后面的常量不用写赋值,就会自动拿到递增的编号。
注意: iota 只能在 const 常量声明中使用,不能用于 var 变量声明或普通函数代码中,否则编译器会直接报错。
iota 常用示例
搞清楚上面 3 条规则之后,我们通过几个由浅入深的例子,看看 iota 在实际代码中怎么使用。
示例 1:生成连续递增常量
package main
import "fmt"
func main() {
const (
A = iota // 0
B // 1
C // 2
)
fmt.Println(A, B, C)
const D = iota // 遇到新 const,重置为 0
fmt.Println(D)
}运行结果如下。
0 1 2
0分析:
在第 1 个 const 块中,我们只给第 1 行的 A 写了 = iota,此时 iota 为 0。后面的 B 和 C 省略了赋值,会自动沿用上一行的 = iota,并且每往下走一行 iota 就加 1。对于这个例子来说,第 1 个 const 块等价于下面代码。
const (
A = iota // iota 为 0
B = iota // iota 为 1
C = iota // iota 为 2
)接着往下看,const D = iota 开启了一个新的 const 关键字。只要遇到新的 const,iota 就会重新归零,因此打印 D 的结果又是 0。
在实际开发中,有时我们希望编号从 1 开始算,或者按 10、20、30 这样的固定倍数递增。这时只需要让 iota 配合简单的运算符一起计算就可以了。
示例 2:iota 结合算术运算
package main
import "fmt"
func main() {
const (
Jan = iota + 1 // 0 + 1 = 1
Feb // 1 + 1 = 2
Mar // 2 + 1 = 3
)
fmt.Println(Jan, Feb, Mar)
const (
Level1 = (iota + 1) * 10 // (0 + 1) * 10 = 10
Level2 // (1 + 1) * 10 = 20
Level3 // (2 + 1) * 10 = 30
)
fmt.Println(Level1, Level2, Level3)
}运行结果如下。
1 2 3
10 20 30分析:
Jan = iota + 1 表示在当前 iota 的基础上加 1。由于后面的 Feb 和 Mar 省略了赋值,它们会自动沿用上一行的 iota + 1 算式。对于第 1 个常量块来说,上面代码等价于下面代码。
const (
Jan = iota + 1 // 0 + 1 = 1
Feb = iota + 1 // 1 + 1 = 2
Mar = iota + 1 // 2 + 1 = 3
)随着每一行的 iota 依次变成 0、1、2,计算出来的结果自然就是 1、2、3。同理,在第 2 个常量块中,每一行都会自动沿用 (iota + 1) * 10 这个表达式,算出来的结果就是 10、20、30。
如果在一组连续递增的编号中,某个数字是我们不需要的、想要直接跳过它,就可以借用前面学过的匿名变量 _ 来占一行位置。
示例 3:使用 _ 跳过某个值
package main
import "fmt"
func main() {
const (
C1 = iota // 0
_ // 占第 2 行,跳过 1
C3 // 2
C4 // 3
)
fmt.Println(C1, C3, C4)
}运行结果如下。
0 2 3分析:
第 1 行的 C1 拿到的 iota 是 0。到了第 2 行,我们使用下划线 _ 占了一行位置。虽然 iota 照常加 1 变成了 1,但赋给 _ 之后这个 1 就被直接丢弃了。
接着往下走到第 3 行的 C3 时,iota 继续加 1 变成 2,第 4 行的 C4 则变成 3。这样一来,最终打印的结果就跳过了中间的 1,输出 0 2 3。
如果在 const 块的中间某一行不使用 iota,而是中途赋了一个固定数值,后面的编号又会怎么计算呢?我们通过下面这个例子来验证一下。
示例 4:iota 中途插队赋值
package main
import "fmt"
func main() {
const (
N1 = iota // 0
N2 = 100 // 中途赋固定值 100
N3 = iota // 恢复计数,值为 2
N4 // 沿用 = iota,值为 3
)
fmt.Println(N1, N2, N3, N4)
}运行结果如下。
0 100 2 3分析:
从运行结果可以看出,N3 的值是 2 而不是 1。为什么会这样呢?因为不管某一行有没有用到 iota,只要在 const 块中多占了一行常量声明,底层的 iota 就会照常加 1:
- 第 1 行(N1 = iota):处于第 1 行,对应的
iota为 0,所以N1的值是 0。 - 第 2 行(N2 = 100):虽然直接赋了固定值 100,但它依然占用了第 2 行,此时底层的
iota已经加 1 变成了 1。 - 第 3 行(N3 = iota):重新使用
iota,此时处于第 3 行,对应的iota再加 1 变成了 2,所以N3的值直接是 2。 - 第 4 行(N4):省略赋值,自动沿用上一行的
= iota。此时处于第 4 行,对应的iota为 3,因此N4的值是 3。
这里要特别留意一点:当 N2 = 100 中途赋了固定值之后,如果下一行的 N3 想要恢复按 iota 计数,必须显式写出 N3 = iota。如果 N3 什么都不写,它会继续沿用上一行 N2 的 100。
按照 “每新增一行常量声明加 1” 这条规律,还有两个细节很好理解:如果同一行内同时定义了多个常量,它们拿到的 iota 值是相同的;而中间穿插的空行和纯注释行不算常量声明,不会让 iota 加 1。看下面这段代码就清楚了:
const (
X1, X2 = iota, iota + 10 // 第 1 行:X1=0, X2=10
// 空行和纯注释行不计数
Y1, Y2 // 第 2 行:Y1=1, Y2=11
)提示: 在实际开发中,大多数场景下我们只是使用 iota 从 0 或 1 开始生成连续编号。后面学完位运算后,我们也常用它来定义 KB、MB 等文件大小单位。像中途插队赋值和同行多定义的写法,小伙伴们看懂按行递增的原理即可,平时写代码尽量保持简单直观。
