目录
- 一、函数的概念
- 二、匿名函数
- 三、闭包
- 四、defer
- 五、异常机制
一、函数的概念
- 函数的基本形式
//函数定义。a,b是形参
func argf(a int, b int) { a = a + b
}
var x, y int = 3, 6
argf(x, y) //函数调用。x,y是实参
- 函数参数:
func arg2(a, b int) { //参数类型相同时可以只写一次a = a + b//不写return时,默认执行完最后一行代码函数返回
}func arg3(a, b *int) { //如果想通过函数修改实参,就需要指针类型*a = *a + *b*b = 888
}func no_arg() { //函数可以没有参数,也没有返回值fmt.Println("欢迎开启Golang之旅")
}func return1(a, b int) int { //函数需要返回一个int型数据a = a + bc := a //声明并初始化一个变量creturn c
}func return2(a, b int) (c int) { //返回变量c已经声明好了a = a + bc = a //直接使用creturn //由于函数要求有返回值,即使给c赋过值了,也需要显式写return
}func return3() (int, int) { //可以没有形参,可以返回多个参数now := time.Now()return now.Hour(), now.Minute()
}
- slice、map、channel作为函数参数:
- slice、map、channel都是引用类型
- 它们作为函数参数时其实跟普通struct没什么区别
- 都是对struct内部的各个字段做一次拷贝传到函数内部
func slice_arg_1(arr []int) { //slice作为参数,实际上是把slice的arrayPointer、len、cap拷贝了一份传进来arr[0] = 1 //修改底层数据里的首元素arr = append(arr, 1) //arr的len和cap发生了变化,不会影响实参
}func main() {arr := []int{8}slice_arg_1(arr)fmt.Println(arr[0]) //1fmt.Println(len(arr)) //1
}
- 不定长参数:不定长参数实际上是slice类型
//不定长参数
func variable_ength_arg(a int, other ...int) int { //调用该函数时,other可以对应0个参数也可以对应多个参数sum := a//不定长参数实际上是slice类型for _, ele := range other {sum += ele}if len(other) > 0 {fmt.Printf("first ele %d len %d cap %d\n", other[0], len(other), cap(other))} else {fmt.Printf("len %d cap %d\n", len(other), cap(other))}return sum
}func main() {variable_ength_arg(1, 2, 3, 4, 5) //first ele 2 len 4 cap 4
}
- append函数接收的就是不定长参数:
func append(slice []Type, elems ...Type) []Type
func main() {arr := []int{4, 5, 6}//append函数接收的就是不定长参数arr = append(arr, 1, 2, 3)arr = append(arr, 7)fmt.Printf("new arr %v\n", arr) //new arr [4 5 6 1 2 3 7]
}
- **递归函数 **:函数自己调用自己
// 斐波那契数列前10个数为:0,1,1,2,3,5,8,13,21,34
func Fibonacci(n int) int {if n == 0 || n == 1 {return n //凡是递归,一定要有终止条件,否则会进入无限循环}return Fibonacci(n-1) + Fibonacci(n-2) //递归调用函数自身
}
二、匿名函数
- 函数也是一种数据类型
func function_arg1(f func(a, b int) int, b int) int { //f参数是一种函数类型a := 2 * breturn f(a, b)
}type foo func(a, b int) int //foo是一种函数类型
func function_arg2(f foo, b int) int { //参数类型看上去简洁多了a := 2 * breturn f(a, b)
}type User struct {Name stringbye foo //bye的类型是foo,而foo代表一种函数类型hello func(name string) string //使用匿名函数来声明struct字段的类型
}func main() {ch := make(chan func(string) string, 10)ch <- func(name string) string { //使用匿名函数return "hello " + name}
}
- 实例1
var sum = func(a, b int) int {return a + b
}type add func(a, b int) intfunc op(f add, a int) int {b := 2 * areturn f(a, b)
}func main() {fmt.Println(sum(1, 2)) //3fmt.Println(op(sum, 2)) //6
}
- 实例2
type User struct {Name stringRec func(int, int) int
}func add(a, b int) int {return a + b
}func sub(a, b int) int {return a - b
}func main() {user := User{Name: "hello", Rec: add}fmt.Println(user.Rec(1, 2)) // 3user.Rec = subfmt.Println(user.Rec(1, 2)) // -1}
三、闭包
- 闭包概念
- 闭包(Closure)是引用了自由变量的函数
- 自由变量将和函数一同存在,即使已经离开了创造它的环境
- 闭包复制的是原对象的指针
func sub() func() {i := 10fmt.Printf("%p\n", &i)b := func() {fmt.Printf("i addr %p i = ", &i)i--fmt.Println(i)}return b
}func main() {//对于sub来讲,i是局部变量,正常情况下离开了sub就被释放了//但是因为闭包函数b的存在,接下来的2个f()调用仍然是对原局部变量i的地址进行操作f := sub() //0xc000122058f() //i addr 0xc0000180a8 i = 9f() //i addr 0xc0000180a8 i = 8}
- 闭包案例:
- tmp1与传入base=10一同存在
- tmp2(这里base被初始化为10)与传入base=10一同存在
- 可以看到tmp1和tmp2的函数地址是不一样的
func add(base int) func(int) int {return func(i int) int {fmt.Printf("base addr %p\n", &base)base += ireturn base}
}func main() {tmp1 := add(10)fmt.Println(tmp1(1), tmp1(2))// base addr 0xc0000a6058// base addr 0xc0000a6058// 11 13tmp2 := add(10)fmt.Println(tmp2(1), tmp2(2))// base addr 0xc0000a6090// base addr 0xc0000a6090// 11 13
}
四、defer
-
defer概念
- defer用于注册一个延迟调用(在函数返回之前调用)
- defer典型的应用场景是释放资源,比如关闭文件句柄,释放数据库连接等
-
如果同一个函数有多个defer,则后注册的先执行
func basic() {fmt.Println("A")defer fmt.Println("B")//如果同一个函数有多个defer,则后注册的先执行defer fmt.Println("C")fmt.Println("D")
}func main() {basic() // A D C B
}
- defer后接func和接表达式
- defer后接func的时候,不会拷贝变量
- defer后面不是跟func,而直接跟一条执行语句,则相关变量在注册defer时被拷贝或计算
func defer_exe_time() (i int) {i = 9defer func() {fmt.Printf("defer_B i=%d\n", i) //打印5而非9}()defer func(i int) {fmt.Printf("defer_C i=%d\n", i)}(i) //i=9,在注册的时候这里i已经拷贝了9defer fmt.Printf("defer_A i=%d\n", i) //变量在注册defer时被拷贝或计算return 5
}func main() {defer_exe_time()// defer_A i=9// defer_C i=9// defer_B i=5
}
- defer-panic:func内部如果发生panic,会把panic暂时搁置,当把其他defer执行完之后再来执行这个panic
func defer_panic() {defer fmt.Println("11111111")n := 0defer func() {fmt.Println(2 / n)defer fmt.Println("2222222")}()defer fmt.Println("33333333")
}func main() {defer_panic()
}//33333333
//11111111
//发生异常: panic
//"runtime error: integer divide by zero"
//Stack:
// 3 0x0000000000448726 in main.defer_panic.func1
// at c:/develop_project/go_project/proj1/main.go:9
// 5 0x0000000000448465 in main.defer_panic
// at c:/develop_project/go_project/proj1/main.go:13
// 6 0x00000000004488d7 in main.main
// at c:/develop_project/go_project/proj1/main.go:16
五、异常机制
- error:go语言没有try catch,它提倡返回error
func divide(a, b int) (int, error) {if b == 0 {return -1, errors.New("divide by zero")}return a / b, nil
}func main() {if res, err := divide(3, 0); err != nil {fmt.Println(err.Error()) //divide by zero} else {fmt.Println(res)}
}
- 自定义error
type PathError struct {path stringop stringcreateTime stringmessage string
}func NewPathError(path, op, message string) PathError {return PathError{path: path,op: op,createTime: time.Now().Format("2006-01-02"), //yyyy-MM-ddmessage: message,}
}func (e PathError) Error() string {return e.createTime + ":" + e.op + " " + e.path + " " + e.message
}func deletePath(path string) error {return NewPathError(path, "delete", "path not exits")
}
- 何时会发生panic:
- 运行时错误会导致panic,比如数组越界、除0
- 程序主动调用panic(error)
- panic会执行什么:
- 逆序执行当前goroutine的defer链(recover从这里介入)
- 打印错误信息和调用堆栈
- 调用exit(2)结束整个进程
- recover:recover会阻断panic的执行
func soo() {defer func() {if err := recover(); err != nil {fmt.Println("发生了panic,不让程序退出")}}()panic(errors.New("这是错误信息"))
}func main() {soo()fmt.Println("333333333")
}