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

发表评论

电子邮件地址不会被公开。 必填项已用*标注