Golang

关注公众号 jb51net

关闭
首页 > 脚本专栏 > Golang > go slice 数组切片区别

go slice 数组和切片使用区别示例解析

作者:eleven26

这篇文章主要为大家介绍了go slice 数组和切片使用区别示例解析,有需要的朋友可以借鉴参考下,希望能够有所帮助,祝大家多多进步,早日升职加薪

正文

slice(切片)是 go 里面非常常用的一种数据结构,它代表了一个变长的序列,序列中的每个元素都有相同的数据类型。 一个 slice 类型一般写作 []T,其中 T 代表 slice 中元素的类型;slice 的语法和数组很像,但是 slice 没有固定长度。

数组和切片的区别

数组有确定的长度,而切片的长度不固定,并且可以自动扩容。

数组的定义

go 中定义数组的方式有如下两种:

arr := [3]int{1, 2, 3}
arr := [...]{1, 2, 3}

上面这两种定义方式都定义了一个长度为 3 的数组。正如我们所见,长度是数组的一部分,定义数组的时候长度已经确定下来了

切片的定义

切片的定义方式跟数组很像,只不过定义切片的时候不用指定长度

s := []int{1, 2, 3}

在上面定义切片的代码中,我们可以看到其实跟数组唯一的区别就是少了个长度。 那其实我们可以把切片看作是一个无限长度的数组。 当然,实际上它并不是无限的,它只是在切片容纳不下新的元素的时候,会自动进行扩容,从而可以容纳更多的元素。

数组和切片的相似之处

正如我们上面看到的那样,数组和切片两者其实非常相似,在实际使用中,它们也是有些类似的。

比如,通过下标来访问元素:

arr := [3]int{1, 2, 3}
// 通过下标访问
fmt.Println(arr[1]) // 2
s := []int{1, 2, 3}
// 通过下标访问
fmt.Println(s[1]) // 2

数组的局限

我们知道了,数组的长度是固定的,这也就意味着如果我们想往数组里面增加一个元素会比较麻烦, 我们需要新建一个更大的数组,然后将旧的数据复制过去,然后将新的元素写进去,如:

// 往数组 arr 增加一个元素:4
arr := [3]int{1, 2, 3}
// 新建一个更大容量的数组
var arr1 [4]int
// 复制旧数组的数据
for i := 0; i < len(arr); i++ {
    arr1[i] = arr[i]
}
// 加入新的元素:4
arr1[3] = 4
fmt.Println(arr1)

这样一来就非常的繁琐,如果我们使用切片,就可以省去这些步骤:

// 定义一个长度为 3 的数组
arr := [3]int{1, 2, 3}
// 从数组创建一个切片
s := arr[:]
// 增加一个元素
s = append(s, 4)
fmt.Println(s)

因为数组固定长度的缺点,实际使用中切片会使用得更加普遍。

重新理解 slice

在开始之前,我们来看看 slice 这个单词的意思:作为名词,slice 的意思有 片;部分;(切下的食物)薄片;,作为动词,slice 的意思有 切;把…切成(薄)片; 的意思。 从这个角度出发,我们可以把 slice 理解为从某个数组上 切下来的一部分(从这个角度看,slice 这个命名非常的形象)。我们可以看看下图:

在这个图中,A 是一个保存了数字 1~7sliceB 是从 A切下来的一部分,而 B 只包含了 A 中的一部分数据。 我们可以把 B 理解为 A 的一个 视图,B 中的数据是 A 中的数据的一个 引用,而不是 A 中数据的一个 拷贝 (也就是说,我们修改 B 的时候,A 中的数据也会被修改,当然会有例外,那就是 B 发生扩容的时候,再去修改 B 的话就影响不了 A 了)。

slice 的内存布局

现在假设我们有如下代码:

// 创建一个切片,长度为 3,容量为 7
var s = make([]int, 3, 7)
s[0] = 1
s[1] = 2
s[2] = 3
fmt.Println(s)

对应的内存布局如下:

说明:

切片容量存在的意义

对于我们日常开发来说,slice 的容量其实大多数时候不是我们需要关注的点,而且由于容量的存在,也给开发者带来了一定的困惑。 那么容量存在的意义是什么呢?意义就在于避免内存的频繁分配带来的性能下降(容量也就是提前分配的内存大小)。

比如,假如我们有一个切片,然后我们知道需要往它里面存放 1w 个元素, 如果我们不指定容量的话,那么切片就会在它存放不下新的元素的时候进行扩容, 这样一来,可能在我们存放这 1w 个元素的时候需要进行多次扩容, 这也就意味着需要进行多次的内存分配。这样就会影响应用的性能。

我们可以通过下面的例子来简单了解一下:

// Benchmark1-20       100000000          11.68 ns/op
func Benchmark1(b *testing.B) {
   var s []int
   for i := 0; i < b.N; i++ {
      s = append(s, 1)
   }
}
// Benchmark2-20       134283985           7.482 ns/op
func Benchmark2(b *testing.B) {
   var s []int = make([]int, 10, 100000000)
   for i := 0; i < b.N; i++ {
      s = append(s, 1)
   }
}

在第一个例子中,没有给 slice 设置容量,这样它就只会在切片容纳不下新元素的时候才会进行扩容,这样就会需要进行多次扩容。 而第二个例子中,我们先给 slice 设置了一个足够大的容量,那么它就不需要进行频繁扩容了。

最终我们发现,在给切片提前设置容量的情况下,会有一定的性能提升。

切片常用操作

创建切片

我们可以从数组或切片生成新的切片:

注意:生成的切片不包含 end

target[start:end]

说明:

如:

s := []int{1, 2, 3}
s1 := s[1:2]    // 包含下标 1,不包含下标 2
fmt.Println(s1) // [2]
arr := [3]int{1, 2, 3}
s2 := arr[1:2]
fmt.Println(s2) // [2]

在这种初始化方式中,我们可以省略 start

arr := [3]int{1, 2, 3}
fmt.Println(arr[:2]) // [1, 2]

省略 start 的情况下,就是从 target 的第一个元素开始。

我们也可以省略 end

arr := [3]int{1, 2, 3}
fmt.Println(arr[1:]) // [2, 3]

省略 end 的情况下,就是从 start 索引处的元素开始直到 target 的最后一个元素处。

除此之外,我们还可以指定新的切片的容量,通过如下这种方式:

target[start:end:cap]

例子:

arr := [10]int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
s := arr[1:4:5]
fmt.Println(s, len(s), cap(s)) // [2 3 4] 3 4

往切片中添加元素

我们前面说过了,如果我们想往数组里面增加元素,那么我们必须开辟新的内存,将旧的数组复制过去,然后才能将新的元素加入进去。

但是切片就相对简单,我们可以使用 append 这个内置函数来往切片中加入新的元素:

var a []int
a = append(a, 1) // 追加1个元素
a = append(a, 1, 2, 3) // 追加多个元素
a = append(a, []int{1,2,3}...) // 追加一个切片

切片复制

go 有一个内置函数 copy 可以将一个切片的内容复制到另外一个切片中:

copy(dst, src []int)

第一个参数 dst 是目标切片,第二个参数 src 是源切片,调用 copy 的时候会把 src 的内容复制到 dst 中。

示例:

var a []int
var b []int = []int{1, 2, 3}
// a 的容量为 0,容纳不下任何元素
copy(a, b)
fmt.Println(a) // []
a = make([]int, 3, 3) // 给 a 分配内存
copy(a, b)
fmt.Println(a) // [1 2 3]

需要注意的是,如果 dst 的长度比 src 的长度小,那么只会截取 src 的前面一部分。

从切片删除元素

虽然我们往切片追加元素的操作挺方便的,但是要从切片删除元素就相对麻烦一些了。go 语言本身没有提供从切片删除元素的方法。 如果我们要删除切片中的元素,只有构建出一个新的切片:

对应代码:

var a = make([]int, 7, 7)
for i := 0; i < 7; i++ {
    a[i] = i + 1
}
fmt.Println(a) // [1 2 3 4 5 6 7]
var b []int
b = append(b, a[:2]...) // [1 2]
b = append(b, a[5:]...) // [1 2 6 7]
fmt.Println(b) // [1 2 6 7]

在这个例子中,我们想从 a 中删除 3、4、5 这三个元素,也就是下标 2~4 的元素, 我们的做法是,新建了一个新的切片,然后将 3 前面的元素加入到这个新的切片中, 再将 5 后面的元素加入到这个新切片中。

最终得到的切片就是删除了 3、4、5 三个元素之后的切片了。

切片的容量到底是多少?

假设我们有如下代码:

var a = make([]int, 7, 7)
for i := 0; i &lt; 7; i++ {
    a[i] = i + 1
}
// [1 2 3 4 5 6 7]
fmt.Println(a)
s1 := a[:3]
// [1 2 3] 3 7
fmt.Println(s1, len(s1), cap(s1))
s2 := a[4:6]
// [5 6] 2 3
fmt.Println(s2, len(s2), cap(s2))

s1s2 可以用下图表示:

对于 s1s2,我们都没有指定它的容量,但是我们打印发现它们都有容量, 其实在切片中,我们从切片中生成一个新的切片的时候,如果我们不指定容量, 那新切片的容量就是 s[start:end] 中的 start 直到底层数组的最后一个元素的长度。

切片可以共享底层数组

切片最需要注意的点是,当我们从一个切片中创建新的切片的时候,两者会共享同一个底层数组, 如上图的那样,s1s2 都引用了同一个底层的数组不同的索引, s1 引用了底层数组的 0~2 下标范围,s2 引用了底层数组 4~5 下标范围。

这意味着,当我们修改 s1s2 的时候,原来的切片 a 也会发生改变:

var a = make([]int, 7, 7)
for i := 0; i < 7; i++ {
    a[i] = i + 1
}
// [1 2 3 4 5 6 7]
fmt.Println(a)
s1 := a[:3]
// [1 2 3]
fmt.Println(s1)
s1[1] = 100
// [1 100 3 4 5 6 7]
fmt.Println(a)
// [1 100 3]
fmt.Println(s1)

在上面的例子中,s1 这个切片引用了和 a 一样的底层数组, 然后在我们修改 s1 的时候,a 也发生了改变。

切片扩容不会影响原切片

上一小节我们说了,切片可以共享底层数组。但是如果切片扩容的话,那就是一个全新的切片了

var a = []int{1, 2, 3}
// [1 2 3] 3 3
fmt.Println(a, len(a), cap(a))
// a 容纳不下新的元素了,会进行扩容
b := append(a, 4)
// [1 2 3 4] 4 6
fmt.Println(b, len(b), cap(b))
b[1] = 100
// [1 2 3]
fmt.Println(a)
// [1 100 3 4]
fmt.Println(b)

在上面这个例子中,a 是一个长度和容量都是 3 的切片,这也就意味着,这个切片已经满了。 在这种情况下,我们再往其中追加元素的时候,就会进行扩容,生成一个新的切片。 因此,我们可以看到,我们修改了 b 的时候,并没有影响到 a

下面的例子就不一样了:

// 长度为 2,容量为 3
var a = make([]int, 2, 3)
a[0] = 1
a[1] = 2
// [1 2] 2 3
fmt.Println(a, len(a), cap(a))
// a 还可以容纳新的元素,不用扩容
b := append(a, 4)
// [1 2 4] 3 3
fmt.Println(b, len(b), cap(b))
b[1] = 100
// [1 100]
fmt.Println(a)
// [1 100 4]
fmt.Println(b)

在后面这个例子中,我们只是简单地改了一下 a 初始化的方式,改成了只放入两个元素,但是容量还是 3, 在这种情况下,a 可以再容纳一个元素,这样在 b := append(a, 4) 的时候,创建的 b 底层的数组其实跟 a 的底层数组依然是一样的。

所以,我们需要尤其注意代码中作为切片的函数参数,如果我们希望在被调函数中修改了切片之后,在 caller 里面也能看到效果的话,最好是传递指针。

func test1(s []int) {
   s = append(s, 4)
}
func test2(s *[]int) {
   *s = append(*s, 4)
}
func TestSlice(t *testing.T) {
   var a = []int{1, 2, 3}
   // [1 2 3] 3 3
   fmt.Println(a, len(a), cap(a))
   test1(a)
   // [1 2 3] 3 3
   fmt.Println(a, len(a), cap(a))
   var b = []int{1, 2, 3}
   // [1 2 3] 3 3
   fmt.Println(b, len(b), cap(b))
   test2(&amp;b)
   // [1 2 3 4] 4 6
   fmt.Println(b, len(b), cap(b))
}

在上面的例子中,test1 接收的是值参数,所以在 test1 中切片发生扩容的时候,TestSlice 里面的 a 还是没有发生改变。 而 test2 接收的是指针参数,所以在 test2 中发生切片扩容的时候,TestSlice 里面的 b 也发生了改变。

总结

以上就是go slice 数组和切片使用区别示例解析的详细内容,更多关于go slice 数组切片区别的资料请关注脚本之家其它相关文章!

您可能感兴趣的文章:
阅读全文