20220606@切片元素修改

Go语言的内建函数 append() 可以为切片动态添加元素，代码如下所示：
```go
var a []int
a = append(a, 1) // 追加1个元素
a = append(a, 1, 2, 3) // 追加多个元素, 手写解包方式
a = append(a, []int{1,2,3}...) // 追加一个切片, 切片需要解包
```
不过需要注意的是，在使用 append() 函数为切片动态添加元素时，如果空间不足以容纳足够多的元素，切片就会进行“扩容”，此时新切片的长度会发生改变。

切片在扩容时，容量的扩展规律是按容量的 2 倍数进行扩充，例如 1、2、4、8、16……，代码如下：
```go
var numbers []int
for i := 0; i < 10; i++ {
    numbers = append(numbers, i)
    fmt.Printf("len: %d  cap: %d pointer: %p\n", len(numbers), cap(numbers), numbers)
}
```

## append()为切片添加元素

```go
package main

import "fmt"

func main()  {
	//声明一个切片
	num := make([]int,5,10)

//打印添加前的切片
	fmt.Println("动态添加元素前：",num)

//为切片动态添加元素(手动解包方式)
	num = append(num,1,2)

//为切片动态添加元素(切片解包方式)
	aped := []int{3,4}
	num = append(num,aped...)

//打印添加后的切片
	fmt.Println("动态添加元素后：",num)

//切片容量的自动扩容
	//打印扩容前
	fmt.Printf("扩容前num切片的长度: %v 容量：%v\n",len(num),cap(num))

//进行自动扩容
	for i:=0;i<15;i++ {

num = append(num,i)

//扩容规则
		// 容量的扩展规律是按容量的 2 倍数进行扩充
		// 如下示例说明：切片长度 len 并不等于切片的容量 cap,随着容量的变化，内存会跟着变化
		//在内存中，容量扩充变化需要先申请内存，然后再将旧内存中的所有迁移到新的内存地址中
		fmt.Printf("追加元素：%d, 目前长度：%d, 容量：%d, 内存地址：%p\n",i,len(num),cap(num),num)

}

//在切片元素头部添加元素
	//头部添加元素是需要将所有已存在的元素进行向后复制移动，消耗性能
	fmt.Println("添加头部元素前：",num)

//添加头部元素
	num = append([]int{9,9,9},num...)

fmt.Println("添加头部元素后：",num)

//在指定索引位置插入元素
	//在第2个索引后插入元素5,5
	num = append(num[:2],append([]int{5},num...)...)

fmt.Println("添加元素到指定位置后：",num)

}
```

## 切片复制（切片拷贝）

Go语言的内置函数 copy() 可以将一个数组切片复制到另一个数组切片中，如果加入的两个数组切片不一样大，就会按照其中较小的那个数组切片的元素个数进行复制。

copy() 函数的使用格式如下：
```go
copy( destSlice, srcSlice []T) int
```
其中 srcSlice 为数据来源切片，destSlice 为复制的目标（也就是将 srcSlice 复制到 destSlice），目标切片必须分配过空间且足够承载复制的元素个数，并且来源和目标的类型必须一致，copy() 函数的返回值表示实际发生复制的元素个数。

下面的代码展示了使用 copy() 函数将一个切片复制到另一个切片的过程：
```go
slice1 := []int{1, 2, 3, 4, 5}
slice2 := []int{5, 4, 3}
copy(slice2, slice1) // 只会复制slice1的前3个元素到slice2中
copy(slice1, slice2) // 只会复制slice2的3个元素到slice1的前3个位置
```
虽然通过循环复制切片元素更直接，不过内置的 copy() 函数使用起来更加方便，copy() 函数的第一个参数是要复制的目标 slice，第二个参数是源 slice，两个 slice 可以共享同一个底层数组，甚至有重叠也没有问题。

```go
package main

import "fmt"

// 定义切片常量
const eleCount = 1000

func main()  {

//声明一组切片
	var  s1 = []int{1,2,3,4,5}
	var  s2 = []int{0,0,0}

//将切片s1复制到s2
	fmt.Println("before copy",s2)
	copy(s2,s1)
	fmt.Println("after copy",s2)

//定义一个数组
	srcData := make([]int,eleCount)

//赋值
	for i := 0; i < eleCount; i++ {
		srcData[i] = i
	}

//引用切片
	refData := srcData

//复制切片
	copyData := make([]int,eleCount)
	copy(copyData,srcData)

//修改原始切片的元素内容
	srcData[0] = 123
	//分别打印引用切片和复制切片对应的值
	fmt.Println("引用：",refData[0])
	fmt.Println("复制：",copyData[0])

/*
	说明：
		当切片为引用后，内存底层地址相同，同一内存地址内存放的数据发生变化后，新引用切片的数据也会发生变化
		但当切片为复制后，源切片的修改不会影响到复制后的结果
	 */

}
```

## 从切片中删除元素

Go语言并没有对删除切片元素提供专用的语法或者接口，需要使用切片本身的特性来删除元素，根据要删除元素的位置有三种情况，分别是从开头位置删除、从中间位置删除和从尾部删除，其中删除切片尾部的元素速度最快。
从开头位置删除
删除开头的元素可以直接移动数据指针：
```go
a = []int{1, 2, 3}
a = a[1:] // 删除开头1个元素
a = a[N:] // 删除开头N个元素
```
也可以不移动数据指针，但是将后面的数据向开头移动，可以用 append 原地完成（所谓原地完成是指在原有的切片数据对应的内存区间内完成，不会导致内存空间结构的变化）：
```go
a = []int{1, 2, 3}
a = append(a[:0], a[1:]...) // 删除开头1个元素
a = append(a[:0], a[N:]...) // 删除开头N个元素
```go
还可以用 copy() 函数来删除开头的元素：
```go
a = []int{1, 2, 3}
a = a[:copy(a, a[1:])] // 删除开头1个元素
a = a[:copy(a, a[N:])] // 删除开头N个元素
```
从中间位置删除
对于删除中间的元素，需要对剩余的元素进行一次整体挪动，同样可以用 append 或 copy 原地完成：
```go
a = []int{1, 2, 3, ...}
a = append(a[:i], a[i+1:]...) // 删除中间1个元素
a = append(a[:i], a[i+N:]...) // 删除中间N个元素
a = a[:i+copy(a[i:], a[i+1:])] // 删除中间1个元素
a = a[:i+copy(a[i:], a[i+N:])] // 删除中间N个元素
```
从尾部删除
```go
a = []int{1, 2, 3}
a = a[:len(a)-1] // 删除尾部1个元素
a = a[:len(a)-N] // 删除尾部N个元素

```
删除开头的元素和删除尾部的元素都可以认为是删除中间元素操作的特殊情况

代码的删除过程可以使用下图来描述。

![](/media/202206/2022-06-08_165749_955301.png)

## 循环迭代切片
通过前面的学习我们了解到切片其实就是多个相同类型元素的连续集合，既然切片是一个集合，那么我们就可以迭代其中的元素，Go语言有个特殊的关键字 range，它可以配合关键字 for 来迭代切片里的每一个元素，如下所示：
```go
// 创建一个整型切片，并赋值
slice := []int{10, 20, 30, 40}
// 迭代每一个元素，并显示其值
for index, value := range slice {
    fmt.Printf("Index: %d Value: %d\n", index, value)
}
```
第 4 行中的 index 和 value 分别用来接收 range 关键字返回的切片中每个元素的索引和值，这里的 index 和 value 不是固定的，读者也可以定义成其它的名字。

关于 for 的详细使用我们将在下一章《Go语言流程控制》中为大家详细介绍。

上面代码的输出结果为：
```
Index: 0 Value: 10
Index: 1 Value: 20
Index: 2 Value: 30
Index: 3 Value: 40
```
当迭代切片时，关键字 range 会返回两个值，第一个值是当前迭代到的索引位置，第二个值是该位置对应元素值的一份副本，如下图所示。

使用 range 迭代切片会创建每个元素的副本
图：使用 range 迭代切片会创建每个元素的副本

需要强调的是，range 返回的是每个元素的副本，而不是直接返回对该元素的引用，如下所示。

【示例 1】range 提供了每个元素的副本
```go
// 创建一个整型切片，并赋值
slice := []int{10, 20, 30, 40}
// 迭代每个元素，并显示值和地址
for index, value := range slice {
    fmt.Printf("Value: %d Value-Addr: %X ElemAddr: %X\n", value, &value, &slice[index])
}
```
输出结果为：
```
Value: 10 Value-Addr: 10500168 ElemAddr: 1052E100
Value: 20 Value-Addr: 10500168 ElemAddr: 1052E104
Value: 30 Value-Addr: 10500168 ElemAddr: 1052E108
Value: 40 Value-Addr: 10500168 ElemAddr: 1052E10C
```

因为迭代返回的变量是一个在迭代过程中根据切片依次赋值的新变量，所以 value 的地址总是相同的，要想获取每个元素的地址，需要使用切片变量和索引值（例如上面代码中的 &slice[index]）。

如果不需要索引值，也可以使用下划线_来忽略这个值，代码如下所示。

【示例 2】使用空白标识符（下划线）来忽略索引值
```go
// 创建一个整型切片，并赋值
slice := []int{10, 20, 30, 40}
// 迭代每个元素，并显示其值
for _, value := range slice {
    fmt.Printf("Value: %d\n", value)
}
```
输出结果为：
```
Value: 10
Value: 20
Value: 30
Value: 40
```
关键字 range 总是会从切片头部开始迭代。如果想对迭代做更多的控制，则可以使用传统的 for 循环，代码如下所示。

【示例 3】使用传统的 for 循环对切片进行迭代
```go
// 创建一个整型切片，并赋值
slice := []int{10, 20, 30, 40}
// 从第三个元素开始迭代每个元素
for index := 2; index < len(slice); index++ {
    fmt.Printf("Index: %d Value: %d\n", index, slice[index])
}
```
输出结果为：
```
Index: 2 Value: 30
Index: 3 Value: 40
```

在前面几节的学习中我们了解了两个特殊的内置函数 len() 和 cap()，可以用于处理数组、切片和通道，对于切片，函数 len() 可以返回切片的长度，函数 cap() 可以返回切片的容量，在上面的示例中，使用到了函数 len() 来控制循环迭代的次数。

学习结束地址：http://c.biancheng.net/view/29.html