GO语言基础教程（26）Go有类型的常量：Go语言常量：别拿你的var跟我比，咱是“有身份”的贵族！-优快云博客

Go语言常量——披着羊皮的“类型安全”狼

兄弟们，姐妹们，码农朋友们！今天咱们不聊那些枯燥的语法糖，来点硬核的。咱们来深扒一下Go语言里一个看似人畜无害，实则内力深厚的家伙——有类型的常量。

你是不是经常这么写代码？

const Pi = 3.14159
var radius = 10
var circumference = 2 * Pi * radius // 一切安好，美滋滋

然后你觉得，Pi不就是个不变的var吗？兄弟，你这个想法很危险啊！如果你真这么想，那你可太小看Go语言的设计者了。Go的常量，可不是普通的“变量它家亲戚”，它是自带光环、有身份、有原则的“类型贵族”。

第一回合：`const` vs `var`——不是一个级别的选手

我们先来个灵魂拷问：常量和变量，到底有啥本质区别？

变量（var）：像一个盒子。你声明var age int = 30，就等于拿了一个贴着“int”标签的盒子，把30这个值装进去。以后你想往这个盒子里放东西，必须得是整数（int），你放个字符串"hello"试试？编译器直接给你一板砖。
常量（const）：像一个纹身。你声明const Age = 30，就相当于把30这个值直接刻在了代码里。它没有固定的“盒子”（类型），它自己就是那个值本身。这个纹身，啊不，这个常量，它的“类型”是可以根据上下文来“变色”的。

关键点来了： Go语言中的常量，绝大多数情况下是 “无类型（untyped）” 的。const Pi = 3.14159，这里的Pi本身没有类型，它只是一个叫做无类型浮点数常量的数字概念。

第二回合：常量的“无类型”大法，才是真功夫

“无类型”？那岂不是无法无天了？非也非也！这正是Go常量设计的精妙之处。无类型常量有自己的一套“基本种类”：

无类型布尔常量 (如 const IsOpen = true)
无类型整数常量 (如 const BatchSize = 100)
无类型浮点数常量 (如 const Pi = 3.14159)
无类型复数常量 (如 const C = 1 + 2i)
无类型字符常量 (如 const Exclamation = '!')
无类型字符串常量 (如 const Greeting = "Hello")

这些“无类型”的常量，就像一个万能演员，你让它演什么角色（类型），它就能演什么角色，只要剧本（上下文）合理。

来看个完整示例，感受一下它的灵活性：

package main

import "fmt"

func main() {
    // 声明一堆无类型常量
    const untypedInt = 123          // 无类型整数
    const untypedFloat = 4.56       // 无类型浮点数
    const untypedString = "Gopher"  // 无类型字符串
    const untypedBool = true        // 无类型布尔

    // 魔法开始：它们可以自由地与各种类型变量混合运算（在合理范围内）
    var myInt int = 10
    var myFloat64 float64 = 2.5
    var myString string = " Hello"
    var myBool bool

    // 无类型整数 可以赋值给 int, float64等
    result1 := untypedInt + myInt        // 当作 int 使用
    result2 := untypedInt + myFloat64    // 当作 float64 使用

    // 无类型浮点数 也可以赋值给 int? 不行！会丢失精度，但可以和float64运算
    // result3 := untypedFloat + myInt   // 这行会编译错误！
    result3 := untypedFloat + myFloat64  // 当作 float64 使用

    // 字符串拼接
    result4 := untypedString + myString

    // 布尔运算
    myBool = untypedBool && (myInt > 5)

    fmt.Printf("result1 (int): %d, type: %T\n", result1, result1)
    fmt.Printf("result2 (float64): %f, type: %T\n", result2, result2)
    fmt.Printf("result3 (float64): %f, type: %T\n", result3, result3)
    fmt.Printf("result4 (string): %s, type: %T\n", result4, result4)
    fmt.Printf("myBool: %t, type: %T\n", myBool, myBool)
}

输出:

result1 (int): 133, type: int
result2 (float64): 125.500000, type: float64
result3 (float64): 7.060000, type: float64
result4 (string): Gopher Hello, type: string
myBool: true, type: bool

看到了吗？untypedInt这个常量，在result1里化身int，在result2里又化身float64，左右逢源，如鱼得水。这就是“无类型”带来的灵活性与简洁性。

第三回合：当常量“穿了衣服”——什么是有类型常量？

当然，Go也允许你给常量“穿上衣服”，也就是声明有类型的常量。

const TypedInt int = 42
const TypedFloat float64 = 3.14

一旦常量有了明确的类型，它就失去了“变色龙”的超能力，变得和变量一样严格。

再来看个对比示例：

package main

import "fmt"

func main() {
    // 有类型常量 vs 无类型常量
    const typedConst int = 100    // 有类型整数常量
    const untypedConst = 100      // 无类型整数常量

    var i int = 10
    var f float64 = 5.5

    // 有类型常量的运算：必须类型匹配或显式转换
    result1 := typedConst + i     // OK，同为int
    // result2 := typedConst + f  // 错误！int 和 float64 不能直接相加
    result2 := float64(typedConst) + f // OK，显式转换后

    // 无类型常量的运算：自由飞翔
    result3 := untypedConst + i   // OK，当作int
    result4 := untypedConst + f   // OK，当作float64

    fmt.Println("有类型常量运算:")
    fmt.Printf("  result1: %d\n", result1)
    fmt.Printf("  result2: %f\n", result2)

    fmt.Println("无类型常量运算:")
    fmt.Printf("  result3: %d\n", result3)
    fmt.Printf("  result4: %f\n", result4)
}

这个例子清晰地展示了区别：typedConst因为穿了int的“衣服”，就不能再和float64的变量f愉快地玩耍了，除非你强行给它“换装”（类型转换）。而untypedConst依然是那个自由的灵魂。

第四回合：常量“贵族”的特权与底线

为什么Go要设计这么一套“无类型常量”体系？是为了炫技吗？不，是为了类型安全和精度。

特权1：高精度计算
常量的值在编译期是任意精度的，不会像变量一样有溢出问题。

package main

import "fmt"

func main() {
    // 定义一个巨大的常量
    const HugeNumber = 1e1000 // 10的1000次方，一个巨大的数字
    fmt.Println("HugeNumber is:", HugeNumber) // 可以打印出来

    // 但你无法把它赋给一个普通的float64变量
    // var notSoHuge float64 = HugeNumber // 编译错误：常数溢出float64

    // 只有在编译期可以确定其值且不溢出的情况下，才能赋值
    const ReasonableLarge = 1e18
    var largeEnough float64 = ReasonableLarge // OK
    fmt.Println("largeEnough is:", largeEnough)
}

底线2：隐式转换的规则
无类型常量不是万能的，它不能随意跨越“种类”界限。

一个无类型整数常量可以隐式转换为int, int32, float64等数值类型。
一个无类型字符串常量可以隐式转换为string或[]byte（在特定上下文中，如拼接）。
但一个无类型整数常量绝不能隐式转换为string或bool。

const n = 65
// var s string = n  // 错误！不能将无类型整数65隐式转换为字符串
var s string = string(n) // 这是将65当作ASCII码，转换为字符"A"，不是数字"65"
var i int = n        // OK

终极大实战：枚举的优雅实现（`iota`与有类型常量的完美结合）

Go没有传统的enum关键字，但它用const和iota实现了一套更强大的枚举系统。这里，有类型常量扮演了关键角色。

package main

import "fmt"

// 声明一个自定义类型，作为枚举的基类型
type Weekday int

// 使用 iota 和 有类型常量 定义枚举值
const (
    Sunday    Weekday = iota // 0
    Monday                   // 1, 类型继承自 Sunday，即 Weekday
    Tuesday                  // 2
    Wednesday                // 3
    Thursday                 // 4
    Friday                   // 5
    Saturday                 // 6
)

// 为枚举类型定义方法
func (d Weekday) String() string {
    names := [...]string{"Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"}
    if d < Sunday || d > Saturday {
        return "Unknown"
    }
    return names[d]
}

func (d Weekday) IsWeekend() bool {
    return d == Saturday || d == Sunday
}

func main() {
    var today Weekday = Wednesday

    fmt.Printf("Today is %s (%d)\n", today, today) // 调用 String() 方法
    fmt.Printf("Is it weekend? %t\n", today.IsWeekend())

    // 因为有明确的类型，可以有效防止无意义的运算或赋值
    // var nonsense = today + "hello" // 编译错误！
    // var anotherDay int = today     // 编译错误！需要显式转换

    // 但同类型枚举值之间的运算是允许的
    tomorrow := (today + 1) % 7
    fmt.Printf("Tomorrow is %s\n", tomorrow)
}

输出:

Today is Wednesday (3)
Is it weekend? false
Tomorrow is Thursday

在这个例子中，Sunday, Monday...这些常量，都是有类型的常量，它们的类型是Weekday。这带来了巨大的好处：

类型安全：你不能把一个随便的int值赋给Weekday类型的变量。
可读性：var d Weekday = Monday 比 var d int = 1 清晰无数倍。
可扩展性：你可以为这个类型绑定方法（如String(), IsWeekend()），让枚举变得“活”起来。

总结：你该什么时候给常量“穿衣服”？

好了，深度之旅到此结束。我们来总结一下核心思想：

默认情况下，请多用“无类型常量”。就像 const Delay = 5，让它保持灵活性，在需要int、time.Duration或float64时都能从容应对。这是Go代码简洁性的重要来源。
当你需要明确的类型约束时，使用“有类型常量”。尤其是在实现枚举、定义需要严格遵循某种类型的公共接口常量时，比如 const StatusOK MyStatus = 200。
理解“无类型”的本质：它不是没有类型，而是将类型决定的权力推迟到了使用它的那一刻。这是编译器送给你的一份“延迟绑定”大礼。

所以，下次再写const时，可别再把它当成一个简单的“不变值”了。它是一位深藏不露的功夫大师，用“无类型”的柔，成就了“类型安全”的刚。摸透了它的脾气，你的Go代码功力，必定能更上一层楼！