9Go语言基础之函数

本文是李文周的博客go语言学习之路的目录提要版，方便复习查看使用，原文参见文章连接：

https://www.liwenzhou.com/posts/Go/go_menu/

函数是组织好的、可重复使用的、用于执行指定任务的代码块。本文介绍了Go语言中函数的相关内容。

Go语言中支持函数、匿名函数和闭包，异常。并且函数在Go语言中属于“一等公民”。

函数总结

函数

1.函数的定义和调用

func 函数名(参数)(返回值){
    函数体
}
func intSum(x int, y int) int {
	return x + y
}
func main(){
    intSum(2,3)   
}

2.参数

相同类型简写
func intSum(x, y int) int {
	return x + y
}
可变参数
func intSum2(x ...int) int {
	fmt.Println(x) //x是一个切片
	sum := 0
	for _, v := range x {
		sum = sum + v
	}
	return sum
}

3.返回值

多返回值
func calc(x, y int) (int, int) {
	sum := x + y
	sub := x - y
	return sum, sub
}
// 有名返回值
func calc(x, y int) (sum, sub int) {
	sum = x + y
	sub = x - y
	return
}

4.函数类型与变量

定义函数类型:使用type关键字来定义一个函数类型，具体格式如下：
type calculation func(int, int) int

简单来说，凡是满足这个条件的函数都是calculation类型的函数，例如下面的add和sub是calculation类型。
func add(x, y int) int {
	return x + y
}

func sub(x, y int) int {
	return x - y
}

add和sub都能赋值给calculation类型的变量。
var c calculation
c = add

我们可以声明函数类型的变量并且为该变量赋值：
func main() {
	var c calculation               // 声明一个calculation类型的变量c
	c = add                         // 把add赋值给c
	fmt.Printf("type of c:%T\n", c) // type of c:main.calculation
	fmt.Println(c(1, 2))            // 像调用add一样调用c

	f := add                        // 将函数add赋值给变量f1
	fmt.Printf("type of f:%T\n", f) // type of f:func(int, int) int
	fmt.Println(f(10, 20))          // 像调用add一样调用f
}

4.函数作为参数

func add(x, y int) int {
	return x + y
}
func calc(x, y int, op func(int, int) int) int {
	return op(x, y)
}
func main() {
	ret2 := calc(10, 20, add)
	fmt.Println(ret2) //30
}

5.函数作为返回值

func do(s string) (func(int, int) int, error) {
	switch s {
	case "+":
		return add, nil
	case "-":
		return sub, nil
	default:
		err := errors.New("无法识别的操作符")
		return nil, err
	}
}

匿名函数和闭包

匿名函数:

匿名函数就是没有函数名的函数，匿名函数的定义格式如下：
func(参数)(返回值){
    函数体
}
匿名函数因为没有函数名，所以没办法像普通函数那样调用，所以匿名函数需要保存到某个变量或者作为立即执行函数:
func main() {
	// 将匿名函数保存到变量
	add := func(x, y int) {
		fmt.Println(x + y)
	}
	add(10, 20) // 通过变量调用匿名函数

	//自执行函数：匿名函数定义完加()直接执行
	func(x, y int) {
		fmt.Println(x + y)
	}(10, 20)
}
匿名函数多用于实现回调函数和闭包。

闭包:

闭包指的是一个函数和与其相关的引用环境组合而成的实体。简单来说，闭包=函数+引用环境。
即：内层函数使用到了外层函数定义的变量(引用环境).
首先我们来看一个例子：
func adder() func(int) int {
	var x int
	return func(y int) int {
		x += y
		return x
	}
}
func main() {
	var f = adder()
	fmt.Println(f(10)) //10
	fmt.Println(f(20)) //30
	fmt.Println(f(30)) //60

	f1 := adder()
	fmt.Println(f1(40)) //40
	fmt.Println(f1(50)) //90
}
变量f是一个函数并且它引用了其外部作用域中的x变量，此时f就是一个闭包。 在f的生命周期内，变量x也一直有效。 闭包进阶示例1

defer语句:

使用场景：资源清理、文件关闭、解锁及记录时间等。

Go语言中的`defer`语句会将其后面跟随的语句进行延迟处理。在函数return语句或panic语句执行完之前，从后往前依次执行defer语句。
func main() {
	fmt.Println("start")
	defer fmt.Println(1)
	defer fmt.Println(2)
	defer fmt.Println(3)
	fmt.Println("end")
}
// 结果： start end 3 2 1

defer执行时机

注：

return的返回值会被保存为临时变量，

当return后面接的是 无名返回值，defer语句无法修改该值

当return后面接的是 有名返回值，defer语句可以修改该值。

内置函数介绍

内置函数	介绍
close	主要用来关闭channel
len	用来求长度，如string, array, slice, map, channel
new	用来分配内存，主要用来分配值类型，如int struct. 返回的是指针
make	用来分配内存，主要用来分配引用类型，比如chan、map、slice
append	用来追加元素到数组、slice中
panic和recover	用来做错误处理

异常处理

panic和recover

Go语言中目前（Go1.12）是没有异常机制，但是使用panic/recover模式来处理错误。 panic可以在任何地方引发，但recover只有在defer调用的函数中有效。 首先来看一个例子：

func funcA() {
	fmt.Println("func A")
}

func funcB() {
	defer func() {
		err := recover()
		//如果程序出出现了panic错误,可以通过recover恢复过来
		if err != nil {
			fmt.Println("recover in B")
		}
	}()
	panic("panic in B")
}

func funcC() {
	fmt.Println("func C")
}
func main() {
	funcA()
	funcB()
	funcC()
}
程序运行期间`funcB`中引发了`panic`导致程序崩溃，异常退出了。这个时候我们就可以通过`recover`将程序恢复回来，继续往后执行。

注意：

1. recover()必须搭配defer使用。
2. defer一定要在可能引发panic的语句之前定义。