GoLong的学习之路（十）语法之函数

书接上回，上回书说到，结构体，一言之重在于体。一体之重在于经。经之重甚于骨。这张就说go的经络—函数。

函数

函数是组织好的、可重复使用的、用于执行指定任务的代码块。

Go语言中支持函数、匿名函数和闭包。

函数如何定义

Go语言中定义函数使用func关键字（其实吧，我认为这个里面的所有都是要加func，当然结构体不加）

func 函数名(参数)(返回值){
    函数体
}
1
2
3

注意

• 函数名：由字母、数字、下划线组成。
  • 函数名的第一个字母不能是数字
  • 在同一个包内，函数名也称不能重名
• 参数：参数由参数变量和参数变量的类型组成，多个参数之间使用,分隔。
• 返回值：返回值由返回值变量和其变量类型组成，也可以只写返回值的类型，多个返回值必须用()包裹，并用,分隔。(这个就有点牛了)
• 函数体：实现指定功能的代码块。

函数的参数和返回值都是可选的。

func sayHello() {
	fmt.Println("Hello")
}
1
2
3

定义了函数之后，我们可以通过函数名()的方式调用函数。 调用有返回值的函数时，可以不接收其返回值。

func main() {
	sayHello()
}
1
2
3

参数

函数的参数中如果相邻变量的类型相同，则可以省略类型

func intSum(x, y int) int {
	return x + y
}
1
2
3

可变参数

可变参数是指函数的参数数量不固定。Go语言中的可变参数通过在参数名后加…来标识。这种方式在java中是通过重写来实现。但是这里似乎就不许要这么麻烦。

注意：可变参数通常要作为函数的最后一个参数。

func intSum2(x ...int) int {
	fmt.Println(x) //x是一个切片
	sum := 0
	for _, v := range x {
		sum = sum + v
	}
	return sum
}
1
2
3
4
5
6
7
8

ret1 := intSum2()
ret2 := intSum2(10)
ret3 := intSum2(10, 20)
ret4 := intSum2(10, 20, 30)
fmt.Println(ret1, ret2, ret3, ret4) //0 10 30 60
1
2
3
4
5

注意
固定参数搭配可变参数使用时，可变参数要放在固定参数的后面

实际上：函数的可变参数是通过切片来实现的。

返回值

Go语言中通过return关键字向外输出返回值。其实这个大差不差，毕竟语言差别都差不多

多返回值

Go语言中函数支持多返回值，函数如果有多个返回值时必须用()将所有返回值包裹起来

func calc(x, y int) (int, int) {
	sum := x + y
	sub := x - y
	return sum, sub
}
1
2
3
4
5

其实这个括号的返回参数的类型，可以为任意属性，但是在return的返回值时，也必须按照这个返回顺序返回。

---

当我们的一个函数返回值类型为slice时，nil可以看做是一个有效的slice，没必要显示返回一个长度为0的切片。

func someFunc(x string) []int {
	if x == "" {
		return nil // 没必要返回[]int{}
	}
	...
}
1
2
3
4
5
6

---

函数定义时可以给返回值命名，并在函数体中直接使用这些变量，最后通过return关键字返回

func calc(x, y int) (sum, sub int) {
	sum = x + y
	sub = x - y
	return
}
1
2
3
4
5

函数类型与变量

我们可以使用type关键字来定义一个函数类型：

type calculation func(int, int) int

定义了一个calculation类型，它是一种函数类型，这种函数接收两个int类型的参数并且返回一个int类型的返回值。

凡是满足这个条件的函数都是calculation类型的函数。

type calculation func(int, int) int

func add(x, y int) int {
	return x + y
}

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

var c calculation

func main() {
	c = add
	fmt.Println(c(10, 20))
	c = sub
	fmt.Println(c(10, 20))
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

高阶函数

高阶函数分为函数作为参数和函数作为返回值这两部分两部分。

函数作为参数

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
}
1
2
3
4
5
6
7
8
9
10

函数作为返回值

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
	}
}
1
2
3
4
5
6
7
8
9
10
11

匿名函数

当函数作为返回值时，在Go语言中函数内部就不能像之前那样定义函数了，只能定义匿名函数，匿名函数就是没有函数名的函数。

func(参数)(返回值){
    函数体
}
1
2
3

匿名函数因为没有函数名，所以没办法像普通函数那样调用，所以匿名函数需要保存到某个变量或者作为立即执行函数（这种方式多用于回调函数和闭包）：

func main() {
	// 将匿名函数保存到变量
	add := func(x, y int) {
		fmt.Println(x + y)
	}
	add(10, 20) // 通过变量调用匿名函数

	//自执行函数：匿名函数定义完加()直接执行
	func(x, y int) {
		fmt.Println(x + y)
	}(10, 20)
}
1
2
3
4
5
6
7
8
9
10
11
12

闭包

闭包指的是一个函数和与其相关的引用环境组合而成的实体。
闭包 = 函数 + 引用环境

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+0
	fmt.Println(f(20)) //30 = 10 + 20
	fmt.Println(f(50)) //80 = 50 + 30

	f2 := adder()
	fmt.Println(f2(60)) //60 = 0 + 60
	fmt.Println(f2(30)) //90 = 30 + 60 
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

变量f是一个函数并且它引用了其外部作用域中的x变量，此时f就是一个闭包。 在main方法中f成为了adder函数的指针，此时，他作为一个函数，x 是 属于第二个函数的全局变量。在这种情况下，在 f 的生命周期没有结束，此时x中的有效值就会一直存在。

闭包其实并不复杂，只要牢记闭包=函数+引用环境

当然在结合上面普通的函数特点我们就可以将闭包升级。

在函数中添加参数

func adder2(x int) func(int) int {
	return func(y int) int {
		x += y
		return x
	}
}
1
2
3
4
5
6

在匿名函数中做逻辑判断

func makeSuffixFunc(suffix string) func(string) string {
	return func(name string) string {
		if !strings.HasSuffix(name, suffix) {
			return name + suffix
		}
		return name
	}
}
1
2
3
4
5
6
7
8

返回多个函数

func calc(base int) (func(int) int, func(int) int) {
	add := func(i int) int {
		base += i
		return base
	}

	sub := func(i int) int {
		base -= i
		return base
	}
	return add, sub
}

1
2
3
4
5
6
7
8
9
10
11
12
13

defer语句

Go语言中的defer语句会将其后面跟随的语句进行延迟处理。

在defer归属的函数即将返回时，将延迟处理的语句按defer定义的逆序进行执行。

先被defer的语句最后被执行，最后被defer的语句，最先被执行。

func main() {
	fmt.Println("start")
	defer fmt.Println(1)
	defer fmt.Println(2)
	defer fmt.Println(3)
	fmt.Println("end")
}
1
2
3
4
5
6
7

这就最先执行defer，最后执行的意思

底层逻辑

在Go语言的函数中return语句在底层并不是原子操作，它分为给返回值赋值和RET指令两步。
而 defer 执行的时机就在返回值赋值操作后。

看一道题：

func calc(index string, a, b int) int {
	ret := a + b
	fmt.Println(index, a, b, ret)
	return ret
}

func main() {
	x := 1
	y := 2
	defer calc("AA", x, calc("A", x, y))
	x = 10
	defer calc("BB", x, calc("B", x, y))
	y = 20
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

想一想打印什么？


发现没有，在7，8中有一个问题，就是x的值，此时的8的x的值是之前没有变成 10 之前的。

内置函数

panic/recover（错误处理）

Go语言中目前是没有异常机制，但是使用panic/recover模式来处理错误。panic可以在任何地点引发，但recover只有在defer调用的函数中有效。

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

func funcB() {
	panic("panic in B")
}

func funcC() {
	fmt.Println("func C")
}
func main() {
	funcA()
	funcB()
	funcC()
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

程序运行期间funcB中引发了panic导致程序崩溃，异常退出了。但是我们要如何像java中那样去抛出异常呢？

这个时候我们就可以通过recover将程序恢复回来，继续往后执行

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()
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

注意 :这个就有一点像Java的 try…catch

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