golang中的切片到底是值传递还是引用传递?

/ 默认分类 / 0 条评论 / 4008浏览

golang

一.基础介绍

1.1 基本概念

slice 并不是数组或数组指针。它通过内部指针和相关属性引用数组片段，以实现变长方案。

切片的声明和初始化:

//全局声明切片,没有初始化,此时s1是nil
var s1 []int

//局部声明切片,这样得到的是一个初始化的空切片 []
s2 := []int{}


//声明的时候进行初始化数据
s5 := []int{1, 2, 3}

//基于数组声明切片
arr := [5]int{1, 2, 3, 4, 5}
var s6 []int
//包括前不包括后
s6 = arr[1:4]

和数组声明的却区别其实就是,数组的声明必须指定数组的大小,或者直接使用[...]来让编译器自行推断大小,并且数组的类型是数组元素类型和数字大小的综合.但是切片在声明的时候不需要指定大小,直接就[]即可.

使用make函数创建切片

    var slice []type = make([]type, len)
    slice  := make([]type, len)
    //数组类型,元素个数,容量
    slice  := make([]type, len, cap)

slice在go中其实就是一个结构体,具体的源码如下: runtime/slice.go

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

可以看到,其中有三个属性,array就是当前切片引用的数组,len就是当前切片的现有元素的长度,cap就是当前切片的容量大小.

通过下面两张图可以形象地认识下slice:

可以看到,切片本身就是为数组维护了一个逻辑映射的概念.

1.2.slice的扩容

前面我们说了,slice底层其实也是引用了一个指定的数组,只不过是数组指针,所以这个数组是可变的,所以如果当向slice中插入数据,已经超过了slice的容量,那么slice就会扩容,扩容后的slice中底层引用的数组就不是原来的了,而是变成了扩容后的新数组.

首先我们这样初始化一个切片:

s := make([]int, 2, 4)

那么现在的切片如下:

然后我们将s[1]设置为1:

 s := make([]int, 2, 4)
	s[1] = 1

那么此时的切片如下:

如果我们执行s[2] = 1,那么就会出现panic: runtime error: index out of range [2] with length 2,这样操作的原本想法可能是想,当前slice的容量是4,目前只存储了2个元素(即len是2),所以我想给index是2的位置上插入一个元素,但是这样的操作panic了.

那么我们应该怎样向切片中插入元素呢?我们可以使用go的内置函数append，将元素追加到切片的末尾.

比如:

//将元素1插入切片s的末尾
s = append(s, 1)

也支持一次插入多个元素到slice

s = append(s, 1, 2)
s = append(s, []int{1, 2}...)

还可以将字符串追加到切片末尾

s = append([]byte("hello"), "world"...)

好的,现在我们执行append(s, 2)，将元素2追加到s[1]后面，我们会得到下面的结果:

此时切片s的容量仍然是4,但是长度变成了3

接着,我们再一次性插入三个元素到切片s中:

s = append(s, 1, 2, 3)

即综合上面所有的步骤,执行以下代码:

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

得到结果:

s：[0 1 2 1 2 3]，len(s)：6，cap(s)：8

原因:当我们添加第5个元素时，发现已经超过切片的容量了。这个时候会触发扩容，会将容量加倍，然后复制所有元素创建另一个数组。然后会把剩下的2和3插进去。如下所示:

扩容机制：如果不到1024个元素，会成倍扩容；超过1024个元素，按25%扩容

另外,还有使用区间进行赋值的,如下:

 s := make([]int, 2, 4)
	s[1] = 1
	s = append(s, 2)
	s = append(s, 1, 2, 3)
	fmt.Printf("s：%v，len(s)：%d，cap(s)：%d\n",
		s, len(s), cap(s))
	s2 := s[1:2] // 这里重新赋值给s2
	fmt.Printf("s2：%v，len(s2)：%d，cap(s2)：%d\n",
		s2, len(s2), cap(s2))

s：[0 1 2 1 2 3]，len(s)：6，cap(s)：8
s2：[1]，len(s2)：1，cap(s2)：7

切片s和s2此时是引用同一个底层数组的，但是由于s2是从1开始，所以容量变成了7,并且s2只引用了[1,2]所以,打印出来的数据只有一个元素1:

这时如果我们修改了s2[0]或者s[1]，实际上他们指向的是底层数组的同一个元素。所以s2[0]或者s[1]都会被修改掉。

 := make([]int, 2, 4)
	s[1] = 1
	s = append(s, 2)
	s = append(s, 1, 2, 3)
	s2 := s[1:2]
	s2[0] = 8 // 这里
	fmt.Printf("修改俩切片指向的同一个元素：s：%v，len(s)：%d，cap(s)：%d)----s2：%v，len(s2)：%d，cap(s2)：%d\n",
		s, len(s), cap(s), s2, len(s2), cap(s2))

go run 4.go
修改俩切片指向的同一个元素：s：[0 8 2 1 2 3]，len(s)：6，cap(s)：8)----s2：[8]，len(s2)：1，cap(s2)：7

继续往s2中插入一个元素

s := make([]int, 2, 4)
	s[1] = 1
	s = append(s, 2)
	s = append(s, 1, 2, 3)
	s2 := s[1:2]
	s2[0] = 8
	// 插入元素6
	s2 = append(s2, 6)
	fmt.Printf("往s2插入一个元素：s：%v，len(s)：%d，cap(s)：%d----s2：%v，len(s2)：%d，cap(s2)：%d\n",
		s, len(s), cap(s), s2, len(s2), cap(s2))

往s2插入一个元素：s：[0 8 6 1 2 3]，len(s)：6，cap(s)：8----s2：[8 6]，len(s2)：2，cap(s2)：7

我们可以看到s2[1]的元素写进去了，值是6,长度变为2。但是s的长度并没有变化，s[2]的元素却也被修改为了6。这是因为往s2插入元素时并没有超过s2的容量，所以它和s还是共用同一个底层数组。

继续往s2中添加6个元素，看看超出容量后的底层数组会是什么样的：

 s := make([]int, 2, 4)
	s[1] = 1
	s = append(s, 2)
	s = append(s, 1, 2, 3)
	s2 := s[1:2]
	s2[0] = 8
	s2 = append(s2, 6)
	// 继续插入6个元素
	s2 = append(s2, 7)
	s2 = append(s2, 8)
	s2 = append(s2, 9)
	s2 = append(s2, 10)
	s2 = append(s2, 11)
	s2 = append(s2, 12)
	fmt.Printf("继续往s2插入6个元素：s：%v，len(s)：%d，cap(s)：%d----s2：%v，len(s2)：%d，cap(s2)：%d\n",
		s, len(s), cap(s), s2, len(s2), cap(s2))

我们来分析下上面的例子：

二.切片是值传递还是地址传递

想搞清楚这个,首先需要明确一点,其实上面我也说明了,就是golang中的切片是引用类型,也就是说,可以认为切片变量本身就是一个地址.看下面的代码:

	var s1 = []int{1, 2, 3}
	fmt.Printf("s1切片变量的地址(修改前):%p,s1引用表示的地址(修改前)%p,s1的值(修改前):%d,s1的类型%T\n", &s1, s1, s1, s1)
	modifySlice(s1)
	fmt.Printf("s1切片变量的地址(修改后):%p,s1引用表示的地址(修改后):%p,s1的值(修改后):%d,s1的类型%T\n", &s1, s1, s1, s1)

	var arr = [5]int{1, 2, 3, 4, 5}
	fmt.Printf("arr数组的变量地址:%p\n", &arr)
	var s2 = arr[1:3]
	fmt.Printf("s2切片变量的地址(修改前):%p,s2引用表示的地址(修改前)%p,s2的值(修改前):%d,s2的类型%T\n", &s2, s2, s2, s2)
	fmt.Printf("%T", arr[1])

func modifySlice(s []int) {
	fmt.Printf("传入函数内的切片变量的地址:%p,传入函数内的切片引用表示的地址:%p,传入函数内的切片的值:%d,传入函数内的切片的类型:%T\n", &s, s, s, s)
	s[1] = 1000
}

执行结果:

s1切片变量的地址(修改前):0x1400000c030,s1引用表示的地址(修改前)0x1400001e0a8,s1的值(修改前):[1 2 3],s1的类型[]int
传入函数内的切片变量的地址:0x1400000c090,传入函数内的切片引用表示的地址:0x1400001e0a8,传入函数内的切片的值:[1 2 3],传入函数内的切片的类型:[]int
s1切片变量的地址(修改后):0x1400000c030,s1引用表示的地址(修改后):0x1400001e0a8,s1的值(修改后):[1 2 3],s1的类型[]int
arr数组的变量地址:0x14000018150
s2切片变量的地址(修改前):0x1400000c138,s2引用表示的地址(修改前)0x14000018158,s2的值(修改前):[2 3],s2的类型[]int
int

还需要明确一点,因为切片是引用类型,所以切片变量的值可以认为是所引用的数组的首地址. 传入函数内部后的切片变量本身(也就是代码里说的引用表示的地址,因为切片本身就是引用类型,所以它本身就是地址)和外部是一样的,也就是 说值被拷贝传了进来,所以是一样的.

后面使用数组初始化切片,得到的引用本身就是原数组的地址(数组的地址就是其首元素地址)偏移8个byte得到的(0x14000018150-->0x14000018158). 因为切片是[1:3],所以切片引用的数组是原数组的第1个元素开始,也就是说切片的地址就是原数组的第一个元素的地址,而我们这里使用的是默认的int类型,而int类型没有注明大小,我们这台机器是64bit操作系统,在golang中默认就是int64,也就是8byte,所以便宜8个byte得到0x14000018158.

	var s1 = []int{1, 2, 3}
	fmt.Printf("s1切片变量的地址(修改前):%p,s1引用表示的地址(修改前)%p,s1的值(修改前):%d,s1的类型%T\n", &s1, s1, s1, s1)
	modifySlice(s1)
	fmt.Printf("s1切片变量的地址(修改后):%p,s1引用表示的地址(修改后):%p,s1的值(修改后):%d,s1的类型%T\n", &s1, s1, s1, s1)

func modifySlice(s []int) {
	fmt.Printf("修改前:传入函数内的切片变量的地址:%p,传入函数内的切片引用表示的地址:%p,传入函数内的切片的值:%d,传入函数内的切片的类型:%T\n", &s, s, s, s)
	s[1] = 100
	fmt.Printf("修改后:传入函数内的切片变量的地址:%p,传入函数内的切片引用表示的地址:%p,传入函数内的切片的值:%d,传入函数内的切片的类型:%T\n", &s, s, s, s)
}

s1切片变量的地址(修改前):0x1400010e018,s1引用表示的地址(修改前)0x14000122018,s1的值(修改前):[1 2 3],s1的类型[]int
修改前:传入函数内的切片变量的地址:0x1400010e078,传入函数内的切片引用表示的地址:0x14000122018,传入函数内的切片的值:[1 2 3],传入函数内的切片的类型:[]int
修改后:传入函数内的切片变量的地址:0x1400010e078,传入函数内的切片引用表示的地址:0x14000122018,传入函数内的切片的值:[1 100 3],传入函数内的切片的类型:[]int
s1切片变量的地址(修改后):0x1400010e018,s1引用表示的地址(修改后):0x14000122018,s1的值(修改后):[1 100 3],s1的类型[]int

如下图:

所以这类虽然打印的值地址是一样的,其实是因为拷贝的就是地址.

如果修改为下面这样,就比较明显了,不会那么容易误解为引用传递:

	var s1 = make([]int, 3)
	fmt.Printf("s1切片变量的地址(修改前):%p,s1引用表示的地址(修改前)%p,s1的值(修改前):%d,s1的类型%T\n", &s1, s1, s1, s1)
	modifySlice(s1)
	fmt.Printf("s1切片变量的地址(修改后):%p,s1引用表示的地址(修改后):%p,s1的值(修改后):%d,s1的类型%T\n", &s1, s1, s1, s1)

func modifySlice(s []int) {
	fmt.Printf("修改前:传入函数内的切片变量的地址:%p,传入函数内的切片引用表示的地址:%p,传入函数内的切片的值:%d,传入函数内的切片的类型:%T\n", &s, s, s, s)
	sTemp := append(s, 100)
	fmt.Printf("sTemp:%p,%p,%v \n", &sTemp, sTemp, sTemp)
	s = sTemp
	fmt.Printf("修改后:传入函数内的切片变量的地址:%p,传入函数内的切片引用表示的地址:%p,传入函数内的切片的值:%d,传入函数内的切片的类型:%T\n", &s, s, s, s)
}

s1切片变量的地址(修改前):0x14000110018,s1引用表示的地址(修改前)0x14000122018,s1的值(修改前):[0 0 0],s1的类型[]int
修改前:传入函数内的切片变量的地址:0x14000110078,传入函数内的切片引用表示的地址:0x14000122018,传入函数内的切片的值:[0 0 0],传入函数内的切片的类型:[]int
sTemp:0x140001100d8,0x1400012a030,[0 0 0 100] 
修改后:传入函数内的切片变量的地址:0x14000110078,传入函数内的切片引用表示的地址:0x1400012a030,传入函数内的切片的值:[0 0 0 100],传入函数内的切片的类型:[]int
s1切片变量的地址(修改后):0x14000110018,s1引用表示的地址(修改后):0x14000122018,s1的值(修改后):[0 0 0],s1的类型[]int

扩容后图示:

赋值后图示:

赋值后,切片s底层使用的就不是原来的数组了,而是指向了新扩容后的数组.所以此时再对切片s进行修改操作,那么就不会影响到原有的切片s1了.

比如这样:

	var s1 = make([]int, 3)
	fmt.Printf("s1切片变量的地址(修改前):%p,s1引用表示的地址(修改前)%p,s1的值(修改前):%d,s1的类型%T\n", &s1, s1, s1, s1)
	modifySlice(s1)
	fmt.Printf("s1切片变量的地址(修改后):%p,s1引用表示的地址(修改后):%p,s1的值(修改后):%d,s1的类型%T\n", &s1, s1, s1, s1)

func modifySlice(s []int) {
	fmt.Printf("修改前:传入函数内的切片变量的地址:%p,传入函数内的切片引用表示的地址:%p,传入函数内的切片的值:%d,传入函数内的切片的类型:%T\n", &s, s, s, s)
	sTemp := append(s, 100)
	fmt.Printf("sTemp:%p,%p,%v \n", &sTemp, sTemp, sTemp)
	s = sTemp
	s[0] = 99
	fmt.Printf("修改后:传入函数内的切片变量的地址:%p,传入函数内的切片引用表示的地址:%p,传入函数内的切片的值:%d,传入函数内的切片的类型:%T\n", &s, s, s, s)
}

s1切片变量的地址(修改前):0x14000110018,s1引用表示的地址(修改前)0x14000122018,s1的值(修改前):[0 0 0],s1的类型[]int
修改前:传入函数内的切片变量的地址:0x14000110078,传入函数内的切片引用表示的地址:0x14000122018,传入函数内的切片的值:[0 0 0],传入函数内的切片的类型:[]int
sTemp:0x140001100d8,0x1400012a030,[0 0 0 100] 
修改后:传入函数内的切片变量的地址:0x14000110078,传入函数内的切片引用表示的地址:0x1400012a030,传入函数内的切片的值:[99 0 0 100],传入函数内的切片的类型:[]int
s1切片变量的地址(修改后):0x14000110018,s1引用表示的地址(修改后):0x14000122018,s1的值(修改后):[0 0 0],s1的类型[]int

可以看到,将元素1修改为99后,外部函数的切片s1并没有修改,所以golang中的切片实际上是值传递.

本站文章除注明转载/出处外，均为本站原创或翻译，转载前请务必署名,转载请标明出处
最后编辑时间为: 2023/03/28 00:05