Go 常量

Go - 常量

Go 中的常量（Constant）是固定的值，在程序执行期间不能更改。它们使用 const 关键字声明，可以是基本类型，如 boolean（布尔型）、rune（Unicode 码点）、integer（整型）、floating-point（浮点型）、complex（复数型）或 string（字符串型）。

与变量（variable）不同，常量必须在声明时初始化。其值在编译时（compile time）确定。

声明常量

常量可以单独声明，也可以成组声明。

const Pi = 3.14159 // Untyped floating-point constant
const Greeting = "Hello, Go!" // Untyped string constant

// Grouped constants
const (
    StatusOK    = 200         // Untyped integer constant
    Version     = "1.0.0"     // Untyped string constant
    DebugMode   = true        // Untyped boolean constant
)

// Typed constants
const MaxUsers int = 1000

有类型常量 vs 无类型常量

Go 常量可以是有类型 (typed) 或无类型 (untyped)。

有类型常量被显式赋予一个类型（例如，const MyInt int = 10）。它们严格遵守该类型的规则。
无类型常量具有“种类”（kind）（例如，整型、浮点型、字符串型），但在用于需要特定类型的上下文（例如，赋值给变量或与有类型值一起在表达式中使用）之前，它们没有固定的特定类型。无类型常量提供了更大的灵活性，它们可以被赋值给任何兼容类型的变量，而无需显式转换，只要值合适即可。数值类型的无类型常量支持编译时任意精度算术。

const UntypedNumber = 12345678901234567890 // High-precision integer kind
var myInt64 int64 = UntypedNumber       // OK, fits in int64
// var myInt32 int32 = UntypedNumber    // Compile error if UntypedNumber is too large for int32

const UntypedFloat = 3.0
var f32 float32 = UntypedFloat // OK
var f64 float64 = UntypedFloat // OK

常量使用的数字字面量

整型字面量（Integer literals）：可以是十进制（例如，123）、八进制（前缀 0o 或 0O，例如，0o177）、十六进制（前缀 0x 或 0X，例如，0xFF）或二进制（前缀 0b 或 0B，例如，0b1010）。
浮点型字面量（Floating-point literals）：可以包含整数部分、小数点、小数部分和可选的指数部分（例如，3.14、1.0e3、.25）。
Rune 字面量（Rune literals）：表示一个单个 Unicode 字符，用单引号括起来（例如，'a'、'\n'、'世'）。它们具有整型种类。
虚部字面量（Imaginary literals）：用于构成复数常量（例如，3i、2.718i）。

const (
    DecimalConst = 42
    OctalConst   = 0o52      // 42 in decimal
    HexConst     = 0x2A      // 42 in decimal
    BinaryConst  = 0b101010  // 42 in decimal
    FloatConst   = 2.71828
    RuneConst    = 'G'
    ComplexConst = 1 + 2i
)

字符串字面量与转义序列

字符串字面量用双引号 "..." 或反引号 `...` 括起来。

解释型字符串字面量（Interpreted string literals） (双引号)：允许使用转义序列，如 \n (换行符)、\t (制表符)、\" (双引号)、\\ (反斜杠) 以及 Unicode 转义，如 \uXXXX 或 \UXXXXXXXX。
原生字符串字面量（Raw string literals） (反引号)：不处理转义序列，可以跨越多行。原生字符串字面量中的回车符 (\r) 会被忽略。

const InterpretedString = "Hello\tWorld\nThis is a G\u00F6 program."
const RawString = `This is a raw string.
It can span multiple lines.
No \escapes are processed.`

// 示例展示转义序列
// package main
// import "fmt"
// func main() {
//    fmt.Println(InterpretedString)
//    fmt.Println(RawString)
// }

Go 字符串和 rune 字面量中常见的转义序列：

转义序列	含义
`\a`	响铃符 (U+0007)
`\b`	退格符 (U+0008)
`\f`	换页符 (U+000C)
`\n`	换行符 (U+000A)
`\r`	回车符 (U+000D)
`\t`	水平制表符 (U+0009)
`\v`	垂直制表符 (U+000B)
`\\`	反斜杠 (U+005C)
`\'`	单引号 (U+0027) - 在 rune 字面量中有效
`\"`	双引号 (U+0022) - 在解释型字符串字面量中有效
`\ooo`	八进制字符值 (例如，`\141` 是 ‘a’)
`\xhh`	十六进制字符值 (例如，`\x61` 是 ‘a’)

`iota` 常量生成器

iota 是一个特殊的预声明标识符，用于 const 声明中，以简化创建顺序整数常量（枚举）的过程。它在每个 const 块中从 0 开始，并在块中每个后续常量规范递增 1。

const (
    C0 = iota // C0 = 0
    C1 = iota // C1 = 1
    C2 = iota // C2 = 2
)

const (
    FlagRead = 1 << iota // FlagRead = 1 (1 << 0)
    FlagWrite            // FlagWrite = 2 (1 << 1)，iota 递增，表达式重复
    FlagExecute          // FlagExecute = 4 (1 << 2)
    _                    // 跳过一个值 (iota 递增)
    FlagAdmin            // FlagAdmin = 16 (1 << 4)
)

// package main
// import "fmt"
// func main() {
//    fmt.Println(C0, C1, C2)                             // 输出: 0 1 2
//    fmt.Println(FlagRead, FlagWrite, FlagExecute, FlagAdmin) // 输出: 1 2 4 16
// }

常量是编写健壮且可维护的 Go 代码的基础部分，常用于定义固定参数、状态码或位掩码。