func append(slice []Type, elems ...Type) []Type
# 增加0到n个元素到slice中，返回新的slice，注意第一个参数不能是指针类型
intslice := make([]int, 0)
intslice = append(intslice, 1)
intslice = append(intslice, 2)
//intslice : [1,2]
func copy(dst, src []Type) int
# 用于将源slice的数据（第二个参数），复制到目标slice（第一个参数）。
# 返回值为拷贝了的数据个数，是len(dst)和len(src)中的最小值。
var a = []int{0, 1, 2, 3, 4, 5, 6, 7}
var s = make([]int, 6)
//源长度为8，目标为6，只会复制前6个
n1 := copy(s, a)
fmt.Println("s - ", s)
fmt.Println("n1 - ", n1)
//源长为7，目标为6，复制索引1到6
n2 := copy(s, a[1:])
fmt.Println("s - ", s)
fmt.Println("n2 - ", n2)
//源长为8-5=3，只会复制3个值，目标中的后三个值不会变
n3 := copy(s, a[5:])
fmt.Println("s - ", s)
fmt.Println("n3 - ", n3)
//将源中的索引5,6,7复制到目标中的索引3,4,5
n4 := copy(s[3:], a[5:])
fmt.Println("s - ", s)
fmt.Println("n4 - ", n4)
func delete(m map[Type]Type1, key Type)
# 删除map中的一个映射， m为nil或者m[k]不存在也不会panic,而是一个空操作
m := map[int]string{
1: "张三",
2: "李四",
}
delete(m, 1)
fmt.Println(m) // map[2:李四]
func len(v Type) int
# 得到字符串、数组、数值指针、slice、map、chan的长度
s := "hello world,你好中国"
a := [5]int{1, 2, 3, 4, 5}
sl := a[:3]
m := map[string]int{"a": 1, "b": 2}
c := make(chan int, 3)
fmt.Println(len(s)) // 字符串：记录字节数。 24
fmt.Println(len(a)) // 数组：记录数组元素个数。 5
fmt.Println(len(sl)) // 切片：记录切片元素个数。 3
fmt.Println(len(m)) // map：记录map元素个数。2
fmt.Println(len(c)) // channel：记录channel通道中的元素个数 0
func cap(v Type) int
# 可以用来查看数组或slice的容量
slice := []int{1, 2, 3, 4, 5, 6, 7, 8, 9}
slice1 := slice[1:5]
fmt.Println(slice) //[1 2 3 4 5 6 7 8 9]
fmt.Println(slice1) // [2 3 4 5] : 包括1 但不包括5
fmt.Println(len(slice1)) // 4 切片的长度
fmt.Println(cap(slice1)) // 8 切片的容量
func make(t Type, size ...IntegerType) Type
# 生成slice、map、channel对象
sl1 := make([]int, 5) //定义长度和容量都为5的切片
sl2 := make([]int, 5, 10) //定义长度为5，容量为10的切片
map1 := make(map[string]int) //定义map
map2 := make(map[string]int, 2) //定义map 初始可以容纳2个元素的空间
c1 := make(chan int) //定义不带缓存的channel
c2 := make(chan int, 5) // 定义缓存大小为5的channel
func new(Type) *Type
# 生成类型T的零值指针,注意它返回的是指针 *T
# golang 中有两个内存分配机制 ：new和make，二者有明显区别．
# new：用来初始化一个对象，并且返回该对象的首地址．其自身是一个指针．可用于初始化任何类型
# make:返回一个初始化的实例，返回的是一个实例，而不是指针，其只能用来初始化：slice,map和channel三种类型
t := new(T)
func complex(r, i FloatType) ComplexType
func real(c ComplexType) FloatType
func imag(c ComplexType) FloatType
# Go提供了两种大小的复数类型：complex64和complex128，分别由float32和float64组成。
# 内置函数complex从指定的实部和虚部构建复数，内置函数real和imag用来获取复数的实部和虚部
var x complex128 = complex(1, 2) // 1+2i 构建复数
var y complex128 = complex(3, 4) // 3+4i 构建复数
fmt.Println(x*y) // "(-5+10i)"
fmt.Println(real(x*y)) // "-5" 获取实部
fmt.Println(imag(x*y)) // "10" 获取虚部
func close(c chan<- Type)
# 关闭channel
ch := make(chan bool)
close(ch)
close(ch) // 这样会panic的，channel不能close两次
ch <- false //已经关闭channel 不能写入数据
i, ok := <- ch 判断channel是否关闭
i := <-ch 不会panic, i读取到的值是false,如果是有缓存channel，可以继续读取channel中的剩余的数据
func panic(v interface{})
func recover() interface{}
defer func() { // 必须要先声明defer，否则不能捕获到panic异常
fmt.Println("c")
if err := recover(); err != nil { //调用recover函数将会捕获到当前的panic（如果有的话
fmt.Println(err) // 这里的err其实就是panic传入的内容，55
}
fmt.Println("d")
}()
fmt.Println("a")
panic(55) // panic是用来表示非常严重的不可恢复的错误的,一般会导致程序挂掉（除非recover)
fmt.Println("b")
fmt.Println("f")
// 输出结果：a c 55 d
# panic 只会触发当前 Goroutine 的延迟函数调用
# recover 只有在 defer 函数中调用才会生效；
# panic 允许在 defer 中嵌套多次调用；
