GO语言中的函数

函数的基本形式

//函数定义。a,b是形参
func argf(a int, b int) { 
	a = a + b 
}
var x, y int = 3, 6
argf(x, y) //函数调用。x,y是实参

• 形参是函数内部的局部变量，实参的值会拷贝给形参。
• 函数定义时的第一个的大括号不能另起一行。
• 形参可以有0个或多个。
• 参数类型相同时可以只写一次，比如argf(a,b int)。
• 在函数内部修改形参的值，实参的值不受影响。
• 如果想通过函数修改实参，就需要指针类型。

func argf(a, b *int) { 
    *a = *a + *b
    *b = 888
}
var x, y int = 3, 6
argf(&x, &y)

slice、map、channel都是引用类型，它们作为函数参数时其实跟普通struct没什么区别，都是对struct内部的各个字段做一次拷贝传到函数内部。

package main

import "fmt"

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])   //1
	fmt.Println(len(arr)) //1
}

关于函数返回值

• 可以返回0个或多个参数。
• 可以在func行直接声明要返回的变量。
• return后面的语句不会执行。
• 无返回参数时return可以不写。

func returnf(a, b int) (c int) { //返回变量c已经声明好了
    a = a + b
    c = a //直接使用c
    return //由于函数要求有返回值，即使给c赋过值了，也需要显式写return
}

不定长参数

不定长参数实际上是slice类型。

不定长参数需要在类型前面加上三个点...，以切片的形式存储不定长参数

取出参数需要使用循环遍历

func variable_ength_arg(a int, other ...int) int { 
    sum := a
    for _, ele := range other {//不定长参数实际上是slice类型
        sum += ele
    }
    fmt.Printf("len %d cap %d\n", len(other), cap(other))
    return sum
}
variable_ength_arg(1)
variable_ength_arg(1,2,3,4)

把切片转换为不定长参数

最典型的例子就是append函数

append函数接收的就是不定长参数。

在切片的后面加上...，就可以把切片转换为不定长参数

arr = append(arr, 1, 2, 3)
arr = append(arr, 7)
arr = append(arr)
slice := append([]byte("hello "), "world"...) //...自动把"world"转成byte切片，等价于[]byte("world")...
slice2 := append([]rune("hello "), []rune("world")...) //需要显式把"world"转成rune切片

在很多场景下string都隐式的转换成了byte切片，而非rune切片，比如"a中"[1]是228而非"中"。

递归函数

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参数是一种函数类型 f的函数类型就是一个匿名函数
	a := 2 * b
	return f(a, b)
}

type foo func(a, b int) int //foo是一种函数类型
func function_arg2(f foo, b int) int { //参数类型看上去简洁多了
    a := 2 * b
    return f(a, b)
}

type User struct {
    Name string
    bye foo //bye的类型是foo，而foo代表一种函数类型
    hello func(name string) string //使用匿名函数来声明struct字段的类型
}

ch := make(chan func(string) string, 10)//声明一个管道，管道的值是就是匿名函数
ch <- func(name string) string {  //使用匿名函数
	return "hello " + name
}

闭包

闭包（Closure）是引用了自由变量的函数，自由变量将和函数一同存在，即使已经离开了创造它的环境。闭包复制的是原对象的指针。

package main

import "fmt"

//闭包（Closure）是引用了自由变量的函数。自由变量将和函数一同存在，即使已经离开了创造它的环境。
func sub() func() {
	i := 10
	fmt.Printf("%p\n", &i)
	b := func() {
		fmt.Printf("i addr %p\n", &i) //闭包复制的是原对象的指针
		i--                           //b函数内部引用了变量i
		fmt.Println(i)
	}
	return b //返回了b函数，变量i和b函数将一起存在，即使已经离开函数sub()
}

// 外部引用函数参数局部变量
func add(base int) func(int) int {
	return func(i int) int {
		fmt.Printf("base addr %p\n", &base)
		base += i
		return base
	}
}

func main() {
	b := sub()
	b()
	b()
	fmt.Println()

	tmp1 := add(10)
	fmt.Println(tmp1(1), tmp1(2)) //11,13
	// 此时tmp1和tmp2不是一个实体了
	tmp2 := add(100)
	fmt.Println(tmp2(1), tmp2(2)) //101,103
}

延迟调用defer

• defer用于注册一个延迟调用（在函数返回之前调用）。
• defer典型的应用场景是释放资源，比如关闭文件句柄，释放数据库连接等。
• 如果同一个函数里有多个defer，则后注册的先执行。
• defer后可以跟一个func，func内部如果发生panic，会把panic暂时搁置，当把其他defer执行完之后再来执行这个。
• defer后不是跟func，而直接跟一条执行语句，则相关变量在注册defer时被拷贝或计算。

defer执行顺序

后注册先执行

func fn() {
	fmt.Println("A")
    //如果同一个函数里有多个defer，则后注册的先执行
	defer fmt.Println("E")
	fmt.Println("B")
	defer fmt.Println("D")
	fmt.Println("C")
}
func main() {
	fn()
}
/*
A
B
C
D
E
*/

defer中的变量

func defer_exe_time() (i int) {
	i = 9
	defer func() { //defer后可以跟一个func
		fmt.Printf("first i=%d\n", i) //打印5，而非9。充分理解“defer在函数返回前执行”的含义，不是在“return语句前执行defer”
	}()
	defer func(i int) {
		fmt.Printf("second i=%d\n", i) //打印9，注册时就被赋了值
	}(i)
	defer fmt.Printf("third i=%d\n", i) //defer后不是跟func，而直接跟一条执行语句，则相关变量在注册defer时被拷贝或计算
	return 5 //会将5赋值给i
}
/*
third i=9
second i=9
first i=5
*/

defer内部有异常

不会影响其他defer，会把异常放到最后处理

func fn() {
	n := 0
	defer fmt.Println("AAAAA")
	defer func() {
		fmt.Println(2 / n)
	}()
	defer fmt.Println("BBBBB")
}
func main() {
	fn()
}
/*
BBBBB
AAAAA
panic: runtime error: integer divide by zero

goroutine 1 [running]:
main.fn.func1()
        E:/Codes/GO/test.go:9 +0x86
main.fn()
        E:/Codes/GO/test.go:12 +0xe9
main.main()
        E:/Codes/GO/test.go:14 +0x17
exit status 2
*/

异常处理

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
}
if res, err := divide(3, 0); err != nil {//函数调用方判断error是否为nil
    fmt.Println(err.Error())
}

创建异常的方法：

• errors.New(错误信息的字符串)
• fmt.Errorf("hahhahh%d", 20) 可以是格式化字符串

自定义异常

Go语言定义了error这个接口，自定义的error一定要实现Error()方法。

type diyerror struct {    //自定义error
    name string
    message string
}
func (err diyerror) Error() string {    //error接口要求实现Error() string方法
	return e.name + "=========" + e.msg + time.Now().Format("2006-01-02 15:04:05")
}
//调用
func newerror() diyerror {
	return diyerror{"一个错误", "这是消息"}
}

//抛出异常
func main() {
	panic(newerror())
}

何时会发生panic:

• 运行时错误会导致panic，比如数组越界、除0。
• 程序主动调用panic(error)。

panic会执行什么：

1. 逆序执行当前goroutine的defer链（recover()从这里介入）。
2. 打印错误信息和调用堆栈。
3. 调用exit(2)结束整个进程。

recover()会使程序从panic中恢复(即不会执行panic的第2步和第3步)，并返回panic value。

recover()所在的函数后续的代码不会执行，但函数可以正常返回。

在未发生panic时调用recover()，会返回nil。

recover()必须在defer中才能生效。

处理异常

func soo() {
	fmt.Println("enter soo")

	defer func() { //去掉这个defer试试，看看panic的流程。把这个defer放到soo函数末尾试试。把这个defer移到main()里试试。
		//recover必须在defer中才能生效
		if err := recover(); err != nil {
            fmt.Printf("soo函数中发生了panic:%v\n", err.Error())
		}
	}()
	fmt.Println("regist recover")

	defer fmt.Println("hello")
	defer func() {
		n := 0
		_ = 3 / n //除0异常，发生panic，下一行的defer没有注册成功
		defer fmt.Println("how are you")
	}()
}

package main

import (
	"fmt"
)

func B() {
	// defer func() { //方式一，recover()在B()函数里，则在B()函数中panic后面的代码不会执行。不影响BBBBBBB的打印
	// 	if panicValue := recover(); panicValue != nil {
	// 		fmt.Printf("panic info %v\n", panicValue)
	// 	}
	// }()
	panic(5)
}

func main() {
	defer func() { //方式二，recover()在main()函数里，则在main()函数中panic后面的代码不会执行。BBBBBBB不会打印出来
		if panicValue := recover(); panicValue != nil {
			fmt.Printf("panic info %v\n", panicValue)
		}
	}()

	B()
	fmt.Println("BBBBBBB")
}

取出error结构体的内容

使用error.Error()