Go 基础体系 · 第 3/113 篇。示例统一基于 Go 1.26.4；核心片段可能省略 package 与 import，完整程序可直接按文中结构运行。

Go 变量、常量、基本类型与零值：把类型边界说清楚

本文以 Go 1.26.4 为基准。类型系统不仅决定一行代码能否编译，还决定数值怎样表示、赋值是否复制、零值能否使用以及数据跨越协议边界时会不会丢失。Go 故意减少隐式转换，让这些边界在源码中可见；代价是开发者必须真正理解无类型常量、整数宽度、浮点误差、字符串字节和 nil 的具体含义。

变量是有类型的存储位置，常量是编译期可求值的精确值或类型值。var、短声明和类型推断只是建立变量的不同入口，并没有改变 Go 的静态类型本质。

1. 声明、初始化与短变量声明

var count int 声明一个 int 并赋零值；var count = 3 从初始化表达式推断类型；count := 3 是函数体内的短声明。包级作用域不能使用 :=，因为包初始化需要清晰、可排序的声明形式。

package main

import "fmt"

var serviceName = "billing"

func main() {
	var retries int
	var enabled = true
	timeout, unit := 3, "s"
	fmt.Printf("%s retries=%d enabled=%t timeout=%d%s\n",
		serviceName, retries, enabled, timeout, unit)
}

同一作用域再次使用 := 时，左侧至少有一个非空标识符是新变量，已有变量才是赋值。例如 value, err := load() 可在 err 已存在时声明新的 value 并更新同层 err。如果位于更内层的块，则两个名字都可能成为新变量，造成遮蔽。编译器只禁止声明后完全未使用的局部变量，并不会判断你是否更新错了那个同名变量。

多变量声明适合表达同一操作的结果；为了少写一行而把无关状态塞在一起，会降低初始化顺序的可读性。包级可变变量还会隐藏依赖和增加并发同步成本，通常应由 main 显式组装并传入。

2. 零值是一条设计契约

未显式初始化的变量总有零值：整数和浮点数为 0，布尔值为 false，字符串为 ""；指针、slice、map、channel、函数和接口为 nil；数组和结构体递归地由字段零值组成。

零值“存在”不等于所有操作都有效。nil slice 可以读取长度、遍历和 append；nil map 可以查询和删除，但写入会 panic；nil channel 的发送和接收会永久阻塞；nil 函数调用会 panic。它们都打印成类似的空状态，却有不同操作语义。

优秀类型尽量让零值可用。bytes.Buffer、sync.Mutex 和 sync.Once 都无需构造即可工作。自定义计数器也可遵循这一原则：

type Counter struct {
	value int64
}

func (c *Counter) Add(delta int64) { c.value += delta }
func (c Counter) Value() int64     { return c.value }

若类型必须持有非 nil map、后台 goroutine 或外部连接，构造函数就有意义。但应防止零值落入“看起来能用、稍后才崩”的半合法状态，可在方法入口返回明确错误，或调整表示使惰性初始化安全。

3. 基本类型、别名与平台宽度

基本类型包括 bool、string、有符号整数 int8 到 int64、无符号整数 uint8 到 uint64、int、uint、uintptr、float32/64 和 complex64/128。byte 是 uint8 的别名，rune 是 int32 的别名，因此赋值不需要转换；别名强调语义，不创建新类型。

int 和 uint 的宽度随目标架构变化，至少为 32 位。在内存索引、切片长度和普通循环中优先使用 int，因为标准 API 以它为主。协议字段、文件格式、数据库列和跨进程结构应选明确位宽，不能把 amd64 上的 int 假定为永远 64 位。

uintptr 是足以容纳指针位模式的整数，不是受 GC 跟踪的引用。把指针转成 uintptr 保存起来可能让对象变得不可达；除与 unsafe 和系统调用交互的极窄场景外，不应用它表示地址或对象身份。

自定义类型会建立新的类型身份：

type UserID int64
type OrderID int64

var user UserID = 10
var order OrderID = 10
// user = order // 编译失败：两个已定义类型不同

这种“不方便”正是价值所在，它阻止把同为整数的不同领域标识混用，并允许为类型定义方法。

4. 常量与无类型常量为什么更精确

常量只能由布尔、字符串或数值常量表达式组成，并在编译期求值。未显式指定类型的常量保持无类型状态，拥有比普通机器数值更高的表示精度，直到进入需要具体类型的上下文。

const (
	secondsPerDay = 24 * 60 * 60
	maxPacket     = 1 << 20
	ratio         = 1.0 / 3.0
	typedSize int64 = 4096
)

secondsPerDay 可赋给任何能够表示 86400 的整数类型；若赋给 int16，编译器会报告溢出。ratio 作为常量参与后续常量运算时仍保持高精度，赋给 float64 才舍入。相比运行期转换后静默截断，常量溢出更早暴露。

iota 是常量声明组内从 0 递增的索引，适合紧凑定义相关值，但不要假定插入一行不会改变持久化协议值。对外枚举应显式给数值或保留空位：

type Status uint8

const (
	StatusUnknown Status = 0
	StatusPending Status = 10
	StatusDone    Status = 20
)

常量不是不可变变量：数组、slice、map、结构体和函数结果不能成为常量。需要运行期只读约定时，应通过未导出字段和只读方法维护，而不是寻找 const slice。

5. 赋值兼容与显式类型转换

Go 没有一般性的隐式数值提升。int32 与 int64 即使都表示整数，也必须显式转换。转换描述的是按语言规则生成目标类型的值，不保证业务含义安全，也不会自动检查范围。

var n int64 = 300
small := int8(n)
fmt.Println(small) // 44：保留低 8 位后的有符号结果

边界输入要在转换前检查：

func toUint16(n int64) (uint16, error) {
	if n < 0 || n > int64(^uint16(0)) {
		return 0, fmt.Errorf("%d is outside uint16", n)
	}
	return uint16(n), nil
}

从浮点数转整数会丢弃小数部分；超出目标整数范围时不能依赖跨平台业务结果。字符串和字节/rune 切片之间的转换会产生内容对应的表示，通常伴随分配与复制。热点路径先用 benchmark 和 profile 证明转换成本，再考虑复用缓冲，不能用 unsafe 绕开所有权约束。

6. 整数溢出、无符号数与边界检查

运行期整数运算按固定宽度计算，溢出会按二进制补码或模运算效果回绕，不会自动 panic。下面的检查本身就可能先溢出：if a*b > limit。对非负整数，应在乘法前改写为除法边界，或使用标准库位运算辅助函数。

func checkedMul(a, b uint64) (uint64, bool) {
	if a != 0 && b > ^uint64(0)/a {
		return 0, false
	}
	return a * b, true
}

无符号类型不代表值已经被验证为非负。把负数转换为 uint64 会得到很大的值；倒序循环 for i := len(xs)-1; i >= 0; i-- 若 i 是无符号数将永不因 i >= 0 停止。普通长度和索引优先 int，只有位掩码、协议字段和明确模运算才自然适合无符号类型。

解析外部整数应使用 strconv.ParseInt 或 ParseUint 并指定位宽，让范围错误在输入边界出现。JSON 解到 any 时数字默认常成为 float64，大整数可能失真；可用 json.Decoder.UseNumber 或解到明确字段类型。

7. 浮点数、NaN 与金额

float32 和 float64 遵循 IEEE 754 二进制浮点表示。许多十进制小数不能精确表示，因此 0.1+0.2 的存储结果不必等于精确十进制 0.3。算法结果比较通常使用结合量级的容差，而不是固定地把所有差异与一个极小常数比较。

func almostEqual(a, b, rel, abs float64) bool {
	diff := math.Abs(a - b)
	if diff <= abs {
		return true
	}
	return diff <= rel*math.Max(math.Abs(a), math.Abs(b))
}

NaN 与包括自身在内的任何值都不相等，正负无穷也可能由除零等运算产生。接收科学计算结果时用 math.IsNaN、math.IsInf 做显式验证。排序函数若未定义 NaN 顺序，可能违反比较器要求。

金额不要直接用浮点累计。币种小数位固定时可存最小货币单位整数，并在乘法、汇率和税率计算中定义舍入规则；范围和精度更复杂时使用经过评估的十进制定点库。关键不只是选类型，还要记录单位，例如字段命名 AmountCents 比含糊的 Amount 更可靠。

8. 字符串是只读字节序列，不是 rune 数组

Go 字符串保存字节序列，可以包含任意字节，也可以不是合法 UTF-8。len(s) 返回字节数；按索引 s[i] 得到一个字节；range 按 UTF-8 解码，返回每个 rune 的起始字节偏移。无效编码会产生 utf8.RuneError 并前进相应宽度。

s := "Go语言"
fmt.Println(len(s), utf8.RuneCountInString(s)) // 8 4
for index, r := range s {
	fmt.Printf("byte=%d rune=%q\n", index, r)
}

rune 是 Unicode 码点，不等于用户看到的字形。一个字形可能由基础字符与组合符组成，也可能是多个码点的表情序列。按“字符数”限制用户名时必须先定义是字节、码点还是字素簇，并选择对应实现。

字符串不可原地修改。[]byte(s) 适合处理编码字节，[]rune(s) 适合按码点编辑，但二者通常都会分配。拼接少量常量可用 +，循环构造文本优先 strings.Builder；构造二进制数据则用 bytes.Buffer 或预分配的 []byte。

9. 数组、slice 和 map 的值语义差异

数组类型包含长度，[3]int 与 [4]int 是不同类型；数组赋值会复制全部元素。slice 是描述底层数组窗口的值，包含指针、长度和容量，复制 slice 只复制描述符，元素仍可能共享。append 在容量不足时会分配新数组，因此调用方不能假定追加后一定共享。

base := []int{1, 2, 3}
view := base[:2]
view[0] = 9              // base[0] 也变为 9
view = append(view, 8)   // 是否重用 base 取决于容量
fmt.Println(base, view)

API 若要保留调用方传入的 slice，应明确所有权：需要隔离时使用 slices.Clone，返回内部数据时也考虑副本。否则调用方后续修改或多个 goroutine 并发访问会破坏封装。

map 是引用底层哈希表的描述值，赋值不会复制内容。nil map 可读不可写，使用 make(map[K]V) 后才能写。读取不存在的键会返回值类型零值，所以需要用 value, ok := m[key] 区分“不存在”和“存在但值为零”。map 遍历顺序未定义，序列化或测试输出要求稳定时先提取并排序键。

10. nil 接口与带类型的 nil

接口值可理解为动态类型和动态值两部分。只有两部分都为空时，接口才等于 nil。把一个值为 nil 的具体指针赋给接口后，接口携带动态类型，因此不等于 nil：

type Problem struct{ Message string }

func (p *Problem) Error() string {
	if p == nil {
		return "<nil problem>"
	}
	return p.Message
}

func bad() error {
	var p *Problem
	return p // 非 nil error，动态类型是 *Problem
}

正确做法是在没有错误时直接 return nil，不要先把具体 nil 指针装入接口。日志看到 <nil> 但 err != nil 时，可用 %T 和 %#v 打印动态类型与值定位。

nil slice 与空 slice 在 len、遍历和 append 上相近，但 reflect.DeepEqual、某些 JSON 编码和 API 契约可能区分 null 与 []。不要在整个代码库武断统一；应在外部协议边界明确是否区分，内部再保持一种一致表示。

11. 结构体、可比较性与内存布局

结构体赋值按字段复制。字段若含 slice、map、指针或接口，复制的仍是这些描述值，引用的数据可能共享，所以“结构体按值传递”等于深拷贝是错误的。是否使用指针接收者主要取决于方法需不需要修改值、复制成本和一致性，而不只是结构体大小。

只有可比较类型才能用 ==，也只有可比较类型可作 map 键。slice、map 和函数不可比较（除与 nil 比较），含这些字段的结构体也不可比较。业务相等往往还要忽略缓存字段、统一时间精度或比较集合语义，宜写命名清楚的 Equal 方法，而不是诉诸反射。

字段顺序会因对齐填充影响结构体大小，可用 unsafe.Sizeof 做诊断，但不要过早为了省几个字节破坏领域可读性。海量对象或缓存热点经 profile 证明受内存布局影响时，再将相同对齐需求的字段分组，并重新 benchmark。跨网络或磁盘绝不能直接依赖 Go 结构体内存布局，应使用明确编码格式。

12. 类型推断、泛型约束与底层类型

泛型函数的类型参数由实参和约束推断。~int 表示底层类型为 int 的已定义类型也满足约束，这使领域类型可以复用算法而不丢失类型身份。

type Integer interface {
	~int | ~int32 | ~int64
}

func Sum[T Integer](values []T) T {
	var total T
	for _, value := range values {
		total += value
	}
	return total
}

var total T 使用类型参数实例化后的零值，是泛型代码获取零值的标准方式。不能假设任意 T 都可比较、排序或为 nil；这些操作必须由约束允许。约束的类型集合是编译期能力描述，不是运行期接口检查。

泛型不会消除数值溢出。Sum([]int32{...}) 仍按 int32 计算；需要更宽累加器时，应让 API 明确返回类型或提供转换函数，不能把精度策略藏在通用名字后面。

13. 一个可运行的边界检查程序

下面程序把解析、范围检查、整数金额和 UTF-8 长度放在一起，展示如何在输入边界尽早拒绝含糊数据：

package main

import (
	"errors"
	"fmt"
	"strconv"
	"unicode/utf8"
)

type Order struct {
	Quantity uint16
	UnitCents int64
	Label     string
}

func parseOrder(quantity, cents, label string) (Order, error) {
	q, err := strconv.ParseUint(quantity, 10, 16)
	if err != nil {
		return Order{}, fmt.Errorf("quantity: %w", err)
	}
	price, err := strconv.ParseInt(cents, 10, 64)
	if err != nil || price < 0 {
		return Order{}, errors.New("unit cents must be a non-negative int64")
	}
	if !utf8.ValidString(label) || utf8.RuneCountInString(label) > 12 {
		return Order{}, errors.New("label must be valid UTF-8 with at most 12 code points")
	}
	return Order{Quantity: uint16(q), UnitCents: price, Label: label}, nil
}

func (o Order) TotalCents() (int64, error) {
	q := int64(o.Quantity)
	if q != 0 && o.UnitCents > int64(^uint64(0)>>1)/q {
		return 0, errors.New("total overflows int64")
	}
	return q * o.UnitCents, nil
}

func main() {
	order, err := parseOrder("3", "1299", "Go语言")
	if err != nil {
		panic(err)
	}
	total, err := order.TotalCents()
	if err != nil {
		panic(err)
	}
	fmt.Printf("%s: %d items, total=%d cents\n", order.Label, order.Quantity, total)
}

运行 go run . 应输出 Go语言: 3 items, total=3897 cents。测试时应加入数量为 65536、负价格、非法 UTF-8、空标签、零数量以及接近 int64 上限等用例，验证失败发生在预期边界。

14. 常见错误、诊断与实践清单

编译错误 mismatched types 通常不是编译器多事，而是在提示单位、宽度或领域类型尚未对齐。先查看两侧 %T、函数签名和数据来源，再决定在哪个边界转换；不要在表达式各处散布强转。

数值异常可用十进制与十六进制同时打印，检查转换前后的类型和值；浮点异常打印足够有效位并检查 NaN/Inf；文本异常输出 %q、字节长度、rune 数及原始十六进制；接口 nil 异常打印 %T 和 %#v。诊断先保存原输入，避免格式化日志再次丢失信息。

工程中应坚持几条原则：协议和持久化字段用明确位宽；金额携带单位并定义舍入；外部输入先解析到足够宽的类型再检查范围；map 查询在零值有业务意义时使用 ok；共享 slice 和 map 明确所有权；结构体尽量保持零值可用；不把 uintptr 当指针；泛型算法明确溢出和比较约束。

类型设计的目标不是让转换越少越好，而是让错误的值难以进入核心逻辑。表示边界越明确，编译器越能替你阻止混用，运行期诊断也越能快速定位“值从哪里开始不再可信”。

---

系列导航与关联阅读

• 系列入口：Go 完整技术体系学习路线：从语法、并发到框架、中间件与 AI
• 上一篇：Go 工具链与模块：从安装、go mod 到可重复构建
• 下一篇：Go 控制流与作用域：if、for、switch 和变量遮蔽
• 延伸：Go 指针、值语义、new 与 make：理解复制和共享
• 延伸：Go 字符串、byte、rune 与 Unicode：正确处理中文文本

官方资料

• Go specification: Variables
• Go specification: Constants
• A Tour of Go: Basic types

本文依据 Go 官方规范、标准库文档和 Go 官方博客重新梳理；正文与示例由 WR BLOG 编写。