Golang 常量定义不仅仅是简单的数值绑定，更可以通过
iota实现枚举，让代码更具可读性和维护性。
iota可以看作是一个编译器管理的计数器，在
const声明块中，每定义一个常量，
iota的值就会自动加 1。
Golang 中定义常量使用关键字
const。常量的值在编译时就已经确定，因此必须是编译器可以计算出来的表达式。
解决方案：
package main
import "fmt"
const (
StatusOK = 200
StatusError = 500
Pi = 3.14159
)
func main() {
fmt.Println("StatusOK:", StatusOK)
fmt.Println("StatusError:", StatusError)
fmt.Println("Pi:", Pi)
}iota 枚举实现原理
立即学习“go语言免费学习笔记（深入）”；
iota是 Golang 中一个特殊的常量生成器。它从 0 开始，在每个
const声明块中，每遇到一个常量声明，其值自动加 1。
package main
import "fmt"
const (
A = iota // A = 0
B // B = 1
C // C = 2
)
func main() {
fmt.Println("A:", A)
fmt.Println("B:", B)
fmt.Println("C:", C)
}如果某些常量需要跳过某些值，可以显式地给
iota赋值。
package main
import "fmt"
const (
D = iota // D = 0
_ // 跳过 1
E // E = 2
F = iota // F = 3
G // G = 4
)
func main() {
fmt.Println("D:", D)
fmt.Println("E:", E)
fmt.Println("F:", F)
fmt.Println("G:", G)
}如何自定义枚举的起始值？
iota总是从 0 开始计数。如果需要自定义起始值，可以在第一个常量声明时显式赋值。
package main
import "fmt"
const (
H = iota + 10 // H = 10
I // I = 11
J // J = 12
)
func main() {
fmt.Println("H:", H)
fmt.Println("I:", I)
fmt.Println("J:", J)
}iota的一个常见应用场景是定义位掩码。
package main
import "fmt"
const (
FlagA = 1 << iota // FlagA = 1
FlagB // FlagB = 2
FlagC // FlagC = 4
)
func main() {
fmt.Println("FlagA:", FlagA)
fmt.Println("FlagB:", FlagB)
fmt.Println("FlagC:", FlagC)
}常量可以使用表达式进行赋值，但是表达式必须是编译时可求值的。
package main
import "fmt"
const (
Size = 10
ArraySize = Size * 2 // ArraySize = 20
)
func main() {
fmt.Println("ArraySize:", ArraySize)
}常量一旦定义后，其值就不能被修改。这与变量不同，变量的值可以在程序运行期间被改变。 试图修改常量的值会导致编译错误。
package main
func main() {
const Immutable = 10
// Immutable = 20 // 编译错误: cannot assign to Immutable
}无类型常量和类型常量有什么区别？
Golang 中的常量可以分为无类型常量和类型常量。无类型常量没有明确的类型，可以根据使用的上下文自动推断类型。类型常量则有明确的类型声明。
package main
import "fmt"
const (
UntypedInt = 10 // 无类型整型常量
TypedInt int = 10 // 类型整型常量
UntypedFloat = 3.14 // 无类型浮点型常量
TypedFloat float64 = 3.14 // 类型浮点型常量
UntypedString = "hello" // 无类型字符串常量
TypedString string = "hello" // 类型字符串常量
)
func main() {
fmt.Printf("UntypedInt 类型: %T, 值: %v\n", UntypedInt, UntypedInt)
fmt.Printf("TypedInt 类型: %T, 值: %v\n", TypedInt, TypedInt)
fmt.Printf("UntypedFloat 类型: %T, 值: %v\n", UntypedFloat, UntypedFloat)
fmt.Printf("TypedFloat 类型: %T, 值: %v\n", TypedFloat, TypedFloat)
fmt.Printf("UntypedString 类型: %T, 值: %v\n", UntypedString, UntypedString)
fmt.Printf("TypedString 类型: %T, 值: %v\n", TypedString, TypedString)
// 无类型常量可以赋值给任何兼容的类型
var i int = UntypedInt
var f float64 = UntypedInt
fmt.Println("i:", i)
fmt.Println("f:", f)
}无类型常量的优势在于其灵活性，可以避免不必要的类型转换。类型常量则可以提供更强的类型安全。
iota在复杂的枚举中如何使用？
iota可以结合位运算，实现更复杂的枚举类型，例如权限控制。
package main
import "fmt"
const (
Read = 1 << iota // Read = 1
Write // Write = 2
Execute // Execute = 4
All = Read | Write | Execute // All = 7
)
func main() {
fmt.Println("Read:", Read)
fmt.Println("Write:", Write)
fmt.Println("Execute:", Execute)
fmt.Println("All:", All)
// 检查是否具有某个权限
permissions := Read | Write
fmt.Println("Has Read permission:", (permissions & Read) != 0)
fmt.Println("Has Execute permission:", (permissions & Execute) != 0)
}在实际项目中，可以使用字符串常量来关联枚举值，提高代码的可读性。
package main
import "fmt"
const (
Red Color = iota // Red = 0
Green // Green = 1
Blue // Blue = 2
)
type Color int
var colorNames = []string{
"Red",
"Green",
"Blue",
}
func (c Color) String() string {
if c >= 0 && int(c) < len(colorNames) {
return colorNames[c]
}
return "Unknown"
}
func main() {
fmt.Println("Red:", Red, Red.String())
fmt.Println("Green:", Green, Green.String())
fmt.Println("Blue:", Blue, Blue.String())
} 
