04 - Go 的变量和常量：零值、类型推导与枚举

文章目录

• [深入理解 Go 的变量和常量：零值、类型推导与枚举](#深入理解 Go 的变量和常量：零值、类型推导与枚举)
• 变量的本质：不仅仅是"存数据"
• • [Go 为什么强调变量声明？](#Go 为什么强调变量声明？)
• [零值（Zero Value）：Go 的隐藏设计哲学](#零值（Zero Value）：Go 的隐藏设计哲学)
• • 什么是零值？
  • 为什么零值设计很重要？
  • 常见类型零值一览
  • 一个容易踩坑的点
• 类型推导：简洁背后的规则
• • 推导是如何发生的？
  • 推导的限制
  • [❌ 无法推导的情况：](#❌ 无法推导的情况：)
  • 多变量推导
  • 一个高级点：类型固定
• 常量：编译期的"绝对值"
• • 常量的核心特性
  • [常量 vs 变量（关键区别）](#常量 vs 变量（关键区别）)
  • 常量的"隐式类型"特性（重点）
• [iota：Go 枚举的核心利器](#iota：Go 枚举的核心利器)
• • 基础用法
  • [iota 重置规则](#iota 重置规则)
  • [iota 高级用法：位运算](#iota 高级用法：位运算)
  • [iota + 跳值技巧](#iota + 跳值技巧)
• 实战案例：状态码设计（非常常用）
• 最佳实践总结（非常重要）
• • [✅ 变量](#✅ 变量)
  • [✅ 常量](#✅ 常量)
• 总结

---

深入理解 Go 的变量和常量：零值、类型推导与枚举

在 Go 语言中，变量（variable）与常量（constant）看似基础，但其设计却非常"有哲学"。尤其是零值（zero value）机制、类型推导、以及 iota 枚举，体现了 Go 在简洁与安全之间的平衡。

本文将从原理 + 实战角度，带你深入理解这些核心机制。

---

变量的本质：不仅仅是"存数据"

Go 为什么强调变量声明？

Go 是强类型语言，但又通过类型推导降低冗余：

package main

import "fmt"

func main() {
	var a int = 10
	var b = 20
	c := 30

	fmt.Println(a)
	fmt.Println(b)
	fmt.Println(c)
}

输出结果：

10
20
30

三种写法本质区别：

写法	是否显式类型	使用场景
var a int = 10	是	需要明确类型
var b = 20	否	编译器推导
c := 30	否	函数内部简洁写法

👉 核心思想：类型安全 + 语法简化

---

零值（Zero Value）：Go 的隐藏设计哲学

什么是零值？

Go 中所有变量在声明后都会自动初始化，这一点非常关键：

package main

import "fmt"

func main() {
	var a int
	var b bool
	var c string
	fmt.Printf("a: %d, b: %t, c: %q\n", a, b, c)

	fmt.Println("a:", a)
	fmt.Println("b:", b)
	fmt.Println("c:", c)
	fmt.Println(len(c))
}

输出：

a: 0, b: false, c: ""
a: 0
b: false
c: 
0

区别在于：

• %q (quoted)：强制显示字符串的引号，即使是空字符串也会显示 ""
• Println：直接输出字符串的实际值，空字符串就是空（看不见任何字符）

---

为什么零值设计很重要？

对比其他语言（如 Java、C）：

• 避免"未初始化变量"问题
• 减少空指针风险
• 降低开发心智负担

👉 Go 的理念是：让变量"默认可用"

---

常见类型零值一览

类型	零值
int / float	0
bool	false
string	""
slice / map / pointer	nil

---

一个容易踩坑的点

var s []int
fmt.Println(s == nil) // true

⚠️ slice 的零值是 nil，但可以直接使用 append：

s = append(s, 1) // 完全没问题

👉 这也是 Go 很"优雅"的地方之一

package main

import "fmt"

func main() {
	var s []int
	fmt.Println(s == nil)
	s = append(s, 1)
	s = append(s, 2)
	fmt.Println(s)
}

输出：

true
[1 2]

---

类型推导：简洁背后的规则

推导是如何发生的？

x := 10      // int
y := 3.14    // float64
z := "hello" // string

Go 编译器会根据右值自动推导类型。

---

推导的限制

❌ 无法推导的情况：

var a

👉 必须有类型或初始值

---

多变量推导

a, b := 1, "go"

类型分别为：

• a → int
• b → string

---

一个高级点：类型固定

x := 10
x = 20      // OK
x = 3.14    // ❌ 编译错误

👉 一旦推导完成，类型就不可变

---

常量：编译期的"绝对值"

常量的核心特性

const Pi = 3.14

特点：

• 必须初始化
• 不能修改
• 在编译期确定

---

常量 vs 变量（关键区别）

特性	变量	常量
修改	可以	不可以
计算时机	运行时	编译时
类型	固定	可隐式

---

常量的"隐式类型"特性（重点）

const x = 10

这个 x 是无类型常量（untyped constant）

var a int = x
var b float64 = x

👉 都是合法的！

---

iota：Go 枚举的核心利器

基础用法

package main

func main() {
	const (
		A = iota // 0
		B        // 1
		C        // 2
	)
	println(A, B, C)
}

输出：

0 1 2

👉 iota 每行自动 +1

---

iota 重置规则

package main

func main() {
	const (
		A = iota // 0
		B        // 1
	)

	const (
		C = iota // 0（重新开始）
	)
	println(A, B, C)
}

输出：

0 1 0

---

iota 高级用法：位运算

<< 是位运算：左移

规则：

1 << n  =  1 * 2^n

package main

func main() {
	const (
		Read    = 1 << iota // 1
		Write               // 2
		Execute             // 4
	)
	println(Read, Write, Execute)
}

输出：

1 2 4

理解：

在 const 块中：

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

👉 结论：

• iota 从 0 开始
• 每一行 +1

所以你的代码等价于：

const (
    Read    = 1 << 0
    Write   = 1 << 1
    Execute = 1 << 2
)

✅ Read

1 << 0

= 1 × 2⁰ = 1

✅ Write

1 << 1

= 1 × 2¹ = 2

✅ Execute

1 << 2

= 1 × 2² = 4

👉 非常适合做权限控制：

perm := Read | Write

---

iota + 跳值技巧

const (
package main

func main() {
	const (
		A = iota
		_
		C
	)
	println(A, C)
}

输出：

0 2

👉 _ 用于占位，跳过某个值

---

实战案例：状态码设计（非常常用）

package main

func main() {
	const (
		StatusInit = iota
		StatusRunning
		StatusSuccess
		StatusFailed
	)
	println(StatusInit, StatusRunning, StatusSuccess, StatusFailed)
}

输出：

0 1 2 3

👉 优势：

• 可读性强
• 避免魔法数字
• 易扩展

---

最佳实践总结（非常重要）

✅ 变量

• 优先使用 :=
• 减少全局变量
• 善用零值

✅ 常量

• 替代魔法数字
• 枚举用 iota
• 利用无类型常量提高灵活性

---

总结

Go 在变量和常量上的设计体现了三个核心思想：

• 简单（Simple）：语法简洁，减少冗余
• 安全（Safe）：零值机制避免错误
• 高效（Efficient）：编译期常量优化

👉 掌握这些之后，你会发现 Go 写起来不仅舒服，而且"很难写出低级错误"。

---