今天来说个简单的，也不简单的东西，那就是切片。slice对于golang来说那真的是一个非常常用的东西了，很多地方都会用到它，今天就来说说，slice底层是如何实现的，又有哪些坑是需要提前注意的。

slice结构

很多第一次接触golang的同学都会认为，数组和切片是差不多的东西，其实不是的，切片是数组的封装。

1
2
3
4
5
type slice struct {
	array unsafe.Pointer
	len   int
	cap   int
}

上面这个就是slice的结构，顺便说一下：slice的源码位置是：
go/src/runtime/slice.go

  • 其中array是一个指针，指向底层的数组
  • len代表slice的长度
  • cap代表slice的容量

为什么会有长度和容量这个区分呢，这两个东西是用来干什么的呢？我们往下看。

slice的长度和容量

我们先来看一个最简单的案例

1
2
3
4
sli := make([]int, 2)
fmt.Printf("len=%d  cap=%d\n", len(sli), cap(sli))
sli = append(sli, 1)
fmt.Printf("len=%d  cap=%d\n", len(sli), cap(sli))

我们创建一个长度为2的slice然后打印一下它的len和cap。
然后添加一个元素，再次打印最后结果为：
len=2 cap=2
len=3 cap=4

从中我们可以知道len和cap是不同的东西，明显嘛。但是为什么呢？

其实原因很简单，因为数组在创建的时候只能创建固定大小的数组，而当slice在不断往其中添加元素的时候，势必会遇到大小不够的情况，如果每次添加都不够，那么每次都要创建新的数组，那会相当浪费时间和资源，所以当不够的时候索性一次就创建大一些，所以cap其实就代表了整体的一个容量，而len代表当前用到了第几个。

slice的扩容

刚才提到的整个过程就是扩容的原因，那么slice究竟是如何进行扩容的呢？
网上我看见过两个说法：

  1. 每次2倍
  2. 当len<1024的时候每次2倍，当len>1024的时候每次1.25倍

我最后得到的结论是其实两个都不完全正确。正确的应该看看源码中是怎么说的。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
func growslice(et *_type, old slice, cap int) slice {
	.....
	
	newcap := old.cap
	doublecap := newcap + newcap
	if cap > doublecap {
		newcap = cap
	} else {
		if old.len < 1024 {
			newcap = doublecap
		} else {
			// Check 0 < newcap to detect overflow
			// and prevent an infinite loop.
			for 0 < newcap && newcap < cap {
				newcap += newcap / 4
			}
			// Set newcap to the requested cap when
			// the newcap calculation overflowed.
			if newcap <= 0 {
				newcap = cap
			}
		}
	}

	var overflow bool
	var lenmem, newlenmem, capmem uintptr
	const ptrSize = unsafe.Sizeof((*byte)(nil))
	switch et.size {
	case 1:
		lenmem = uintptr(old.len)
		newlenmem = uintptr(cap)
		capmem = roundupsize(uintptr(newcap))
		overflow = uintptr(newcap) > _MaxMem
		newcap = int(capmem)
	case ptrSize:
		lenmem = uintptr(old.len) * ptrSize
		newlenmem = uintptr(cap) * ptrSize
		capmem = roundupsize(uintptr(newcap) * ptrSize)
		overflow = uintptr(newcap) > _MaxMem/ptrSize
		newcap = int(capmem / ptrSize)
	default:
		lenmem = uintptr(old.len) * et.size
		newlenmem = uintptr(cap) * et.size
		capmem = roundupsize(uintptr(newcap) * et.size)
		overflow = uintptr(newcap) > maxSliceCap(et.size)
		newcap = int(capmem / et.size)
	}

	......
	return slice{p, old.len, newcap}
}

我们省略其中部分代码看关键部分，首先说明一下growslice这个方法是扩容的方法，其中的入参
et *_type, old slice, cap int
分别是元素的类型，老的slice，新slice要求的最小容量
针对最后这个参数举个简单的例子，当前如果是len=2，cap=2的一个slice添加一个元素，那么这个参数传入的就是3，因为最小需要容量为3。

其实从前半部分来看，第二种说法是正确的，当len<1024确实就是两倍，而当len>1024的时候，每次以原来的25%增加直到满足要求。

但是其实你看后面部分，有一个roundupsize的方法，并且又对newcap进行赋值，所以肯定修改了cap的值，所以其实扩容并没有描述的那么简单，实际中会进行内存对齐，具体什么事内存对齐呢？简单的描述是，内存中肯定不是你想怎么放就怎么放的肯定要满足一个规则，有的地方虽然你只要这么点地方，但是由于美观的要求，会多给你一点，凑个整，保持统一整齐，这就是内存对齐。（是不是花里胡哨的，我尽可能已经白话了，具体还是要看）
https://blog.csdn.net/u011957758/article/details/85059117
总之，我们知道，slice的扩容并不是那么简单的。最后附上一个例子作为验证：

1
2
3
4
5
6
7
8
9
10
11
12
func main() {
    sli := make([]int, 2)
    
    preCap := cap(sli)
    for i := 0; i <= 2048; i++ {
        sli = append(sli, i)
        if cap(sli) != preCap {
            fmt.Printf("len=%4d \t cap=%d\n", len(sli)-1, cap(sli))
            preCap = cap(sli)
        }
    }
}

输出

1
2
3
4
5
6
7
8
9
10
11
12
len=   2 	 cap=4
len=   4 	 cap=8
len=   8 	 cap=16
len=  16 	 cap=32
len=  32 	 cap=64
len=  64 	 cap=128
len= 128 	 cap=256
len= 256 	 cap=512
len= 512 	 cap=1024
len=1024 	 cap=1280
len=1280 	 cap=1696
len=1696 	 cap=2304

1280 = 1024 * 1.25
1696 = 1280 * 1.325

slice的操作

普通的创建添加元素我就不多说了，你肯定知道，你要是不知道就不会来看我的博客了。说一些看起来高端的微操。

创建slice

make([]int, 10, 32)
make的时候可以指定第三个参数也就是初始的cap

slice删除一个元素

sli = append(sli[:3], sli[4:]…)
因为底层是数组，所以删除一个元素看起来会比较麻烦

reslice

1
2
3
4
5
6
7
8
9
10
11
12
func main() {
    sli := make([]int, 0)
    
    for i := 1; i <= 10; i++ {
        sli = append(sli, i)
    }

    fmt.Println(sli)
    sli = sli[1:3:5]
    fmt.Println(sli)
    fmt.Println(len(sli), cap(sli))
}

sli = sli[1:3:5]
reslice的时候也可以指定cap，但是注意的是，这个时候并不是指定的整体容量为5，而是容量为原来slice下标为5的地方。
如果原来是[1 2 3 4 5 6 7 8 9 10]
按照上面的操作，按照我自己的平常说的就是切两刀，第一刀是切到3，第二刀是切到5
slice是[2,3]，但是实际底层还有[4,5] cap应该是4，所以输出应该是：

1
2
3
[1 2 3 4 5 6 7 8 9 10]
[2 3]
2 4

slice的坑点

slice的坑其实主要在于使用者需要清楚值传递引用传递的关系。
首先在golang中只有值传递，没有引用传递。

  • reslice的时候要注意，如果只是reslice那么后续操作是会对原来的slice造成影响的。
  • 但是如果经过append之后，那么由于扩容的时候回重新分配内存，如果涉及扩容之后，那么就不会对原来的slice造成影响。
  • 如果作为函数的参数传递的是数组，因为是值传递，所以函数内部的修改不会对外部的变量产生影响，但是如果是slice传递，那么因为传递的是指针，所以会修改外部的变量。
  • 同时因为是值传递，形参的重新赋值是不会对外部的变量造成影响的。

下面的代码说明了以上可能出现的坑点

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
package main

import "fmt"

func main() {
    a := [3]int{1, 1, 1}
    s := []int{1, 1, 1}
    
    modifyArray(a)
    fmt.Println(a)
    
    modifySlice(s)
    fmt.Println(s)
    
    reslice(s)
    fmt.Println(s)
    
    s1 := make([]int, 2, 3)
    s2 := append(s1, 1)
    s2[0] = 3
    fmt.Println(s1)

    s3 := append(s1, 1, 1)
    s3[0] = 4
    fmt.Println(s1)
}

func modifyArray(a [3]int) {
    a[0] = 2
}

func modifySlice(s []int) {
    s[0] = 2
}

func reslice(s []int) {
    s = s[:2]
}

总结

总结一下，创建slice的时候如果可以的话尽可能初始化好要用容量，以免经常扩容。slice作为参数进行传递的时候，还有slice进行append的时候注意一下，别的应该没有问题。总的来说slice的实现还是比较简单的。