写在前面：
本篇除了介绍Slice和Map外，还会介绍数组类型以及初始化的一些方法，单独吧Slice和Map拿出来是因为开发中几乎每个函数都会遇到它们，所以需要重点了解。
0x01 — 数组
数组在Golang中不经常用到，用到数组的地方一般都会用slice，不过slice的基础还是一个数组，所以我们还是要了解数组。
首先是定义方法：
package main
import "testing"
// 数组定义
func TestArray(t *testing.T){
// 定义一个int数组，长度为3，
// 在未初始化时数组默认值是根据定义数组的类型有关系，
// 比如int都是0，字符串都是空字符串"",
// 下面的ta数组中第三位未定义
var ta [3]int
// 赋值
ta[0] = 1
ta[1] = 2
t.Log("数组ta: ", ta)
//ta[4] = 3 超出下标抛出异常：Invalid array index '4' (out of bounds for the 3-element array)
// 定义一个int数组，长度为5，并进行赋值
ta1 := [5]int{234,333,444,555,1231}
t.Log("数组ta1: ", ta1)
// 通过len函数获取数组长度
t.Log("数组ta1的长度: ", len(ta1))
// 通过for循环遍历出数组，range会返回两个值，索引和值
for index, d := range ta1 {
t.Logf("索引: %d 的值 是: %d", index, d)
}
//如果不确定数组长度可以使用...表示
var ta2 = [...]int{11,2,2,3,4,5,232}
// 注意，数组在初始化时长度就固定了，无法修改长度，同时超出
// 索引范围的访问都是失效的
// ta2[19] = 99 //Invalid array index '19' (out of bounds for the 7-element array)
t.Log("数组ta2:", ta2)
t.Log("数组ta2的长度:", len(ta2))
} 输出：
=== RUN TestArray
slice_map_test.go:15: 数组ta: [1 2 0]
slice_map_test.go:21: 数组ta1: [234 333 444 555 1231]
slice_map_test.go:24: 数组ta1的长度: 5
slice_map_test.go:28: 索引: 0 的值 是: 234
slice_map_test.go:28: 索引: 1 的值 是: 333
slice_map_test.go:28: 索引: 2 的值 是: 444
slice_map_test.go:28: 索引: 3 的值 是: 555
slice_map_test.go:28: 索引: 4 的值 是: 1231
slice_map_test.go:33: 数组ta2: [11 2 2 3 4 5 232]
slice_map_test.go:34: 数组ta2的长度: 7
--- PASS: TestArray (0.00s)
PASS 注意事项：
数组的长度是固定的，不可修改
定义多维数组是可通过var ta3 = [2][3]int{}，访问也需要通过下标多级访问ta3[1][2]。
0x03 — Slice(切片)
GoLang中切片可以说是数组的抽象，基于数组基础，在之上建立可变长度的索引指针。
切片的声明方式和数组不同的一点就是不需要指定长度或… 定义如下：
var identifier []type 切片的一系列操作：
package main
import (
"math/rand"
"sort"
"testing"
)
// 切片
func TestSlice(t *testing.T) {
//定义切片
var ts []int
// 切片由于未初始化，长度为0，所以无法赋值，此错误编译简短无法抛出，
// 运行时会抛出异常：panic: runtime error: index out of range [0] with length 0
//ts[0] = 1
t.Log("切片ts: ", ts)
// 通过下面两种方式初始化一个切片，
// make方式是比较常用的初始化方式map也会通过make初始化
var ts1 []int= make([]int, 5) // int型数组长度为5,默认值为0
//var ts1 = make([]int, 3) // 类型[]int可以省略，Golang会自动推算出类型
ts2 := []int{4, 5, 9} // 直接定义并赋值
t.Logf("切片ts1:%v, 长度:%d ", ts1, len(ts1))
t.Logf("切片ts2:%v, 长度:%d ", ts2, len(ts2))
// 数组长度通过append方式增加也可以通过切片索引方式取其中的部分
ts2 = append(ts2,100, 200, 300) // 向数组中增加三个元素
t.Logf("(append)切片ts2:%v, 长度:%d ", ts2, len(ts2))
ts2 = ts2[2:4] // 取2，3两个数据组成ts2
t.Logf("([2:4])切片ts2:%v, 长度:%d ", ts2, len(ts2))
// 通过解构方式可以合并两个数组
ts2 = append(ts2, ts1...)
t.Logf("(将ts1合并到ts2)切片ts2:%v, 长度:%d ", ts2, len(ts2))
// Copy slice
ts3 := make([]int, 10)
for i := 0; i < 10; i++ {
ts3[i] = int(rand.Int31n(1000)) // 随机生成1000内的整数
}
t.Logf("切片ts3:%v, 长度:%d ", ts3, len(ts3))
sort.Ints(ts3) // 对ts3进行排序
ts3c := make([]int, 5)
copy(ts3c, ts3[:5]) // 将ts3的前5个数copy到ts3c中
t.Logf("切片ts3c:%v, 长度:%d ", ts3c, len(ts3c))
ts3c1 := make([]int, 5)
copy(ts3c1[1:], ts3[:4]) // 将ts3的前4个数copy到ts3c1中的后4个位置
t.Logf("切片ts3c1:%v, 长度:%d ", ts3c1, len(ts3c1))
// 创建二维切片，子切片里的类型可以省略，最后一个元素的逗号不可省略
ts4 := [][]int{
[]int{1,2,3},
[]int{4,5,6},
{7,8,9},
}
t.Logf("切片ts4:%v, 长度:%d ", ts4, len(ts4))
} 输出：
=== RUN TestSlice
slice_map_test.go:53: 切片ts: []
slice_map_test.go:60: 切片ts1:[0 0 0 0 0], 长度:5
slice_map_test.go:61: 切片ts2:[4 5 9], 长度:3
slice_map_test.go:65: (append)切片ts2:[4 5 9 100 200 300], 长度:6
slice_map_test.go:67: ([2:4])切片ts2:[9 100], 长度:2
slice_map_test.go:70: (将ts1合并到ts2)切片ts2:[9 100 0 0 0 0 0], 长度:7
slice_map_test.go:77: 切片ts3:[81 887 847 59 81 318 425 540 456 300], 长度:10
slice_map_test.go:81: 切片ts3c:[59 81 81 300 318], 长度:5
slice_map_test.go:84: 切片ts3c1:[0 59 81 81 300], 长度:5
slice_map_test.go:92: 切片ts4:[[1 2 3] [4 5 6] [7 8 9]], 长度:3
--- PASS: TestSlice (0.00s)
PASS 切片在初始化时通过make可以指定长度和容量（capacity），容量可选，默认和长度一致。
copy slice时注意接收侧的优先级要高于被拷贝的元素数量
0x04 — Map(映射,字典，hashMap)
Golang中map是一种无序键值对，可以通过key来获取key对应的value，map可以通过循环遍历出每对元素。
package main
import "testing"
// map
func TestMap(t *testing.T) {
//定义Map
var tm map[string]int
// 这里只定义了tm，如果不初始化 map，那么就会创建一个 nil map
// nil map 不能用来存放键值对，直接赋值会报错:assignment to entry in nil map
//tm["ming"] = 12
//var tm = map[string]int{"wang":11, "niu": 23} // 可以在定义时进行初始化赋值
// 初始化map,起始容量为5的map，如果你能知道你的Map有多少个键，定义时指定一个初始大小可以获得一定的性能提升
tm = make(map[string]int, 2)
t.Logf("Map tm:%v, 长度:%d", tm, len(tm))
tm["ming"] = 12
tm["hua"] = 23
tm["ca"] = 44
t.Logf("Map tm:%v, 长度:%d", tm, len(tm))
// 获取map中元素需要设置两个接收遍历，第二个返回值会返回是否存在
ming, ok := tm["ming"]
t.Log("Map item ming:", ming, ok)
// 如果发现key值不存在，则返回value的默认值，同时第二个返回值为false
// 如果不想使用第二个值，可以将第二个值改为_,默认会被抛弃同时不会编译报错
// ming1, _ := tm["ming1"]
ming1, ok1 := tm["ming1"]
t.Log("Map item ming1:", ming1, ok1)
//遍历map
for k := range tm {
t.Logf("Map key:%s, value:%d", k, tm[k])
}
// 删除元素
delete(tm, "ming")
delete(tm, "ming")
t.Log("Map detete tm:", tm)
} 输出：
=== RUN TestMap
slice_map_test.go:16: Map tm:map[], 长度:0
slice_map_test.go:20: Map tm:map[ca:44 hua:23 ming:12], 长度:3
slice_map_test.go:24: Map item ming: 12 true
slice_map_test.go:29: Map item ming1: 0 false
slice_map_test.go:33: Map key:ming, value:12
slice_map_test.go:33: Map key:hua, value:23
slice_map_test.go:33: Map key:ca, value:44
slice_map_test.go:38: Map detete tm: map[ca:44 hua:23]
--- PASS: TestMap (0.00s)
PASS 注意事项：
map一定要注意声明后需要初始化，不然无法接收key
map是无序的，每次遍历的得到顺序可能不同
0x05 — 初始化
在初始化Slice和Map时，以及后续初始化Chan，都需要用到make，make是内置的初始化函数，定义+分配内存，官方定义解释：
Slice: The size specifies the length. The capacity of the slice is
equal to its length. A second integer argument may be provided to
specify a different capacity; it must be no smaller than the
length. For example, make([]int, 0, 10) allocates an underlying array
of size 10 and returns a slice of length 0 and capacity 10 that is
backed by this underlying array.
Map: An empty map is allocated with enough space to hold the
specified number of elements. The size may be omitted, in which case
a small starting size is allocated.
Channel: The channel's buffer is initialized with the specified
buffer capacity. If zero, or the size is omitted, the channel is
unbuffered. 解释：
Slice：大小指定长度。片的容量等于它的长度。可以提供第二整数参数以指定不同的容量；必须不小于长度。
例如，make([]int,0,10）分配一个大小为10的基础数组，并返回由该基础数组支持的长度为0和容量为10的片。
map：为一个空map分配足够的空间来容纳指定数量的元素。可以省略该大小，在这种情况下分配一个小的起始大小。
通道：通道的缓冲区用指定的缓冲区容量初始化。如果为零，或者省略了大小，则不缓冲信道(缓存信道是队列类型)
make方法可以创建并初始，和new方法类似，不同之处在于make返回初始化后的内容，new返回的是指针。
对slice而言，除了指定元素，还可以指定长度和容量，长度表示当前初始化的数量，容量表示最大数量，超出索引将抛出异常。
对map而言，初始化时指定第二个参数，会暗示需要的长度，有助于空间快速分配和访问，但是这个参数不会控制map真正的长度。
0x06 — 总结
Slice和Map是使用频率很高的功能，在使用时注意初始化，同时在开发过程中如果熟悉方法变量，内置函数参数等，可以通过IDE的追溯功能找到源代码注解，看一遍大概理解的更深。比如make函数，可以通过查看源码文档，同时还可以直接点进去查看源码
make的官方定义
