Golang内置函数

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 中嵌套多次调用；