03 类型与零值

03 类型与零值

本页回答：有哪些类型、各占多宽、默认值是什么、什么时候必须显式转换。复合类型的操作细节在 07 数组·切片·映射·结构体。

基线：Go 1.27.1 / darwin/arm64（64 位平台）。所有数值均为本机实跑结果。

类型体系全景

Go 的类型分四层：基本类型 → 复合类型 → 引用类型 → 接口类型。搞清这张图，nil 能赋给谁、什么能比较，就都不用背了。

flowchart TB
    T(["类型 Type"])

    T --> BASIC["基本类型"]
    T --> COMP["复合类型"]
    T --> REF["引用语义类型"]
    T --> IFACE["接口类型"]

    BASIC --> B1["布尔 bool"]
    BASIC --> B2["整数<br/>int int8..64<br/>uint uint8..64 uintptr"]
    BASIC --> B3["浮点<br/>float32 float64"]
    BASIC --> B4["复数<br/>complex64 complex128"]
    BASIC --> B5["字符串 string"]
    BASIC --> B6["字符别名<br/>byte=uint8<br/>rune=int32"]

    COMP --> C1["数组 [N]T<br/>值语义"]
    COMP --> C2["结构体 struct{}<br/>值语义"]
    COMP --> C3["指针 *T"]

    REF --> R1["切片 []T"]
    REF --> R2["映射 map[K]V"]
    REF --> R3["通道 chan T"]
    REF --> R4["函数 func()"]

    IFACE --> I1["接口 interface{}"]
    IFACE --> I2["any = interface{}"]

    REF -. "零值是 nil ⚠️" .-> NIL(["nil"])
    IFACE -. "零值是 nil ⚠️" .-> NIL

可以比较（==）的类型：布尔、数值、字符串、指针、通道、接口、数组（元素可比较时）、结构体（字段全可比较时）。 不能比较的类型：切片、映射、函数——只能与 nil 比较 🛑。

1
2
3

var s1, s2 []int
fmt.Println(s1 == nil)   // ✅ true
// fmt.Println(s1 == s2)  // 🛑 编译错误：slice can only be compared to nil

数值类型全表

1
2

fmt.Println("int bits:", unsafe.Sizeof(int(0))*8, "ptr bits:", unsafe.Sizeof(uintptr(0))*8)
fmt.Println(math.MaxInt64, math.MinInt64, math.MaxInt32, math.MaxUint8)

1
2

int bits: 64 ptr bits: 64
9223372036854775807 -9223372036854775808 2147483647 255

常用边界常量（都在 math 包）

⚠️ math 包里没有 MinUint* 系列——无符号整数下界恒为 0，不需要常量。也没有 MaxComplex，复数用两个 float64 表示。

⚠️ int 不是 int64。写库时如果 API 用了 int，在 32 位平台上就装不下大数；跨平台的持久化字段一律用定宽类型 int64。

该用哪个数值类型

• 日常默认
• 协议与持久化
• 什么时候用无符号

1
2
3
4
5
6

// 🛑 无符号倒序循环会死循环
var i uint = 10
for ; i >= 0; i-- { }   // i=0 后 i-- 变成 18446744073709551615

// ✅
for i := 10; i > 0; i-- { }

各类型占多少字节

1
2
3

fmt.Println(unsafe.Sizeof(byte(0)), unsafe.Sizeof(rune(0)), unsafe.Sizeof(int16(0)),
	unsafe.Sizeof(int32(0)), unsafe.Sizeof(int64(0)), unsafe.Sizeof(float32(0)),
	unsafe.Sizeof(float64(0)), unsafe.Sizeof(complex64(0)), unsafe.Sizeof(complex128(0)))

1

1 4 2 4 8 4 8 8 16

string 的头部是 16 字节（1 个指针 + 1 个长度），所以字符串赋值是「拷贝头部、共享底层字节」。

1

string header: 16

rune、byte、string 三者的关系

这张图是 Go 文本处理的全部真相：string 是只读的字节序列，byte 是字节，rune 是码点。

flowchart LR
    S["string<br/>不可变 · UTF-8 字节序列"]
    S -->|"s[i]"| B["byte / uint8<br/>一个字节"]
    S -->|"[]rune(s)"| R["[]rune<br/>码点序列"]
    S -->|"for range"| RC["rune + 起始字节下标"]
    R -->|"string(rs)"| S
    B -->|"string(b)"| S
    S -->|"len(s)"| N1["字节数 ⚠️"]
    R -->|"len(rs)"| N2["字符数 ✅"]

    ALIAS["类型别名"] --> BA["byte = uint8"]
    ALIAS --> RA["rune = int32"]

1
2
3

s := "héllo, 世界"
fmt.Println("len(bytes) =", len(s), " len(runes) =", len([]rune(s)))
fmt.Println(len("中文"), utf8.RuneCountInString("中文"))

1
2

len(bytes) = 14  len(runes) = 9
6 2

UTF-8 编码长度规律（记住它就能心算字节数）：

拿 "héllo, 世界" 逐字符验证一遍，长度就对上了：

所以 len(s) == 14 而 len([]rune(s)) == 9——和实跑结果一致。💡 现实代码里不要心算，需要字符数就用 utf8.RuneCountInString。

字符串不可变

1
2
3
4
5
6

s := "hello"
// s[0] = 'H'        // 🛑 编译错误：cannot assign to s[0]
b := []byte(s)       // ✅ 转成可变切片（拷贝）
b[0] = 'H'
s2 := string(b)      // 再转回来
fmt.Println(s, s2)   // hello Hello

改字符串的正确姿势：[]byte（要处理字节）或 []rune（要处理字符），改完再转回 string。每次转换都是一次完整拷贝，热路径上要留意（见 14 字符串 的 strings.Builder）。

类型转换：什么时候必须写 T(v)

Go 没有隐式数值转换，这是它和 C/Java 最大的区别之一：不同类型之间运算必须先转换。

flowchart TB
    Q(["需要把 x 变成 T 类型"]) --> Q1{"可赋值（assignable）？<br/>底层类型相同 且 至少一侧不是具名类型"}
    Q1 -- 是 --> IMPL["直接赋值 ✅<br/>type MySlice []int<br/>var s []int; var m MySlice = s"]
    Q1 -- "否（如 int → MyInt，两侧都是具名类型）" --> CONV0["必须显式转换 T(x)"]
    Q1 -- 否 --> Q2{"都是数值类型？"}
    Q2 -- 是 --> CONV["T(x) 显式转换 ✅<br/>可能丢失精度 ⚠️"]
    Q2 -- 否 --> Q3{"string ↔ []byte/[]rune？"}
    Q3 -- 是 --> SCONV["转换即拷贝 ✅"]
    Q3 -- 否 --> Q4{"接口 ↔ 具体类型？"}
    Q4 -- "接口 → 具体" --> ASSERT["类型断言 x.(T)"]
    Q4 -- "具体 → 接口" --> AUTO["自动装箱，无需写 ✅"]

精度丢失的方向

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

var f float64 = 3.99
fmt.Println(int(f))       // 截断，不是四舍五入

var neg float64 = -2.7
fmt.Println(int(neg))     // 向零截断，不是 floor

var negInt int = -1
fmt.Println(uint8(negInt)) // 回绕

var n int = 300
fmt.Println(uint8(n))      // 只保留低 8 位

var big int64 = 1 << 40
fmt.Println(int32(big))    // 只保留低 32 位，高位静默丢弃 ⚠️

1
2
3
4
5

3
-2
255
44
0

⚠️ 编译期能查的会报错，运行期不能查的静默截断：

1
2

var _ = uint8(300)      // 🛑 编译错误：constant 300 overflows uint8
var _ = int32(1 << 62)  // 🛑 编译错误：constant 4611686018427387904 overflows int32

但一旦经过变量，编译器就不再检查，直接静默截断/回绕。go vet 也管不了这个，只能靠代码审查和显式范围校验。

零值总表

Go 没有未初始化变量：声明即得零值。这张表要背下来，因为它解释了「为什么 nil map 能读不能写」这类问题。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

type S struct {
	A int
	B string
	C []int
	D map[string]int
	E *int
	F error
	G any
	H [2]int
	I func()
	J chan int
	K bool
}

var s S
fmt.Printf("%+v\n", s)

1

{A:0 B: C:[] D:map[] E:<nil> F:<nil> G:<nil> H:[0 0] I:<nil> J:<nil> K:false}

nil 容器三兄弟的行为差异

这是初学者最容易翻车的地方，单列出来：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

var c []int
func demo() {
	defer func() { fmt.Println("recover:", recover() != nil) }()

	var c []int
	c = append(c, 1)             // ✅ nil 切片可以直接 append
	fmt.Println(c, len(c), cap(c))

	var m map[string]int
	fmt.Println(m["x"], len(m))  // ✅ 读 nil map 是安全的

	m["x"] = 1                   // ❌ panic: assignment to entry in nil map
}

1
2
3

[1] 1 1
0 0
recover: true

⚠️ 最后一行是 defer 在 panic 展开时执行的输出，所以它出现在所有常规打印之后；m["x"] = 1 之后不会再有代码运行。

💡 实践结论：

• 切片不需要「先 make 才能用」，直接 var s []int + append 是惯用法，也是返回空结果的推荐做法（见 07 切片）。
• 映射必须 make 或字面量初始化后才能写。
• 通道的 nil 阻塞特性其实是有用的：在 select 里把某个 case 的通道设为 nil，就等于永久禁用该分支 🔥（见 12 select）。

浮点数的三个真相

真相一：常量精度高于运行时精度

Go 的无类型常量在编译期用任意精度计算，一旦落到变量上就退化成 IEEE-754：

1
2
3
4
5

fmt.Println("const: 0.1+0.2 == 0.3 ->", 0.1+0.2 == 0.3)

a, b, c := 0.1, 0.2, 0.3
fmt.Println("vars:  0.1+0.2 == 0.3 ->", a+b == c)
fmt.Printf("vars:  %v\n", a+b)

1
2
3

const: 0.1+0.2 == 0.3 -> true
vars:  0.1+0.2 == 0.3 -> false
vars:  0.30000000000000004

⚠️ 这意味着同一段算术，写成常量还是变量，结果可能不同。跨语言对比浮点行为时这是常见的困惑源。

真相二：float32 只有约 7 位有效数字

1
2

x, y, z := float32(0.1), float32(0.2), float32(0.3)
fmt.Println(float64(x+y), x+y == z)

1

0.30000001192092896 true

💡 默认一律用 float64。float32 只在明确为了省内存（大规模数组、图形/ML 数据）时使用。

真相三：浮点比较必须用误差容忍

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

// 🛑 不要这样比
if a+b == c { }

// ✅ 误差容忍
const eps = 1e-9
if math.Abs((a+b)-c) < eps { }

// ✅ 需要严格语义时用 math 的专用判断
math.IsNaN(f)      // NaN != NaN，必须用它
math.IsInf(f, 0)   // 判断 ±Inf

⚠️ NaN != NaN 恒为真。用 == 判 NaN 永远失败，用 math.IsNaN。同时 NaN 会让 map 的键行为异常（NaN 作键永远取不到），别拿浮点当 map 键。

类型别名 vs 类型定义

两者长得像，语义完全不同：

1
2
3
4

type MyInt int          // 类型定义：新类型，与 int 不通用 ⚠️
type AliasInt = int     // 类型别名：就是 int，完全等价 ✅
type Celsius float64    // 定义：可以给它挂方法
type ID = string       // 别名：ID 和 string 可以互相赋值

flowchart LR
    subgraph DEF["type MyInt int（定义）"]
        D1["MyInt 是独立类型"] --> D2["不能直接赋给 int<br/>需要 int(m)"]
        D2 --> D3["可以定义方法 ✅"]
    end
    subgraph ALI["type AliasInt = int（别名）"]
        A1["AliasInt 与 int 是同一个类型"] --> A2["互相赋值无需转换 ✅"]
        A2 --> A3["不能单独定义方法 ❌<br/>因为方法属于 int"]
    end

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

type Celsius float64
type Fahrenheit float64

func (c Celsius) ToF() Fahrenheit { return Fahrenheit(c*9/5 + 32) }

c := Celsius(100)
fmt.Println(c.ToF())          // 212
fmt.Println(c + 1.0)          // ✅ 101：1.0 是无类型常量，自动取 Celsius 类型

var f float64 = 1.5
// fmt.Println(c + f)         // 🛑 编译错误：Celsius 与 float64 不通用（两个都是【变量】）
fmt.Println(c + Celsius(f))   // ✅ 显式转换后才能相加

⚠️ 关键是分清「无类型常量」与「变量」：

本页陷阱速查

📘 官方参考：Spec — Types、The Go Blog — Strings, bytes, runes and characters in Go、Go 1.21 builtin min/max/clear

➡️ 上一节：02 词法与语法骨架 ｜ 下一节：04 变量·常量·iota