总目录：//www.greatytc.com/p/e406a9bc93a9
Golang - 子目录：//www.greatytc.com/p/8b3e5b2b4497
切片
go语言的切片与Python的切片看起来是一样的，但是却截然不同，Python的切片操作是一种深拷贝行为，切出来就是切出来了，go语言的切片操作是一种引用行为。
为什么会有切片
go语言中的数组是定长序列，查询快但是不易操作，例如我们不能对他进行追加元素。
所以就有了切片，相比于数组，切片是一个不定长序列，同时他是基于数组的封装，也就是说他有了数组的操作速度的同时更加的灵活。
我们上面也说go语言的切片是一种引用类型，所以他的内部结构是地址，长度和容量。一般使用切片来进行对一块数据的快速操作。
切片的定义
语法：
var 切片名 []数据类型
例子：
package main
import "fmt"
func main() {
var s1 []int //定义一个整数类型的切片
var s2 []string //定义一个字符串类型的切片
fmt.Println(s1, s2)
}
----------
[][]
切片的初始化
切片的初始化没有什么需要注意的，需要注意的是初始化之后的切片，哪怕是空值，他也不等于nil了。
例子：
package main
import "fmt"
func main() {
// 切片的定义
var s1 []int //定义一个整数类型的切片
var s2 []string //定义一个字符串类型的切片
// 切片的初始化
s1 = []int{1, 2, 3} //对已经创建的切片赋值
var s3 = []string{} //创建时初始化，并且赋空值
var s4 = []bool{false, true} //创建时初始化，并且赋值
fmt.Println(s1, s2, s3, s4)
fmt.Println(s1 == nil)
fmt.Println(s2 == nil)
fmt.Println(s3 == nil)
fmt.Println(s4 == nil)
}
-----------
[1 2 3] [] [] [false true]
false
true
false
false
切片的长度与容量
既然我们说切片是一个不定长数据类型，那么我们肯定需要知道某个切片的长度。但实际上切片除了长度这个属性外，还有一个属性--容量。
package main
import "fmt"
func main() {
// 切片的定义
var s1 []int //定义一个整数类型的切片
// 切片的初始化
s1 = []int{1, 2, 3} //对已经创建的切片赋值
// 切片的长度与容量
fmt.Printf("len(s1):%d,cap(s1):%d",len(s1),cap(s1))
}
----------
len(s1):3,cap(s1):3
乍一看，长度和容量都是3，好像没有什么不同，这就需要来看我们另外一种定义方式---基于数组定义切片。
基于数组定义切片
基于数组的切片操作起来和Python基于序列的切片一样，遵循左闭右开规则，切的都是索引。
package main
import "fmt"
func main() {
// 基于数组定义切片
// 定义一个数组
arr1 := [5]int{1, 2, 3, 4, 5}
// 基于一个数组定义切片 遵循左闭右开规则
s1 := arr1[1:4]
fmt.Println(s1)
fmt.Printf("%T\n", s1)
fmt.Printf("len(s1):%d,cap(s1):%d", len(s1), cap(s1))
}
----------
[2 3 4]
[]int
len(s1):3,cap(s1):4
但是运行完后，我们发现切片的长度为3，但是容量为4了。
这是因为容量是从数组中切片的首元素下标开始数，数到数组的尾下标。s1的容量是4，具体点是2, 3, 4, 5这四个元素所占的长度。
这是我们再来看看，他是不是和Python一样，都有步长：
但是看样子是不可以的，他说这样是无效的，那么我们把它们颠倒一下。
颠倒之后并没有报错，然后我看来一下官方文档，切片操作的第三个参数是用来限制切片的容量。
允许限制新切片的容量为底层数组提供了一定的保护，可以更好地控制追加操作。
package main
import "fmt"
func main() {
arr1 := [5]int{1, 2, 3, 4, 5}
// 限制切片的容量
s2 := arr1[1:2:3]
fmt.Println(s2)
fmt.Printf("%T\n", s2)
fmt.Printf("len(s2):%d,cap(s2):%d", len(s2), cap(s2))
}
----------
[2]
[]int
len(s2):1,cap(s2):2
如果没有第三个参数的话，容量会一直到数组末位，但是设置第三个参数，就会到第三个参数标注的索引处。
接着让我们来看一下一些通用操作：
package main
import "fmt"
func main() {
arr1 := [5]int{1, 2, 3, 4, 5}
fmt.Println(arr1[2:]) //从第二个索引取到末位，包括第二个索引
fmt.Println(arr1[:4]) //从头取到第四个索引，不包括第四个索引
fmt.Println(arr1[:]) //从头取到未
}
----------
[3 4 5]
[1 2 3 4]
[1 2 3 4 5]
基于切片再切片
package main
import "fmt"
func main() {
// 切片再切片
// 定义一个数组
arr2 := [...]int{1,2,3,4,5,6,7,8,9,10}
// 切片
s3 := arr2[:7]
fmt.Println("s3:",s3)
// 切片在切片
s4 := s3[3:5]
fmt.Println("s4:",s4)
s5 := s3[1:9]
fmt.Println("s5:",s5)
// 一个限制容量的切片
s6 := arr2[:7:8]
fmt.Println("s6:",s6)
// 在切片 这里会报错，因为s6的容量只到8.
s7 := s6[1:9]
fmt.Println("s7:",s7)
}
----------
s3: [1 2 3 4 5 6 7]
s4: [4 5]
s5: [2 3 4 5 6 7 8 9]
s6: [1 2 3 4 5 6 7]
panic: runtime error: slice bounds out of range [:9] with capacity 8
切片再切片并不是在原来的切片上面切片，因为切片是引用类型，所以再切片也是在底层数组上进行切片的。
同时如果切片限制了容量，那么再切片不能超过这个容量，否则会越界。
再切片也不能超过数组的长度。
既然切片是引用类型，那么我们修改一下切片里的元素呢
package main
import "fmt"
func main() {
arr2 := [...]int{1,2,3,4,5,6,7,8,9,10}
// 如果修改了切片的元素呢
fmt.Printf("没有修改的s6[3]:%d\n",s6[3])
s6[3] = 100
fmt.Printf("修改过的s6[3]:%d\n",s6[3])
fmt.Println("修改过的数组:",arr2)
}
----------
没有修改的s6[3]:4
修改过的s6[3]:100
修改过的数组: [1 2 3 100 5 6 7 8 9 10]
使用make()函数构造切片
make()函数就是一个内置的用来创建切片的函数。
语法
make ([]T, size, cap)
T:切片的元素类型
size:切片中元素的数量
cap:切片的容量
例子：
package main
import "fmt"
func main() {
// make函数
a := make([]int, 2, 10)
fmt.Printf("len(a):%d,cap(a):%d\n", len(a), cap(a))
}
----------
len(a):2,cap(a):10
如果不写容量，则默认长度就是容量。
package main
import "fmt"
func main() {
// make函数
a := make([]int, 2)
fmt.Printf("len(a):%d,cap(a):%d\n", len(a), cap(a))
}
----------
len(a):2,cap(a):2
切片的本质
切片的本质就是对底层数组的封装，它包含了三个信息：底层数组的指针、切片的长度（len）和切片的容量（cap）。
举个例子，现在有一个数组a := [8]int{0, 1, 2, 3, 4, 5, 6, 7}，切片s1 := a[:5]，相应示意图如下。
切片s2 := a[3:6]，相应示意图如下：
切片的比较
切片之间是不能比较的，我们不能使用==操作符来判断两个切片是否含有全部相等元素。 切片唯一合法的比较操作是和nil比较。 一个nil值的切片并没有底层数组，一个nil值的切片的长度和容量都是0。但是我们不能说一个长度和容量都是0的切片一定是nil，例如下面的示例：
var s1 []int //len(s1)=0;cap(s1)=0;s1==nil
s2 := []int{} //len(s2)=0;cap(s2)=0;s2!=nil
s3 := make([]int, 0) //len(s3)=0;cap(s3)=0;s3!=nil
所以要判断一个切片是否是空的，要是用len(s) == 0来判断，不应该使用s == nil来判断。
切片的赋值
切片是引用类型，只要他们是从同一个底层散发出去的，他们的修改操作就会影响底层。
package main
import "fmt"
func main() {
// 切片赋值
ms1 := make([]int, 3) //[0 0 0]
ms2 := ms1 //将s1直接赋值给s2，s1和s2共用一个底层数组
ms2[0] = 100
fmt.Println(ms1) //[100 0 0]
fmt.Println(ms2) //[100 0 0]
}
----------
[100 0 0]
[100 0 0]
切片的遍历
因为底层还是数组，所以遍历的方式与结果与数组一致。
package main
import "fmt"
func main() {
// 切片遍历
s := []int{1, 3, 5}
for i := 0; i < len(s); i++ {
fmt.Println(i, s[i])
}
for index, value := range s {
fmt.Println(index, value)
}
}
----------
0 1
1 3
2 5
0 1
1 3
2 5
append()
Go语言的内建函数append()可以为切片动态添加元素。 可以一次添加一个元素，可以添加多个元素，也可以添加另一个切片中的元素（后面加…）。
package main
import "fmt"
func main() {
s1 := []string{"北京", "上海", "深圳"}
fmt.Printf("len(s1):%d,cap(s1):%d\n", len(s1), cap(s1))
// 按照原来的写法，对数组进行扩容可以：
// s1[3] = "广州" //但是go中数组是定长类型，所以不能这么写
// 正确的写法： 使用一个变量接受返回值，一般用原来的切片接受返回值
s1 = append(s1, "广州") // 进行扩容之后的切片，就不再是原来的切片了。
fmt.Printf("len(s1):%d,cap(s1):%d\n", len(s1), cap(s1))
// 添加多个元素
s1 = append(s1, "成都", "重庆")
fmt.Printf("len(s1):%d,cap(s1):%d\n", len(s1), cap(s1))
// 添加另一个切片中的元素
s2 := []string{"石家庄", "保定", "邢台"}
s1 = append(s1, s2...)
fmt.Printf("len(s1):%d,cap(s1):%d\n", len(s1), cap(s1))
}
----------
len(s1):3,cap(s1):3
len(s1):4,cap(s1):6
len(s1):6,cap(s1):6
len(s1):9,cap(s1):12
注意：append()函数可以直接作用于没有初始化的切片。
每个切片会指向一个底层数组，这个数组的容量够用就添加新增元素。当底层数组不能容纳新增的元素时，切片就会自动按照一定的策略进行“扩容”，此时该切片指向的底层数组就会更换。“扩容”操作往往发生在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倍。
切片的扩容策略
我们先看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类型的处理方式就不一样。
大白话一下就是：
1.如果要的容量是原来容量的两倍还要多，那么把他要的给他：
s1 := []string{"北京", "上海", "深圳"}
fmt.Printf("len(s1):%d,cap(s1):%d\n", len(s1), cap(s1))
s1 = append(s1, "广州","成都", "重庆","石家庄", "保定", "邢台","张家口")
fmt.Printf("len(s1):%d,cap(s1):%d\n", len(s1), cap(s1))
----------
len(s1):3,cap(s1):3
len(s1):10,cap(s1):10
他最开始有3容量，然后一次性插入7个元素，比他本来的容量的两倍大，那么就用现在的容量直接覆盖原来的容量。
2.如果要的容量没有原来容量两倍大，那就扩充到原来容量的两倍。
s1 := []string{"北京", "上海", "深圳"}
fmt.Printf("len(s1):%d,cap(s1):%d\n", len(s1), cap(s1))
s1 = append(s1, "广州","成都")
fmt.Printf("len(s1):%d,cap(s1):%d\n", len(s1), cap(s1))
----------
len(s1):3,cap(s1):3
len(s1):10,cap(s1):6
3.如果原来的容量大于1024，那么每次提升25%，不再是提升100%。
也就是原来是2000的容量，扩充会先扩充到2500，不够再扩充到3000，不会一下翻两倍到4000。
copy()
关于拷贝的用法，可以参考我的深浅拷贝那一节，理解了Python的深浅拷贝，就能秒懂这个。
package main
import "fmt"
func main() {
// copy
a := []int{1, 2, 3, 4, 5}
c := make([]int, 5, 5)
copy(c, a) //使用copy()函数将切片a中的元素复制到切片c
fmt.Printf("a:%v,len(a):%d,cap(a):%d\n", a,len(a), cap(a))
fmt.Printf("c:%v,len(c):%d,cap(c):%d\n", c,len(c), cap(c))
c[0] = 1000 // copy操作之后的切片c和切片a之间没有任何关系 是两个独立的切片
fmt.Printf("a:%v,len(a):%d,cap(a):%d\n", a,len(a), cap(a))
fmt.Printf("c:%v,len(c):%d,cap(c):%d\n", c,len(c), cap(c))
}
----------
a:[1 2 3 4 5],len(a):5,cap(a):5
c:[1 2 3 4 5],len(c):5,cap(c):5
a:[1 2 3 4 5],len(a):5,cap(a):5
c:[1000 2 3 4 5],len(c):5,cap(c):5
删除元素
Go语言中并没有删除切片元素的专用方法，我们可以使用切片本身的特性来删除元素。
// 删除元素
s := []int{1,2,3,4,5,6,7,8}
// 使用append间隔追加
s = append(s[:1],s[2:]...)
fmt.Printf("s:%v,len(s):%d,cap(s):%d\n", s,len(s), cap(s))
---------
s:[1 3 4 5 6 7 8],len(s):7,cap(s):8
练习题
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)
}
[ 0 1 2 3 4 5 6 7 8 9]
// 最开始的a是一个有五个空字符串的切片。
// 切片里面能放多少元素，是容量说的算
2.请使用内置的sort包对数组var a = [...]int{3, 7, 8, 9, 1}进行排序
var a1 = [...]int{3, 7, 8, 9, 1}
sort.Ints(a1[:])
fmt.Println(a1)
要导入sort这个包。 记得把数组变成切片。
