Golang 变量与常量声明详解：从基础到 iota 技巧

变量的类型与作用

基础概念

Go 是一种强类型语言，这意味着每个变量都有确定的类型（如整型、浮点型、布尔型、字符串等）。编译器在编译时会严格检查类型的合法性，这有助于在开发阶段发现逻辑错误。变量本质上是一段内存空间的标识符，用于存储运行时数据。

声明规则

在 Go 中，未使用的变量会被标记为编译错误，从而避免冗余代码带来的维护成本。此外，在同一作用域内不支持对同一标识符重复声明。

变量的声明方式

目的：根据场景选择合适的语法来定义和初始化变量。

第1步：使用 var 关键字进行标准或批量声明

• 入口/动作：使用 var 关键字明确指定变量名和数据类型。
• 参数说明：若忽略类型，可通过右侧赋值推导类型（需确保右侧有初始值）；若不指定初始值，则使用该类型的零值。

// 单行标准声明
var name string
var age int
var isShow bool

// 批量声明：当连续声明多个变量时，可省略 var 关键字
var (
	name    string
	age     int
	isShow  bool
	num     float32
)

第2步：了解变量的默认初始化值（零值）

如果声明变量时未提供初始值，Go 会自动将其分配对应的“零值”（Zero Value）：

• 整型和浮点型：0
• 布尔型：false
• 字符串：""（空字符串）
• 指针、切片、函数、接口等引用类型：nil

第3步：显式初始化与类型推导

可以在声明的同时赋初值。当右侧有值时，左侧类型可以省略，编译器会进行类型推断。

// 显式指定类型
var name string = "water"
var age int = 18

// 显式指定类型并一次性定义多个变量
var name, age = "water", 20

// 省略类型，由编译器推导
var name = "water"
var age = 18

第4步：函数内部使用短变量声明符 :=

注意：:= 只能用在函数体内，不能用于包级别的全局变量声明。

package main

import "fmt"

// 全局变量通常使用 var (除非确定要推导类型，但全局不可用 :=)
var gName = "global"

func main() {
	// 短变量声明：既声明又赋值，且推导类型
	a := 1
	b := 2
	fmt.Println(a, b) // 输出: 1 2
}

第5步：使用匿名变量 _ 忽略返回值

当一个函数返回多个值，而我们只关心其中一部分时，可以使用下划线 _ 接收不需要的值。匿名变量不占用命名空间，也不会分配内存，因此不受“必须使用”规则的限制。

func getValue() (int, string) {
	return 18, "water"
}

func main() {
	a, _ := getValue() // a = 18
	_, b := getValue() // b = "water"
	fmt.Println("a=", a)
	fmt.Println("b=", b)
}

总结变量声明要点：

• 包级别声明必须以 var 或 func 开头。
• := 仅限函数体内部。
• _ 用于占位，不产生副作用。

常量的定义与特性

常量在编译时确定其值，且运行过程中不可更改。常量的声明结构与变量类似，只需将 var 替换为 const。

基本声明格式

常量在定义时必须给出一个明确的初始值。

const a = 123
const b = 456

// 批量声明
const (
	a = 123
	b = 456
)

多行常量省略规则

如果在 const () 块中省略了下一行的值，则该常量的值与上一行相同。这在定义一组固定枚举或配置项时非常有用。

const (
	a = 1
	b       // b 的值也是 1
	c       // c 的值也是 1
)

iota 计数器的高级应用

iota 是 Go 语言的常量计数器。它在每一个 const 关键字出现时被重置为 0，然后在 const 内每新增一行常量声明时，计数增加 1。

基础行为验证

const (
	a = iota // 0
	b        // 1
	c        // 2
	d        // 3
)

实用技巧 1：使用下划线跳过值

通过在下划线位置放置占位符，可以跳过特定的计数值。

const (
	a = iota // 0
	b        // 1
	_        // 占位，计数继续但不赋值给变量
	d        // 3
)

实用技巧 2：混合使用常数与 Iota

如果在 iota 序列中间嵌入了具体的数值，后续行的 iota 仍然按行递增，而不是延续之前的计算结果。

const (
	a = iota // 0
	b = 20   // 此时值为手动指定的 20
	c = iota // 这里的 iota 已经是 2（第三行）
	d = iota // 这里的 iota 是 3（第四行）
)

const e = iota // 新的一组 const，iota 重置为 0，所以 e = 0

实用技巧 3：单行定义多个变量

在同一行声明多个变量时，它们使用的是同一个 iota 值。常用于定义具有关联关系的枚举。

const (
	a, b = iota + 1, iota + 2 // a = 1, b = 2
	c, d                     // c = 2, d = 3
	e, f                     // e = 3, f = 4
)

综合案例

package main

import "fmt"

// 全局常量组：使用 iota 生成唯一的状态码
const (
	StatusPending = iota + 1
	StatusApproved
	StatusRejected
)

func main() {
	// 短变量声明局部变量
	var username = "developer" // 显示推导类型
	count := 1                 // 整数类型
	
	fmt.Printf("User %s has status code: %d\n", username, StatusPending)
	_ = count // 演示虽然 count 被使用了，但如果不需要打印，可用 _ 忽略部分结果
}