【go从入门到精通】常量和枚举详解

作者简介：
        高科，先后在 IBM PlatformComputing从事网格计算，淘米网，网易从事游戏服务器开发，拥有丰富的C++，go等语言开发经验，mysql，mongo，redis等数据库，设计模式和网络库开发经验，对战棋类，回合制，moba类页游，手游有丰富的架构设计和开发经验。 （谢谢你的关注）
——————————————————————————————————————————

常量

常量是指程序在执行过程中不能改变的固定值。

常量可以是任何基本数据类型，例如整型常量、浮点常量、字符常量或字符串文字。还有计数常量。

常量的处理方式与普通变量相同，只是其值在定义后不能更改而已。

诸如 pi (22/7)、光速 (299,792,458 m/s) 之类的数据如果被声明为常量而不是变量，就是很好的数据示例，因为它们的值是固定的并且不会改变。

在go语言里，常量使用关键字 const 定义，用于存储不会改变的数据。常量不能被重新赋予任何值。 存储在常量中的数据类型只可以是布尔型、数字型（整数型、浮点型和复数）和字符串型。 常量的定义格式：const identifier [type] = value，例如：

const MAXNETPACKETSIZE  2048000

在 Go 语言中，你可以省略类型说明符 [type]，因为编译器可以根据变量（常量）的值来推断其类型。

显式类型定义： const b string = "abc"
隐式类型定义： const b = "abc"

Go的常量定义可以限定常量类型，但不是必需的。如果定义常量时没有指定类型，那么它与字面常量一样，是无类型（untyped）常量。一个没有指定类型的常量被使用时，会根据其使用环境而推断出它所需要具备的类型。换句话说，未定义类型的常量会在必要时刻根据上下文来获得相关类型。

字面常量（literal），是指程序中硬编码的常量，如：-12。它们的值即为它们本身，是无法被改变的。

常量的值必须是能够在编译时就能够确定的；你可以在其赋值表达式中涉及计算过程，但是所有用于计算的值必须在编译期间就能获得。

iota

Go语言预定义了这些常量： true、 false和 iota。布尔常量只包含两个值：true 和 false。iota比较特殊，可以被认为是一个可被编译器修改的常量，在每一个const关键字出现时被重置为0，然后在下一个const出现之前，每出现一次iota，其所代表的数字会自动增1，iota 的初始值为 0。我们可以使用 iota 来定义一系列相关的枚举常量，如下所示：

const (
    Apple = iota
    Banana
    Cherry
)

在上面的例子中，Apple 的值为 0，Banana 的值为 1，Cherry 的值为 2。可以看到，使用 iota 可以简化常量的定义，而不需要显式地指定每个常量的值。

数值常量（Numeric constants）包括整数，浮点数以及复数常量。数值常量有一些微妙之处。

package main
 
import (
    "fmt"
)
 
func main() {
    const a = 5
    var intVar int = a
    var int32Var int32 = a
    var float64Var float64 = a
    var complex64Var complex64 = a
    fmt.Println("intVar", intVar, "\nint32Var", int32Var, "\nfloat64Var", float64Var, "\ncomplex64Var", complex64Var)
}

程序输出
intVar 5 
int32Var 5 
float64Var 5 
complex64Var (5+0i)

在这个程序中，a 的值是 5 并且 a 在语法上是泛化的（它既可以表示浮点数 5.0，也可以表示整数 5，甚至可以表示没有虚部的复数 5 + 0i），因此 a 可以赋值给任何与之类型兼容的变量。像 a 这种数值常量的默认类型可以想象成是通过上下文动态生成的。

当然，常量之所以为常量就是恒定不变的量，因此我们无法在程序运行过程中修改它的值；如果你在代码中试图修改常量的值则会引发编译错误。同时，在const 定义中，对常量名没有强制要求全部大写，不过我们一般都会全部字母大写，以便阅读。

iota 表达式的应用

除了基本的使用方式，iota 还可以与位操作符和位掩码一起使用，来进行更加复杂的枚举定义。例如，可以使用位操作符 << 来进行位左移操作，如下所示：

const (
    Readable = 1 << iota // 1 << 0，表示可读
    Writable            // 1 << 1，表示可写
    Executable          // 1 << 2，表示可执行
)

在上面的例子中，我们定义了三个枚举常量，它们的值分别为 1、2 和 4。这种方式可以方便地使用位运算进行判断，例如：

var permissions int = Readable | Writable // 可读可写
var isExecutable bool = permissions&Executable == Executable // 判断是否可执行

注意事项

在使用 iota 时，我们需要注意以下几个事项：

1. iota 的递增规则：iota 在每个 const 声明中都会自动递增，而不是在每个 const block 中递增。如果在常量定义中跳过某个值，iota 会继续递增，不会受到影响。

2. iota 的作用域：iota 在每个 const 声明中具有独立的作用域，它只在当前 const 声明中有效。当 const 声明结束后，iota 的值会被重置为 0。

3. iota 的数据类型：iota 的数据类型是 int，它的范围与 int 类型相同。我们可以根据实际的需要来决定使用 int8、int16、int32 还是 int64。4. 使用 iota 时的注意事项：在定义常量时，不要滥用 iota，尽量避免产生混淆的代码。当我们需要定义不同的枚举集合时，可以使用多个 const block，每个 block 中使用独立的 iota。

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

a, b, c分别为0, 8, 8，新的常量b声明后，iota 不再向下赋值，后面常量如果没有赋值，则继承上一个常量值。

可以简单理解为在一个const块中，每换一行定义个常量，iota 都会自动+1。

枚举

        enum枚举类在日常工作中非常常见，枚举将相关常量分组为一种类型。

枚举示例：

• 时区：EST、CST…
• T恤尺寸：小号、中号、大号
• 服务器状态：未知、正在运行、已停止、已恢复

为什么我们需要枚举？

• 枚举通过为值提供描述性名称而不是使用原始整数或字符串常量，使代码更具可读性。这增强了代码清晰度，并使其他开发人员更容易理解和维护代码库。
• 枚举提供编译时检查，这有助于在开发过程的早期捕获错误。这可以防止将无效或意外的值分配给变量，从而减少运行时错误的可能性。
• 通过将变量可以保存的可能值限制为预定义的集合，枚举有助于防止由不正确或意外的值引起的逻辑错误。

虽然 Java 和 C++ 等语言提供了对枚举的本机支持，Go 开发人员没有使用专用的枚举类型，但 Go 采用了不同的方法-------使用常量或带有 iota 的自定义类型来模拟类似枚举的行为。

用常量定义枚举

常量是在 Go 中定义枚举的一种简单方法。让我们考虑一个基本示例，其中我们定义了代表一周中不同日期的枚举常量。

package main 
 
import  "fmt" 
 
const ( 
    SUNDAY = "星期日"
     MONDAY = "星期一"     
     TUESDAY = "星期二"
     WEDNESDAY = "星期三"
     THURSDAY = "星期四"
     FRIDAY = "星期五"
     SATURDAY = "星期六"
 ) 
 
func  main () { 
    day := MONDAY 
    fmt.Println( "今天是 " , day) // "今天是星期一"
 }