Go 学习笔记（7）— 常量定义、常量使用、枚举用法、iota 常量、不设置初始值常量

1. 常量定义及分类

1.1 定义

常量是指在程序运行时，不会被修改的量。

常量中的数据类型只可以是布尔型、数字型（整数型、浮点型和复数）和字符串型。

常量的定义格式：

const identifier [type] = value

可以省略类型说明符 [type]，因为编译器可以根据变量的值来推断其类型。

• 显式类型定义

const b string = "abc"

• 隐式类型定义

const b = "abc"

多个相同类型的声明可以简写为：

const name1, name2 = value1, value2

1.2 分类

2. 常量使用

package main

import "fmt"

func main() {
   const LENGTH int = 10
   const WIDTH int = 5   
   var area int
   const a, b, c = 1, false, "str" //多重赋值

   area = LENGTH * WIDTH
   fmt.Printf("面积为 : %d", area)
   println()
   println(a, b, c)   
}

输出结果为：

面积为 : 50
1 false str

3. 常量作为枚举

const (
    Unknown = 0
    Female = 1
    Male = 2
)

数字 0、1 和 2 分别代表未知性别、女性和男性。

常量可以用 len(), cap(), unsafe.Sizeof() 函数计算表达式的值。常量表达式中，函数必须是内置函数，否则编译不过：

在包一级声明语句声明的名字可在整个包对应的每个源文件中访问，而不是仅仅在其声明语句所在的源文件中访问。如下代码中的 a 、 b 、 c 。

package main

import "unsafe"
const (
    a = "abc"
    b = len(a)
    c = unsafe.Sizeof(a)
)

func main(){
    println(a, b, c)
}

运行结果为：

abc 3 16

注意：字符串类型在 go 里是个结构, 包含指向底层数组的指针和长度，这两部分每部分都是 8 个字节，所以字符串类型大小为 16 个字节。

4. iota 常量

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

iota 在 const 关键字出现时将被重置为 0 (const 内部的第一行之前)，const 中每新增一行常量声明将使iota 计数一次 ( iota 可理解为 const 语句块中的行索引)。

iota 可以被用作枚举值：

const (
    a = iota
    b = iota
    c = iota
)

第一个 iota 等于 0，每当 iota 在新的一行被使用时，它的值都会自动加 1 ；所以 a=0, b=1, c=2 可以简写为如下形式：

const (
    a = iota
    b
    c
)

使用示例

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

4.1 const 作用域只在当前的括号范围内

iota 的含义是初始化一个计数器，这个计数器的影响范围只能是 const 后括号作用域范围内的常量。

package main

import (
    "fmt"
)

func main() {
    const (
        a = iota
        b
        c
        d
        e
    )
    const (
        A = iota
        B
        C
        D
    )
    fmt.Println(a, b, c, d, e)
    fmt.Println(A, B, C)
}

输出结果如下：

0 1 2 3 4
0 1 2

iota 把初始值 0 赋给 a 后，自增 1，此时 iota 等于1，随后将 1 赋值给常量 b，赋值完成后，iota 又自增 1，此时 iota 等于2，这个自增过程，只会出现在 const 后括号范围内，超过这个括号作为域。再次使用 iota 时，其初始值为 0。从输出结果可知，常量 A 从 0 开始，可以证实这个观点。

4.2 const 作用域内，iota 自增 1

package main

import (
    "fmt"
)

func main() {
    const (
        NUM1 = iota
        NUM2
        NUM3 = iota
        NUM4
        NUM5
    )
    const (
        A = iota
        B
        C
        D
    )
    fmt.Println(NUM1, NUM2, NUM3, NUM4, NUM5)
    fmt.Println(A, B, C)
}

输出信息是：

0 1 2 3 4
0 1 2

4.3 iota 不会自动初始化括号作用域内 iota 前边的常量

// 错误示例代码
func main() {
    const (
        a 
        b
        c = iota
        d
        e
    )
    fmt.Println(a, b, c, d, e)
}

编译时产生的错误信息：
./hello.go:9:9: missing value in const declaration
./hello.go:10:9: missing value in const declaration
./hello.go:15:17: undefined: a
./hello.go:15:20: undefined: b

从上边的示例代码中可以得知，iota 并不会给括号作用域范围内使用 iota 赋值的那个常量之前的常量赋值，只会给括号作用域内使用 iota 初始化的那个常量后边的所有常量自增 1 后赋值。

4.4 设定从某个特定初始值开始

iota 默认初始值为 0，我们可以定义的常量初始值从 10 开始，代码如下：

func main() {
    const (
        a = 10 + iota
        b
        c
        d
        e
    )
    fmt.Println(a, b, c, d, e)
}

输出结果：

10 11 12 13 14

当使用带 iota 的表达式初始化常量时，括号作用域内，后边的常量在初始化时，也会使用这个表达式进行初始化。相当于初始化表达式是：10+1，b 初始化的值是：10+2，以此类推。整个初始化过程中，依然是 iota 在自增 1。

4.5 const 常量带有多个 iota 表达式

func main() {
    const (
        a = iota + 10
        b = iota
        c = iota + 5
        d
        e
    )
    fmt.Println(a, b, c, d, e)
}

输出信息是：

10 1 7 8 9

从上边的输出信息可以得知，在使用表达式初始化常量时，会使用离被初始化常量前边最近的那个表达式。如初始化 c 时，使用的是 2+5，初始化 b 时，使用的是 iota，此时的 iota 值为 1。

5. 定义常量组不设置初始值

在定义常量组时，如果不提供初始值，则表示将使用上行的表达式值。

package main

import "fmt"

const (
    a = 1
    b
    c
    d
)

func main() {
    fmt.Println(a)
    // b、c、d没有初始化，使用上一行(即a)的值
    fmt.Println(b)   // 输出1
    fmt.Println(c)   // 输出1
    fmt.Println(d)   // 输出1
}