golang切片参数,go 切片容量和长度

本文目录一览：

• 1、golang-101-hacks(12)——切片作为函数参数传递
• 2、Golang|切片原理
• 3、slice切片做函数参数
• 4、golang 切片在函数传递
• 5、GoLang中的切片扩容机制
• 6、Golang 中数组（Array）和切片（Slice）的区别

golang-101-hacks(12)——切片作为函数参数传递

注：本文是对 golang-101-hacks 中文翻译。

在Go语言中，函数参数是值传递。使用slice作为函数参数时，函数获取到的是slice的副本:一个指针，指向底层数组的起始地址，同时带有slice的长度和容量。既然各位熟知数据存储的内存的地址，现在可以对切片数据进行修改。让我们看看下面的例子:

In Go, the function parameters are passed by value. With respect to use slice as a function argument, that means the function will get the copies of the slice: a pointer which points to the starting address of the underlying array, accompanied by the length and capacity of the slice. Oh boy! Since you know the address of the memory which is used to store the data, you can tweak the slice now. Let’s see the following example:

运行结果如下

由此可见，执行modifyValue函数，切片s的元素发生了变化。尽管modifyValue函数只是操作slice的副本，但是任然改变了切片的数据元素，看另一个例子:

You can see, after running modifyValue function, the content of slice s is changed. Although the modifyValue function just gets a copy of the memory address of slice’s underlying array, it is enough!

See another example:

The result is like this:

而这一次，addValue函数并没有修改main函数中的切片s的元素。这是因为它只是操作切片s的副本，而不是切片s本身。所以如果真的想让函数改变切片的内容，可以传递切片的地址:

This time, the addValue function doesn’t take effect on the s slice in main function. That’s because it just manipulate the copy of the s, not the “real” s.

So if you really want the function to change the content of a slice, you can pass the address of the slice:

运行结果如下

Golang|切片原理

在Golang语言开发过程中，我们经常会用到数组和切片数据结构，数组是固定长度的，而切片是可以扩张的数组，那么切片底层到底有什么不同？接下来我们来详细分析一下内部实现。

首先我们来看一下数据结构

这里的array其实是指向切片管理的内存块首地址，而len就是切片的实际使用大小，cap就是切片的容量。

我们可以通过下面的代码输出slice：

这么分析下来，我们可以了解如下内容：

使用一个切片通常有两种方法：

另一种是slice = make([]int, len, cap)这种方法，称为分配内存。

创建一个slice，实质上是在分配内存。

这里跟一下细节，math.MulUintptr是基于底层的指针计算乘法的，这样计算不会导致超出int大小，这个方法在后面会经常用到。

同样，对于int64的长度，也有对应的方法

而实际分配内存的操作调用mallocgc这个分配内存的函数，这个函数以后再分析。

我们了解切片和数组最大的不同就是切片能够自动扩容，接下来看看切片是如何扩容的

这里可以看到，growslice是返回了一个新的slice，也就是说如果发生了扩容，会发生拷贝。

所以我们在使用过程中，如果预先知道容量，可以预先分配好容量再使用，能提高运行效率。

copy这个函数在内部实现为slicecopy

还有关于字符串的拷贝

这里显示了可以把string拷贝成[]byte，不能把[]byte拷贝成string。

1、切片的数据结构是 array内存地址，len长度，cap容量

2、make的时候需要注意 容量 * 长度 分配的内存大小要小于264，并且要小于可分配的内存量，同时长度不能大于容量。

3、内存增长的过程：

4、当发生内存扩容时，会发生拷贝数据的现象，影响程序运行的效率，如果可以，要先分配好指定的容量

5、关于拷贝，可以把string拷贝成[]byte，不能把[]byte拷贝成string。

slice切片做函数参数

        再来分析一下golang中的切片slice底层的实现细节。

slice通过数组实现，类似一个结构体，其中一个字段保存的是底层数组的地址，还有长度(len) 和 容量(cap）两个字段。

        我们都知道，结构体作为函数参数时是值拷贝，同理，实际上slice作为函数参数时也是值拷贝，在函数中对slice的修改是通过slice中保存的地址对底层数组进行修改，所以函数外的silce看起来被改变了。

        当需要对slice做插入和删除时(如：append操作)，由于需要更改slice结构体中的长度字段，值拷贝就行不通了，需要传slice本身在内存中的地址。

看一个值传递的例子：

“`

package main

import “fmt”

func processSlice(x []int) {

    x = append(x, 6)

}

func main() {

    var numbers = []int{1, 2, 3, 4, 5}

    processSlice(numbers)

    for _, v := range(numbers) {

        fmt.Println(v)

    }

}

“`

1　2　3　4　5

再看一个指针传递的例子：

“`

package main

import “fmt”

func processSlice(x *[]int) {

    *x = append(*x, 6)

}

func main() {

    var numbers = []int{1, 2, 3, 4, 5}

    processSlice(numbers)

    for _, v := range(numbers) {

        fmt.Println(v)

    }

}

“`

1　2　3　4　5　6

slice for 循环中删除元素

方法1:

“`

chars:=[]string{“a”,”a”,”b”}

fori:=0;ilen(chars);i++{

    if chars[i]==”a” {

        chars=append(chars[:i],chars[i+1:]…)

        i–// form the remove item index to start iterate next item

}

}

fmt.Printf(“%+v”,chars)

“`

方式2：

“`

p := []int{1, -13, 9, 6, -21, 125}

j := 0

for _, n := range p {

    if n 0 {

        p[j] = n   //删除小于零的元素

        j++

    }

}

“`

不改原slice

“`

p := []int{1, -13, 9, 6, -21, 125}

j := 0

q := make([]int, len(p))

for _, n := range p {

    if n 0 {

        q[j] = n   //删除小于零的元素

        j++

    }

}

q = q[:j]

“`

golang 切片在函数传递

背景： 切片当参数传递时，无法append

原因： go语言中切片是地址传递，test函数添加的1，2，3后被分配了新的地址，s切片还是指向原来的地址，a和s内存地址不一样

解决方法：推荐方法2

1.在test函数返回新的切片，main函数接受返回结果

GoLang中的切片扩容机制

[5]int 是数组，而 []int 是切片。二者看起来相似，实则是根本上不同的数据结构。

切片的数据结构中，包含一个指向数组的指针 array ，当前长度 len ，以及最大容量 cap 。在使用 make([]int, len) 创建切片时，实际上还有第三个可选参数 cap ，也即 make([]int, len, cap) 。在不声明 cap 的情况下，默认 cap=len 。当切片长度没有超过容量时，对切片新增数据，不会改变 array 指针的值。

当对切片进行 append 操作，导致长度超出容量时，就会创建新的数组，这会导致和原有切片的分离。在下例中

由于 a 的长度超出了容量，所以切片 a 指向了一个增长后的新数组，而 b 仍然指向原来的老数组。所以之后对 a 进行的操作，对 b 不会产生影响。

试比较

本例中， a 的容量为6，因此在 append 后并未超出容量，所以 array 指针没有改变。因此，对 a 进行的操作，对 b 同样产生了影响。

下面看看用 a := []int{} 这种方式来创建切片会是什么情况。

可以看到，空切片的容量为0，但后面向切片中添加元素时，并不是每次切片的容量都发生了变化。这是因为，如果增大容量，也即需要创建新数组，这时还需要将原数组中的所有元素复制到新数组中，开销很大，所以GoLang设计了一套扩容机制，以减少需要创建新数组的次数。但这导致无法很直接地判断 append 时是否创建了新数组。

如果一次添加多个元素，容量又会怎样变化呢？试比较下面两个例子：

那么，是不是说，当向一个空切片中插入 2n-1 个元素时，容量就会被设置为 2n 呢？我们来试试其他的数据类型。

可以看到，根据切片对应数据类型的不同，容量增长的方式也有很大的区别。相关的源码包括： src/runtime/msize.go ， src/runtime/mksizeclasses.go 等。

我们再看看切片初始非空的情形。

可以看到，与刚刚向空切片添加5个int的情况一致，向有3个int的切片中添加2个int，容量增长为6。

需要注意的是， append 对切片扩容时，如果容量超过了一定范围，处理策略又会有所不同。可以看看下面这个例子。

具体为什么会是这样的变化过程，还需要从 源码 中寻找答案。下面是 src/runtime/slice.go 中的 growslice 函数中的核心部分。

GoLang中的切片扩容机制，与切片的数据类型、原本切片的容量、所需要的容量都有关系，比较复杂。对于常见数据类型，在元素数量较少时，大致可以认为扩容是按照翻倍进行的。但具体情况需要具体分析。

Golang 中数组（Array）和切片（Slice）的区别

Go 中数组的长度是不可改变的，而 Slice 解决的就是对不定长数组的需求。他们的区别主要有两点。

数组：

切片：

注意 1

虽然数组在初始化时也可以不指定长度，但 Go 语言会根据数组中元素个数自动设置数组长度，并且不可改变。切片通过 append 方法增加元素：

如果将 append 用在数组上，你将会收到报错：first argument to append must be slice。

注意 2

切片不只有长度（len）的概念，同时还有容量（cap）的概念。因此切片其实还有一个指定长度和容量的初始化方式：

这就初始化了一个长度为3，容量为5的切片。

此外，切片还可以从一个数组中初始化（可应用于如何将数组转换成切片）：

上述例子通过数组 a 初始化了一个切片 s。

当切片和数组作为参数在函数（func）中传递时，数组传递的是值，而切片传递的是指针。因此当传入的切片在函数中被改变时，函数外的切片也会同时改变。相同的情况，函数外的数组则不会发生任何变化。