• 在常量组中, 如果上一行常量有初始值,但是下一行没有初始值, 那么下一行的值就是上一行的值
• 定义的局部变量或者导入的包没有被使用, 那么编译器会报错,无法编译运行
• 但是定义的常量没有被使用,编译器不会报错, 可以编译运行

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)
}
0 1 2 ha ha 100 100 7 8

在 Golang 中，iota 是一个特殊的常量生成器，用于简化一系列相关常量的定义。它通常与 const 关键字一起使用。iota 的值在每个 const 声明块中从 0 开始，并且每次出现时会自动递增。

iota 的基本用法

iota 的基本用法是定义一组连续的常量。以下是一个简单的例子：

package main

import (
    "fmt"
)

const (
    A = iota // 0
    B        // 1
    C        // 2
)

func main() {
    fmt.Println(A) // 输出 0
    fmt.Println(B) // 输出 1
    fmt.Println(C) // 输出 2
}

在这个例子中，iota 从 0 开始，之后每行递增 1。因此，A、B 和 C 分别被赋值为 0、1 和 2。

使用 iota 定义位掩码

iota 也可以用于定义一组位掩码常量，适用于需要按位操作的场景：

package main

import (
    "fmt"
)

const (
    _  = iota             // 忽略第一个值（0）
    KB = 1 << (10 * iota) // 1 << 10 = 1024
    MB = 1 << (10 * iota) // 1 << 20 = 1048576
    GB = 1 << (10 * iota) // 1 << 30 = 1073741824
)

func main() {
    fmt.Println(KB) // 输出 1024
    fmt.Println(MB) // 输出 1048576
    fmt.Println(GB) // 输出 1073741824
}

在这个例子中，iota 用于生成按位移位的常量，用于表示字节单位（KB、MB、GB）。

重置 iota

每个 const 声明块中，iota 都会从 0 重新开始：

package main

import (
    "fmt"
)

const (
    A = iota // 0
    B        // 1
    C        // 2
)

const (
    D = iota // 0
    E        // 1
    F        // 2
)

func main() {
    fmt.Println(A, B, C) // 输出 0 1 2
    fmt.Println(D, E, F) // 输出 0 1 2
}

在这个例子中，有两个 const 声明块，每个块中的 iota 都从 0 开始。

使用 iota 进行复杂常量定义

iota 可以结合表达式使用，生成复杂的常量值：

package main

import (
    "fmt"
)

const (
    _  = iota             // 忽略第一个值（0）
    ONE
    TWO
    FOUR
)

const (
    _, KB, MB, GB = iota, 1 << (10 * iota), 1 << (10 * (iota+1)), 1 << (10 * (iota+2))
)

func main() {
    fmt.Println(ONE, TWO, FOUR) // 输出 1 2 4
    fmt.Println(KB, MB, GB)     // 输出 1024 1048576 1073741824
}

在这个例子中，第一个 const 块生成了一组简单的递增常量，第二个 const 块生成了一组按位移位的常量，并利用 iota 进行更复杂的计算。