Go 语言常量

常量是一个简单值的标识符，在程序运行时，不会被修改的量。

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

常量的定义格式：

const identifier [type] = value

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

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

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

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

const c_name1, c_name2 = value1, value2

以下实例演示了常量的应用：

大写字母表示常量

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

常量还可以用作枚举：

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

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

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

package main  
  
import "unsafe"  
const (  
    a = "abc"  
    b = len(a)  
    c = unsafe.Sizeof(a)  
)  
  
func main(){  
    println(a, b, c)  
}

以上实例运行结果为：

abc 3 16

---

iota

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

iota 在 ==const关键字出现时将被重置为 0(const 内部的第一行之前)==

iota 是一个常量生成器，它会自动递增值，主要用于定义枚举常量。每遇到一个 const 关键字，iota 的值就会重置为 0，然后每增加一行常量定义，iota 的值就会自动加 1

==使用 iota 定义的常量组中，如果后续常量不显式赋值，它们会自动采用上一行的表达式，并根据 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 开始，定义了常量 A = 0，B = 1，C = 2。每一行会自动递增 iota 的值。

定义多个枚举值

可以利用 iota 为多个枚举值赋值。特别适合在编写状态或类型的常量集时使用。

package main

import "fmt"

const (
    Read = iota   // 0
    Write         // 1
    Execute       // 2
)

func main() {
    fmt.Println(Read)   // 输出 0
    fmt.Println(Write)  // 输出 1
    fmt.Println(Execute) // 输出 2
}

自定义步长或位运算

可以通过结合 iota 和表达式来生成自定义值，例如定义位标志。

package main

import "fmt"

const (
    FlagNone  = 1 << iota // 1 << 0 == 1
    FlagRead              // 1 << 1 == 2
    FlagWrite             // 1 << 2 == 4
    FlagExecute           // 1 << 3 == 8
)

func main() {
    fmt.Println(FlagNone)   // 输出 1
    fmt.Println(FlagRead)   // 输出 2
    fmt.Println(FlagWrite)  // 输出 4
    fmt.Println(FlagExecute) // 输出 8
}

在这个例子中，1 << iota 生成了一系列按位递增的常量，这种用法特别适合定义权限或标志位。

多个 iota 组

每个 const 关键字都会重置 iota 的计数，所以可以在不同的常量组中使用 iota。

package main

import "fmt"

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

const (
    X = iota // 0
    Y        // 1
    Z        // 2
)

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

跳过值

可以使用 _ 跳过某个 iota 值。

package main

import "fmt"

const (
    A = iota // 0
    _        // 跳过 1
    C        // 2
)

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