高阶函数

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

函数作为参数

函数可以作为参数：

func processFuncCalc(x, y int, op func(int, int) int) int {
	//op是一个参数
	return op(x, y)
}
func processFuncDemo8() {
	//processAdd是传递的参数
	ret2 := processFuncCalc(10, 20, processAdd)
	fmt.Println(ret2)
}

函数作为返回值

函数也可以作为返回值：

func processFuncDemo9() {
	sum, err := do("+")
	if sum == nil {
		fmt.Println(err)
	} else {
		fmt.Println(sum(1, 2), err)
	}

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

匿名函数和闭包

匿名函数

函数还可以作为返回值，但是在Go语言中函数内部不能再像之前那样定义函数了，只能定义匿名函数。匿名函数就是没有函数名的函数，匿名函数的定义格式如下：

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

匿名函数因为没有函数名，所以没办法像普通函数那样调用，所以匿名函数需要保存到某个变量或者作为立即执行函数:

在匿名函数后"()"直接传入实参

func processFuncDemo10() {
	// 将匿名函数保存到变量
	add := func(x, y int) {
		fmt.Println(x + y)
	}
	add(10, 20)
	//自执行函数：匿名函数定义完加()直接执行
	//(里面是参数值)
	func(x, y int) {
		fmt.Println(x + y)
	}(10, 21)
}

匿名函数多用于实现回调函数和闭包。

看以下代码

func main() {
	processFuncDemo13()
}
func processFuncDemo12(i int) func() int {
	return func() int {
		i++
		return i
	}
}
func processFuncDemo13() {
	a1 := processFuncDemo12(5)
	fmt.Println(a1())
	fmt.Println(a1())
	a2 := processFuncDemo12(10)
	fmt.Println(a2())
	fmt.Print("a1闭包的地址为:")
	fmt.Printf("%p\n", &a1)
	fmt.Print("a2闭包的地址为:")
	fmt.Printf("%p\n", &a2)
}

输出:

6
7
11
a1闭包的地址为:0xc0000ca020
a2闭包的地址为:0xc0000ca030

详解

processFuncDemo12函数返回了一个闭包函数，通过定义a1和a2变量，创建了两个闭包的实例(引用环境不同导致)

每次调用闭包实例，i的值都会在原有的基础上加1  从打印的结果可以看到 两个闭包实例的地址完全不同，两个闭包的调用结果互不影响

闭包进阶示例

func processMakeSuffixFunc(suffix string) func(string) string {
	return func(name string) string {
		if !strings.HasSuffix(name, suffix) {
			return name + suffix
		}
		return name
	}
}
func processFuncDemo14() {
	jpgFunc := processMakeSuffixFunc(".jpg")
	txtFunc := processMakeSuffixFunc(".txt")
	fmt.Println(jpgFunc("test.jpg"))
	fmt.Println(txtFunc("test.txt"))
}

输出:

test.jpg
test.txt

闭包进阶示例

func processCalc(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
}
func processFuncCalcDemo() {
	f1, f2 := processCalc(10)
	fmt.Println(f1(1), f2(2)) //11 9
	fmt.Println(f1(3), f2(4)) //12 8
	fmt.Println(f1(5), f2(6)) //13 7
}

defer延迟执行语句

go语言中存在一种延迟执行的语句，由defer关键字标识

Go语言中的defer语句会将其后面跟随的语句进行延迟处理。在defer归属的函数即将返回时，将延迟处理的语句按defer定义的逆序进行执行，也就是说，先被defer的语句最后被执行，最后被defer的语句，最先被执行。

举个例子：

func processDeferDemo() {
	fmt.Println("start now")
	defer fmt.Println("这是第一条defer")
	defer fmt.Println("这是第二条defer")
	defer fmt.Println("这是第三条defer")
	fmt.Println("end")
}

输出:

start now
end
这是第三条defer
这是第二条defer
这是第一条defer

由于defer语句延迟调用的特性，所以defer语句能非常方便的处理资源释放问题。比如：资源清理、文件关闭、解锁及记录时间等。

来看一个连接关闭的例子

func tcpSend() {
	//建立一个tcp连接
	conn, err := net.Dial("tcp", "www.baidu.com:80")
	if err == nil {
		//执行完成后 关闭连接
		defer conn.Close()
		//获取远程网络地址
		fmt.Println("remote address:", conn.RemoteAddr())
	}
	fmt.Println("erros:", err)
}

输出:

remote address: 157.148.69.74:80
erros: <nil>

defer执行时机

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

总的来说 defer 语句中的函数会在函数返回之前执行，但它并不会对函数的返回值产生直接影响

具体如下图所示：

defer经典案例

代码：

func f1() int {
	x := 5
	//加到延迟执行中 由于在加入时值就确定了 x = 5
	defer func() {
		x++
	}()
	//延迟执行会在return返回前执行
	return x
}

func f2() (x int) {
	defer func() {
		x++
	}()
	//在函数的最后，return 5 语句将 5 赋值给命名返回值 x。然而，在实际返回之前，defer 语句中的匿名函数会被执行，此时 x 的值会自增
	return 5
}

func f3() (y int) {
	x := 5
	defer func() {
		x++
	}()
	return x
}
func f4() (x int) {
	defer func(x int) {
		x++
	}(x)
	return 5
}
func processFuncDemo15() {
	fmt.Println(f1())
	fmt.Println(f2())
	fmt.Println(f3())
	fmt.Println(f4())
}

返回值：

5
6
5
5

defer语句中的fmt.Println()参数i值在defer出现时就已经确定下来，实际上是拷贝了一份。后面对变量i的修改不会影响fmt.Println()函数的执行

比如代码中的f1函数就是拷贝了

注意：对于指针类型参数，规则仍然适用，只不过延迟函数的参数是一个地址值，这种情况下，defer后面的语句对变量的修改可能会影响延迟函数。

比如f2函数就是一个典型的影响了变量 因为它的参数是一个地址

再来一个示例：

func deferFuncReturn() (result int) {
	i := 1
	defer func() {
		result++
	}()
	return i
}

输出:

2

defer面试题

代码:

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

func processFuncDemo16() {
	a := 1
	b := 2
	defer processCalcDemo("1", a, processCalcDemo("10", a, b))
	a = 0
	defer processCalcDemo("2", a, processCalcDemo("20", a, b))
	b = 1
}

输出:

10 1 2 3
20 0 2 2
2 0 2 2
1 1 3 4

 代码解释

1. 在 processFuncDemo16 函数中，定义了变量 a 和 b 分别赋值为 1 和 2。
2. 在第一个延迟函数调用 defer processCalcDemo("1", a, processCalcDemo("10", a, b)) 中：
   • 首先，执行内部的函数调用 processCalcDemo("10", a, b)，将参数值传递给该函数。这里会输出 "10 1 2 3"，并返回结果 3。
   • 然后，执行外部的函数调用 processCalcDemo("1", a, 3)，其中参数 a 的值为 1，参数 b 的值为前一个函数调用的结果 3。这里会输出 "1 1 3 4"，并返回结果 4。
   • 最终，将函数调用 processCalcDemo("1", a, 4) 添加到延迟执行队列中。
3. 接着，修改变量 a 的值为 0。
4. 在第二个延迟函数调用 defer processCalcDemo("2", a, processCalcDemo("20", a, b)) 中：
   • 首先，执行内部的函数调用 processCalcDemo("20", a, b)，将参数值传递给该函数。这里会输出 "20 0 2 2"，并返回结果 2。
   • 然后，执行外部的函数调用 processCalcDemo("2", 0, 2)，其中参数 a 的值为 0，参数 b 的值为前一个函数调用的结果 2。这里会输出 "2 0 2 2"，并返回结果 2。
   • 最终，将函数调用 processCalcDemo("2", 0, 2) 添加到延迟执行队列中。
5. 最后，修改变量 b 的值为 1。
6. 函数执行完毕，开始依次执行延迟执行队列中的函数调用：
   • 先执行 processCalcDemo("2", 0, 2)，输出 "2 0 2 2"。
   • 然后执行 processCalcDemo("1", 1, 4)，输出 "1 1 3 4"。

需要注意的是，延迟执行的函数调用是在函数结束时按照添加顺序执行的。在添加到延迟执行队列时，会立即计算并传递参数值，但函数的实际执行会在函数结束时才发生。因此，在 defer 语句中的函数调用参数会在添加到延迟执行队列时进行计算，而不是在实际执行延迟函数时计算。这就是导致输出顺序不同于函数调用顺序的原因。