Go语言的100个错误使用场景（21-29）｜数据类型

目录

• 前言
• 3. Data types
  • 3.5 低效的切片初始化（#21）
  • 3.6 切片为 nil 与为空混淆（#22）
  • 3.7 没有正确检查切片是否为空（#23）
  • 3.8 错误的切片拷贝（#24）
  • 3.9 切片使用 append 的副作用（#25）
  • 3.10 切片和内存泄漏（#26）
  • 3.11 低效的 Map 初始化（#27）
  • 3.12 Map 和内存泄漏（#28）
  • 3.13 错误的值比较方式（#29）
• 小结

前言

大家好，这里是白泽。《Go语言的100个错误以及如何避免》是最近朋友推荐我阅读的书籍，我初步浏览之后，大为惊喜。就像这书中第一章的标题说到的：“Go: Simple to learn but hard to master”，整本书通过分析100个错误使用 Go 语言的场景，带你深入理解 Go 语言。

我的愿景是以这套文章，在保持权威性的基础上，脱离对原文的依赖，对这100个场景进行篇幅合适的中文讲解。所涉内容较多，总计约 8w 字，这是该系列的第三篇文章，对应书中第21-29个错误场景。

🌟 当然，如果您是一位 Go 学习的新手，您可以在我开源的学习仓库中，找到针对《Go 程序设计语言》英文书籍的配套笔记，期待您的 star。

公众号【白泽talk】，聊天交流群：622383022，原书电子版可以加群获取。

前文链接：

• 《Go语言的100个错误使用场景（1-10）｜代码和项目组织》
• 《Go语言的100个错误使用场景（11-20）｜项目组织和数据类型》

3. Data types

🌟 章节概述：

• 基本类型涉及的常见错误
• 掌握 slice 和 map 的基本概念，避免使用时产生 bug
• 值的比较

3.5 低效的切片初始化（#21）

实现一个 conver 方法，将一个切片 Foo 转换成另一个类型的切片 Bar，这里给出三种实现方式：

// 方式一
func convert(foos []Foo) []Bar {
    bars := make([]Bar, 0)
    
    for _, foo := range foos {
        bars = append(bars, fooToBar(foo))
    }
    return bars
}
// 方式二
func convert(foos []Foo) []Bar {
    n := len(foos)
    // 设置容量但是不设置长度，此时append调用会从0索引开始为底层数组赋值
    bars := make([]Bar, 0, n)
    
    for _, foo := range foos {
        bars = append(bars, fooToBar(foo))
    }
    return bars
}
// 方式三
func convert(foo []Foo) []Bar {
    n := len(foo)
    // 设置len之后，会初始化这部分的值为Foo的零值，此时append会追加在len之后，触发扩容
    bars := make([]Bar, n)
    
    for i, foo := range foos {
        bars[i] = fooToBar(foo)
    }
    return bars
}

• 方式一：由于没有初始化切片的长度，因此切片随着 append 逐渐扩容，不断替换底层数组，增加 GC 压力，在已知切片长度的时候，不推荐使用。
• 方式二和方式三：单就性能来说方式三会更好一点，因为不用调用 append 操作。但是在大多数情况下方式二的表述更为清晰。因为如果遇到 convert 方法内有复杂逻辑，直接使用索引去为 bars[i] 设置值不太方便。

🌟 如果有一个场景是需要将一个 Foo 切片转换成一个两倍长度的 Bar 切片，则使用索引复制的方式看起来将不太清晰，且不易维护：

// 方式二
func convert(foos []Foo) []Bar {
    n := len(foos)
    // 设置容量但是不设置长度，此时append调用会从0索引开始为底层数组赋值
    bars := make([]Bar, 0, 2*n)
    
    for _, foo := range foos {
        bars = append(bars, fooToBar(foo))
        bars = append(bars, fooToBar(foo))
    }
    return bars
}
// 方式三
func convert(foo []Foo) []Bar {
    n := len(foo)
    // 设置len之后，会初始化这部分的值为Foo的零值，此时append会追加在len之后，触发扩容
    bars := make([]Bar, 2*n)
    
    for i, foo := range foos {
        bars[2*i] = fooToBar(foo)
        bars[2*i+1] = fooToBar(foo)
    }
    return bars
}

3.6 切片为 nil 与为空混淆（#22）

两个概念：

• 一个切片为空，如果它的长度是0
• 一个切片为nil，如果这个切片等于nil

func main {
    var s []string // 方式一
    long(1, s) 
    
    s = []string(nil) // 方式二
    log(2, s)
    
    s = []string{} // 方式三
    log(3, s)
    
    s = make([]string, 0) // 方式四
    log(4, s)
}

func log(i int, s []string) {
    fmt.Printf("%d: empty=%t\tnil=%t\n", i, len(s) == 0, s == nil)
}
// 输出结果
1: empty=true nil=true // 方式一
2: empty=true nil=true // 方式二
3: empty=true nil=false // 方式三
4: empty=true nil=false // 方式四

所有切片的 len 都是0，因此 nil 切片也是空切片。在探究哪种初始化切片之前，需要提示两点：

• 空切片和 nil 切片的区别在于是否分配地址，初始化一个 nil 切片不会发生地址分配（底层数组）。
• 无论切片是空还是 nil，内置的 append 方法都可以直接调用。

因此如果需要初始化一个 nil 切片，推荐上述方式一（var s []string）；如果需要初始化一个长度为0的空切片，则使用方式四（make([]string, 0)）。

当然如果你需要初始化一个已知长度的切片，不仅仅是空切片，也推荐方式四：

func intsToStrings(ints []int) []string {
    // 使用 make([]string, 0, len(ints)) 以及 append 的方式也是可以的
    s := make([]string, len(ints))
    for i, v := range ints {
        s[i] = strconv.Itoa(v)
    }
}

• 方式二的意义：

s := append([]string(nil), "32")

类似语法糖的用法，可以用一行代码完成切片初始化和添加元素的编写。

• 方式三使用场景分析：

s := []string{"1", "2", "3"}

如果初始化切片但是不设置初始元素 s := []string{}，则不如使用方式一 var s []string 进行初始化。方式三应该用在需要指定初始化值的切片时。

留意空切片（empty but non-nil）和 nil 切片（empty and nil）在一些库中会发生不同处理：

• encoding/json 库中，针对 marshal 序列化方法，空切片序列化为 []，而 nil 切片序列化为 null。
• 标准库 reflect.DeepEqual 方法中，比较 nil 和 空切片返回 false。

3.7 没有正确检查切片是否为空（#23）

示例代码1:

func handleOperations(id string) {
    operations := getOperations(id)
    if operations != nil {
        handle(operations)
    }
}

func getOperations(id string) []float32 {
    operations := make([]float32, 0)
    
    if if == "" {
        return operations
    }
    // ... 相关逻辑
    
    return operations
}

假设调用 getOperations 得到 []float32 切片后，通过判断它是否为 nil 来决定是否执行 handle 方法，但事实上，getOperations 方法从来都不会返回 nil，因此这种情况下 handle(operations) 一定会触发。

此时有两种修改方式：

1. 修改被调用方（不推荐）：

func getOperations(id string) []float32 {
    operations := make([]float32, 0)
    
    if if == "" {
        return nil // 返回一个 nil 切片
    }
    return operations
}

此时调用方代码中 operations != nil 确实可以生效，但是作为被调用方的函数来说，本身是无法预计所有被调用的场景的，并且什么时候返回 nil，什么时候返回空，不应该通过习惯去约束。

🌟 而应该在在调用方 handleOperations 侧做更通用的判断。

2. 修改调用方：

func handleOperations(id string) {
    operations := getOperations(id)
    if len(operations) != 0 {
        handle(operations)
    }
}

因为无论切片是 nil 还是空，都会满足 len(operations) != 0 这个条件。

3.8 错误的切片拷贝（#24）

错误示例：

src := []int{0, 1, 2}
var dst []int
copy(dst, src)
fmt.Println(dst) // 输出 [] 而不是 [0, 1, 2]

原因在于内置的 copy 函数，拷贝的切片的元素个数等于：min(len(dst), len(src))

修正方案：

src := []int{0, 1, 2}
dst := make([]int, len(src))
copy(dst, src)
fmt.Println(dst) // 输出 [0, 1, 2]

通过 append 方法实现拷贝切片的功能：

src := []int{0, 1, 2}
dst := append([]int(nil), src...)

通过这种方式，将一个切片追加到一个 nil 切片之中，此时 dst 切片的长度和容量都为3。

3.9 切片使用 append 的副作用（#25）

示例代码：

s1 := []int{1, 2, 3}
s2 := s1[1:2]
s3 := append(s2, 10)
fmt.Println(s1, s2, s3) // [1, 2, 10] [2] [2, 10]

当执行完上述第三行代码，s1 切片的第三个元素也发生了修改。

这种情况也发生在将切片作为参数传递给某个函数：

func main() {
    s := []int{1, 2, 3}
    
    f(s[:2])
    fmt.Println(s) // [1, 2, 10]
}

func f(s []int) {
    _ = append(s, 10)
}

🌟 有两种方法可以避免这个问题。

方法一：

func main() {
    s := []int{1, 2, 3}
    sCopy := make([]int, 2)
    copy(sCopy, s)
    
    f(sCopy)
    fmt.Println(s) // [1, 2, 3]
}

在传入切片之前，将其通过 copy 函数拷贝一份，则无论其是否在 f 中被改动，将不会影响 s。

方法二：

func main() {
    s := []int{1, 2, 3}
    f(s[:2:2])
}

切片截取 s[low:high:max] 前两个参数左闭右开控制切片区间，第三个参数控制新切片的容量（max-low）。

由于此时通过 s[:2:2] 创建的切片容量是2，如果在 f 函数内对其进行 append 操作时，由于 len 已经等于 cap，将触发扩容，导致其底层数组将引用一个新的二倍扩容后的数组。

3.10 切片和内存泄漏（#26）

🌟 场景一：切片容量泄漏

func consumeMessages() {
    for {
        msg := receiveMessage() // 假设每次msg都是一个长度为1000000的字节切片
        storeMessageType(getMessageType(msg))
    }
}

// 字符切片截取函数，截取前5个字符
func getMessageType(msg []byte) []byte {
    return msg[:5]
}

这个场景不断输入大小为 1M 的字节切片，截取前五个字节存储。如果一共有1000个切片传入，程序运行之后，内存占用将达到1G。

分析原因：

for 循环内，getMessageType() 函数每次在调用之后，虽然 msg 切片变量已经不在被引用，从而被 GC 回收，但是底层的数组没有收到影响。

即 getMessageType() 函数每次截取前5个字符，但是 msg[:5] 切片的 cap 值依旧是1M，Go 语言并不会自动回收其余部分的内存占用。

解决方案：

// 有效方案
func getMessageType(msg []byte) []byte {
    msgType := make([]byte, 5)
    copy(msgType, msg)
    return msgType
}
// 无效方案
func getMessageType(msg []byte) []byte {
    return msg[:5:5]
}

通过 copy 创建新的切片存放5个字节，使得原 msg 以及底层数组解除引用从而在 for 循环后被 GC 回收。但是通过 msg[:5:5] 方式创建切片，虽然限制了索引5之后的位置的访问，但是 Go 语言目前不支持自动回收这部分无法访问的内存。

🌟 场景二：切片和引用

type Foo struct {
	v []byte
}

func main() {
	foos := make([]Foo, 1_000)
	printAlloc()

	for i := 0; i < len(foos); i++ {
		foos[i] = Foo{
			v: make([]byte, 1024*1024),
		}
	}
	printAlloc()

	two := keepFirstTwoElementsOnly(foos)
	runtime.GC()
	printAlloc()
	runtime.KeepAlive(two) // 保持对变量two的引用
}

func keepFirstTwoElementsOnly(foos []Foo) []Foo {
	return foos[:2]
}

func printAlloc() {
	var m runtime.MemStats // 记录内存分配
	runtime.ReadMemStats(&m)
	fmt.Printf("%d KB\n", m.Alloc/1024)
}
// 结果展示
95 KB // 分配了1000个零值的 Foo 结构
1024098 KB // 为长度为1000的 Foo 切片的 v 属性分配内存1024*1024
1024101 KB // 虽然截取前两个元素，但是后998个Foo以及其内部v的内存依旧占用

⚠️ 注意：如果切片的元素是引用类型或者是一个内部有引用类型的结构，在这个元素被回收之前，则这个元素所指向内容将不会被 GC 自动回收。（引用链依旧存在）

解决方案：

// 方式一
func keepFirstTwoElementsOnly(foos []Foo) []Foo {
    res := make([]Foo, 2)
    copy(res, foos)
    return res
}
// 方式二
func keepFirstTwoElementsOnly(foos []Foo) []Foo {
    for i := 2; i < len(foos); i++ {
        foos[i].v = nil
    }
    return foos[:2]
}

方式一：通过上面反复提及的 copy 创建一个新的切片实现赋值，此时新切片 len 和 cap 都是2。原切片 foos 由于不再被引用，则整体全部被 GC 回收，包括每个 Foo 结构的 v 切片。

方式二：通过手动将索引2至999的 Foo 结构的 v 切片手动设置为 nil，此时后998个 Foo 元素的 v 切片底层数组失去引用，会被 GC 回收。与方式一的区别在于，for 循环之后，foos[:2] 新切片 len 为2但是 cap 依旧为1000。

🌟 使用这两种方案自行权衡效率，方案一需要遍历0至i-1的元素，方案二需要遍历i至n-1的元素。

3.11 低效的 Map 初始化（#27）

🌟 map 的实现：

map 本质是一个 hash table，以数组的形式组织一系列的 bucket，每个 bucket 固定存放8个键值对，根据 key 的 hash 结果，决定这个 key-value 存放在哪个索引的 bucket 中。

如果相同 hash 值的键值对超过8个，则会创建一个新的 bucket，被前一个 bucket 链式引用，因此最差情况下，查询效率会退化成 O(p)，p 等价于这个 bucket 链条中键值对的个数。

🌟 map 的初始化：

mp := map[string]int {
    "1": 1,
    "2", 2,
    "3", 3
}

当逐渐向这个 map 添加 1_000_000 个键值对，达到某些条件时会触发 map 的扩容，因为 map 的设计上不会允许 hash 值相同的 bucket 链无限延长，这失去了 hash table 的效率。

🌟 扩容时机：

1. 负载因子：当 bucket 的平均容量超过6.5。
2. 太多的 bucket 溢出（包含超过8个键值对）。

在这两种情况下，map 会触发扩容，增加 hash array 的长度，并重建整个 map，重新整理和平衡各个 bucket 链。这种情况下，会导致绝大多数键值对重新分配，因此简单的一次 insert 操作，性能可能就跌落为 O(N)，N 为当前 map 的所有键值对数量。

🌟 高效的初始化：

mp := make(map[string]int, 1_000_000)

与切片的初始化类似，通过指定希望存放的键值对的个数，map 的内置初始化流程会根据输入的容量，创建一个合适大小的 map。这为后续存入 1_000_000 免去了 map 扩容导致的重建开销。

同样的，指定 1_000_000 大小，不意味着这个 map 只能存放这么多键值对，这只是提示给 Go runtime 去分配至少能容纳 1_000_000 键值对的空间。

// 分配1_000_000容量的 banchmarks，性能相差约60%
InitiateMapWithoutSize  6       227413490 ns/op
InitiateMapWithSize     13		 91174193 ns/op

3.12 Map 和内存泄漏（#28）

概念：Go 语言的 Map 只能增长大小，并不能自动收缩，即使内部元素被删除。

场景分析：

n := 1_000_000
m := make(map[int][128]byte)
printAlloc()

for i := 0; i < n; i++ {
    m[i] = randBytes() // 获取长度128的字符切片
}
printAlloc()

for i := 0; i < n; i++ {
    delete(m, i)
}

runtime.GC()
printAlloc()
runtime.KeepAlive(m) // 保持对m的引用，避免被回收
// 打印结果展示
0 MB
461 MB
293 MB

第一次打印：由于初始化的是空的切片，因此没有分配内存。

第二次打印：添加了一百万个字符数组。

第三次打印：虽然从 map 中删除了这一百万个字符数组，但是内存占用依旧很大。

🌟 原因分析：

type hmap struct {
    B uint8 // 2^B 个 buckets
    // ...
}

Go 语言的 map 底层实现是一个 hmap 结构，有一个 B 字段存放 map 的 buckets 的个数，这个场景下，存放 1_000_000 个键值对，B == 18，2^18 == 262144 个 buckets。

当 delete 1_000_000 个键值对之后，B 依旧是18，意味着 buckets 没有减少，只是将 bucket 对应的插槽设置为0值。

因此如果用 map 做缓存，当 map 某一时间段扩容到很大情况时，后续访问量下降，这个 map 还是占用很大的内存空间。

🌟 解决方案：

• 方案一：使用 map 做缓存，则根据时间，定期新创建一个 map，去存放旧 map 的元素，人工去释放旧 map。（缺点在于在下次 GC 触发之前，会占用两倍内存，并且拷贝 map 中元素也需要花费时间，同时需要考虑并发安全）。
• 方案二：将键值对的值元素使用指针替换：map[int]*[128]byte，这种情况下，bucket 中 value 占用的内存将限制在一个指针的大小（bucket 的插槽变小了），通过 delete 操作删除所有键值对，最后即使 map 的 bucket 数量无法减少，但是占用内存减少比较明显。（因为实际指向的 [128]byte 数组失去了引用，被回收）。

⚠️ 注意：当使用 map 时，如果 key/value 的长度超过 128 bytes，Go 将会默认使用指针存放 bucket 的键值对。

3.13 错误的值比较方式（#29）

使用逻辑运算符不可比较的数据类型：

• 切片
• map

使用逻辑运算符可比较的数据类型：

• 布尔型：比较两个 Booleans 是否相等
• 数值型：比较数值是否相等
• Strings：比较字符串是否相等
• Channels：比较两个 channel 是否通过相同的 make 创建，或者是否都是 nil
• Interfaces：比较两个接口的动态类型和动态值，或者是否都是 nil
• Pointers：比较两个指针指向的内存中的 value 是否相等，或者是否都是 nil
• 结构体和数组：整合上述可比较的数据类型，依次比较

针对不可使用逻辑运算符比较的数据类型，可以使用 Go 的反射去实现运行时的比较（递归），使用前建议阅读文档：

cust1 := customer{id: "x", operations: []float64{1.}}
cust2 := customer{id: "x", operations: []float64{1.}}
fmt.Println(reflect.DeepEqual(cust1, cust2)) // true

此时即使结构体存在不可比较的切片类型，依旧可以打印出 true。

🌟 使用反射比较需要注意的点：

1. 集合为空和集合为 nil 是不同的概念（这在 #22 中提到了），需要留意。
2. 反射是在运行时确定值的，因此性能很差，通常来说比 == 差两个数量级（100倍）。因此反射可以使用在单元测试中，而不是程序运行时。

自定义 compare 方法代替 reflect.DeepEqual()：

func (a customer) equal(b customer) bool {
    if a.id != b.id {
        return false
    }
    if len(a.operations) != len(b.operations) {
        return false
    }
    for i := 0; i < len(a.operations); i++ {
        if a.operations[i] != b.operations[i] {
            return false
        }
    }
    return true
}

经过 benchmark 测试，使用自定义的 equal 方法比较两个切片是否相等，比使用反射快96倍。

📒 提示：针对数据类型的比较，可以选择开源的第三方的库。

小结

你已完成全书学习进度30/100，喝杯咖啡休息一下吧。