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 mainimport "fmt"func main() {const LENGTH int = 10const WIDTH int = 5   var area intconst a, b, c = 1, false, "str" //多重赋值area = LENGTH * WIDTHfmt.Printf("面积为 : %d", area)println()println(a, b, c)
}

输出结果为：

面积为 : 50
1 false str

3. 常量作为枚举

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

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

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

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

package mainimport "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 = iotab = iotac = iota
)

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

const (a = iotabc
)

使用示例

package mainimport "fmt"func main() {const (a = iota   //0b          //1c          //2d = "ha"   //独立值，iota += 1e          //"ha"   iota += 1f = 100    //iota +=1g          //100  iota +=1h = 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 mainimport ("fmt"
)func main() {const (a = iotabcde)const (A = iotaBCD)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 mainimport ("fmt"
)func main() {const (NUM1 = iotaNUM2NUM3 = iotaNUM4NUM5)const (A = iotaBCD)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 bc = iotade)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 + iotabcde)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 + 10b = iotac = iota + 5de)fmt.Println(a, b, c, d, e)
}

输出信息是：

10 1 7 8 9

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

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

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

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