Go 语言中的 Slice 陷阱：如何避免常见错误

时间：2023-02-14 07:17:17

耐心和持久胜过激烈和*。

哈喽大家好，我是陈明勇，本文介绍的内容是 Go 语言中的 ​​Slice​​ 的常见陷阱以及如何避免这些错误。如果本文对你有帮助，不妨点个赞，如果你是 ​​Go​​ 语言初学者，不妨点个关注，一起成长一起进步，如果本文有错误的地方，欢迎指出！

前言

​​Go​​ 语言提供了很多方便的数据类型，其中包括 ​​slice​​。然而，由于 ​​slice​​ 的特殊性质，在使用过程中易犯一些错误，如果不注意，可能导致程序出现意外行为。本文将详细介绍 使用 ​​slice​​ 时易犯的一些错误，帮助读者更好的使用 ​​Go​​ 的 ​​slice​​，避免犯错误。

slice 作为函数 / 方法的参数进行传递的陷阱

​​slice​​ 作为参数进行传递，有一些地方需要注意，先说结论：

  • 1、在函数里修改切片元素的值，原切片的值也会被改变；
  • 若想修改新切片的值，而不影响原切片的值，可以对原切片进行深拷贝：
  • 通过 ​​copy(dst, src []Type) int ​​ 函数将原切片的元素拷贝到新切片中：此函数在拷贝时，会基于两个切片中，最小长度为基础去拷贝，也就是初始化新切片时，长度必须大于等于原切片的长度。
  • 2、在函数里通过 append 方法，对切片执行追加元素的操作，可能会引起切片扩容，导致内存分配的问题，可能会对程序的性能 造成影响；
  • 为避免切片扩容，导致内存分配，对程序的性能造成影响，在初始化切片时，应该根据使用场景，指定一个合理 ​​cap​​ 参数。
  • 3、在函数里通过 append 函数，对切片执行追加元素的操作，原切片里不存在新元素。
  • 若想实现执行 ​​append​​ 函数之后，原切片也能得到新元素；需将函数的参数类型由 切片类型 改成 切片指针类型。

通过例子来感受一下上面结论的由来：

package main

import "fmt"

func main() {
   s := []int{0, 2, 3}
   fmt.Printf("切片的长度：%d, 切片的容量：%d, 切片的元素：%v\n", len(s), cap(s), s) // 3 3 [0, 2, 3]
   sliceOperation(s)
   fmt.Printf("切片的长度：%d, 切片的容量：%d, 切片的元素：%v\n", len(s), cap(s), s) // 3 3 [1, 2, 3]
}

func sliceOperation(s []int) {
   s[0] = 1
   s = append(s, 4)
   fmt.Printf("切片的长度：%d, 切片的容量：%d, 切片的元素：%v\n", len(s), cap(s), s) // 4 6 [1, 2, 3]
}
  • 首先定义并初始化切片 ​​s​​，切片里有三个元素；
  • 调用 ​​sliceOperation​​ 函数，将切片作为参数进行传递；
  • 在函数里修改切片的第一个元素的值为 ​​1​​，然后通过 ​​append​​ 函数插入元素 ​​4​​，此时函数里的切片 由于容量不够，​​s​​ 的容量被扩大了，变成 ​​原 cap * 2 = 3 * 2 = 6​​；
  • 打印结果已注释在代码里，通过打印结果可知：
  • 在函数里修改切片的第一个元素的值，原切片元素的值也会改变；
  • 在函数里通过 ​​append​​ 函数，向切片追加元素 4，原切片并没有此元素；
  • 函数里的切片扩容了，原切片却没有。

由于切片是引用类型，因此在函数修改切片元素的值，原切片的元素值也会改变。

有的人可能会产生以下两个疑问：

  • 1、既然切片是引用类型，为什么通过 ​​append​​ 追加元素，原切片 ​​s​​ 却没有新元素？
  • 2、为什么函数里的切片扩容了，原切片却没有？

在探究这两个问题之前，我们需要了解切片的数据结构：

type slice struct {
   array unsafe.Pointer
   len   int
   cap   int
}

切片包含三个字段：​​array​​ (指针类型，指向一个数组)、​​len​​ (切片的长度)、​​cap​​ (切片的容量)。

知道了切片的数据结构，我们通过图片来直观地看看切片 ​​s​​：

Go 语言中的 Slice 陷阱：如何避免常见错误

切片 ​​s​​​ 没有被修改之前，在内存中是以上图所描述的形式存在，​​array​​​ 指针变量指向数组 ​​[0, 2, 3]​​​，长度为 ​​3​​​，容量为 ​​3​​。

Go 语言中的 Slice 陷阱：如何避免常见错误

在执行 ​​sliceOperation​​​ 函数之后，原切片 ​​s​​​ 和 ​​sliceOperation​​​ 函数里的切片 ​​s​​ 如上图所示。

通过上上图和上图对比可知，底层数组 ​​[0, 2, 3]​​ 的第一个元素的值被修改为 ​​1​​，然后追加元素 ​​4​​，此时函数里的切片发生变化，长度 ​​3 → 4​​，容量 ​​3 → 6​​ 变成原来的两倍，底层数组的长度也由 ​​3 → 6​​。

由于原切片 ​​s​​​ 的长度为 ​​3​​，​​array​​ 指针所指向的区域只有 ​​[1, 2, 3]​​，这也是为什么在函数里新增了 元素 ​​4​​，在原切片 ​​s​​ 里看不到的原因。

第一个问题解决了，我们来思考第二个问题的原因：

在 ​​Go​​ 中，函数 / 方法的参数传递方式为值传递，​​main​​ 函数将 ​​s​​ 传递过来，​​sliceOperation​​ 函数用 ​​s​​ 去接收，此时的 ​​s​​​ 为新的切片，只不过它们所指向的底层数组为同一个，长度和容量也是一样。而扩容操作是在新切片上进行的，因此原切片不受影响。

slice 通过 make 函数初始化，后续操作不当所造成的陷阱

使用 ​​make​​ 函数初始化切片后，如果在后续操作中没有正确处理切片长度，容易造成以下陷阱：

  • 越界访问：如果访问超出切片实际长度的索引，则会导致 ​​index out of range​​ 错误，例如：
func main() {
   s := make([]int, 0, 4)
   s[0] = 1 // panic: runtime error: index out of range [0] with length 0
}
  • 通过 ​​make([]int, 0, 4)​​ 初始化切片，虽说容量为 4，但是长度为 0，如果通过索引去赋值，会发生panic；为避免 ​​panic​​，可以通过 ​​s := make([]int, 4)​​ 或 ​​s := make([]int, 4, 4)​​ 对切片进行初始化。
  • 切片初始化不当，通过 ​​append​​ 函数追加新元素的位置可能于预料之外
func main() {
   s := make([]int, 4)
   s = append(s, 1)
   fmt.Println(s[0]) // 0

   s2 := make([]int, 0, 4)
   s2 = append(s2, 1)
   fmt.Println(s2[0]) // 1
}
  • 通过打印结果可知，对于切片 ​​s​​，元素 ​​1​​ 没有被放置在第一个位置，而对于切片 ​​s2​​，元素 ​​1​​ 被放置在切片的第一个位置。这是因为通过 ​​make([]int, 4)​​ 和 ​​make([]int, 0, 4)​​ 初始化切片，底层所指向的数组的值是不一样的：
  • 第一种初始化的方式，切片的长度和容量都为 4，底层所指向的数组长度也是 4，数组的值为 [0, 0, 0, 0]，每个位置的元素被赋值为零值，s = append(s, 1) 执行后，s 切片的值为 [0, 0, 0, 0, 1]；
  • 第二种初始化的方式，切片的长度为 0，容量为 4，底层所指向的数组长度为 0，数组的值为 []，s2 = append(s2, 1) 执行后，s2 切片的值为 [1]；
  • 通过 append 向切片追加元素，会执行尾插操作。如果我们需要初始化一个空切片，然后从第一个位置开始插入元素，需要避免 make([]int, 4) 这种初始化的方式，否则添加的结果会在预料之外。

性能陷阱

  • 内存泄露
    内存泄露是指程序分配内存后不再使用该内存，但未将其释放，导致内存资源被浪费。
    切片引用切片场景：如果一个切片有大量的元素，而它只有少部分元素被引用，其他元素存在于内存中，但是没有被使用，则会造成内存泄露。代码示例如下：
var s []int

  func main() {
     sliceOperation()
     fmt.Println(s)
  }

  func sliceOperation() {
     a := make([]int, 0, 10)
     a = append(a, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
     s = a[0:4]
  }

上述代码中，切片 ​​a​​ 的元素有 ​​10​​ 个，而切片 ​​s​​ 是基于 ​​a​​ 创建的，它底层所指向的数组与 ​​a​​ 所指向的数组是同一个，只不过范围为前四个元素，而后六个元素依然存在于内存中，却没有被使用，这样会造成内存泄露。为了避免内存泄露，我们可以对代码进行改造：
​​s = a[0:4]​​ → ​​s = append(s, a[0:4]...)​​，通过 ​​append​​ 进行元素追加，这样切片 ​​a​​ 底层的数组没有被引用，后面会被 ​​gc​​。

  • 扩容
    扩容陷阱在前面的例子也提到过，通过 append 方法，对切片执行追加元素的操作，可能会引起切片扩容，导致内存分配的问题。
func main() {
     s := make([]int, 0, 4)
     fmt.Printf("切片的长度：%d, 切片的容量：%d\n", len(s), cap(s)) // 4 4
     s = append(s, 1, 2, 3, 4, 5)
     fmt.Printf("切片的长度：%d, 切片的容量：%d\n", len(s), cap(s)) // 5 8
  }

切片扩容，可能会对程序的性能 造成影响；为避免此情况的发生，应该根据使用场景，估算切片的容量，指定一个合理 ​​cap​​ 参数。

小结

本篇文章主要介绍了使用 ​​Go​​​ ​​slice​​​ 的过程中可能会遇到的陷阱以及如何避免这些错误，帮助读者更好地使用 ​​Go​​​ ​​slice​​。

如果读者有遇到别的陷阱，欢迎在评论区留言探讨。

标签：

相关文章