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

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

耐心和持久胜过激烈和狂热。

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

前言

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

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

s.png

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

s.jpg

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


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

由于原切片 s 的长度为 3array 指针所指向的区域只有 [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 参数。

小结

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

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

目录
相关文章
|
6天前
|
存储 JSON 监控
Viper,一个Go语言配置管理神器!
Viper 是一个功能强大的 Go 语言配置管理库,支持从多种来源读取配置,包括文件、环境变量、远程配置中心等。本文详细介绍了 Viper 的核心特性和使用方法,包括从本地 YAML 文件和 Consul 远程配置中心读取配置的示例。Viper 的多来源配置、动态配置和轻松集成特性使其成为管理复杂应用配置的理想选择。
23 2
|
10天前
|
JavaScript Java Go
探索Go语言在微服务架构中的优势
在微服务架构的浪潮中,Go语言以其简洁、高效和并发处理能力脱颖而出。本文将深入探讨Go语言在构建微服务时的性能优势,包括其在内存管理、网络编程、并发模型以及工具链支持方面的特点。通过对比其他流行语言,我们将揭示Go语言如何成为微服务架构中的一股清流。
102 53
|
4天前
|
Go 索引
go语言中的循环语句
【11月更文挑战第4天】
13 2
|
4天前
|
Go C++
go语言中的条件语句
【11月更文挑战第4天】
16 2
|
9天前
|
Ubuntu 编译器 Linux
go语言中SQLite3驱动安装
【11月更文挑战第2天】
31 7
|
9天前
|
关系型数据库 Go 网络安全
go语言中PostgreSQL驱动安装
【11月更文挑战第2天】
38 5
|
9天前
|
安全 Go
用 Zap 轻松搞定 Go 语言中的结构化日志
在现代应用程序开发中,日志记录至关重要。Go 语言中有许多日志库,而 Zap 因其高性能和灵活性脱颖而出。本文详细介绍如何在 Go 项目中使用 Zap 进行结构化日志记录,并展示如何定制日志输出,满足生产环境需求。通过基础示例、SugaredLogger 的便捷使用以及自定义日志配置,帮助你在实际开发中高效管理日志。
25 1
|
8天前
|
程序员 Go
go语言中的控制结构
【11月更文挑战第3天】
85 58
|
7天前
|
监控 Go API
Go语言在微服务架构中的应用实践
在微服务架构的浪潮中,Go语言以其简洁、高效和并发处理能力脱颖而出,成为构建微服务的理想选择。本文将探讨Go语言在微服务架构中的应用实践,包括Go语言的特性如何适应微服务架构的需求,以及在实际开发中如何利用Go语言的特性来提高服务的性能和可维护性。我们将通过一个具体的案例分析,展示Go语言在微服务开发中的优势,并讨论在实际应用中可能遇到的挑战和解决方案。
|
8天前
|
存储 编译器 Go
go语言中的变量、常量、数据类型
【11月更文挑战第3天】
25 9