思考
先思考一个问题：如何给切片添加元素？下面这串代码行不行？是错误的，不能直接用s1[3]来添加元素，否则会造成索引越界。
package main
import "fmt"
func main() {
/*append：给切片添加元素*/
s1 := []string{"beijing", "shanghai", "guangzhou"}
s1[3] = "shenzhen" //错误！索引越界！
fmt.Println(s1)
}
append()方法为切片添加元素
概述
Go语言的内建函数append()可以为切片动态添加元素。 可以一次添加一个元素，可以添加多个元素，也可以添加另一个切片中的元素（后面加…）。
func main() {
/*append：给切片添加元素*/
s1 := []string{"beijing", "shanghai", "guangzhou"}
// s1[3] = "shenzhen" //错误！索引越界！
// fmt.Println(s1)
fmt.Printf("len(s1): %d, cap(s1): %d", len(s1), cap(s1))
fmt.Printf("\n")
//调用append函数必须用原来的切片变量接收返回值
s1 = append(s1, "shenzhen") //append追加元素，原来的底层数组放不下的时候，Go底层就会把底层数组换一个。
fmt.Printf("len(s1):%d, cap(s1): %d", len(s1), cap(s1))
}
你会发现一个问题，为什么变化后的s1容量变成了6呢？
因为原先的切片底层的数组为3个元素，再加一个不行了，盛不下，只能再新建一块内存，让新加入的搬进来。相当于公司搬家一样，刚开始公司就2个人，一个老板一个前台，后来来了第三个人后公司盛不下了，只能再新建一块内存了。
所以，按照这个道理来说，我再加一个，只要不超过3，容量就一直是6。这也就是为什么调用append函数必须用原来的切片变量接收返回值。
注意
通过var声明的零值切片可以在append()函数直接使用，无需初始化。
var s []int
s = append(s, 1, 2, 3)
没有必要像下面的代码一样初始化一个切片再传入append()函数使用，
s := []int{} // 没有必要初始化
s = append(s, 1, 2, 3)
var s = make([]int) // 没有必要初始化
s = append(s, 1, 2, 3)
append函数添加整个切片的元素
这么写是错的，不过大概思路是没什么问题的。
ss := []string{"chengdu","chongqing","suzhou"}
s1 = append(s1,ss)
只需要改一个位置即可，千万不要笑哈，很真实，就是下面这样子：在想要添加的切片后，添加三个省略号即可！表示拆开切片，分裂元素加入
ss := []string{"chengdu","chongqing","suzhou"}
s1 = append(s1,ss...)
贴一下代码：
package main
import "fmt"
func main() {
/*append：给切片添加元素*/
s1 := []string{"beijing", "shanghai", "guangzhou"}
// s1[3] = "shenzhen" //错误！索引越界！
// fmt.Println(s1)
fmt.Printf("len(s1): %d, cap(s1): %d", len(s1), cap(s1))
fmt.Printf("\n")
s1 = append(s1, "shenzhen", "hangzhou")
fmt.Printf("len(s1):%d, cap(s1): %d", len(s1), cap(s1))
fmt.Printf("\n")
ss := []string{"chengdu", "chongqing", "suzhou"}
s1 = append(s1, ss...)
fmt.Printf("len(s1):%d, cap(s1): %d", len(s1), cap(s1))
}
总结
1、append函数必须要用一个变量来接收返回值，这个变量必须要是之前的那个切片变量！
2、append函数允许添加一个或者多个元素来接收返回值
3、如果底层的数组不够添加元素，就会新创建一个数组，新创建一个内存区域。
4、导入新的切片元素时，使用...来分割
详细说明切片扩容策略
每个切片会指向一个底层数组，这个数组的容量够用就添加新增元素。当底层数组不能容纳新增的元素时，切片就会自动按照一定的策略进行“扩容”，此时该切片指向的底层数组就会更换。“扩容”操作往往发生在append()函数调用时，所以我们通常都需要用原变量接收append函数的返回值。
举个例子：
func main() {
//append()添加元素和切片扩容
var numSlice []int
for i := 0; i < 10; i++ {
numSlice = append(numSlice, i)
fmt.Printf("%v len:%d cap:%d ptr:%p\n", numSlice, len(numSlice), cap(numSlice), numSlice)
}
}
输出：
[0] len:1 cap:1 ptr:0xc0000a8000
[0 1] len:2 cap:2 ptr:0xc0000a8040
[0 1 2] len:3 cap:4 ptr:0xc0000b2020
[0 1 2 3] len:4 cap:4 ptr:0xc0000b2020
[0 1 2 3 4] len:5 cap:8 ptr:0xc0000b6000
[0 1 2 3 4 5] len:6 cap:8 ptr:0xc0000b6000
[0 1 2 3 4 5 6] len:7 cap:8 ptr:0xc0000b6000
[0 1 2 3 4 5 6 7] len:8 cap:8 ptr:0xc0000b6000
[0 1 2 3 4 5 6 7 8] len:9 cap:16 ptr:0xc0000b8000
[0 1 2 3 4 5 6 7 8 9] len:10 cap:16 ptr:0xc0000b8000
从上面的结果可以看出：
-
append()函数将元素追加到切片的最后并返回该切片。 - 切片numSlice的容量按照1，2，4，8，16这样的规则自动进行扩容，每次扩容后都是扩容前的2倍。
有什么规律呢？
切片的扩容策略规律（了解，用到的时候再看）
可以通过查看$GOROOT/src/runtime/slice.go源码，其中扩容相关代码如下：
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
}
}
}
从上面的代码可以看出以下内容：
- 首先判断，如果新申请容量（cap）大于2倍的旧容量（old.cap），最终容量（newcap）就是新申请的容量（cap）。
- 否则判断，如果旧切片的长度小于1024，则最终容量(newcap)就是旧容量(old.cap)的两倍，即（newcap=doublecap），
- 否则判断，如果旧切片长度大于等于1024，则最终容量（newcap）从旧容量（old.cap）开始循环增加原来的1/4，即（newcap=old.cap,for {newcap += newcap/4}）直到最终容量（newcap）大于等于新申请的容量(cap)，即（newcap >= cap）
- 如果最终容量（cap）计算值溢出，则最终容量（cap）就是新申请容量（cap）。
需要注意的是，切片扩容还会根据切片中元素的类型不同而做不同的处理，比如int和string类型的处理方式就不一样。
使用copy()函数复制切片
首先我们来看一个问题：
func main() {
a := []int{1, 2, 3, 4, 5}
b := a
fmt.Println(a) //[1 2 3 4 5]
fmt.Println(b) //[1 2 3 4 5]
b[0] = 1000
fmt.Println(a) //[1000 2 3 4 5]
fmt.Println(b) //[1000 2 3 4 5]
}
由于切片是引用类型，所以a和b其实都指向了同一块内存地址。修改b的同时a的值也会发生变化。
Go语言内建的copy()函数可以迅速地将一个切片的数据复制到另外一个切片空间中，copy()函数的使用格式如下：
copy(destSlice, srcSlice []T)
其中：
- srcSlice: 数据来源切片
- destSlice: 目标切片
举个例子：
package main
import "fmt"
func main() {
a1 := []int{1, 3, 5}
a2 := a1
//var a3 []int //这么写相当于切片a3 == nil为空，肯定是将a1拷贝不进去
var a3 = make([]int, 3) //这样子写就正确了，其实make函数不用写后面的容量都是可以的
copy(a3, a1)
fmt.Println(a1, a2, a3)
a1[0] = 2000 //更改a1，那么a2也会发生变化，因为他们两个用的同一块内存
fmt.Println(a1, a2, a3)
}
从切片中删除元素
Go语言中并没有删除切片元素的专用方法，我们可以使用切片本身的特性以及append函数来删除元素。 代码如下：
func main() {
// 从切片中删除元素
a := []int{30, 31, 32, 33, 34, 35, 36, 37}
// 要删除索引为2的元素
a = append(a[:2], a[3:]...)
fmt.Println(a) //[30 31 33 34 35 36 37]
}
总结一下就是：要从切片a中删除索引为index的元素，操作方法是a = append(a[:index], a[index+1:]...)
练习题
1.请写出下面代码的输出结果。
func main() {
var a = make([]string, 5, 10)
for i := 0; i < 10; i++ {
a = append(a, fmt.Sprintf("%v", i))
}
fmt.Println(a)
}
2.请使用内置的sort包对数组var a = [...]int{3, 7, 8, 9, 1}进行排序（附加题，自行查资料解答）。