array
array就是数组，它的定义方式如下：
在[n]type中，n表示数组的长度，type表示存储元素的类型。对数组的操作和其
它语言类似，都是通过[]来进行读取或赋值：
var arr [10]int // 声明了一个int类型的数组
arr[0] = 42 // 数组下标是从0开始的
arr[1] = 13 // 赋值操作
fmt.Printf(“The first element is %d\n”, arr[0]) // 获取数据，返回42
fmt.Printf(“The last element is %d\n”, arr[9]) //返回未赋值的最后一个元
素，默认返回0
由于长度也是数组类型的一部分，因此[3]int与[4]int是不同的类型，数组也就
不能改变长度。数组之间的赋值是值的赋值，即当把一个数组作为参数传入函
数的时候，传入的其实是该数组的副本，而不是它的指针。如果要使用指针，
那么就需要用到后面介绍的slice类型了。
数组可以使用另一种:=来声明
a := [3]int{1, 2, 3} // 声明了一个长度为3的int数组
b := [10]int{1, 2, 3} // 声明了一个长度为10的int数组，其中前三个元素初始化为
1、2、3，其它默认为0
c := […]int{4, 5, 6} // 可以省略长度而采用`…`的方式，Go会自动根据元素个
数来计算长度
也许你会说，我想数组里面的值还是数组，能实现吗？当然咯，Go支持嵌套数
组，即多维数组。比如下面的代码就声明了一个二维数组：
// 声明了一个二维数组，该数组以两个数组作为元素，其中每个数组中又有4个int类型
的元素doubleArray := [2][4]int{[4]int{1, 2, 3, 4}, [4]int{5, 6, 7, 8}}
// 上面的声明可以简化，直接忽略内部的类型easyArray := [2][4]int{{1, 2, 3,
4}, {5, 6, 7, 8}}
数组的分配如下所示：
slice
在很多应用场景中，数组并不能满足我们的需求。在初始定义数组时，我们并
不知道需要多大的数组，因此我们就需要“动态数组”。在Go里面这种数据结构
叫slice
slice并不是真正意义上的动态数组，而是一个引用类型。slice总是指向一个底
层array，slice的声明也可以像array一样，只是不需要长度。
// 和声明array一样，只是少了长度var fslice []int
接下来我们可以声明一个slice，并初始化数据，如下所示：
slice := []byte {‘a’, ‘b’, ‘c’, ‘d’}
slice可以从一个数组或一个已经存在的slice中再次声明。slice通过array[i:j]
来获取，其中i是数组的开始位置，j是结束位置，但不包含array[j]，它的长度
是j-i。
// 声明一个含有10个元素元素类型为byte的数组var ar = [10]byte {‘a’, ‘b’, ‘c’,
‘d’, ‘e’, ‘f’, ‘g’, ‘h’, ‘i’, ‘j’}
// 声明两个含有byte的slice: var a, b []byte
// a指向数组的第3个元素开始，并到第五个元素结束，
a = ar[2:5]
//现在a含有的元素: ar[2]、ar[3]和ar[4]
// b是数组ar的另一个slice
b = ar[3:5]
// b的元素是：ar[3]和ar[4]
注意slice和数组在声明时的区别：声明数组时，方括号内写明了数组的长
度或使用…自动计算长度，而声明slice时，方括号内没有任何字符。
它们的数据结构如下所示：
slice有一些简便的操作
- slice的默认开始位置是0，ar[:n]等价于ar[0:n]
- slice的第二个序列默认是数组的长度，ar[n:]等价于ar[n:len(ar)]
- 如果从一个数组里面直接获取slice，可以这样ar[:]，因为默认第一个序列是0，第二个是数组的长度，即等价于ar[0:len(ar)]
下面这个例子展示了更多关于slice的操作：
// 声明一个数组var array = [10]byte{‘a’, ‘b’, ‘c’, ‘d’, ‘e’, ‘f’, ‘g’, ‘h’,
‘i’, ‘j’}
// 声明两个slice：var aSlice, bSlice []byte// 演示一些简便操作
aSlice = array[:3] // 等价于aSlice = array[0:3] aSlice包含元素: a,b,c
aSlice = array[5:] // 等价于aSlice = array[5:10] aSlice包含元素:
f,g,h,i,j
aSlice = array[:] // 等价于aSlice = array[0:10] 这样aSlice包含了全部的元
素
// 从slice中获取slice
aSlice = array[3:7] // aSlice包含元素: d,e,f,g，len=4，cap=7
bSlice = aSlice[1:3] // bSlice 包含aSlice[1], aSlice[2] 也就是含有: e,f
bSlice = aSlice[:3] // bSlice 包含 aSlice[0], aSlice[1], aSlice[2] 也就
是含有: d,e,f
bSlice = aSlice[0:5] // 对slice的slice可以在cap范围内扩展，此时bSlice包
含：d,e,f,g,h
bSlice = aSlice[:] // bSlice包含所有aSlice的元素: d,e,f,g
slice是引用类型，所以当引用改变其中元素的值时，其它的所有引用都会改变
该值，例如上面的aSlice和bSlice，如果修改了aSlice中元素的值，那么bSlice
相对应的值也会改变。
从概念上面来说slice像一个 结构体 ，这个结构体包含了三个元素：
- 一个指针，指向数组中slice指定的开始位置
- 长度，即slice的长度
- 最大长度，也就是slice开始位置到数组的最后位置的长度
Array_a := [10]byte{‘a’, ‘b’, ‘c’, ‘d’, ‘e’, ‘f’, ‘g’, ‘h’, ‘i’, ‘j’}
Slice_a := Array_a[2:5]
上面代码的真正存储结构如下图所示：
对于slice有几个有用的内置函数：
- len 获取slice的长度
- cap 获取slice的最大容量
- append 向slice里面追加一个或者多个元素，然后返回一个和slice一样类型的slice
- copy 函数copy从源slice的src中复制元素到目标dst，并且返回复制的元素的个数
注：append函数会改变slice所引用的数组的内容，从而影响到引用同一数组的
其它slice。 但当slice中没有剩余空间（即(cap-len) == 0）时，此时将动态分
配新的数组空间。返回的slice数组指针将指向这个空间，而原数组的内容将保
持不变；其它引用此数组的slice则不受影响。比如：
/*
更多课程信息：
goland deveops 项目实战：
Linux C/C++服务器/架构师课程：
更多学习资料： C/C++架构师：762073882 ，Golang Deveops项目实战：148745800
*/
package main
import “fmt”
func main() {
arr := […]byte{‘a’, ‘b’, ‘c’, ‘d’, ‘e’, ‘f’, ‘g’, ‘h’, ‘i’, ‘j’}
a := arr[2:5]
b := arr[5:]
fmt.Printf(“arr : %s , size : %d \n”, arr, len(arr))
fmt.Printf(“a : %s , size : %d \n”, a, len(a))
fmt.Printf(“b : %s , size : %d \n”, b, len(b))
s1 := []byte{‘1’, ‘2’, ‘3’}
s1 = append(a, s1…)
fmt.Printf(“s1: %s \n”, s1)
fmt.Printf(“a : %s \n”, a)
fmt.Printf(“b : %s \n”, b)
fmt.Printf(“arr : %s \n”, arr)
fmt.Printf(“零声学院\n”)
}
上面程序的输出是：
arr : abcdefghij , size : 10
a : cde , size : 3
b : fghij , size : 5
s1: cde123
a : cde
b : 123ij
arr : abcde123ij
零声学院从Go1.2开始slice支持了三个参数的slice，之前我们一直采用这种方式在slice或
者array基础上来获取一个slice
var array [10]int
s1 := array[2:4:]
这个例子里面s1的容量是8，新版本里面可以指定这个容量
s2 = array[2:4:7]
上面这个的容量就是7-2，即5。这样这个产生的新的slice就没办法访问最后的
三个元素。
如果slice是这样的形式array[:i:j]，即第一个参数为空，默认值就是0。
视频教程
