Go语言学习-- No.10 -- 函数---Go内置函数

内置函数汇总

append

使用格式：

新变量 := append(原变量, element1, element2, 等) 

新变量 := append(原变量, 数组...)  

将数据追加到 slice 的末尾，返回一个 slice。

举例：

package main

import "fmt"

func main() {
	sourceSlice := []int{1, 2, 3}
	sourceSlice = append(sourceSlice, 4, 5, 6)
	fmt.Println("使用append添加元素: ", sourceSlice)

	slice_app := []int{111, 222, 333}
	sourceSlice1 := append(sourceSlice, slice_app...)
	fmt.Println("在原有的基础上, 拼接数组", sourceSlice1)

}

// 使用append添加元素:  [1 2 3 4 5 6]
// 在原有的基础上, 拼接数组 [1 2 3 4 5 6 111 222 333]

copy

使用格式 ：

copy(target, old) 完成的操作是将 old 复制给 target 

举例：

package main

import "fmt"

func main() {
	sourceSlice := []int{1, 2, 3, 4}
	sourceSlice = append(sourceSlice, 4, 5, 6)
	fmt.Println("使用append添加元素: ", sourceSlice)

	targetSlice := make([]int, 4)
	fmt.Println("targetSlice的内容为: ", targetSlice)

	newSlice := copy(targetSlice, sourceSlice)
	fmt.Println("把sourceSlice复制到targetSlice: ", targetSlice) // 覆盖式创建
	fmt.Println("把sourceSlice复制到targetSlice得到newSlice: ", newSlice)

}

// 使用append添加元素:  [1 2 3 4 4 5 6]
// targetSlice的内容为:  [0 0 0 0]
// 把sourceSlice复制到targetSlice:  [1 2 3 4]
// 把sourceSlice复制到targetSlice得到newSlice:  4

delete

使用格式:

delete(映射map变量, 映射中的键key)

举例 ：

package main

import (
	"fmt"
)

func main() {
	dict := map[string]int{
		"a": 1,
		"b": 2,
		"c": 3,
	}
	fmt.Println("删除前: ", dict)

	delete(dict, "a")
	fmt.Println("删除后", dict)
}

// 删除前:  map[a:1 b:2 c:3]
// 删除后 map[b:2 c:3]

len

package main

import "fmt"

func main() {
	sourceSlice := []int{1, 2, 3, 4}
	fmt.Println("abc", sourceSlice)

	fmt.Println("切片长度为len(sourceSlice) == ", len(sourceSlice))
	fmt.Println("切片容量为cap(sourceSlice) == ", cap(sourceSlice))
}

// abc [1 2 3 4]
// 切片长度为len(sourceSlice) ==  4
// 切片容量为cap(sourceSlice) ==  4

cap

package main

import "fmt"

func main() {
	sourceSlice := []int{1, 2, 3, 4}
	fmt.Println("abc", sourceSlice)

	fmt.Println("切片长度为len(sourceSlice) == ", len(sourceSlice))
	fmt.Println("切片容量为cap(sourceSlice) == ", cap(sourceSlice))
}

// abc [1 2 3 4]
// 切片长度为len(sourceSlice) ==  4
// 切片容量为cap(sourceSlice) ==  4

make

为 slice、map 或 channel 类型分配内存并初始化对象。

使用格式：

var 变量名 []变量类型
变量名 = make([]类型, 长度len, 容量cap)

或者

变量名 := make([]类型, 长度len, 容量cap)
  

举例：

package main

import (
	"fmt"
)

func main() {

	a := make([]string, 0, 1)
	slice := make([]int, 0, 100)   // 切片make初始化
	hash := make(map[int]bool, 10) // map映射初始化
	ch := make(chan int, 5)        // channel初始化

	fmt.Println("a = ", a)
	fmt.Println("slice = ", slice)
	fmt.Println("hash = ", hash)
	fmt.Println("channel = ", ch)

}

// a =  []
// slice =  []
// hash =  map[]
// channel =  0xc000106000

new

为 slice、map 和 channel 以外的类型分配内存并初始化对象，返回类型指针

使用格式

指针变量名 = new(指针变量类型)
var 变量名 变量类型
指针变量名 = &变量名 // 对指针变量进行赋值 

举例：

package main

import "fmt"

func main() {
	p := new(int)
	fmt.Println("未赋值的指针变量p : ", p)
	var a int
	p = &a
	fmt.Println("经过a赋值后的指针变量: ", p)
	fmt.Println("a本身取出来的指针地址: ", &a)
}

// 未赋值的指针变量p :  0xc000014098
// 经过a赋值后的指针变量:  0xc0000140c0
// a本身取出来的指针地址:  0xc0000140c0

complex, real, imag

定义复数，找到实部和虚部。

package main

import (
	"fmt"
)

func main() {
	c1 := complex(1, 2)
	fmt.Println("复数的实部: ", real(c1))
	fmt.Println("复数的虚部: ", imag(c1))

}

// 复数的实部:  1
// 复数的虚部:  2

close

用于关闭 channel
使用格式 ：

ch := make(chan int, 通道数)  // 声明channel
....使用ch（channel变量的程序）
close(ch)  // 关闭channel 

举例说明：

package main

import "fmt"

func main() {
	ch := make(chan int, 5)  // 声明channel

	for i := 0; i < 5; i++ {
		ch <- i
	}

	close(ch) // 关闭ch

	for i := 0; i < 10; i++ {
		e, ok := <-ch
		fmt.Printf("%v, %v\n", e, ok)

		if !ok {
			break
		}
	}
}

panic

触发宕机
panic是Go语言中的一个内置函数，可以停止程序的控制流，改变其流转，并且触发“恐慌”事件。

package main

import (
	"fmt"
	"time"
)

func main() {
	fmt.Println("start the program === ")
	defer fmt.Println("in main")
	go func() {
		defer fmt.Println("in gorountine")
		panic("panic happend ! ")
		// Go 语言在发生 panic 时只会执行当前协程中的 defer 函数

	}()

	time.Sleep(1 * time.Second)
}

// start the program === 
// in gorountine
// panic: panic happend ! 

// goroutine 6 [running]:
// main.main.func1()
// 	f:/Go-Player/Goexample/read_book漫画图解/练习题/ceshiban.go:13 +0x73
// created by main.main
// 	f:/Go-Player/Goexample/read_book漫画图解/练习题/ceshiban.go:11 +0xb7
// exit status 2

很明显，上面的代码中 main函数的defer 并没有被执行，但是go func() 中的 panic执行了，go func() 中的 defer 也执行了，而且还出现了错误提示 。

这说明， Go 语言在发生 panic 时只会执行当前协程中的 defer 函数。

recover

recover也是一个内置函数，其功能与panic相反，recover可以让程序重新获取“恐慌”事件后的程序控制权，但是recover必须在defer中才会生效。

举例：

package main

import (
	"fmt"
)

func main() {
	fmt.Println("start the program === ")
	defer fmt.Println("in main")
	defer func() {
		if err := recover(); err != nil {
			fmt.Println("in gorountine")
			fmt.Println(err)
		}

		// 当panic发生的时候，defer + recover 会重新都会panic的控制权，执行 defer recover 中的程序
		

	}()
	panic("panic happend ! ")
}

// start the program ===
// in gorountine
// panic happend !
// in main

recover 函数其实只是阻止了当前程序的崩溃，但是当前控制流中的其他 defer 函数还会正常执行。

具体的内容可以看一下文章：