一、函数的概念

• 函数的基本形式

//函数定义。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")
}